Add Daniel Gordon's Ergodox Infinity and Chimera

   * gordon.c defines many aliases for KC codes.
   * gordon.c defines many advanced tap dance functions.
   * This is a squashed commit of about 6 months of work on chimera and
     ergodox infinity changes.
   * Ignore the change-id below.

Change-Id: I83927139e8a80fe08992ae91ec7d62571498f7f7

4 files changed, 447 insertions, 0 deletions

diff --git a/users/gordon/gordon.c b/users/gordon/gordon.c
new file mode 100644
index 0000000000..056012a21c
--- /dev/null
+++ b/users/gordon/gordon.c
@@ -0,0 +1,275 @@
+#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_LCTRL);
+}
+
+void unregister_ctrl_shift (void) { 
+  unregister_code (KC_LSFT); 
+  unregister_code (KC_LCTRL);
+}
+
+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_LSHIFT) ;register_code(KC_ESC); break;
+    case TRIPLE_HOLD: register_code(KC_LSHIFT); 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_LSHIFT); unregister_code(KC_ESC); break;
+    case TRIPLE_HOLD: unregister_code(KC_LSHIFT); 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(4); break;
+    case DOUBLE_TAP: layer_invert(4); break;
+    case DOUBLE_HOLD: layer_on(5); break;
+    case DOUBLE_SINGLE_TAP: layer_invert(4); 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(4); 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;
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case KC_SECRET_1 ... KC_SECRET_5:
+    if (!record->event.pressed) {
+      send_string(secret[keycode - KC_SECRET_1]);
+    }
+    return false;
+    break;
+  }
+  return true;
+}
\ No newline at end of file
diff --git a/users/gordon/gordon.h b/users/gordon/gordon.h
new file mode 100644
index 0000000000..548c630496
--- /dev/null
+++ b/users/gordon/gordon.h
@@ -0,0 +1,157 @@
+#ifndef GORDON
+#define GORDON
+
+#include "quantum.h"
+#include "process_keycode/process_tap_dance.h"
+
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define ________ KC_TRNS
+#define _________ KC_TRNS
+#define XXXXXXX KC_NO
+
+// KC codes that are too long
+#define DOLLAR KC_DOLLAR
+#define LSQUIGLY KC_LBRACKET
+#define RSQUIGLY KC_RBRACKET
+#define NUMLOCK KC_NUMLOCK
+#define CAPLOCK KC_CAPSLOCK
+#define BK_SLASH KC_BSLASH
+#define ASTERSK KC_KP_ASTERISK
+ 
+// Navigation
+#define SNAPLEFT  LGUI(KC_LEFT)
+#define SNAPRGHT  LGUI(KC_RIGHT)
+#define SNAPUP    LGUI(KC_UP)
+#define SNAPDOWN  LGUI(KC_DOWN)
+#define PREVTAB   LCTL(LSFT(KC_TAB))
+#define NEXTTAB   LCTL(KC_TAB)
+#define WORKRIGHT LCTL(LGUI(KC_RIGHT))
+#define WORKLEFT  LCTL(LGUI(KC_LEFT))
+
+// KC/modifier hold
+#define CTRL_F   CTL_T(KC_F)
+#define CTRL_J   CTL_T(KC_J)
+#define CTRL_Z   CTL_T(KC_Z)
+#define ALT_V    ALT_T(KC_V)
+#define ALT_M    ALT_T(KC_M)
+#define WIN_G    GUI_T(KC_G)
+#define WIN_H    GUI_T(KC_H)
+#define HYPER_X  ALL_T(KC_X)
+#define HYPE_DOT ALL_T(KC_DOT)
+#define MEH_S    MEH_T(KC_S)
+#define MEH_L    MEH_T(KC_L)
+#define ALT_HOME ALT_T(KC_HOME)
+
+
+// KC/Layer Hold
+#define NAV_E    LT(_NAV,KC_E)
+#define NUMPAD_D LT(_NUMPAD,KC_D)
+#define MOUSE_C  LT(_MOUSE,KC_C)
+#define SYMB_BSP LT(_SYMBOLS,KC_BSPACE)
+#define COL_MOUS LT(_MOUSE,KC_SCOLON)
+#define SPAC_SYM LT(_SYMBOLS,KC_SPACE)
+
+// Double Modifier ONLY hold
+#define ALT_SHFT LSFT(KC_LALT)
+#define CTR_SHFT LSFT(KC_LCTL)
+
+// KC/Double modifier Hold
+#define CTR_SH_W MT(MOD_LCTL|MOD_LSFT,KC_W)
+#define CTR_AL_R MT(MOD_LCTL|MOD_LALT,KC_R)
+
+//MISC
+#define PRINTSCR KC_PSCREEN
+#define CALTDEL LCTL(LALT(KC_DEL))
+#define TSKMGR LCTL(LSFT(KC_ESC))
+
+
+typedef struct {
+  bool is_press_action;
+  int state;
+} xtap;
+
+enum {
+  SINGLE_TAP = 1,
+  SINGLE_HOLD = 2,
+  DOUBLE_TAP = 3,
+  DOUBLE_HOLD = 4,
+  DOUBLE_SINGLE_TAP = 5, //send two single taps
+  TRIPLE_TAP = 6,
+  TRIPLE_HOLD = 7
+};
+
+enum gordon_layers
+{
+  _QWERTY = 0,
+  _SYMBOLS,
+  _MOUSE,
+  _NUMPAD,
+  _NAV,
+  _MACROS,
+  _FUNCTION,
+  _TEXTNAV
+};
+
+
+
+void register_hyper (void);
+void unregister_hyper (void);
+
+void register_ctrl_a (void); 
+void unregister_ctrl_a (void); 
+
+void register_alt_f7 (void); 
+void unregister_alt_f7 (void);
+
+void register_shift_f6 (void); 
+void unregister_shift_f6 (void); 
+
+void register_ctrl_shift (void); 
+void unregister_ctrl_shift (void); 
+
+void register_alt_shift (void); 
+void unregister_alt_shift (void);
+
+int cur_dance (qk_tap_dance_state_t *state); 
+int hold_cur_dance (qk_tap_dance_state_t *state); 
+
+void x_finished (qk_tap_dance_state_t *state, void *user_data);
+void x_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void h_finished (qk_tap_dance_state_t *state, void *user_data);
+void h_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void tab_finished (qk_tap_dance_state_t *state, void *user_data);
+void tab_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void comma_finished (qk_tap_dance_state_t *state, void *user_data);
+void comma_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void bt_finished (qk_tap_dance_state_t *state, void *user_data);
+void bt_reset (qk_tap_dance_state_t *state, void *user_data);
+
+// Macro Declarations
+enum {
+  INFOQM,
+  TIL_SLASH,
+  DEREF,
+  EQRIGHT,
+  TILD3,
+  TICK3,
+  ALTTAB_START,
+  ALTTAB_END
+};
+
+enum secret_strings {
+  KC_SECRET_1 = SAFE_RANGE,
+  KC_SECRET_2,
+  KC_SECRET_3,
+  KC_SECRET_4,
+  KC_SECRET_5,
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt);
+
+#endif
\ No newline at end of file
diff --git a/users/gordon/readme.md b/users/gordon/readme.md
new file mode 100644
index 0000000000..fdea33b67a
--- /dev/null
+++ b/users/gordon/readme.md
@@ -0,0 +1,14 @@
+Copyright <year> <name> <email> @<github_username>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
\ No newline at end of file
diff --git a/users/gordon/rules.mk b/users/gordon/rules.mk
new file mode 100644
index 0000000000..5dd62c200b
--- /dev/null
+++ b/users/gordon/rules.mk
@@ -0,0 +1 @@
+SRC += gordon.c
\ No newline at end of file