From 65faab3b89245f81c50b029ca178aed175d5f330 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 29 Jun 2016 17:49:41 -0400
Subject: Moves features to their own files (process_*), adds tap dance feature
 (#460)

* non-working commit

* working

* subprojects implemented for planck

* pass a subproject variable through to c

* consolidates clueboard revisions

* thanks for letting me know about conflicts..

* turn off audio for yang's

* corrects starting paths for subprojects

* messing around with travis

* semicolon

* travis script

* travis script

* script for travis

* correct directory (probably), amend files to commit

* remove origin before adding

* git pull, correct syntax

* git checkout

* git pull origin branch

* where are we?

* where are we?

* merging

* force things to happen

* adds commit message, adds add

* rebase, no commit message

* rebase branch

* idk!

* try just pull

* fetch - merge

* specify repo branch

* checkout

* goddammit

* merge? idk

* pls

* after all

* don't split up keyboards

* syntax

* adds quick for all-keyboards

* trying out new script

* script update

* lowercase

* all keyboards

* stop replacing compiled.hex automatically

* adds if statement

* skip automated build branches

* forces push to automated build branch

* throw an add in there

* upstream?

* adds AUTOGEN

* ignore all .hex files again

* testing out new repo

* global ident

* generate script, keyboard_keymap.hex

* skip generation for now, print pandoc info, submodule update

* try trusty

* and sudo

* try generate

* updates subprojects to keyboards

* no idea

* updates to keyboards

* cleans up clueboard stuff

* setup to use local readme

* updates cluepad, planck experimental

* remove extra led.c [ci skip]

* audio and midi moved over to separate files

* chording, leader, unicode separated

* consolidate each [skip ci]

* correct include

* quantum: Add a tap dance feature (#451)

* quantum: Add a tap dance feature

With this feature one can specify keys that behave differently, based on
the amount of times they have been tapped, and when interrupted, they
get handled before the interrupter.

To make it clear how this is different from `ACTION_FUNCTION_TAP`, lets
explore a certain setup! We want one key to send `Space` on single tap,
but `Enter` on double-tap.

With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and
has the problem that when the sequence is interrupted, the interrupting
key will be send first. Thus, `SPC a` will result in `a SPC` being sent,
if they are typed within `TAPPING_TERM`. With the tap dance feature,
that'll come out as `SPC a`, correctly.

The implementation hooks into two parts of the system, to achieve this:
into `process_record_quantum()`, and the matrix scan. We need the latter
to be able to time out a tap sequence even when a key is not being
pressed, so `SPC` alone will time out and register after `TAPPING_TERM`
time.

But lets start with how to use it, first!

First, you will need `TAP_DANCE_ENABLE=yes` in your `Makefile`, because
the feature is disabled by default. This adds a little less than 1k to
the firmware size. Next, you will want to define some tap-dance keys,
which is easiest to do with the `TD()` macro, that - similar to `F()`,
takes a number, which will later be used as an index into the
`tap_dance_actions` array.

This array specifies what actions shall be taken when a tap-dance key is
in action. Currently, there are two possible options:

* `ACTION_TAP_DANCE_DOUBLE(kc1, kc2)`: Sends the `kc1` keycode when
  tapped once, `kc2` otherwise.
* `ACTION_TAP_DANCE_FN(fn)`: Calls the specified function - defined in
  the user keymap - with the current state of the tap-dance action.

The first option is enough for a lot of cases, that just want dual
roles. For example, `ACTION_TAP_DANCE(KC_SPC, KC_ENT)` will result in
`Space` being sent on single-tap, `Enter` otherwise.

And that's the bulk of it!

Do note, however, that this implementation does have some consequences:
keys do not register until either they reach the tapping ceiling, or
they time out. This means that if you hold the key, nothing happens, no
repeat, no nothing. It is possible to detect held state, and register an
action then too, but that's not implemented yet. Keys also unregister
immediately after being registered, so you can't even hold the second
tap. This is intentional, to be consistent.

And now, on to the explanation of how it works!

The main entry point is `process_tap_dance()`, called from
`process_record_quantum()`, which is run for every keypress, and our
handler gets to run early. This function checks whether the key pressed
is a tap-dance key. If it is not, and a tap-dance was in action, we
handle that first, and enqueue the newly pressed key. If it is a
tap-dance key, then we check if it is the same as the already active
one (if there's one active, that is). If it is not, we fire off the old
one first, then register the new one. If it was the same, we increment
the counter and the timer.

This means that you have `TAPPING_TERM` time to tap the key again, you
do not have to input all the taps within that timeframe. This allows for
longer tap counts, with minimal impact on responsiveness.

Our next stop is `matrix_scan_tap_dance()`. This handles the timeout of
tap-dance keys.

For the sake of flexibility, tap-dance actions can be either a pair of
keycodes, or a user function. The latter allows one to handle higher tap
counts, or do extra things, like blink the LEDs, fiddle with the
backlighting, and so on. This is accomplished by using an union, and
some clever macros.

In the end, lets see a full example!

```c
enum {
 CT_SE = 0,
 CT_CLN,
 CT_EGG
};

/* Have the above three on the keymap, TD(CT_SE), etc... */

void dance_cln (qk_tap_dance_state_t *state) {
  if (state->count == 1) {
    register_code (KC_RSFT);
    register_code (KC_SCLN);
    unregister_code (KC_SCLN);
    unregister_code (KC_RSFT);
  } else {
    register_code (KC_SCLN);
    unregister_code (KC_SCLN);
    reset_tap_dance (state);
  }
}

void dance_egg (qk_tap_dance_state_t *state) {
  if (state->count >= 100) {
    SEND_STRING ("Safety dance!");
    reset_tap_dance (state);
  }
}

const qk_tap_dance_action_t tap_dance_actions[] = {
  [CT_SE]  = ACTION_TAP_DANCE_DOUBLE (KC_SPC, KC_ENT)
 ,[CT_CLN] = ACTION_TAP_DANCE_FN (dance_cln)
 ,[CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
};
```

This addresses #426.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>

* hhkb: Fix the build with the new tap-dance feature

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>

* tap_dance: Move process_tap_dance further down

Process the tap dance stuff after midi and audio, because those don't
process keycodes, but row/col positions.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>

* tap_dance: Use conditionals instead of dummy functions

To be consistent with how the rest of the quantum features are
implemented, use ifdefs instead of dummy functions.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>

* Merge branch 'master' into quantum-keypress-process

# Conflicts:
#	Makefile
#	keyboards/planck/rev3/config.h
#	keyboards/planck/rev4/config.h

* update build script
---
 quantum/process_keycode/process_tap_dance.c | 90 +++++++++++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 quantum/process_keycode/process_tap_dance.c

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
new file mode 100644
index 0000000000..9b172e1b6c
--- /dev/null
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -0,0 +1,90 @@
+#include "quantum.h"
+
+static qk_tap_dance_state_t qk_tap_dance_state;
+
+static void _process_tap_dance_action_pair (qk_tap_dance_state_t *state,
+                                            uint16_t kc1, uint16_t kc2) {
+  uint16_t kc;
+
+  if (state->count == 0)
+    return;
+
+  kc = (state->count == 1) ? kc1 : kc2;
+
+  register_code (kc);
+  unregister_code (kc);
+
+  if (state->count >= 2) {
+    reset_tap_dance (state);
+  }
+}
+
+static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
+                                          qk_tap_dance_user_fn_t fn)
+{
+  fn(state);
+}
+
+void process_tap_dance_action (uint16_t keycode)
+{
+  uint16_t idx = keycode - QK_TAP_DANCE;
+  qk_tap_dance_action_t action;
+
+  action = tap_dance_actions[idx];
+
+  switch (action.type) {
+  case QK_TAP_DANCE_TYPE_PAIR:
+    _process_tap_dance_action_pair (&qk_tap_dance_state,
+                                    action.pair.kc1, action.pair.kc2);
+    break;
+  case QK_TAP_DANCE_TYPE_FN:
+    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn);
+    break;
+
+  default:
+    break;
+  }
+}
+
+bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
+  bool r = true;
+
+  switch(keycode) {
+  case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+    if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
+      process_tap_dance_action (qk_tap_dance_state.keycode);
+    } else {
+      r = false;
+    }
+
+    if (record->event.pressed) {
+      qk_tap_dance_state.keycode = keycode;
+      qk_tap_dance_state.timer = timer_read ();
+      qk_tap_dance_state.count++;
+    }
+    break;
+
+  default:
+    if (qk_tap_dance_state.keycode) {
+      process_tap_dance_action (qk_tap_dance_state.keycode);
+
+      reset_tap_dance (&qk_tap_dance_state);
+    }
+    break;
+  }
+
+  return r;
+}
+
+void matrix_scan_tap_dance () {
+  if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
+    process_tap_dance_action (qk_tap_dance_state.keycode);
+
+    reset_tap_dance (&qk_tap_dance_state);
+  }
+}
+
+void reset_tap_dance (qk_tap_dance_state_t *state) {
+  state->keycode = 0;
+  state->count = 0;
+}
-- 
cgit v1.2.3


