411 lines
13 KiB
C
411 lines
13 KiB
C
#include "gordon.h"
|
|
#include "quantum.h"
|
|
#include "action.h"
|
|
#include "process_keycode/process_tap_dance.h"
|
|
|
|
#if (__has_include("secret.h"))
|
|
#include "secret.h"
|
|
#else
|
|
const char secret[][64] = {
|
|
"test1",
|
|
"test2",
|
|
"test3",
|
|
"test4",
|
|
"test5"
|
|
};
|
|
#endif
|
|
|
|
void register_hyper (void) { //Helper function to invoke Hyper
|
|
register_code (KC_LSFT);
|
|
register_code (KC_LCTL);
|
|
register_code (KC_LALT);
|
|
register_code (KC_LGUI);
|
|
}
|
|
void unregister_hyper (void) { //Helper function to invoke Hyper
|
|
unregister_code (KC_LSFT);
|
|
unregister_code (KC_LCTL);
|
|
unregister_code (KC_LALT);
|
|
unregister_code (KC_LGUI);
|
|
}
|
|
|
|
void register_ctrl_a (void) {
|
|
register_code(KC_LCTL);
|
|
register_code(KC_A);
|
|
}
|
|
|
|
void unregister_ctrl_a (void) {
|
|
unregister_code(KC_LCTL);
|
|
unregister_code(KC_A);
|
|
}
|
|
|
|
void register_alt_f7 (void) {
|
|
register_code (KC_LALT);
|
|
register_code (KC_F7);
|
|
}
|
|
|
|
void unregister_alt_f7 (void) {
|
|
unregister_code (KC_LALT);
|
|
unregister_code (KC_F7);
|
|
}
|
|
|
|
void register_shift_f6 (void) {
|
|
register_code (KC_LSFT);
|
|
register_code (KC_F6);
|
|
}
|
|
|
|
void unregister_shift_f6 (void) {
|
|
unregister_code (KC_LSFT);
|
|
unregister_code (KC_F6);
|
|
}
|
|
|
|
void register_ctrl_shift (void) {
|
|
register_code (KC_LSFT);
|
|
register_code (KC_LCTL);
|
|
}
|
|
|
|
void unregister_ctrl_shift (void) {
|
|
unregister_code (KC_LSFT);
|
|
unregister_code (KC_LCTL);
|
|
}
|
|
|
|
void register_alt_shift (void) {
|
|
register_code (KC_LSFT);
|
|
register_code (KC_LALT);
|
|
}
|
|
|
|
void unregister_alt_shift (void) {
|
|
unregister_code (KC_LSFT);
|
|
unregister_code (KC_LALT);
|
|
}
|
|
|
|
// To activate SINGLE_HOLD, you will need to hold for 200ms first.
|
|
// This tap dance favors keys that are used frequently in typing like 'f'
|
|
int cur_dance (qk_tap_dance_state_t *state) {
|
|
if (state->count == 1) {
|
|
//If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
|
|
if (state->interrupted) {
|
|
// if (!state->pressed) return SINGLE_TAP;
|
|
//need "permissive hold" here.
|
|
// else return SINsGLE_HOLD;
|
|
//If the interrupting key is released before the tap-dance key, then it is a single HOLD
|
|
//However, if the tap-dance key is released first, then it is a single TAP
|
|
//But how to get access to the state of the interrupting key????
|
|
return SINGLE_TAP;
|
|
}
|
|
else {
|
|
if (!state->pressed) return SINGLE_TAP;
|
|
else return SINGLE_HOLD;
|
|
}
|
|
}
|
|
//If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
|
|
//with single tap.
|
|
else if (state->count == 2) {
|
|
if (state->interrupted) return DOUBLE_SINGLE_TAP;
|
|
else if (state->pressed) return DOUBLE_HOLD;
|
|
else return DOUBLE_TAP;
|
|
}
|
|
else if ((state->count == 3) && ((state->interrupted) || (!state->pressed))) return TRIPLE_TAP;
|
|
else if (state->count == 3) return TRIPLE_HOLD;
|
|
else return 8; //magic number. At some point this method will expand to work for more presses
|
|
}
|
|
|
|
//This works well if you want this key to work as a "fast modifier". It favors being held over being tapped.
|
|
int hold_cur_dance (qk_tap_dance_state_t *state) {
|
|
if (state->count == 1) {
|
|
if (state->interrupted) {
|
|
if (!state->pressed) return SINGLE_TAP;
|
|
else return SINGLE_HOLD;
|
|
}
|
|
else {
|
|
if (!state->pressed) return SINGLE_TAP;
|
|
else return SINGLE_HOLD;
|
|
}
|
|
}
|
|
//If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
|
|
//with single tap.
|
|
else if (state->count == 2) {
|
|
if (state->pressed) return DOUBLE_HOLD;
|
|
else return DOUBLE_TAP;
|
|
}
|
|
else if (state->count == 3) {
|
|
if (!state->pressed) return TRIPLE_TAP;
|
|
else return TRIPLE_HOLD;
|
|
}
|
|
else return 8; //magic number. At some point this method will expand to work for more presses
|
|
}
|
|
|
|
|
|
static xtap htap_state = {
|
|
.is_press_action = true,
|
|
.state = 0
|
|
};
|
|
|
|
void h_finished (qk_tap_dance_state_t *state, void *user_data) {
|
|
htap_state.state = cur_dance(state);
|
|
switch (htap_state.state) {
|
|
case SINGLE_TAP: register_code(KC_H); break;
|
|
case SINGLE_HOLD: layer_on(8); register_code(KC_LALT); break;
|
|
case DOUBLE_TAP: layer_invert(8); register_code(KC_LALT); break;
|
|
// case DOUBLE_HOLD: register_code(KC_LALT);
|
|
case DOUBLE_SINGLE_TAP: register_code(KC_H);unregister_code(KC_H);register_code(KC_H);
|
|
}
|
|
}
|
|
|
|
void h_reset (qk_tap_dance_state_t *state, void *user_data) {
|
|
switch (htap_state.state) {
|
|
case SINGLE_TAP: unregister_code(KC_H); break;
|
|
case SINGLE_HOLD: layer_off(8); unregister_code(KC_LALT); break;
|
|
case DOUBLE_TAP: unregister_code(KC_LALT);break;
|
|
// case DOUBLE_HOLD: unregister_code(KC_LALT);
|
|
case DOUBLE_SINGLE_TAP: unregister_code(KC_H);
|
|
}
|
|
htap_state.state = 0;
|
|
}
|
|
|
|
|
|
/**************** QUAD FUNCTION FOR TAB ****************/
|
|
// TAB, ALT + SHIFT, TAB TAB, CTRL + SHIFT
|
|
static xtap tab_state = {
|
|
.is_press_action = true,
|
|
.state = 0
|
|
};
|
|
|
|
void tab_finished (qk_tap_dance_state_t *state, void *user_data) {
|
|
tab_state.state = cur_dance(state);
|
|
switch (tab_state.state) {
|
|
case SINGLE_TAP: register_code(KC_TAB); break; //send tab on single press
|
|
case SINGLE_HOLD: register_ctrl_shift(); break;
|
|
case DOUBLE_HOLD: register_alt_shift(); break; //alt shift on single hold
|
|
case DOUBLE_TAP: register_code(KC_TAB); unregister_code(KC_TAB); register_code(KC_TAB); break; //tab tab
|
|
case TRIPLE_TAP: register_code(KC_LSFT) ;register_code(KC_ESC); break;
|
|
case TRIPLE_HOLD: register_code(KC_LSFT); register_code(KC_LGUI); break;
|
|
}
|
|
}
|
|
|
|
void tab_reset (qk_tap_dance_state_t *state, void *user_data) {
|
|
switch (tab_state.state) {
|
|
case SINGLE_TAP: unregister_code(KC_TAB); break; //unregister tab
|
|
case DOUBLE_HOLD: unregister_alt_shift(); break; //let go of alt shift
|
|
case DOUBLE_TAP: unregister_code(KC_TAB); break;
|
|
case SINGLE_HOLD: unregister_ctrl_shift(); break;
|
|
case TRIPLE_TAP: unregister_code(KC_LSFT); unregister_code(KC_ESC); break;
|
|
case TRIPLE_HOLD: unregister_code(KC_LSFT); unregister_code(KC_LGUI); break;
|
|
}
|
|
tab_state.state = 0;
|
|
}
|
|
/**************** QUAD FUNCTION FOR TAB ****************/
|
|
|
|
//*************** SUPER COMMA *******************//
|
|
// Assumption: we don't care about trying to hit ,, quickly
|
|
//*************** SUPER COMMA *******************//
|
|
static xtap comma_state = {
|
|
.is_press_action = true,
|
|
.state = 0
|
|
};
|
|
|
|
void comma_finished (qk_tap_dance_state_t *state, void *user_data) {
|
|
comma_state.state = hold_cur_dance(state); //Use the dance that favors being held
|
|
switch (comma_state.state) {
|
|
case SINGLE_TAP: register_code(KC_COMMA); break;
|
|
case SINGLE_HOLD: layer_on(1); break; //turn on symbols layer
|
|
case DOUBLE_TAP: layer_invert(4); break; //toggle numbers layer
|
|
case DOUBLE_HOLD: layer_on(2); break;
|
|
case TRIPLE_TAP: register_code(KC_CALCULATOR); break;
|
|
case TRIPLE_HOLD: layer_on(3);
|
|
}
|
|
}
|
|
|
|
void comma_reset (qk_tap_dance_state_t *state, void *user_data) {
|
|
switch (comma_state.state) {
|
|
case SINGLE_TAP: unregister_code(KC_COMMA); break; //unregister comma
|
|
case SINGLE_HOLD: layer_off(1); break;
|
|
case DOUBLE_TAP: ;break;
|
|
case DOUBLE_HOLD: layer_off(2); break;
|
|
case TRIPLE_TAP: unregister_code(KC_CALCULATOR); break;
|
|
case TRIPLE_HOLD: layer_off(3);
|
|
}
|
|
comma_state.state = 0;
|
|
}
|
|
//*************** SUPER COMMA *******************//
|
|
//*************** SUPER COMMA *******************//
|
|
|
|
|
|
//*************** F3 TAP DANCE *******************//
|
|
//Good example for accessing multiple layers from the same key.
|
|
static xtap S1_state = {
|
|
.is_press_action = true,
|
|
.state = 0
|
|
};
|
|
|
|
void bt_finished (qk_tap_dance_state_t *state, void *user_data) {
|
|
S1_state.state = cur_dance(state);
|
|
switch (S1_state.state) {
|
|
case SINGLE_TAP: register_code(KC_F3); break;
|
|
case SINGLE_HOLD: layer_on(_MACROS); break;
|
|
case DOUBLE_TAP: layer_invert(_MACROS); break;
|
|
case DOUBLE_HOLD: layer_on(5); break;
|
|
case DOUBLE_SINGLE_TAP: layer_invert(_MACROS); break;
|
|
}
|
|
}
|
|
|
|
void bt_reset (qk_tap_dance_state_t *state, void *user_data) {
|
|
switch (S1_state.state) {
|
|
case SINGLE_TAP: unregister_code(KC_F3); break;
|
|
case SINGLE_HOLD: layer_off(_MACROS); break;
|
|
case DOUBLE_TAP: break; //already inverted. Don't do anything.
|
|
case DOUBLE_HOLD: layer_off(5); break;
|
|
case DOUBLE_SINGLE_TAP: break;
|
|
}
|
|
S1_state.state = 0;
|
|
}
|
|
|
|
// Tap Dance Definitions
|
|
qk_tap_dance_action_t tap_dance_actions[] = {
|
|
// simple tap dance
|
|
[F12ETAPS] = ACTION_TAP_DANCE_DOUBLE(KC_F12,LSFT(LCTL(KC_F10))),
|
|
[REFRESH] = ACTION_TAP_DANCE_DOUBLE(KC_R,LCTL(KC_R)),
|
|
[ENDESC] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_ESC),
|
|
[Q_ESCAPE] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC),
|
|
[ENDHOME] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_HOME),
|
|
[CALCCOMP] = ACTION_TAP_DANCE_DOUBLE(KC_CALCULATOR, KC_MY_COMPUTER),
|
|
[ALTF4] = ACTION_TAP_DANCE_DOUBLE(KC_F4,LALT(KC_F4)),
|
|
[F6F7] = ACTION_TAP_DANCE_DOUBLE(LSFT(KC_F6), LALT(KC_F7)),
|
|
[F1F13] = ACTION_TAP_DANCE_DOUBLE(KC_F1, KC_F13),
|
|
[F2F14] = ACTION_TAP_DANCE_DOUBLE(KC_F2, KC_F14),
|
|
[F5F15] = ACTION_TAP_DANCE_DOUBLE(KC_F5, KC_F15),
|
|
[TABCOMBO] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tab_finished, tab_reset),
|
|
[F3D] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, bt_finished, bt_reset),
|
|
[COMMA] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, comma_finished, comma_reset),
|
|
[HTAB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,h_finished, h_reset)
|
|
};
|
|
|
|
// bool process_record_user(uint16_t keycode, keyrecord_t *record) {
|
|
// if (!record->event.pressed) {
|
|
// switch (keycode) {
|
|
|
|
// case KC_SECRET_1 ... KC_SECRET_5:
|
|
// send_string(secret[keycode - KC_SECRET_1]);
|
|
// // clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
|
|
// return true; break;
|
|
|
|
// case UP_ENTER_RESET:
|
|
// register_code(KC_UP);
|
|
// unregister_code(KC_UP);
|
|
// register_code(KC_ENTER);
|
|
// unregister_code(KC_ENTER);
|
|
// reset_keyboard();
|
|
// return false; break;
|
|
|
|
// case TIL_SLASH:
|
|
// SEND_STRING ("~/.");
|
|
// return false; break;
|
|
|
|
// case DBMS_OUT:
|
|
// SEND_STRING ("dbms_output.put_line('');");
|
|
// SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT));
|
|
// return false; break;
|
|
|
|
// case ID_MAN_IP:
|
|
// SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com");
|
|
// return false; break;
|
|
|
|
// case MODRESET:
|
|
// clear_mods();
|
|
// return false; break;
|
|
|
|
// case DEREF:
|
|
// SEND_STRING ("->");
|
|
// return false; break;
|
|
|
|
// case EQRIGHT:
|
|
// SEND_STRING ("=>");
|
|
// return false; break;
|
|
|
|
// case TICK3:
|
|
// SEND_STRING ("```");
|
|
// return false; break;
|
|
|
|
// case TILD3:
|
|
// SEND_STRING ("~~~");
|
|
// return false; break;
|
|
// }
|
|
// }
|
|
// return true;
|
|
// };
|
|
|
|
|
|
|
|
|
|
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
|
|
if (!record->event.pressed) {
|
|
switch (keycode) {
|
|
case KC_SECRET_1 ... KC_SECRET_5:
|
|
send_string(secret[keycode - KC_SECRET_1]);
|
|
// clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
|
|
return true; break;
|
|
case UP_ENTER_RESET:
|
|
SEND_STRING("make ergodox_infinity:gordon:dfu-util");
|
|
register_code(KC_ENTER);
|
|
unregister_code(KC_ENTER);
|
|
reset_keyboard();
|
|
return false; break;
|
|
|
|
case TIL_SLASH:
|
|
SEND_STRING ("~/.");
|
|
return false; break;
|
|
|
|
case DBMS_OUT:
|
|
SEND_STRING ("dbms_output.put_line('');");
|
|
SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT));
|
|
return false; break;
|
|
case DIE_1000X_RIGHT:
|
|
SEND_STRING (SS_TAP(X_G) SS_TAP(X_G) SS_TAP(X_RIGHT) SS_TAP(X_B) SS_TAP(X_J));
|
|
return false; break;
|
|
case DIE_1000X_LEFT:
|
|
SEND_STRING (SS_TAP(X_GRAVE) SS_TAP(X_G) SS_TAP(X_LEFT) SS_TAP(X_B) SS_TAP(X_J));
|
|
return false; break;
|
|
case ID_MAN_IP:
|
|
SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com");
|
|
return false; break;
|
|
|
|
case MODRESET:
|
|
clear_mods();
|
|
return false; break;
|
|
|
|
case DEREF:
|
|
SEND_STRING ("->");
|
|
return false; break;
|
|
|
|
case EQRIGHT:
|
|
SEND_STRING ("=>");
|
|
return false; break;
|
|
|
|
case TICK3:
|
|
SEND_STRING ("```");
|
|
|
|
return false; break;
|
|
|
|
case SPRK_TCK:
|
|
SEND_STRING ("```");
|
|
SEND_STRING (SS_DOWN(X_LSFT) SS_TAP(X_ENTER) SS_UP(X_LSFT));
|
|
SEND_STRING (SS_DOWN(X_LSFT) SS_TAP(X_ENTER) SS_UP(X_LSFT));
|
|
SEND_STRING ("```");
|
|
SEND_STRING (SS_TAP(X_UP));
|
|
return false; break;
|
|
|
|
case TILD3:
|
|
SEND_STRING ("~~~");
|
|
return false; break;
|
|
}
|
|
}
|
|
else { //On key being pressed
|
|
switch (keycode) {
|
|
case KC_SECRET_1 ... KC_SECRET_5:
|
|
clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
|
|
return false; break;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|