users/wanleg/tapdances.c

   1 //Tap Dance Settings
   2 #include "wanleg.h"
   3
   4 ///// QUAD FUNCTION TAP DANCE GENERAL SETUP SECTION START /////
   5 ///// (no need to edit this section) /////
   6 //Enums used to clearly convey the state of the tap dance
   7 enum {
   8   SINGLE_TAP = 1,
   9   SINGLE_HOLD = 2,
  10   DOUBLE_TAP = 3,
  11   DOUBLE_HOLD = 4,
  12   DOUBLE_SINGLE_TAP = 5 //send SINGLE_TAP twice - NOT DOUBLE_TAP
  13   // Add more enums here if you want for triple, quadruple, etc.
  14 };
  15
  16 typedef struct {
  17   bool is_press_action;
  18   int state;
  19 } tap;
  20
  21 int cur_dance (qk_tap_dance_state_t *state) {
  22   if (state->count == 1) {
  23     //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
  24     if (state->interrupted || !state->pressed) return SINGLE_TAP;
  25     if (state->interrupted) return SINGLE_TAP;
  26     else return SINGLE_HOLD;
  27   }
  28   //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
  29   //with single tap.
  30   else if (state->count == 2) {
  31     if (state->interrupted) return DOUBLE_SINGLE_TAP;
  32     else if (state->pressed) return DOUBLE_HOLD;
  33     else return DOUBLE_TAP;
  34   }
  35   else return 6; //magic number. At some point this method will expand to work for more presses
  36 }
  37 ///// QUAD FUNCTION TAP DANCE GENERAL SETUP SECTION END /////
  38 ///// QUAD FUNCTION TAP DANCE PERSONALIZATION SECTION START /////
  39 //instantiate 'tap' for the 'ENT' tap dance.
  40 static tap ENTtap_state = {
  41   .is_press_action = true,
  42   .state = 0
  43 };
  44
  45 void ENT_finished (qk_tap_dance_state_t *state, void *user_data) {
  46   ENTtap_state.state = cur_dance(state);
  47   switch (ENTtap_state.state) {
  48     case SINGLE_TAP: register_code(KC_SPC); break;
  49     case SINGLE_HOLD: register_code(KC_LSFT); break;
  50     case DOUBLE_TAP: register_code(KC_ENT); break;
  51     case DOUBLE_HOLD: register_code(KC_NO); break; // setting double hold to do nothing (change this if you want)
  52     case DOUBLE_SINGLE_TAP: register_code(KC_SPC); unregister_code(KC_SPC); register_code(KC_SPC);
  53     //Last case is for fast typing. Assuming your key is `f`:
  54     //For example, when typing the word `buffer`, and you want to make sure that you send `ff` and not `Esc`.
  55     //In order to type `ff` when typing fast, the next character will have to be hit within the `TAPPING_TERM`, which by default is 200ms.
  56   }
  57 }
  58
  59 void ENT_reset (qk_tap_dance_state_t *state, void *user_data) {
  60   switch (ENTtap_state.state) {
  61     case SINGLE_TAP: unregister_code(KC_SPC); break;
  62     case SINGLE_HOLD: unregister_code(KC_LSFT); break;
  63     case DOUBLE_TAP: unregister_code(KC_ENT); break;
  64     case DOUBLE_HOLD: unregister_code(KC_NO);
  65     case DOUBLE_SINGLE_TAP: unregister_code(KC_SPC);
  66   }
  67   ENTtap_state.state = 0;
  68 }
  69
  70 //instantiate 'tap' for the 'DEL' tap dance.
  71 static tap DELtap_state = {
  72   .is_press_action = true,
  73   .state = 0
  74 };
  75
  76 void DEL_finished (qk_tap_dance_state_t *state, void *user_data) {
  77   DELtap_state.state = cur_dance(state);
  78   switch (DELtap_state.state) {
  79     case SINGLE_TAP: register_code(KC_BSPC); break;
  80     case SINGLE_HOLD: register_code(KC_LCTL); break;
  81     case DOUBLE_TAP: register_code(KC_DEL); break;
  82     case DOUBLE_HOLD: register_code(KC_NO); break;
  83     case DOUBLE_SINGLE_TAP: register_code(KC_BSPC); unregister_code(KC_BSPC); register_code(KC_BSPC);
  84   }
  85 }
  86
  87 void DEL_reset (qk_tap_dance_state_t *state, void *user_data) {
  88   switch (DELtap_state.state) {
  89     case SINGLE_TAP: unregister_code(KC_BSPC); break;
  90     case SINGLE_HOLD: unregister_code(KC_LCTL); break;
  91     case DOUBLE_TAP: unregister_code(KC_DEL); break;
  92     case DOUBLE_HOLD: unregister_code(KC_NO);
  93     case DOUBLE_SINGLE_TAP: unregister_code(KC_BSPC);
  94   }
  95   DELtap_state.state = 0;
  96 }
  97
  98 //instantiate 'tap' for the 'CAD' tap dance.
  99 static tap CADtap_state = {
 100   .is_press_action = true,
 101   .state = 0
 102 };
 103
 104 void CAD_finished (qk_tap_dance_state_t *state, void *user_data) {
 105   CADtap_state.state = cur_dance(state);
 106   switch (CADtap_state.state) {
 107     case SINGLE_TAP:
 108                 //register_code(KC_SPC);
 109                 SEND_STRING(SS_LGUI("l"));
 110                 #ifdef BACKLIGHT_ENABLE
 111                 backlight_set(3);
 112                 #endif
 113                 break;
 114     case SINGLE_HOLD:
 115                 //register_code(KC_NO);
 116                 //take a screenshot of a single window, open Paint and paste
 117                 SEND_STRING(SS_LALT(SS_TAP(X_PSCREEN)) SS_LGUI("r"));
 118         _delay_ms(500);
 119         SEND_STRING("mspaint" SS_TAP(X_ENTER));
 120         _delay_ms(700);
 121         SEND_STRING(SS_LCTRL("v"));
 122                 break; //register this keycode when button is held
 123     case DOUBLE_TAP:
 124                 //register_code(KC_ENT);
 125                 SEND_STRING(SS_LCTRL(SS_LALT(SS_TAP(X_DELETE))));
 126                 #ifdef BACKLIGHT_ENABLE
 127                 backlight_set(0);
 128                 #endif
 129                 break;
 130     //case DOUBLE_HOLD: register_code(KC_NO); break; //register this keycode when button is tapped and then held
 131         case DOUBLE_HOLD:
 132                 reset_keyboard();
 133                 break; //register this keycode when button is tapped and then held
 134     case DOUBLE_SINGLE_TAP: register_code(KC_NO); unregister_code(KC_NO); register_code(KC_NO);
 135   }
 136 }
 137
 138 void CAD_reset (qk_tap_dance_state_t *state, void *user_data) {
 139   switch (CADtap_state.state) {
 140     case SINGLE_TAP:
 141                 //unregister_code(KC_SPC);
 142                 SEND_STRING(SS_LGUI("l"));
 143                 #ifdef BACKLIGHT_ENABLE
 144                 backlight_set(3);
 145                 #endif
 146                 break;
 147     case SINGLE_HOLD:
 148                 register_code(KC_NO); //(un)register this keycode when button is held and then released
 149                 //SEND_STRING(SS_LCTRL("v"));
 150                 break;
 151     case DOUBLE_TAP:
 152                 //register_code(KC_ENT);
 153                 SEND_STRING(SS_LCTRL(SS_LALT(SS_TAP(X_DELETE))));
 154                 #ifdef BACKLIGHT_ENABLE
 155                 backlight_set(0);
 156                 #endif
 157                 break;
 158     case DOUBLE_HOLD: register_code(KC_NO); //(un)register this keycode when button is tapped and then held, and then released
 159     case DOUBLE_SINGLE_TAP: unregister_code(KC_NO);
 160   }
 161   CADtap_state.state = 0;
 162 }
 163
 164 //instantiate 'tap' for the 'RST' tap dance.
 165 static tap RSTtap_state = {
 166   .is_press_action = true,
 167   .state = 0
 168 };
 169
 170 void RST_finished (qk_tap_dance_state_t *state, void *user_data) {
 171   RSTtap_state.state = cur_dance(state);
 172   switch (RSTtap_state.state) {
 173         case SINGLE_TAP: register_code(KC_LCTL); break;
 174         case SINGLE_HOLD: register_code(KC_LCTL); break;
 175         case DOUBLE_TAP: reset_keyboard(); break;
 176         case DOUBLE_HOLD: register_code(KC_NO); break;
 177         case DOUBLE_SINGLE_TAP: register_code(KC_LCTL); unregister_code(KC_LCTL); register_code(KC_LCTL);
 178   }
 179 }
 180
 181 void RST_reset (qk_tap_dance_state_t *state, void *user_data) {
 182   switch (RSTtap_state.state) {
 183         case SINGLE_TAP: unregister_code(KC_LCTL); break;
 184         case SINGLE_HOLD: unregister_code(KC_LCTL); break;
 185         case DOUBLE_TAP: unregister_code(KC_NO); break;
 186         case DOUBLE_HOLD: unregister_code(KC_NO);
 187     case DOUBLE_SINGLE_TAP: unregister_code(KC_LCTL);
 188   }
 189   RSTtap_state.state = 0;
 190 }
 191
 192 //instantiate 'tap' for the 'LYR' tap dance.
 193 static tap LYRtap_state = {
 194   .is_press_action = true,
 195   .state = 0
 196 };
 197
 198 void LYR_finished (qk_tap_dance_state_t *state, void *user_data) {
 199   LYRtap_state.state = cur_dance(state);
 200   switch (LYRtap_state.state) {
 201         case SINGLE_TAP: register_code(KC_PSLS); break;
 202         case SINGLE_HOLD: register_code(KC_NO); break;
 203         case DOUBLE_TAP: set_single_persistent_default_layer(_GK); break;
 204         case DOUBLE_HOLD: register_code(KC_NO); break;
 205     case DOUBLE_SINGLE_TAP: register_code(KC_PSLS); unregister_code(KC_PSLS); register_code(KC_PSLS);
 206   }
 207 }
 208
 209 void LYR_reset (qk_tap_dance_state_t *state, void *user_data) {
 210   switch (LYRtap_state.state) {
 211     case SINGLE_TAP: unregister_code(KC_PSLS); break;
 212     case SINGLE_HOLD: unregister_code(KC_NO); break;
 213     case DOUBLE_TAP: set_single_persistent_default_layer(_GK); break;
 214     case DOUBLE_HOLD: unregister_code(KC_NO);
 215     case DOUBLE_SINGLE_TAP: unregister_code(KC_PSLS);
 216   }
 217   LYRtap_state.state = 0;
 218 }
 219 ///// QUAD FUNCTION TAP DANCE PERSONALIZATION SECTION END /////
 220
 221 //Tap Dance Definitions
 222 //THIS SECTION HAS TO BE AT THE END OF THE TAP DANCE SECTION
 223 qk_tap_dance_action_t tap_dance_actions[] = {
 224   [TD_SFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS)
 225 // Other declarations would go here, separated by commas, if you have them
 226  ,[TD_Q_ESC]  = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC)
 227  ,[ENT_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ENT_finished, ENT_reset)
 228  ,[DEL_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, DEL_finished, DEL_reset)
 229  ,[RST_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, RST_finished, RST_reset)
 230  ,[CAD_TD] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, CAD_finished, CAD_reset)
 231  ,[LYR_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, LYR_finished, LYR_reset)
 232
 233 };
 234
 235 //In Layer declaration, add tap dance item in place of a key code
 236 //TD(TD_SFT_CAPS)