process_tap_dance.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
  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. #include "action_tapping.h"
  18. #ifndef NO_ACTION_ONESHOT
  19. uint8_t get_oneshot_mods(void);
  20. #endif
  21. static uint16_t last_td;
  22. static int8_t highest_td = -1;
  23. void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data) {
  24. qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
  25. if (state->count == 2) {
  26. register_code16(pair->kc2);
  27. state->finished = true;
  28. }
  29. }
  30. void qk_tap_dance_pair_finished(qk_tap_dance_state_t *state, void *user_data) {
  31. qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
  32. if (state->count == 1) {
  33. register_code16(pair->kc1);
  34. } else if (state->count == 2) {
  35. register_code16(pair->kc2);
  36. }
  37. }
  38. void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data) {
  39. qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
  40. if (state->count == 1) {
  41. unregister_code16(pair->kc1);
  42. } else if (state->count == 2) {
  43. unregister_code16(pair->kc2);
  44. }
  45. }
  46. void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_data) {
  47. qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
  48. if (state->count == 2) {
  49. layer_move(pair->layer);
  50. state->finished = true;
  51. }
  52. }
  53. void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_data) {
  54. qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
  55. if (state->count == 1) {
  56. register_code16(pair->kc);
  57. } else if (state->count == 2) {
  58. pair->layer_function(pair->layer);
  59. }
  60. }
  61. void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data) {
  62. qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
  63. if (state->count == 1) {
  64. unregister_code16(pair->kc);
  65. }
  66. }
  67. static inline void _process_tap_dance_action_fn(qk_tap_dance_state_t *state, void *user_data, qk_tap_dance_user_fn_t fn) {
  68. if (fn) {
  69. fn(state, user_data);
  70. }
  71. }
  72. 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); }
  73. static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_action_t *action) {
  74. if (action->state.finished) return;
  75. action->state.finished = true;
  76. add_mods(action->state.oneshot_mods);
  77. add_weak_mods(action->state.weak_mods);
  78. send_keyboard_report();
  79. _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_dance_finished);
  80. }
  81. static inline void process_tap_dance_action_on_reset(qk_tap_dance_action_t *action) {
  82. _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_reset);
  83. del_mods(action->state.oneshot_mods);
  84. del_weak_mods(action->state.weak_mods);
  85. send_keyboard_report();
  86. }
  87. void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
  88. qk_tap_dance_action_t *action;
  89. if (!record->event.pressed) return;
  90. if (highest_td == -1) return;
  91. for (int i = 0; i <= highest_td; i++) {
  92. action = &tap_dance_actions[i];
  93. if (action->state.count) {
  94. if (keycode == action->state.keycode && keycode == last_td) continue;
  95. action->state.interrupted = true;
  96. action->state.interrupting_keycode = keycode;
  97. process_tap_dance_action_on_dance_finished(action);
  98. reset_tap_dance(&action->state);
  99. }
  100. }
  101. }
  102. bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
  103. uint16_t idx = keycode - QK_TAP_DANCE;
  104. qk_tap_dance_action_t *action;
  105. switch (keycode) {
  106. case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
  107. if ((int16_t)idx > highest_td) highest_td = idx;
  108. action = &tap_dance_actions[idx];
  109. action->state.pressed = record->event.pressed;
  110. if (record->event.pressed) {
  111. action->state.keycode = keycode;
  112. action->state.count++;
  113. action->state.timer = timer_read();
  114. #ifndef NO_ACTION_ONESHOT
  115. action->state.oneshot_mods = get_oneshot_mods();
  116. #else
  117. action->state.oneshot_mods = 0;
  118. #endif
  119. action->state.weak_mods = get_mods();
  120. action->state.weak_mods |= get_weak_mods();
  121. process_tap_dance_action_on_each_tap(action);
  122. last_td = keycode;
  123. } else {
  124. if (action->state.count && action->state.finished) {
  125. reset_tap_dance(&action->state);
  126. }
  127. }
  128. break;
  129. }
  130. return true;
  131. }
  132. void matrix_scan_tap_dance() {
  133. if (highest_td == -1) return;
  134. uint16_t tap_user_defined;
  135. for (uint8_t i = 0; i <= highest_td; i++) {
  136. qk_tap_dance_action_t *action = &tap_dance_actions[i];
  137. if (action->custom_tapping_term > 0) {
  138. tap_user_defined = action->custom_tapping_term;
  139. } else {
  140. tap_user_defined = get_tapping_term(action->state.keycode, NULL);
  141. }
  142. if (action->state.count && timer_elapsed(action->state.timer) > tap_user_defined) {
  143. process_tap_dance_action_on_dance_finished(action);
  144. reset_tap_dance(&action->state);
  145. }
  146. }
  147. }
  148. void reset_tap_dance(qk_tap_dance_state_t *state) {
  149. qk_tap_dance_action_t *action;
  150. if (state->pressed) return;
  151. action = &tap_dance_actions[state->keycode - QK_TAP_DANCE];
  152. process_tap_dance_action_on_reset(action);
  153. state->count = 0;
  154. state->interrupted = false;
  155. state->finished = false;
  156. state->interrupting_keycode = 0;
  157. last_td = 0;
  158. }