process_tap_dance.c 5.9 KB

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