#include QMK_KEYBOARD_H #if __has_include("keymap.h") # include "keymap.h" #endif // --- tap dance definitions --- // taken from https://docs.qmk.fm/features/tap_dance typedef enum { TD_NONE, TD_UNKNOWN, TD_SINGLE_TAP, TD_SINGLE_HOLD, TD_DOUBLE_TAP, TD_DOUBLE_HOLD, TD_DOUBLE_SINGLE_TAP, // Send two single taps TD_TRIPLE_TAP, TD_TRIPLE_HOLD } td_state_t; typedef struct { bool is_press_action; td_state_t state; } td_tap_t; // Tap dance enums // enum { // // X_RMAIN, // // X_CHECK // }; td_state_t cur_dance(tap_dance_state_t *state); // For the x tap dance. Put it here so it can be used in any keymap void x_finished(tap_dance_state_t *state, void *user_data); void x_reset(tap_dance_state_t *state, void *user_data); // --- keymap --- /* THIS FILE WAS GENERATED! * * This file was generated by qmk json2c. You may or may not want to * edit it directly. */ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /*DEFAULT WITH TAP DANCES*/ [0] = LAYOUT_split_3x6_3(KC_NO/*SH_TOGG*//*TD(0)*/, KC_NO/*TD(1)*/, TD(2), TD(3), TD(4), KC_NO/*TD(5)*/, /**/ KC_NO/*TD(6)*/, TD(7), TD(8), TD(9), KC_NO/*TD(10)*/, KC_NO/*SH_TOGG*//*TD(11)*/, LCTL(KC_LGUI)/*QK_AREP*//*TD(12)*/, KC_A/*TD(13)*/, TD(14), TD(15), TD(16), TD(17), /**/ TD(18), TD(19), TD(20), TD(21), KC_SCLN/*TD(22)*/, LCTL(KC_APP)/*QK_REP*//*TD(23)*/, KC_NO/*TD(24)*/, KC_Z/*TD(25)*/, KC_X/*TD(26)*/, TD(27), TD(28), TD(29), /**/ TD(30), TD(31), TD(32), TD(33), KC_Q/*TD(34)*/, KC_NO/*TD(35)*/, /**/ LGUI_T(KC_TAB), TT(4), LSFT_T(KC_SPC), /**/ LCTL_T(KC_ENT), TT(6), LT(5,KC_DEL) /**/), /*DEFAULT*/ [1] = LAYOUT_split_3x6_3( SH_TOGG, KC_NO, KC_W, KC_E, KC_R, KC_NO, /**/ KC_NO, KC_U, KC_I, KC_O, KC_NO, SH_TOGG, KC_GRV, KC_A, KC_S, KC_D, KC_F, KC_G, /**/ KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, /**/ KC_N, KC_M, KC_T, KC_Y, KC_Q, KC_NO, /**/ LGUI_T(KC_TAB), TT(4), LSFT_T(KC_SPC), /**/ LCTL_T(KC_ENT), TT(6), LT(5,KC_DEL) /**/), /*QWERTY*/ [2] = LAYOUT_split_3x6_3( TG(3), KC_NO, KC_W, KC_F, KC_P, KC_TRNS, /**/ KC_TRNS, KC_L, KC_U, KC_Y, KC_NO, KC_NO, KC_TRNS, KC_A, KC_R, KC_S, KC_T, KC_D, /**/ KC_H, KC_N, KC_E, KC_I, KC_O, KC_TRNS, TG(2), KC_Z, KC_X, KC_C, KC_V, KC_B, /**/ KC_K, KC_M, KC_G, KC_J, KC_Q, KC_NO, /**/ KC_TRNS, KC_TRNS, KC_TRNS, /**/ KC_TRNS, KC_TRNS, KC_TRNS /**/), /*RUSSIAN*/ [3] = LAYOUT_split_3x6_3( TG(3), KC_NO, KC_SCLN, KC_A, KC_G, KC_TRNS, /**/ KC_TRNS, KC_K, KC_E, KC_S, KC_DOT, KC_NO, KC_TRNS, KC_F, KC_H, KC_C, KC_N, KC_L, /**/ KC_X, KC_Y, KC_T, KC_B, KC_J, KC_TRNS, KC_NO, KC_P, KC_LBRC, KC_C, KC_D, KC_COMM, /**/ KC_R, KC_V, KC_U, KC_Q, KC_Z, KC_NO, /**/ KC_TRNS, KC_TRNS, KC_TRNS, /**/ KC_TRNS, KC_TRNS, KC_TRNS /**/), /*NUMBERS*/ [4] = LAYOUT_split_3x6_3( KC_NO, OSM(MOD_LSFT), KC_2, KC_3, KC_4, KC_TRNS, /**/ KC_TRNS, KC_7, KC_8, KC_9, KC_DEL, KC_NO, OSM(MOD_LALT), KC_HOME, KC_PGDN, KC_PGUP, KC_END, KC_1, /**/ KC_0, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_PSCR, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_5, /**/ KC_6, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, /**/ KC_NO, KC_TRNS, KC_TRNS, /**/ KC_BSPC, KC_ESC, MO(7) /**/), /*SYMBOLS*/ [5] = LAYOUT_split_3x6_3( KC_NO, KC_NO, LSFT(KC_COMM), LSFT(KC_DOT), KC_DLR, KC_NO, /**/ KC_NO, KC_BSLS, KC_AMPR, KC_NO, KC_NO, KC_NO, KC_NO, KC_ASTR, KC_COMM/*KC_LPRN*/, KC_DOT/*KC_RPRN*/, KC_MINS, KC_SLSH, /**/ KC_EXLM, KC_EQL, KC_LBRC, KC_RBRC, KC_P, RALT(KC_QUOT), KC_NO, KC_NO, KC_NO, KC_CIRC, LALT(KC_LEFT), LALT(KC_RGHT), /**/ LSFT(KC_LEFT), LSFT(KC_RGHT), KC_AT, RALT(KC_QUOT), KC_NO, KC_NO, /**/ KC_NO, MO(7), KC_DEL, /**/ KC_TRNS, KC_NO, KC_TRNS /**/), /*MOUSE*/ [6] = LAYOUT_split_3x6_3( KC_NO, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_NO, /**/ KC_NO, LCTL(KC_W), LALT(KC_C), KC_NO, KC_NO, MS_ACL0, KC_MPLY, MS_LEFT, MS_DOWN, MS_UP, MS_RGHT, LALT(KC_SPC), /**/ LALT(KC_TAB), LCA(KC_LEFT), MS_WHLD, MS_WHLU, LCA(KC_RGHT), MS_ACL1, KC_NO, LSFT(KC_LALT), MS_WHLD, MS_WHLU, LALT(KC_LEFT), LALT(KC_RGHT), /**/ LSFT(KC_LEFT), LSFT(KC_RGHT), KC_NO, KC_NO, KC_NO, MS_ACL2, /**/ MS_BTN3, MS_BTN2, MS_BTN1, /**/ KC_TRNS, KC_TRNS, KC_NO /**/ ), /*ADJUST*/ [7] = LAYOUT_split_3x6_3( KC_NO, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_NO, /**/ KC_NO, KC_MUTE, KC_BRID, KC_BRIU, KC_NO, KC_NO, KC_MPLY, LALT(KC_C), KC_NO, LSFT(KC_LALT), LALT(KC_TAB), LALT(KC_SPC), /**/ KC_NO, LSFT(KC_LEFT), LSFT(KC_DOWN), LSFT(KC_UP), LSFT(KC_RGHT), KC_NO, TG(2), KC_NO, KC_NO, KC_NO, LCA(KC_LEFT), LCA(KC_RGHT), /**/ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, TG(1), /**/ KC_NO, KC_TRNS, KC_NO, /**/ KC_NO, KC_TRNS, KC_NO /**/), // /*TAP DANCES*/ // [7] = LAYOUT_split_3x6_3(TD(0), TD(1), TD(2), TD(3), TD(4), TD(5), /**/ TD(6), TD(7), TD(8), TD(9), TD(10), TD(11), // TD(12), TD(13), TD(14), TD(15), TD(16), TD(17), /**/ TD(18), TD(19), TD(20), TD(21), TD(22), TD(23), // TD(24), TD(25), TD(26), TD(27), TD(28), TD(29), /**/ TD(30), TD(31), TD(32), TD(33), TD(34), TD(35), // /**/ KC_TRNS, KC_TRNS, KC_TRNS, /**/ KC_TRNS, KC_TRNS, KC_TRNS /**/ ) }; #ifdef OTHER_KEYMAP_C # include OTHER_KEYMAP_C #endif // OTHER_KEYMAP_C // --- custom auto shift --- bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) { switch(keycode) { case KC_LPRN: case KC_RPRN: case KC_COMM: case KC_DOT: case KC_ASTR: case KC_EXLM: return true; default: return false; } } void autoshift_press_user(uint16_t keycode, bool shifted, keyrecord_t *record) { switch(keycode) { case KC_LPRN: register_code16((!shifted) ? KC_LPRN : KC_COMM); break; case KC_RPRN: register_code16((!shifted) ? KC_RPRN : KC_DOT); break; case KC_COMM: register_code16((!shifted) ? KC_COMM : KC_LPRN); break; case KC_DOT: register_code16((!shifted) ? KC_DOT : KC_RPRN); break; case KC_ASTR: register_code16((!shifted) ? KC_ASTR : KC_PERC); break; case KC_EXLM: register_code16((!shifted) ? KC_EXLM : KC_HASH); break; default: if (shifted) { add_weak_mods(MOD_BIT(KC_LSFT)); } // & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift register_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode); } } void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) { switch(keycode) { case KC_LPRN: unregister_code16((!shifted) ? KC_LPRN : KC_COMM); break; case KC_RPRN: unregister_code16((!shifted) ? KC_RPRN : KC_DOT); break; case KC_COMM: unregister_code16((!shifted) ? KC_COMM : KC_LPRN); break; case KC_DOT: unregister_code16((!shifted) ? KC_DOT : KC_RPRN); break; case KC_ASTR: unregister_code16((!shifted) ? KC_ASTR : KC_PERC); break; case KC_EXLM: unregister_code16((!shifted) ? KC_EXLM : KC_HASH); break; default: // & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift // The IS_RETRO check isn't really necessary here, always using // keycode & 0xFF would be fine. unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode); } } // --- key overrides --- const key_override_t bspc_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL); // This globally defines all key overrides to be used const key_override_t *key_overrides[] = { &bspc_key_override, }; // --- tap dance --- // taken from https://docs.qmk.fm/features/tap_dance /* Return an integer that corresponds to what kind of tap dance should be executed. * * How to figure out tap dance state: interrupted and pressed. * * Interrupted: If the state of a dance is "interrupted", that means that another key has been hit * under the tapping term. This is typically indicative that you are trying to "tap" the key. * * Pressed: Whether or not the key is still being pressed. If this value is true, that means the tapping term * has ended, but the key is still being pressed down. This generally means the key is being "held". * * One thing that is currently not possible with qmk software in regards to tap dance is to mimic the "permissive hold" * feature. In general, advanced tap dances do not work well if they are used with commonly typed letters. * For example "A". Tap dances are best used on non-letter keys that are not hit while typing letters. * * Good places to put an advanced tap dance: * z,q,x,j,k,v,b, any function key, home/end, comma, semi-colon * * Criteria for "good placement" of a tap dance key: * Not a key that is hit frequently in a sentence * Not a key that is used frequently to double tap, for example 'tab' is often double tapped in a terminal, or * in a web form. So 'tab' would be a poor choice for a tap dance. * Letters used in common words as a double. For example 'p' in 'pepper'. If a tap dance function existed on the * letter 'p', the word 'pepper' would be quite frustrating to type. * * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested * */ td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. else return TD_SINGLE_HOLD; } else if (state->count == 2) { // TD_DOUBLE_SINGLE_TAP is to distinguish between typing "pepper", and actually wanting a double tap // action when hitting 'pp'. Suggested use case for this return value is when you want to send two // keystrokes of the key, and not the 'double tap' action/macro. if (state->interrupted) return TD_DOUBLE_SINGLE_TAP; else if (state->pressed) return TD_DOUBLE_HOLD; else return TD_DOUBLE_TAP; } // Assumes no one is trying to type the same letter three times (at least not quickly). // If your tap dance key is 'KC_W', and you want to type "www." quickly - then you will need to add // an exception here to return a 'TD_TRIPLE_SINGLE_TAP', and define that enum just like 'TD_DOUBLE_SINGLE_TAP' if (state->count == 3) { if (state->interrupted || !state->pressed) return TD_TRIPLE_TAP; else return TD_TRIPLE_HOLD; } else return TD_UNKNOWN; } // Create an instance of 'td_tap_t' for the 'x' tap dance. static td_tap_t xtap_state = { .is_press_action = true, .state = TD_NONE }; uint16_t t_layer[] = { KC_NO, KC_NO, KC_W, KC_E, KC_R, SH_TOGG, /**/ SH_TOGG, KC_U, KC_I, KC_O, KC_NO, KC_NO, KC_GRV, KC_A, KC_S, KC_D, KC_F, KC_G, /**/ KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, /**/ KC_N, KC_M, KC_T, KC_Y, KC_Q, KC_NO, // thumb cluster KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, }; uint16_t tt_layer[] = { KC_NO, KC_NO, LSFT(KC_COMM), LSFT(KC_DOT), KC_DLR, KC_NO, /**/ KC_NO, KC_BSLS, KC_AMPR, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO/*KC_ASTR*//*13*/, KC_COMM/*KC_LPRN*//*14*/, KC_DOT/*KC_RPRN*//*15*/, KC_MINS, KC_SLSH, /**/ KC_EXLM/*18*/, KC_EQL, KC_LBRC, KC_RBRC, KC_NO/*KC_P*/, RALT(KC_QUOT), KC_NO, KC_NO, KC_NO, KC_CIRC, KC_ASTR/*28*/, KC_GRV, /**/ KC_QUOT, KC_P, KC_AT, RALT(KC_QUOT)/*33*/, KC_NO, KC_NO, // thumb cluster KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, }; #define TAP_DANCE_FUNC(NAME, KEY_T, KEY_TH, KEY_TT, KEY_TTH) \ void x_finished##NAME (tap_dance_state_t *state, void *user_data) { \ xtap_state.state = cur_dance(state); \ switch (xtap_state.state) { \ case TD_SINGLE_TAP: register_code16(KEY_T); break; \ case TD_SINGLE_HOLD: register_code16(KEY_TH); break; \ case TD_DOUBLE_TAP: register_code16(KEY_TT); break; \ case TD_DOUBLE_HOLD: register_code16(KEY_TTH); break; \ case TD_DOUBLE_SINGLE_TAP: tap_code16(KEY_T); register_code16(KEY_T); break; \ default: break; \ } \ } \ void x_reset##NAME (tap_dance_state_t *state, void *user_data) { \ switch (xtap_state.state) { \ case TD_SINGLE_TAP: unregister_code16(KEY_T); break; \ case TD_SINGLE_HOLD: unregister_code16(KEY_TH); break; \ case TD_DOUBLE_TAP: unregister_code16(KEY_TT); break; \ case TD_DOUBLE_HOLD: unregister_code16(KEY_TTH); break; \ case TD_DOUBLE_SINGLE_TAP: unregister_code16(KEY_T); break; \ default: break; \ } \ xtap_state.state = TD_NONE; \ } #define TAP_DANCE_LAYER_FUNC_ALT(ID, KEY_TTH) \ void x_finished##ID (tap_dance_state_t *state, void *user_data) { \ xtap_state.state = cur_dance(state); \ switch (xtap_state.state) { \ case TD_SINGLE_TAP: register_code16(t_layer[ID]); break; \ case TD_SINGLE_HOLD: tap_code16(LSFT(t_layer[ID])); break; \ case TD_DOUBLE_TAP: register_code16(tt_layer[ID]); break; \ case TD_DOUBLE_HOLD: tap_code16(KEY_TTH); break; \ case TD_DOUBLE_SINGLE_TAP: register_code16(tt_layer[ID]); break; \ case TD_TRIPLE_TAP: tap_code16(t_layer[ID]); register_code16(t_layer[ID]); break; \ case TD_TRIPLE_HOLD: tap_code16(LSFT(t_layer[ID])); tap_code16(LSFT(t_layer[ID])); break; \ default: break; \ } \ } \ void x_reset##ID (tap_dance_state_t *state, void *user_data) { \ switch (xtap_state.state) { \ case TD_SINGLE_TAP: unregister_code16(t_layer[ID]); break; \ case TD_SINGLE_HOLD: break; \ case TD_DOUBLE_TAP: unregister_code16(tt_layer[ID]); break; \ case TD_DOUBLE_HOLD: break; \ case TD_DOUBLE_SINGLE_TAP: unregister_code16(tt_layer[ID]); break; \ case TD_TRIPLE_TAP: unregister_code16(t_layer[ID]); break; \ case TD_TRIPLE_HOLD: break; \ default: break; \ } \ xtap_state.state = TD_NONE; \ } #define TAP_DANCE_LAYER_FUNC(ID) \ TAP_DANCE_LAYER_FUNC_ALT(ID, LSFT(tt_layer[ID])) /* // void x_finished##ID (tap_dance_state_t *state, void *user_data) { \ // xtap_state.state = cur_dance(state); \ // switch (xtap_state.state) { \ // case TD_SINGLE_TAP: register_code16(t_layer[ID]); break; \ // case TD_SINGLE_HOLD: tap_code16(LSFT(t_layer[ID])); break; \ // case TD_DOUBLE_TAP: register_code16(tt_layer[ID]); break; \ // case TD_DOUBLE_HOLD: tap_code16(LSFT(tt_layer[ID])); break; \ // case TD_DOUBLE_SINGLE_TAP: register_code16(tt_layer[ID]); break; \ // default: break; \ // } \ // } \ // void x_reset##ID (tap_dance_state_t *state, void *user_data) { \ // switch (xtap_state.state) { \ // case TD_SINGLE_TAP: unregister_code16(t_layer[ID]); break; \ // case TD_SINGLE_HOLD: break; \ // case TD_DOUBLE_TAP: unregister_code16(tt_layer[ID]); break; \ // case TD_DOUBLE_HOLD: break; \ // case TD_DOUBLE_SINGLE_TAP: unregister_code16(tt_layer[ID]); break; \ // default: break; \ // } \ // xtap_state.state = TD_NONE; \ // } */ #define TAP_DANCE_ENT(NAME) \ [NAME] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished##NAME, x_reset##NAME), // void x_finished(tap_dance_state_t *state, void *user_data) { // xtap_state.state = cur_dance(state); // switch (xtap_state.state) { // case TD_SINGLE_TAP: register_code(KC_BSPC); break; // case TD_SINGLE_HOLD: register_code(KC_BSPC); break; // case TD_DOUBLE_TAP: register_code(KC_ENT); break; // case TD_DOUBLE_HOLD: register_code(KC_LCTL); break; // // Last case is for fast typing. Assuming your key is `f`: // // For example, when typing the word `buffer`, and you want to make sure that you send `ff` and not `Esc`. // // In order to type `ff` when typing fast, the next character will have to be hit within the `TAPPING_TERM`, which by default is 200ms. // case TD_DOUBLE_SINGLE_TAP: tap_code(KC_BSPC); register_code(KC_BSPC); break; // default: break; // } // } // void x_reset(tap_dance_state_t *state, void *user_data) { // switch (xtap_state.state) { // case TD_SINGLE_TAP: unregister_code(KC_BSPC); break; // case TD_SINGLE_HOLD: unregister_code(KC_BSPC); break; // case TD_DOUBLE_TAP: unregister_code(KC_ENT); break; // case TD_DOUBLE_HOLD: unregister_code(KC_LCTL); break; // case TD_DOUBLE_SINGLE_TAP: unregister_code(KC_BSPC); break; // default: break; // } // xtap_state.state = TD_NONE; // } // ------- mods ------- void x_finished37 (tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case TD_SINGLE_TAP: tap_code16(get_last_keycode()); break; case TD_SINGLE_HOLD: layer_on(4); break; default: break; } } void x_reset37 (tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case TD_SINGLE_TAP: /*unregister_code16(QK_REP);*/ break; case TD_SINGLE_HOLD: layer_off(4); break; default: break; } xtap_state.state = TD_NONE; } void x_finished40 (tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case TD_SINGLE_TAP: register_code16(QK_REP); break; case TD_SINGLE_HOLD: layer_on(5); break; default: break; } } void x_reset40 (tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case TD_SINGLE_TAP: unregister_code16(QK_REP); break; case TD_SINGLE_HOLD: layer_off(5); break; default: break; } xtap_state.state = TD_NONE; } // ------- // TAP_DANCE_FUNC(X_RMAIN, KC_BSPC, KC_BSPC, KC_ENT, KC_LCTL) TAP_DANCE_LAYER_FUNC(0) TAP_DANCE_LAYER_FUNC(1) TAP_DANCE_LAYER_FUNC(2) TAP_DANCE_LAYER_FUNC(3) TAP_DANCE_LAYER_FUNC(4) TAP_DANCE_LAYER_FUNC(5) TAP_DANCE_LAYER_FUNC(6) TAP_DANCE_LAYER_FUNC(7) TAP_DANCE_LAYER_FUNC(8) TAP_DANCE_LAYER_FUNC(9) TAP_DANCE_LAYER_FUNC(10) TAP_DANCE_LAYER_FUNC(11) TAP_DANCE_LAYER_FUNC(12) TAP_DANCE_LAYER_FUNC_ALT(13, KC_PERC) TAP_DANCE_LAYER_FUNC_ALT(14, KC_LPRN) //KC_COMM) TAP_DANCE_LAYER_FUNC_ALT(15, KC_RPRN) //KC_DOT) TAP_DANCE_LAYER_FUNC(16) TAP_DANCE_LAYER_FUNC(17) TAP_DANCE_LAYER_FUNC_ALT(18, KC_HASH) TAP_DANCE_LAYER_FUNC(19) TAP_DANCE_LAYER_FUNC(20) TAP_DANCE_LAYER_FUNC(21) TAP_DANCE_LAYER_FUNC(22) TAP_DANCE_LAYER_FUNC(23) TAP_DANCE_LAYER_FUNC(24) TAP_DANCE_LAYER_FUNC(25) TAP_DANCE_LAYER_FUNC(26) TAP_DANCE_LAYER_FUNC(27) TAP_DANCE_LAYER_FUNC_ALT(28, KC_PERC) TAP_DANCE_LAYER_FUNC(29) TAP_DANCE_LAYER_FUNC(30) TAP_DANCE_LAYER_FUNC(31) TAP_DANCE_LAYER_FUNC(32) TAP_DANCE_LAYER_FUNC_ALT(33, RALT(KC_QUOT)) TAP_DANCE_LAYER_FUNC(34) TAP_DANCE_LAYER_FUNC(35) TAP_DANCE_LAYER_FUNC(36) // TAP_DANCE_FUNC(37, QK_AREP, MO(4), QK_AREP, MO(4)) //TAP_DANCE_LAYER_FUNC(37) TAP_DANCE_LAYER_FUNC(38) TAP_DANCE_LAYER_FUNC(39) // TAP_DANCE_FUNC(40, QK_REP, MO(5), QK_REP, MO(5)) //TAP_DANCE_LAYER_FUNC(40) TAP_DANCE_LAYER_FUNC(41) tap_dance_action_t tap_dance_actions[] = { TAP_DANCE_ENT(0) TAP_DANCE_ENT(1) TAP_DANCE_ENT(2) TAP_DANCE_ENT(3) TAP_DANCE_ENT(4) TAP_DANCE_ENT(5) TAP_DANCE_ENT(6) TAP_DANCE_ENT(7) TAP_DANCE_ENT(8) TAP_DANCE_ENT(9) TAP_DANCE_ENT(10) TAP_DANCE_ENT(11) TAP_DANCE_ENT(12) TAP_DANCE_ENT(13) TAP_DANCE_ENT(14) TAP_DANCE_ENT(15) TAP_DANCE_ENT(16) TAP_DANCE_ENT(17) TAP_DANCE_ENT(18) TAP_DANCE_ENT(19) TAP_DANCE_ENT(20) TAP_DANCE_ENT(21) TAP_DANCE_ENT(22) TAP_DANCE_ENT(23) TAP_DANCE_ENT(24) TAP_DANCE_ENT(25) TAP_DANCE_ENT(26) TAP_DANCE_ENT(27) TAP_DANCE_ENT(28) TAP_DANCE_ENT(29) TAP_DANCE_ENT(30) TAP_DANCE_ENT(31) TAP_DANCE_ENT(32) TAP_DANCE_ENT(33) TAP_DANCE_ENT(34) TAP_DANCE_ENT(35) // thumb keys TAP_DANCE_ENT(36) TAP_DANCE_ENT(37) TAP_DANCE_ENT(38) TAP_DANCE_ENT(39) TAP_DANCE_ENT(40) TAP_DANCE_ENT(41) // TAP_DANCE_ENT(X_RMAIN) // [X_RMAIN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset), // [X_CHECK] = ACTION_TAP_DANCE_DOUBLE(KC_X, LSFT(KC_MINS)) };