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 000000000..9b172e1b6
--- /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-70-g09d2


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 9b172e1b6..186889bc2 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-70-g09d2


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 ++++++++++++++++++++++++++++-
 quantum/process_keycode/process_tap_dance.h | 28 ++++++++++++++++++----
 2 files changed, 59 insertions(+), 5 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 186889bc2..40fba2a6a 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;
 }
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index b9d7c7fcf..bf925df0f 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -22,6 +22,7 @@ typedef enum
 } qk_tap_dance_type_t;
 
 typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state);
+typedef void (*qk_tap_dance_user_fn_reset_t) (void);
 
 typedef struct
 {
@@ -31,18 +32,37 @@ typedef struct
       uint16_t kc1;
       uint16_t kc2;
     } pair;
-    qk_tap_dance_user_fn_t fn;
+    struct {
+      qk_tap_dance_user_fn_t regular;
+      qk_tap_dance_user_fn_t anyway;
+      qk_tap_dance_user_fn_reset_t reset;
+    } fn;
   };
 } qk_tap_dance_action_t;
 
 #define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
-    .type = QK_TAP_DANCE_TYPE_PAIR,         \
-    .pair = { kc1, kc2 }                    \
+    .type = QK_TAP_DANCE_TYPE_PAIR, \
+    .pair = { kc1, kc2 }            \
   }
 
 #define ACTION_TAP_DANCE_FN(user_fn) { \
     .type = QK_TAP_DANCE_TYPE_FN, \
-    .fn = user_fn                 \
+    .fn = { user_fn, NULL, NULL } \
+  }
+
+#define ACTION_TAP_DANCE_FN_ANYWAY(user_fn, user_fn_anyway) { \
+    .type = QK_TAP_DANCE_TYPE_FN,           \
+    .fn = { user_fn, user_fn_anyway, NULL } \
+  }
+
+#define ACTION_TAP_DANCE_FN_RESET(user_fn, user_fn_reset) { \
+    .type = QK_TAP_DANCE_TYPE_FN,          \
+    .fn = { user_fn, NULL, user_fn_reset } \
+  }
+
+#define ACTION_TAP_DANCE_FN_ANYWAY_RESET(user_fn, user_fn_anyway, user_fn_reset) { \
+    .type = QK_TAP_DANCE_TYPE_FN,                    \
+    .fn = { user_fn, user_fn_anyway, user_fn_reset } \
   }
 
 extern const qk_tap_dance_action_t tap_dance_actions[];
-- 
cgit v1.2.3-70-g09d2


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 ++++++++++++++---------------
 quantum/process_keycode/process_tap_dance.h | 27 ++++++++----------------
 2 files changed, 23 insertions(+), 36 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 40fba2a6a..93b326b5f 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;
 
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index bf925df0f..7b820584a 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -22,7 +22,6 @@ typedef enum
 } qk_tap_dance_type_t;
 
 typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state);
-typedef void (*qk_tap_dance_user_fn_reset_t) (void);
 
 typedef struct
 {
@@ -33,9 +32,9 @@ typedef struct
       uint16_t kc2;
     } pair;
     struct {
-      qk_tap_dance_user_fn_t regular;
-      qk_tap_dance_user_fn_t anyway;
-      qk_tap_dance_user_fn_reset_t reset;
+      qk_tap_dance_user_fn_t on_each_tap;
+      qk_tap_dance_user_fn_t on_dance_finished;
+      qk_tap_dance_user_fn_t on_reset;
     } fn;
   };
 } qk_tap_dance_action_t;
@@ -45,24 +44,14 @@ typedef struct
     .pair = { kc1, kc2 }            \
   }
 
-#define ACTION_TAP_DANCE_FN(user_fn) { \
+#define ACTION_TAP_DANCE_FN(user_fn) {  \
     .type = QK_TAP_DANCE_TYPE_FN, \
