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-30 05:04:19 -04:00
Code Issues Projects Releases Packages Wiki Activity

Finished porting over to the key override system. Woo!

Browse source
This commit is contained in:
Drew Whitney 2025-11-01 19:30:34 -06:00
commit 623b2bafc6
10 changed files with 268 additions and 444 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -0,0 +1,46 @@
#pragma once
#include QMK_KEYBOARD_H
#include "./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
};
// 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)))
// 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

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

@ -1,5 +1,6 @@
#include QMK_KEYBOARD_H
#include "caps_word.h"
#include "../alias.h"
bool caps_word_press_user(uint16_t keycode) {
switch (keycode) {
@ -10,17 +11,18 @@ 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:
case KC_RGHT:
case KC_MINS:
case KC_UNDS:
// custom keycodes
return true;
break;
default:
return false; // Deactivate Caps Word
break;
}
}
}

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

@ -19,16 +19,13 @@
#define I2C0_SDA_PIN GP4
#define I2C0_SCL_PIN GP5m
#define SPLIT_USB_TIMEOUT 20000
// -------------------------------------------------------------------------------------------------
// #define DYNAMIC_KEYMAP_LAYER_COUNT 5
// stuff I added
#define MAX_REMAPS_PER_CUSTOM_KEY 2
// end stuff I added
#define SPLIT_USB_TIMEOUT 20000
#define TAPPING_TERM 200
#define QUICK_TAP_TERM_PER_KEY
@ -44,6 +41,3 @@
// disable some features to make the code smaller
#define NO_ACTION_ONESHOT
// delete later; tap dance
#define TAPPING_TERM_PER_KEY

120
keyboards/keebio/nyquist/rev4/keymaps/drew/custom_keys/custom_keys.c
View file

@ -1,120 +0,0 @@
#include "custom_keys.h"
#include "../caps_word/caps_word.h"
#include "mapping.h"
void suppress_flashing_mods_needed(uint8_t mods_to_check, uint8_t active_mods) {
if (mods_to_check & MOD_MASK_AG) {
suppress_flashing_mods(active_mods);
}
}
void update_held_keycode(custom_key_t* custom_key, uint16_t keycode) {
custom_key->held_keycode = keycode;
}
void handle_caps_word(uint16_t keycode) {
if (is_caps_word_on()) {
if (!caps_word_press_user(keycode)) {
caps_word_off();
}
}
}
void do_keycode(uint16_t keycode, custom_key_t* custom_key) {
handle_caps_word(keycode);
register_code16(keycode);
update_held_keycode(custom_key, keycode);
}
void do_action(key_remap_t* remap, custom_key_t* custom_key) {
// handle the dynamic typing of replacement_action
if (remap->options.action_is_function) {
void (*action)(custom_key_t*) = remap->replacement_action;
action(custom_key);
} else {
uint16_t* keycode = remap->replacement_action;
do_keycode(*keycode, custom_key);
}
}
void register_default_keycode(custom_key_t* custom_key) {
uint16_t* keycode = custom_key->default_action;
do_keycode(*keycode, custom_key);
}
void run_default_fn(custom_key_t* custom_key) {
void (*action)(custom_key_t*) = custom_key->default_action;
action(custom_key);
}
void process_remaps(
custom_key_t* custom_key, keyrecord_t* record, void (*default_fn)(custom_key_t*)
) {
if (record->event.pressed) { // key down
for (uint8_t i = 0; i < custom_key->num_remaps; i++) {
key_remap_t* remap = &(custom_key->remaps)[i];
key_remap_options_t* options = &remap->options;
// determine whether there is a mod match
bool match;
uint8_t mods = get_mods();
if (options->exact_match) {
match = (mods == remap->trigger_mods);
} else {
match = (mods & remap->trigger_mods);
}
// if any of the trigger_mods are active AND none of the negative mods are active
if (match && !(mods & remap->negative_mods)) {
// determine if we need to remove any mods
switch (options->mod_removal_mode) {
case REMOVE_TRIGGER:
// if Alt or GUI are in the trigger mods, suppress them
suppress_flashing_mods_needed(remap->trigger_mods, mods);
del_mods(remap->trigger_mods);
break;
case REMOVE_ALL:
// if Alt or GUI are active, suppress them
suppress_flashing_mods_needed(mods, mods);
clear_mods();
break;
}
// register the replacement/perform the function
do_action(remap, custom_key);
set_mods(mods);
return; // do not process more remaps
}
}
// if none of the remaps trigger, register the default keycode/run the default function
default_fn(custom_key);
} else { // key up
unregister_code16(custom_key->held_keycode);
neutralize_mods_on_release(); // necessary for flashing mods
}
}
bool process_custom_taphold(uint16_t custom_keycode, keyrecord_t* record) {
// only trigger a remap on a tap, not a hold
if (record->tap.count) {
// get the index from the tap-hold keycode
uint8_t index = (custom_keycode & 0b11111111) - ((SAFE_RANGE) & 0b11111111);
custom_key_t* custom_key = &custom_keys[index];
switch (index) {
case KEYCODE_RANGE:
process_remaps(custom_key, record, register_default_keycode);
break;
case FUNCTION_RANGE:
process_remaps(custom_key, record, run_default_fn);
break;
}
return false;
}
return true;
}
void process_custom_key(uint16_t custom_keycode, keyrecord_t* record) {
// subtract SAFE_RANGE to get an index that starts at 0
custom_key_t* custom_key = &custom_keys[custom_keycode - SAFE_RANGE];
process_remaps(custom_key, record, register_default_keycode);
}

