diff --git a/keyboards/crkbd/keymaps/sajenim/combos.def b/keyboards/crkbd/keymaps/sajenim/combos.def
index 50e3506..6d31f98 100644
--- a/keyboards/crkbd/keymaps/sajenim/combos.def
+++ b/keyboards/crkbd/keymaps/sajenim/combos.def
@@ -1,23 +1,12 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
+// name result chord keys
+COMB(DF_TAB, KC_TAB, KC_D, KC_F)
+COMB(JK_ESC, KC_ESC, KC_J, KC_K)
+SUBS(RT_HOME, "~/", KC_R, KC_T)
+SUBS(YU_UPDIR, "../", KC_Y, KC_U)
-//#include "dictionaries/emerge.def"
-
-// name result chord keys
-COMB(NE_ESCAPE, KC_ESC, HOME_N, HOME_E)
-COMB(SE_CAPSWRD, CW_TOGG, HOME_S, HOME_E)
+// name result chord keys
+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)
/* vim: set filetype=c : */
diff --git a/keyboards/crkbd/keymaps/sajenim/config.h b/keyboards/crkbd/keymaps/sajenim/config.h
index edac0c0..86c8b02 100644
--- a/keyboards/crkbd/keymaps/sajenim/config.h
+++ b/keyboards/crkbd/keymaps/sajenim/config.h
@@ -1,19 +1,3 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
#pragma once
// By default, the firmware does not know which side is which; it needs some help to determine that.
@@ -26,36 +10,40 @@
#define OLED_FONT_H "keyboards/crkbd/lib/glcdfont.c"
// Tap-Hold Configuration Options
-// Configure the global tapping term (default: 200ms)
#define TAPPING_TERM 200
-// Activate the modifier when another key is pressed and released while the mod-tap is held.
-#define PERMISSIVE_HOLD
-// Makes tap and hold keys (like Layer Tap) work better for fast typists
-#define HOLD_ON_OTHER_KEY_PRESS
-// Prevent normal rollover on alphas from accidentally triggering mods.
-#define IGNORE_MOD_TAP_INTERRUPT
-// Enable rapid switch from tap to hold, disables double tap hold auto-repeat.
-#define TAPPING_FORCE_HOLD
// One Shot Keys
-#define ONESHOT_TAP_TOGGLE 2
+#define ONESHOT_TAP_TOGGLE 3
#define ONESHOT_TIMEOUT 2000
// Auto Shift
#define AUTO_SHIFT_TIMEOUT 175
-#define AUTO_SHIFT_REPEAT
-#define AUTO_SHIFT_MODIFIERS
-// Retro Shift
-#define RETRO_SHIFT 500
// Caps Word
#define CAPS_WORD_IDLE_TIMEOUT 2000
-// Leader Key
-#define LEADER_TIMEOUT 500
-#define LEADER_NO_TIMEOUT
-#define LEADER_PER_KEY_TIMING
+// Layer Lock
+#define LAYER_LOCK_IDLE_TIMEOUT 60000
// Combos
#define COMBO_TERM 50
+#define COMBO_ONLY_FROM_LAYER 0
+// RGB
+#ifdef RGBLIGHT_ENABLE
+ #define RGBLIGHT_SLEEP
+ #define RGBLIGHT_EFFECT_BREATHING
+ #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+ #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+ #define RGBLIGHT_EFFECT_SNAKE
+ #define RGBLIGHT_EFFECT_KNIGHT
+ #define RGBLIGHT_EFFECT_CHRISTMAS
+ #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+ #define RGBLIGHT_EFFECT_RGB_TEST
+ #define RGBLIGHT_EFFECT_ALTERNATING
+ #define RGBLIGHT_EFFECT_TWINKLE
+ #define RGBLIGHT_LIMIT_VAL 120
+ #define RGBLIGHT_HUE_STEP 10
+ #define RGBLIGHT_SAT_STEP 17
+ #define RGBLIGHT_VAL_STEP 17
+#endif
diff --git a/keyboards/crkbd/keymaps/sajenim/features/layer_lock.c b/keyboards/crkbd/keymaps/sajenim/features/layer_lock.c
new file mode 100644
index 0000000..a14ce3b
--- /dev/null
+++ b/keyboards/crkbd/keymaps/sajenim/features/layer_lock.c
@@ -0,0 +1,145 @@
+// 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
new file mode 100644
index 0000000..a0f1455
--- /dev/null
+++ b/keyboards/crkbd/keymaps/sajenim/features/layer_lock.h
@@ -0,0 +1,136 @@
+// 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/features/sentence_case.c b/keyboards/crkbd/keymaps/sajenim/features/sentence_case.c
new file mode 100644
index 0000000..f1a9e98
--- /dev/null
+++ b/keyboards/crkbd/keymaps/sajenim/features/sentence_case.c
@@ -0,0 +1,338 @@
+// 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 sentence_case.c
+ * @brief Sentence Case implementation
+ *
+ * For full documentation, see
+ *
+ */
+
+#include "sentence_case.h"
+
+#include
+
+#ifdef NO_ACTION_ONESHOT
+// One-shot keys must be enabled for Sentence Case. One-shot keys are enabled
+// by default, but are disabled by `#define NO_ACTION_ONESHOT` in config.h. If
+// your config.h includes such a line, please remove it.
+#error "Sentence case: Please enable oneshot."
+#else
+
+// Number of keys of state history to retain for backspacing.
+#define STATE_HISTORY_SIZE 6
+
+// clang-format off
+/** States in matching the beginning of a sentence. */
+enum {
+ STATE_INIT, /**< Initial enabled state. */
+ STATE_WORD, /**< Within a word. */
+ STATE_ABBREV, /**< Within an abbreviation like "e.g.". */
+ STATE_ENDING, /**< Sentence ended. */
+ STATE_PRIMED, /**< "Primed" state, in the space following an ending. */
+ STATE_DISABLED, /**< Sentence Case is disabled. */
+};
+// clang-format on
+
+#if SENTENCE_CASE_TIMEOUT > 0
+static uint16_t idle_timer = 0;
+#endif // SENTENCE_CASE_TIMEOUT > 0
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+static uint16_t key_buffer[SENTENCE_CASE_BUFFER_SIZE] = {0};
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+static uint8_t state_history[STATE_HISTORY_SIZE];
+static uint16_t suppress_key = KC_NO;
+static uint8_t sentence_state = STATE_INIT;
+
+// Sets the current state to `new_state`.
+static void set_sentence_state(uint8_t new_state) {
+#ifndef NO_DEBUG
+ if (debug_enable && sentence_state != new_state) {
+ static const char* state_names[] = {
+ "INIT", "WORD", "ABBREV", "ENDING", "PRIMED", "DISABLED",
+ };
+ dprintf("Sentence case: %s\n", state_names[new_state]);
+ }
+#endif // NO_DEBUG
+
+ const bool primed = (new_state == STATE_PRIMED);
+ if (primed != (sentence_state == STATE_PRIMED)) {
+ sentence_case_primed(primed);
+ }
+ sentence_state = new_state;
+}
+
+void sentence_case_clear(void) {
+#if SENTENCE_CASE_TIMEOUT > 0
+ idle_timer = 0;
+#endif // SENTENCE_CASE_TIMEOUT > 0
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+ memset(key_buffer, 0, sizeof(key_buffer));
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+ memset(state_history, 0, sizeof(state_history));
+ suppress_key = KC_NO;
+ if (sentence_state != STATE_DISABLED) {
+ set_sentence_state(STATE_INIT);
+ }
+}
+
+void sentence_case_on(void) {
+ if (sentence_state == STATE_DISABLED) {
+ sentence_state = STATE_INIT;
+ sentence_case_clear();
+ }
+}
+
+void sentence_case_off(void) {
+ if (sentence_state != STATE_DISABLED) {
+ set_sentence_state(STATE_DISABLED);
+ }
+}
+
+void sentence_case_toggle(void) {
+ if (sentence_state != STATE_DISABLED) {
+ sentence_case_off();
+ } else {
+ sentence_case_on();
+ }
+}
+
+bool is_sentence_case_on(void) { return sentence_state != STATE_DISABLED; }
+
+#if SENTENCE_CASE_TIMEOUT > 0
+#if SENTENCE_CASE_TIMEOUT < 100 || SENTENCE_CASE_TIMEOUT > 30000
+// Constrain timeout to a sensible range. With the 16-bit timer, the longest
+// representable timeout is 32768 ms, rounded here to 30000 ms = half a minute.
+#error "sentence_case: SENTENCE_CASE_TIMEOUT must be between 100 and 30000 ms"
+#endif
+
+void sentence_case_task(void) {
+ if (idle_timer && timer_expired(timer_read(), idle_timer)) {
+ sentence_case_clear(); // Timed out; clear all state.
+ }
+}
+#endif // SENTENCE_CASE_TIMEOUT > 0
+
+bool process_sentence_case(uint16_t keycode, keyrecord_t* record) {
+ // Only process while enabled, and only process press events.
+ if (sentence_state == STATE_DISABLED || !record->event.pressed) {
+ return true;
+ }
+
+#if SENTENCE_CASE_TIMEOUT > 0
+ idle_timer = (record->event.time + SENTENCE_CASE_TIMEOUT) | 1;
+#endif // SENTENCE_CASE_TIMEOUT > 0
+
+ switch (keycode) {
+#ifndef NO_ACTION_TAPPING
+ case QK_MOD_TAP ... QK_MOD_TAP_MAX:
+ if (record->tap.count == 0) {
+ return true;
+ }
+ keycode = QK_MOD_TAP_GET_TAP_KEYCODE(keycode);
+ break;
+#ifndef NO_ACTION_LAYER
+ case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
+#endif // NO_ACTION_LAYER
+ if (record->tap.count == 0) {
+ return true;
+ }
+ keycode = QK_LAYER_TAP_GET_TAP_KEYCODE(keycode);
+ break;
+#endif // NO_ACTION_TAPPING
+
+#ifdef SWAP_HANDS_ENABLE
+ case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
+ if (IS_SWAP_HANDS_KEYCODE(keycode) || record->tap.count == 0) {
+ return true;
+ }
+ keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode);
+ break;
+#endif // SWAP_HANDS_ENABLE
+ }
+
+ if (keycode == KC_BSPC) {
+ // Backspace key pressed. Rewind the state and key buffers.
+ set_sentence_state(state_history[STATE_HISTORY_SIZE - 1]);
+
+ memmove(state_history + 1, state_history, STATE_HISTORY_SIZE - 1);
+ state_history[0] = STATE_INIT;
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+ memmove(key_buffer + 1, key_buffer,
+ (SENTENCE_CASE_BUFFER_SIZE - 1) * sizeof(uint16_t));
+ key_buffer[0] = KC_NO;
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+ return true;
+ }
+
+ const uint8_t mods = get_mods() | get_weak_mods() | get_oneshot_mods();
+ uint8_t new_state = STATE_INIT;
+
+ // We search for sentence beginnings using a simple finite state machine. It
+ // matches things like "a. a" and "a. a" but not "a.. a" or "a.a. a". The
+ // state transition matrix is:
+ //
+ // 'a' '.' ' ' '\''
+ // +-------------------------------------
+ // INIT | WORD INIT INIT INIT
+ // WORD | WORD ENDING INIT WORD
+ // ABBREV | ABBREV ABBREV INIT ABBREV
+ // ENDING | ABBREV INIT PRIMED ENDING
+ // PRIMED | match! INIT PRIMED PRIMED
+ char code = sentence_case_press_user(keycode, record, mods);
+ dprintf("Sentence Case: code = '%c' (%d)\n", code, (int)code);
+ switch (code) {
+ case '\0': // Current key should be ignored.
+ return true;
+
+ case 'a': // Current key is a letter.
+ switch (sentence_state) {
+ case STATE_ABBREV:
+ case STATE_ENDING:
+ new_state = STATE_ABBREV;
+ break;
+
+ case STATE_PRIMED:
+ // This is the start of a sentence.
+ if (keycode != suppress_key) {
+ suppress_key = keycode;
+ set_oneshot_mods(MOD_BIT(KC_LSFT)); // Shift mod to capitalize.
+ new_state = STATE_WORD;
+ }
+ break;
+
+ default:
+ new_state = STATE_WORD;
+ }
+ break;
+
+ case '.': // Current key is sentence-ending punctuation.
+ switch (sentence_state) {
+ case STATE_WORD:
+ new_state = STATE_ENDING;
+ break;
+
+ default:
+ new_state = STATE_ABBREV;
+ }
+ break;
+
+ case ' ': // Current key is a space.
+ if (sentence_state == STATE_PRIMED ||
+ (sentence_state == STATE_ENDING
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+ && sentence_case_check_ending(key_buffer)
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+ )) {
+ new_state = STATE_PRIMED;
+ suppress_key = KC_NO;
+ }
+ break;
+
+ case '\'': // Current key is a quote.
+ new_state = sentence_state;
+ break;
+ }
+
+ // Slide key_buffer and state_history buffers one element to the left.
+ // Optimization note: Using manual loops instead of memmove() here saved
+ // ~100 bytes on AVR.
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+ for (int8_t i = 0; i < SENTENCE_CASE_BUFFER_SIZE - 1; ++i) {
+ key_buffer[i] = key_buffer[i + 1];
+ }
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+ for (int8_t i = 0; i < STATE_HISTORY_SIZE - 1; ++i) {
+ state_history[i] = state_history[i + 1];
+ }
+
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+ key_buffer[SENTENCE_CASE_BUFFER_SIZE - 1] = keycode;
+ if (new_state == STATE_ENDING && !sentence_case_check_ending(key_buffer)) {
+ dprintf("Not a real ending.\n");
+ new_state = STATE_INIT;
+ }
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+ state_history[STATE_HISTORY_SIZE - 1] = sentence_state;
+
+ set_sentence_state(new_state);
+ return true;
+}
+
+bool sentence_case_just_typed_P(const uint16_t* buffer, const uint16_t* pattern,
+ int8_t pattern_len) {
+#if SENTENCE_CASE_BUFFER_SIZE > 1
+ buffer += SENTENCE_CASE_BUFFER_SIZE - pattern_len;
+ for (int8_t i = 0; i < pattern_len; ++i) {
+ if (buffer[i] != pgm_read_word(pattern + i)) {
+ return false;
+ }
+ }
+ return true;
+#else
+ return false;
+#endif // SENTENCE_CASE_BUFFER_SIZE > 1
+}
+
+__attribute__((weak)) bool sentence_case_check_ending(const uint16_t* buffer) {
+#if SENTENCE_CASE_BUFFER_SIZE >= 5
+ // Don't consider the abbreviations "vs." and "etc." to end the sentence.
+ if (SENTENCE_CASE_JUST_TYPED(KC_SPC, KC_V, KC_S, KC_DOT) ||
+ SENTENCE_CASE_JUST_TYPED(KC_SPC, KC_E, KC_T, KC_C, KC_DOT)) {
+ return false; // Not a real sentence ending.
+ }
+#endif // SENTENCE_CASE_BUFFER_SIZE >= 5
+ return true; // Real sentence ending; capitalize next letter.
+}
+
+__attribute__((weak)) char sentence_case_press_user(uint16_t keycode,
+ keyrecord_t* record,
+ uint8_t mods) {
+ if ((mods & ~(MOD_MASK_SHIFT | MOD_BIT(KC_RALT))) == 0) {
+ const bool shifted = mods & MOD_MASK_SHIFT;
+ switch (keycode) {
+ case KC_LCTL ... KC_RGUI: // Mod keys.
+ return '\0'; // These keys are ignored.
+
+ case KC_A ... KC_Z:
+ return 'a'; // Letter key.
+
+ case KC_DOT: // . is punctuation, Shift . is a symbol (>)
+ return !shifted ? '.' : '#';
+ case KC_1:
+ case KC_SLSH:
+ return shifted ? '.' : '#';
+ case KC_2 ... KC_0: // 2 3 4 5 6 7 8 9 0
+ case KC_MINS ... KC_SCLN: // - = [ ] ; backslash
+ case KC_GRV:
+ case KC_COMM:
+ return '#'; // Symbol key.
+
+ case KC_SPC:
+ return ' '; // Space key.
+
+ case KC_QUOT:
+ return '\''; // Quote key.
+ }
+ }
+
+ // Otherwise clear Sentence Case to initial state.
+ sentence_case_clear();
+ return '\0';
+}
+
+__attribute__((weak)) void sentence_case_primed(bool primed) {}
+
+#endif // NO_ACTION_ONESHOT
diff --git a/keyboards/crkbd/keymaps/sajenim/features/sentence_case.h b/keyboards/crkbd/keymaps/sajenim/features/sentence_case.h
new file mode 100644
index 0000000..5b1ebbc
--- /dev/null
+++ b/keyboards/crkbd/keymaps/sajenim/features/sentence_case.h
@@ -0,0 +1,224 @@
+// Copyright 2022 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 sentence_case.h
+ * @brief Sentence case: automatically capitalize the first letter of sentences.
+ *
+ * This library automatically capitalizes the first letter of sentences,
+ * reducing the need to explicitly use shift. To use it, you simply type as
+ * usual but without shifting at the start of sentences. The feature detects
+ * when new sentences begin and capitalizes automatically.
+ *
+ * Sentence Case matches patterns like
+ *
+ * "a. a"
+ * "a. a"
+ * "a? a"
+ * "a!' 'a"
+ *
+ * but not
+ *
+ * "a... a"
+ * "a.a. a"
+ *
+ * Additionally by default, abbreviations "vs." and "etc." are exceptionally
+ * detected as not real sentence endings. You can use the callback
+ * `sentence_case_check_ending()` to define other exceptions.
+ *
+ * @note One-shot keys must be enabled.
+ *
+ * For full documentation, see
+ *
+ */
+
+#pragma once
+
+#include "quantum.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The size of the keycode buffer for `sentence_case_check_ending()`. It must be
+// at least as large as the longest pattern checked. If less than 2, buffering
+// is disabled and the callback is not called.
+#ifndef SENTENCE_CASE_BUFFER_SIZE
+#define SENTENCE_CASE_BUFFER_SIZE 8
+#endif // SENTENCE_CASE_BUFFER_SIZE
+
+/**
+ * Handler function for Sentence Case.
+ *
+ * Call this function from `process_record_user()` to implement Sentence Case.
+ */
+bool process_sentence_case(uint16_t keycode, keyrecord_t* record);
+
+/**
+ * @fn sentence_case_task(void)
+ * Matrix task function for Sentence Case.
+ *
+ * If using `SENTENCE_CASE_TIMEOUT`, call this function from your
+ * `matrix_scan_user()` function in keymap.c. (If no timeout is set, calling
+ * `sentence_case_task()` has no effect.)
+ */
+#if SENTENCE_CASE_TIMEOUT > 0
+void sentence_case_task(void);
+#else
+static inline void sentence_case_task(void) {}
+#endif
+
+void sentence_case_on(void); /**< Enables Sentence Case. */
+void sentence_case_off(void); /**< Disables Sentence Case. */
+void sentence_case_toggle(void); /**< Toggles Sentence Case. */
+bool is_sentence_case_on(void); /**< Gets whether currently enabled. */
+void sentence_case_clear(void); /**< Clears Sentence Case to initial state. */
+
+/**
+ * Optional callback to indicate primed state.
+ *
+ * This callback gets called when Sentence Case changes to or from a "primed"
+ * state, useful to indicate with an LED or otherwise that the next letter typed
+ * will be capitalized.
+ */
+void sentence_case_primed(bool primed);
+
+/**
+ * Optional callback to determine whether there is a real sentence ending.
+ *
+ * When a sentence-ending punctuation key is typed, this callback is called to
+ * determine whether it is a real sentence ending, meaning the first letter of
+ * the following word should be capitalized. For instance, abbreviations like
+ * "vs." are usually not real sentence endings. The input argument is a buffer
+ * of the last SENTENCE_CASE_BUFFER_SIZE keycodes. Returning true means it is a
+ * real sentence ending; returning false means it is not.
+ *
+ * The default implementation checks for the abbreviations "vs." and "etc.":
+ *
+ * bool sentence_case_check_ending(const uint16_t* buffer) {
+ * // Don't consider "vs." and "etc." to end the sentence.
+ * if (SENTENCE_CASE_JUST_TYPED(KC_SPC, KC_V, KC_S, KC_DOT) ||
+ * SENTENCE_CASE_JUST_TYPED(KC_SPC, KC_E, KC_T, KC_C, KC_DOT)) {
+ * return false; // Not a real sentence ending.
+ * }
+ * return true; // Real sentence ending; capitalize next letter.
+ * }
+ *
+ * @note This callback is used only if `SENTENCE_CASE_BUFFER_SIZE >= 2`.
+ * Otherwise it has no effect.
+ *
+ * @param buffer Buffer of the last `SENTENCE_CASE_BUFFER_SIZE` keycodes.
+ * @return whether there is a real sentence ending.
+ */
+bool sentence_case_check_ending(const uint16_t* buffer);
+
+/**
+ * Macro to be used in `sentence_case_check_ending()`.
+ *
+ * Returns true if a given pattern of keys was just typed by comparing with the
+ * keycode buffer. This is useful for defining exceptions in
+ * `sentence_case_check_ending()`.
+ *
+ * For example, `SENTENCE_CASE_JUST_TYPED(KC_SPC, KC_V, KC_S, KC_DOT)` returns
+ * true if " vs." were the last four keys typed.
+ *
+ * @note The pattern must be no longer than `SENTENCE_CASE_BUFFER_SIZE`.
+ */
+#define SENTENCE_CASE_JUST_TYPED(...) \
+ ({ \
+ static const uint16_t PROGMEM pattern[] = {__VA_ARGS__}; \
+ sentence_case_just_typed_P(buffer, pattern, \
+ sizeof(pattern) / sizeof(uint16_t)); \
+ })
+bool sentence_case_just_typed_P(const uint16_t* buffer, const uint16_t* pattern,
+ int8_t pattern_len);
+
+/**
+ * Optional callback defining which keys are letter, punctuation, etc.
+ *
+ * This callback may be useful if you type non-US letters or have customized the
+ * shift behavior of the punctuation keys. The return value tells Sentence Case
+ * how to interpret the key:
+ *
+ * 'a' Key is a letter, by default KC_A to KC_Z. If occurring at the start of
+ * a sentence, Sentence Case applies shift to capitalize it.
+ *
+ * '.' Key is sentence-ending punctuation. Default: . ? !
+ *
+ * '#' Key types a backspaceable character that isn't part of a word.
+ * Default: - = [ ] ; ' ` , < > / digits backslash
+ *
+ * ' ' Key is a space. Default: KC_SPC
+ *
+ * '\'' Key is a quote or double quote character. Default: KC_QUOT.
+ *
+ * '\0' Sentence Case should ignore this key.
+ *
+ * If a hotkey or navigation key is pressed (or another key that performs an
+ * action that backspace doesn't undo), then the callback should call
+ * `sentence_case_clear()` to clear the state and then return '\0'.
+ *
+ * The default callback is:
+ *
+ * char sentence_case_press_user(uint16_t keycode,
+ * keyrecord_t* record,
+ * uint8_t mods) {
+ * if ((mods & ~(MOD_MASK_SHIFT | MOD_BIT(KC_RALT))) == 0) {
+ * const bool shifted = mods & MOD_MASK_SHIFT;
+ * switch (keycode) {
+ * case KC_LCTL ... KC_RGUI: // Mod keys.
+ * return '\0'; // These keys are ignored.
+ *
+ * case KC_A ... KC_Z:
+ * return 'a'; // Letter key.
+ *
+ * case KC_DOT: // . is punctuation, Shift . is a symbol (>)
+ * return !shifted ? '.' : '#';
+ * case KC_1:
+ * case KC_SLSH:
+ * return shifted ? '.' : '#';
+ * case KC_2 ... KC_0: // 2 3 4 5 6 7 8 9 0
+ * case KC_MINS ... KC_SCLN: // - = [ ] ; backslash
+ * case KC_GRV:
+ * case KC_COMM:
+ * return '#'; // Symbol key.
+ *
+ * case KC_SPC:
+ * return ' '; // Space key.
+ *
+ * case KC_QUOT:
+ * return '\''; // Quote key.
+ * }
+ * }
+ *
+ * // Otherwise clear Sentence Case to initial state.
+ * sentence_case_clear();
+ * return '\0';
+ * }
+ *
+ * To customize, copy the above function into your keymap and add/remove
+ * keycodes to the above cases.
+ *
+ * @param keycode Current keycode.
+ * @param record record_t for the current press event.
+ * @param mods equal to `get_mods() | get_weak_mods() | get_oneshot_mods()`
+ * @return char code 'a', '.', '#', ' ', or '\0' indicating how the key is to be
+ * interpreted as described above.
+ */
+char sentence_case_press_user(uint16_t keycode, keyrecord_t* record,
+ uint8_t mods);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/keyboards/crkbd/keymaps/sajenim/keymap.c b/keyboards/crkbd/keymaps/sajenim/keymap.c
index 1fdb5f8..c5935b9 100644
--- a/keyboards/crkbd/keymaps/sajenim/keymap.c
+++ b/keyboards/crkbd/keymaps/sajenim/keymap.c
@@ -24,32 +24,55 @@
/* 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(
//,-----------------------------------------------------. ,-----------------------------------------------------.
- KC_GRV, KC_W, KC_L, KC_Y, KC_P, KC_B, KC_Z, KC_F, KC_O, KC_U, KC_QUOT, XXXXXXX,
+ QK_GESC, KC_W, KC_L, KC_Y, KC_P, KC_B, KC_Z, KC_F, KC_O, KC_U, KC_QUOT, BSPC_DW,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- BAKWORD, HOME_C, HOME_R, HOME_S, HOME_T, KC_G, KC_M, HOME_N, HOME_E, HOME_I, HOME_A, DELWORD,
+ TABCTRL, KC_C, KC_R, KC_S, KC_T, KC_G, KC_M, KC_N, KC_E, KC_I, KC_A, KC_SCLN,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, KC_Q, KC_J, KC_V, KC_D, KC_K, KC_X, KC_H, KC_SLSH, KC_COMM, KC_DOT, XXXXXXX,
+ OS_LSFT, KC_Q, KC_J, KC_V, KC_D, KC_K, KC_X, KC_H, KC_SLSH, KC_COMM, KC_DOT, OS_RSFT,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- LOWER, FN_PFX, FN_SPC, FN_ENT, FN_LDR, RAISE
+ GUI_EXT, BAK_LWR, SPC_EXT, ENT_SFT, DEL_RSE, ALT_EXT
//`--------------------------' `--------------------------'
-
),
- [L_NAVIGATION] = LAYOUT_split_3x6_3(
+ [L_EXTEND] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
- _______, XXXXXXX, XXXXXXX, KC_PGUP, KC_PGDN, XXXXXXX, XXXXXXX, KC_HOME, KC_END, XXXXXXX, XXXXXXX, _______,
+ XXXXXXX, XXXXXXX, XXXXXXX, KC_UP, XXXXXXX, XXXXXXX, KC_PGUP, KC_HOME, KC_UP, KC_END, KC_DEL, BSPC_DW,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- _______, OS_LGUI, OS_LALT, OS_LSFT, OS_LCTL, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______,
+ XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_RGHT, XXXXXXX, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, KC_BSPC, KC_COLN,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,
+ KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_0, KC_1, KC_2, KC_3, KC_4, KC_5,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, _______, KC_TAB, _______, _______
+ XXXXXXX, XXXXXXX, XXXXXXX, WZ_CMOD, WZ_COPY, WZ_PSTE
//`--------------------------' `--------------------------'
),
- [L_SYMBOLS] = LAYOUT_split_3x6_3(
+ [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, KC_PWR,
+ //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
+ KC_VOLD, KC_MPRV, KC_F4, KC_F5, KC_F6, KC_F11, KC_ASTR, KC_4, KC_5, KC_6, KC_PLUS, KC_SLEP,
+ //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
+ KC_MUTE, KC_MPLY, KC_F1, KC_F2, KC_F3, KC_F12, KC_0, KC_1, KC_2, KC_3, KC_DOT, KC_WAKE,
+ //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
+ XXXXXXX, _______, XXXXXXX, CK_LOCK, _______, XXXXXXX
+ //`--------------------------' `--------------------------'
+ ),
+
+ [L_RAISE] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, KC_LABK, KC_DLR, KC_RABK, XXXXXXX, XXXXXXX, KC_LBRC, KC_UNDS, KC_RBRC, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
@@ -57,127 +80,24 @@ 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,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, _______, _______, _______, _______
- //`--------------------------' `--------------------------'
- ),
-
- [L_NUMBERS] = LAYOUT_split_3x6_3(
- //,-----------------------------------------------------. ,-----------------------------------------------------.
- _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, _______,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- _______, OS_LGUI, OS_LALT, OS_LSFT, OS_LCTL, XXXXXXX, KC_ASTR, KC_4, KC_5, KC_6, KC_PLUS, _______,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_DOT, KC_1, KC_2, KC_3, KC_EQL, _______,
- //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, _______, _______, KC_0, _______
- //`--------------------------' `--------------------------'
- ),
-
- [L_MACRO] = LAYOUT_split_3x6_3(
- //,-----------------------------------------------------. ,-----------------------------------------------------.
- HOME, XXXXXXX, XXXXXXX, YANK, PSTE, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, UPDIR,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, XXXXXXX, XXXXXXX, VI_SAVE, VI_EXIT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
- //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, ST_PSTE, _______, _______, _______
- //`--------------------------' `--------------------------'
- ),
-
- [L_LOWER] = LAYOUT_split_3x6_3(
- //,-----------------------------------------------------. ,-----------------------------------------------------.
- XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
- //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, _______, _______, _______, _______
- //`--------------------------' `--------------------------'
- ),
-
- [L_RAISE] = LAYOUT_split_3x6_3(
- //,-----------------------------------------------------. ,-----------------------------------------------------.
- KC_MUTE, KC_F1, KC_F2, KC_F3, KC_F4, XXXXXXX, KC_MSEL, KC_MPLY, KC_MSTP, KC_MPRV, KC_MNXT, KC_SLEP,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- KC_VOLU, KC_F5, KC_F6, KC_F7, KC_F8, XXXXXXX, KC_WHOM, KC_WREF, KC_WSTP, KC_WBAK, KC_WFWD, KC_BRIU,
- //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- KC_VOLD, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_BRID,
- //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, _______, _______, _______, _______
+ XXXXXXX, _______, CK_LOCK, XXXXXXX, _______, XXXXXXX
//`--------------------------' `--------------------------'
),
[L_ADJUST] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
- QK_BOOT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AS_TOGG,
+ QK_BOOT, xQWERTY, xCANARY, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AS_TOGG,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AC_TOGG,
+ RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AC_TOGG,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
- XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, CM_TOGG,
+ RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, CM_TOGG,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
- _______, _______, _______, _______, _______, _______
+ XXXXXXX, _______, XXXXXXX, XXXXXXX, _______, XXXXXXX
//`--------------------------' `--------------------------'
),
};
-/* Add Home Row Mods to Auto Shift */
-
-bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
- switch(keycode) {
- // Left hand home-row mods
- case HOME_C:
- return true;
- case HOME_R:
- return true;
- case HOME_S:
- return true;
- case HOME_T:
- return true;
-
- // Right hand home-row mods
- case HOME_N:
- return true;
- case HOME_E:
- return true;
- case HOME_I:
- return true;
- case HOME_A:
- return true;
-
- default:
- return false;
- }
-}
-
-
-/* Configure which words are word breaking */
-bool caps_word_press_user(uint16_t keycode) {
- switch (keycode) {
- // Keycodes that continue Caps Word, with shift applied.
- case KC_A ... KC_Z:
- case KC_MINS:
- add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to next key.
- return true;
-
- // Keycodes that continue Caps Word, without shifting.
- case KC_1 ... KC_0:
- case KC_BSPC:
- case KC_DEL:
- case KC_UNDS:
- // Our custom keys
- case BAKWORD:
- case DELWORD:
- return true;
-
- default:
- return false; // Deactivate Caps Word.
- }
-}
-
-
/* Layer Change */
layer_state_t layer_state_set_user(layer_state_t state) {
diff --git a/keyboards/crkbd/keymaps/sajenim/layers.h b/keyboards/crkbd/keymaps/sajenim/layers.h
index 85bb610..666480f 100644
--- a/keyboards/crkbd/keymaps/sajenim/layers.h
+++ b/keyboards/crkbd/keymaps/sajenim/layers.h
@@ -1,31 +1,10 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-#pragma once
-
// Our layers
enum layers {
+ L_QWERTY,
L_CANARY,
+ L_EXTEND,
L_LOWER,
L_RAISE,
L_ADJUST,
- L_NAVIGATION,
- L_SYMBOLS,
- L_NUMBERS,
- L_OPERATORS,
- L_MACRO,
};
diff --git a/keyboards/crkbd/keymaps/sajenim/leader.c b/keyboards/crkbd/keymaps/sajenim/leader.c
deleted file mode 100644
index 7dd094f..0000000
--- a/keyboards/crkbd/keymaps/sajenim/leader.c
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-#include QMK_KEYBOARD_H
-#include "leader.h"
-#include "secrets.h"
-
-LEADER_EXTERNS();
-
-void matrix_scan_user(void) {
- LEADER_DICTIONARY() {
- leading = false;
- leader_end();
-
- /* Emerge */
- SEQ_TWO_KEYS(KC_E, KC_S) {
- SEND_STRING(SEARCH);
- }
- SEQ_TWO_KEYS(KC_E, KC_I) {
- SEND_STRING(INSTALL);
- }
- SEQ_TWO_KEYS(KC_E, KC_R) {
- SEND_STRING(REMOVE);
- }
- SEQ_TWO_KEYS(KC_E, KC_U) {
- SEND_STRING(UPDATE);
- }
- SEQ_TWO_KEYS(KC_E, KC_D) {
- SEND_STRING(DEPCLEAN);
- }
- SEQ_THREE_KEYS(KC_E, KC_U, KC_U) {
- SEND_STRING(UPGRADE);
- }
-
- /* Expansion */
- SEQ_TWO_KEYS(KC_G, KC_M) {
- SEND_STRING(GM);
- }
- SEQ_TWO_KEYS(KC_G, KC_N) {
- SEND_STRING(GN);
- }
- SEQ_FOUR_KEYS(KC_R, KC_T, KC_F, KC_M) {
- SEND_STRING(RTFM);
- }
-
- /* Secrets */
- SEQ_TWO_KEYS(KC_A, KC_H) {
- SEND_STRING(ADDRESS);
- }
- SEQ_TWO_KEYS(KC_P, KC_M) {
- SEND_STRING(PHONE);
- }
- SEQ_TWO_KEYS(KC_E, KC_O) {
- SEND_STRING(OUTLOOK);
- }
- SEQ_TWO_KEYS(KC_E, KC_P) {
- SEND_STRING(PROTON);
- }
- }
-}
diff --git a/keyboards/crkbd/keymaps/sajenim/leader.h b/keyboards/crkbd/keymaps/sajenim/leader.h
deleted file mode 100644
index 33fa54a..0000000
--- a/keyboards/crkbd/keymaps/sajenim/leader.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-#pragma once
-
-/* Emerge */
-#define SEARCH "sudo emerge --search "
-#define INSTALL "sudo emerge --ask "
-#define REMOVE "sudo emerge --ask --deselect "
-#define UPDATE "sudo emerge --sync"
-#define DEPCLEAN "sudo emerge --ask --depclean"
-#define UPGRADE "sudo emerge --ask --update --deep --newuse --with-bdeps=y @world"
-
-/* Expansion */
-#define GM "Goodmorning friends, I hope we all have/had a wonderfull day. :sunflower:"
-#define GN "Well i think it's time to hit the hay, farewell comrades. :sleeping:"
-#define RTFM "Read the fucking manual! :pepedumb:"
-
diff --git a/keyboards/crkbd/keymaps/sajenim/oled.c b/keyboards/crkbd/keymaps/sajenim/oled.c
index 8641126..1c9902b 100644
--- a/keyboards/crkbd/keymaps/sajenim/oled.c
+++ b/keyboards/crkbd/keymaps/sajenim/oled.c
@@ -1,22 +1,5 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
#include QMK_KEYBOARD_H
#include
-#include "oled.h"
#include "layers.h"
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
@@ -31,6 +14,9 @@ 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:
+ oled_write("QWRTY", false);
+ break;
case L_CANARY:
oled_write("CANRY", false);
break;
@@ -43,20 +29,8 @@ void oled_render_master(void) {
case L_ADJUST:
oled_write("ADJST", false);
break;
- case L_NAVIGATION:
- oled_write_ln(" NAV", false);
- break;
- case L_SYMBOLS:
- oled_write_ln(" SYM", false);
- break;
- case L_NUMBERS:
- oled_write_ln(" NUM", false);
- break;
- case L_OPERATORS:
- oled_write("OPER8", false);
- break;
- case L_MACRO:
- oled_write("MACRO", false);
+ case L_EXTEND:
+ oled_write("EXTND", false);
break;
default:
oled_write_ln(" UND", false);
diff --git a/keyboards/crkbd/keymaps/sajenim/oled.h b/keyboards/crkbd/keymaps/sajenim/oled.h
deleted file mode 100644
index e69de29..0000000
diff --git a/keyboards/crkbd/keymaps/sajenim/process_record.c b/keyboards/crkbd/keymaps/sajenim/process_record.c
index aa3ea75..c39ce55 100644
--- a/keyboards/crkbd/keymaps/sajenim/process_record.c
+++ b/keyboards/crkbd/keymaps/sajenim/process_record.c
@@ -1,50 +1,46 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
#include "process_record.h"
+#include "layers.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) {
- case VI_SAVE:
- if (record->event.pressed) {
- tap_code(KC_ESC);
- SEND_STRING(":w");
- tap_code(KC_ENT);
- }
- break;
+ case GUI_EXT:
+ if (record->tap.count && record->event.pressed) {
+ set_oneshot_mods(MOD_BIT(KC_LGUI));
+ return false;
+ } else if (record->event.pressed) {
+ register_mods(MOD_BIT(KC_LGUI));
+ layer_on(L_EXTEND);
+ } else {
+ unregister_mods(MOD_BIT(KC_LGUI));
+ layer_off(L_EXTEND);
+ }
+ return false;
- case VI_EXIT:
- if (record->event.pressed) {
- tap_code(KC_ESC);
- SEND_STRING(":q!");
- tap_code(KC_ENT);
- }
- break;
+ case ALT_EXT:
+ if (record->tap.count && record->event.pressed) {
+ set_oneshot_mods(MOD_BIT(KC_LALT));
+ return false;
+ } else if (record->event.pressed) {
+ register_mods(MOD_BIT(KC_LALT));
+ layer_on(L_EXTEND);
+ } else {
+ unregister_mods(MOD_BIT(KC_LALT));
+ layer_off(L_EXTEND);
+ }
+ return false;
- case HOME:
- if (record->event.pressed) {
- SEND_STRING("~/");
- }
- break;
-
- case UPDIR:
- if (record->event.pressed) {
- SEND_STRING("../");
- }
- break;
+ case BSPC_DW:
+ if (record->tap.count && record ->event.pressed) {
+ tap_code(KC_BSPC);
+ } else if (record->event.pressed) {
+ tap_code16(C(KC_W));
+ }
+ return false;
}
return true;
diff --git a/keyboards/crkbd/keymaps/sajenim/process_record.h b/keyboards/crkbd/keymaps/sajenim/process_record.h
index 243f074..2cd55d5 100644
--- a/keyboards/crkbd/keymaps/sajenim/process_record.h
+++ b/keyboards/crkbd/keymaps/sajenim/process_record.h
@@ -1,59 +1,24 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
#pragma once
#include "quantum.h"
-#include "tapdance.h"
// Our custom keycodes
enum custom_keycodes {
- VI_SAVE = SAFE_RANGE,
- VI_EXIT,
- HOME,
- UPDIR
+ CK_LOCK = SAFE_RANGE,
+ BSPC_DW,
};
// Left-hand thumb key layers
-#define LOWER MO(L_LOWER)
-#define FN_PFX TD(TD_FNPFX)
-#define FN_SPC LT(L_NAVIGATION, KC_SPC)
+#define GUI_EXT LT(L_EXTEND, KC_LGUI)
+#define BAK_LWR LT(L_LOWER, KC_BSPC)
+#define SPC_EXT LT(L_EXTEND, KC_SPC)
// Right-hand thumb key layers
-#define FN_ENT LT(L_MACRO, KC_ENT)
-#define FN_LDR TD(TD_FNLDR)
-#define RAISE MO(L_RAISE)
-
-// Left-hand home row mods
-#define HOME_C LGUI_T(KC_C)
-#define HOME_R LALT_T(KC_R)
-#define HOME_S LSFT_T(KC_S)
-#define HOME_T LCTL_T(KC_T)
-
-// Right-hand home row mods
-#define HOME_N RCTL_T(KC_N)
-#define HOME_E RSFT_T(KC_E)
-#define HOME_I RALT_T(KC_I)
-#define HOME_A RGUI_T(KC_A)
+#define ENT_SFT MT(MOD_LSFT, KC_ENT)
+#define DEL_RSE LT(L_RAISE, KC_DEL)
+#define ALT_EXT LT(L_EXTEND, KC_LALT)
// One Shot Keys
-#define OS_MEH OSM(MOD_MEH)
-#define OS_SUPR OSM(MOD_LGUI)
-#define OS_HYPR OSM(MOD_HYPR)
-
#define OS_LCTL OSM(MOD_LCTL)
#define OS_LSFT OSM(MOD_LSFT)
#define OS_LALT OSM(MOD_LALT)
@@ -64,13 +29,16 @@ enum custom_keycodes {
#define OS_RALT OSM(MOD_RALT)
#define OS_RGUI OSM(MOD_RGUI)
-// Tap Dance
-#define YANK TD(TD_YANK)
-#define PSTE TD(TD_PSTE)
-#define BAKWORD TD(TD_BAKWORD)
-#define DELWORD TD(TD_DELWORD)
+// Default Layers
+#define xQWERTY DF(L_QWERTY)
+#define xCANARY DF(L_CANARY)
// Shortcuts
-#define PREFIX LCTL(KC_B)
-#define ST_PSTE LSFT(KC_INSERT)
+#define WZ_CMOD LCTL(LSFT(KC_X))
+#define WZ_COPY LCTL(LSFT(KC_C))
+#define WZ_PSTE LCTL(LSFT(KC_V))
+
+// 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 a5aab55..abef87c 100644
--- a/keyboards/crkbd/keymaps/sajenim/rules.mk
+++ b/keyboards/crkbd/keymaps/sajenim/rules.mk
@@ -1,42 +1,29 @@
# We are using a Splinky RP2040 as a drop-in replacement controller
CONVERT_TO = promicro_rp2040
-
-# Bootloader selection
BOOTLOADER = rp2040
# Default features
LTO_ENABLE = yes
-OLED_DRIVER = SSD1306
-
-# Toggleable through keymap
-AUTO_SHIFT_ENABLE = yes
-AUTOCORRECT_ENABLE = yes
-CAPS_WORD_ENABLE = yes
# Optional features
-OLED_ENABLE = yes
-COMBO_ENABLE = yes
-TAP_DANCE_ENABLE = yes
-LEADER_ENABLE = yes
-# Only required if OLED_ENABLE = yes
-WPM_ENABLE = yes
+OLED_ENABLE = yes
+RGBLIGHT_ENABLE = yes
+COMBO_ENABLE = yes
+# Toggleable through keymap
+AUTO_SHIFT_ENABLE = yes
+AUTOCORRECT_ENABLE = yes
+CAPS_WORD_ENABLE = yes
-# Source required c files
-SRC += ./process_record.c
+SRC += process_record.c
+SRC += features/layer_lock.c
+SRC += features/sentence_case.c
-# Contitionally source optional c files
ifeq ($(OLED_ENABLE),yes)
SRC += ./oled.c
+ OLED_DRIVER = SSD1306
+ WPM_ENABLE = yes
endif
ifeq ($(COMBO_ENABLE),yes)
VPATH += keyboards/gboards
endif
-
-ifeq ($(TAP_DANCE_ENABLE),yes)
- SRC += ./tapdance.c
-endif
-
-ifeq ($(LEADER_ENABLE),yes)
- SRC += ./leader.c
-endif
diff --git a/keyboards/crkbd/keymaps/sajenim/tapdance.c b/keyboards/crkbd/keymaps/sajenim/tapdance.c
deleted file mode 100644
index 9fd3e32..0000000
--- a/keyboards/crkbd/keymaps/sajenim/tapdance.c
+++ /dev/null
@@ -1,350 +0,0 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-#include QMK_KEYBOARD_H
-#include "layers.h"
-#include "tapdance.h"
-
-/* Return an integer that corresponds to what kind of tap dance should be executed.
- *
- * How to figure out tap dance state: interrupted and pressed.
- *
- * Interrupted: If the state of a dance is "interrupted", that means that another key has been hit
- * under the tapping term. This is typically indicitive that you are trying to "tap" the key.
- *
- * Pressed: Whether or not the key is still being pressed. If this value is true, that means the tapping term
- * has ended, but the key is still being pressed down. This generally means the key is being "held".
- *
- * One thing that is currenlty not possible with qmk software in regards to tap dance is to mimic the "permissive hold"
- * feature. In general, advanced tap dances do not work well if they are used with commonly typed letters.
- * For example "A". Tap dances are best used on non-letter keys that are not hit while typing letters.
- *
- * Good places to put an advanced tap dance:
- * z,q,x,j,k,v,b, any function key, home/end, comma, semi-colon
- *
- * Criteria for "good placement" of a tap dance key:
- * Not a key that is hit frequently in a sentence
- * Not a key that is used frequently to double tap, for example 'tab' is often double tapped in a terminal, or
- * in a web form. So 'tab' would be a poor choice for a tap dance.
- * Letters used in common words as a double. For example 'p' in 'pepper'. If a tap dance function existed on the
- * letter 'p', the word 'pepper' would be quite frustating to type.
- *
- * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested
- *
- */
-
-td_state_t cur_dance(qk_tap_dance_state_t *state) {
- if (state->count == 1) {
- if (state->interrupted || !state->pressed) return TD_SINGLE_TAP;
- // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'.
- else return TD_SINGLE_HOLD;
- } else if (state->count == 2) {
- // TD_DOUBLE_SINGLE_TAP is to distinguish between typing "pepper", and actually wanting a double tap
- // action when hitting 'pp'. Suggested use case for this return value is when you want to send two
- // keystrokes of the key, and not the 'double tap' action/macro.
- if (state->interrupted) return TD_DOUBLE_SINGLE_TAP;
- else if (state->pressed) return TD_DOUBLE_HOLD;
- else return TD_DOUBLE_TAP;
- }
-
- // Assumes no one is trying to type the same letter three times (at least not quickly).
- // If your tap dance key is 'KC_W', and you want to type "www." quickly - then you will need to add
- // an exception here to return a 'TD_TRIPLE_SINGLE_TAP', and define that enum just like 'TD_DOUBLE_SINGLE_TAP'
- if (state->count == 3) {
- if (state->interrupted || !state->pressed) return TD_TRIPLE_TAP;
- else return TD_TRIPLE_HOLD;
- } else return TD_UNKNOWN;
-}
-
-
-/* Yank:
- *
- * Sends + on single tap
- * Sends + + on double tap (Commonly used in UNIX terminals)
- *
- */
-
-static td_tap_t yank_tap_state = {
- .is_press_action = true,
- .state = TD_NONE
-};
-
-void yank_finished(qk_tap_dance_state_t *state, void *user_data) {
- yank_tap_state.state = cur_dance(state);
- switch (yank_tap_state.state) {
- case TD_SINGLE_TAP:
- register_code(KC_LCTL);
- register_code(KC_C);
- break;
- case TD_DOUBLE_TAP:
- register_code(KC_LCTL);
- register_code(KC_LSFT);
- register_code(KC_C);
- break;
- default:
- break;
- }
-}
-
-void yank_reset(qk_tap_dance_state_t *state, void *user_data) {
- switch (yank_tap_state.state) {
- case TD_SINGLE_TAP:
- unregister_code(KC_LCTL);
- unregister_code(KC_C);
- break;
- case TD_DOUBLE_TAP:
- unregister_code(KC_LCTL);
- unregister_code(KC_LSFT);
- unregister_code(KC_C);
- break;
- default:
- break;
- }
- yank_tap_state.state = TD_NONE;
-}
-
-
-/* Paste:
- *
- * Sends + on single tap
- * Sends + + on double tap (Commonly used in UNIX terminals)
- *
- */
-
-static td_tap_t pste_tap_state = {
- .is_press_action = true,
- .state = TD_NONE
-};
-
-void pste_finished(qk_tap_dance_state_t *state, void *user_data) {
- pste_tap_state.state = cur_dance(state);
- switch (pste_tap_state.state) {
- case TD_SINGLE_TAP:
- register_code(KC_LCTL);
- register_code(KC_V);
- break;
- case TD_DOUBLE_TAP:
- register_code(KC_LCTL);
- register_code(KC_LSFT);
- register_code(KC_V);
- break;
- default:
- break;
- }
-}
-
-void pste_reset(qk_tap_dance_state_t *state, void *user_data) {
- switch (pste_tap_state.state) {
- case TD_SINGLE_TAP:
- unregister_code(KC_LCTL);
- unregister_code(KC_V);
- break;
- case TD_DOUBLE_TAP:
- unregister_code(KC_LCTL);
- unregister_code(KC_LSFT);
- unregister_code(KC_V);
- break;
- default:
- break;
- }
- pste_tap_state.state = TD_NONE;
-}
-
-
-/* Delete word:
- *
- * Sends delete on single tap or hold
- * Sends + "daw" on double tap (Vim: delete the word under the cursor)
- *
- */
-
-static td_tap_t delword_tap_state = {
- .is_press_action = true,
- .state = TD_NONE
-};
-
-void delword_finished(qk_tap_dance_state_t *state, void *user_data) {
- delword_tap_state.state = cur_dance(state);
- switch (delword_tap_state.state) {
- case TD_SINGLE_TAP:
- register_code(KC_DEL);
- break;
- case TD_SINGLE_HOLD:
- register_code(KC_DEL);
- break;
- case TD_DOUBLE_TAP:
- tap_code(KC_ESC);
- SEND_STRING("daw");
- break;
- default:
- break;
- }
-}
-
-void delword_reset(qk_tap_dance_state_t *state, void *user_data) {
- switch (delword_tap_state.state) {
- case TD_SINGLE_TAP:
- unregister_code(KC_DEL);
- break;
- case TD_SINGLE_HOLD:
- unregister_code(KC_DEL);
- break;
- default:
- break;
- }
- delword_tap_state.state = TD_NONE;
-}
-
-
-/* Back word:
- *
- * Sends bacspace on single tap or hold
- * Sends + on double tap (Bash: remove the command/argument before the cursor)
- *
- */
-
-static td_tap_t backword_tap_state = {
- .is_press_action = true,
- .state = TD_NONE
-};
-
-void bakword_finished(qk_tap_dance_state_t *state, void *user_data) {
- backword_tap_state.state = cur_dance(state);
- switch (backword_tap_state.state) {
- case TD_SINGLE_TAP:
- register_code(KC_BSPC);
- break;
- case TD_SINGLE_HOLD:
- register_code(KC_BSPC);
- break;
- case TD_DOUBLE_TAP:
- register_code(KC_LCTL);
- register_code(KC_W);
- break;
- default:
- break;
- }
-}
-
-void bakword_reset(qk_tap_dance_state_t *state, void *user_data) {
- switch (backword_tap_state.state) {
- case TD_SINGLE_TAP:
- unregister_code(KC_BSPC);
- break;
- case TD_SINGLE_HOLD:
- unregister_code(KC_BSPC);
- break;
- case TD_DOUBLE_TAP:
- unregister_code(KC_LCTL);
- unregister_code(KC_W);
- break;
- default:
- break;
- }
- backword_tap_state.state = TD_NONE;
-}
-
-
-/* Function prefix:
- *
- * Send tmux prefix on tap + .
- * Enable function layer on hold.
- *
- */
-
-static td_tap_t fnpfx_tap_state = {
- .is_press_action = true,
- .state = TD_NONE
-};
-
-void fnpfx_finished(qk_tap_dance_state_t *state, void *user_data) {
- fnpfx_tap_state.state = cur_dance(state);
- switch (fnpfx_tap_state.state) {
- case TD_SINGLE_TAP:
- register_code(KC_LCTL);
- register_code(KC_B);
- break;
- case TD_SINGLE_HOLD:
- layer_on(L_NUMBERS);
- break;
- default:
- break;
- }
-}
-
-void fnpfx_reset(qk_tap_dance_state_t *state, void *user_data) {
- switch (fnpfx_tap_state.state) {
- case TD_SINGLE_TAP:
- unregister_code(KC_LCTL);
- unregister_code(KC_B);
- break;
- case TD_SINGLE_HOLD:
- layer_off(L_NUMBERS);
- break;
- default:
- break;
- }
- fnpfx_tap_state.state = TD_NONE;
-}
-
-
-/* Function leader:
- *
- * Send leader key on tap.
- * Enable function layer on hold.
- *
- */
-
-static td_tap_t fnldr_tap_state = {
- .is_press_action = true,
- .state = TD_NONE
-};
-
-void fnldr_finished(qk_tap_dance_state_t *state, void *user_data) {
- fnldr_tap_state.state = cur_dance(state);
- switch (fnldr_tap_state.state) {
- case TD_SINGLE_TAP:
- qk_leader_start();
- break;
- case TD_SINGLE_HOLD:
- layer_on(L_SYMBOLS);
- break;
- default:
- break;
- }
-}
-
-void fnldr_reset(qk_tap_dance_state_t *state, void *user_data) {
- switch (fnldr_tap_state.state) {
- case TD_SINGLE_HOLD:
- layer_off(L_SYMBOLS);
- break;
- default:
- break;
- }
- fnldr_tap_state.state = TD_NONE;
-}
-
-// Define `ACTION_TAP_DANCE_FN_ADVANCED()` for each tapdance keycode, passing in `finished` and `reset` functions
-qk_tap_dance_action_t tap_dance_actions[] = {
- [TD_YANK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, yank_finished, yank_reset),
- [TD_PSTE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, pste_finished, pste_reset),
- [TD_DELWORD] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, delword_finished, delword_reset),
- [TD_BAKWORD] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, bakword_finished, bakword_reset),
- [TD_FNPFX] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, fnpfx_finished, fnpfx_reset),
- [TD_FNLDR] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, fnldr_finished, fnldr_reset)
-};
-
diff --git a/keyboards/crkbd/keymaps/sajenim/tapdance.h b/keyboards/crkbd/keymaps/sajenim/tapdance.h
deleted file mode 100644
index 88c630b..0000000
--- a/keyboards/crkbd/keymaps/sajenim/tapdance.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* Copyright 2022 @ sajenim (https://github.com/sajenim)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-#pragma once
-
-// Our tapdance keycodes
-enum td_keycodes {
- TD_YANK,
- TD_PSTE,
- TD_BAKWORD,
- TD_DELWORD,
- TD_FNPFX,
- TD_FNLDR
-};
-
-// Define a type containing as many tapdance states as we need
-typedef enum {
- TD_NONE,
- TD_UNKNOWN,
- TD_SINGLE_TAP,
- TD_SINGLE_HOLD,
- TD_DOUBLE_TAP,
- TD_DOUBLE_HOLD,
- TD_DOUBLE_SINGLE_TAP, // Send two single taps
- TD_TRIPLE_TAP,
- TD_TRIPLE_HOLD
-} td_state_t;
-
-typedef struct {
- bool is_press_action;
- td_state_t state;
-} td_tap_t;
-
-// Declare our tapdance functions:
-
-// Function to determine the current tapdance state
-td_state_t cur_dance(qk_tap_dance_state_t *state);
-
-// `finished` and `reset` functions for each tapdance keycode
-void yank_finished(qk_tap_dance_state_t *state, void *user_data);
-void yank_reset(qk_tap_dance_state_t *state, void *user_data);
-
-void pste_finished(qk_tap_dance_state_t *state, void *user_data);
-void pste_reset(qk_tap_dance_state_t *state, void *user_data);
-
-void delword_finished(qk_tap_dance_state_t *state, void *user_data);
-void delword_reset(qk_tap_dance_state_t *state, void *user_data);
-
-void bakword_finished(qk_tap_dance_state_t *state, void *user_data);
-void bakword_reset(qk_tap_dance_state_t *state, void *user_data);
-
-void fnpfx_finished(qk_tap_dance_state_t *state, void *user_data);
-void fnpfx_reset(qk_tap_dance_state_t *state, void *user_data);
-
-void fnldr_finished(qk_tap_dance_state_t *state, void *user_data);
-void fnldr_reset(qk_tap_dance_state_t *state, void *user_data);
-