aboutsummaryrefslogtreecommitdiff
path: root/quantum/action_tapping.c
diff options
context:
space:
mode:
Diffstat (limited to 'quantum/action_tapping.c')
-rw-r--r--quantum/action_tapping.c274
1 files changed, 254 insertions, 20 deletions
diff --git a/quantum/action_tapping.c b/quantum/action_tapping.c
index 8f238490f2..9171970702 100644
--- a/quantum/action_tapping.c
+++ b/quantum/action_tapping.c
@@ -49,6 +49,45 @@ __attribute__((weak)) bool get_permissive_hold(uint16_t keycode, keyrecord_t *re
}
# endif
+# if defined(CHORDAL_HOLD)
+extern const char chordal_hold_layout[MATRIX_ROWS][MATRIX_COLS] PROGMEM;
+
+# define REGISTERED_TAPS_SIZE 8
+// Array of tap-hold keys that have been settled as tapped but not yet released.
+static keypos_t registered_taps[REGISTERED_TAPS_SIZE] = {};
+static uint8_t num_registered_taps = 0;
+
+/** Adds `key` to the registered_taps array. */
+static void registered_taps_add(keypos_t key);
+/** Returns the index of `key` in registered_taps, or -1 if not found. */
+static int8_t registered_tap_find(keypos_t key);
+/** Removes index `i` from the registered_taps array. */
+static void registered_taps_del_index(uint8_t i);
+/** Logs the registered_taps array for debugging. */
+static void debug_registered_taps(void);
+
+/** \brief Finds which queued events should be held according to Chordal Hold.
+ *
+ * In a situation with multiple unsettled tap-hold key presses, scan the queue
+ * up until the first release, non-tap-hold, or one-shot event and find the
+ * latest event in the queue that settles as held according to
+ * get_chordal_hold().
+ *
+ * \return Index of the first tap, or equivalently, one past the latest hold.
+ */
+static uint8_t waiting_buffer_find_chordal_hold_tap(void);
+
+/** Processes queued events up to and including `key` as tapped. */
+static void waiting_buffer_chordal_hold_taps_until(keypos_t key);
+
+/** \brief Processes and pops buffered events until the first tap-hold event. */
+static void waiting_buffer_process_regular(void);
+
+static bool is_mt_or_lt(uint16_t keycode) {
+ return IS_QK_MOD_TAP(keycode) || IS_QK_LAYER_TAP(keycode);
+}
+# endif // CHORDAL_HOLD
+
# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY
__attribute__((weak)) bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) {
return false;
@@ -166,6 +205,20 @@ void action_tapping_process(keyrecord_t record) {
bool process_tapping(keyrecord_t *keyp) {
const keyevent_t event = keyp->event;
+# if defined(CHORDAL_HOLD)
+ if (!event.pressed) {
+ const int8_t i = registered_tap_find(event.key);
+ if (i != -1) {
+ // If a tap-hold key was previously settled as tapped, set its
+ // tap.count correspondingly on release.
+ keyp->tap.count = 1;
+ registered_taps_del_index(i);
+ ac_dprintf("Found tap release for [%d]\n", i);
+ debug_registered_taps();
+ }
+ }
+# endif // CHORDAL_HOLD
+
// state machine is in the "reset" state, no tapping key is to be
// processed
if (IS_NOEVENT(tapping_key.event)) {
@@ -188,7 +241,7 @@ bool process_tapping(keyrecord_t *keyp) {
return true;
}
-# if (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)) || defined(PERMISSIVE_HOLD_PER_KEY) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY)
+# if (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)) || defined(PERMISSIVE_HOLD_PER_KEY) || defined(CHORDAL_HOLD) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY)
TAP_DEFINE_KEYCODE;
# endif
@@ -199,6 +252,7 @@ bool process_tapping(keyrecord_t *keyp) {
// early return for tick events
return true;
}
+
if (tapping_key.tap.count == 0) {
if (IS_TAPPING_RECORD(keyp) && !event.pressed) {
// first tap!
@@ -212,6 +266,25 @@ bool process_tapping(keyrecord_t *keyp) {
// enqueue
return false;
}
+# if defined(CHORDAL_HOLD)
+ else if (is_mt_or_lt(tapping_keycode) && !event.pressed && waiting_buffer_typed(event) && !get_chordal_hold(tapping_keycode, &tapping_key, get_record_keycode(keyp, false), keyp)) {
+ // Key release that is not a chord with the tapping key.
+ // Settle the tapping key and any other pending tap-hold
+ // keys preceding the press of this key as tapped.
+
+ ac_dprintf("Tapping: End. Chord considered a tap\n");
+ tapping_key.tap.count = 1;
+ registered_taps_add(tapping_key.event.key);
+ process_record(&tapping_key);
+ tapping_key = (keyrecord_t){0};
+
+ waiting_buffer_chordal_hold_taps_until(event.key);
+ debug_registered_taps();
+ debug_waiting_buffer();
+ // enqueue
+ return false;
+ }
+# endif // CHORDAL_HOLD
/* Process a key typed within TAPPING_TERM
* This can register the key before settlement of tapping,
* useful for long TAPPING_TERM but may prevent fast typing.
@@ -229,6 +302,22 @@ bool process_tapping(keyrecord_t *keyp) {
// clang-format on
ac_dprintf("Tapping: End. No tap. Interfered by typing key\n");
process_record(&tapping_key);
+
+# if defined(CHORDAL_HOLD)
+ uint8_t first_tap = waiting_buffer_find_chordal_hold_tap();
+ ac_dprintf("first_tap = %u\n", first_tap);
+ if (first_tap < WAITING_BUFFER_SIZE) {
+ for (; waiting_buffer_tail != first_tap; waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE) {
+ ac_dprintf("Processing [%u]\n", waiting_buffer_tail);
+ process_record(&waiting_buffer[waiting_buffer_tail]);
+ }
+ }
+
+ waiting_buffer_chordal_hold_taps_until(event.key);
+ debug_registered_taps();
+ debug_waiting_buffer();
+# endif // CHORDAL_HOLD
+
tapping_key = (keyrecord_t){0};
debug_tapping_key();
// enqueue
@@ -237,6 +326,19 @@ bool process_tapping(keyrecord_t *keyp) {
/* Process release event of a key pressed before tapping starts
* Without this unexpected repeating will occur with having fast repeating setting
* https://github.com/tmk/tmk_keyboard/issues/60
+ *
+ * NOTE: This workaround causes events to process out of order,
+ * e.g. in a rolled press of three tap-hold keys like
+ *
+ * "A down, B down, C down, A up, B up, C up"
+ *
+ * events are processed as
+ *
+ * "A down, B down, A up, B up, C down, C up"
+ *
+ * It seems incorrect to process keyp before the tapping key.
+ * This workaround is old, from 2013. This might no longer
+ * be needed for the original problem it was meant to address.
*/
else if (!event.pressed && !waiting_buffer_typed(event)) {
// Modifier/Layer should be retained till end of this tapping.
@@ -271,19 +373,52 @@ bool process_tapping(keyrecord_t *keyp) {
// set interrupted flag when other key pressed during tapping
if (event.pressed) {
tapping_key.tap.interrupted = true;
- if (TAP_GET_HOLD_ON_OTHER_KEY_PRESS
+
+# if defined(CHORDAL_HOLD)
+ if (is_mt_or_lt(tapping_keycode) && !get_chordal_hold(tapping_keycode, &tapping_key, get_record_keycode(keyp, false), keyp)) {
+ // In process_action(), HOLD_ON_OTHER_KEY_PRESS
+ // will revert interrupted events to holds, so
+ // this needs to be set false.
+ tapping_key.tap.interrupted = false;
+
+ if (!is_tap_record(keyp)) {
+ ac_dprintf("Tapping: End. Chord considered a tap\n");
+ tapping_key.tap.count = 1;
+ registered_taps_add(tapping_key.event.key);
+ debug_registered_taps();
+ process_record(&tapping_key);
+ tapping_key = (keyrecord_t){0};
+ }
+ } else
+# endif // CHORDAL_HOLD
+ if (TAP_GET_HOLD_ON_OTHER_KEY_PRESS
# if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)
- // Auto Shift cannot evaluate this early
- // Retro Shift uses the hold action for all nested taps even without HOLD_ON_OTHER_KEY_PRESS, so this is fine to skip
- && !(MAYBE_RETRO_SHIFTING(event, keyp) && get_auto_shifted_key(get_record_keycode(keyp, false), keyp))
+ // Auto Shift cannot evaluate this early
+ // Retro Shift uses the hold action for all nested taps even without HOLD_ON_OTHER_KEY_PRESS, so this is fine to skip
+ && !(MAYBE_RETRO_SHIFTING(event, keyp) && get_auto_shifted_key(get_record_keycode(keyp, false), keyp))
# endif
- ) {
+ ) {
+ // Settle the tapping key as *held*, since
+ // HOLD_ON_OTHER_KEY_PRESS is enabled for this key.
ac_dprintf("Tapping: End. No tap. Interfered by pressed key\n");
process_record(&tapping_key);
- tapping_key = (keyrecord_t){0};
+
+# if defined(CHORDAL_HOLD)
+ if (waiting_buffer_tail != waiting_buffer_head && is_tap_record(&waiting_buffer[waiting_buffer_tail])) {
+ tapping_key = waiting_buffer[waiting_buffer_tail];
+ // Pop tail from the queue.
+ waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE;
+ debug_waiting_buffer();
+ } else
+# endif // CHORDAL_HOLD
+ {
+ tapping_key = (keyrecord_t){0};
+ }
debug_tapping_key();
- // enqueue
- return false;
+
+# if defined(CHORDAL_HOLD)
+ waiting_buffer_process_regular();
+# endif // CHORDAL_HOLD
}
}
// enqueue
@@ -520,26 +655,125 @@ void waiting_buffer_scan_tap(void) {
}
}
-/** \brief Tapping key debug print
- *
- * FIXME: Needs docs
- */
+# ifdef CHORDAL_HOLD
+__attribute__((weak)) bool get_chordal_hold(uint16_t tap_hold_keycode, keyrecord_t *tap_hold_record, uint16_t other_keycode, keyrecord_t *other_record) {
+ return get_chordal_hold_default(tap_hold_record, other_record);
+}
+
+bool get_chordal_hold_default(keyrecord_t *tap_hold_record, keyrecord_t *other_record) {
+ if (tap_hold_record->event.type != KEY_EVENT || other_record->event.type != KEY_EVENT) {
+ return true; // Return true on combos or other non-key events.
+ }
+
+ char tap_hold_hand = chordal_hold_handedness(tap_hold_record->event.key);
+ if (tap_hold_hand == '*') {
+ return true;
+ }
+ char other_hand = chordal_hold_handedness(other_record->event.key);
+ return other_hand == '*' || tap_hold_hand != other_hand;
+}
+
+__attribute__((weak)) char chordal_hold_handedness(keypos_t key) {
+ return (char)pgm_read_byte(&chordal_hold_layout[key.row][key.col]);
+}
+
+static void registered_taps_add(keypos_t key) {
+ if (num_registered_taps >= REGISTERED_TAPS_SIZE) {
+ ac_dprintf("TAPS OVERFLOW: CLEAR ALL STATES\n");
+ clear_keyboard();
+ num_registered_taps = 0;
+ }
+
+ registered_taps[num_registered_taps] = key;
+ ++num_registered_taps;
+}
+
+static int8_t registered_tap_find(keypos_t key) {
+ for (int8_t i = 0; i < num_registered_taps; ++i) {
+ if (KEYEQ(registered_taps[i], key)) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+static void registered_taps_del_index(uint8_t i) {
+ if (i < num_registered_taps) {
+ --num_registered_taps;
+ if (i < num_registered_taps) {
+ registered_taps[i] = registered_taps[num_registered_taps];
+ }
+ }
+}
+
+static void debug_registered_taps(void) {
+ ac_dprintf("registered_taps = { ");
+ for (int8_t i = 0; i < num_registered_taps; ++i) {
+ ac_dprintf("%02X%02X ", registered_taps[i].row, registered_taps[i].col);
+ }
+ ac_dprintf("}\n");
+}
+
+static uint8_t waiting_buffer_find_chordal_hold_tap(void) {
+ keyrecord_t *prev = &tapping_key;
+ uint16_t prev_keycode = get_record_keycode(&tapping_key, false);
+ uint8_t first_tap = WAITING_BUFFER_SIZE;
+ for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) {
+ keyrecord_t * cur = &waiting_buffer[i];
+ const uint16_t cur_keycode = get_record_keycode(cur, false);
+ if (!cur->event.pressed || !is_mt_or_lt(prev_keycode)) {
+ break;
+ } else if (get_chordal_hold(prev_keycode, prev, cur_keycode, cur)) {
+ first_tap = i; // Track one index past the latest hold.
+ }
+ prev = cur;
+ prev_keycode = cur_keycode;
+ }
+ return first_tap;
+}
+
+static void waiting_buffer_chordal_hold_taps_until(keypos_t key) {
+ while (waiting_buffer_tail != waiting_buffer_head) {
+ keyrecord_t *record = &waiting_buffer[waiting_buffer_tail];
+ ac_dprintf("waiting_buffer_chordal_hold_taps_until: processing [%u]\n", waiting_buffer_tail);
+ if (is_tap_record(record)) {
+ record->tap.count = 1;
+ registered_taps_add(record->event.key);
+ }
+ process_record(record);
+ waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE;
+
+ if (KEYEQ(key, record->event.key) && record->event.pressed) {
+ break;
+ }
+ }
+}
+
+static void waiting_buffer_process_regular(void) {
+ for (; waiting_buffer_tail != waiting_buffer_head; waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE) {
+ if (is_tap_record(&waiting_buffer[waiting_buffer_tail])) {
+ break; // Stop once a tap-hold key event is reached.
+ }
+ ac_dprintf("waiting_buffer_process_regular: processing [%u]\n", waiting_buffer_tail);
+ process_record(&waiting_buffer[waiting_buffer_tail]);
+ }
+ debug_waiting_buffer();
+}
+# endif // CHORDAL_HOLD
+
+/** \brief Logs tapping key if ACTION_DEBUG is enabled. */
static void debug_tapping_key(void) {
ac_dprintf("TAPPING_KEY=");
debug_record(tapping_key);
ac_dprintf("\n");
}
-/** \brief Waiting buffer debug print
- *
- * FIXME: Needs docs
- */
+/** \brief Logs waiting buffer if ACTION_DEBUG is enabled. */
static void debug_waiting_buffer(void) {
- ac_dprintf("{ ");
+ ac_dprintf("{");
for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) {
- ac_dprintf("[%u]=", i);
+ ac_dprintf(" [%u]=", i);
debug_record(waiting_buffer[i]);
- ac_dprintf(" ");
}
ac_dprintf("}\n");
}