mirrors/qmk_userspace
Watch
1
0
Fork
You've already forked qmk_userspace
 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2026-07-25 11:05:57 -04:00
Code Issues Projects Releases Packages Wiki Activity

Updated the nyquist keymap as a temporary replacement for my broken boards

Browse source
This commit is contained in:
Drew Whitney 2025-12-28 17:48:32 -07:00
commit a01e2af3d2
15 changed files with 245 additions and 628 deletions
Download patch file Download diff file Expand all files Collapse all files

3
flash.sh
View file

@ -1 +1,2 @@
qmk flash -kb keebio/iris_lm/g1 -km drew -j 0
# qmk flash -kb keebio/iris_lm/g1 -km drew -j 0
qmk flash -kb keebio/nyquist/rev4 -km drew -j 0

71
keyboards/keebio/nyquist/rev4/keymaps/drew/alias.h
View file

@ -1,74 +1,31 @@
#pragma once
#include QMK_KEYBOARD_H
#include "./layers.h"
#include "./layers/layers.h"
/// @brief Custom keycodes.
enum CustomKeycodes {
DOWN = SAFE_RANGE,
UP,
LOW_6,
LOW_7,
LOW_8,
LOW_9,
LOW_0,
MULT, // avoids a conflict with KC_ASTR
CAPS_WORD,
WIN_SWAP = SAFE_RANGE, // custom alt-tabbing
};
#define TD_CLS TD(TD_CAD_LOCK_SLEEP)
#define COMPOSE KC_SCRL
// keys
#define CAD C(A(KC_DEL))
#define LOCK G(KC_L)
#define LAUNCH A(KC_SPC)
#define MENU S(KC_F10)
#define TAB_FORWARD C(KC_TAB)
#define TAB_BACKWARD (C(S(KC_TAB)))
#define TAB_RIGHT C(KC_TAB)
#define TAB_LEFT (C(S(KC_TAB)))
#define ZOOM_IN C(KC_EQL)
#define ZOOM_OUT C(KC_MINS)
// layers
#define NUM_SPC LT(_NUM, KC_SPC)
#define NAV_ENT LT(_NAV, KC_ENT)
#define FUNC_PLAY LT(_FUNC, KC_MPLY)
// mod-taps (not homerow mods)
#define GUI_LAUNCH GUI_T(LAUNCH)
#define NUM MO(_NUM) // used by the NumCombo combo
#define SYM_BSPC LT(_SYM, KC_BSPC)
#define NAV_TAB LT(_NAV, KC_TAB)
#define ARROW MO(_SH_ARROW)
#define FN_SPC LT(_FUNC, KC_SPC)
#define FUNC MO(_FUNC)
// trigger mods
#define TABBING_TRIGGER_MODS MOD_MASK_ALT
#define OBLITERATE_TRIGGER_MODS MOD_MASK_GUI
// home row mods
// base layer
#define GUI_A GUI_T(KC_A)
#define ALT_S ALT_T(KC_S)
#define CTL_D CTL_T(KC_D)
#define SFT_F SFT_T(KC_F)
#define GUI_SCLN RGUI_T(KC_SCLN)
#define ALT_L RALT_T(KC_L)
#define CTL_K RCTL_T(KC_K)
#define SFT_J RSFT_T(KC_J)
// nav layer
#define GUI_BSLS GUI_T(KC_BSLS)
#define ALT_LBRC ALT_T(KC_LBRC)
#define CTL_RBRC CTL_T(KC_RBRC)
#define SFT_MINS SFT_T(KC_MINS)
#define GUI_RGHT RGUI_T(KC_RGHT)
#define ALT_UP RALT_T(KC_UP)
#define CTL_DOWN RCTL_T(KC_DOWN)
#define SFT_LEFT RSFT_T(KC_LEFT)
// num layer
#define GUI_1 GUI_T(KC_1)
#define ALT_2 ALT_T(KC_2)
#define CTL_3 CTL_T(KC_3)
#define SFT_4 SFT_T(KC_4)
#define GUI_0 RGUI_T(KC_0)
#define ALT_9 RALT_T(KC_9)
#define CTL_8 RCTL_T(KC_8)
#define SFT_7 RSFT_T(KC_7)

3
keyboards/keebio/nyquist/rev4/keymaps/drew/caps_word/caps_word.c
View file