From 1a7e954f9fc4d250ba1ae46e3bfc168aca2b5cce Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Wed, 13 Jul 2016 00:20:28 +0200
Subject: in case its NULL

---
 quantum/process_keycode/process_tap_dance.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 9b172e1b6c..186889bc29 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -22,7 +22,9 @@ static void _process_tap_dance_action_pair (qk_tap_dance_state_t *state,
 static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
                                           qk_tap_dance_user_fn_t fn)
 {
-  fn(state);
+  if (fn) {
+    fn(state);
+  }
 }
 
 void process_tap_dance_action (uint16_t keycode)
-- 
cgit v1.2.3


From f3b56701ed7e6c622dc48e429780124ba5fde172 Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Wed, 13 Jul 2016 16:47:45 +0200
Subject: add an `anyway` and a `reset` callback

when using tap dance, we have the `regular` callback that is called on
the last tap. this commit adds an `anyway` callback that is called on
every tap, and a `reset` callback that is called on reset of the tap
dance taps.
---
 quantum/process_keycode/process_tap_dance.c | 36 ++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 186889bc29..40fba2a6a6 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -40,7 +40,24 @@ void process_tap_dance_action (uint16_t keycode)
                                     action.pair.kc1, action.pair.kc2);
     break;
   case QK_TAP_DANCE_TYPE_FN:
-    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn);
+    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.regular);
+    break;
+
+  default:
+    break;
+  }
+}
+
+void process_tap_dance_action_anyway (uint16_t keycode)
+{
+  uint16_t idx = keycode - QK_TAP_DANCE;
+  qk_tap_dance_action_t action;
+
+  action = tap_dance_actions[idx];
+
+  switch (action.type) {
+  case QK_TAP_DANCE_TYPE_FN:
+    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.anyway);
     break;
 
   default:
@@ -53,6 +70,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
   switch(keycode) {
   case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+    process_tap_dance_action_anyway (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
       process_tap_dance_action (qk_tap_dance_state.keycode);
     } else {
@@ -68,6 +86,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
   default:
     if (qk_tap_dance_state.keycode) {
+      //process_tap_dance_action_anyway (qk_tap_dance_state.keycode);
       process_tap_dance_action (qk_tap_dance_state.keycode);
 
       reset_tap_dance (&qk_tap_dance_state);
@@ -87,6 +106,21 @@ void matrix_scan_tap_dance () {
 }
 
 void reset_tap_dance (qk_tap_dance_state_t *state) {
+  uint16_t idx = state->keycode - QK_TAP_DANCE;
+  qk_tap_dance_action_t action;
+
+  action = tap_dance_actions[idx];
+  switch (action.type) {
+  case QK_TAP_DANCE_TYPE_FN:
+    if (action.fn.reset) {
+      action.fn.reset();
+    }
+    break;
+
+  default:
+    break;
+  }
+
   state->keycode = 0;
   state->count = 0;
 }
-- 
cgit v1.2.3


From d3091faf363afc8fef73ddf4948f872439b0e827 Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Fri, 15 Jul 2016 23:54:08 +0200
Subject: change naming, and remove extraneous definition

---
 quantum/process_keycode/process_tap_dance.c | 32 ++++++++++++++---------------
 1 file changed, 15 insertions(+), 17 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 40fba2a6a6..93b326b5fc 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -27,7 +27,7 @@ static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
   }
 }
 
-void process_tap_dance_action (uint16_t keycode)
+void process_tap_dance_action_on_each_tap (uint16_t keycode)
 {
   uint16_t idx = keycode - QK_TAP_DANCE;
   qk_tap_dance_action_t action;
@@ -35,12 +35,8 @@ void process_tap_dance_action (uint16_t keycode)
   action = tap_dance_actions[idx];
 
   switch (action.type) {
-  case QK_TAP_DANCE_TYPE_PAIR:
-    _process_tap_dance_action_pair (&qk_tap_dance_state,
-                                    action.pair.kc1, action.pair.kc2);
-    break;
   case QK_TAP_DANCE_TYPE_FN:
-    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.regular);
+    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.on_each_tap);
     break;
 
   default:
@@ -48,7 +44,7 @@ void process_tap_dance_action (uint16_t keycode)
   }
 }
 
-void process_tap_dance_action_anyway (uint16_t keycode)
+void process_tap_dance_action_on_dance_finished (uint16_t keycode)
 {
   uint16_t idx = keycode - QK_TAP_DANCE;
   qk_tap_dance_action_t action;
@@ -56,8 +52,12 @@ void process_tap_dance_action_anyway (uint16_t keycode)
   action = tap_dance_actions[idx];
 
   switch (action.type) {
+  case QK_TAP_DANCE_TYPE_PAIR:
+    _process_tap_dance_action_pair (&qk_tap_dance_state,
+                                    action.pair.kc1, action.pair.kc2);
+    break;
   case QK_TAP_DANCE_TYPE_FN:
-    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.anyway);
+    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.on_dance_finished);
     break;
 
   default:
@@ -70,9 +70,9 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
   switch(keycode) {
   case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
-    process_tap_dance_action_anyway (qk_tap_dance_state.keycode);
+    process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
-      process_tap_dance_action (qk_tap_dance_state.keycode);
+      process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
     } else {
       r = false;
     }
