st/my_crkbd_firmware
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/my-crkbd-firmware.git synced 2025-12-22 22:58:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
my_crkbd_firmware/keymaps/default/keymap.c
ProgramSnail 9257714ece improvements
2025-09-08 13:38:27 +03:00

526 lines
21 KiB
C
Raw Permalink Blame History

#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))
};
Reference in a new issue View git blame Copy permalink