users/wanleg/tapdances.c

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