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-29 20:54:18 -04:00
Code Issues Projects Releases Packages Wiki Activity

Implemented all the home row stuff. This is wacky

Browse source
This commit is contained in:
Drew Whitney 2025-11-02 22:50:51 -07:00
commit a4b85513a6
10 changed files with 344 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -15,6 +15,8 @@ enum CustomKeycodes {
LOW_0,
MULT, // avoids a conflict with KC_ASTR
CAPS_WORD,
};
// keys
@ -25,22 +27,50 @@ enum CustomKeycodes {
#define TAB_FORWARD C(KC_TAB)
#define TAB_BACKWARD (C(S(KC_TAB)))
// weird tap holds
#define CW_CL SFT_T(CAPS_WORD)
// layers
#define NUM_SPC LT(_NUM, KC_SPC)
#define NAV_ENT LT(_NAV, KC_ENT)
#define FUNC_PLAY LT(_FUNC, KC_MPLY)
// mod-tap
// 8-bit tap key
#define SFT_DEL RSFT_T(KC_DEL)
#define L_SFT SFT_T(KC_LSFT)
#define SFT_COMM SFT_T(KC_COMM)
#define ALT_COMP ALT_T(KC_RALT)
// 16-bit tap key
#define SFT_TILD SFT_T(KC_TILD)
#define CTL_COLN CTL_T(KC_COLN)
#define GUI_LAUNCH GUI_T(LAUNCH)
// 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 GUI_T(KC_S)
#define SFT_D SFT_T(KC_D)
#define CTL_F CTL_T(KC_F)
#define CTL_G CTL_T(KC_G)
#define GUI_SCLN GUI_T(KC_SCLN)
#define ALT_L ALT_T(KC_L)
#define SFT_K RSFT_T(KC_K)
#define CTL_J CTL_T(KC_J)
#define CTL_H CTL_T(KC_H)
// nav layer
#define GUI_BSLS GUI_T(KC_BSLS)
#define ALT_LBRC ALT_T(KC_LBRC)
#define SFT_RBRC SFT_T(KC_RBRC)
#define CTL_MINS CTL_T(KC_MINS)
#define GUI_RGHT GUI_T(KC_RGHT)
#define ALT_UP ALT_T(KC_UP)
#define SFT_DOWN RSFT_T(KC_DOWN)
#define CTL_LEFT CTL_T(KC_LEFT)
// num layer
#define GUI_1 GUI_T(KC_1)
#define ALT_2 ALT_T(KC_2)
#define SFT_3 SFT_T(KC_3)
#define CTL_4 CTL_T(KC_4)
#define GUI_0 GUI_T(KC_0)
#define ALT_9 ALT_T(KC_9)
#define SFT_8 RSFT_T(KC_8)
#define CTL_7 CTL_T(KC_7)

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

@ -25,4 +25,3 @@ bool caps_word_press_user(uint16_t keycode) {
break;
}
}

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

@ -0,0 +1,15 @@
// 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 Normal file
View file

@ -0,0 +1,9 @@
#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
);

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

@ -21,7 +21,6 @@
#define SPLIT_USB_TIMEOUT 20000
// -------------------------------------------------------------------------------------------------
// #define DYNAMIC_KEYMAP_LAYER_COUNT 5
@ -33,6 +32,7 @@
#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY
#define PERMISSIVE_HOLD_PER_KEY
#define TAPPING_TERM_PER_KEY
// #define CHORDAL_HOLD
#define CAPS_WORD_IDLE_TIMEOUT 0

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