-    .fn = { user_fn, NULL, NULL } \
+    .fn = { NULL, user_fn, NULL } \
   }
 
-#define ACTION_TAP_DANCE_FN_ANYWAY(user_fn, user_fn_anyway) { \
-    .type = QK_TAP_DANCE_TYPE_FN,           \
-    .fn = { user_fn, user_fn_anyway, NULL } \
-  }
-
-#define ACTION_TAP_DANCE_FN_RESET(user_fn, user_fn_reset) { \
-    .type = QK_TAP_DANCE_TYPE_FN,          \
-    .fn = { user_fn, NULL, user_fn_reset } \
-  }
-
-#define ACTION_TAP_DANCE_FN_ANYWAY_RESET(user_fn, user_fn_anyway, user_fn_reset) { \
-    .type = QK_TAP_DANCE_TYPE_FN,                    \
-    .fn = { user_fn, user_fn_anyway, user_fn_reset } \
+#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_reset) { \
+    .type = QK_TAP_DANCE_TYPE_FN,                                              \
+    .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_reset } \
   }
 
 extern const qk_tap_dance_action_t tap_dance_actions[];
-- 
cgit v1.2.3-70-g09d2


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 93b326b5f..bab6bb81b 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-70-g09d2


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 bab6bb81b..58192413f 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-70-g09d2


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 58192413f..b9b836df2 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-70-g09d2


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 ++++++++++-
 quantum/process_keycode/process_tap_dance.h |  2 ++
 2 files changed, 12 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 b9b836df2..097440405 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;
 }
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index 7b820584a..d457db9b3 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -11,6 +11,8 @@ typedef struct
   uint8_t count;
   uint16_t keycode;
   uint16_t timer;
+  bool active:1;
+  bool pressed:1;
 } qk_tap_dance_state_t;
 
 #define TD(n) (QK_TAP_DANCE + n)
-- 
cgit v1.2.3-70-g09d2


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 ++++++++++-------------------
 quantum/process_keycode/process_tap_dance.h | 41 +++++++++----------
 2 files changed, 38 insertions(+), 64 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 097440405..94b6af130 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;
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index d457db9b3..e2c74efe9 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -17,42 +17,34 @@ typedef struct
 
 #define TD(n) (QK_TAP_DANCE + n)
 
-typedef enum
-{
-  QK_TAP_DANCE_TYPE_PAIR,
-  QK_TAP_DANCE_TYPE_FN,
-} qk_tap_dance_type_t;
-
-typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state);
+typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state, void *user_data);
 
 typedef struct
 {
-  qk_tap_dance_type_t type;
-  union {
-    struct {
-      uint16_t kc1;
-      uint16_t kc2;
-    } pair;
-    struct {
-      qk_tap_dance_user_fn_t on_each_tap;
-      qk_tap_dance_user_fn_t on_dance_finished;
-      qk_tap_dance_user_fn_t on_reset;
-    } fn;
-  };
+  struct {
+    qk_tap_dance_user_fn_t on_each_tap;
+    qk_tap_dance_user_fn_t on_dance_finished;
+    qk_tap_dance_user_fn_t on_reset;
+  } fn;
+  void *user_data;
 } qk_tap_dance_action_t;
 
+typedef struct
+{
+  uint16_t kc1;
+  uint16_t kc2;
+} qk_tap_dance_pair_t;
+
 #define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
-    .type = QK_TAP_DANCE_TYPE_PAIR, \
-    .pair = { kc1, kc2 }            \
+    .fn = { NULL, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset }, \
+    .user_data = (void *)&((qk_tap_dance_pair_t) { kc1, kc2 })  \
   }
 
 #define ACTION_TAP_DANCE_FN(user_fn) {  \
-    .type = QK_TAP_DANCE_TYPE_FN, \
     .fn = { NULL, user_fn, NULL } \
   }
 
 #define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_reset) { \
