users/zer09/tap_dance.c

   1 #include "tap_dance.h"
   2 #include "lights.h"
   3
   4 qk_tap_dance_action_t tap_dance_actions[] = {
   5     [DA_LCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_lctl_finished,
   6                                              dance_lctl_reset),
   7     [DA_LSPR] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_lspr_finished,
   8                                              dance_lspr_reset),
   9     [DA_RCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_rctl_finished,
  10                                              dance_rctl_reset),
  11     [DA_RALT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_ralt_finished,
  12                                              dance_ralt_reset),
  13     [DA_UPLY] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_uply_finished,
  14                                              dance_uply_reset),
  15     [DA_DWLY] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_dwly_finished,
  16                                              dance_dwly_reset),
  17 };
  18
  19 volatile uint8_t active_layer = _BL;
  20 static tap upltap_state = {.state = 0};
  21 static tap dwltap_state = {.state = 0};
  22 static tap lsprtap_state = {.state = 0};
  23 static tap ralttap_state = {.state = 0};
  24
  25 void layer_switcher_tap(uint8_t new_layer) {
  26   layer_off(active_layer);
  27   layer_on(new_layer);
  28   active_layer = new_layer;
  29 }
  30
  31 int cur_dance(qk_tap_dance_state_t *state) {
  32   switch (state->count) {
  33   case 1:
  34     return state->pressed == 0 ? SINGLE_TAP : SINGLE_HOLD;
  35   case 2:
  36     return state->pressed == 0 ? DOUBLE_TAP : DOUBLE_HOLD;
  37   case 3:
  38     return state->pressed == 0 ? TRIPLE_TAP : TRIPLE_HOLD;
  39   default:
  40     return state->pressed == 0 ? DEFAULT_TAP : DEFAULT_HOLD;
  41   }
  42 }
  43
  44 void dance_lctl_finished(qk_tap_dance_state_t *state, void *user_data) {
  45   rbw_led_keys[RBW_LCTL].status = ENABLED;
  46   register_code(KC_LCTRL);
  47 };
  48
  49 void dance_lctl_reset(qk_tap_dance_state_t *state, void *user_data) {
  50   unregister_code(KC_LCTRL);
  51   rbw_led_keys[RBW_LCTL].status = DISABLED;
  52 };
  53
  54 void dance_lspr_finished(qk_tap_dance_state_t *state, void *user_data) {
  55   lsprtap_state.state = cur_dance(state);
  56
  57   switch (lsprtap_state.state) {
  58   case DOUBLE_HOLD:
  59     rbw_led_keys[RBW_LSPR].status = ENABLED;
  60     register_code(KC_LALT);
  61     break;
  62   default:
  63     register_code(KC_LGUI);
  64     break;
  65   }
  66 };
  67
  68 void dance_lspr_reset(qk_tap_dance_state_t *state, void *user_data) {
  69   switch (lsprtap_state.state) {
  70   case DOUBLE_HOLD:
  71     unregister_code(KC_LALT);
  72     rbw_led_keys[RBW_LSPR].status = DISABLED;
  73     break;
  74   default:
  75     unregister_code(KC_LGUI);
  76     break;
  77   }
  78 };
  79
  80 void dance_rctl_finished(qk_tap_dance_state_t *state, void *user_data) {
  81   rbw_led_keys[RBW_RCTL].status = ENABLED;
  82   register_code(KC_RCTRL);
  83 };
  84
  85 void dance_rctl_reset(qk_tap_dance_state_t *state, void *user_data) {
  86   unregister_code(KC_RCTRL);
  87   rbw_led_keys[RBW_RCTL].status = DISABLED;
  88 };
  89
  90 void dance_ralt_finished(qk_tap_dance_state_t *state, void *user_data) {
  91   ralttap_state.state = cur_dance(state);
  92
  93   switch (ralttap_state.state) {
  94   case DOUBLE_HOLD:
  95     rbw_led_keys[RBW_RALT].status = ENABLED;
  96     unregister_code(KC_LGUI);
  97     break;
  98   default:
  99     register_code(KC_RALT);
 100     break;
 101   }
 102 };
 103
 104 void dance_ralt_reset(qk_tap_dance_state_t *state, void *user_data) {
 105   switch (ralttap_state.state) {
 106   case DOUBLE_HOLD:
 107     unregister_code(KC_RGUI);
 108     rbw_led_keys[RBW_RALT].status = DISABLED;
 109     break;
 110   default:
 111     unregister_code(KC_RALT);
 112     break;
 113   }
 114 };
 115
 116 void dance_uply_finished(qk_tap_dance_state_t *state, void *user_data) {
 117   upltap_state.state = cur_dance(state);
 118
 119   switch (upltap_state.state) {
 120   case SINGLE_TAP:
 121     if (active_layer == _UL) {
 122       layer_switcher_tap(_BL);
 123     } else {
 124       layer_switcher_tap(_UL);
 125     }
 126     break;
 127   case SINGLE_HOLD:
 128     layer_switcher_tap(_UL);
 129     break;
 130   default:
 131     layer_switcher_tap(_BL);
 132     break;
 133   }
 134 }
 135
 136 void dance_uply_reset(qk_tap_dance_state_t *state, void *user_data) {
 137   switch (upltap_state.state) {
 138   case SINGLE_TAP:
 139     break;
 140   case SINGLE_HOLD:
 141   default:
 142     layer_switcher_tap(_BL);
 143     break;
 144   }
 145   upltap_state.state = 0;
 146 }
 147
 148 void dance_dwly_finished(qk_tap_dance_state_t *state, void *user_data) {
 149   dwltap_state.state = cur_dance(state);
 150
 151   switch (dwltap_state.state) {
 152   case SINGLE_TAP:
 153     if (active_layer == _DL) {
 154       layer_switcher_tap(_BL);
 155     } else {
 156       layer_switcher_tap(_DL);
 157     }
 158     break;
 159   case SINGLE_HOLD:
 160     layer_switcher_tap(_DL);
 161     break;
 162   case DOUBLE_HOLD:
 163     layer_switcher_tap(_AL);
 164     break;
 165   default:
 166     layer_switcher_tap(_BL);
 167     break;
 168   }
 169 }
 170
 171 void dance_dwly_reset(qk_tap_dance_state_t *state, void *user_data) {
 172   switch (dwltap_state.state) {
 173   case SINGLE_TAP:
 174     break;
 175   case SINGLE_HOLD:
 176   case DOUBLE_HOLD:
 177   default:
 178     layer_switcher_tap(_BL);
 179     break;
 180   }
 181   dwltap_state.state = 0;
 182 }