@ -3,41 +3,50 @@
#include "./layers.h"
#include "./tap_dance/tap_dance.c"
#include "./tap_dance/tap_dance.h"
#include "./taphold/taphold_options.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
// 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,
CTL_T(KC_TAB), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
L_SFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, SFT_DEL,
KC_NO, FUNC_PLAY, ALT_T(KC_LALT), TD(TD_CAD_LOCK_SLEEP), GUI_LAUNCH, NUM_SPC, NAV_ENT, ALT_COMP, KC_LEFT, DOWN, UP, KC_RGHT
KC_TAB, GUI_A, ALT_S, SFT_D, CTL_F, CTL_G, CTL_H, CTL_J, SFT_K, ALT_L, GUI_SCLN, KC_QUOT,
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, ALT_T(KC_LALT), TD(TD_CAD_LOCK_SLEEP), LAUNCH, NUM_SPC, NAV_ENT, KC_RALT, KC_LEFT, DOWN, UP, KC_RGHT
),
// gamer
[_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_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_F, KC_G, 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
),
// special characters
// 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,
CTL_T(KC_DOT), KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_TRNS,
SFT_COMM, LOW_6, LOW_7, LOW_8, LOW_9, LOW_0, KC_SCLN, KC_COLN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
CTL_COLN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
KC_DOT, GUI_1, ALT_2, SFT_3, CTL_4, KC_5, KC_6, CTL_7, SFT_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, KC_BSLS, KC_LBRC, KC_RBRC, KC_MINS, KC_EQL, KC_HOME, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_END,
SFT_TILD, KC_PIPE, KC_LCBR, KC_RCBR, KC_UNDS, KC_PLUS, KC_NO, KC_F2, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_TRNS, GUI_BSLS, ALT_LBRC, SFT_RBRC, CTL_MINS, KC_EQL, KC_HOME, CTL_LEFT, SFT_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
@ -52,6 +61,35 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
bool process_record_user(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
case CW_CL: { // caps word is really complicated, eek
static bool tab_backward_held = false;
if (record->tap.count) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & TABBING_TRIGGER_MODS) { // tabbing
del_mods(TABBING_TRIGGER_MODS);
register_code16(TAB_BACKWARD);
set_mods(mods);
tab_backward_held = true; // set the flag
} else { // caps word
caps_word_toggle();
}
} else {
if (tab_backward_held) {
tab_backward_held = false; // clear the flag
unregister_code16(TAB_BACKWARD);
neutralize_flashing_mods();
}
}
} else { // hold; caps lock
if (record->event.pressed) {
tap_code(KC_CAPS);
}
}
return false;
break;
}
// make it possible to go from layer 3 to layer 2
case NUM_SPC:
if (!record->tap.count) {
@ -77,119 +115,52 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
}
break;
case GUI_LAUNCH:
if (record->tap.count && record->event.pressed) {
tap_code16(LAUNCH);
return false;
}
// 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 CTL_4:
return unshift_register_or_ctrl_fallthrough(keycode, KC_F, record);
break;
case CTL_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 CTL_MINS:
return unshift_register_or_ctrl_fallthrough(keycode, KC_F, record);
break;
case SFT_DEL:
if (record->tap.count) { // only trigger on taps, not holds
uint8_t mods = get_mods();
if (mods & OBLITERATE_TRIGGER_MODS) { // obliterate line forwards
if (record->event.pressed) {
del_mods(OBLITERATE_TRIGGER_MODS);
tap_code16(S(KC_END));
register_code(KC_DEL);
set_mods(mods);
return false;
} else {
neutralize_flashing_mods();
}
} else if (mods & MOD_MASK_SHIFT) { // caps lock
if (record->event.pressed) {
tap_code(KC_CAPS);
}
return false;
}
}
case SFT_3:
case GUI_0:
case SFT_8:
case ALT_9:
case SFT_RBRC: // no control override, just unshift
return unshift_register(keycode, record);
break;
case L_SFT: {
static bool tab_backward_held = false;
if (record->tap.count) {
// make arrow key homerow mods trigger the tap action when held and the hold time expires
case GUI_RGHT:
case ALT_UP:
case SFT_DOWN:
case CTL_LEFT:
// if this is a hold action and it occurred naturally
if (!record->tap.count && !record->tap.interrupted) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & TABBING_TRIGGER_MODS) { // tabbing
del_mods(TABBING_TRIGGER_MODS);
register_code16(TAB_BACKWARD);
set_mods(mods);
tab_backward_held = true; // set the flag
} else if (mods & MOD_MASK_SHIFT) { // caps lock
tap_code(KC_CAPS);
} else { // caps word
caps_word_toggle();
}
register_code(keycode);
return false;
} else {
if (tab_backward_held) {
tab_backward_held = false; // clear the flag
unregister_code16(TAB_BACKWARD);
neutralize_flashing_mods();
return false;
}
unregister_code(keycode);
}
}
break;
}
case SFT_TILD: {
static bool tab_backward_held = false;
if (record->tap.count) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & TABBING_TRIGGER_MODS) { // tabbing
del_mods(TABBING_TRIGGER_MODS);
register_code16(TAB_BACKWARD);
set_mods(mods);
tab_backward_held = true; // set the flag
} else { // TILDE is 16-bit
register_code16(KC_TILD);
}
} else {
if (tab_backward_held) {
tab_backward_held = false; // clear the flag
unregister_code16(TAB_BACKWARD);
neutralize_flashing_mods();
} else {
unregister_code16(KC_TILD);
}
}
return false;
}
break;
}
case SFT_COMM: {
static bool tab_backward_held = false;
if (record->tap.count) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & TABBING_TRIGGER_MODS) { // tabbing
del_mods(TABBING_TRIGGER_MODS);
register_code16(TAB_BACKWARD);
set_mods(mods);
tab_backward_held = true; // set the flag
return false;
}
} else {
if (tab_backward_held) {
unregister_code16(TAB_BACKWARD);
neutralize_flashing_mods();
return false;
}
}
}
break;
}
case CTL_COLN: // COLN is 16-bit
if (record->tap.count) {
(record->event.pressed ? register_code16 : unregister_code16)(KC_COLN);
return false;
}
break;
// make it so only the opposite-side shift key works
case KC_Q:
@ -197,11 +168,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
case KC_E:
case KC_R:
case KC_T:
case KC_A:
case KC_S:
case KC_D:
case KC_F:
case KC_G:
case KC_Z:
case KC_X:
case KC_C:
@ -212,16 +178,21 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
}
break;
case GUI_A:
case ALT_S:
case SFT_D:
case CTL_F:
case CTL_G:
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_J:
case KC_K:
case KC_L:
case KC_SCLN:
case KC_QUOT:
case KC_N:
case KC_M:
@ -232,12 +203,26 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
return false; // do nothing
}
break;
case GUI_SCLN:
case ALT_L:
case SFT_K:
case CTL_J:
case CTL_H:
if (record->event.pressed && record->tap.count && get_mods() == MOD_BIT(KC_RSFT)) {
return false; // do nothing
}
break;
}
return true;
}
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,
@ -245,6 +230,13 @@ const key_override_t BSPC_TO_OBLITERATE = {
.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,
.layers = 0xFF,
.custom_action = obliterate_line_forwards,
.suppressed_mods = OBLITERATE_TRIGGER_MODS,
};
const key_override_t HOME_NOCTRL = ko_make_basic(MOD_MASK_CTRL, KC_HOME, KC_HOME);
const key_override_t HOME_TO_MEGA_HOME = ko_make_basic(MOD_MASK_GUI, KC_HOME, C(KC_HOME));
@ -263,31 +255,6 @@ 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
const key_override_t ONE_TO_A = ko_make_with_layers(MOD_MASK_CTRL, KC_1, C(KC_A), 1 << _NUM);
const key_override_t ONE_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_1, KC_1);
const key_override_t TWO_TO_S = ko_make_with_layers(MOD_MASK_CTRL, KC_2, C(KC_S), 1 << _NUM);
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_TO_F = ko_make_with_layers(MOD_MASK_CTRL, KC_4, C(KC_F), 1 << _NUM);
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_TO_H = ko_make_with_layers(MOD_MASK_CTRL, KC_6, C(KC_H), 1 << _NUM);
const key_override_t SIX_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_6, KC_6);
const key_override_t SEVEN_TO_J = ko_make_with_layers(MOD_MASK_CTRL, KC_7, C(KC_J), 1 << _NUM);
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);
@ -310,7 +277,6 @@ 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_TO_F = ko_make_with_layers(MOD_MASK_CTRL, KC_MINS, C(KC_F), 1 << _NAV);
const key_override_t MINUS_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_MINS, KC_MINS);
// multiply symbol (prevents conflict with ASTR) *
@ -334,17 +300,6 @@ const key_override_t COLN_TO_M = ko_make_with_layers(MOD_MASK_CTRL, KC_COLN, C(K
// dlr $
const key_override_t DLR_TO_R = ko_make_with_layers(MOD_MASK_CTRL, KC_DLR, C(KC_R), 1 << _NAV);
// bsls
const key_override_t BSLS_TO_A = ko_make_with_layers(MOD_MASK_CTRL, KC_BSLS, C(KC_A), 1 << _NAV);
const key_override_t BSLS_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_BSLS, KC_BSLS);
// lbrc [
const key_override_t LBRC_TO_S = ko_make_with_layers(MOD_MASK_CTRL, KC_LBRC, C(KC_S), 1 << _NAV);
const key_override_t LBRC_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_LBRC, KC_LBRC);
// rbrc ]
const key_override_t RBRC_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_RBRC, KC_RBRC);
// eql =
const key_override_t EQL_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_EQL, KC_EQL);
@ -368,9 +323,12 @@ const key_override_t F2_TO_M = ko_make_with_layers(MOD_MASK_CTRL, KC_F2, C(KC_M)
// this globally defines all key overrides to be used
const key_override_t* key_overrides[] = {
&COMM_TO_TAB_BACKWARDS,
&TILDE_TO_TAB_BACKWARDS,
&Q_TO_KILL,
//
&BSPC_TO_OBLITERATE,
&DEL_TO_OBLITERATE,
&HOME_NOCTRL,
&HOME_TO_MEGA_HOME,
@ -387,21 +345,6 @@ const key_override_t* key_overrides[] = {
&UP_TO_ZOOM_IN,
&UP_DEFAULT,
&ONE_TO_A,
&ONE_NOSHIFT,
&TWO_TO_S,
&TWO_NOSHIFT,
&THREE_NOSHIFT,
&FOUR_TO_F,
&FOUR_NOSHIFT,
&FIVE_NOSHIFT,
&SIX_TO_H,
&SIX_NOSHIFT,
&SEVEN_TO_J,
&SEVEN_NOSHIFT,
&EIGHT_NOSHIFT,
&NINE_NOSHIFT,
&ZERO_NOSHIFT,
&LOW_6_TO_Z,
&LOW_6_NOSHIFT,
&LOW_6_DEFAULT,
@ -419,7 +362,6 @@ const key_override_t* key_overrides[] = {
&LOW_0_DEFAULT,
&MINUS_TO_R,
&MINUS_TO_F,
&MINUS_NOSHIFT,
&MULT_DEFAULT,
@ -436,14 +378,6 @@ const key_override_t* key_overrides[] = {
&DLR_TO_R,
&BSLS_TO_A,
&BSLS_NOSHIFT,
&LBRC_TO_S,
&LBRC_NOSHIFT,
&RBRC_NOSHIFT,
&EQL_NOSHIFT,
&PIPE_TO_Z,

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

@ -1,6 +1,7 @@
SRC += caps_word/caps_word.c
SRC += taphold/taphold_options.c
SRC += utils/utils.c
# SRC += chordal_hold/chordal_options.c
# VIA_ENABLE = yes
LTO_ENABLE = yes

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

@ -7,9 +7,34 @@ uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record) {
case CTL_T(KC_TAB):
case NUM_SPC:
case NAV_ENT:
case GUI_LAUNCH:
case FUNC_PLAY:
return 0; // no repeat tapping when tapped and then held for these keys
case FUNC_PLAY: // no repeat tapping for these keys
case GUI_A:
case ALT_S:
case SFT_D:
case CTL_F:
case CTL_G:
case GUI_SCLN:
case ALT_L:
case SFT_K:
case CTL_J:
case CTL_H:
case GUI_1:
case ALT_2:
case SFT_3:
case CTL_4:
case GUI_0:
case ALT_9:
case SFT_8:
case CTL_7:
case GUI_BSLS:
case ALT_LBRC:
case SFT_RBRC:
case CTL_MINS: // no repeat tapping for homerow mods
// intentionally omitting arrow keys
return 0;
break;
}
return QUICK_TAP_TERM;
@ -20,6 +45,36 @@ bool get_permissive_hold(uint16_t keycode, keyrecord_t* record) {
case NUM_SPC: // permissive hold for layer tap space
return true;
break;
case GUI_A:
case ALT_S:
case SFT_D:
case CTL_F:
case CTL_G:
case GUI_SCLN:
case ALT_L:
case SFT_K:
case CTL_J:
case CTL_H:
case GUI_1:
case ALT_2:
case SFT_3:
case CTL_4:
case GUI_0:
case ALT_9:
case SFT_8:
case CTL_7:
case GUI_BSLS:
case ALT_LBRC:
case SFT_RBRC:
case CTL_MINS: // permissive hold for homerow mods
case GUI_RGHT:
case ALT_UP:
case SFT_DOWN:
case CTL_LEFT:
return true;
break;
}
return false;
}
@ -29,13 +84,56 @@ bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t* record) {
case NUM_SPC: // no hold on other key press for layer tap space
return false;
break;
case GUI_A:
case ALT_S:
case SFT_D:
case CTL_F:
case CTL_G:
case GUI_SCLN:
case ALT_L:
case SFT_K:
case CTL_J:
case CTL_H:
case GUI_1:
case ALT_2:
case SFT_3:
case CTL_4:
case GUI_0:
case ALT_9:
case SFT_8:
case CTL_7:
case GUI_BSLS:
case ALT_LBRC:
case SFT_RBRC:
case CTL_MINS: // no hold on other key press for homerow mods
case GUI_RGHT:
case ALT_UP:
case SFT_DOWN:
case CTL_LEFT:
return false;
break;
}
return true;
}
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
case GUI_LAUNCH:
case GUI_A:
case GUI_SCLN:
case GUI_1:
case GUI_0:
case GUI_BSLS:
case GUI_RGHT:
case ALT_S:
case ALT_L:
case ALT_2:
case ALT_9:
case ALT_LBRC: // alt and gui have events for a hold and release
case ALT_UP:
return 400;
break;
}