-    .type = QK_TAP_DANCE_TYPE_FN,                                              \
     .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_reset } \
   }
 
@@ -64,6 +56,9 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record);
 void matrix_scan_tap_dance (void);
 void reset_tap_dance (qk_tap_dance_state_t *state);
 
+void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data);
+void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data);
+
 #else
 
 #define TD(n) KC_NO
-- 
cgit v1.2.3-70-g09d2


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 94b6af130..d240dc2e6 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-70-g09d2


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 +++++++++++++++
 quantum/process_keycode/process_tap_dance.h |  1 +
 2 files changed, 16 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 d240dc2e6..5429e3438 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);
 }
 
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index e2c74efe9..6a1258067 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -49,6 +49,7 @@ typedef struct
   }
 
 extern const qk_tap_dance_action_t tap_dance_actions[];
+extern bool td_debug_enable;
 
 /* To be used internally */
 
-- 
cgit v1.2.3-70-g09d2


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 5429e3438..bab5c4dbd 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-70-g09d2


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>
---
 keyboards/ergodox/keymaps/algernon/keymap.c |   2 +-
 keyboards/preonic/keymaps/kinesis/keymap.c  |   2 +-
 quantum/process_keycode/process_tap_dance.c | 121 ++++++++++++++--------------
 quantum/process_keycode/process_tap_dance.h |   9 ++-
 readme.md                                   |   4 +-
 5 files changed, 70 insertions(+), 68 deletions(-)

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

diff --git a/keyboards/ergodox/keymaps/algernon/keymap.c b/keyboards/ergodox/keymaps/algernon/keymap.c
index 244bfb51f..144030e2e 100644
--- a/keyboards/ergodox/keymaps/algernon/keymap.c
+++ b/keyboards/ergodox/keymaps/algernon/keymap.c
@@ -853,7 +853,7 @@ void ang_tap_dance_ta_reset (qk_tap_dance_state_t *state, void *user_data) {
   td_ta->finished_once = false;
 }
 
-const qk_tap_dance_action_t tap_dance_actions[] = {
+qk_tap_dance_action_t tap_dance_actions[] = {
    [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, ang_tap_dance_cln_finished, ang_tap_dance_cln_reset)
   ,[CT_MNS] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, ang_tap_dance_mns_finished, ang_tap_dance_mns_reset)
   ,[CT_TA]  = {
diff --git a/keyboards/preonic/keymaps/kinesis/keymap.c b/keyboards/preonic/keymaps/kinesis/keymap.c
index 1cd6eb993..9691be91d 100644
--- a/keyboards/preonic/keymaps/kinesis/keymap.c
+++ b/keyboards/preonic/keymaps/kinesis/keymap.c
@@ -123,7 +123,7 @@ void music_scale_user(void)
 }
 
 
-const qk_tap_dance_action_t tap_dance_actions[] = {
+qk_tap_dance_action_t tap_dance_actions[] = {
   //Tap once for equal, twice for hyper + X (alfred lock)
   [TD_EQ_LOCK] = ACTION_TAP_DANCE_DOUBLE(KC_EQL,  HYPR(KC_X)),
   //Tap once for minus, twice for time.heals.nothing
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index bab5c4dbd..e152f2350 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;
 }
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index 6a1258067..d7b857bdc 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -11,8 +11,9 @@ typedef struct
   uint8_t count;
   uint16_t keycode;
   uint16_t timer;
-  bool active:1;
-  bool pressed:1;
+  bool interrupted;
+  bool pressed;
+  bool finished;
 } qk_tap_dance_state_t;
 
 #define TD(n) (QK_TAP_DANCE + n)
@@ -26,6 +27,7 @@ typedef struct
     qk_tap_dance_user_fn_t on_dance_finished;
     qk_tap_dance_user_fn_t on_reset;
   } fn;
+  qk_tap_dance_state_t state;
   void *user_data;
 } qk_tap_dance_action_t;
 
