4 ///// QUAD FUNCTION TAP DANCE GENERAL SETUP SECTION START /////
5 ///// (no need to edit this section) /////
6 //Enums used to clearly convey the state of the tap dance
12 DOUBLE_SINGLE_TAP = 5 //send SINGLE_TAP twice - NOT DOUBLE_TAP
13 // Add more enums here if you want for triple, quadruple, etc.
21 int cur_dance (qk_tap_dance_state_t *state) {
22 if (state->count == 1) {
23 //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
24 if (state->interrupted || !state->pressed) return SINGLE_TAP;
25 if (state->interrupted) return SINGLE_TAP;
26 else return SINGLE_HOLD;
28 //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
30 else if (state->count == 2) {
31 if (state->interrupted) return DOUBLE_SINGLE_TAP;
32 else if (state->pressed) return DOUBLE_HOLD;
33 else return DOUBLE_TAP;
35 else return 6; //magic number. At some point this method will expand to work for more presses
37 ///// QUAD FUNCTION TAP DANCE GENERAL SETUP SECTION END /////
38 ///// QUAD FUNCTION TAP DANCE PERSONALIZATION SECTION START /////
39 //instantiate 'tap' for the 'ENT' tap dance.
40 static tap ENTtap_state = {
41 .is_press_action = true,
45 void ENT_finished (qk_tap_dance_state_t *state, void *user_data) {
46 ENTtap_state.state = cur_dance(state);
47 switch (ENTtap_state.state) {
48 case SINGLE_TAP: register_code(KC_SPC); break;
49 case SINGLE_HOLD: register_code(KC_LSFT); break;
50 case DOUBLE_TAP: register_code(KC_ENT); break;
51 case DOUBLE_HOLD: register_code(KC_NO); break; // setting double hold to do nothing (change this if you want)
52 case DOUBLE_SINGLE_TAP: register_code(KC_SPC); unregister_code(KC_SPC); register_code(KC_SPC);
53 //Last case is for fast typing. Assuming your key is `f`:
54 //For example, when typing the word `buffer`, and you want to make sure that you send `ff` and not `Esc`.
55 //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.
59 void ENT_reset (qk_tap_dance_state_t *state, void *user_data) {
60 switch (ENTtap_state.state) {
61 case SINGLE_TAP: unregister_code(KC_SPC); break;
62 case SINGLE_HOLD: unregister_code(KC_LSFT); break;
63 case DOUBLE_TAP: unregister_code(KC_ENT); break;
64 case DOUBLE_HOLD: unregister_code(KC_NO);
65 case DOUBLE_SINGLE_TAP: unregister_code(KC_SPC);
67 ENTtap_state.state = 0;
70 //instantiate 'tap' for the 'DEL' tap dance.
71 static tap DELtap_state = {
72 .is_press_action = true,
76 void DEL_finished (qk_tap_dance_state_t *state, void *user_data) {
77 DELtap_state.state = cur_dance(state);
78 switch (DELtap_state.state) {
79 case SINGLE_TAP: register_code(KC_BSPC); break;
80 case SINGLE_HOLD: register_code(KC_LCTL); break;
81 case DOUBLE_TAP: register_code(KC_DEL); break;
82 case DOUBLE_HOLD: register_code(KC_NO); break;
83 case DOUBLE_SINGLE_TAP: register_code(KC_BSPC); unregister_code(KC_BSPC); register_code(KC_BSPC);
87 void DEL_reset (qk_tap_dance_state_t *state, void *user_data) {
88 switch (DELtap_state.state) {
89 case SINGLE_TAP: unregister_code(KC_BSPC); break;
90 case SINGLE_HOLD: unregister_code(KC_LCTL); break;
91 case DOUBLE_TAP: unregister_code(KC_DEL); break;
92 case DOUBLE_HOLD: unregister_code(KC_NO);
93 case DOUBLE_SINGLE_TAP: unregister_code(KC_BSPC);
95 DELtap_state.state = 0;
98 //instantiate 'tap' for the 'CAD' tap dance.
99 static tap CADtap_state = {
100 .is_press_action = true,
104 void CAD_finished (qk_tap_dance_state_t *state, void *user_data) {
105 CADtap_state.state = cur_dance(state);
106 switch (CADtap_state.state) {
108 //register_code(KC_SPC);
109 SEND_STRING(SS_LGUI("l"));
110 #ifdef BACKLIGHT_ENABLE
115 //register_code(KC_NO);
116 //take a screenshot of a single window, open Paint and paste
117 SEND_STRING(SS_LALT(SS_TAP(X_PSCREEN)) SS_LGUI("r"));
119 SEND_STRING("mspaint" SS_TAP(X_ENTER));
121 SEND_STRING(SS_LCTRL("v"));
122 break; //register this keycode when button is held
124 //register_code(KC_ENT);
125 SEND_STRING(SS_LCTRL(SS_LALT(SS_TAP(X_DELETE))));
126 #ifdef BACKLIGHT_ENABLE
130 //case DOUBLE_HOLD: register_code(KC_NO); break; //register this keycode when button is tapped and then held
133 break; //register this keycode when button is tapped and then held
134 case DOUBLE_SINGLE_TAP: register_code(KC_NO); unregister_code(KC_NO); register_code(KC_NO);
138 void CAD_reset (qk_tap_dance_state_t *state, void *user_data) {
139 switch (CADtap_state.state) {
141 //unregister_code(KC_SPC);
142 SEND_STRING(SS_LGUI("l"));
143 #ifdef BACKLIGHT_ENABLE
148 register_code(KC_NO); //(un)register this keycode when button is held and then released
149 //SEND_STRING(SS_LCTRL("v"));
152 //register_code(KC_ENT);
153 SEND_STRING(SS_LCTRL(SS_LALT(SS_TAP(X_DELETE))));
154 #ifdef BACKLIGHT_ENABLE
158 case DOUBLE_HOLD: register_code(KC_NO); //(un)register this keycode when button is tapped and then held, and then released
159 case DOUBLE_SINGLE_TAP: unregister_code(KC_NO);
161 CADtap_state.state = 0;
164 //instantiate 'tap' for the 'RST' tap dance.
165 static tap RSTtap_state = {
166 .is_press_action = true,
170 void RST_finished (qk_tap_dance_state_t *state, void *user_data) {
171 RSTtap_state.state = cur_dance(state);
172 switch (RSTtap_state.state) {
173 case SINGLE_TAP: register_code(KC_LCTL); break;
174 case SINGLE_HOLD: register_code(KC_LCTL); break;
175 case DOUBLE_TAP: reset_keyboard(); break;
176 case DOUBLE_HOLD: register_code(KC_NO); break;
177 case DOUBLE_SINGLE_TAP: register_code(KC_LCTL); unregister_code(KC_LCTL); register_code(KC_LCTL);
181 void RST_reset (qk_tap_dance_state_t *state, void *user_data) {
182 switch (RSTtap_state.state) {
183 case SINGLE_TAP: unregister_code(KC_LCTL); break;
184 case SINGLE_HOLD: unregister_code(KC_LCTL); break;
185 case DOUBLE_TAP: unregister_code(KC_NO); break;
186 case DOUBLE_HOLD: unregister_code(KC_NO);
187 case DOUBLE_SINGLE_TAP: unregister_code(KC_LCTL);
189 RSTtap_state.state = 0;
192 //instantiate 'tap' for the 'LYR' tap dance.
193 static tap LYRtap_state = {
194 .is_press_action = true,
198 void LYR_finished (qk_tap_dance_state_t *state, void *user_data) {
199 LYRtap_state.state = cur_dance(state);
200 switch (LYRtap_state.state) {
201 case SINGLE_TAP: register_code(KC_PSLS); break;
202 case SINGLE_HOLD: register_code(KC_NO); break;
203 case DOUBLE_TAP: set_single_persistent_default_layer(_GK); break;
204 case DOUBLE_HOLD: register_code(KC_NO); break;
205 case DOUBLE_SINGLE_TAP: register_code(KC_PSLS); unregister_code(KC_PSLS); register_code(KC_PSLS);
209 void LYR_reset (qk_tap_dance_state_t *state, void *user_data) {
210 switch (LYRtap_state.state) {
211 case SINGLE_TAP: unregister_code(KC_PSLS); break;
212 case SINGLE_HOLD: unregister_code(KC_NO); break;
213 case DOUBLE_TAP: set_single_persistent_default_layer(_GK); break;
214 case DOUBLE_HOLD: unregister_code(KC_NO);
215 case DOUBLE_SINGLE_TAP: unregister_code(KC_PSLS);
217 LYRtap_state.state = 0;
219 ///// QUAD FUNCTION TAP DANCE PERSONALIZATION SECTION END /////
221 //Tap Dance Definitions
222 //THIS SECTION HAS TO BE AT THE END OF THE TAP DANCE SECTION
223 qk_tap_dance_action_t tap_dance_actions[] = {
224 [TD_SFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS)
225 // Other declarations would go here, separated by commas, if you have them
226 ,[TD_Q_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC)
227 ,[ENT_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ENT_finished, ENT_reset)
228 ,[DEL_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, DEL_finished, DEL_reset)
229 ,[RST_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, RST_finished, RST_reset)
230 ,[CAD_TD] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, CAD_finished, CAD_reset)
231 ,[LYR_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, LYR_finished, LYR_reset)
235 //In Layer declaration, add tap dance item in place of a key code