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 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);
  23 }
  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);
  29 }
  30
  31 void register_ctrl_a (void) {
  32   register_code(KC_LCTL);
  33   register_code(KC_A);
  34 }
  35
  36 void unregister_ctrl_a (void) {
  37   unregister_code(KC_LCTL);
  38   unregister_code(KC_A);
  39 }
  40
  41 void register_alt_f7 (void) {
  42   register_code (KC_LALT);
  43   register_code (KC_F7);
  44 }
  45
  46 void unregister_alt_f7 (void) {
  47   unregister_code (KC_LALT);
  48   unregister_code (KC_F7);
  49 }
  50
  51 void register_shift_f6 (void) {
  52   register_code (KC_LSFT);
  53   register_code (KC_F6);
  54 }
  55
  56 void unregister_shift_f6 (void) {
  57   unregister_code (KC_LSFT);
  58   unregister_code (KC_F6);
  59 }
  60
  61 void register_ctrl_shift (void) {
  62   register_code (KC_LSFT);
  63   register_code (KC_LCTRL);
  64 }
  65
  66 void unregister_ctrl_shift (void) {
  67   unregister_code (KC_LSFT);
  68   unregister_code (KC_LCTRL);
  69 }
  70
  71 void register_alt_shift (void) {
  72   register_code (KC_LSFT);
  73   register_code (KC_LALT);
  74 }
  75
  76 void unregister_alt_shift (void) {
  77   unregister_code (KC_LSFT);
  78   unregister_code (KC_LALT);
  79 }
  80
  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????
  93       return SINGLE_TAP;
  94     }
  95     else {
  96       if (!state->pressed) return SINGLE_TAP;
  97       else return SINGLE_HOLD;
  98     }
  99   }
 100   //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
 101   //with single tap.
 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;
 106   }
 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
 110 }
 111
 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;
 118     }
 119     else {
 120       if (!state->pressed) return SINGLE_TAP;
 121       else return SINGLE_HOLD;
 122     }
 123   }
 124   //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
 125   //with single tap.
 126   else if (state->count == 2) {
 127     if (state->pressed) return DOUBLE_HOLD;
 128     else return DOUBLE_TAP;
 129   }
 130   else if (state->count == 3) {
 131     if (!state->pressed) return TRIPLE_TAP;
 132     else return TRIPLE_HOLD;
 133   }
 134   else return 8; //magic number. At some point this method will expand to work for more presses
 135 }
 136
 137
 138 static xtap htap_state = {
 139   .is_press_action = true,
 140   .state = 0
 141 };
 142
 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);
 151   }
 152 }
 153
 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);
 161   }
 162   htap_state.state = 0;
 163 }
 164
 165
 166 /**************** QUAD FUNCTION FOR TAB ****************/
 167 // TAB, ALT + SHIFT, TAB TAB, CTRL + SHIFT
 168 static xtap tab_state = {
 169   .is_press_action = true,
 170   .state = 0
 171 };
 172
 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;
 182   }
 183 }
 184
 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;
 193   }
 194   tab_state.state = 0;
 195 }
 196 /**************** QUAD FUNCTION FOR TAB ****************/
 197
 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,
 203   .state = 0
 204 };
 205
 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);
 215   }
 216 }
 217
 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);
 226   }
 227   comma_state.state = 0;
 228 }
 229 //*************** SUPER COMMA *******************//
 230 //*************** SUPER COMMA *******************//
 231
 232
 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,
 237   .state = 0
 238 };
 239
 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;
 248   }
 249 }
 250
 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;
 258   }
 259   S1_state.state = 0;
 260 }
 261
 262 // Tap Dance Definitions
 263 qk_tap_dance_action_t tap_dance_actions[] = {
 264   // simple tap dance
 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)
 280 };
 281
 282 // bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 283 //   if (!record->event.pressed) {
 284 //     switch (keycode) {
 285
 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;
 290
 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);
 296 //           reset_keyboard();
 297 //           return false; break;
 298
 299 //       case TIL_SLASH:
 300 //           SEND_STRING ("~/.");
 301 //           return false; break;
 302
 303 //       case DBMS_OUT:
 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;
 307
 308 //       case ID_MAN_IP:
 309 //           SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com");
 310 //           return false; break;
 311
 312 //       case MODRESET:
 313 //           clear_mods();
 314 //           return false; break;
 315
 316 //       case DEREF:
 317 //           SEND_STRING ("->");
 318 //           return false; break;
 319
 320 //       case EQRIGHT:
 321 //           SEND_STRING ("=>");
 322 //           return false; break;
 323
 324 //       case TICK3:
 325 //           SEND_STRING ("```");
 326 //           return false; break;
 327
 328 //       case TILD3:
 329 //           SEND_STRING ("~~~");
 330 //           return false; break;
 331 //     }
 332 //   }
 333 //   return true;
 334 // };
 335
 336
 337
 338
 339 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 340   if (!record->event.pressed) {
 341     switch (keycode) {
 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);
 345           return true; break;
 346       case UP_ENTER_RESET:
 347           SEND_STRING("make ergodox_infinity:gordon:dfu-util");
 348           register_code(KC_ENTER);
 349           unregister_code(KC_ENTER);
 350           reset_keyboard();
 351           return false; break;
 352
 353       case TIL_SLASH:
 354           SEND_STRING ("~/.");
 355           return false; break;
 356
 357       case DBMS_OUT:
 358           SEND_STRING ("dbms_output.put_line('');");
 359           SEND_STRING (SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT));
 360           return false; break;
 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));
 363           return false; break;
 364       case DIE_1000X_LEFT:
 365           SEND_STRING (SS_TAP(X_GRAVE) SS_TAP(X_G) SS_TAP(X_LEFT) SS_TAP(X_B) SS_TAP(X_J));
 366           return false; break;
 367       case ID_MAN_IP:
 368           SEND_STRING ("http://dev-1967110238.us-east-1.elb.amazonaws.com");
 369           return false; break;
 370
 371       case MODRESET:
 372           clear_mods();
 373           return false; break;
 374
 375       case DEREF:
 376           SEND_STRING ("->");
 377           return false; break;
 378
 379       case EQRIGHT:
 380           SEND_STRING ("=>");
 381           return false; break;
 382
 383       case TICK3:
 384           SEND_STRING ("```");
 385
 386           return false; break;
 387
 388       case SPRK_TCK:
 389           SEND_STRING ("```");
 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));
 392           SEND_STRING ("```");
 393           SEND_STRING (SS_TAP(X_UP));
 394           return false; break;
 395
 396       case TILD3:
 397           SEND_STRING ("~~~");
 398           return false; break;
 399     }
 400   }
 401   else { //On key being pressed
 402     switch (keycode) {
 403       case KC_SECRET_1 ... KC_SECRET_5:
 404           clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
 405           return false; break;
 406     }
 407   }
 408   return true;
 409 };
 410