41
keyboards/keebio/nyquist/rev4/keymaps/drew/utils/utils.c
View file

@ -1,4 +1,3 @@
#include QMK_KEYBOARD_H
#include "./utils.h"
bool obliterate_line(bool key_down, uint8_t deletion_keycode, uint8_t movement_keycode) {
@ -19,7 +18,43 @@ bool obliterate_line_forwards(bool key_down, void* _) {
return obliterate_line(key_down, KC_DEL, KC_END);
}
bool turn_on_caps_word(bool key_down, void* _) {
caps_word_on();
bool toggle_caps_word(bool key_down, void* _) {
caps_word_toggle();
return false;
}
bool unshift_register_or_ctrl_fallthrough(
uint8_t keycode, uint8_t control_keycode, keyrecord_t* record
) {
if (record->tap.count) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & MOD_MASK_CTRL) {
register_code(control_keycode);
return false;
} else if (mods & MOD_MASK_SHIFT) {
del_mods(MOD_MASK_SHIFT); // remove shift
// register the code. This is fine because you will just chop to the 8-bit keycode
register_code(keycode);
set_mods(mods); // re-add shift
return false;
}
} else {
unregister_code(control_keycode);
}
}
return true;
}
bool unshift_register(uint8_t keycode, keyrecord_t* record) {
if (record->tap.count && record->event.pressed) {
uint8_t mods = get_mods();
if (mods & MOD_MASK_SHIFT) {
del_mods(MOD_MASK_SHIFT);
register_code(keycode);
set_mods(mods);
return false;
}
}
return true;
}

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