@ -1,5 +1,4 @@
#include QMK_KEYBOARD_H
#include "caps_word.h"
#include "../alias.h"
#include "../tap_dance/tap_dance.h"
@ -12,7 +11,6 @@ bool caps_word_press_user(uint16_t keycode) {
break;
// Keycodes that continue Caps Word, without shifting
case KC_1 ... KC_0:
case LOW_6 ... LOW_0:
case KC_BSPC:
case KC_DEL:
case KC_LEFT:
@ -20,7 +18,6 @@ bool caps_word_press_user(uint16_t keycode) {
case KC_MINS:
case KC_UNDS:
case KC_SLSH:
case TD(TD_CW_CL): // this makes toggling work
return true;
break;
default:

4
keyboards/keebio/nyquist/rev4/keymaps/drew/caps_word/caps_word.h
View file

@ -1,4 +0,0 @@
#pragma once
#include "stdint.h"
bool caps_word_press_user(uint16_t keycode);

15
keyboards/keebio/nyquist/rev4/keymaps/drew/chordal_hold/chordal_options.c
View file

@ -1,15 +0,0 @@
// TODO: possibly remove
#include "../alias.h"
bool get_chordal_hold(
uint16_t tap_hold_keycode, keyrecord_t* tap_hold_record, uint16_t other_keycode,
keyrecord_t* other_record
) {
switch (tap_hold_keycode) {
case SFT_D:
case SFT_K: // no same hand stuff for shift
return get_chordal_hold_default(tap_hold_record, other_record);
}
return true; // allow same hand stuff for everything else
}

9
keyboards/keebio/nyquist/rev4/keymaps/drew/chordal_hold/chordal_options.h
View file

@ -1,9 +0,0 @@
#pragma once
#include QMK_KEYBOARD_H
#include "stdint.h"
bool get_chordal_hold(
uint16_t tap_hold_keycode, keyrecord_t* tap_hold_record, uint16_t other_keycode,
keyrecord_t* other_record
);

27
keyboards/keebio/nyquist/rev4/keymaps/drew/config.h
View file

@ -3,7 +3,7 @@
#pragma once
#define SPLIT_HAND_PIN GP23
#pragma once
#define USB_VBUS_PIN GP18
@ -15,30 +15,25 @@
#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET
#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 1000U
#define I2C_DRIVER I2CD0
#define I2C0_SDA_PIN GP4
#define I2C0_SCL_PIN GP5m
#define SPLIT_USB_TIMEOUT 20000
// -------------------------------------------------------------------------------------------------
// #define DYNAMIC_KEYMAP_LAYER_COUNT 5
#define TAPPING_TERM 200
// tap-hold
#define QUICK_TAP_TERM_PER_KEY
#define HOLD_ON_OTHER_KEY_PRESS
// #define HOLD_ON_OTHER_KEY_PRESS_PER_KEY
// #define PERMISSIVE_HOLD_PER_KEY
#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY
#define PERMISSIVE_HOLD_PER_KEY
#define TAPPING_TERM_PER_KEY
// #define FLOW_TAP_TERM 150
// #define CHORDAL_HOLD
// combos
#define COMBO_PROCESS_KEY_RELEASE
#define COMBO_PROCESS_KEY_REPRESS
#define COMBO_TERM_PER_COMBO
#define COMBO_MUST_HOLD_PER_COMBO
#define CAPS_WORD_IDLE_TIMEOUT 0
#define DUMMY_MOD_NEUTRALIZER_KEYCODE KC_RCTL
#define MODS_TO_NEUTRALIZE {MOD_BIT(KC_LALT), MOD_BIT(KC_RALT), MOD_BIT(KC_LGUI), MOD_BIT(KC_RGUI)}
// disable some features to make the code smaller
#define NO_ACTION_ONESHOT
#define NKRO_DEFAULT_ON true

35
keyboards/keebio/nyquist/rev4/keymaps/drew/flow_tap/flow_tap_options.c
View file

@ -1,35 +0,0 @@
#include QMK_KEYBOARD_H
#include "../alias.h"
uint16_t get_flow_tap_term(uint16_t keycode, keyrecord_t* record, uint16_t previous_keycode) {
switch (get_tap_keycode(previous_keycode)) {
case KC_A ... KC_Z:
case KC_DOT:
case KC_COMM:
case KC_SCLN:
case KC_SLSH:
case KC_QUOT: // enable flow-tap for these keys
break;
default: // disable otherwise
return 0;
}
switch (keycode) {
case CTL_D:
case CTL_K:
case CTL_3:
case CTL_8:
case CTL_RBRC:
case CTL_DOWN: // control should always be allowed to hold
case GUI_LAUNCH: // same with non-homerow mod taps
case NUM_SPC:
case NAV_ENT:
case FUNC_PLAY: // same with layer-taps
return 0;
break;
}
return FLOW_TAP_TERM; // enable flow-tap
}

506
keyboards/keebio/nyquist/rev4/keymaps/drew/keymap.c
View file

@ -1,237 +1,181 @@
#include QMK_KEYBOARD_H
#include "./caps_word/caps_word.h"
#include "./layers.h"
#include "./tap_dance/tap_dance.c"
#include "./alias.h"
#include "./combos/combos.h"
#include "./layers/layers.h"
#include "./tap_dance/tap_dance.h"
#include "./utils/utils.h"
#include "stdbool.h"
#include "stdint.h"
bool NAV_enabled = false;
// clang-format off
// chordal tap config
const char chordal_hold_layout[MATRIX_ROWS][MATRIX_COLS] PROGMEM = LAYOUT_ortho_4x12(
'*', 'L', 'L', 'L', 'L', 'L', 'R', 'R', 'R', 'R', 'R', '*',
'*', 'L', 'L', 'L', 'L', 'L', 'R', 'R', 'R', 'R', 'R', 'R',
'*', 'L', 'L', 'L', 'L', 'L', 'R', 'R', 'R', 'R', 'R', '*',
'*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'
);
// clang-format on
#include <stdbool.h>
#include <stdint.h>
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// base
[_BASE] = LAYOUT_ortho_4x12(
KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
KC_TAB, GUI_A, ALT_S, CTL_D, SFT_F, KC_G, KC_H, SFT_J, CTL_K, ALT_L, GUI_SCLN, KC_QUOT,
TD(TD_CW_CL), KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_DEL,
KC_NO, FUNC_PLAY, KC_LALT, TD(TD_CAD_LOCK_SLEEP), GUI_LAUNCH, NUM_SPC, NAV_ENT, KC_SCRL, KC_LEFT, DOWN, UP, KC_RGHT
),
// gamer
[_GAME] = LAYOUT_ortho_4x12(
[_BASE] = LAYOUT_ortho_4x12(
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_NO, KC_Q, KC_W, KC_F, KC_P, KC_B, KC_J, KC_L, KC_U, KC_Y, KC_QUOT, KC_NO,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_A, KC_R, KC_S, KC_T, KC_G, KC_M, KC_N, KC_E, KC_I, KC_O, KC_NO,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_Z, KC_X, KC_C, KC_D, KC_V, KC_K, KC_H, KC_COMM, KC_DOT, KC_SLSH, KC_NO,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, NAV_TAB, KC_SPC, OS_LSFT, SYM_BSPC, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
[_GAME] = LAYOUT_ortho_4x12(
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_TAB, KC_A, KC_S, KC_D, KC_TRNS, KC_TRNS, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_TRNS,
KC_LSFT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_LCTL, KC_TRNS, KC_TRNS, KC_PGDN, KC_PGUP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
),
// numbers
[_NUM] = LAYOUT_ortho_4x12(
KC_TRNS, KC_SLSH, KC_AT, MULT, KC_MINS, KC_PLUS, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_TRNS,
KC_DOT, GUI_1, ALT_2, CTL_3, SFT_4, KC_5, KC_6, SFT_7, CTL_8, ALT_9, GUI_0, KC_TRNS,
KC_COMM, LOW_6, LOW_7, LOW_8, LOW_9, LOW_0, KC_SCLN, KC_COLN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_COLN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
),
// navigation and special characters
[_NAV] = LAYOUT_ortho_4x12(
KC_GRV, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_TRNS,
KC_TRNS, GUI_BSLS, ALT_LBRC, CTL_RBRC, SFT_MINS, KC_EQL, KC_HOME, SFT_LEFT, CTL_DOWN, ALT_UP, GUI_RGHT, KC_END,
KC_TILDE, KC_PIPE, KC_LCBR, KC_RCBR, KC_UNDS, KC_PLUS, KC_NO, KC_F2, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
),
// function
[_FUNC] = LAYOUT_ortho_4x12(
KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,
KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, QK_RBT,
KC_TRNS, KC_MUTE, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_NO, KC_NO, KC_NO, KC_NO, TG(_GAME), QK_BOOT,
KC_TRNS, KC_NO, KC_BRID, KC_BRIU, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_WBAK, KC_TRNS, KC_TRNS, KC_WFWD
),
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, KC_I, KC_TRNS, TG(_GAME), KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
[_SH_ARROW] = LAYOUT_ortho_4x12( // single-handed arrows
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_J, KC_L, KC_UP, KC_NO, KC_NO, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_LEFT, KC_DOWN, KC_RGHT, KC_NO, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, NAV_TAB, KC_TRNS, OS_LSFT, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
[_SYM] = LAYOUT_ortho_4x12(
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_TRNS, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_QUES, KC_GRV, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_PIPE, KC_PLUS, KC_UNDS, KC_MINS, KC_EQL, KC_DQUO, OS_LSFT, OS_LCTL, OS_LALT, OS_LGUI, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_LPRN, KC_RPRN, KC_LBRC, KC_RBRC, KC_BSLS, KC_SCLN, KC_COLN, KC_LCBR, KC_RCBR, KC_TILD, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, NAV_TAB, KC_TRNS, ARROW, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
[_NAV] = LAYOUT_ortho_4x12(
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_TRNS, KC_ESC, C(KC_Y), TAB_LEFT, TAB_RIGHT, LAUNCH, COMPOSE, KC_HOME, KC_UP, KC_END, KC_DEL, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, OS_LGUI, OS_LALT, OS_LCTL, OS_LSFT, KC_F2, KC_CAPS, KC_LEFT, KC_DOWN, KC_RGHT, KC_ENT, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, C(KC_Z), C(KC_X), C(KC_C), KC_SPC, C(KC_V), KC_NO, CW_TOGG, KC_COMM, KC_DOT, KC_SLSH, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, NAV_TAB, FN_SPC, OS_LSFT, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
[_NUM] = LAYOUT_ortho_4x12(
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_TRNS, KC_NO, KC_PLUS, KC_E, KC_MINS, KC_EQL, KC_CIRC, KC_NO, KC_ASTR, KC_NO, KC_NO, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_LPRN, KC_RPRN, KC_NO, KC_SPC, KC_NO, KC_SCLN, KC_COLN, KC_COMM, KC_DOT, KC_SLSH, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, NAV_TAB, KC_TRNS, OS_LSFT, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
[_FUNC] = LAYOUT_ortho_4x12( // functions
//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
KC_TRNS, KC_NO, KC_NO, ZOOM_OUT, ZOOM_IN, KC_F11, QK_BOOT, KC_F1, KC_F2, KC_F3, KC_F4, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_MPRV, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY, CAD, KC_F5, KC_F6, KC_F7, KC_F8, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_TRNS, KC_BRID, KC_BRIU, KC_WBAK, KC_WFWD, KC_MUTE, KC_SLEP, KC_F9, KC_F10, KC_F11, KC_F12, KC_TRNS,
//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤
KC_NO, KC_NO, KC_NO, KC_NO, TG(_GAME), KC_TRNS, OS_LSFT, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO
//└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
),
};
// clang-format on
tap_dance_action_t tap_dance_actions[] = {
[TD_CAD_LOCK_SLEEP] = ACTION_TAP_DANCE_FN(CAD_lock_sleep),
};
const uint16_t PROGMEM num_layer_combo[] = {NAV_TAB, SYM_BSPC, COMBO_END};
const uint16_t PROGMEM win_swap_combo[] = {TAB_LEFT, TAB_RIGHT, COMBO_END};
combo_t key_combos[] = {
// [NumCombo] = COMBO(num_layer_combo, NUM),
[WinSwapCombo] = COMBO(win_swap_combo, WIN_SWAP),
};
bool process_record_user(uint16_t keycode, keyrecord_t* record) {
// static bool NAV_is_on = false;
switch (keycode) {
case GUI_LAUNCH: // make this keycode work (16-bit mod-tap)
if (record->tap.count) {
// allow NAV and SYM to override each other
case SYM_BSPC:
if (!record->tap.count) {
// if NAV is on, turn it off when SYM is turned on, then restore it when SYM is
// turned off
// if we're NUM-latched, don't interfere with the states
// if (NAV_is_on) {
// record->event.pressed && !NUM_latched ? layer_off(_NAV) : layer_on(_NAV);
// }
} else {
// backspace -> obliterate line
if (record->event.pressed) {
tap_code16(LAUNCH);
}
uint8_t mods = get_mods();
if ((mods | get_oneshot_mods()) & OBLITERATE_TRIGGER_MODS) {
tap_code(DUMMY_MOD_NEUTRALIZER_KEYCODE);
unregister_mods(OBLITERATE_TRIGGER_MODS);
clear_oneshot_mods();
tap_code16(S(KC_HOME));
register_code(KC_BSPC);
set_mods(mods);
return false;
}
}
}
break;
// make it possible to go from layer 3 to layer 2
case NUM_SPC:
if (!record->tap.count) {
if (NAV_enabled) {
record->event.pressed ? layer_off(_NAV) : layer_on(_NAV);
}
// case NAV_TAB:
// if (!record->tap.count) {
// NAV_is_on = record->event.pressed;
// }
// break;
case WIN_SWAP: // easy Alt-Tab
if (record->event.pressed) {
register_mods(MOD_LALT);
tap_code(KC_TAB);
} else {
unregister_mods(MOD_LALT);
}
break;
case KC_SPC:
// have to implement this here instead of as a key override because it was acting
// weird with layers as a key override
if (get_highest_layer(layer_state) != _BASE) {
return true; // return early
}
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & MOD_MASK_CTRL) {
if ((mods | get_oneshot_mods()) & MOD_MASK_CTRL) {
del_mods(MOD_MASK_CTRL);
clear_oneshot_mods();
tap_code16(MENU);
set_mods(mods);
return false;
}
}
}
break;
case NAV_ENT:
if (!record->tap.count) {
NAV_enabled = record->event.pressed;
}
break;
// noshift homerow mods with control overrides
case GUI_1:
return unshift_register_or_ctrl_fallthrough(keycode, KC_A, record);
break;
case ALT_2:
return unshift_register_or_ctrl_fallthrough(keycode, KC_S, record);
break;
case SFT_4:
return unshift_register_or_ctrl_fallthrough(keycode, KC_F, record);
break;
case SFT_7:
return unshift_register_or_ctrl_fallthrough(keycode, KC_J, record);
break;
case GUI_BSLS:
return unshift_register_or_ctrl_fallthrough(keycode, KC_A, record);
break;
case ALT_LBRC:
return unshift_register_or_ctrl_fallthrough(keycode, KC_S, record);
break;
case SFT_MINS:
return unshift_register_or_ctrl_fallthrough(keycode, KC_F, record);
break;
case CTL_3:
case GUI_0:
case CTL_8:
case ALT_9:
case CTL_RBRC: // no control override, just unshift
return unshift_register(keycode, record);
break;
// make arrow key homerow mods trigger the tap action when held and the hold time expires
case ALT_UP:
case CTL_DOWN:
if (!record->tap.count && !record->tap.interrupted) {
if (record->event.pressed) {
register_code(keycode);
return false;
} else {
unregister_code(keycode);
}
} else {
uint8_t mods = get_mods();
if (record->event.pressed) {
if (mods == MOD_BIT(KC_LCTL)) { // remove control
del_mods(MOD_BIT(KC_LCTL));
register_code(keycode);
set_mods(mods);
return false;
}
}
}
case SFT_LEFT:
case GUI_RGHT:
// if this is a hold action and it occurred naturally
if (!record->tap.count && !record->tap.interrupted) {
if (record->event.pressed) {
register_code(keycode);
return false;
} else {
unregister_code(keycode);
}
}
break;
// make it so only the opposite-side shift key works
case KC_Q:
case KC_W:
case KC_E:
case KC_R:
case KC_T:
case KC_G:
case KC_Z:
case KC_X:
case KC_C:
case KC_V:
case KC_B: // left-side
if (record->event.pressed && get_mods() == MOD_BIT(KC_LSFT)) {
return false; // do nothing
}
break;
case GUI_A:
case ALT_S:
case CTL_D:
case SFT_F:
if (record->event.pressed && record->tap.count && get_mods() == MOD_BIT(KC_LSFT)) {
return false; // do nothing
}
break;
case KC_Y:
case KC_U:
case KC_I:
case KC_O:
case KC_P:
case KC_H:
case KC_QUOT:
case KC_N:
case KC_M:
case KC_COMM:
case KC_DOT:
case KC_SLSH:
if (IS_LAYER_ON(_BASE) && record->event.pressed && get_mods() == MOD_BIT(KC_RSFT)) {
return false; // do nothing
}
break;
case GUI_SCLN:
case ALT_L:
case CTL_K:
case SFT_J:
if (IS_LAYER_ON(_BASE) && record->event.pressed && record->tap.count &&
get_mods() == MOD_BIT(KC_RSFT)) {
return false; // do nothing
}
break;
}
return true;
}
const key_override_t CW_CL_TO_TAB_BACKWARDS =
ko_make_basic(TABBING_TRIGGER_MODS, TD(TD_CW_CL), TAB_BACKWARD);
const key_override_t Q_TO_KILL = ko_make_with_layers(MOD_MASK_GUI, KC_Q, A(KC_F4), 1 << _BASE);
const key_override_t COMM_TO_TAB_BACKWARDS =
ko_make_with_layers(TABBING_TRIGGER_MODS, KC_COMM, TAB_BACKWARD, 1 << _NUM);
const key_override_t TILDE_TO_TAB_BACKWARDS =
ko_make_with_layers(TABBING_TRIGGER_MODS, KC_TILDE, TAB_BACKWARD, 1 << _NAV);
const key_override_t BSPC_TO_OBLITERATE = {
.trigger = KC_BSPC,
.trigger_mods = OBLITERATE_TRIGGER_MODS,
.layers = 0xFF,
.custom_action = obliterate_line_backwards,
.suppressed_mods = OBLITERATE_TRIGGER_MODS,
};
const key_override_t DEL_TO_OBLITERATE = {
.trigger = KC_DEL,
.trigger_mods = OBLITERATE_TRIGGER_MODS,
@ -246,143 +190,67 @@ const key_override_t HOME_TO_MEGA_HOME = ko_make_basic(MOD_MASK_GUI, KC_HOME, C(
const key_override_t END_NO_CTRL = ko_make_basic(MOD_MASK_CTRL, KC_END, KC_END);
const key_override_t END_TO_META_END = ko_make_basic(MOD_MASK_GUI, KC_END, C(KC_END));
const key_override_t ESC_TO_TAB_FORWARD = ko_make_basic(TABBING_TRIGGER_MODS, KC_ESC, TAB_FORWARD);
const key_override_t UP_NO_CTRL = ko_make_with_layers_and_negmods(MOD_MASK_CTRL, KC_UP, KC_UP, 0xFF & ~(1 << _SH_ARROW), MOD_MASK_SAG);
const key_override_t DOWN_NO_CTRL = ko_make_with_layers_and_negmods(MOD_MASK_CTRL, KC_DOWN, KC_DOWN, 0xFF & ~(1 << _SH_ARROW), MOD_MASK_SAG);
const key_override_t GRV_TO_TAB_FORWARD = ko_make_basic(TABBING_TRIGGER_MODS, KC_GRV, TAB_FORWARD);
const key_override_t GRV_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_GRV, KC_GRV);
const key_override_t LPRN_TO_LABK = ko_make_with_layers(MOD_MASK_SHIFT, KC_LPRN, KC_LABK, 1 << _SYM | 1 << _NUM);
const key_override_t RPRN_TO_RABK = ko_make_with_layers(MOD_MASK_SHIFT, KC_RPRN, KC_RABK, 1 << _SYM | 1 << _NUM);
const key_override_t DOWN_TO_ZOOM_OUT = ko_make_basic(MOD_MASK_CTRL, DOWN, C(KC_MINS));
const key_override_t DOWN_DEFAULT = ko_make_basic(0, DOWN, KC_DOWN);
const key_override_t UP_TO_ZOOM_IN = ko_make_basic(MOD_MASK_CTRL, UP, C(KC_EQL));
const key_override_t UP_DEFAULT = ko_make_basic(0, UP, KC_UP);
// NUM layer
// noshifts
const key_override_t ONE_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_1, KC_1);
const key_override_t TWO_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_2, KC_2);
const key_override_t THREE_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_3, KC_3);
const key_override_t FOUR_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_4, KC_4);
const key_override_t FIVE_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_5, KC_5);
const key_override_t SIX_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_6, KC_6);
const key_override_t SEVEN_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_7, KC_7);
const key_override_t EIGHT_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_8, KC_8);
const key_override_t NINE_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_9, KC_9);
const key_override_t ZERO_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_0, KC_0);
const key_override_t LOW_6_TO_Z = ko_make_basic(MOD_MASK_CTRL, LOW_6, C(KC_Z));
const key_override_t LOW_6_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_6, KC_6);
const key_override_t LOW_6_DEFAULT = ko_make_basic(0, LOW_6, KC_6);
const key_override_t LOW_7_TO_X = ko_make_basic(MOD_MASK_CTRL, LOW_7, C(KC_X));
const key_override_t LOW_7_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_7, KC_7);
const key_override_t LOW_7_DEFAULT = ko_make_basic(0, LOW_7, KC_7);
const key_override_t LOW_8_TO_C = ko_make_basic(MOD_MASK_CTRL, LOW_8, C(KC_C));
const key_override_t LOW_8_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_8, KC_8);
const key_override_t LOW_8_DEFAULT = ko_make_basic(0, LOW_8, KC_8);
const key_override_t LOW_9_TO_V = ko_make_basic(MOD_MASK_CTRL, LOW_9, C(KC_V));
const key_override_t LOW_9_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_9, KC_9);
const key_override_t LOW_9_DEFAULT = ko_make_basic(0, LOW_9, KC_9);
const key_override_t LOW_0_TO_B = ko_make_basic(MOD_MASK_CTRL, LOW_0, C(KC_B));
const key_override_t LOW_0_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_0, KC_0);
const key_override_t LOW_0_DEFAULT = ko_make_basic(0, LOW_0, KC_0);
// minus -
const key_override_t MINUS_TO_R = ko_make_with_layers(MOD_MASK_CTRL, KC_MINS, C(KC_R), 1 << _NUM);
const key_override_t MINUS_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_MINS, KC_MINS);
// multiply symbol (prevents conflict with ASTR) *
const key_override_t MULT_DEFAULT = ko_make_basic(0, MULT, KC_ASTR);
// circ ^
const key_override_t CIRC_TO_Y = ko_make_basic(MOD_MASK_CTRL, KC_CIRC, C(KC_Y));
// ampr &
const key_override_t AMPR_TO_U = ko_make_basic(MOD_MASK_CTRL, KC_AMPR, C(KC_U));
// astr *
const key_override_t ASTR_TO_I = ko_make_basic(MOD_MASK_CTRL, KC_ASTR, C(KC_I));
// rprn (
const key_override_t RPRN_TO_P = ko_make_basic(MOD_MASK_CTRL, KC_RPRN, C(KC_P));
// coln )
const key_override_t COLN_TO_M = ko_make_with_layers(MOD_MASK_CTRL, KC_COLN, C(KC_M), 1 << _NUM);
// dlr $
const key_override_t DLR_TO_R = ko_make_with_layers(MOD_MASK_CTRL, KC_DLR, C(KC_R), 1 << _NAV);
// eql =
// \[]-=`
const key_override_t BSLS_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_BSLS, KC_BSLS);
const key_override_t LBRC_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_LBRC, KC_LBRC);
const key_override_t RBRC_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_RBRC, KC_RBRC);
const key_override_t MINS_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_MINS, KC_MINS);
const key_override_t EQL_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_EQL, KC_EQL);
// pipe |
const key_override_t PIPE_TO_Z = ko_make_with_layers(MOD_MASK_CTRL, KC_PIPE, C(KC_Z), 1 << _NAV);
// lcbr {
const key_override_t LCBR_TO_X = ko_make_with_layers(MOD_MASK_CTRL, KC_LCBR, C(KC_X), 1 << _NAV);
// rcbr }
const key_override_t RCBR_TO_C = ko_make_with_layers(MOD_MASK_CTRL, KC_RCBR, C(KC_C), 1 << _NAV);
// unds _
const key_override_t UNDS_TO_V = ko_make_with_layers(MOD_MASK_CTRL, KC_UNDS, C(KC_V), 1 << _NAV);
// plus +
const key_override_t PLUS_TO_B = ko_make_with_layers(MOD_MASK_CTRL, KC_PLUS, C(KC_B), 1 << _NAV);
// F2
const key_override_t F2_TO_M = ko_make_with_layers(MOD_MASK_CTRL, KC_F2, C(KC_M), 1 << _NAV);
const key_override_t GRV_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_GRV, KC_GRV);
// this globally defines all key overrides to be used
const key_override_t* key_overrides[] = {
&CW_CL_TO_TAB_BACKWARDS,
&COMM_TO_TAB_BACKWARDS,
&TILDE_TO_TAB_BACKWARDS,
&Q_TO_KILL,
//
&BSPC_TO_OBLITERATE,
// blocking formatting with this line
&DEL_TO_OBLITERATE,
&HOME_NOCTRL,
&HOME_TO_MEGA_HOME,
&END_NO_CTRL,
&HOME_NOCTRL,
&END_TO_META_END,
&END_NO_CTRL,
&ESC_TO_TAB_FORWARD,
&UP_NO_CTRL,
&DOWN_NO_CTRL,
&GRV_TO_TAB_FORWARD,
&GRV_NOSHIFT,
&DOWN_TO_ZOOM_OUT,
&DOWN_DEFAULT,
&UP_TO_ZOOM_IN,
&UP_DEFAULT,
&LPRN_TO_LABK,
&RPRN_TO_RABK,
// noshifts
&ONE_NOSHIFT,
&TWO_NOSHIFT,
&THREE_NOSHIFT,
&FOUR_NOSHIFT,
&FIVE_NOSHIFT,
&SIX_NOSHIFT,
&LOW_6_TO_Z,
&LOW_6_NOSHIFT,
&LOW_6_DEFAULT,
&LOW_7_TO_X,
&LOW_7_NOSHIFT,
&LOW_7_DEFAULT,
&LOW_8_TO_C,
&LOW_8_NOSHIFT,
&LOW_8_DEFAULT,
&LOW_9_TO_V,
&LOW_9_NOSHIFT,
&LOW_9_DEFAULT,
&LOW_0_TO_B,
&LOW_0_NOSHIFT,
&LOW_0_DEFAULT,
&MINUS_TO_R,
&MINUS_NOSHIFT,
&MULT_DEFAULT,
&CIRC_TO_Y,
&AMPR_TO_U,
&ASTR_TO_I,
&RPRN_TO_P,
&COLN_TO_M,
&DLR_TO_R,
&SEVEN_NOSHIFT,
&EIGHT_NOSHIFT,
&NINE_NOSHIFT,
&ZERO_NOSHIFT,
&BSLS_NOSHIFT,
&LBRC_NOSHIFT,
&RBRC_NOSHIFT,
&MINS_NOSHIFT,
&EQL_NOSHIFT,
&PIPE_TO_Z,
&LCBR_TO_X,
&RCBR_TO_C,
&UNDS_TO_V,
&PLUS_TO_B,
&F2_TO_M,
&GRV_NOSHIFT,
&GRV_NOSHIFT,
};

