diff --git a/keyboards/moonlander/keymaps/erez/config.h b/keyboards/moonlander/keymaps/erez/config.h new file mode 100644 index 0000000000..f760626aa4 --- /dev/null +++ b/keyboards/moonlander/keymaps/erez/config.h @@ -0,0 +1,11 @@ +/* + Set any config.h overrides for your specific keymap here. + See config.h options at https://docs.qmk.fm/#/config_options?id=the-configh-file +*/ +#define ORYX_CONFIGURATOR +#undef DEBOUNCE +#define DEBOUNCE 5 + +#define USB_SUSPEND_WAKEUP_DELAY 0 +#define FIRMWARE_VERSION u8"60Aor/mX3dD" +#define RGB_MATRIX_STARTUP_SPD 60 diff --git a/keyboards/moonlander/keymaps/erez/keymap.c b/keyboards/moonlander/keymaps/erez/keymap.c new file mode 100644 index 0000000000..baf1720b55 --- /dev/null +++ b/keyboards/moonlander/keymaps/erez/keymap.c @@ -0,0 +1,1033 @@ +#include QMK_KEYBOARD_H +#include "version.h" +#include "keymap_german.h" +#include "keymap_nordic.h" +#include "keymap_french.h" +#include "keymap_spanish.h" +#include "keymap_hungarian.h" +#include "keymap_swedish.h" +#include "keymap_br_abnt2.h" +#include "keymap_canadian_multilingual.h" +#include "keymap_german_ch.h" +#include "keymap_jp.h" +#include "keymap_korean.h" +#include "keymap_bepo.h" +#include "keymap_italian.h" +#include "keymap_slovenian.h" +#include "keymap_lithuanian_azerty.h" +#include "keymap_danish.h" +#include "keymap_norwegian.h" +#include "keymap_portuguese.h" +#include "keymap_contributions.h" +#include "keymap_czech.h" +#include "keymap_romanian.h" +#include "keymap_russian.h" +#include "keymap_uk.h" +#include "keymap_estonian.h" +#include "keymap_belgian.h" +#include "keymap_us_international.h" + +#define KC_MAC_UNDO LGUI(KC_Z) +#define KC_MAC_CUT LGUI(KC_X) +#define KC_MAC_COPY LGUI(KC_C) +#define KC_MAC_PASTE LGUI(KC_V) +#define KC_PC_UNDO LCTL(KC_Z) +#define KC_PC_CUT LCTL(KC_X) +#define KC_PC_COPY LCTL(KC_C) +#define KC_PC_PASTE LCTL(KC_V) +#define ES_LESS_MAC KC_GRAVE +#define ES_GRTR_MAC LSFT(KC_GRAVE) +#define ES_BSLS_MAC ALGR(KC_6) +#define NO_PIPE_ALT KC_GRAVE +#define NO_BSLS_ALT KC_EQUAL +#define LSA_T(kc) MT(MOD_LSFT | MOD_LALT, kc) +#define BP_NDSH_MAC ALGR(KC_8) +#define MOON_LED_LEVEL LED_LEVEL + +enum custom_keycodes { + RGB_SLD = ML_SAFE_RANGE, +}; + + +enum tap_dance_codes { + DANCE_0, + DANCE_1, + DANCE_2, + DANCE_3, + DANCE_4, + DANCE_5, + DANCE_6, + DANCE_7, + DANCE_8, + DANCE_9, + DANCE_10, + DANCE_11, + DANCE_12, + DANCE_13, + DANCE_14, + DANCE_15, + DANCE_16, + DANCE_17, + DANCE_18, + DANCE_19, + DANCE_20, + DANCE_21, + DANCE_22, +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT_moonlander( + TD(DANCE_0), TD(DANCE_1), TD(DANCE_2), TD(DANCE_3), TD(DANCE_4), TD(DANCE_5), TD(DANCE_6), LGUI(KC_EQUAL), KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINUS, + KC_DELETE, TD(DANCE_7), TD(DANCE_8), KC_E, KC_R, KC_T, TD(DANCE_9), KC_NO, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSLASH, + TD(DANCE_10), KC_A, KC_S, KC_D, TD(DANCE_11), KC_G, KC_HYPR, KC_MEH, KC_H, LGUI_T(KC_J), RALT_T(KC_K), KC_L, LT(2,KC_SCOLON),LGUI_T(KC_QUOTE), + KC_LSPO, LCTL_T(KC_Z), TD(DANCE_12), TD(DANCE_13), TD(DANCE_14), KC_B, KC_N, TD(DANCE_19), KC_COMMA, KC_DOT, KC_SLASH, KC_RSPC, + KC_GRAVE, KC_ESCAPE, DPI_CONFIG, TD(DANCE_15), KC_SPACE, LCTL(KC_SPACE), LGUI(LSFT(KC_SCOLON)),TD(DANCE_20), TD(DANCE_21), KC_LBRACKET, KC_RBRACKET, KC_NO, + KC_SPACE, TD(DANCE_17), TD(DANCE_18), KC_END, TD(DANCE_22), KC_ENTER + ), + [1] = LAYOUT_moonlander( + KC_ESCAPE, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_TRANSPARENT, KC_TRANSPARENT, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_F12, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, TOGGLE_LAYER_COLOR,KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_F2, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, LCTL(KC_PGUP), LCTL(KC_PGDOWN),RGB_MOD, RGB_TOG, RGB_HUI, RGB_HUD, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, + RGB_VAD, RGB_VAI, TOGGLE_LAYER_COLOR, RGB_SLD, KC_TRANSPARENT, LGUI(KC_ENTER) + ), + [2] = LAYOUT_moonlander( + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, RESET, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_5, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, MAGIC_TOGGLE_NKRO, + KC_TRANSPARENT, KC_LEFT, KC_UP, KC_DOWN, KC_RIGHT, KC_5, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_MINUS, KC_TRANSPARENT, KC_MEDIA_PLAY_PAUSE, + KC_TRANSPARENT, KC_6, KC_7, KC_8, KC_9, KC_0, KC_TRANSPARENT, KC_TRANSPARENT, KC_MEDIA_PREV_TRACK,KC_MEDIA_NEXT_TRACK,KC_TRANSPARENT, KC_TRANSPARENT, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, LCTL(KC_LEFT), LCTL(KC_RIGHT), WEBUSB_PAIR, KC_WWW_FORWARD, KC_AUDIO_VOL_UP,KC_AUDIO_VOL_DOWN,KC_AUDIO_MUTE, KC_TRANSPARENT, KC_TRANSPARENT, + KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_PGDOWN, KC_PGUP + ), +}; + +extern bool g_suspend_state; +extern rgb_config_t rgb_matrix_config; + +void keyboard_post_init_user(void) { + rgb_matrix_enable(); +} + +const uint8_t PROGMEM ledmap[][DRIVER_LED_TOTAL][3] = { + [1] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {30,96,255}, {30,96,255}, {0,0,0}, {0,0,0}, {30,96,255}, {0,0,0}, {30,96,255}, {0,0,0}, {0,0,0}, {0,0,0}, {30,96,255}, {30,96,255}, {31,255,255}, {0,0,0}, {0,0,0}, {30,96,255}, {30,96,255}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {30,96,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} }, + + [2] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,205,155}, {0,0,255}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {31,255,255}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {31,255,255}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {31,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} }, + +}; + +void set_layer_color(int layer) { + for (int i = 0; i < DRIVER_LED_TOTAL; i++) { + HSV hsv = { + .h = pgm_read_byte(&ledmap[layer][i][0]), + .s = pgm_read_byte(&ledmap[layer][i][1]), + .v = pgm_read_byte(&ledmap[layer][i][2]), + }; + if (!hsv.h && !hsv.s && !hsv.v) { + rgb_matrix_set_color( i, 0, 0, 0 ); + } else { + RGB rgb = hsv_to_rgb( hsv ); + float f = (float)rgb_matrix_config.hsv.v / UINT8_MAX; + rgb_matrix_set_color( i, f * rgb.r, f * rgb.g, f * rgb.b ); + } + } +} + +void rgb_matrix_indicators_user(void) { + if (keyboard_config.disable_layer_led) { return; } + switch (biton32(layer_state)) { + case 1: + set_layer_color(1); + break; + case 2: + set_layer_color(2); + break; + default: + if (rgb_matrix_get_flags() == LED_FLAG_NONE) + rgb_matrix_set_color_all(0, 0, 0); + break; + } +} + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case RGB_SLD: + if (record->event.pressed) { + rgblight_mode(1); + } + return false; + } + return true; +} + +typedef struct { + bool is_press_action; + uint8_t step; +} tap; + +enum { + SINGLE_TAP = 1, + SINGLE_HOLD, + DOUBLE_TAP, + DOUBLE_HOLD, + DOUBLE_SINGLE_TAP, + MORE_TAPS +}; + +static tap dance_state[23]; + +uint8_t dance_step(qk_tap_dance_state_t *state); + +uint8_t dance_step(qk_tap_dance_state_t *state) { + if (state->count == 1) { + if (state->interrupted || !state->pressed) return SINGLE_TAP; + else return SINGLE_HOLD; + } else if (state->count == 2) { + if (state->interrupted) return DOUBLE_SINGLE_TAP; + else if (state->pressed) return DOUBLE_HOLD; + else return DOUBLE_TAP; + } + return MORE_TAPS; +} + + +void on_dance_0(qk_tap_dance_state_t *state, void *user_data); +void dance_0_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_0_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_0(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_EQUAL); + tap_code16(KC_EQUAL); + tap_code16(KC_EQUAL); + } + if(state->count > 3) { + tap_code16(KC_EQUAL); + } +} + +void dance_0_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[0].step = dance_step(state); + switch (dance_state[0].step) { + case SINGLE_TAP: register_code16(KC_EQUAL); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F18))))); break; + case DOUBLE_TAP: register_code16(KC_EQUAL); register_code16(KC_EQUAL); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_EQUAL); register_code16(KC_EQUAL); + } +} + +void dance_0_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[0].step) { + case SINGLE_TAP: unregister_code16(KC_EQUAL); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F18))))); break; + case DOUBLE_TAP: unregister_code16(KC_EQUAL); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_EQUAL); break; + } + dance_state[0].step = 0; +} +void on_dance_1(qk_tap_dance_state_t *state, void *user_data); +void dance_1_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_1_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_1(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_1); + tap_code16(KC_1); + tap_code16(KC_1); + } + if(state->count > 3) { + tap_code16(KC_1); + } +} + +void dance_1_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[1].step = dance_step(state); + switch (dance_state[1].step) { + case SINGLE_TAP: register_code16(KC_1); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F11))))); break; + case DOUBLE_TAP: register_code16(KC_1); register_code16(KC_1); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_1); register_code16(KC_1); + } +} + +void dance_1_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[1].step) { + case SINGLE_TAP: unregister_code16(KC_1); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F11))))); break; + case DOUBLE_TAP: unregister_code16(KC_1); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_1); break; + } + dance_state[1].step = 0; +} +void on_dance_2(qk_tap_dance_state_t *state, void *user_data); +void dance_2_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_2_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_2(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_2); + tap_code16(KC_2); + tap_code16(KC_2); + } + if(state->count > 3) { + tap_code16(KC_2); + } +} + +void dance_2_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[2].step = dance_step(state); + switch (dance_state[2].step) { + case SINGLE_TAP: register_code16(KC_2); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F12))))); break; + case DOUBLE_TAP: register_code16(KC_2); register_code16(KC_2); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_2); register_code16(KC_2); + } +} + +void dance_2_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[2].step) { + case SINGLE_TAP: unregister_code16(KC_2); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F12))))); break; + case DOUBLE_TAP: unregister_code16(KC_2); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_2); break; + } + dance_state[2].step = 0; +} +void on_dance_3(qk_tap_dance_state_t *state, void *user_data); +void dance_3_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_3_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_3(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_3); + tap_code16(KC_3); + tap_code16(KC_3); + } + if(state->count > 3) { + tap_code16(KC_3); + } +} + +void dance_3_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[3].step = dance_step(state); + switch (dance_state[3].step) { + case SINGLE_TAP: register_code16(KC_3); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F13))))); break; + case DOUBLE_TAP: register_code16(KC_3); register_code16(KC_3); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_3); register_code16(KC_3); + } +} + +void dance_3_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[3].step) { + case SINGLE_TAP: unregister_code16(KC_3); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F13))))); break; + case DOUBLE_TAP: unregister_code16(KC_3); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_3); break; + } + dance_state[3].step = 0; +} +void on_dance_4(qk_tap_dance_state_t *state, void *user_data); +void dance_4_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_4_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_4(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_4); + tap_code16(KC_4); + tap_code16(KC_4); + } + if(state->count > 3) { + tap_code16(KC_4); + } +} + +void dance_4_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[4].step = dance_step(state); + switch (dance_state[4].step) { + case SINGLE_TAP: register_code16(KC_4); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F14))))); break; + case DOUBLE_TAP: register_code16(KC_4); register_code16(KC_4); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_4); register_code16(KC_4); + } +} + +void dance_4_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[4].step) { + case SINGLE_TAP: unregister_code16(KC_4); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F14))))); break; + case DOUBLE_TAP: unregister_code16(KC_4); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_4); break; + } + dance_state[4].step = 0; +} +void on_dance_5(qk_tap_dance_state_t *state, void *user_data); +void dance_5_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_5_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_5(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_5); + tap_code16(KC_5); + tap_code16(KC_5); + } + if(state->count > 3) { + tap_code16(KC_5); + } +} + +void dance_5_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[5].step = dance_step(state); + switch (dance_state[5].step) { + case SINGLE_TAP: register_code16(KC_5); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F15))))); break; + case DOUBLE_TAP: register_code16(KC_5); register_code16(KC_5); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_5); register_code16(KC_5); + } +} + +void dance_5_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[5].step) { + case SINGLE_TAP: unregister_code16(KC_5); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F15))))); break; + case DOUBLE_TAP: unregister_code16(KC_5); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_5); break; + } + dance_state[5].step = 0; +} +void on_dance_6(qk_tap_dance_state_t *state, void *user_data); +void dance_6_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_6_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_6(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(LGUI(KC_MINUS)); + tap_code16(LGUI(KC_MINUS)); + tap_code16(LGUI(KC_MINUS)); + } + if(state->count > 3) { + tap_code16(LGUI(KC_MINUS)); + } +} + +void dance_6_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[6].step = dance_step(state); + switch (dance_state[6].step) { + case SINGLE_TAP: register_code16(LGUI(KC_MINUS)); break; + case SINGLE_HOLD: register_code16(LALT(LCTL(LGUI(LSFT(KC_F16))))); break; + case DOUBLE_TAP: register_code16(LGUI(KC_MINUS)); register_code16(LGUI(KC_MINUS)); break; + case DOUBLE_SINGLE_TAP: tap_code16(LGUI(KC_MINUS)); register_code16(LGUI(KC_MINUS)); + } +} + +void dance_6_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[6].step) { + case SINGLE_TAP: unregister_code16(LGUI(KC_MINUS)); break; + case SINGLE_HOLD: unregister_code16(LALT(LCTL(LGUI(LSFT(KC_F16))))); break; + case DOUBLE_TAP: unregister_code16(LGUI(KC_MINUS)); break; + case DOUBLE_SINGLE_TAP: unregister_code16(LGUI(KC_MINUS)); break; + } + dance_state[6].step = 0; +} +void on_dance_7(qk_tap_dance_state_t *state, void *user_data); +void dance_7_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_7_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_7(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_Q); + tap_code16(KC_Q); + tap_code16(KC_Q); + } + if(state->count > 3) { + tap_code16(KC_Q); + } +} + +void dance_7_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[7].step = dance_step(state); + switch (dance_state[7].step) { + case SINGLE_TAP: register_code16(KC_Q); break; + case SINGLE_HOLD: register_code16(LGUI(KC_Q)); break; + case DOUBLE_TAP: register_code16(KC_Q); register_code16(KC_Q); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_Q); register_code16(KC_Q); + } +} + +void dance_7_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[7].step) { + case SINGLE_TAP: unregister_code16(KC_Q); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_Q)); break; + case DOUBLE_TAP: unregister_code16(KC_Q); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_Q); break; + } + dance_state[7].step = 0; +} +void on_dance_8(qk_tap_dance_state_t *state, void *user_data); +void dance_8_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_8_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_8(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_W); + tap_code16(KC_W); + tap_code16(KC_W); + } + if(state->count > 3) { + tap_code16(KC_W); + } +} + +void dance_8_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[8].step = dance_step(state); + switch (dance_state[8].step) { + case SINGLE_TAP: register_code16(KC_W); break; + case SINGLE_HOLD: register_code16(LGUI(KC_W)); break; + case DOUBLE_TAP: register_code16(KC_W); register_code16(KC_W); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_W); register_code16(KC_W); + } +} + +void dance_8_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[8].step) { + case SINGLE_TAP: unregister_code16(KC_W); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_W)); break; + case DOUBLE_TAP: unregister_code16(KC_W); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_W); break; + } + dance_state[8].step = 0; +} +void on_dance_9(qk_tap_dance_state_t *state, void *user_data); +void dance_9_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_9_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_9(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(LCTL(KC_F16)); + tap_code16(LCTL(KC_F16)); + tap_code16(LCTL(KC_F16)); + } + if(state->count > 3) { + tap_code16(LCTL(KC_F16)); + } +} + +void dance_9_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[9].step = dance_step(state); + switch (dance_state[9].step) { + case SINGLE_TAP: register_code16(LCTL(KC_F16)); break; + case SINGLE_HOLD: register_code16(LCTL(KC_UP)); break; + case DOUBLE_TAP: register_code16(LCTL(KC_F16)); register_code16(LCTL(KC_F16)); break; + case DOUBLE_SINGLE_TAP: tap_code16(LCTL(KC_F16)); register_code16(LCTL(KC_F16)); + } +} + +void dance_9_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[9].step) { + case SINGLE_TAP: unregister_code16(LCTL(KC_F16)); break; + case SINGLE_HOLD: unregister_code16(LCTL(KC_UP)); break; + case DOUBLE_TAP: unregister_code16(LCTL(KC_F16)); break; + case DOUBLE_SINGLE_TAP: unregister_code16(LCTL(KC_F16)); break; + } + dance_state[9].step = 0; +} +void on_dance_10(qk_tap_dance_state_t *state, void *user_data); +void dance_10_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_10_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_10(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_BSPACE); + tap_code16(KC_BSPACE); + tap_code16(KC_BSPACE); + } + if(state->count > 3) { + tap_code16(KC_BSPACE); + } +} + +void dance_10_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[10].step = dance_step(state); + switch (dance_state[10].step) { + case SINGLE_TAP: register_code16(KC_BSPACE); break; + case SINGLE_HOLD: register_code16(LALT(KC_BSPACE)); break; + case DOUBLE_TAP: register_code16(KC_BSPACE); register_code16(KC_BSPACE); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_BSPACE); register_code16(KC_BSPACE); + } +} + +void dance_10_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[10].step) { + case SINGLE_TAP: unregister_code16(KC_BSPACE); break; + case SINGLE_HOLD: unregister_code16(LALT(KC_BSPACE)); break; + case DOUBLE_TAP: unregister_code16(KC_BSPACE); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_BSPACE); break; + } + dance_state[10].step = 0; +} +void on_dance_11(qk_tap_dance_state_t *state, void *user_data); +void dance_11_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_11_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_11(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_F); + tap_code16(KC_F); + tap_code16(KC_F); + } + if(state->count > 3) { + tap_code16(KC_F); + } +} + +void dance_11_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[11].step = dance_step(state); + switch (dance_state[11].step) { + case SINGLE_TAP: register_code16(KC_F); break; + case SINGLE_HOLD: register_code16(LGUI(KC_F)); break; + case DOUBLE_TAP: register_code16(KC_F); register_code16(KC_F); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_F); register_code16(KC_F); + } +} + +void dance_11_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[11].step) { + case SINGLE_TAP: unregister_code16(KC_F); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_F)); break; + case DOUBLE_TAP: unregister_code16(KC_F); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_F); break; + } + dance_state[11].step = 0; +} +void on_dance_12(qk_tap_dance_state_t *state, void *user_data); +void dance_12_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_12_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_12(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_X); + tap_code16(KC_X); + tap_code16(KC_X); + } + if(state->count > 3) { + tap_code16(KC_X); + } +} + +void dance_12_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[12].step = dance_step(state); + switch (dance_state[12].step) { + case SINGLE_TAP: register_code16(KC_X); break; + case SINGLE_HOLD: register_code16(LGUI(KC_X)); break; + case DOUBLE_TAP: register_code16(KC_X); register_code16(KC_X); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_X); register_code16(KC_X); + } +} + +void dance_12_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[12].step) { + case SINGLE_TAP: unregister_code16(KC_X); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_X)); break; + case DOUBLE_TAP: unregister_code16(KC_X); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_X); break; + } + dance_state[12].step = 0; +} +void on_dance_13(qk_tap_dance_state_t *state, void *user_data); +void dance_13_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_13_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_13(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_C); + tap_code16(KC_C); + tap_code16(KC_C); + } + if(state->count > 3) { + tap_code16(KC_C); + } +} + +void dance_13_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[13].step = dance_step(state); + switch (dance_state[13].step) { + case SINGLE_TAP: register_code16(KC_C); break; + case SINGLE_HOLD: register_code16(LGUI(KC_C)); break; + case DOUBLE_TAP: register_code16(KC_C); register_code16(KC_C); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_C); register_code16(KC_C); + } +} + +void dance_13_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[13].step) { + case SINGLE_TAP: unregister_code16(KC_C); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_C)); break; + case DOUBLE_TAP: unregister_code16(KC_C); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_C); break; + } + dance_state[13].step = 0; +} +void on_dance_14(qk_tap_dance_state_t *state, void *user_data); +void dance_14_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_14_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_14(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_V); + tap_code16(KC_V); + tap_code16(KC_V); + } + if(state->count > 3) { + tap_code16(KC_V); + } +} + +void dance_14_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[14].step = dance_step(state); + switch (dance_state[14].step) { + case SINGLE_TAP: register_code16(KC_V); break; + case SINGLE_HOLD: register_code16(LGUI(KC_V)); break; + case DOUBLE_TAP: register_code16(KC_V); register_code16(KC_V); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_V); register_code16(KC_V); + } +} + +void dance_14_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[14].step) { + case SINGLE_TAP: unregister_code16(KC_V); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_V)); break; + case DOUBLE_TAP: unregister_code16(KC_V); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_V); break; + } + dance_state[14].step = 0; +} +void on_dance_15(qk_tap_dance_state_t *state, void *user_data); +void dance_15_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_15_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_15(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_LEFT); + tap_code16(KC_LEFT); + tap_code16(KC_LEFT); + } + if(state->count > 3) { + tap_code16(KC_LEFT); + } +} + +void dance_15_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[15].step = dance_step(state); + switch (dance_state[15].step) { + case SINGLE_TAP: register_code16(KC_LEFT); break; + case SINGLE_HOLD: register_code16(LALT(KC_LEFT)); break; + case DOUBLE_TAP: register_code16(LCTL(KC_PGUP)); break; + case DOUBLE_HOLD: register_code16(KC_HOME); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_LEFT); register_code16(KC_LEFT); + } +} + +void dance_15_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[15].step) { + case SINGLE_TAP: unregister_code16(KC_LEFT); break; + case SINGLE_HOLD: unregister_code16(LALT(KC_LEFT)); break; + case DOUBLE_TAP: unregister_code16(LCTL(KC_PGUP)); break; + case DOUBLE_HOLD: unregister_code16(KC_HOME); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_LEFT); break; + } + dance_state[15].step = 0; +} +void on_dance_16(qk_tap_dance_state_t *state, void *user_data); +void dance_16_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_16_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_16(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_SPACE); + tap_code16(KC_SPACE); + tap_code16(KC_SPACE); + } + if(state->count > 3) { + tap_code16(KC_SPACE); + } +} + +void dance_16_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[16].step = dance_step(state); + switch (dance_state[16].step) { + case SINGLE_TAP: register_code16(KC_SPACE); break; + case SINGLE_HOLD: register_code16(LALT(KC_RIGHT)); break; + case DOUBLE_TAP: register_code16(LCTL(KC_PGDOWN)); break; + case DOUBLE_HOLD: register_code16(KC_END); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_SPACE); register_code16(KC_RIGHT); + } +} + +void dance_16_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[16].step) { + case SINGLE_TAP: unregister_code16(KC_RIGHT); break; + case SINGLE_HOLD: unregister_code16(LALT(KC_RIGHT)); break; + case DOUBLE_TAP: unregister_code16(LCTL(KC_PGDOWN)); break; + case DOUBLE_HOLD: unregister_code16(KC_END); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_RIGHT); break; + } + dance_state[16].step = 0; +} +void on_dance_17(qk_tap_dance_state_t *state, void *user_data); +void dance_17_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_17_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_17(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_TAB); + tap_code16(KC_TAB); + tap_code16(KC_TAB); + } + if(state->count > 3) { + tap_code16(KC_TAB); + } +} + +void dance_17_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[17].step = dance_step(state); + switch (dance_state[17].step) { + case SINGLE_TAP: register_code16(KC_TAB); break; + case SINGLE_HOLD: register_code16(LSFT(KC_F20)); break; + case DOUBLE_TAP: register_code16(KC_TAB); register_code16(KC_TAB); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_TAB); register_code16(KC_TAB); + } +} + +void dance_17_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[17].step) { + case SINGLE_TAP: unregister_code16(KC_TAB); break; + case SINGLE_HOLD: unregister_code16(LSFT(KC_F20)); break; + case DOUBLE_TAP: unregister_code16(KC_TAB); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_TAB); break; + } + dance_state[17].step = 0; +} +void on_dance_18(qk_tap_dance_state_t *state, void *user_data); +void dance_18_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_18_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_18(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_HOME); + tap_code16(KC_HOME); + tap_code16(KC_HOME); + } + if(state->count > 3) { + tap_code16(KC_HOME); + } +} + +void dance_18_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[18].step = dance_step(state); + switch (dance_state[18].step) { + case SINGLE_TAP: register_code16(KC_HOME); break; + case SINGLE_HOLD: register_code16(KC_F20); break; + case DOUBLE_TAP: register_code16(KC_HOME); register_code16(KC_HOME); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_HOME); register_code16(KC_HOME); + } +} + +void dance_18_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[18].step) { + case SINGLE_TAP: unregister_code16(KC_HOME); break; + case SINGLE_HOLD: unregister_code16(KC_F20); break; + case DOUBLE_TAP: unregister_code16(KC_HOME); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_HOME); break; + } + dance_state[18].step = 0; +} +void on_dance_19(qk_tap_dance_state_t *state, void *user_data); +void dance_19_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_19_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_19(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_M); + tap_code16(KC_M); + tap_code16(KC_M); + } + if(state->count > 3) { + tap_code16(KC_M); + } +} + +void dance_19_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[19].step = dance_step(state); + switch (dance_state[19].step) { + case SINGLE_TAP: register_code16(KC_M); break; + case SINGLE_HOLD: register_code16(LGUI(KC_SPACE)); break; + case DOUBLE_TAP: register_code16(KC_M); register_code16(KC_M); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_M); register_code16(KC_M); + } +} + +void dance_19_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[19].step) { + case SINGLE_TAP: unregister_code16(KC_M); break; + case SINGLE_HOLD: unregister_code16(LGUI(KC_SPACE)); break; + case DOUBLE_TAP: unregister_code16(KC_M); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_M); break; + } + dance_state[19].step = 0; +} +void on_dance_20(qk_tap_dance_state_t *state, void *user_data); +void dance_20_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_20_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_20(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_UP); + tap_code16(KC_UP); + tap_code16(KC_UP); + } + if(state->count > 3) { + tap_code16(KC_UP); + } +} + +void dance_20_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[20].step = dance_step(state); + switch (dance_state[20].step) { + case SINGLE_TAP: register_code16(KC_UP); break; + case SINGLE_HOLD: register_code16(KC_AUDIO_VOL_UP); break; + case DOUBLE_TAP: register_code16(KC_PGUP); break; + case DOUBLE_HOLD: register_code16(LGUI(KC_U)); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_UP); register_code16(KC_UP); + } +} + +void dance_20_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[20].step) { + case SINGLE_TAP: unregister_code16(KC_UP); break; + case SINGLE_HOLD: unregister_code16(KC_AUDIO_VOL_UP); break; + case DOUBLE_TAP: unregister_code16(KC_PGUP); break; + case DOUBLE_HOLD: unregister_code16(LGUI(KC_U)); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_UP); break; + } + dance_state[20].step = 0; +} +void on_dance_21(qk_tap_dance_state_t *state, void *user_data); +void dance_21_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_21_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_21(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_DOWN); + tap_code16(KC_DOWN); + tap_code16(KC_DOWN); + } + if(state->count > 3) { + tap_code16(KC_DOWN); + } +} + +void dance_21_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[21].step = dance_step(state); + switch (dance_state[21].step) { + case SINGLE_TAP: register_code16(KC_DOWN); break; + case SINGLE_HOLD: register_code16(KC_AUDIO_VOL_DOWN); break; + case DOUBLE_TAP: register_code16(KC_PGDOWN); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_DOWN); register_code16(KC_DOWN); + } +} + +void dance_21_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[21].step) { + case SINGLE_TAP: unregister_code16(KC_DOWN); break; + case SINGLE_HOLD: unregister_code16(KC_AUDIO_VOL_DOWN); break; + case DOUBLE_TAP: unregister_code16(KC_PGDOWN); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_DOWN); break; + } + dance_state[21].step = 0; +} +void on_dance_22(qk_tap_dance_state_t *state, void *user_data); +void dance_22_finished(qk_tap_dance_state_t *state, void *user_data); +void dance_22_reset(qk_tap_dance_state_t *state, void *user_data); + +void on_dance_22(qk_tap_dance_state_t *state, void *user_data) { + if(state->count == 3) { + tap_code16(KC_TAB); + tap_code16(KC_TAB); + tap_code16(KC_TAB); + } + if(state->count > 3) { + tap_code16(KC_TAB); + } +} + +void dance_22_finished(qk_tap_dance_state_t *state, void *user_data) { + dance_state[22].step = dance_step(state); + switch (dance_state[22].step) { + case SINGLE_TAP: register_code16(KC_TAB); break; + case SINGLE_HOLD: layer_on(1); break; + case DOUBLE_TAP: register_code16(KC_TAB); register_code16(KC_TAB); break; + case DOUBLE_HOLD: layer_on(2); break; + case DOUBLE_SINGLE_TAP: tap_code16(KC_TAB); register_code16(KC_TAB); + } +} + +void dance_22_reset(qk_tap_dance_state_t *state, void *user_data) { + wait_ms(10); + switch (dance_state[22].step) { + case SINGLE_TAP: unregister_code16(KC_TAB); break; + case SINGLE_HOLD: layer_off(1); break; + case DOUBLE_TAP: unregister_code16(KC_TAB); break; + case DOUBLE_HOLD: layer_off(2); break; + case DOUBLE_SINGLE_TAP: unregister_code16(KC_TAB); break; + } + dance_state[22].step = 0; +} + +qk_tap_dance_action_t tap_dance_actions[] = { + [DANCE_0] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_0, dance_0_finished, dance_0_reset), + [DANCE_1] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_1, dance_1_finished, dance_1_reset), + [DANCE_2] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_2, dance_2_finished, dance_2_reset), + [DANCE_3] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_3, dance_3_finished, dance_3_reset), + [DANCE_4] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_4, dance_4_finished, dance_4_reset), + [DANCE_5] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_5, dance_5_finished, dance_5_reset), + [DANCE_6] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_6, dance_6_finished, dance_6_reset), + [DANCE_7] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_7, dance_7_finished, dance_7_reset), + [DANCE_8] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_8, dance_8_finished, dance_8_reset), + [DANCE_9] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_9, dance_9_finished, dance_9_reset), + [DANCE_10] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_10, dance_10_finished, dance_10_reset), + [DANCE_11] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_11, dance_11_finished, dance_11_reset), + [DANCE_12] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_12, dance_12_finished, dance_12_reset), + [DANCE_13] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_13, dance_13_finished, dance_13_reset), + [DANCE_14] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_14, dance_14_finished, dance_14_reset), + [DANCE_15] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_15, dance_15_finished, dance_15_reset), + [DANCE_16] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_16, dance_16_finished, dance_16_reset), + [DANCE_17] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_17, dance_17_finished, dance_17_reset), + [DANCE_18] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_18, dance_18_finished, dance_18_reset), + [DANCE_19] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_19, dance_19_finished, dance_19_reset), + [DANCE_20] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_20, dance_20_finished, dance_20_reset), + [DANCE_21] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_21, dance_21_finished, dance_21_reset), + [DANCE_22] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_22, dance_22_finished, dance_22_reset), +}; + diff --git a/keyboards/moonlander/keymaps/erez/rules.mk b/keyboards/moonlander/keymaps/erez/rules.mk new file mode 100644 index 0000000000..626f9e4de9 --- /dev/null +++ b/keyboards/moonlander/keymaps/erez/rules.mk @@ -0,0 +1,8 @@ +# Set any rules.mk overrides for your specific keymap here. +# See rules at https://docs.qmk.fm/#/config_options?id=the-rulesmk-file +CONSOLE_ENABLE = no +COMMAND_ENABLE = no +MOUSEKEY_ENABLE = no +WEBUSB_ENABLE = yes +ORYX_ENABLE = yes +TAP_DANCE_ENABLE = yes