104
keyboards/keebio/nyquist/rev4/keymaps/drew/custom_keys/custom_keys.h
View file

@ -1,104 +0,0 @@
#pragma once
#include QMK_KEYBOARD_H
#include "../common.h"
#include "../utils/mod_suppression.h"
#include "alias.h"
// -------------------------------------------------------------------------------------------------
#define CUSTOM_KEY_RANGE NK(NK_Q)... NK(NK_LAST)
#define KEYCODE_RANGE TH_DEL... TH_COLN
#define FUNCTION_RANGE TH_LAUNCH
#define NK(keycode) keycode + SAFE_RANGE
// -------------------------------------------------------------------------------------------------
typedef struct {
// 0 = do not change current mods, 1 = remove just trigger mods, 2 = remove all mods
uint8_t mod_removal_mode;
// true = mods must match exactly, false = only one match is required
bool exact_match;
// whether replacement_action is a function or a keycode
bool action_is_function;
} key_remap_options_t;
typedef struct {
void* replacement_action;
uint8_t trigger_mods;
uint8_t negative_mods;
key_remap_options_t options;
} key_remap_t;
typedef struct {
void* default_action; // the action to perform if none of the remaps trigger
uint16_t held_keycode; // the currently held keycode
uint8_t num_remaps; // how many entries are in remaps[]
// an array containing remaps that dictate how the key is handles based on the mod state
key_remap_t remaps[MAX_REMAPS_PER_CUSTOM_KEY];
} custom_key_t;
// -------------------------------------------------------------------------------------------------
void update_held_keycode(custom_key_t* custom_key, uint16_t keycode);
void process_custom_key(uint16_t custom_keycode, keyrecord_t* record);
bool process_custom_taphold(uint16_t custom_keycode, keyrecord_t* record);
// -------------------------------------------------------------------------------------------------
enum {
NO_CHANGE,
REMOVE_TRIGGER,
REMOVE_ALL
};
// -------------------------------------------------------------------------------------------------
typedef void (*remap_fn)(custom_key_t*);
#define REMAP_OPTIONS(mod_removal_mode, exact_match, action_is_function) \
{mod_removal_mode, exact_match, action_is_function}
#define REMAP_WITH_NEGATIVE_MODS_AND_OPTIONS_FN( \
replacement_action, trigger_mods, negative_mods, mod_removal_mode, exact_match \
) \
{(remap_fn)replacement_action, trigger_mods, negative_mods, \
REMAP_OPTIONS(mod_removal_mode, exact_match, true)}
#define REMAP_WITH_NEGATIVE_MODS_AND_OPTIONS( \
replacement_keycode, trigger_mods, negative_mods, mod_removal_mode, exact_match \
) \
{&(uint16_t){replacement_keycode}, trigger_mods, negative_mods, \
REMAP_OPTIONS(mod_removal_mode, exact_match, false)}
#define REMAP_WITH_NEGATIVE_MODS(replacement_keycode, trigger_mods, negative_mods) \
REMAP_WITH_NEGATIVE_MODS_AND_OPTIONS( \
replacement_keycode, trigger_mods, negative_mods, NO_CHANGE, false \
)
#define REMAP_WITH_OPTIONS(replacement_keycode, trigger_mods, mod_removal_mode, exact_match) \
REMAP_WITH_NEGATIVE_MODS_AND_OPTIONS( \
replacement_keycode, trigger_mods, 0, mod_removal_mode, exact_match \
)
#define REMAP(replacement_keycode, trigger_mods) \
REMAP_WITH_NEGATIVE_MODS(replacement_keycode, trigger_mods, 0)
#define CUSTOM_KEY(default_keycode, num_remaps, ...) \
{ \
&(uint16_t){default_keycode}, KC_NO, num_remaps, { \
__VA_ARGS__ \
} \
}
#define CUSTOM_KEY_NO_REMAP(default_keycode) {&(uint16_t){default_keycode}, 0}
#define CUSTOM_KEY_FN(default_action, num_remaps, ...) \
{ \
(void)(*)(custom_key_t*){default_action}, num_remaps, { \
__VA_ARGS__ \
} \
}
#define CUSTOM_KEY_FN_NO_REMAP(default_action) {(remap_fn)default_action, 0}
// -------------------------------------------------------------------------------------------------