@@ -85,10 +85,9 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
     break;
 
   default:
+    process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode) {
-      //process_tap_dance_action_anyway (qk_tap_dance_state.keycode);
-      process_tap_dance_action (qk_tap_dance_state.keycode);
-
+      process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
       reset_tap_dance (&qk_tap_dance_state);
     }
     break;
@@ -99,8 +98,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
 void matrix_scan_tap_dance () {
   if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
-    process_tap_dance_action (qk_tap_dance_state.keycode);
-
+    process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
     reset_tap_dance (&qk_tap_dance_state);
   }
 }
@@ -112,8 +110,8 @@ void reset_tap_dance (qk_tap_dance_state_t *state) {
   action = tap_dance_actions[idx];
   switch (action.type) {
   case QK_TAP_DANCE_TYPE_FN:
-    if (action.fn.reset) {
-      action.fn.reset();
+    if (action.fn.on_reset) {
+      action.fn.on_reset(state);
     }
     break;
 
-- 
cgit v1.2.3


From dda2fd6ff3984ed96f8275c661b47a0484f9ee18 Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Mon, 18 Jul 2016 23:34:02 +0200
Subject: in the default case, it should be called if there is actually a tap
 dance happening, and in the normal case, it should be called when the tap
 down is happening.

---
 quantum/process_keycode/process_tap_dance.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 93b326b5fc..bab6bb81b3 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -70,7 +70,6 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
   switch(keycode) {
   case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
-    process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
       process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
     } else {
@@ -81,12 +80,13 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
       qk_tap_dance_state.keycode = keycode;
       qk_tap_dance_state.timer = timer_read ();
       qk_tap_dance_state.count++;
+      process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     }
     break;
 
   default:
-    process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode) {
+      process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
       process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
       reset_tap_dance (&qk_tap_dance_state);
     }
-- 
cgit v1.2.3


From d5daec2a58019ebdb9804787e0f786e4fc3c05b9 Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Tue, 19 Jul 2016 18:00:59 +0200
Subject: on_each_tap_fn is called on tap down and tap up

---
 quantum/process_keycode/process_tap_dance.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index bab6bb81b3..58192413fb 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -70,6 +70,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
   switch(keycode) {
   case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+    process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
       process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
     } else {
@@ -80,7 +81,6 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
       qk_tap_dance_state.keycode = keycode;
       qk_tap_dance_state.timer = timer_read ();
       qk_tap_dance_state.count++;
-      process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     }
     break;
 
-- 
cgit v1.2.3


From 4e6a8627d8ebd7af942f68142d1a959d60361d90 Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Tue, 19 Jul 2016 18:02:13 +0200
Subject: add a couple of comments

---
 quantum/process_keycode/process_tap_dance.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 58192413fb..b9b836df2e 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -86,6 +86,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
   default:
     if (qk_tap_dance_state.keycode) {
+      // if we are here, the tap dance was interrupted by a different key
       process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
       process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
       reset_tap_dance (&qk_tap_dance_state);
@@ -98,6 +99,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 
 void matrix_scan_tap_dance () {
   if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
+    // if we are here, the tap dance was timed out
     process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
     reset_tap_dance (&qk_tap_dance_state);
   }
-- 
cgit v1.2.3


From 70e42489dec375e558d8e81ed5ebfb69b4f3dbd9 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 20 Jul 2016 10:22:52 +0200
Subject: tap-dance: Support for holding keys

With this change, tap dance will now store the pressed state of the
tap-dance key, and allow one to make an action sooner, while the key is
still held, and only unregister when the key is released.

The registration must happen in the `on_dance_finished` callback, while
unregistering goes to `on_reset`. The surrounding code makes sure not to
call either multiple times.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index b9b836df2e..097440405c 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -73,10 +73,14 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
     process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
     if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
       process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
+    } else if (qk_tap_dance_state.active && qk_tap_dance_state.pressed) {
+      reset_tap_dance (&qk_tap_dance_state);
     } else {
       r = false;
     }
 
+    qk_tap_dance_state.active = true;
+    qk_tap_dance_state.pressed = record->event.pressed;
     if (record->event.pressed) {
       qk_tap_dance_state.keycode = keycode;
       qk_tap_dance_state.timer = timer_read ();
@@ -90,6 +94,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
       process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
       process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
       reset_tap_dance (&qk_tap_dance_state);
+      qk_tap_dance_state.active = false;
     }
     break;
   }
@@ -98,7 +103,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 }
 
 void matrix_scan_tap_dance () {
-  if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
+  if (qk_tap_dance_state.active && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
     // if we are here, the tap dance was timed out
     process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
     reset_tap_dance (&qk_tap_dance_state);
@@ -109,6 +114,9 @@ void reset_tap_dance (qk_tap_dance_state_t *state) {
   uint16_t idx = state->keycode - QK_TAP_DANCE;
   qk_tap_dance_action_t action;
 
+  if (state->pressed)
+    return;
+
   action = tap_dance_actions[idx];
   switch (action.type) {
   case QK_TAP_DANCE_TYPE_FN:
@@ -123,4 +131,5 @@ void reset_tap_dance (qk_tap_dance_state_t *state) {
 
   state->keycode = 0;
   state->count = 0;
+  state->active = false;
 }
-- 
cgit v1.2.3


From ce8cc9219fca5dde077f1142d03d011b38d27479 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 20 Jul 2016 11:34:45 +0200
Subject: tap-dance: Support user_data for the callbacks

Refactored the code a little, so all callbacks now receive a `user_data`
pointer, which can be anything. As an example, the key pairs from
`ACTION_TAP_DANCE_DOUBLE` now use this, and custom, built-in functions.

This makes it easier to extend the tap dance functionality, and also
simplifies the code a little.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 61 ++++++++++-------------------
 1 file changed, 20 insertions(+), 41 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 097440405c..94b6af1305 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -2,28 +2,32 @@
 
 static qk_tap_dance_state_t qk_tap_dance_state;
 
-static void _process_tap_dance_action_pair (qk_tap_dance_state_t *state,
-                                            uint16_t kc1, uint16_t kc2) {
-  uint16_t kc;
+void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data) {
+  qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
 
-  if (state->count == 0)
-    return;
-
-  kc = (state->count == 1) ? kc1 : kc2;
+  if (state->count == 1) {
+    register_code (pair->kc1);
+  } else if (state->count == 2) {
+    register_code (pair->kc2);
+  }
+}
 
-  register_code (kc);
-  unregister_code (kc);
+void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data) {
+  qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
 
-  if (state->count >= 2) {
-    reset_tap_dance (state);
+  if (state->count == 1) {
+    unregister_code (pair->kc1);
+  } else if (state->count == 2) {
+    unregister_code (pair->kc2);
   }
 }
 
 static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
+                                          void *user_data,
                                           qk_tap_dance_user_fn_t fn)
 {
   if (fn) {
-    fn(state);
+    fn(state, user_data);
   }
 }
 
@@ -34,14 +38,7 @@ void process_tap_dance_action_on_each_tap (uint16_t keycode)
 
   action = tap_dance_actions[idx];
 
-  switch (action.type) {
-  case QK_TAP_DANCE_TYPE_FN:
-    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.on_each_tap);
-    break;
-
-  default:
-    break;
-  }
+  _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_each_tap);
 }
 
 void process_tap_dance_action_on_dance_finished (uint16_t keycode)
