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

Switching branches so I can reflash

Browse source
This commit is contained in:
Drew Whitney 2025-11-01 18:12:47 -06:00
commit fc8f1a1507
15 changed files with 141 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

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

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

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

@ -1,4 +0,0 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>

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

@ -1,21 +0,0 @@
#pragma once
#include QMK_KEYBOARD_H
#include "../common.h"
#define TAB_FORWARD C(KC_TAB)
#define TAB_BACKWARD (C(S(KC_TAB)))
#define NUM_SPC LT(_NUM, KC_SPC)
#define NAV_ENT LT(_NAV, KC_ENT)
#define LAUNCH A(KC_SPC)
#define MENU S(KC_F10)
#define GUI_LAUNCH GUI_T(LAUNCH)
#define ALT_DEL ALT_T(NK(TH_DEL))
#define SFT_TILD SFT_T(NK(TH_TILD))
#define SFT_SFT SFT_T(NK(TH_LSFT))
#define SFT_COMM SFT_T(NK(TH_COMM))
#define CTL_COLN CTL_T(NK(TH_COLN))
// non-custom
#define CAD C(A(KC_DEL))
#define LOCK G(KC_L)

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

@ -44,10 +44,6 @@ custom_key_t custom_keys[] = {
),
[NK_EQL] =
CUSTOM_KEY(KC_EQL, 1, REMAP_WITH_OPTIONS(KC_EQL, MOD_MASK_SHIFT, REMOVE_TRIGGER, false)),
[NK_GRV] = CUSTOM_KEY(
KC_GRV, 2, REMAP_WITH_OPTIONS(TAB_FORWARD, MOD_MASK_ALT, REMOVE_ALL, false),
REMAP_WITH_OPTIONS(KC_GRV, 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)),
@ -55,25 +51,10 @@ custom_key_t custom_keys[] = {
[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)),
[NK_HOME] = CUSTOM_KEY(
KC_HOME, 2, REMAP_WITH_OPTIONS(C(KC_HOME), MOD_MASK_GUI, REMOVE_TRIGGER, false),
REMAP_WITH_OPTIONS(KC_HOME, MOD_MASK_CTRL, REMOVE_TRIGGER, false)
),
[NK_END] = CUSTOM_KEY(
KC_END, 2, REMAP_WITH_OPTIONS(C(KC_END), MOD_MASK_GUI, REMOVE_TRIGGER, false),
REMAP_WITH_OPTIONS(KC_END, MOD_MASK_CTRL, REMOVE_TRIGGER, false)
),
// 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)),
// tap-hold
[TH_TILD] =
CUSTOM_KEY(KC_TILD, 1, REMAP_WITH_OPTIONS(TAB_BACKWARD, MOD_MASK_ALT, REMOVE_ALL, false)),
[TH_COMM] =
CUSTOM_KEY(KC_COMM, 1, REMAP_WITH_OPTIONS(TAB_BACKWARD, MOD_MASK_ALT, REMOVE_ALL, false)),
[TH_COLN] = CUSTOM_KEY_NO_REMAP(KC_COLN),
};

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

@ -1,11 +1,36 @@
#pragma once
#include QMK_KEYBOARD_H
#include "../common.h"
#include "../alias.h"
#include "../layers.h"
#include "../utils/deletion.h"
#include "alias.h"
#include "custom_keys.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;
// -------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

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