60
keyboards/keebio/nyquist/rev4/keymaps/drew/custom_keys/mapping.c
View file

@ -1,60 +0,0 @@
#include "mapping.h"
void obliterate_line_backwards(custom_key_t* custom_key) {
obliterate_line(KC_BSPC);
update_held_keycode(custom_key, KC_BSPC);
}
void obliterate_line_forwards(custom_key_t* custom_key) {
obliterate_line(KC_DEL);
update_held_keycode(custom_key, KC_DEL);
}
void launch(custom_key_t* custom_key) {
tap_code16(LAUNCH);
update_held_keycode(custom_key, KC_NO);
}
void turn_on_caps_word(custom_key_t* custom_key) {
caps_word_on();
update_held_keycode(custom_key, KC_NO);
}
custom_key_t custom_keys[] = {
// _BASE layer
// _NUM layer
[NK_COLN] = CUSTOM_KEY(KC_COLN, 1, REMAP(KC_M, MOD_MASK_CTRL)),
[NK_MINS_NUM] = CUSTOM_KEY(
KC_MINS, 2, REMAP(KC_R, MOD_MASK_CTRL),
REMAP_WITH_OPTIONS(KC_MINS, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)
),
// _NAV layer
[NK_BSLS] = CUSTOM_KEY(
KC_BSLS, 2, REMAP(KC_A, MOD_MASK_CTRL),
REMAP_WITH_OPTIONS(KC_BSLS, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)
),
[NK_LBRC] = CUSTOM_KEY(
KC_LBRC, 2, REMAP(KC_S, MOD_MASK_CTRL),
REMAP_WITH_OPTIONS(KC_LBRC, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)
),
[NK_RBRC] =
CUSTOM_KEY(KC_RBRC, 1, REMAP_WITH_OPTIONS(KC_RBRC, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)),
[NK_MINS_NAV] = CUSTOM_KEY(
KC_MINS, 2, REMAP(KC_F, MOD_MASK_CTRL),
REMAP_WITH_OPTIONS(KC_MINS, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)
),
[NK_EQL] =
CUSTOM_KEY(KC_EQL, 1, REMAP_WITH_OPTIONS(KC_EQL, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)),
[NK_PIPE] = CUSTOM_KEY(KC_PIPE, 1, REMAP(KC_Z, MOD_MASK_CTRL)),
[NK_LCBR] = CUSTOM_KEY(KC_LCBR, 1, REMAP(KC_X, MOD_MASK_CTRL)),
[NK_RCBR] = CUSTOM_KEY(KC_RCBR, 1, REMAP(KC_C, MOD_MASK_CTRL)),
[NK_UNDS] = CUSTOM_KEY(KC_UNDS, 1, REMAP(KC_V, MOD_MASK_CTRL)),
[NK_PLUS] = CUSTOM_KEY(KC_PLUS, 1, REMAP(KC_B, MOD_MASK_CTRL)),
[NK_F2] = CUSTOM_KEY(KC_F2, 1, REMAP(KC_M, MOD_MASK_CTRL)),
[NK_DLR] = CUSTOM_KEY(KC_DLR, 1, REMAP(KC_Y, MOD_MASK_CTRL)),
// multiple layers
[NK_CIRC] = CUSTOM_KEY(KC_CIRC, 1, REMAP(KC_Y, MOD_MASK_CTRL)),
[NK_AMPR] = CUSTOM_KEY(KC_AMPR, 1, REMAP(KC_U, MOD_MASK_CTRL)),
[NK_ASTR] = CUSTOM_KEY(KC_ASTR, 1, REMAP(KC_I, MOD_MASK_CTRL)),
[NK_RPRN] = CUSTOM_KEY(KC_RPRN, 1, REMAP(KC_P, MOD_MASK_CTRL)),
};

