From 22f5edcfa9850d8127c34e2cc937617aca5be182 Mon Sep 17 00:00:00 2001 From: sajenim Date: Thu, 30 Mar 2023 12:41:27 +0800 Subject: [PATCH] a --- keyboards/crkbd/keymaps/sajenim/combos.def | 29 +- keyboards/crkbd/keymaps/sajenim/config.h | 56 ++- .../keymaps/sajenim/features/layer_lock.c | 145 ++++++++ .../keymaps/sajenim/features/layer_lock.h | 136 +++++++ .../keymaps/sajenim/features/sentence_case.c | 338 +++++++++++++++++ .../keymaps/sajenim/features/sentence_case.h | 224 +++++++++++ keyboards/crkbd/keymaps/sajenim/keymap.c | 158 ++------ keyboards/crkbd/keymaps/sajenim/layers.h | 25 +- keyboards/crkbd/keymaps/sajenim/leader.c | 72 ---- keyboards/crkbd/keymaps/sajenim/leader.h | 31 -- keyboards/crkbd/keymaps/sajenim/oled.c | 36 +- keyboards/crkbd/keymaps/sajenim/oled.h | 0 .../crkbd/keymaps/sajenim/process_record.c | 78 ++-- .../crkbd/keymaps/sajenim/process_record.h | 68 +--- keyboards/crkbd/keymaps/sajenim/rules.mk | 37 +- keyboards/crkbd/keymaps/sajenim/tapdance.c | 350 ------------------ keyboards/crkbd/keymaps/sajenim/tapdance.h | 70 ---- 17 files changed, 987 insertions(+), 866 deletions(-) create mode 100644 keyboards/crkbd/keymaps/sajenim/features/layer_lock.c create mode 100644 keyboards/crkbd/keymaps/sajenim/features/layer_lock.h create mode 100644 keyboards/crkbd/keymaps/sajenim/features/sentence_case.c create mode 100644 keyboards/crkbd/keymaps/sajenim/features/sentence_case.h delete mode 100644 keyboards/crkbd/keymaps/sajenim/leader.c delete mode 100644 keyboards/crkbd/keymaps/sajenim/leader.h delete mode 100644 keyboards/crkbd/keymaps/sajenim/oled.h delete mode 100644 keyboards/crkbd/keymaps/sajenim/tapdance.c delete mode 100644 keyboards/crkbd/keymaps/sajenim/tapdance.h 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); -