4 #include "process_keycode/process_tap_dance.h"
6 #if (__has_include("secret.h"))
9 const char secret[][64] = {
18 void register_hyper (void) { //Helper function to invoke Hyper
19 register_code (KC_LSFT);
20 register_code (KC_LCTL);
21 register_code (KC_LALT);
22 register_code (KC_LGUI);
24 void unregister_hyper (void) { //Helper function to invoke Hyper
25 unregister_code (KC_LSFT);
26 unregister_code (KC_LCTL);
27 unregister_code (KC_LALT);
28 unregister_code (KC_LGUI);
31 void register_ctrl_a (void) {
32 register_code(KC_LCTL);
36 void unregister_ctrl_a (void) {
37 unregister_code(KC_LCTL);
38 unregister_code(KC_A);
41 void register_alt_f7 (void) {
42 register_code (KC_LALT);
43 register_code (KC_F7);
46 void unregister_alt_f7 (void) {
47 unregister_code (KC_LALT);
48 unregister_code (KC_F7);
51 void register_shift_f6 (void) {
52 register_code (KC_LSFT);
53 register_code (KC_F6);
56 void unregister_shift_f6 (void) {
57 unregister_code (KC_LSFT);
58 unregister_code (KC_F6);
61 void register_ctrl_shift (void) {
62 register_code (KC_LSFT);
63 register_code (KC_LCTRL);
66 void unregister_ctrl_shift (void) {
67 unregister_code (KC_LSFT);
68 unregister_code (KC_LCTRL);
71 void register_alt_shift (void) {
72 register_code (KC_LSFT);
73 register_code (KC_LALT);
76 void unregister_alt_shift (void) {
77 unregister_code (KC_LSFT);
78 unregister_code (KC_LALT);
81 // To activate SINGLE_HOLD, you will need to hold for 200ms first.
82 // This tap dance favors keys that are used frequently in typing like 'f'
83 int cur_dance (qk_tap_dance_state_t *state) {
84 if (state->count == 1) {
85 //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
86 if (state->interrupted) {
87 // if (!state->pressed) return SINGLE_TAP;
88 //need "permissive hold" here.
89 // else return SINsGLE_HOLD;
90 //If the interrupting key is released before the tap-dance key, then it is a single HOLD
91 //However, if the tap-dance key is released first, then it is a single TAP
92 //But how to get access to the state of the interrupting key????
96 if (!state->pressed) return SINGLE_TAP;
97 else return SINGLE_HOLD;
100 //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
102 else if (state->count == 2) {
103 if (state->interrupted) return DOUBLE_SINGLE_TAP;
104 else if (state->pressed) return DOUBLE_HOLD;
105 else return DOUBLE_TAP;
107 else if ((state->count == 3) && ((state->interrupted) || (!state->pressed))) return TRIPLE_TAP;
108 else if (state->count == 3) return TRIPLE_HOLD;
109 else return 8; //magic number. At some point this method will expand to work for more presses
112 //This works well if you want this key to work as a "fast modifier". It favors being held over being tapped.
113 int hold_cur_dance (qk_tap_dance_state_t *state) {
114 if (state->count == 1) {
115 if (state->interrupted) {
116 if (!state->pressed) return SINGLE_TAP;
117 else return SINGLE_HOLD;
120 if (!state->pressed) return SINGLE_TAP;
121 else return SINGLE_HOLD;
124 //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
126 else if (state->count == 2) {
127 if (state->pressed) return DOUBLE_HOLD;
128 else return DOUBLE_TAP;
130 else if (state->count == 3) {
131 if (!state->pressed) return TRIPLE_TAP;
132 else return TRIPLE_HOLD;
134 else return 8; //magic number. At some point this method will expand to work for more presses
138 static xtap htap_state = {
139 .is_press_action = true,
143 void h_finished (qk_tap_dance_state_t *state, void *user_data) {
144 htap_state.state = cur_dance(state);
145 switch (htap_state.state) {
146 case SINGLE_TAP: register_code(KC_H); break;
147 case SINGLE_HOLD: layer_on(8); register_code(KC_LALT); break;
148 case DOUBLE_TAP: layer_invert(8); register_code(KC_LALT); break;
149 // case DOUBLE_HOLD: register_code(KC_LALT);
150 case DOUBLE_SINGLE_TAP: register_code(KC_H);unregister_code(KC_H);register_code(KC_H);
154 void h_reset (qk_tap_dance_state_t *state, void *user_data) {
155 switch (htap_state.state) {
156 case SINGLE_TAP: unregister_code(KC_H); break;
157 case SINGLE_HOLD: layer_off(8); unregister_code(KC_LALT); break;
158 case DOUBLE_TAP: unregister_code(KC_LALT);break;
159 // case DOUBLE_HOLD: unregister_code(KC_LALT);
160 case DOUBLE_SINGLE_TAP: unregister_code(KC_H);
162 htap_state.state = 0;
166 /**************** QUAD FUNCTION FOR TAB ****************/
167 // TAB, ALT + SHIFT, TAB TAB, CTRL + SHIFT
168 static xtap tab_state = {
169 .is_press_action = true,
173 void tab_finished (qk_tap_dance_state_t *state, void *user_data) {
174 tab_state.state = cur_dance(state);
175 switch (tab_state.state) {
176 case SINGLE_TAP: register_code(KC_TAB); break; //send tab on single press
177 case SINGLE_HOLD: register_ctrl_shift(); break;
178 case DOUBLE_HOLD: register_alt_shift(); break; //alt shift on single hold
179 case DOUBLE_TAP: register_code(KC_TAB); unregister_code(KC_TAB); register_code(KC_TAB); break; //tab tab
180 case TRIPLE_TAP: register_code(KC_LSHIFT) ;register_code(KC_ESC); break;
181 case TRIPLE_HOLD: register_code(KC_LSHIFT); register_code(KC_LGUI); break;
185 void tab_reset (qk_tap_dance_state_t *state, void *user_data) {
186 switch (tab_state.state) {
187 case SINGLE_TAP: unregister_code(KC_TAB); break; //unregister tab
188 case DOUBLE_HOLD: unregister_alt_shift(); break; //let go of alt shift
189 case DOUBLE_TAP: unregister_code(KC_TAB); break;
190 case SINGLE_HOLD: unregister_ctrl_shift(); break;
191 case TRIPLE_TAP: unregister_code(KC_LSHIFT); unregister_code(KC_ESC); break;
192 case TRIPLE_HOLD: unregister_code(KC_LSHIFT); unregister_code(KC_LGUI); break;
196 /**************** QUAD FUNCTION FOR TAB ****************/
198 //*************** SUPER COMMA *******************//
199 // Assumption: we don't care about trying to hit ,, quickly
200 //*************** SUPER COMMA *******************//
201 static xtap comma_state = {
202 .is_press_action = true,
206 void comma_finished (qk_tap_dance_state_t *state, void *user_data) {
207 comma_state.state = hold_cur_dance(state); //Use the dance that favors being held
208 switch (comma_state.state) {
209 case SINGLE_TAP: register_code(KC_COMMA); break;
210 case SINGLE_HOLD: layer_on(1); break; //turn on symbols layer
211 case DOUBLE_TAP: layer_invert(4); break; //toggle numbers layer
212 case DOUBLE_HOLD: layer_on(2); break;
213 case TRIPLE_TAP: register_code(KC_CALCULATOR); break;
214 case TRIPLE_HOLD: layer_on(3);
218 void comma_reset (qk_tap_dance_state_t *state, void *user_data) {
219 switch (comma_state.state) {
220 case SINGLE_TAP: unregister_code(KC_COMMA); break; //unregister comma
221 case SINGLE_HOLD: layer_off(1); break;
222 case DOUBLE_TAP: ;break;
223 case DOUBLE_HOLD: layer_off(2); break;
224 case TRIPLE_TAP: unregister_code(KC_CALCULATOR); break;
225 case TRIPLE_HOLD: layer_off(3);
227 comma_state.state = 0;
229 //*************** SUPER COMMA *******************//
230 //*************** SUPER COMMA *******************//
233 //*************** F3 TAP DANCE *******************//
234 //Good example for accessing multiple layers from the same key.
235 static xtap S1_state = {
236 .is_press_action = true,
240 void bt_finished (qk_tap_dance_state_t *state, void *user_data) {
241 S1_state.state = cur_dance(state);
242 switch (S1_state.state) {
243 case SINGLE_TAP: register_code(KC_F3); break;
244 case SINGLE_HOLD: layer_on(_MACROS); break;
245 case DOUBLE_TAP: layer_invert(_MACROS); break;
246 case DOUBLE_HOLD: layer_on(5); break;
247 case DOUBLE_SINGLE_TAP: layer_invert(_MACROS); break;
251 void bt_reset (qk_tap_dance_state_t *state, void *user_data) {
252 switch (S1_state.state) {
253 case SINGLE_TAP: unregister_code(KC_F3); break;
254 case SINGLE_HOLD: layer_off(_MACROS); break;
255 case DOUBLE_TAP: break; //already inverted. Don't do anything.
256 case DOUBLE_HOLD: layer_off(5); break;
257 case DOUBLE_SINGLE_TAP: break;
262 // Tap Dance Definitions
263 qk_tap_dance_action_t tap_dance_actions[] = {
265 [F12ETAPS] = ACTION_TAP_DANCE_DOUBLE(KC_F12,LSFT(LCTL(KC_F10))),
266 [REFRESH] = ACTION_TAP_DANCE_DOUBLE(KC_R,LCTL(KC_R)),
267 [ENDESC] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_ESC),
268 [Q_ESCAPE] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC),
269 [ENDHOME] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_HOME),
270 [CALCCOMP] = ACTION_TAP_DANCE_DOUBLE(KC_CALCULATOR, KC_MY_COMPUTER),
271 [ALTF4] = ACTION_TAP_DANCE_DOUBLE(KC_F4,LALT(KC_F4)),
272 [F6F7] = ACTION_TAP_DANCE_DOUBLE(LSFT(KC_F6), LALT(KC_F7)),
273 [F1F13] = ACTION_TAP_DANCE_DOUBLE(KC_F1, KC_F13),
274 [F2F14] = ACTION_TAP_DANCE_DOUBLE(KC_F2, KC_F14),
275 [F5F15] = ACTION_TAP_DANCE_DOUBLE(KC_F5, KC_F15),
276 [TABCOMBO] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tab_finished, tab_reset),
277 [F3D] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, bt_finished, bt_reset),
278 [COMMA] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, comma_finished, comma_reset),
279 [HTAB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,h_finished, h_reset)
282 // bool process_record_user(uint16_t keycode, keyrecord_t *record) {
283 // if (!record->event.pressed) {
284 // switch (keycode) {
286 // case KC_SECRET_1 ... KC_SECRET_5:
287 // send_string(secret[keycode - KC_SECRET_1]);
288 // // clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
289 // return true; break;
291 // case UP_ENTER_RESET:
292 // register_code(KC_UP);
293 // unregister_code(KC_UP);
294 // register_code(KC_ENTER);
295 // unregister_code(KC_ENTER);
297 // return false; break;
300 // SEND_STRING ("~/.");
301 // return false; break;
304 // SEND_STRING ("dbms_output.put_line('');");
305 // SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT));
306 // return false; break;
309 // SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com");
310 // return false; break;
314 // return false; break;
317 // SEND_STRING ("->");
318 // return false; break;
321 // SEND_STRING ("=>");
322 // return false; break;
325 // SEND_STRING ("```");
326 // return false; break;
329 // SEND_STRING ("~~~");
330 // return false; break;
339 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
340 if (!record->event.pressed) {
342 case KC_SECRET_1 ... KC_SECRET_5:
343 send_string(secret[keycode - KC_SECRET_1]);
344 // clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
347 SEND_STRING("make ergodox_infinity:gordon:dfu-util");
348 register_code(KC_ENTER);
349 unregister_code(KC_ENTER);
358 SEND_STRING ("dbms_output.put_line('');");
359 SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT));
361 case DIE_1000X_RIGHT:
362 SEND_STRING (SS_TAP(X_G) SS_TAP(X_G) SS_TAP(X_RIGHT) SS_TAP(X_B) SS_TAP(X_J));
365 SEND_STRING (SS_TAP(X_GRAVE) SS_TAP(X_G) SS_TAP(X_LEFT) SS_TAP(X_B) SS_TAP(X_J));
368 SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com");
390 SEND_STRING (SS_DOWN(X_LSHIFT) SS_TAP(X_ENTER) SS_UP(X_LSHIFT));
391 SEND_STRING (SS_DOWN(X_LSHIFT) SS_TAP(X_ENTER) SS_UP(X_LSHIFT));
393 SEND_STRING (SS_TAP(X_UP));
401 else { //On key being pressed
403 case KC_SECRET_1 ... KC_SECRET_5:
404 clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);