109
keyboards/keebio/nyquist/rev4/keymaps/drew/custom_keys/mapping.h
View file

@ -1,109 +0,0 @@
#pragma once
#include QMK_KEYBOARD_H
#include "../alias.h"
#include "../layers.h"
#define CUSTOM_KEY_RANGE NK(NK_Q)... NK(NK_LAST)
#define KEYCODE_RANGE TH_DEL... TH_COLN
#define FUNCTION_RANGE TH_LAUNCH
#define NK(keycode) keycode + SAFE_RANGE
typedef struct {
// 0 = do not change current mods, 1 = remove just trigger mods, 2 = remove all mods
uint8_t mod_removal_mode;
// true = mods must match exactly, false = only one match is required
bool exact_match;
// whether replacement_action is a function or a keycode
bool action_is_function;
} key_remap_options_t;
typedef struct {
void* replacement_action;
uint8_t trigger_mods;
uint8_t negative_mods;
key_remap_options_t options;
} key_remap_t;
typedef struct {
void* default_action; // the action to perform if none of the remaps trigger
uint16_t held_keycode; // the currently held keycode
uint8_t num_remaps; // how many entries are in remaps[]
// an array containing remaps that dictate how the key is handles based on the mod state
key_remap_t remaps[MAX_REMAPS_PER_CUSTOM_KEY];
} custom_key_t;
// -------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------
// clang-format off
// NK stands for "new key"
enum custom_keycodes {
// _BASE layer
NK_Q,
// _NUM layer
NK_COLN,
NK_MINS_NUM,
NK_1,
NK_2,
NK_3,
NK_4,
NK_5,
NK_6,
NK_7,
NK_8,
NK_9,
NK_0,
NK_6_LOW,
NK_7_LOW,
NK_8_LOW,
NK_9_LOW,
NK_0_LOW,
// _NAV layer
NK_BSLS, // backslash
NK_LBRC, // [
NK_RBRC, // ]
NK_MINS_NAV, // -
NK_EQL, // =
NK_GRV, // `
NK_PIPE,
NK_LCBR,
NK_RCBR,
NK_UNDS,
NK_PLUS,
NK_F2,
NK_DLR,
NK_HOME,
NK_END,
// multiple layers
NK_CIRC,
NK_AMPR,
NK_ASTR,
NK_RPRN,
NK_ESC,
NK_UP,
NK_DOWN,
NK_BSPC,
// tap-hold
// default function
TH_LAUNCH,
// default keycode
TH_DEL,
TH_RALT,
TH_TILD,
TH_LSFT,
TH_COMM,
TH_COLN,
TH_SPC,
// this is always last
NK_LAST,
};
// clang-format on
// -------------------------------------------------------------------------------------------------
extern custom_key_t custom_keys[];
// -------------------------------------------------------------------------------------------------

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

