process_tap_dance.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
  1. /* Copyright 2016 Jack Humbert
  2. *
  3. * This program is free software: you can redistribute it and/or modify
  4. * it under the terms of the GNU General Public License as published by
  5. * the Free Software Foundation, either version 2 of the License, or
  6. * (at your option) any later version.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #include "quantum.h"
  17. #ifndef NO_ACTION_ONESHOT
  18. uint8_t get_oneshot_mods(void);
  19. #endif
  20. static uint16_t last_td;
  21. static int8_t highest_td = -1;
  22. void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data) {
  23. qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
  24. if (state->count == 2) {
  25. register_code16(pair->kc2);
  26. state->finished = true;
  27. }
  28. }
  29. void qk_tap_dance_pair_finished(qk_tap_dance_state_t *state, void *user_data) {
  30. qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
  31. if (state->count == 1) {
  32. register_code16(pair->kc1);
  33. } else if (state->count == 2) {
  34. register_code16(pair->kc2);
  35. }
  36. }
  37. void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data) {
  38. qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
  39. if (state->count == 1) {
  40. unregister_code16(pair->kc1);
  41. } else if (state->count == 2) {
  42. unregister_code16(pair->kc2);
  43. }
  44. }
  45. void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_data) {
  46. qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
  47. if (state->count == 2) {
  48. layer_move(pair->layer);
  49. state->finished = true;
  50. }
  51. }
  52. void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_data) {
  53. qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
  54. if (state->count == 1) {
  55. register_code16(pair->kc);
  56. } else if (state->count == 2) {
  57. pair->layer_function(pair->layer);
  58. }
  59. }
  60. void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data) {
  61. qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
  62. if (state->count == 1) {
  63. unregister_code16(pair->kc);
  64. }
  65. }
  66. static inline void _process_tap_dance_action_fn(qk_tap_dance_state_t *state, void *user_data, qk_tap_dance_user_fn_t fn) {
  67. if (fn) {
  68. fn(state, user_data);
  69. }
  70. }
  71. static inline void process_tap_dance_action_on_each_tap(qk_tap_dance_action_t *action) { _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_each_tap); }
  72. static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_action_t *action) {
  73. if (action->state.finished) return;
  74. action->state.finished = true;
  75. add_mods(action->state.oneshot_mods);
  76. add_weak_mods(action->state.weak_mods);
  77. send_keyboard_report();
  78. _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_dance_finished);
  79. }
  80. static inline void process_tap_dance_action_on_reset(qk_tap_dance_action_t *action) {
  81. _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_reset);
  82. del_mods(action->state.oneshot_mods);
  83. del_weak_mods(action->state.weak_mods);
  84. send_keyboard_report();
  85. }
  86. void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
  87. qk_tap_dance_action_t *action;
  88. if (!record->event.pressed) return;
  89. if (highest_td == -1) return;
  90. for (int i = 0; i <= highest_td; i++) {
  91. action = &tap_dance_actions[i];
  92. if (action->state.count) {
  93. if (keycode == action->state.keycode && keycode == last_td) continue;
  94. action->state.interrupted = true;
  95. action->state.interrupting_keycode = keycode;
  96. process_tap_dance_action_on_dance_finished(action);
  97. reset_tap_dance(&action->state);
  98. }
  99. }
  100. }
  101. bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
  102. uint16_t idx = keycode - QK_TAP_DANCE;
  103. qk_tap_dance_action_t *action;
  104. switch (keycode) {
  105. case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
  106. if ((int16_t)idx > highest_td) highest_td = idx;
  107. action = &tap_dance_actions[idx];
  108. action->state.pressed = record->event.pressed;
  109. if (record->event.pressed) {
  110. action->state.keycode = keycode;
  111. action->state.count++;
  112. action->state.timer = timer_read();
  113. #ifndef NO_ACTION_ONESHOT
  114. action->state.oneshot_mods = get_oneshot_mods();
  115. #else
  116. action->state.oneshot_mods = 0;
  117. #endif
  118. action->state.weak_mods = get_mods();
  119. action->state.weak_mods |= get_weak_mods();
  120. process_tap_dance_action_on_each_tap(action);
  121. last_td = keycode;
  122. } else {
  123. if (action->state.count && action->state.finished) {
  124. reset_tap_dance(&action->state);
  125. }
  126. }
  127. break;
  128. }
  129. return true;
  130. }
  131. void matrix_scan_tap_dance() {
  132. if (highest_td == -1) return;
  133. uint16_t tap_user_defined;
  134. for (uint8_t i = 0; i <= highest_td; i++) {
  135. qk_tap_dance_action_t *action = &tap_dance_actions[i];
  136. if (action->custom_tapping_term > 0) {
  137. tap_user_defined = action->custom_tapping_term;
  138. } else {
  139. #ifdef TAPPING_TERM_PER_KEY
  140. tap_user_defined = get_tapping_term(action->state.keycode, NULL);
  141. #else
  142. tap_user_defined = TAPPING_TERM;
  143. #endif
  144. }
  145. if (action->state.count && timer_elapsed(action->state.timer) > tap_user_defined) {
  146. process_tap_dance_action_on_dance_finished(action);
  147. reset_tap_dance(&action->state);
  148. }
  149. }
  150. }
  151. void reset_tap_dance(qk_tap_dance_state_t *state) {
  152. qk_tap_dance_action_t *action;
  153. if (state->pressed) return;
  154. action = &tap_dance_actions[state->keycode - QK_TAP_DANCE];
  155. process_tap_dance_action_on_reset(action);
  156. state->count = 0;
  157. state->interrupted = false;
  158. state->finished = false;
  159. state->interrupting_keycode = 0;
  160. last_td = 0;
  161. }