9
keyboards/keebio/nyquist/rev4/keymaps/drew/layers.h
View file

@ -1,9 +0,0 @@
#pragma once
enum layers {
_BASE,
_GAME,
_NUM,
_NAV,
_FUNC,
};

10
keyboards/keebio/nyquist/rev4/keymaps/drew/rules.mk
View file

@ -1,8 +1,9 @@
SRC += caps_word/caps_word.c
SRC += tap_dance/tap_dance.c
SRC += layers/layers.c
SRC += combos/combos.c
SRC += taphold/taphold_options.c
SRC += utils/utils.c
# SRC += chordal_hold/chordal_options.c
# SRC += flow_tap/flow_tap_options.c
# VIA_ENABLE = yes
LTO_ENABLE = yes
@ -13,5 +14,6 @@ CAPS_WORD_ENABLE = yes
TAP_DANCE_ENABLE = yes
KEY_OVERRIDE_ENABLE = yes
RGBLIGHT_ENABLE = no # turn off RGB lights
COMBO_ENABLE = yes
qwfpbarstgzxcdvjluy'mneiokh,./
NKRO_ENABLE = yes

27
keyboards/keebio/nyquist/rev4/keymaps/drew/tap_dance/tap_dance.c
View file

@ -1,4 +1,3 @@
#include QMK_KEYBOARD_H
#include "./tap_dance.h"
#include "../alias.h"
@ -12,33 +11,7 @@ void CAD_lock_sleep(tap_dance_state_t* state, void*) {
break;
case 3:
tap_code16(KC_SLEP);
default:
reset_tap_dance(state);
break;
}
}
void caps_lock_caps_word_on_tap(tap_dance_state_t* state, void*) {
switch (state->count) {
case 1: // do nothing for the first tap
break;
default:
tap_code(KC_CAPS);
break;
}
}
void caps_lock_caps_word_on_finish(tap_dance_state_t* state, void*) {
switch (state->count) {
case 1:
caps_word_toggle();
break;
}
}
tap_dance_action_t tap_dance_actions[] = {
[TD_CAD_LOCK_SLEEP] = ACTION_TAP_DANCE_FN(CAD_lock_sleep),
[TD_CW_CL] = ACTION_TAP_DANCE_FN_ADVANCED(
caps_lock_caps_word_on_tap, caps_lock_caps_word_on_finish, NULL
),
};

