users/gordon/gordon.c

   1 #include "gordon.h"
   2 #include "quantum.h"
   3 #include "action.h"
   4 #include "process_keycode/process_tap_dance.h"
   5
   6 #if (__has_include("secret.h"))
   7 #include "secret.h"
   8 #else
   9 const char secret[][64] = {
  10   "test1",
  11   "test2",
  12   "test3",
  13   "test4",
  14   "test5"
  15 };
  16 #endif
  17
  18
  19
  20
  21 void register_hyper (void) { //Helper function to invoke Hyper
  22   register_code (KC_LSFT);
  23   register_code (KC_LCTL);
  24   register_code (KC_LALT);
  25   register_code (KC_LGUI);
  26 }
  27 void unregister_hyper (void) { //Helper function to invoke Hyper
  28   unregister_code (KC_LSFT);
  29   unregister_code (KC_LCTL);
  30   unregister_code (KC_LALT);
  31   unregister_code (KC_LGUI);
  32 }
  33
  34 void register_ctrl_a (void) {
  35   register_code(KC_LCTL);
  36   register_code(KC_A);
  37 }
  38
  39 void unregister_ctrl_a (void) {
  40   unregister_code(KC_LCTL);
  41   unregister_code(KC_A);
  42 }
  43
  44 void register_alt_f7 (void) {
  45   register_code (KC_LALT);
  46   register_code (KC_F7);
  47 }
  48
  49 void unregister_alt_f7 (void) {
  50   unregister_code (KC_LALT);
  51   unregister_code (KC_F7);
  52 }
  53
  54 void register_shift_f6 (void) {
  55   register_code (KC_LSFT);
  56   register_code (KC_F6);
  57 }
  58
  59 void unregister_shift_f6 (void) {
  60   unregister_code (KC_LSFT);
  61   unregister_code (KC_F6);
  62 }
  63
  64 void register_ctrl_shift (void) {
  65   register_code (KC_LSFT);
  66   register_code (KC_LCTRL);
  67 }
  68
  69 void unregister_ctrl_shift (void) {
  70   unregister_code (KC_LSFT);
  71   unregister_code (KC_LCTRL);
  72 }
  73
  74 void register_alt_shift (void) {
  75   register_code (KC_LSFT);
  76   register_code (KC_LALT);
  77 }
  78
  79 void unregister_alt_shift (void) {
  80   unregister_code (KC_LSFT);
  81   unregister_code (KC_LALT);
  82 }
  83
  84 // To activate SINGLE_HOLD, you will need to hold for 200ms first.
  85 // This tap dance favors keys that are used frequently in typing like 'f'
  86 int cur_dance (qk_tap_dance_state_t *state) {
  87   if (state->count == 1) {
  88     //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
  89     if (state->interrupted) {
  90       //     if (!state->pressed) return SINGLE_TAP;
  91       //need "permissive hold" here.
  92       //     else return SINsGLE_HOLD;
  93       //If the interrupting key is released before the tap-dance key, then it is a single HOLD
  94       //However, if the tap-dance key is released first, then it is a single TAP
  95       //But how to get access to the state of the interrupting key????
  96       return SINGLE_TAP;
  97     }
  98     else {
  99       if (!state->pressed) return SINGLE_TAP;
 100       else return SINGLE_HOLD;
 101     }
 102   }
 103   //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
 104   //with single tap.
 105   else if (state->count == 2) {
 106     if (state->interrupted) return DOUBLE_SINGLE_TAP;
 107     else if (state->pressed) return DOUBLE_HOLD;
 108     else return DOUBLE_TAP;
 109   }
 110   else if ((state->count == 3) && ((state->interrupted) || (!state->pressed))) return TRIPLE_TAP;
 111   else if (state->count == 3) return TRIPLE_HOLD;
 112   else return 8; //magic number. At some point this method will expand to work for more presses
 113 }
 114
 115 //This works well if you want this key to work as a "fast modifier". It favors being held over being tapped.
 116 int hold_cur_dance (qk_tap_dance_state_t *state) {
 117   if (state->count == 1) {
 118     if (state->interrupted) {
 119       if (!state->pressed) return SINGLE_TAP;
 120       else return SINGLE_HOLD;
 121     }
 122     else {
 123       if (!state->pressed) return SINGLE_TAP;
 124       else return SINGLE_HOLD;
 125     }
 126   }
 127   //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
 128   //with single tap.
 129   else if (state->count == 2) {
 130     if (state->pressed) return DOUBLE_HOLD;
 131     else return DOUBLE_TAP;
 132   }
 133   else if (state->count == 3) {
 134     if (!state->pressed) return TRIPLE_TAP;
 135     else return TRIPLE_HOLD;
 136   }
 137   else return 8; //magic number. At some point this method will expand to work for more presses
 138 }
 139
 140
 141 static xtap htap_state = {
 142   .is_press_action = true,
 143   .state = 0
 144 };
 145
 146 void h_finished (qk_tap_dance_state_t *state, void *user_data) {
 147   htap_state.state = cur_dance(state);
 148   switch (htap_state.state) {
 149     case SINGLE_TAP: register_code(KC_H); break;
 150     case SINGLE_HOLD: layer_on(8); register_code(KC_LALT); break;
 151     case DOUBLE_TAP: layer_invert(8); register_code(KC_LALT); break;
 152     // case DOUBLE_HOLD: register_code(KC_LALT);
 153     case DOUBLE_SINGLE_TAP: register_code(KC_H);unregister_code(KC_H);register_code(KC_H);
 154   }
 155 }
 156
 157 void h_reset (qk_tap_dance_state_t *state, void *user_data) {
 158   switch (htap_state.state) {
 159     case SINGLE_TAP: unregister_code(KC_H); break;
 160     case SINGLE_HOLD: layer_off(8); unregister_code(KC_LALT); break;
 161     case DOUBLE_TAP: unregister_code(KC_LALT);break;
 162     // case DOUBLE_HOLD: unregister_code(KC_LALT);
 163     case DOUBLE_SINGLE_TAP: unregister_code(KC_H);
 164   }
 165   htap_state.state = 0;
 166 }
 167
 168
 169 /**************** QUAD FUNCTION FOR TAB ****************/
 170 // TAB, ALT + SHIFT, TAB TAB, CTRL + SHIFT
 171 static xtap tab_state = {
 172   .is_press_action = true,
 173   .state = 0
 174 };
 175
 176 void tab_finished (qk_tap_dance_state_t *state, void *user_data) {
 177   tab_state.state = cur_dance(state);
 178   switch (tab_state.state) {
 179     case SINGLE_TAP: register_code(KC_TAB); break;  //send tab on single press
 180     case SINGLE_HOLD: register_ctrl_shift(); break;
 181     case DOUBLE_HOLD: register_alt_shift(); break; //alt shift on single hold
 182     case DOUBLE_TAP: register_code(KC_TAB); unregister_code(KC_TAB); register_code(KC_TAB); break; //tab tab
 183     case TRIPLE_TAP: register_code(KC_LSHIFT) ;register_code(KC_ESC); break;
 184     case TRIPLE_HOLD: register_code(KC_LSHIFT); register_code(KC_LGUI); break;
 185   }
 186 }
 187
 188 void tab_reset (qk_tap_dance_state_t *state, void *user_data) {
 189   switch (tab_state.state) {
 190     case SINGLE_TAP: unregister_code(KC_TAB); break; //unregister tab
 191     case DOUBLE_HOLD: unregister_alt_shift(); break; //let go of alt shift
 192     case DOUBLE_TAP: unregister_code(KC_TAB); break;
 193     case SINGLE_HOLD: unregister_ctrl_shift(); break;
 194     case TRIPLE_TAP: unregister_code(KC_LSHIFT); unregister_code(KC_ESC); break;
 195     case TRIPLE_HOLD: unregister_code(KC_LSHIFT); unregister_code(KC_LGUI); break;
 196   }
 197   tab_state.state = 0;
 198 }
 199 /**************** QUAD FUNCTION FOR TAB ****************/
 200
 201 //*************** SUPER COMMA *******************//
 202 // Assumption: we don't care about trying to hit ,, quickly
 203 //*************** SUPER COMMA *******************//
 204 static xtap comma_state = {
 205   .is_press_action = true,
 206   .state = 0
 207 };
 208
 209 void comma_finished (qk_tap_dance_state_t *state, void *user_data) {
 210   comma_state.state = hold_cur_dance(state); //Use the dance that favors being held
 211   switch (comma_state.state) {
 212     case SINGLE_TAP: register_code(KC_COMMA); break;
 213     case SINGLE_HOLD: layer_on(1); break; //turn on symbols layer
 214     case DOUBLE_TAP: layer_invert(4); break; //toggle numbers layer
 215     case DOUBLE_HOLD: layer_on(2); break;
 216     case TRIPLE_TAP: register_code(KC_CALCULATOR); break;
 217     case TRIPLE_HOLD: layer_on(3);
 218   }
 219 }
 220
 221 void comma_reset (qk_tap_dance_state_t *state, void *user_data) {
 222   switch (comma_state.state) {
 223     case SINGLE_TAP: unregister_code(KC_COMMA); break; //unregister comma
 224     case SINGLE_HOLD: layer_off(1); break;
 225     case DOUBLE_TAP: ;break;
 226     case DOUBLE_HOLD: layer_off(2); break;
 227     case TRIPLE_TAP: unregister_code(KC_CALCULATOR); break;
 228     case TRIPLE_HOLD: layer_off(3);
 229   }
 230   comma_state.state = 0;
 231 }
 232 //*************** SUPER COMMA *******************//
 233 //*************** SUPER COMMA *******************//
 234
 235
 236 //*************** F3 TAP DANCE *******************//
 237 //Good example for accessing multiple layers from the same key.
 238 static xtap S1_state = {
 239   .is_press_action = true,
 240   .state = 0
 241 };
 242
 243 void bt_finished (qk_tap_dance_state_t *state, void *user_data) {
 244   S1_state.state = cur_dance(state);
 245   switch (S1_state.state) {
 246     case SINGLE_TAP: register_code(KC_F3); break;
 247     case SINGLE_HOLD: layer_on(4); break;
 248     case DOUBLE_TAP: layer_invert(4); break;
 249     case DOUBLE_HOLD: layer_on(5); break;
 250     case DOUBLE_SINGLE_TAP: layer_invert(4); break;
 251   }
 252 }
 253
 254 void bt_reset (qk_tap_dance_state_t *state, void *user_data) {
 255   switch (S1_state.state) {
 256     case SINGLE_TAP: unregister_code(KC_F3); break;
 257     case SINGLE_HOLD: layer_off(4); break;
 258     case DOUBLE_TAP: break; //already inverted. Don't do anything.
 259     case DOUBLE_HOLD: layer_off(5); break;
 260     case DOUBLE_SINGLE_TAP: break;
 261   }
 262   S1_state.state = 0;
 263 }
 264
 265 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 266   switch (keycode) {
 267     case KC_SECRET_1 ... KC_SECRET_5:
 268     if (!record->event.pressed) {
 269       send_string(secret[keycode - KC_SECRET_1]);
 270     }
 271     return false;
 272     break;
 273   }
 274   return true;
 275 }