@ -1,5 +1,6 @@
#pragma once
#include QMK_KEYBOARD_H
#include "stdbool.h"
#include "stdint.h"
@ -26,11 +27,27 @@ bool obliterate_line_forwards(bool key_down, void* _);
/// @param key_down Whether the key was pressed down.
/// @param _ Unused.
/// @return Always returns `false`.
bool turn_on_caps_word(bool key_down, void* _);
bool toggle_caps_word(bool key_down, void* _);
/// @brief Neutralize flashing modifiers (Alt and Super) if they are active.
static inline void neutralize_flashing_mods(void) {
if (get_mods() & MOD_MASK_AG) {
tap_code(DUMMY_MOD_NEUTRALIZER_KEYCODE);
}
} // have to define this here because it is inline
} // have to define this here because it is inline
/// @brief If control is held, register the control keycode. Otherwise, if shift is being held,
/// register the key without shift. Otherwise, register the key normally.
/// @param keycode The keycode being processed.
/// @param ctrl_keycode The keycode to register if control is being held.
/// @param record The current `keyrecord_t`.
/// @return Whether processing of the key should continue.
bool unshift_register_or_ctrl_fallthrough(
uint8_t keycode, uint8_t ctrl_keycode, keyrecord_t* record
);
/// @brief Register a keycode without shift.
/// @param keycode The keycode being processed.
/// @param record The current `keyrecord_t`.
/// @return Whether processing of the key should continue.
bool unshift_register(uint8_t keycode, keyrecord_t* record);