@@ -51,18 +48,7 @@ void process_tap_dance_action_on_dance_finished (uint16_t keycode)
 
   action = tap_dance_actions[idx];
 
-  switch (action.type) {
-  case QK_TAP_DANCE_TYPE_PAIR:
-    _process_tap_dance_action_pair (&qk_tap_dance_state,
-                                    action.pair.kc1, action.pair.kc2);
-    break;
-  case QK_TAP_DANCE_TYPE_FN:
-    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn.on_dance_finished);
-    break;
-
-  default:
-    break;
-  }
+  _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_dance_finished);
 }
 
 bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
@@ -118,15 +104,8 @@ void reset_tap_dance (qk_tap_dance_state_t *state) {
     return;
 
   action = tap_dance_actions[idx];
-  switch (action.type) {
-  case QK_TAP_DANCE_TYPE_FN:
-    if (action.fn.on_reset) {
-      action.fn.on_reset(state);
-    }
-    break;
-
-  default:
-    break;
+  if (action.fn.on_reset) {
+    action.fn.on_reset(state, action.user_data);
   }
 
   state->keycode = 0;
-- 
cgit v1.2.3


From 44e16ffc80620b61eaa17aedcfdd8233d9c99bd9 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 20 Jul 2016 11:49:59 +0200
Subject: tap-dance: Code cleanup

Removes a number of duplicated code, by passing actions around instead
of keycodes, so the various dance action functions do not have to look
up the action, but the caller does that for them.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 45 +++++++++++++++--------------
 1 file changed, 24 insertions(+), 21 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 94b6af1305..d240dc2e66 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -22,7 +22,7 @@ void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data) {
   }
 }
 
-static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
+static inline void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
                                           void *user_data,
                                           qk_tap_dance_user_fn_t fn)
 {
@@ -31,34 +31,33 @@ static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
   }
 }
 
-void process_tap_dance_action_on_each_tap (uint16_t keycode)
+static inline void process_tap_dance_action_on_each_tap (qk_tap_dance_action_t action)
 {
-  uint16_t idx = keycode - QK_TAP_DANCE;
-  qk_tap_dance_action_t action;
-
-  action = tap_dance_actions[idx];
-
   _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_each_tap);
 }
 