@ -1,6 +1,5 @@
#include QMK_KEYBOARD_H
#include "./caps_word/caps_word.h"
#include "./custom_keys/mapping.h"
#include "./layers.h"
#include "./tap_dance/tap_dance.c"
#include "./tap_dance/tap_dance.h"
@ -11,32 +10,6 @@
bool NAV_enabled = false;
enum CustomKeycodes {
DOWN = SAFE_RANGE + 50,
UP,
LOW_6,
LOW_7,
LOW_8,
LOW_9,
LOW_0,
};
#define SFT_DEL SFT_T(KC_DEL)
#define L_SFT SFT_T(KC_LSFT)
#define ALT_COMP ALT_T(KC_RALT)
#define TABBING_TRIGGER_MODS MOD_MASK_ALT
#define OBLITERATE_TRIGGER_MODS MOD_MASK_GUI
/// @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);
}
}
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// base
@ -44,27 +17,27 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
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_RCTL, 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_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
),
// 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_LSFT, 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_PGDN, KC_PGUP, 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, KC_ASTR, KC, KC_PLUS, NK(NK_CIRC), NK(NK_AMPR), NK(NK_ASTR), KC_LPRN, NK(NK_RPRN), KC_TRNS,
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, NK(NK_COLN), KC_TRNS, KC_TRNS, KC_TRNS, 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
),
[_NAV] = LAYOUT_ortho_4x12(
KC_GRV, KC_EXLM, KC_AT, KC_HASH, NK(NK_DLR), KC_PERC, NK(NK_CIRC), NK(NK_AMPR), NK(NK_ASTR), KC_LPRN, NK(NK_RPRN), KC_TRNS,
KC_TRNS, NK(NK_BSLS), NK(NK_LBRC), NK(NK_RBRC), NK(NK_MINS_NAV), NK(NK_EQL), KC_HOME, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_END,
SFT_TILD, NK(NK_PIPE), NK(NK_LCBR), NK(NK_RCBR), NK(NK_UNDS), NK(NK_PLUS), KC_NO, NK(NK_F2), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
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, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
),
// function
@ -224,11 +197,53 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
return false;
}
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_A:
case KC_S:
case KC_D:
case KC_F:
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 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:
case KC_COMM:
case KC_DOT:
case KC_SLSH:
if (record->event.pressed && 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), _BASE + 1);
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 BSPC_TO_OBLITERATE = {
.trigger = KC_BSPC,
@ -254,23 +269,24 @@ 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);
const key_override_t ONE_TO_A = ko_make_basic(MOD_MASK_CTRL, KC_1, C(KC_A));
// 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_basic(MOD_MASK_CTRL, KC_2, C(KC_S));
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_basic(MOD_MASK_CTRL, KC_4, C(KC_F));
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_basic(MOD_MASK_CTRL, KC_6, C(KC_H));
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_basic(MOD_MASK_CTRL, KC_7, C(KC_J));
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);
@ -299,6 +315,64 @@ 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_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) *
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);
// 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);
// 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);
// this globally defines all key overrides to be used
const key_override_t* key_overrides[] = {
&Q_TO_KILL,
@ -350,4 +424,44 @@ const key_override_t* key_overrides[] = {
&LOW_0_TO_B,
&LOW_0_NOSHIFT,
&LOW_0_DEFAULT,
&MINUS_TO_R,
&MINUS_TO_F,
&MINUS_NOSHIFT,
&MULT_DEFAULT,
&CIRC_TO_Y,
&AMPR_TO_U,
&ASTR_TO_I,
&RPRN_TO_P,
&COLN_TO_M,
&DLR_TO_R,
&BSLS_TO_A,
&BSLS_NOSHIFT,
&LBRC_TO_S,
&LBRC_NOSHIFT,
&RBRC_NOSHIFT,
&EQL_NOSHIFT,
&PIPE_TO_Z,
&LCBR_TO_X,
&RCBR_TO_C,
&UNDS_TO_V,
&PLUS_TO_B,
&F2_TO_M,
};

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

@ -0,0 +1,25 @@
#include QMK_KEYBOARD_H
#include "./utils.h"
bool obliterate_line(bool key_down, uint8_t deletion_keycode, uint8_t movement_keycode) {
if (key_down) {
tap_code16(S(movement_keycode));
register_code(deletion_keycode);
} else {
unregister_code(deletion_keycode);
}
return false;
}
bool obliterate_line_backwards(bool key_down, void* _) {
return obliterate_line(key_down, KC_BSPC, KC_HOME);
}
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();
return false;
}

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

@ -0,0 +1,36 @@
#pragma once
#include "stdbool.h"
#include "stdint.h"
/// @brief Obliterate a line of text.
/// @param key_down Whether the key was pressed down.
/// @param deletion_keycode The deletion keycode. Either `KC_BSPC` or `KC_DEL`.
/// @param movement_keycode The movement keycode. Either `KC_HOME` or `KC_END`.
/// @return Always returns `false`.
bool obliterate_line(bool key_down, uint8_t deletion_keycode, uint8_t movement_keycode);
/// @brief Obliterate a line of text backwards from the cursor.
/// @param key_down Whether the key was pressed down.
/// @param _ Unused.
/// @return Always returns `false`.
bool obliterate_line_backwards(bool key_down, void* _);
/// @brief Obliterate a line of text forwards from the cursor.
/// @param key_down Whether the key was pressed down.
/// @param _ Unused.
/// @return Always returns `false`.
bool obliterate_line_forwards(bool key_down, void* _);
/// @brief Wrapper to turn on caps word.
/// @param key_down Whether the key was pressed down.
/// @param _ Unused.
/// @return Always returns `false`.
bool turn_on_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