From a75bd221f2b6ca5b67b05b3284389b0721475acd Mon Sep 17 00:00:00 2001 From: Daniel Gordon Date: Wed, 30 May 2018 10:10:22 -0500 Subject: Updates to gordon keymaps (#3082) Added rules.mk for the infinity * Moved tap dance enums to gordon.h * Moved tap dance aliases to gordon.h Moved TD to user space * Added config file with preventing mods sticking * Added a few keys to keymap --- users/gordon/gordon.c | 241 +++++++++++++++++++++++++++++++++++++++----------- users/gordon/gordon.h | 192 +++++++++++++++++++++++++++++----------- users/gordon/rules.mk | 4 +- 3 files changed, 333 insertions(+), 104 deletions(-) (limited to 'users/gordon') diff --git a/users/gordon/gordon.c b/users/gordon/gordon.c index 056012a21..3115e1c32 100644 --- a/users/gordon/gordon.c +++ b/users/gordon/gordon.c @@ -15,20 +15,17 @@ const char secret[][64] = { }; #endif - - - void register_hyper (void) { //Helper function to invoke Hyper register_code (KC_LSFT); - register_code (KC_LCTL); - register_code (KC_LALT); - register_code (KC_LGUI); + register_code (KC_LCTL); + register_code (KC_LALT); + register_code (KC_LGUI); } void unregister_hyper (void) { //Helper function to invoke Hyper unregister_code (KC_LSFT); - unregister_code (KC_LCTL); - unregister_code (KC_LALT); - unregister_code (KC_LGUI); + unregister_code (KC_LCTL); + unregister_code (KC_LALT); + unregister_code (KC_LGUI); } void register_ctrl_a (void) { @@ -41,55 +38,55 @@ void unregister_ctrl_a (void) { unregister_code(KC_A); } -void register_alt_f7 (void) { - register_code (KC_LALT); +void register_alt_f7 (void) { + register_code (KC_LALT); register_code (KC_F7); } -void unregister_alt_f7 (void) { - unregister_code (KC_LALT); +void unregister_alt_f7 (void) { + unregister_code (KC_LALT); unregister_code (KC_F7); } -void register_shift_f6 (void) { - register_code (KC_LSFT); +void register_shift_f6 (void) { + register_code (KC_LSFT); register_code (KC_F6); } -void unregister_shift_f6 (void) { - unregister_code (KC_LSFT); +void unregister_shift_f6 (void) { + unregister_code (KC_LSFT); unregister_code (KC_F6); } -void register_ctrl_shift (void) { - register_code (KC_LSFT); +void register_ctrl_shift (void) { + register_code (KC_LSFT); register_code (KC_LCTRL); } -void unregister_ctrl_shift (void) { - unregister_code (KC_LSFT); +void unregister_ctrl_shift (void) { + unregister_code (KC_LSFT); unregister_code (KC_LCTRL); } -void register_alt_shift (void) { - register_code (KC_LSFT); +void register_alt_shift (void) { + register_code (KC_LSFT); register_code (KC_LALT); } -void unregister_alt_shift (void) { - unregister_code (KC_LSFT); +void unregister_alt_shift (void) { + unregister_code (KC_LSFT); unregister_code (KC_LALT); } -// To activate SINGLE_HOLD, you will need to hold for 200ms first. +// To activate SINGLE_HOLD, you will need to hold for 200ms first. // This tap dance favors keys that are used frequently in typing like 'f' int cur_dance (qk_tap_dance_state_t *state) { if (state->count == 1) { //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP if (state->interrupted) { - // if (!state->pressed) return SINGLE_TAP; + // if (!state->pressed) return SINGLE_TAP; //need "permissive hold" here. - // else return SINsGLE_HOLD; + // else return SINsGLE_HOLD; //If the interrupting key is released before the tap-dance key, then it is a single HOLD //However, if the tap-dance key is released first, then it is a single TAP //But how to get access to the state of the interrupting key???? @@ -105,8 +102,8 @@ int cur_dance (qk_tap_dance_state_t *state) { else if (state->count == 2) { if (state->interrupted) return DOUBLE_SINGLE_TAP; else if (state->pressed) return DOUBLE_HOLD; - else return DOUBLE_TAP; - } + else return DOUBLE_TAP; + } else if ((state->count == 3) && ((state->interrupted) || (!state->pressed))) return TRIPLE_TAP; else if (state->count == 3) return TRIPLE_HOLD; else return 8; //magic number. At some point this method will expand to work for more presses @@ -116,8 +113,8 @@ int cur_dance (qk_tap_dance_state_t *state) { int hold_cur_dance (qk_tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted) { - if (!state->pressed) return SINGLE_TAP; - else return SINGLE_HOLD; + if (!state->pressed) return SINGLE_TAP; + else return SINGLE_HOLD; } else { if (!state->pressed) return SINGLE_TAP; @@ -128,8 +125,8 @@ int hold_cur_dance (qk_tap_dance_state_t *state) { //with single tap. else if (state->count == 2) { if (state->pressed) return DOUBLE_HOLD; - else return DOUBLE_TAP; - } + else return DOUBLE_TAP; + } else if (state->count == 3) { if (!state->pressed) return TRIPLE_TAP; else return TRIPLE_HOLD; @@ -138,7 +135,7 @@ int hold_cur_dance (qk_tap_dance_state_t *state) { } -static xtap htap_state = { +static xtap htap_state = { .is_press_action = true, .state = 0 }; @@ -168,7 +165,7 @@ void h_reset (qk_tap_dance_state_t *state, void *user_data) { /**************** QUAD FUNCTION FOR TAB ****************/ // TAB, ALT + SHIFT, TAB TAB, CTRL + SHIFT -static xtap tab_state = { +static xtap tab_state = { .is_press_action = true, .state = 0 }; @@ -183,7 +180,7 @@ void tab_finished (qk_tap_dance_state_t *state, void *user_data) { case TRIPLE_TAP: register_code(KC_LSHIFT) ;register_code(KC_ESC); break; case TRIPLE_HOLD: register_code(KC_LSHIFT); register_code(KC_LGUI); break; } -} +} void tab_reset (qk_tap_dance_state_t *state, void *user_data) { switch (tab_state.state) { @@ -201,7 +198,7 @@ void tab_reset (qk_tap_dance_state_t *state, void *user_data) { //*************** SUPER COMMA *******************// // Assumption: we don't care about trying to hit ,, quickly //*************** SUPER COMMA *******************// -static xtap comma_state = { +static xtap comma_state = { .is_press_action = true, .state = 0 }; @@ -209,19 +206,19 @@ static xtap comma_state = { void comma_finished (qk_tap_dance_state_t *state, void *user_data) { comma_state.state = hold_cur_dance(state); //Use the dance that favors being held switch (comma_state.state) { - case SINGLE_TAP: register_code(KC_COMMA); break; + case SINGLE_TAP: register_code(KC_COMMA); break; case SINGLE_HOLD: layer_on(1); break; //turn on symbols layer case DOUBLE_TAP: layer_invert(4); break; //toggle numbers layer case DOUBLE_HOLD: layer_on(2); break; case TRIPLE_TAP: register_code(KC_CALCULATOR); break; case TRIPLE_HOLD: layer_on(3); } -} +} void comma_reset (qk_tap_dance_state_t *state, void *user_data) { switch (comma_state.state) { case SINGLE_TAP: unregister_code(KC_COMMA); break; //unregister comma - case SINGLE_HOLD: layer_off(1); break; + case SINGLE_HOLD: layer_off(1); break; case DOUBLE_TAP: ;break; case DOUBLE_HOLD: layer_off(2); break; case TRIPLE_TAP: unregister_code(KC_CALCULATOR); break; @@ -235,7 +232,7 @@ void comma_reset (qk_tap_dance_state_t *state, void *user_data) { //*************** F3 TAP DANCE *******************// //Good example for accessing multiple layers from the same key. -static xtap S1_state = { +static xtap S1_state = { .is_press_action = true, .state = 0 }; @@ -244,17 +241,17 @@ void bt_finished (qk_tap_dance_state_t *state, void *user_data) { S1_state.state = cur_dance(state); switch (S1_state.state) { case SINGLE_TAP: register_code(KC_F3); break; - case SINGLE_HOLD: layer_on(4); break; - case DOUBLE_TAP: layer_invert(4); break; + case SINGLE_HOLD: layer_on(_MACROS); break; + case DOUBLE_TAP: layer_invert(_MACROS); break; case DOUBLE_HOLD: layer_on(5); break; - case DOUBLE_SINGLE_TAP: layer_invert(4); break; + case DOUBLE_SINGLE_TAP: layer_invert(_MACROS); break; } } void bt_reset (qk_tap_dance_state_t *state, void *user_data) { switch (S1_state.state) { case SINGLE_TAP: unregister_code(KC_F3); break; - case SINGLE_HOLD: layer_off(4); break; + case SINGLE_HOLD: layer_off(_MACROS); break; case DOUBLE_TAP: break; //already inverted. Don't do anything. case DOUBLE_HOLD: layer_off(5); break; case DOUBLE_SINGLE_TAP: break; @@ -262,14 +259,152 @@ void bt_reset (qk_tap_dance_state_t *state, void *user_data) { S1_state.state = 0; } +// Tap Dance Definitions +qk_tap_dance_action_t tap_dance_actions[] = { + // simple tap dance + [F12ETAPS] = ACTION_TAP_DANCE_DOUBLE(KC_F12,LSFT(LCTL(KC_F10))), + [REFRESH] = ACTION_TAP_DANCE_DOUBLE(KC_R,LCTL(KC_R)), + [ENDESC] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_ESC), + [Q_ESCAPE] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC), + [ENDHOME] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_HOME), + [CALCCOMP] = ACTION_TAP_DANCE_DOUBLE(KC_CALCULATOR, KC_MY_COMPUTER), + [ALTF4] = ACTION_TAP_DANCE_DOUBLE(KC_F4,LALT(KC_F4)), + [F6F7] = ACTION_TAP_DANCE_DOUBLE(LSFT(KC_F6), LALT(KC_F7)), + [F1F13] = ACTION_TAP_DANCE_DOUBLE(KC_F1, KC_F13), + [F2F14] = ACTION_TAP_DANCE_DOUBLE(KC_F2, KC_F14), + [F5F15] = ACTION_TAP_DANCE_DOUBLE(KC_F5, KC_F15), + [TABCOMBO] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tab_finished, tab_reset), + [F3D] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, bt_finished, bt_reset), + [COMMA] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, comma_finished, comma_reset), + [HTAB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,h_finished, h_reset) +}; + +// bool process_record_user(uint16_t keycode, keyrecord_t *record) { +// if (!record->event.pressed) { +// switch (keycode) { + +// case KC_SECRET_1 ... KC_SECRET_5: +// send_string(secret[keycode - KC_SECRET_1]); +// // clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); +// return true; break; + +// case UP_ENTER_RESET: +// register_code(KC_UP); +// unregister_code(KC_UP); +// register_code(KC_ENTER); +// unregister_code(KC_ENTER); +// reset_keyboard(); +// return false; break; + +// case TIL_SLASH: +// SEND_STRING ("~/."); +// return false; break; + +// case DBMS_OUT: +// SEND_STRING ("dbms_output.put_line('');"); +// SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT)); +// return false; break; + +// case ID_MAN_IP: +// SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com"); +// return false; break; + +// case MODRESET: +// clear_mods(); +// return false; break; + +// case DEREF: +// SEND_STRING ("->"); +// return false; break; + +// case EQRIGHT: +// SEND_STRING ("=>"); +// return false; break; + +// case TICK3: +// SEND_STRING ("```"); +// return false; break; + +// case TILD3: +// SEND_STRING ("~~~"); +// return false; break; +// } +// } +// return true; +// }; + + + + bool process_record_user(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case KC_SECRET_1 ... KC_SECRET_5: - if (!record->event.pressed) { - send_string(secret[keycode - KC_SECRET_1]); + if (!record->event.pressed) { + switch (keycode) { + case KC_SECRET_1 ... KC_SECRET_5: + send_string(secret[keycode - KC_SECRET_1]); + // clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); + return true; break; + case UP_ENTER_RESET: + SEND_STRING("make ergodox_infinity:gordon:dfu-util"); + register_code(KC_ENTER); + unregister_code(KC_ENTER); + reset_keyboard(); + return false; break; + + case TIL_SLASH: + SEND_STRING ("~/."); + return false; break; + + case DBMS_OUT: + SEND_STRING ("dbms_output.put_line('');"); + SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT)); + return false; break; + case DIE_1000X_RIGHT: + SEND_STRING (SS_TAP(X_G) SS_TAP(X_G) SS_TAP(X_RIGHT) SS_TAP(X_B) SS_TAP(X_J)); + return false; break; + case DIE_1000X_LEFT: + SEND_STRING (SS_TAP(X_GRAVE) SS_TAP(X_G) SS_TAP(X_LEFT) SS_TAP(X_B) SS_TAP(X_J)); + return false; break; + case ID_MAN_IP: + SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com"); + return false; break; + + case MODRESET: + clear_mods(); + return false; break; + + case DEREF: + SEND_STRING ("->"); + return false; break; + + case EQRIGHT: + SEND_STRING ("=>"); + return false; break; + + case TICK3: + SEND_STRING ("```"); + + return false; break; + + case SPRK_TCK: + SEND_STRING ("```"); + SEND_STRING (SS_DOWN(X_LSHIFT) SS_TAP(X_ENTER) SS_UP(X_LSHIFT)); + SEND_STRING (SS_DOWN(X_LSHIFT) SS_TAP(X_ENTER) SS_UP(X_LSHIFT)); + SEND_STRING ("```"); + SEND_STRING (SS_TAP(X_UP)); + return false; break; + + case TILD3: + SEND_STRING ("~~~"); + return false; break; + } + } + else { //On key being pressed + switch (keycode) { + case KC_SECRET_1 ... KC_SECRET_5: + clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); + return false; break; } - return false; - break; } return true; -} \ No newline at end of file +}; + diff --git a/users/gordon/gordon.h b/users/gordon/gordon.h index 548c63049..92641a8aa 100644 --- a/users/gordon/gordon.h +++ b/users/gordon/gordon.h @@ -6,20 +6,21 @@ // Fillers to make layering more clear -#define _______ KC_TRNS -#define ________ KC_TRNS +#define _______ KC_TRNS +#define ________ KC_TRNS #define _________ KC_TRNS -#define XXXXXXX KC_NO +#define _XXXXXX_ KC_TRNS +#define XXXXXXX KC_NO // KC codes that are too long -#define DOLLAR KC_DOLLAR -#define LSQUIGLY KC_LBRACKET -#define RSQUIGLY KC_RBRACKET -#define NUMLOCK KC_NUMLOCK -#define CAPLOCK KC_CAPSLOCK -#define BK_SLASH KC_BSLASH -#define ASTERSK KC_KP_ASTERISK - +#define DOLLAR KC_DOLLAR +#define LSQUIGLY KC_LBRACKET +#define RSQUIGLY KC_RBRACKET +#define NUMLOCK KC_NUMLOCK +#define CAPLOCK KC_CAPSLOCK +#define BK_SLASH KC_BSLASH +#define ASTERSK KC_KP_ASTERISK + // Navigation #define SNAPLEFT LGUI(KC_LEFT) #define SNAPRGHT LGUI(KC_RIGHT) @@ -30,19 +31,28 @@ #define WORKRIGHT LCTL(LGUI(KC_RIGHT)) #define WORKLEFT LCTL(LGUI(KC_LEFT)) +#define APP_1 LCTL(LGUI(KC_1)) +#define APP_2 LCTL(LGUI(KC_2)) +#define APP_3 LCTL(LGUI(KC_3)) +#define APP_4 LCTL(LGUI(KC_4)) +#define APP_5 LCTL(LGUI(KC_5)) +#define APP_6 LCTL(LGUI(KC_6)) +#define APP_7 LCTL(LGUI(KC_7)) +#define APP_8 LCTL(LGUI(KC_8)) + // KC/modifier hold -#define CTRL_F CTL_T(KC_F) -#define CTRL_J CTL_T(KC_J) -#define CTRL_Z CTL_T(KC_Z) -#define ALT_V ALT_T(KC_V) -#define ALT_M ALT_T(KC_M) -#define WIN_G GUI_T(KC_G) -#define WIN_H GUI_T(KC_H) -#define HYPER_X ALL_T(KC_X) -#define HYPE_DOT ALL_T(KC_DOT) -#define MEH_S MEH_T(KC_S) -#define MEH_L MEH_T(KC_L) -#define ALT_HOME ALT_T(KC_HOME) +#define CTRL_F CTL_T(KC_F) +#define CTRL_J CTL_T(KC_J) +#define CTRL_Z CTL_T(KC_Z) +#define ALT_V ALT_T(KC_V) +#define ALT_M ALT_T(KC_M) +#define WIN_G GUI_T(KC_G) +#define WIN_H GUI_T(KC_H) +#define HYPER_X ALL_T(KC_X) +#define HYPE_DOT ALL_T(KC_DOT) +#define MEH_S MEH_T(KC_S) +#define MEH_L MEH_T(KC_L) +#define ALT_HOME ALT_T(KC_HOME) // KC/Layer Hold @@ -52,6 +62,15 @@ #define SYMB_BSP LT(_SYMBOLS,KC_BSPACE) #define COL_MOUS LT(_MOUSE,KC_SCOLON) #define SPAC_SYM LT(_SYMBOLS,KC_SPACE) +#define SPAC_TXT LT(_TEXTNAV,KC_SPACE) + +#define APP_SW_I LT(_APPSWITCH,KC_I) +#define APP_SW_K LT(_APPSWITCH,KC_K) + +// #define TLSLSH TIL_SLASH +// #define TILDA_3x TILD3 +// #define _RESET_ UP_ENTER_RESET + // Double Modifier ONLY hold #define ALT_SHFT LSFT(KC_LALT) @@ -60,6 +79,7 @@ // KC/Double modifier Hold #define CTR_SH_W MT(MOD_LCTL|MOD_LSFT,KC_W) #define CTR_AL_R MT(MOD_LCTL|MOD_LALT,KC_R) +#define ALT_SH_R MT(MOD_LSFT|MOD_LALT,KC_R) //MISC #define PRINTSCR KC_PSCREEN @@ -82,16 +102,77 @@ enum { TRIPLE_HOLD = 7 }; +//Tap dance enums +enum +{ + F12TAP = 0, + F12ETAPS, + CALCCOMP, + REFRESH, //send R, or Control+R if double tapped. + ENDESC, + XESC, //'quad function'. x, control, escape, alt + ALY2, //'quad function': a, Hyper, ctrl+a, layer 2 + PRLOCK, + F6F7, // Shift F6 or Alt F7 + TABCOMBO, + FCTRL, + F3D, + ALTF4, + COMMA, + AT, + HTAB, + F1F13, + F2F14, + F5F15, + ENDHOME, + Q_ESCAPE +}; + +#ifdef TAP_DANCE_ENABLE +#define F1_F13 TD(F1F13) +#define F2_F14 TD(F2F14) +#define F5_F15 TD(F5F15) +#define F4_ALTF4 TD(ALTF4) +#define END_ESC TD(ENDESC) +#define Q_ESC TD(Q_ESCAPE) +#define END_HOME TD(ENDHOME) +#define SHF6_AF7 TD(F6F7) +#define F12_RUN TD(F12ETAPS) +#define COMMA_TD TD(COMMA) +#define CALC_COM TD(CALCCOMP) +#else //just to make things compile +#define F1_F13 KC_1 +#define F2_F14 KC_1 +#define F5_F15 KC_1 +#define F4_ALTF4 KC_1 +#define END_ESC KC_1 +#define END_HOME KC_1 +#define SHF6_AF7 KC_1 +#define F12_RUN KC_1 +#define COMMA_TD KC_1 +#define CALC_COM KC_1 +#endif + enum gordon_layers { _QWERTY = 0, - _SYMBOLS, - _MOUSE, - _NUMPAD, - _NAV, - _MACROS, - _FUNCTION, - _TEXTNAV + _SYMBOLS, // Programming and all other commonlye used symbols + _MOUSE, // Mouse movement and also a few macros + _NUMPAD, // For getting a numpad under the right hand, and a few helpful things under the left + _NAV, // Windows navigation. Windows snapping, changing workspaces, and ARROWS + _MACROS, // Non-text related Macros. + _FUNCTION, // Not sure what I had in mind for this one + _APPSWITCH, // For switching between apps using the `ctrl + Win + [num]` shortcut. + // This allows for toggling windows of the same app with one button. + // Example: Press and hold `I`, then tap `j` multiple times to cycle through all + // Intellij windows (and only Intellij). This requires the app to be pinned to the Windows bar + _ONESHOT, // A layer I use for shortcuts that require multiple modifiers and a button not on my home layer + // Example: If I need to hit `alt + shift + 5` + _TEXTNAV, // Navigate through text + _QWERTY_KIDS, // So my kids can do nothing but type. Could also be a `speed typing` layer with no LT or MTs + _STREET_FIGHTER, // For Street Fighter 5. Die 1000x Deaths!!!! + _DIRNAV, // For navigating to different directories. + _TEXT_MACROS // For text-manipulation macros. Passwords, saved strings, pre-formatting }; @@ -99,23 +180,23 @@ enum gordon_layers void register_hyper (void); void unregister_hyper (void); -void register_ctrl_a (void); -void unregister_ctrl_a (void); +void register_ctrl_a (void); +void unregister_ctrl_a (void); -void register_alt_f7 (void); +void register_alt_f7 (void); void unregister_alt_f7 (void); -void register_shift_f6 (void); -void unregister_shift_f6 (void); +void register_shift_f6 (void); +void unregister_shift_f6 (void); -void register_ctrl_shift (void); -void unregister_ctrl_shift (void); +void register_ctrl_shift (void); +void unregister_ctrl_shift (void); -void register_alt_shift (void); +void register_alt_shift (void); void unregister_alt_shift (void); -int cur_dance (qk_tap_dance_state_t *state); -int hold_cur_dance (qk_tap_dance_state_t *state); +int cur_dance (qk_tap_dance_state_t *state); +int hold_cur_dance (qk_tap_dance_state_t *state); void x_finished (qk_tap_dance_state_t *state, void *user_data); void x_reset (qk_tap_dance_state_t *state, void *user_data); @@ -132,26 +213,37 @@ void comma_reset (qk_tap_dance_state_t *state, void *user_data); void bt_finished (qk_tap_dance_state_t *state, void *user_data); void bt_reset (qk_tap_dance_state_t *state, void *user_data); +enum secret_strings { + KC_SECRET_1 = SAFE_RANGE, + KC_SECRET_2, + KC_SECRET_3, + KC_SECRET_4, + KC_SECRET_5, + END_SECRET_SAFE_RANGE +}; + + // Macro Declarations enum { - INFOQM, + INFOQM = END_SECRET_SAFE_RANGE, + MODRESET, TIL_SLASH, DEREF, EQRIGHT, TILD3, TICK3, + SPRK_TCK, ALTTAB_START, - ALTTAB_END + ALTTAB_END, + UP_ENTER_RESET, + DBMS_OUT, + DIE_1000X_RIGHT, + DIE_1000X_LEFT, + ID_MAN_IP }; -enum secret_strings { - KC_SECRET_1 = SAFE_RANGE, - KC_SECRET_2, - KC_SECRET_3, - KC_SECRET_4, - KC_SECRET_5, -}; + const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt); -#endif \ No newline at end of file +#endif diff --git a/users/gordon/rules.mk b/users/gordon/rules.mk index 359478912..19e77b01b 100644 --- a/users/gordon/rules.mk +++ b/users/gordon/rules.mk @@ -1,2 +1,4 @@ TAP_DANCE_ENABLE = yes -SRC += gordon.c \ No newline at end of file +SRC += gordon.c + +# BOOTMAGIC_ENABLE = yes -- cgit v1.2.3-24-g4f1b