5
keyboards/keebio/nyquist/rev4/keymaps/drew/tap_dance/tap_dance.h
View file

@ -1,6 +1,9 @@
#pragma once
#include QMK_KEYBOARD_H
enum {
TD_CAD_LOCK_SLEEP,
TD_CW_CL,
};
void CAD_lock_sleep(tap_dance_state_t* state, void*);

144
keyboards/keebio/nyquist/rev4/keymaps/drew/taphold/taphold_options.c
View file

@ -5,135 +5,29 @@
uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
case GUI_LAUNCH:
case NUM_SPC:
case NAV_ENT:
case FUNC_PLAY: // no repeat tapping for these keys
case GUI_A:
case ALT_S:
case CTL_D:
case SFT_F:
case GUI_SCLN:
case ALT_L:
case CTL_K:
case SFT_J:
case GUI_BSLS:
case ALT_LBRC:
case CTL_RBRC:
case SFT_MINS:
// intentionally omitting arrow keys
case GUI_1:
case ALT_2:
case CTL_3:
case SFT_4:
case GUI_0:
case ALT_9:
case CTL_8:
case SFT_7: // no repeat tapping for homerow mods
case NAV_TAB:
case SYM_BSPC:
return 0;
break;
}
return QUICK_TAP_TERM;
}
bool get_permissive_hold(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
case NUM_SPC: // permissive hold for layer tap space
return true;
break;
// TODO: remove
// bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t* record) {
// switch (keycode) {
// case NUM_SPC:
// return false;
// break;
// }
// return true;
// }
case GUI_A:
case ALT_S:
case CTL_D:
case SFT_F:
case GUI_SCLN:
case ALT_L:
case CTL_K:
case SFT_J:
case GUI_BSLS:
case ALT_LBRC:
case CTL_RBRC:
case SFT_MINS:
case GUI_RGHT:
case ALT_UP:
case CTL_DOWN:
case SFT_LEFT:
case GUI_1:
case ALT_2:
case CTL_3:
case SFT_4:
case GUI_0:
case ALT_9:
case CTL_8:
case SFT_7: // permissive hold for mod-taps
return true;
break;
}
return false;
}
bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
case NUM_SPC: // no hold on other key press for layer tap space
return false;
break;
case GUI_A:
case ALT_S:
case CTL_D:
case SFT_F:
case GUI_SCLN:
case ALT_L:
case CTL_K:
case SFT_J:
case GUI_BSLS:
case ALT_LBRC:
case CTL_RBRC:
case SFT_MINS:
case GUI_RGHT:
case ALT_UP:
case CTL_DOWN:
case SFT_LEFT:
case GUI_1:
case ALT_2:
case CTL_3:
case SFT_4:
case GUI_0:
case ALT_9:
case CTL_8:
case SFT_7: // no hold on other key press for mod taps
return false;
break;
}
return true;
}
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
case ALT_S:
case ALT_L:
case ALT_2:
case ALT_9:
case ALT_LBRC:
case ALT_UP:
case GUI_A:
case GUI_SCLN:
case GUI_1:
case GUI_0:
case GUI_BSLS:
case GUI_RGHT: // alt and gui have events for a hold and release
case GUI_LAUNCH: // also non-homerow mod-taps
return 400;
break;
}
return TAPPING_TERM;
}
// bool get_permissive_hold(uint16_t keycode, keyrecord_t* record) {
// switch (keycode) {
// case NUM_SPC:
// return true;
// break;
// }
// return false;
// }

5
keyboards/keebio/nyquist/rev4/keymaps/drew/utils/utils.h
View file

@ -1,8 +1,8 @@
#pragma once
#include QMK_KEYBOARD_H
#include "stdbool.h"
#include "stdint.h"
#include <stdbool.h>
#include <stdint.h>
/// @brief Obliterate a line of text.
/// @param key_down Whether the key was pressed down.
@ -51,4 +51,3 @@ bool unshift_register_or_ctrl_fallthrough(
/// @param record The current `keyrecord_t`.
/// @return Whether processing of the key should continue.
bool unshift_register(uint8_t keycode, keyrecord_t* record);