@ -1,10 +1,13 @@
#include QMK_KEYBOARD_H
#include "caps_word/caps_word.h"
#include "common.h"
#include "layers.h"
#include "tap_dance/tap_dance.c"
#include "tap_dance/tap_dance.h"
#include "taphold/taphold_options.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"
#include "./taphold/taphold_options.h"
#include "./utils/utils.h"
#include "stdbool.h"
#include "stdint.h"
bool NAV_enabled = false;
@ -17,11 +20,15 @@ enum CustomKeycodes {
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) {
@ -37,11 +44,11 @@ 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, LT(_FUNC, KC_MPLY), ALT_T(KC_LALT), TD(TD_CAD_LOCK_SLEEP), GUI_LAUNCH, NUM_SPC, NAV_ENT, ALT_COMP, KC_LEFT, DOWN, UP, KC_RGHT
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
),
// gamer
[_GAME] = LAYOUT_ortho_4x12(
KC_TRNS, KC_Q, 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_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
@ -49,14 +56,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// special characters
// numbers
[_NUM] = LAYOUT_ortho_4x12(
KC_TRNS, KC_SLSH, KC_AT, KC_ASTR, NK(NK_MINS_NUM), KC_PLUS, NK(NK_CIRC), NK(NK_AMPR), NK(NK_ASTR), KC_LPRN, NK(NK_RPRN), KC_TRNS,
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,
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,
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(
NK(NK_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), NK(NK_HOME), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, NK(NK_END),
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_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
),
@ -82,7 +89,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & MOD_MASK_CTRL) {
del_mods(mods);
del_mods(MOD_MASK_CTRL);
tap_code16(MENU);
set_mods(mods);
return false;
@ -107,9 +114,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
case SFT_DEL:
if (record->tap.count) { // only trigger on taps, not holds
uint8_t mods = get_mods();
if (mods & MOD_MASK_GUI) { // obliterate line forwards
if (mods & OBLITERATE_TRIGGER_MODS) { // obliterate line forwards
if (record->event.pressed) {
del_mods(MOD_MASK_GUI);
del_mods(OBLITERATE_TRIGGER_MODS);
tap_code16(S(KC_END));
register_code(KC_DEL);
set_mods(mods);
@ -126,18 +133,18 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
}
break;
case L_SFT:
case L_SFT: {
static bool tab_backward_held = false;
if (record->tap.count) {
if (record->event.pressed) {
uint8_t mods = get_mods();
if (mods & MOD_MASK_ALT) {
del_mods(MOD_MASK_ALT);
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 (mods & MOD_MASK_SHIFT) {
} else if (mods & MOD_MASK_SHIFT) { // caps word
caps_word_on();
return false;
}
@ -151,6 +158,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
}
}
break;
}
case ALT_COMP:
// caps lock
@ -160,86 +168,86 @@ bool process_record_user(uint16_t keycode, keyrecord_t* record) {
}
break;
case CUSTOM_KEY_RANGE:
process_custom_key(keycode, record);
return false;
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 ALT_DEL:
case SFT_TILD:
case SFT_SFT:
case SFT_COMM:
case CTL_COLN:
return process_custom_taphold(keycode, record);
}
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;
}
return true;
}
/// @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_line2(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;
}
/// @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_backwards2(bool key_down, void* _) {
return obliterate_line2(key_down, KC_BSPC, KC_HOME);
}
/// @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_forwards2(bool key_down, void* _) {
return obliterate_line2(key_down, KC_DEL, KC_END);
}
/// @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_word2(bool key_down, void* _) {
caps_word_on();
return false;
}
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 BSPC_TO_OBLITERATE = {
.trigger = KC_BSPC,
.trigger_mods = MOD_MASK_GUI,
.trigger_mods = OBLITERATE_TRIGGER_MODS,
.layers = 0xFF,
.custom_action = obliterate_line_backwards2,
.suppressed_mods = MOD_MASK_GUI,
.custom_action = obliterate_line_backwards,
.suppressed_mods = OBLITERATE_TRIGGER_MODS,
};
const key_override_t DEL_TO_OBLITERATE = {
.trigger = KC_DEL,
.trigger_mods = MOD_MASK_GUI,
.layers = 0xFF,
.custom_action = obliterate_line_forwards2,
.suppressed_mods = MOD_MASK_GUI,
};
const key_override_t DEL_TO_CAPS_WORD = {
.trigger = SFT_DEL,
.trigger_mods = MOD_MASK_SHIFT,
.layers = 0xFF,
.custom_action = turn_on_caps_word2,
};
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));
const key_override_t ESC_TO_TAB_FORWARD = ko_make_basic(MOD_MASK_ALT, KC_ESC, TAB_FORWARD);
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 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 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);
@ -294,11 +302,19 @@ const key_override_t LOW_0_DEFAULT = ko_make_basic(0, LOW_0, KC_0);
// this globally defines all key overrides to be used
const key_override_t* key_overrides[] = {
&Q_TO_KILL,
//
&BSPC_TO_OBLITERATE,
// &DEL_TO_OBLITERATE,
&DEL_TO_CAPS_WORD,
&HOME_NOCTRL,
&HOME_TO_MEGA_HOME,
&END_NO_CTRL,
&END_TO_META_END,
&ESC_TO_TAB_FORWARD,
&GRV_TO_TAB_FORWARD,
&GRV_NOSHIFT,
&DOWN_TO_ZOOM_OUT,
&DOWN_DEFAULT,
&UP_TO_ZOOM_IN,

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

@ -1,9 +1,6 @@
SRC += caps_word/caps_word.c
SRC += taphold/taphold_options.c
SRC += utils/mod_suppression.c
SRC += utils/deletion.c
SRC += custom_keys/custom_keys.c
SRC += custom_keys/mapping.c
SRC += utils/utils.c
# VIA_ENABLE = yes
LTO_ENABLE = yes

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

@ -1,6 +1,6 @@
#include "tap_dance.h"
#include "../common.h"
#include "../custom_keys/alias.h"
#include QMK_KEYBOARD_H
#include "./tap_dance.h"
#include "../alias.h"
void CAD_lock_sleep(tap_dance_state_t* state, void* user_data) {
switch (state->count) {

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

@ -1,7 +1,5 @@
#pragma once
#include "../common.h"
enum {
TD_CAD_LOCK_SLEEP,
};

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

@ -1,4 +1,6 @@
#include "taphold_options.h"
#include "./taphold_options.h"
#include "../alias.h"
#include "../tap_dance/tap_dance.h"
uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record) {
switch (keycode) {
@ -6,7 +8,7 @@ uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record) {
case NUM_SPC:
case NAV_ENT:
case GUI_LAUNCH:
case LT(_FUNC, KC_MPLY):
case FUNC_PLAY:
return 0; // no repeat tapping when tapped and then held for these keys
break;
}

6
keyboards/keebio/nyquist/rev4/keymaps/drew/taphold/taphold_options.h
View file

@ -1,11 +1,7 @@
#pragma once
#include QMK_KEYBOARD_H
#include "../common.h"
#include "../custom_keys/alias.h"
#include "../custom_keys/mapping.h"
#include "../layers.h"
#include "../tap_dance/tap_dance.h"
#include "stdint.h"
uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record);
bool get_permissive_hold(uint16_t keycode, keyrecord_t* record);

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

@ -1,18 +0,0 @@
#include "deletion.h"
void obliterate_line(uint8_t deletion_keycode) {
uint8_t movement_keycode;
switch (deletion_keycode) {
case KC_BSPC:
movement_keycode = KC_HOME;
break;
case KC_DEL:
movement_keycode = KC_END;
break;
default: // this should never run
return;
break;
}
tap_code16(S(movement_keycode));
register_code(deletion_keycode);
}

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

@ -1,4 +0,0 @@
#pragma once
#include QMK_KEYBOARD_H
void obliterate_line(uint8_t deletion_keycode);

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

@ -1,31 +0,0 @@
#include "mod_suppression.h"
void trigger_dummy_key(uint8_t mods) {
if (mods & MOD_BIT(DUMMY_MOD_NEUTRALIZER_KEYCODE)) {
unregister_mods(MOD_BIT(DUMMY_MOD_NEUTRALIZER_KEYCODE));
register_mods(MOD_BIT(DUMMY_MOD_NEUTRALIZER_KEYCODE));
} else {
tap_code(DUMMY_MOD_NEUTRALIZER_KEYCODE);
}
}
void suppress_flashing_mods(uint8_t mods) {
trigger_dummy_key(mods);
del_mods(MOD_MASK_AG);
}
void neutralize_mods_on_release(void) {
uint8_t mods = get_mods();
if (mods & (MOD_MASK_AG)) {
send_keyboard_report();
trigger_dummy_key(mods);
}
}
// void tap_code16_suppress(uint16_t keycode, uint8_t mods) {
// suppress_flashing_mods(mods);
// tap_code16(keycode);
// set_mods(mods);
// }
// void register_code16_suppress(uint16_t keycode, uint8_t mods) {
// suppress_flashing_mods(mods);
// register_code16(keycode);
// set_mods(mods);
// }

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

@ -1,8 +0,0 @@
#pragma once
#include QMK_KEYBOARD_H
void trigger_dummy_key(uint8_t mods);
void suppress_flashing_mods(uint8_t mods);
void neutralize_mods_on_release(void);
void tap_code16_suppress(uint16_t keycode, uint8_t mods);
void register_code16_suppress(uint16_t keycode, uint8_t mods);