-void process_tap_dance_action_on_dance_finished (uint16_t keycode)
+static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_action_t action)
 {
-  uint16_t idx = keycode - QK_TAP_DANCE;
-  qk_tap_dance_action_t action;
-
-  action = tap_dance_actions[idx];
-
   _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_dance_finished);
 }
 
+static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t action)
+{
+  _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_reset);
+}
+
 bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
   bool r = true;
+  uint16_t idx = keycode - QK_TAP_DANCE;
+  qk_tap_dance_action_t action;
 
   switch(keycode) {
   case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
-    process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
+    action = tap_dance_actions[idx];
+
+    process_tap_dance_action_on_each_tap (action);
     if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
-      process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
+      process_tap_dance_action_on_dance_finished (action);
     } else if (qk_tap_dance_state.active && qk_tap_dance_state.pressed) {
       reset_tap_dance (&qk_tap_dance_state);
     } else {
@@ -77,8 +76,11 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
   default:
     if (qk_tap_dance_state.keycode) {
       // if we are here, the tap dance was interrupted by a different key
-      process_tap_dance_action_on_each_tap (qk_tap_dance_state.keycode);
-      process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
+      idx = qk_tap_dance_state.keycode - QK_TAP_DANCE;
+      action = tap_dance_actions[idx];
+
+      process_tap_dance_action_on_each_tap (action);
+      process_tap_dance_action_on_dance_finished (action);
       reset_tap_dance (&qk_tap_dance_state);
       qk_tap_dance_state.active = false;
     }
@@ -91,7 +93,10 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
 void matrix_scan_tap_dance () {
   if (qk_tap_dance_state.active && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
     // if we are here, the tap dance was timed out
-    process_tap_dance_action_on_dance_finished (qk_tap_dance_state.keycode);
+    uint16_t idx = qk_tap_dance_state.keycode - QK_TAP_DANCE;
+    qk_tap_dance_action_t action = tap_dance_actions[idx];
+
+    process_tap_dance_action_on_dance_finished (action);
     reset_tap_dance (&qk_tap_dance_state);
   }
 }
@@ -104,9 +109,7 @@ void reset_tap_dance (qk_tap_dance_state_t *state) {
     return;
 
   action = tap_dance_actions[idx];
-  if (action.fn.on_reset) {
-    action.fn.on_reset(state, action.user_data);
-  }
+  process_tap_dance_action_on_reset (action);
 
   state->keycode = 0;
   state->count = 0;
-- 
cgit v1.2.3


From b21e8b97acb722bfa7b85831cfd010716ed77962 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 27 Jul 2016 08:42:09 +0200
Subject: tap-dance: Add some debugging support

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index d240dc2e66..5429e34383 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -1,6 +1,18 @@
 #include "quantum.h"
 
 static qk_tap_dance_state_t qk_tap_dance_state;
+bool td_debug_enable = false;
+
+#if CONSOLE_ENABLE
+#define td_debug(s) if (td_debug_enable) \
+    { \
+      xprintf ("D:tap_dance:%s:%s = { keycode = %d, count = %d, active = %d, pressed = %d }\n", __FUNCTION__, s, \
+               qk_tap_dance_state.keycode, qk_tap_dance_state.count, \
+               qk_tap_dance_state.active, qk_tap_dance_state.pressed);  \
+    }
+#else
+#define td_debug(s)
+#endif
 
 void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data) {
   qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
@@ -33,16 +45,19 @@ static inline void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
 
 static inline void process_tap_dance_action_on_each_tap (qk_tap_dance_action_t action)
 {
+  td_debug("trigger");
   _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_each_tap);
 }
 
 static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_action_t action)
 {
+  td_debug("trigger");
   _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_dance_finished);
 }
 
 static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t action)
 {
+  td_debug("trigger")
   _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_reset);
 }
 
-- 
cgit v1.2.3


From d78058cc75a9b05a6885991506d5f807ebb2a9f9 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 17 Aug 2016 10:28:08 +0200
Subject: tap-dance: Include action_tapping.h for TAPPING_TERM

Include `action_tapping.h`, so the keymap does not have to define a
`TAPPING_TERM` for us, and we can use the default.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 5429e34383..bab5c4dbd8 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -1,4 +1,5 @@
 #include "quantum.h"
+#include "action_tapping.h"
 
 static qk_tap_dance_state_t qk_tap_dance_state;
 bool td_debug_enable = false;
-- 
cgit v1.2.3


From 29f64d7a93d941167c6c6e95f893ab84586b2205 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 17 Aug 2016 13:04:50 +0200
Subject: tap-dance: Major rework, to make it more reliable

This reworks how the tap-dance feature works: instead of one global
state, we have a state for each tap-dance key, so we can cancel them
when another tap-dance key is in flight. This fixes #527.