@@ -48,8 +50,7 @@ typedef struct
     .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_reset } \
   }
 
-extern const qk_tap_dance_action_t tap_dance_actions[];
-extern bool td_debug_enable;
+extern qk_tap_dance_action_t tap_dance_actions[];
 
 /* To be used internally */
 
diff --git a/readme.md b/readme.md
index e2221e749..8c07a5d1f 100644
--- a/readme.md
+++ b/readme.md
@@ -431,7 +431,7 @@ enum {
 };
 
 //Tap Dance Definitions
-const qk_tap_dance_action_t tap_dance_actions[] = {
+qk_tap_dance_action_t tap_dance_actions[] = {
   //Tap once for Esc, twice for Caps Lock
   [TD_ESC_CAPS]  = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS)
 // Other declarations would go here, separated by commas, if you have them
@@ -517,7 +517,7 @@ void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) {
   ergodox_right_led_3_off();
 }
 
-const qk_tap_dance_action_t tap_dance_actions[] = {
+qk_tap_dance_action_t tap_dance_actions[] = {
   [CT_SE]  = ACTION_TAP_DANCE_DOUBLE (KC_SPC, KC_ENT)
  ,[CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
  ,[CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
-- 
cgit v1.2.3-70-g09d2


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 +++----
 quantum/quantum.c                           | 37 +++++++++++++++++++++++++++++
 quantum/quantum.h                           |  3 +++
 3 files changed, 44 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 e152f2350..07de3ecb8 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);
   }
 }
 
diff --git a/quantum/quantum.c b/quantum/quantum.c
index cb1ba04ff..e3a20f43e 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -1,5 +1,42 @@
 #include "quantum.h"
 
+static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
+  switch (code) {
+  case QK_MODS ... QK_MODS_MAX:
+    break;
+  default:
+    return;
+  }
+
+  if (code & QK_LCTL)
+    f(KC_LCTL);
+  if (code & QK_LSFT)
+    f(KC_LSFT);
+  if (code & QK_LALT)
+    f(KC_LALT);
+  if (code & QK_LGUI)
+    f(KC_LGUI);
+
+  if (code & QK_RCTL)
+    f(KC_RCTL);
+  if (code & QK_RSFT)
+    f(KC_RSFT);
+  if (code & QK_RALT)
+    f(KC_RALT);
+  if (code & QK_RGUI)
+    f(KC_RGUI);
+}
+
+void register_code16 (uint16_t code) {
+  do_code16 (code, register_code);
+  register_code (code);
+}
+
+void unregister_code16 (uint16_t code) {
+  unregister_code (code);
+  do_code16 (code, unregister_code);
+}
+
 __attribute__ ((weak))
 bool process_action_kb(keyrecord_t *record) {
   return true;
diff --git a/quantum/quantum.h b/quantum/quantum.h
index 6e3fbcc79..0c6046649 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -83,6 +83,9 @@ void reset_keyboard(void);
 void startup_user(void);
 void shutdown_user(void);
 
+void register_code16 (uint16_t code);
+void unregister_code16 (uint16_t code);
+
 #ifdef BACKLIGHT_ENABLE
 void backlight_init_ports(void);
 
-- 
cgit v1.2.3-70-g09d2


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 07de3ecb8..79ade4d00 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-70-g09d2


From e1f131db8e59c6ed3471906d3a62457d593f51af Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Wed, 21 Sep 2016 10:11:42 +0200
Subject: restore each_tap callback

---
 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 79ade4d00..6ae362c4c 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) {
       action->state.keycode = keycode;
       action->state.count++;
       action->state.timer = timer_read();
+      process_tap_dance_action_on_each_tap (action);
 
       if (last_td && last_td != keycode) {
         qk_tap_dance_action_t *paction = &tap_dance_actions[last_td - QK_TAP_DANCE];
-- 
cgit v1.2.3-70-g09d2