Since we have a state for each key, we can avoid situation where a keyup
would mess with our global state. This fixes #563.

And while here, we also make sure to fire events only once, and this
fixes #574.

There is one breaking change, though: tap-dance debugging support was
removed, because dumping the whole state would increase the firmware
size too much. Any keymap that made use of this, will have to be
updated (but there's no such keymap in the repo).

Also, there's a nice trick used in this rework: we need to iterate
through tap_dance_actions in a few places, to check for timeouts, and so
on. For this, we'd need to know the size of the array. We can't discover
that at compile-time, because tap-dance gets compiled separately. We'd
like to avoid having to terminate the list with a sentinel value,
because that would require updates to all keymaps that use the feature.
So, we keep track of the highest tap-dance code seen so far, and iterate
until that index.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 121 ++++++++++++++--------------
 1 file changed, 61 insertions(+), 60 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index bab5c4dbd8..e152f23508 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -1,19 +1,8 @@
 #include "quantum.h"
 #include "action_tapping.h"
 
-static qk_tap_dance_state_t qk_tap_dance_state;
-bool td_debug_enable = false;
-
-#if CONSOLE_ENABLE
-#define td_debug(s) if (td_debug_enable) \
-    { \
-      xprintf ("D:tap_dance:%s:%s = { keycode = %d, count = %d, active = %d, pressed = %d }\n", __FUNCTION__, s, \
-               qk_tap_dance_state.keycode, qk_tap_dance_state.count, \
-               qk_tap_dance_state.active, qk_tap_dance_state.pressed);  \
-    }
-#else
-#define td_debug(s)
-#endif
+static uint16_t last_td;
+static int8_t highest_td = -1;
 
 void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data) {
   qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
@@ -36,98 +25,110 @@ void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data) {
 }
 
 static inline void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
-                                          void *user_data,
-                                          qk_tap_dance_user_fn_t fn)
+                                                 void *user_data,
+                                                 qk_tap_dance_user_fn_t fn)
 {
   if (fn) {
     fn(state, user_data);
   }
 }
 
-static inline void process_tap_dance_action_on_each_tap (qk_tap_dance_action_t action)
+static inline void process_tap_dance_action_on_each_tap (qk_tap_dance_action_t *action)
 {
-  td_debug("trigger");
-  _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_each_tap);
+  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_each_tap);
 }
 
-static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_action_t action)
+static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_action_t *action)
 {
-  td_debug("trigger");
-  _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_dance_finished);
+  if (action->state.finished)
+    return;
+  action->state.finished = true;
+  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_dance_finished);
 }
 
-static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t action)
+static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t *action)
 {
-  td_debug("trigger")
-  _process_tap_dance_action_fn (&qk_tap_dance_state, action.user_data, action.fn.on_reset);
+  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_reset);
 }
 
 bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
-  bool r = true;
   uint16_t idx = keycode - QK_TAP_DANCE;
-  qk_tap_dance_action_t action;
+  qk_tap_dance_action_t *action;
+
+  if (last_td && last_td != keycode) {
+    (&tap_dance_actions[last_td - QK_TAP_DANCE])->state.interrupted = true;
+  }
 
   switch(keycode) {
   case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
-    action = tap_dance_actions[idx];
-
-    process_tap_dance_action_on_each_tap (action);
-    if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
-      process_tap_dance_action_on_dance_finished (action);
-    } else if (qk_tap_dance_state.active && qk_tap_dance_state.pressed) {
-      reset_tap_dance (&qk_tap_dance_state);
-    } else {
-      r = false;
-    }
+    if ((int16_t)idx > highest_td)
+      highest_td = idx;
+    action = &tap_dance_actions[idx];
 
-    qk_tap_dance_state.active = true;
-    qk_tap_dance_state.pressed = record->event.pressed;
+    action->state.keycode = keycode;
+    action->state.pressed = record->event.pressed;
     if (record->event.pressed) {
-      qk_tap_dance_state.keycode = keycode;
-      qk_tap_dance_state.timer = timer_read ();
-      qk_tap_dance_state.count++;
+      action->state.count++;
+      action->state.timer = timer_read();
+
+      if (last_td && last_td != keycode) {
+        qk_tap_dance_action_t *paction = &tap_dance_actions[last_td - QK_TAP_DANCE];
+        paction->state.interrupted = true;
+        process_tap_dance_action_on_dance_finished (paction);
+        reset_tap_dance (&paction->state);
+      }
     }
+    last_td = keycode;
+
     break;
 
   default:
-    if (qk_tap_dance_state.keycode) {
-      // if we are here, the tap dance was interrupted by a different key
-      idx = qk_tap_dance_state.keycode - QK_TAP_DANCE;
-      action = tap_dance_actions[idx];
+    if (!record->event.pressed)
+      return true;
+
+    if (highest_td == -1)
+      return true;
 
-      process_tap_dance_action_on_each_tap (action);
+    for (int i = 0; i <= highest_td; i++) {
+      action = &tap_dance_actions[i];
+      if (action->state.count == 0)
+        continue;
+      action->state.interrupted = true;
       process_tap_dance_action_on_dance_finished (action);
-      reset_tap_dance (&qk_tap_dance_state);
-      qk_tap_dance_state.active = false;
+      reset_tap_dance (&action->state);
     }
     break;
   }
 
-  return r;
+  return true;
 }
 
 void matrix_scan_tap_dance () {
-  if (qk_tap_dance_state.active && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
-    // if we are here, the tap dance was timed out
-    uint16_t idx = qk_tap_dance_state.keycode - QK_TAP_DANCE;
-    qk_tap_dance_action_t action = tap_dance_actions[idx];
+  if (highest_td == -1)
+    return;
+
+  for (int i = 0; i <= highest_td; i++) {
+    qk_tap_dance_action_t *action = &tap_dance_actions[i];
 
-    process_tap_dance_action_on_dance_finished (action);
-    reset_tap_dance (&qk_tap_dance_state);
+    if (action->state.count && timer_elapsed (action->state.timer) > TAPPING_TERM) {
+      process_tap_dance_action_on_dance_finished (action);
+      reset_tap_dance (&action->state);
+    }
   }
 }
 
 void reset_tap_dance (qk_tap_dance_state_t *state) {
-  uint16_t idx = state->keycode - QK_TAP_DANCE;
-  qk_tap_dance_action_t action;
+  qk_tap_dance_action_t *action;
 
   if (state->pressed)
     return;
 
-  action = tap_dance_actions[idx];
+  action = &tap_dance_actions[state->keycode - QK_TAP_DANCE];
+
   process_tap_dance_action_on_reset (action);
 
-  state->keycode = 0;
   state->count = 0;
-  state->active = false;
+  state->interrupted = false;
+  state->finished = false;
+  last_td = 0;
 }
-- 
cgit v1.2.3


From 0d28787c5cf2173d12f57b397515f91cffaa820a Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Thu, 18 Aug 2016 11:29:53 +0200
Subject: Add a register/unregister_code16 pair of functions

These functions register not only the 8bit keycode, but the modifiers
too. It doesn't handle the full range of the upper 8bits, just the mods,
but that's a good start.

Changed the tap-dance pair functions to use these, so one can do:

  `ACTION_TAP_DANCE_DOUBLE (KC_COLN, KC_SCLN)`

...and that will do the right thing.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index e152f23508..07de3ecb8f 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -8,9 +8,9 @@ void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data) {
   qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
 
   if (state->count == 1) {
-    register_code (pair->kc1);
+    register_code16 (pair->kc1);
   } else if (state->count == 2) {
-    register_code (pair->kc2);
+    register_code16 (pair->kc2);
   }
 }
 
@@ -18,9 +18,9 @@ void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data) {
   qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
 
   if (state->count == 1) {
-    unregister_code (pair->kc1);
+    unregister_code16 (pair->kc1);
   } else if (state->count == 2) {
-    unregister_code (pair->kc2);
+    unregister_code16 (pair->kc2);
   }
 }
 
-- 
cgit v1.2.3


From acda2b793f69c6e0e9b9667e9ebe8a0325eb5ecd Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Thu, 1 Sep 2016 08:32:47 +0200
Subject: tap-dance: Do not start a sequence on keyup

There was an odd case, which confused the hell out of tap-dance: suppose
you had a number of tap-dance keys, on a layer, and as part of the
tap-dance, you turned that layer off - or had it on one-shot to begin
with. In this case, the keydown event would trigger the tap-dance key,
but the keyup would not. This had two funky consequences:

- tap-dance did not correctly register that the dance has ended.
- pressing any other tap-dance key would interrupt the previous
  tap-dance, and potentially input unwanted characters.

To fix this, we simply do not start a tap-dance sequence on keyup, only
when it is pressed. This way the previous sequence has enough time to
time-out and finish properly, and we don't get confused.

This fixes algernon/ergodox-layout#107.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_tap_dance.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'quantum/process_keycode/process_tap_dance.c')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 07de3ecb8f..79ade4d000 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -65,9 +65,9 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
       highest_td = idx;
     action = &tap_dance_actions[idx];
 
-    action->state.keycode = keycode;
     action->state.pressed = record->event.pressed;
     if (record->event.pressed) {
+      action->state.keycode = keycode;
       action->state.count++;
       action->state.timer = timer_read();
 
@@ -77,8 +77,9 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
         process_tap_dance_action_on_dance_finished (paction);
         reset_tap_dance (&paction->state);
       }
+
+      last_td = keycode;
     }
-    last_td = keycode;
 
     break;
 
-- 
cgit v1.2.3