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')

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


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')

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


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')

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


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')

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


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')

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


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')

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


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')

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


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')

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


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')

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


From 3ea738e450e9326b0d3ee4192da881cffb4c13c1 Mon Sep 17 00:00:00 2001
From: Robert Dale <robdale@gmail.com>
Date: Sun, 24 Jul 2016 10:00:39 -0400
Subject: ensure there's a recording to play before playing; also enables the
 LGUI button to play a tone

---
 quantum/process_keycode/process_music.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
index c8f3ddb90..2d52e47a7 100644
--- a/quantum/process_keycode/process_music.c
+++ b/quantum/process_keycode/process_music.c
@@ -6,6 +6,7 @@ int offset = 7;
 
 // music sequencer
 static bool music_sequence_recording = false;
+static bool music_sequence_recorded = false;
 static bool music_sequence_playing = false;
 static float music_sequence[16] = {0};
 static uint8_t music_sequence_count = 0;
@@ -77,6 +78,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
       if (keycode == KC_LCTL && record->event.pressed) { // Start recording
         stop_all_notes();
         music_sequence_recording = true;
+        music_sequence_recorded = false;
         music_sequence_playing = false;
         music_sequence_count = 0;
         return false;
@@ -84,12 +86,15 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
 
       if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
         stop_all_notes();
+        if (music_sequence_recording) { // was recording
+          music_sequence_recorded = true;
+        }
         music_sequence_recording = false;
         music_sequence_playing = false;
         return false;
       }
 
-      if (keycode == KC_LGUI && record->event.pressed) { // Start playing
+      if (keycode == KC_LGUI && record->event.pressed && music_sequence_recorded) { // Start playing
         stop_all_notes();
         music_sequence_recording = false;
         music_sequence_playing = true;
-- 
cgit v1.2.3


From 8b94e26d7c3b30cc57d710a11e5651d15e8e3b20 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Sun, 24 Jul 2016 22:07:43 -0400
Subject: Fixes midi functionality

---
 quantum/process_keycode/process_midi.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c
index d6ab9c626..8784e64f3 100644
--- a/quantum/process_keycode/process_midi.c
+++ b/quantum/process_keycode/process_midi.c
@@ -1,8 +1,8 @@
 #include "process_midi.h"
 
 bool midi_activated = false;
-uint8_t starting_note = 0x0C;
-int offset = 7;
+uint8_t midi_starting_note = 0x0C;
+int midi_offset = 7;
 
 bool process_midi(uint16_t keycode, keyrecord_t *record) {
     if (keycode == MI_ON && record->event.pressed) {
@@ -20,42 +20,42 @@ bool process_midi(uint16_t keycode, keyrecord_t *record) {
     if (midi_activated) {
       if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
           if (record->event.pressed) {
-              starting_note++; // Change key
+              midi_starting_note++; // Change key
               midi_send_cc(&midi_device, 0, 0x7B, 0);
           }
           return false;
       }
       if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
           if (record->event.pressed) {
-              starting_note--; // Change key
+              midi_starting_note--; // Change key
               midi_send_cc(&midi_device, 0, 0x7B, 0);
           }
           return false;
       }
       if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
-          offset++; // Change scale
+          midi_offset++; // Change scale
           midi_send_cc(&midi_device, 0, 0x7B, 0);
           return false;
       }
       if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
-          offset--; // Change scale
+          midi_offset--; // Change scale
           midi_send_cc(&midi_device, 0, 0x7B, 0);
           return false;
       }
       // basic
-      // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
+      // uint8_t note = (midi_starting_note + SCALE[record->event.key.col + midi_offset])+12*(MATRIX_ROWS - record->event.key.row);
       // advanced
-      // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
+      // uint8_t note = (midi_starting_note + record->event.key.col + midi_offset)+12*(MATRIX_ROWS - record->event.key.row);
       // guitar
-      uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
+      uint8_t note = (midi_starting_note + record->event.key.col + midi_offset)+5*(MATRIX_ROWS - record->event.key.row);
       // violin
-      // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
+      // uint8_t note = (midi_starting_note + record->event.key.col + midi_offset)+7*(MATRIX_ROWS - record->event.key.row);
 
       if (record->event.pressed) {
-        // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+        // midi_send_noteon(&midi_device, record->event.key.row, midi_starting_note + SCALE[record->event.key.col], 127);
         midi_send_noteon(&midi_device, 0, note, 127);
       } else {
-        // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+        // midi_send_noteoff(&midi_device, record->event.key.row, midi_starting_note + SCALE[record->event.key.col], 127);
         midi_send_noteoff(&midi_device, 0, note, 127);
       }
 
-- 
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 +++++++++++++++
 quantum/process_keycode/process_tap_dance.h |  1 +
 2 files changed, 16 insertions(+)

(limited to 'quantum/process_keycode')

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


From 8bdf745909bc2581491acce11225f56a85bc8f24 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sat, 13 Aug 2016 10:33:47 +0200
Subject: process_unicode: Fix set_unicode_input_mode()

In the header, this was defined as `set_unicode_input_mode`, but the
implementation had `set_unicode_mode` for a name. Changed the
implementation to match the header.

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

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index ad5d7f86b..3fcac15ce 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -13,7 +13,7 @@ uint16_t hex_to_keycode(uint8_t hex)
   }
 }
 
-void set_unicode_mode(uint8_t os_target)
+void set_unicode_input_mode(uint8_t os_target)
 {
   input_mode = os_target;
 }
-- 
cgit v1.2.3


From 63e5782d2cdf0ee282ad434c773463d9da9db6b3 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sat, 13 Aug 2016 10:43:22 +0200
Subject: process_unicode: Small refactor & linux fix

This moves the unicode input start / end sequences into their own
functions, so keymaps and other functionality can build on it too.

At the same time, it changes how the Linux variant works, to match
reality: CTRL+SHIFT must be unregistered too, and we close the thing
with a Space instead.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 76 ++++++++++++++++++-------------
 quantum/process_keycode/process_unicode.h |  3 ++
 2 files changed, 48 insertions(+), 31 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 3fcac15ce..55e47f179 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -18,40 +18,54 @@ void set_unicode_input_mode(uint8_t os_target)
   input_mode = os_target;
 }
 
+void unicode_input_start (void) {
+  switch(input_mode) {
+  case UC_OSX:
+    register_code(KC_LALT);
+    break;
+  case UC_LNX:
+    register_code(KC_LCTL);
+    register_code(KC_LSFT);
+    register_code(KC_U);
+    unregister_code(KC_U);
+    unregister_code(KC_LSFT);
+    unregister_code(KC_LCTL);
+    break;
+  case UC_WIN:
+    register_code(KC_LALT);
+    register_code(KC_PPLS);
+    unregister_code(KC_PPLS);
+    break;
+  }
+}
+
+void unicode_input_finish (void) {
+  switch(input_mode) {
+  case UC_OSX:
+  case UC_WIN:
+    unregister_code(KC_LALT);
+    break;
+  case UC_LNX:
+    register_code(KC_SPC);
+    unregister_code(KC_SPC);
+    break;
+  }
+}
+
+void register_hex(uint16_t hex) {
+  for(int i = 3; i >= 0; i--) {
+    uint8_t digit = ((hex >> (i*4)) & 0xF);
+    register_code(hex_to_keycode(digit));
+    unregister_code(hex_to_keycode(digit));
+  }
+}
+
 bool process_unicode(uint16_t keycode, keyrecord_t *record) {
   if (keycode > QK_UNICODE && record->event.pressed) {
     uint16_t unicode = keycode & 0x7FFF;
-    switch(input_mode) {
-      case UC_OSX:
-        register_code(KC_LALT);
-        break;
-      case UC_LNX:
-        register_code(KC_LCTL);
-        register_code(KC_LSFT);
-        register_code(KC_U);
-        unregister_code(KC_U);
-        break;
-      case UC_WIN:
-        register_code(KC_LALT);
-        register_code(KC_PPLS);
-        unregister_code(KC_PPLS);
-        break;
-    }
-    for(int i = 3; i >= 0; i--) {
-        uint8_t digit = ((unicode >> (i*4)) & 0xF);
-        register_code(hex_to_keycode(digit));
-        unregister_code(hex_to_keycode(digit));
-    }
-    switch(input_mode) {
-      case UC_OSX:
-      case UC_WIN:
-        unregister_code(KC_LALT);
-        break;
-      case UC_LNX:
-        unregister_code(KC_LCTL);
-        unregister_code(KC_LSFT);
-        break;
-    }
+    unicode_input_start();
+    register_hex(unicode);
+    unicode_input_finish();
   }
   return true;
 }
\ No newline at end of file
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index ca17f8f66..f719a1226 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -9,6 +9,9 @@
 #define UC_BSD 3
 
 void set_unicode_input_mode(uint8_t os_target);
+void unicode_input_start(void);
+void unicode_input_finish(void);
+void register_hex(uint16_t hex);
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
-- 
cgit v1.2.3


From fa06a163607e8c6c4bd0968c2de96a9a298b777c Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sat, 13 Aug 2016 10:46:38 +0200
Subject: process_unicode: Add a way to enter unicode symbols by name

The purpose of this change is to allow keymaps to specify a dictionary
of unicode symbol name to code mappings, and let the person at the
keyboard enter unicode symbols by name.

This is done by having a way to trigger unicode symbol input mode, when
all keys are cached until Esc, Enter or Space are pressed. Once that
happens, we try to look up the symbol from our lookup table. If found,
we erase back, and type the unicode magic in to get that symbol. If not
found, we still erase back, start unicode input mode, and replay what
the user typed in.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 93 ++++++++++++++++++++++++++++++-
 quantum/process_keycode/process_unicode.h | 29 +++++++++-
 2 files changed, 120 insertions(+), 2 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 55e47f179..8a6509300 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -68,4 +68,95 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
     unicode_input_finish();
   }
   return true;
-}
\ No newline at end of file
+}
+
+#ifdef UCIS_ENABLE
+void qk_ucis_start(void) {
+  qk_ucis_state.count = 0;
+  qk_ucis_state.in_progress = true;
+
+  unicode_input_start();
+  register_hex(0x2328);
+  unicode_input_finish();
+}
+
+static bool is_uni_seq(char *seq) {
+  uint8_t i;
+
+  for (i = 0; seq[i]; i++) {
+    uint16_t code;
+    if (('1' <= seq[i]) && (seq[i] <= '0'))
+      code = seq[i] - '1' + KC_1;
+    else
+      code = seq[i] - 'a' + KC_A;
+
+    if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
+      return false;
+  }
+
+  return (qk_ucis_state.codes[i] == KC_ENT ||
+          qk_ucis_state.codes[i] == KC_SPC);
+}
+
+__attribute__((weak))
+void qk_ucis_symbol_fallback (void) {
+  for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
+    uint8_t code = qk_ucis_state.codes[i];
+    register_code(code);
+    unregister_code(code);
+  }
+}
+
+bool process_record_ucis (uint16_t keycode, keyrecord_t *record) {
+  uint8_t i;
+
+  if (!qk_ucis_state.in_progress || !record->event.pressed)
+    return true;
+
+  qk_ucis_state.codes[qk_ucis_state.count] = keycode;
+  qk_ucis_state.count++;
+
+  if (keycode == KC_BSPC) {
+    if (qk_ucis_state.count >= 2) {
+      qk_ucis_state.count -= 2;
+      return true;
+    } else {
+      qk_ucis_state.count--;
+      return false;
+    }
+  }
+
+  if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
+    bool symbol_found = false;
+
+    for (i = qk_ucis_state.count; i > 0; i--) {
+      register_code (KC_BSPC);
+      unregister_code (KC_BSPC);
+    }
+
+    if (keycode == KC_ESC) {
+      qk_ucis_state.in_progress = false;
+      return false;
+    }
+
+    unicode_input_start();
+    for (i = 0; ucis_symbol_table[i].symbol; i++) {
+      if (is_uni_seq (ucis_symbol_table[i].symbol)) {
+        symbol_found = true;
+        for (uint8_t j = 0; ucis_symbol_table[i].codes[j]; j++) {
+          register_hex(ucis_symbol_table[i].codes[j]);
+        }
+        break;
+      }
+    }
+    if (!symbol_found) {
+      qk_ucis_symbol_fallback();
+    }
+    unicode_input_finish();
+
+    qk_ucis_state.in_progress = false;
+    return false;
+  }
+  return true;
+}
+#endif
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index f719a1226..372ea2f0d 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -15,6 +15,33 @@ void register_hex(uint16_t hex);
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
+#ifdef UCIS_ENABLE
+#ifndef UCIS_MAX_SYMBOL_LENGTH
+#define UCIS_MAX_SYMBOL_LENGTH 32
+#endif
+
+typedef struct {
+  char *symbol;
+  uint16_t codes[4];
+} qk_ucis_symbol_t;
+
+struct {
+  uint8_t count;
+  uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
+  bool in_progress:1;
+} qk_ucis_state;
+
+#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, {}}}
+#define UCIS_SYM(name, ...) {name, {__VA_ARGS__, 0}}
+
+extern const qk_ucis_symbol_t ucis_symbol_table[];
+
+void qk_ucis_start(void);
+void qk_ucis_symbol_fallback (void);
+bool process_record_ucis (uint16_t keycode, keyrecord_t *record);
+
+#endif
+
 #define UC_BSPC	UC(0x0008)
 
 #define UC_SPC	UC(0x0020)
@@ -122,4 +149,4 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record);
 #define UC_TILD	UC(0x007E)
 #define UC_DEL	UC(0x007F)
 
-#endif
\ No newline at end of file
+#endif
-- 
cgit v1.2.3


From 0b6861827faea747345ea38202d64c8004ab128c Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sat, 13 Aug 2016 11:11:22 +0200
Subject: process_unicode: Handle too long UCIS symbol names

If the symbol name being entered is longer than the max, stop recording
it, and stop processing keycodes apart from the ones that can delete,
finish or cancel the sequence.

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

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 8a6509300..851a96eaa 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -110,7 +110,15 @@ void qk_ucis_symbol_fallback (void) {
 bool process_record_ucis (uint16_t keycode, keyrecord_t *record) {
   uint8_t i;
 
-  if (!qk_ucis_state.in_progress || !record->event.pressed)
+  if (!qk_ucis_state.in_progress)
+    return true;
+
+  if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
+      !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
+    return false;
+  }
+
+  if (!record->event.pressed)
     return true;
 
   qk_ucis_state.codes[qk_ucis_state.count] = keycode;
-- 
cgit v1.2.3


From 857aa5bef6a74f8785a7039feea5286c07bf7067 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sat, 13 Aug 2016 11:14:42 +0200
Subject: process_unicode: Call process_ucis() automatically

If UCIS is enabled, call process_ucis() automatically from
process_record_quantum().

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 2 +-
 quantum/process_keycode/process_unicode.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 851a96eaa..d71434411 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -107,7 +107,7 @@ void qk_ucis_symbol_fallback (void) {
   }
 }
 
-bool process_record_ucis (uint16_t keycode, keyrecord_t *record) {
+bool process_ucis (uint16_t keycode, keyrecord_t *record) {
   uint8_t i;
 
   if (!qk_ucis_state.in_progress)
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 372ea2f0d..c5005897e 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -38,7 +38,7 @@ extern const qk_ucis_symbol_t ucis_symbol_table[];
 
 void qk_ucis_start(void);
 void qk_ucis_symbol_fallback (void);
-bool process_record_ucis (uint16_t keycode, keyrecord_t *record);
+bool process_ucis (uint16_t keycode, keyrecord_t *record);
 
 #endif
 
-- 
cgit v1.2.3


From 234dd276cf03be6fd6961473e9d9c8f35deec682 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sun, 14 Aug 2016 10:37:51 +0200
Subject: process_unicode: Make the startup overridable

Extract out the part of `qk_ucis_start` that inputs the placeholder
symbol, and make it weak, so it can be overridden.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 5 +++++
 quantum/process_keycode/process_unicode.h | 1 +
 2 files changed, 6 insertions(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index d71434411..c474483e7 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -75,6 +75,11 @@ void qk_ucis_start(void) {
   qk_ucis_state.count = 0;
   qk_ucis_state.in_progress = true;
 
+  qk_ucis_start_user();
+}
+
+__attribute__((weak))
+void qk_ucis_start_user(void) {
   unicode_input_start();
   register_hex(0x2328);
   unicode_input_finish();
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index c5005897e..75607e40e 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -37,6 +37,7 @@ struct {
 extern const qk_ucis_symbol_t ucis_symbol_table[];
 
 void qk_ucis_start(void);
+void qk_ucis_start_user(void);
 void qk_ucis_symbol_fallback (void);
 bool process_ucis (uint16_t keycode, keyrecord_t *record);
 
-- 
cgit v1.2.3


From a312cbf712764277e0dbbbb99410c2f6fc6c7484 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Sun, 14 Aug 2016 14:34:52 +0200
Subject: process_unicode: Use uint32_t for UCIS purposes

Use a single uint32_t to store the unicode of a symbol, instead of an
array of uint16_ts.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 12 +++++++++---
 quantum/process_keycode/process_unicode.h |  7 ++++---
 2 files changed, 13 insertions(+), 6 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index c474483e7..698cc3c02 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -60,6 +60,14 @@ void register_hex(uint16_t hex) {
   }
 }
 
+void register_hex32(uint32_t hex) {
+  for(int i = 7; i >= 0; i--) {
+    uint8_t digit = ((hex >> (i*8)) & 0xF);
+    register_code(hex_to_keycode(digit));
+    unregister_code(hex_to_keycode(digit));
+  }
+}
+
 bool process_unicode(uint16_t keycode, keyrecord_t *record) {
   if (keycode > QK_UNICODE && record->event.pressed) {
     uint16_t unicode = keycode & 0x7FFF;
@@ -156,9 +164,7 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
     for (i = 0; ucis_symbol_table[i].symbol; i++) {
       if (is_uni_seq (ucis_symbol_table[i].symbol)) {
         symbol_found = true;
-        for (uint8_t j = 0; ucis_symbol_table[i].codes[j]; j++) {
-          register_hex(ucis_symbol_table[i].codes[j]);
-        }
+        register_hex32(ucis_symbol_table[i].code);
         break;
       }
     }
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 75607e40e..dd6dd7138 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -12,6 +12,7 @@ void set_unicode_input_mode(uint8_t os_target);
 void unicode_input_start(void);
 void unicode_input_finish(void);
 void register_hex(uint16_t hex);
+void register_hex32(uint32_t hex);
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
@@ -22,7 +23,7 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
 typedef struct {
   char *symbol;
-  uint16_t codes[4];
+  uint32_t code;
 } qk_ucis_symbol_t;
 
 struct {
@@ -31,8 +32,8 @@ struct {
   bool in_progress:1;
 } qk_ucis_state;
 
-#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, {}}}
-#define UCIS_SYM(name, ...) {name, {__VA_ARGS__, 0}}
+#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, 0}}
+#define UCIS_SYM(name, code) {name, code}
 
 extern const qk_ucis_symbol_t ucis_symbol_table[];
 
-- 
cgit v1.2.3


From 43d08629cf275d0b32281ffe8785258fff226b49 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Mon, 15 Aug 2016 10:02:05 +0200
Subject: process_unicode: Replace register_hex32

It turns out that register_hex32 did not work reliably, and some systems
only allow 7 chars after the unicode magic sequence, while others allow
8. To remedy the situation, store the codes as strings, and type those
in instead of doing bit shifting magic.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 37 +++++++++++++++++++++++--------
 quantum/process_keycode/process_unicode.h |  8 +++----
 2 files changed, 32 insertions(+), 13 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 698cc3c02..d8a0f667c 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -60,14 +60,6 @@ void register_hex(uint16_t hex) {
   }
 }
 
-void register_hex32(uint32_t hex) {
-  for(int i = 7; i >= 0; i--) {
-    uint8_t digit = ((hex >> (i*8)) & 0xF);
-    register_code(hex_to_keycode(digit));
-    unregister_code(hex_to_keycode(digit));
-  }
-}
-
 bool process_unicode(uint16_t keycode, keyrecord_t *record) {
   if (keycode > QK_UNICODE && record->event.pressed) {
     uint16_t unicode = keycode & 0x7FFF;
@@ -120,6 +112,33 @@ void qk_ucis_symbol_fallback (void) {
   }
 }
 
+void register_ucis(const char *hex) {
+  for(int i = 0; hex[i]; i++) {
+    uint8_t kc = 0;
+    char c = hex[i];
+
+    switch (c) {
+    case '0':
+      kc = KC_0;
+      break;
+    case '1' ... '9':
+      kc = c - '1' + KC_1;
+      break;
+    case 'a' ... 'f':
+      kc = c - 'a' + KC_A;
+      break;
+    case 'A' ... 'F':
+      kc = c - 'A' + KC_A;
+      break;
+    }
+
+    if (kc) {
+      register_code (kc);
+      unregister_code (kc);
+    }
+  }
+}
+
 bool process_ucis (uint16_t keycode, keyrecord_t *record) {
   uint8_t i;
 
@@ -164,7 +183,7 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
     for (i = 0; ucis_symbol_table[i].symbol; i++) {
       if (is_uni_seq (ucis_symbol_table[i].symbol)) {
         symbol_found = true;
-        register_hex32(ucis_symbol_table[i].code);
+        register_ucis(ucis_symbol_table[i].code + 2);
         break;
       }
     }
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index dd6dd7138..be24ddc2b 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -12,7 +12,6 @@ void set_unicode_input_mode(uint8_t os_target);
 void unicode_input_start(void);
 void unicode_input_finish(void);
 void register_hex(uint16_t hex);
-void register_hex32(uint32_t hex);
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
@@ -23,7 +22,7 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
 typedef struct {
   char *symbol;
-  uint32_t code;
+  char *code;
 } qk_ucis_symbol_t;
 
 struct {
@@ -32,14 +31,15 @@ struct {
   bool in_progress:1;
 } qk_ucis_state;
 
-#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, 0}}
-#define UCIS_SYM(name, code) {name, code}
+#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
+#define UCIS_SYM(name, code) {name, #code}
 
 extern const qk_ucis_symbol_t ucis_symbol_table[];
 
 void qk_ucis_start(void);
 void qk_ucis_start_user(void);
 void qk_ucis_symbol_fallback (void);
+void register_ucis(const char *hex);
 bool process_ucis (uint16_t keycode, keyrecord_t *record);
 
 #endif
-- 
cgit v1.2.3


From e8845f0daf8dc7a7674dc5420cc5a684bbbea09b Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Mon, 15 Aug 2016 10:07:13 +0200
Subject: process_unicode: Introduce a slight delay

When entering unicode codes, use some delay, so the OS has time to
process the information. This is not needed on all systems, but some
seem to require it.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 4 ++++
 quantum/process_keycode/process_unicode.h | 4 ++++
 2 files changed, 8 insertions(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index d8a0f667c..72c809c30 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -37,6 +37,7 @@ void unicode_input_start (void) {
     unregister_code(KC_PPLS);
     break;
   }
+  wait_ms(UNICODE_TYPE_DELAY);
 }
 
 void unicode_input_finish (void) {
@@ -109,6 +110,7 @@ void qk_ucis_symbol_fallback (void) {
     uint8_t code = qk_ucis_state.codes[i];
     register_code(code);
     unregister_code(code);
+    wait_ms(UNICODE_TYPE_DELAY);
   }
 }
 
@@ -135,6 +137,7 @@ void register_ucis(const char *hex) {
     if (kc) {
       register_code (kc);
       unregister_code (kc);
+      wait_ms (UNICODE_TYPE_DELAY);
     }
   }
 }
@@ -172,6 +175,7 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
     for (i = qk_ucis_state.count; i > 0; i--) {
       register_code (KC_BSPC);
       unregister_code (KC_BSPC);
+      wait_ms(UNICODE_TYPE_DELAY);
     }
 
     if (keycode == KC_ESC) {
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index be24ddc2b..85364e8eb 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -8,6 +8,10 @@
 #define UC_WIN 2
 #define UC_BSD 3
 
+#ifndef UNICODE_TYPE_DELAY
+#define UNICODE_TYPE_DELAY 10
+#endif
+
 void set_unicode_input_mode(uint8_t os_target);
 void unicode_input_start(void);
 void unicode_input_finish(void);
-- 
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')

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


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 ++++++++++++++--------------
 quantum/process_keycode/process_tap_dance.h |   9 ++-
 2 files changed, 66 insertions(+), 64 deletions(-)

(limited to 'quantum/process_keycode')

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 */
 
-- 
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')

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);
   }
 }
 
-- 
cgit v1.2.3


From dffdeb50b79d3c623e2ed9fd1c1d82d6d0ae7bf0 Mon Sep 17 00:00:00 2001
From: coderkun <olli@coderkun.de>
Date: Sun, 21 Aug 2016 20:25:19 +0200
Subject: Add method to set Unicode input key for ISO 14755

https://github.com/jackhumbert/qmk_firmware/issues/672
---
 quantum/process_keycode/process_unicode.c | 10 ++++++++--
 quantum/process_keycode/process_unicode.h |  5 +++++
 2 files changed, 13 insertions(+), 2 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 72c809c30..422217b6d 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -1,6 +1,7 @@
 #include "process_unicode.h"
 
 static uint8_t input_mode;
+static uint16_t linux_key = UNICODE_LNX_KEY;
 
 uint16_t hex_to_keycode(uint8_t hex)
 {
@@ -18,6 +19,11 @@ void set_unicode_input_mode(uint8_t os_target)
   input_mode = os_target;
 }
 
+void set_unicode_input_key_lnx(uint16_t key)
+{
+  linux_key = key;
+}
+
 void unicode_input_start (void) {
   switch(input_mode) {
   case UC_OSX:
@@ -26,8 +32,8 @@ void unicode_input_start (void) {
   case UC_LNX:
     register_code(KC_LCTL);
     register_code(KC_LSFT);
-    register_code(KC_U);
-    unregister_code(KC_U);
+    register_code(linux_key);
+    unregister_code(linux_key);
     unregister_code(KC_LSFT);
     unregister_code(KC_LCTL);
     break;
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 85364e8eb..60a116ab7 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -8,11 +8,16 @@
 #define UC_WIN 2
 #define UC_BSD 3
 
+#ifndef UNICODE_LNX_KEY
+#define UNICODE_LNX_KEY KC_A
+#endif
+
 #ifndef UNICODE_TYPE_DELAY
 #define UNICODE_TYPE_DELAY 10
 #endif
 
 void set_unicode_input_mode(uint8_t os_target);
+void set_unicode_input_key_lnx(uint16_t linux_key);
 void unicode_input_start(void);
 void unicode_input_finish(void);
 void register_hex(uint16_t hex);
-- 
cgit v1.2.3


From 81594c7883deefedbcd317c72c1b1f1d32e65cd7 Mon Sep 17 00:00:00 2001
From: coderkun <olli@coderkun.de>
Date: Sun, 21 Aug 2016 21:02:18 +0200
Subject: =?UTF-8?q?Drop=20method=20to=20set=20Unicode=20input=20key=20and?=
 =?UTF-8?q?=20declare=20start=20and=20finish=20methods=20as=20=E2=80=9Cwea?=
 =?UTF-8?q?k=E2=80=9D=20instead?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 quantum/process_keycode/process_unicode.c | 12 ++++--------
 quantum/process_keycode/process_unicode.h |  5 -----
 2 files changed, 4 insertions(+), 13 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 422217b6d..a1be8d2fc 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -1,7 +1,6 @@
 #include "process_unicode.h"
 
 static uint8_t input_mode;
-static uint16_t linux_key = UNICODE_LNX_KEY;
 
 uint16_t hex_to_keycode(uint8_t hex)
 {
@@ -19,11 +18,7 @@ void set_unicode_input_mode(uint8_t os_target)
   input_mode = os_target;
 }
 
-void set_unicode_input_key_lnx(uint16_t key)
-{
-  linux_key = key;
-}
-
+__attribute__((weak))
 void unicode_input_start (void) {
   switch(input_mode) {
   case UC_OSX:
@@ -32,8 +27,8 @@ void unicode_input_start (void) {
   case UC_LNX:
     register_code(KC_LCTL);
     register_code(KC_LSFT);
-    register_code(linux_key);
-    unregister_code(linux_key);
+    register_code(KC_U);
+    unregister_code(KC_U);
     unregister_code(KC_LSFT);
     unregister_code(KC_LCTL);
     break;
@@ -46,6 +41,7 @@ void unicode_input_start (void) {
   wait_ms(UNICODE_TYPE_DELAY);
 }
 
+__attribute__((weak))
 void unicode_input_finish (void) {
   switch(input_mode) {
   case UC_OSX:
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 60a116ab7..85364e8eb 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -8,16 +8,11 @@
 #define UC_WIN 2
 #define UC_BSD 3
 
-#ifndef UNICODE_LNX_KEY
-#define UNICODE_LNX_KEY KC_A
-#endif
-
 #ifndef UNICODE_TYPE_DELAY
 #define UNICODE_TYPE_DELAY 10
 #endif
 
 void set_unicode_input_mode(uint8_t os_target);
-void set_unicode_input_key_lnx(uint16_t linux_key);
 void unicode_input_start(void);
 void unicode_input_finish(void);
 void register_hex(uint16_t hex);
-- 
cgit v1.2.3


From a058ae40e268b34ba5db45f5fd5d557d50fa5437 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 24 Aug 2016 15:39:23 +0200
Subject: quantum: Move qk_ucis_state to process_unicode.c

In order to not declare the same variable in multiple objects (which
happens when building UCIS-enabled keymap for both the ErgoDox EZ and
the ErgoDox Infinity), move the declaration to the .c file, and keep
only an extern reference in the header.

Many thanks to @fredizzimo for spotting the error in Travis, and
suggesting the fix.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 2 ++
 quantum/process_keycode/process_unicode.h | 6 ++++--
 2 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index a1be8d2fc..06c1694f2 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -74,6 +74,8 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
 }
 
 #ifdef UCIS_ENABLE
+qk_ucis_state_t qk_ucis_state;
+
 void qk_ucis_start(void) {
   qk_ucis_state.count = 0;
   qk_ucis_state.in_progress = true;
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 85364e8eb..02ce3dd7e 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -29,11 +29,13 @@ typedef struct {
   char *code;
 } qk_ucis_symbol_t;
 
-struct {
+typedef struct {
   uint8_t count;
   uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
   bool in_progress:1;
-} qk_ucis_state;
+} qk_ucis_state_t;
+
+extern qk_ucis_state_t qk_ucis_state;
 
 #define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
 #define UCIS_SYM(name, code) {name, #code}
-- 
cgit v1.2.3


From c9ea236fc35d350c0ff33de0af84d3dee7d0eb95 Mon Sep 17 00:00:00 2001
From: Gergely Nagy <algernon@madhouse-project.org>
Date: Wed, 31 Aug 2016 08:21:52 +0200
Subject: process_unicode: Add get_unicode_input_mode()

There may be cases where one would like to know the current Unicode
input mode, without having to keep track of it themselves. Add a
function that does just this.

Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
---
 quantum/process_keycode/process_unicode.c | 4 ++++
 quantum/process_keycode/process_unicode.h | 1 +
 2 files changed, 5 insertions(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 06c1694f2..a5d7dca21 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -18,6 +18,10 @@ void set_unicode_input_mode(uint8_t os_target)
   input_mode = os_target;
 }
 
+uint8_t get_unicode_input_mode(void) {
+  return input_mode;
+}
+
 __attribute__((weak))
 void unicode_input_start (void) {
   switch(input_mode) {
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 02ce3dd7e..27f8072ee 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -13,6 +13,7 @@
 #endif
 
 void set_unicode_input_mode(uint8_t os_target);
+uint8_t get_unicode_input_mode(void);
 void unicode_input_start(void);
 void unicode_input_finish(void);
 void register_hex(uint16_t hex);
-- 
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')

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


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')

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


From 0edc82f0300924394324e2f3c4d2f8f0008439db Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Wed, 21 Sep 2016 11:29:34 +0200
Subject: formatting

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

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index d7b857bdc..49b06e450 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -39,15 +39,15 @@ typedef struct
 
 #define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
     .fn = { NULL, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset }, \
-    .user_data = (void *)&((qk_tap_dance_pair_t) { kc1, kc2 })  \
+    .user_data = (void *)&((qk_tap_dance_pair_t) { kc1, kc2 }),  \
   }
 
 #define ACTION_TAP_DANCE_FN(user_fn) {  \
-    .fn = { NULL, user_fn, NULL } \
+    .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) { \
-    .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_reset } \
+#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \
+    .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \
   }
 
 extern qk_tap_dance_action_t tap_dance_actions[];
-- 
cgit v1.2.3


From cda4b534fa4921c2d8f9884aa6a144333e7b07c4 Mon Sep 17 00:00:00 2001
From: Pavlos Vinieratos <pvinis@gmail.com>
Date: Wed, 21 Sep 2016 11:29:43 +0200
Subject: add user_data field

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

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index 49b06e450..f753cbba6 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -44,10 +44,12 @@ typedef struct
 
 #define ACTION_TAP_DANCE_FN(user_fn) {  \
     .fn = { NULL, user_fn, NULL }, \
+    .user_data = NULL, \
   }
 
 #define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \
     .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \
+    .user_data = NULL, \
   }
 
 extern qk_tap_dance_action_t tap_dance_actions[];
-- 
cgit v1.2.3


From 8d99140d1b80bf497b2198138d3f481e93b0fbab Mon Sep 17 00:00:00 2001
From: Adam Gausmann <adam@nonemu.ninja>
Date: Thu, 29 Sep 2016 14:46:10 -0500
Subject: Missing ifdef statement

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

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c
index 8784e64f3..577dad43a 100644
--- a/quantum/process_keycode/process_midi.c
+++ b/quantum/process_keycode/process_midi.c
@@ -7,7 +7,9 @@ int midi_offset = 7;
 bool process_midi(uint16_t keycode, keyrecord_t *record) {
     if (keycode == MI_ON && record->event.pressed) {
       midi_activated = true;
+#ifdef AUDIO_ENABLE
       music_scale_user();
+#endif
       return false;
     }
 
@@ -63,4 +65,4 @@ bool process_midi(uint16_t keycode, keyrecord_t *record) {
         return false;
     }
   return true;
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3


From a3f5a4cf5839fe29dd37400d72c5e353812002f8 Mon Sep 17 00:00:00 2001
From: coderkun <olli@coderkun.de>
Date: Sun, 2 Oct 2016 10:35:09 +0200
Subject: =?UTF-8?q?Declare=20Unicode=20method=20hex=5Fto=5Fkeycode()=20as?=
 =?UTF-8?q?=20=E2=80=9Cweak=E2=80=9D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Declare Unicode method hex_to_keycode() as “weak” to be able to override it in keymaps.
---
 quantum/process_keycode/process_unicode.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index a5d7dca21..6a30afe29 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -2,6 +2,7 @@
 
 static uint8_t input_mode;
 
+__attribute__((weak))
 uint16_t hex_to_keycode(uint8_t hex)
 {
   if (hex == 0x0) {
-- 
cgit v1.2.3


From 5b2e455d3b71bfb90754930d1f22d3e8ce98b927 Mon Sep 17 00:00:00 2001
From: Priyadi Iman Nurcahyo <priyadi@priyadi.net>
Date: Mon, 10 Oct 2016 00:46:20 +0700
Subject: Unicode map framework. Allow unicode up to 0xFFFFF using separate
 mapping table

---
 quantum/process_keycode/process_unicode.c | 26 ++++++++++++++++++++++++++
 quantum/process_keycode/process_unicode.h |  4 ++++
 2 files changed, 30 insertions(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 6a30afe29..37dd471ff 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -78,6 +78,32 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
   return true;
 }
 
+#ifdef UNICODEMAP_ENABLE
+__attribute__((weak))
+const uint32_t PROGMEM unicode_map[] = {
+};
+
+// 5 digit max because of linux limitation
+void register_hex32(uint32_t hex) {
+  for(int i = 4; i >= 0; i--) {
+    uint8_t digit = ((hex >> (i*4)) & 0xF);
+    register_code(hex_to_keycode(digit));
+    unregister_code(hex_to_keycode(digit));
+  }
+}
+
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
+  if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
+    const uint32_t* map = unicode_map;
+    uint16_t index = keycode & 0x7FF;
+    unicode_input_start();
+    register_hex32(pgm_read_dword_far(&map[index]));
+    unicode_input_finish();
+  }
+  return true;
+}
+#endif
+
 #ifdef UCIS_ENABLE
 qk_ucis_state_t qk_ucis_state;
 
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 27f8072ee..a6c7e4584 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -20,6 +20,10 @@ void register_hex(uint16_t hex);
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
+#ifdef UNICODEMAP_ENABLE
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
+#endif
+
 #ifdef UCIS_ENABLE
 #ifndef UCIS_MAX_SYMBOL_LENGTH
 #define UCIS_MAX_SYMBOL_LENGTH 32
-- 
cgit v1.2.3


From a889b899e2cf52b3b7807d8a7ad39f12e0761a10 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Sun, 16 Oct 2016 16:03:56 -0400
Subject: working with power limit

---
 quantum/process_keycode/process_printer.c    | 254 ++++++++++++++++++++++++++
 quantum/process_keycode/process_printer.h    |   8 +
 quantum/process_keycode/process_printer_bb.c | 260 +++++++++++++++++++++++++++
 3 files changed, 522 insertions(+)
 create mode 100644 quantum/process_keycode/process_printer.c
 create mode 100644 quantum/process_keycode/process_printer.h
 create mode 100644 quantum/process_keycode/process_printer_bb.c

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_printer.c b/quantum/process_keycode/process_printer.c
new file mode 100644
index 000000000..2e11dd366
--- /dev/null
+++ b/quantum/process_keycode/process_printer.c
@@ -0,0 +1,254 @@
+#include "process_printer.h"
+#include "action_util.h"
+
+bool printing_enabled = false;
+uint8_t character_shift = 0;
+
+void enabled_printing() {
+	printing_enabled = true;
+	serial_init();
+}
+
+void disable_printing() {
+	printing_enabled = false;
+}
+
+uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
+
+// uint8_t keycode_to_ascii[0xFF][2];
+
+// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
+
+void print_char(char c) {
+	USB_Disable();
+	serial_send(c);
+	USB_Init();
+}
+
+void print_box_string(uint8_t text[]) {
+	uint8_t len = strlen(text);
+	uint8_t out[len * 3 + 8];
+	out[0] = 0xDA;
+	for (uint8_t i = 0; i < len; i++) {
+		out[i+1] = 0xC4;
+	}
+	out[len + 1] = 0xBF;
+	out[len + 2] = '\n';
+
+	out[len + 3] = 0xB3;
+	for (uint8_t i = 0; i < len; i++) {
+		out[len + 4 + i] = text[i];
+	}
+	out[len * 2 + 4] = 0xB3;
+	out[len * 2 + 5] = '\n';
+
+
+	out[len * 2 + 6] = 0xC0;
+	for (uint8_t i = 0; i < len; i++) {
+		out[len * 2 + 7 + i] = 0xC4;
+	}
+	out[len * 3 + 7] = 0xD9;
+	out[len * 3 + 8] = '\n';
+
+	print_string(out); 
+}
+
+void print_string(char c[]) {
+	for(uint8_t i = 0; i < strlen(c); i++)
+		print_char(c[i]);
+}
+
+bool process_printer(uint16_t keycode, keyrecord_t *record) {
+	if (keycode == PRINT_ON) {
+		enabled_printing();
+		return false;
+	}
+	if (keycode == PRINT_OFF) {
+		disable_printing();
+		return false;
+	}
+
+	if (printing_enabled) {
+		switch(keycode) {
+			case KC_EXLM ... KC_RPRN:
+			case KC_UNDS:
+			case KC_PLUS:
+			case KC_LCBR:
+			case KC_RCBR:
+			case KC_PIPE:
+			case KC_TILD:
+				keycode &= 0xFF;
+			case KC_LSFT:
+			case KC_RSFT:
+				if (record->event.pressed) {
+					character_shift++;
+				} else {
+					character_shift--;
+				}
+				return false;
+			break;
+		}
+
+		switch(keycode) {
+			case KC_F1:
+				if (record->event.pressed) {
+					print_box_string("This is a line of text!");
+				}
+				return false;
+			case KC_ESC:
+				if (record->event.pressed) {
+					print_char(0x1B);
+				}
+				return false;
+			break;
+			case KC_SPC:
+				if (record->event.pressed) {
+					print_char(0x20);
+				}
+				return false;
+			break;
+			case KC_A ... KC_Z:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x41 + (keycode - KC_A));
+					} else {
+						print_char(0x61 + (keycode - KC_A));
+					}
+				}
+				return false;
+			break;
+			case KC_1 ... KC_0:
+				if (record->event.pressed) {
+					if (character_shift) {
+							print_char(shifted_numbers[keycode - KC_1]);
+					} else {
+							print_char(0x30 + ((keycode - KC_1 + 1) % 10));
+					}
+				}
+				return false;
+			break;
+			case KC_ENT:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x0C);
+					} else {
+						print_char(0x0A);
+					}
+				}
+				return false;
+			break;
+			case KC_BSPC:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x18);
+					} else {
+						print_char(0x1A);
+					}
+				}
+				return false;
+			break;
+			case KC_DOT:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x3E);
+					} else {
+						print_char(0x2E);
+					}
+				}
+				return false;
+			break;
+			case KC_COMM:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x3C);
+					} else {
+						print_char(0x2C);
+					}
+				}
+				return false;
+			break;
+			case KC_SLSH:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x3F);
+					} else {
+						print_char(0x2F);
+					}
+				}
+				return false;
+			break;
+			case KC_QUOT:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x22);
+					} else {
+						print_char(0x27);
+					}
+				}
+				return false;
+			break;
+			case KC_GRV:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7E);
+					} else {
+						print_char(0x60);
+					}
+				}
+				return false;
+			break;
+			case KC_MINS:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x5F);
+					} else {
+						print_char(0x2D);
+					}
+				}
+				return false;
+			break;
+			case KC_EQL:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x2B);
+					} else {
+						print_char(0x3D);
+					}
+				}
+				return false;
+			break;
+			case KC_LBRC:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7B);
+					} else {
+						print_char(0x5B);
+					}
+				}
+				return false;
+			break;
+			case KC_RBRC:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7D);
+					} else {
+						print_char(0x5D);
+					}
+				}
+				return false;
+			break;
+			case KC_BSLS:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7C);
+					} else {
+						print_char(0x5C);
+					}
+				}
+				return false;
+			break;
+		}
+	}
+	return true;
+
+}
\ No newline at end of file
diff --git a/quantum/process_keycode/process_printer.h b/quantum/process_keycode/process_printer.h
new file mode 100644
index 000000000..fdd36d75a
--- /dev/null
+++ b/quantum/process_keycode/process_printer.h
@@ -0,0 +1,8 @@
+#ifndef PROCESS_PRINTER_H
+#define PROCESS_PRINTER_H
+
+#include "quantum.h"
+
+#include "protocol/serial.h"
+
+#endif
\ No newline at end of file
diff --git a/quantum/process_keycode/process_printer_bb.c b/quantum/process_keycode/process_printer_bb.c
new file mode 100644
index 000000000..1924d0377
--- /dev/null
+++ b/quantum/process_keycode/process_printer_bb.c
@@ -0,0 +1,260 @@
+#include "process_printer.h"
+#include "action_util.h"
+
+bool printing_enabled = false;
+uint8_t character_shift = 0;
+
+#define SERIAL_PIN_DDR DDRD
+#define SERIAL_PIN_PORT PORTD
+#define SERIAL_PIN_MASK _BV(PD3)
+#define SERIAL_DELAY 52
+
+inline static
+void serial_delay(void) {
+  _delay_us(SERIAL_DELAY);
+}
+
+inline static
+void serial_high(void) {
+  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
+}
+
+inline static
+void serial_low(void) {
+  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
+}
+
+inline static
+void serial_output(void) {
+  SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
+}
+
+
+void enabled_printing() {
+	printing_enabled = true;
+	serial_output();
+	serial_high();
+}
+
+void disable_printing() {
+	printing_enabled = false;
+}
+
+uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
+
+// uint8_t keycode_to_ascii[0xFF][2];
+
+// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
+
+void print_char(char c) {
+  uint8_t b = 8;
+  serial_output();
+  while( b-- ) {
+    if(c & (1 << b)) {
+      serial_high();
+    } else {
+      serial_low();
+    }
+    serial_delay();
+  }
+}
+
+void print_string(char c[]) {
+	for(uint8_t i = 0; i < strlen(c); i++)
+		print_char(c[i]);
+}
+
+bool process_printer(uint16_t keycode, keyrecord_t *record) {
+	if (keycode == PRINT_ON) {
+		enabled_printing();
+		return false;
+	}
+	if (keycode == PRINT_OFF) {
+		disable_printing();
+		return false;
+	}
+
+	if (printing_enabled) {
+		switch(keycode) {
+			case KC_EXLM ... KC_RPRN:
+			case KC_UNDS:
+			case KC_PLUS:
+			case KC_LCBR:
+			case KC_RCBR:
+			case KC_PIPE:
+			case KC_TILD:
+				keycode &= 0xFF;
+			case KC_LSFT:
+			case KC_RSFT:
+				if (record->event.pressed) {
+					character_shift++;
+				} else {
+					character_shift--;
+				}
+				return false;
+			break;
+		}
+
+		switch(keycode) {
+			case KC_F1:
+				if (record->event.pressed) {
+					print_string("This is a line of text!\n\n\n");
+				}
+				return false;
+			case KC_ESC:
+				if (record->event.pressed) {
+					print_char(0x1B);
+				}
+				return false;
+			break;
+			case KC_SPC:
+				if (record->event.pressed) {
+					print_char(0x20);
+				}
+				return false;
+			break;
+			case KC_A ... KC_Z:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x41 + (keycode - KC_A));
+					} else {
+						print_char(0x61 + (keycode - KC_A));
+					}
+				}
+				return false;
+			break;
+			case KC_1 ... KC_0:
+				if (record->event.pressed) {
+					if (character_shift) {
+							print_char(shifted_numbers[keycode - KC_1]);
+					} else {
+							print_char(0x30 + ((keycode - KC_1 + 1) % 10));
+					}
+				}
+				return false;
+			break;
+			case KC_ENT:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x0C);
+					} else {
+						print_char(0x0A);
+					}
+				}
+				return false;
+			break;
+			case KC_BSPC:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x18);
+					} else {
+						print_char(0x1A);
+					}
+				}
+				return false;
+			break;
+			case KC_DOT:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x3E);
+					} else {
+						print_char(0x2E);
+					}
+				}
+				return false;
+			break;
+			case KC_COMM:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x3C);
+					} else {
+						print_char(0x2C);
+					}
+				}
+				return false;
+			break;
+			case KC_SLSH:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x3F);
+					} else {
+						print_char(0x2F);
+					}
+				}
+				return false;
+			break;
+			case KC_QUOT:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x22);
+					} else {
+						print_char(0x27);
+					}
+				}
+				return false;
+			break;
+			case KC_GRV:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7E);
+					} else {
+						print_char(0x60);
+					}
+				}
+				return false;
+			break;
+			case KC_MINS:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x5F);
+					} else {
+						print_char(0x2D);
+					}
+				}
+				return false;
+			break;
+			case KC_EQL:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x2B);
+					} else {
+						print_char(0x3D);
+					}
+				}
+				return false;
+			break;
+			case KC_LBRC:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7B);
+					} else {
+						print_char(0x5B);
+					}
+				}
+				return false;
+			break;
+			case KC_RBRC:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7D);
+					} else {
+						print_char(0x5D);
+					}
+				}
+				return false;
+			break;
+			case KC_BSLS:
+				if (record->event.pressed) {
+					if (character_shift) {
+						print_char(0x7C);
+					} else {
+						print_char(0x5C);
+					}
+				}
+				return false;
+			break;
+		}
+	}
+	return true;
+
+}
\ No newline at end of file
-- 
cgit v1.2.3


From e7d5dc89f2890007d776f6b613dc9deb473cff22 Mon Sep 17 00:00:00 2001
From: Priyadi Iman Nurcahyo <priyadi@priyadi.net>
Date: Sun, 23 Oct 2016 05:36:26 +0700
Subject: UNICODE_MAP: remove 5 char limit; ignore leading zeroes; handle OS
 limitations

---
 quantum/process_keycode/process_unicode.c | 34 ++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 37dd471ff..a71af5437 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -83,22 +83,42 @@ __attribute__((weak))
 const uint32_t PROGMEM unicode_map[] = {
 };
 
-// 5 digit max because of linux limitation
 void register_hex32(uint32_t hex) {
-  for(int i = 4; i >= 0; i--) {
+  uint8_t onzerostart = 1;
+  for(int i = 7; i >= 0; i--) {
+    if (i <= 3) {
+      onzerostart = 0;
+    }
     uint8_t digit = ((hex >> (i*4)) & 0xF);
-    register_code(hex_to_keycode(digit));
-    unregister_code(hex_to_keycode(digit));
+    if (digit == 0) {
+      if (onzerostart == 0) {
+        register_code(hex_to_keycode(digit));
+        unregister_code(hex_to_keycode(digit));
+      }
+    } else {
+      register_code(hex_to_keycode(digit));
+      unregister_code(hex_to_keycode(digit));
+      onzerostart = 0;
+    }
   }
 }
 
+__attribute__((weak))
+void unicode_map_input_error() {}
+
 bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
   if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
     const uint32_t* map = unicode_map;
     uint16_t index = keycode & 0x7FF;
-    unicode_input_start();
-    register_hex32(pgm_read_dword_far(&map[index]));
-    unicode_input_finish();
+    uint32_t code = pgm_read_dword_far(&map[index]);
+    if ((code > 0xFFFF && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
+      // when character is out of range supported by the OS
+      unicode_map_input_error();
+    } else {
+      unicode_input_start();
+      register_hex32(code);
+      unicode_input_finish();
+    }
   }
   return true;
 }
-- 
cgit v1.2.3


From 4a666c201007eacf13a9031e3c9b156e2e04afe6 Mon Sep 17 00:00:00 2001
From: Priyadi Iman Nurcahyo <priyadi@priyadi.net>
Date: Sun, 23 Oct 2016 19:15:33 +0700
Subject: Unicode WinCompose input method

---
 quantum/process_keycode/process_unicode.c | 5 +++++
 quantum/process_keycode/process_unicode.h | 9 +++++----
 2 files changed, 10 insertions(+), 4 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 37dd471ff..2a991cb39 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -42,6 +42,11 @@ void unicode_input_start (void) {
     register_code(KC_PPLS);
     unregister_code(KC_PPLS);
     break;
+  case UC_WINC:
+    register_code(KC_RALT);
+    unregister_code(KC_RALT);
+    register_code(KC_U);
+    unregister_code(KC_U);
   }
   wait_ms(UNICODE_TYPE_DELAY);
 }
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index a6c7e4584..065eeb5f6 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -3,10 +3,11 @@
 
 #include "quantum.h"
 
-#define UC_OSX 0
-#define UC_LNX 1
-#define UC_WIN 2
-#define UC_BSD 3
+#define UC_OSX 0  // Mac OS X
+#define UC_LNX 1  // Linux
+#define UC_WIN 2  // Windows 'HexNumpad'
+#define UC_BSD 3  // BSD (not implemented)
+#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
 
 #ifndef UNICODE_TYPE_DELAY
 #define UNICODE_TYPE_DELAY 10
-- 
cgit v1.2.3


From 6fee7e178f7c949213a124d78de60bc30267d367 Mon Sep 17 00:00:00 2001
From: Priyadi Iman Nurcahyo <priyadi@priyadi.net>
Date: Sat, 26 Nov 2016 23:53:15 +0700
Subject: fix strict-prototypes warning

---
 quantum/process_keycode/process_unicode.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 065eeb5f6..f17cfa6cf 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -22,6 +22,7 @@ void register_hex(uint16_t hex);
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
 #ifdef UNICODEMAP_ENABLE
+void unicode_map_input_error(void);
 bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
 #endif
 
-- 
cgit v1.2.3


From eac8fa799909817bfc7cb4043448f85551154c6b Mon Sep 17 00:00:00 2001
From: Ofer Plesser <plesserofer@gmail.com>
Date: Sat, 10 Dec 2016 00:49:11 +0200
Subject: Implemented basic key combination feature

---
 quantum/process_keycode/process_combo.c | 66 +++++++++++++++++++++++++++++++++
 quantum/process_keycode/process_combo.h | 25 +++++++++++++
 2 files changed, 91 insertions(+)
 create mode 100644 quantum/process_keycode/process_combo.c
 create mode 100644 quantum/process_keycode/process_combo.h

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_combo.c b/quantum/process_keycode/process_combo.c
new file mode 100644
index 000000000..a6cfed11a
--- /dev/null
+++ b/quantum/process_keycode/process_combo.c
@@ -0,0 +1,66 @@
+#include "process_combo.h"
+#include "print.h"
+
+// __attribute__ ((weak))
+// combo_t key_combos[] = {
+
+// };
+
+#define SEND_KEY(key) \
+do { \
+    register_code16(key); \
+    send_keyboard_report(); \
+    unregister_code16(key); \
+} while(0)
+
+
+#define ALL_COMBO_KEYS_ARE_DOWN (((1<<count)-1) == combo->state)
+static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *record) 
+{
+    uint8_t count = 0;
+    bool is_combo_key = false;
+    // bool combo_key_released = false;
+
+    // Count the number of combo keys
+    for (const uint16_t *key = combo->keys; COMBO_END != pgm_read_word(key); ++key, ++count);
+
+    for (uint8_t i = 0; i < count; ++i) {
+        uint16_t key = pgm_read_word(&combo->keys[i]);
+
+        if (key == keycode) {
+            is_combo_key = true;
+
+            if (record->event.pressed) {
+                combo->state |= (1<<i);
+            } else { // Combo key released
+                if (!combo->state) {
+                    // The combo was sent, no need to send released key
+                    return true;
+                }
+
+                combo->state &= ~(1<<i);
+                SEND_KEY(key);
+            }
+        }
+    }
+
+    if (ALL_COMBO_KEYS_ARE_DOWN) {
+        SEND_KEY(combo->action);
+        combo->state = 0;    
+    }
+
+    return is_combo_key;
+}
+
+
+bool process_combo(uint16_t keycode, keyrecord_t *record)
+{
+    bool is_combo_key = false;
+
+    for (int i = 0; i < NUM_ELEMS(key_combos); ++i) {
+        combo_t *combo = &key_combos[i];
+        is_combo_key |= process_single_combo(combo, keycode, record);
+    }    
+
+    return !is_combo_key;
+}
\ No newline at end of file
diff --git a/quantum/process_keycode/process_combo.h b/quantum/process_keycode/process_combo.h
new file mode 100644
index 000000000..68786c0f1
--- /dev/null
+++ b/quantum/process_keycode/process_combo.h
@@ -0,0 +1,25 @@
+#ifndef PROCESS_COMBO_H
+#define PROCESS_COMBO_H
+
+#include <stdint.h>
+#include "progmem.h"
+#include "quantum.h"
+
+
+typedef struct
+{
+    const uint16_t *keys;
+    uint16_t action;        
+    uint32_t state;
+} combo_t;
+
+
+#define COMBO_END 0
+#define NUM_ELEMS(a) (sizeof(a)/sizeof 0[a])
+
+
+extern combo_t key_combos[1];
+
+bool process_combo(uint16_t keycode, keyrecord_t *record);
+
+#endif
\ No newline at end of file
-- 
cgit v1.2.3


From b6bf4e0dce062a535685c4e772f613252d401ed3 Mon Sep 17 00:00:00 2001
From: Ofer Plesser <plesserofer@gmail.com>
Date: Sat, 10 Dec 2016 16:11:59 +0200
Subject: Added support for timing out combos if a key as been pressed for
 longer than COMBO_TERM

---
 quantum/process_keycode/process_combo.c | 107 +++++++++++++++++++++++---------
 quantum/process_keycode/process_combo.h |  20 +++++-
 2 files changed, 96 insertions(+), 31 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_combo.c b/quantum/process_keycode/process_combo.c
index a6cfed11a..ff7e8aba5 100644
--- a/quantum/process_keycode/process_combo.c
+++ b/quantum/process_keycode/process_combo.c
@@ -1,11 +1,6 @@
 #include "process_combo.h"
 #include "print.h"
 
-// __attribute__ ((weak))
-// combo_t key_combos[] = {
-
-// };
-
 #define SEND_KEY(key) \
 do { \
     register_code16(key); \
@@ -13,54 +8,110 @@ do { \
     unregister_code16(key); \
 } while(0)
 
+#define COMBO_TIMER_ELAPSED -1
+
+#if COMBO_TERM
+#define IS_COMBO_KEY_HELD(combo)            (COMBO_TIMER_ELAPSED == combo->timer ? false : true)
+#define RESET_COMBO_TIMER_AND_KEY(combo)    combo->timer = 0; combo->key = 0
+#else
+#define IS_COMBO_KEY_HELD(combo)            (true)
+#define RESET_COMBO_TIMER_AND_KEY(combo)    do {} while (0)
+#endif
+
+
+__attribute__ ((weak))
+combo_t key_combos[COMBO_COUNT] = {
+
+};
+
+static inline void reset_combo(combo_t *combo)
+{
+    combo->state = 0;
+    RESET_COMBO_TIMER_AND_KEY(combo);
+}
 
 #define ALL_COMBO_KEYS_ARE_DOWN (((1<<count)-1) == combo->state)
+#define NO_COMBO_KEYS_ARE_DOWN  (0 == combo->state)
+#define KEY_STATE_DOWN(key)     do{ combo->state |= (1<<key); } while(0)
+#define KEY_STATE_UP(key)       do{ combo->state &= ~(1<<key); } while(0)
 static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *record) 
 {
     uint8_t count = 0;
-    bool is_combo_key = false;
-    // bool combo_key_released = false;
+    uint8_t index = -1;
+    /* Find index of keycode and number of combo keys */
+    for (const uint16_t *keys = combo->keys; ;++count) {
+        uint16_t key = pgm_read_word(&keys[count]);
+        if (keycode == key) index = count;
+        if (COMBO_END == key) break;
+    }
 
-    // Count the number of combo keys
-    for (const uint16_t *key = combo->keys; COMBO_END != pgm_read_word(key); ++key, ++count);
+    /* Return if not a combo key */
+    if (-1 == index) return false;
 
-    for (uint8_t i = 0; i < count; ++i) {
-        uint16_t key = pgm_read_word(&combo->keys[i]);
+    bool is_combo_active = IS_COMBO_KEY_HELD(combo);
 
-        if (key == keycode) {
-            is_combo_key = true;
+    if (record->event.pressed) {
+        KEY_STATE_DOWN(index);
+        
+#if COMBO_TERM
+        if (is_combo_active) {
+            combo->timer = timer_read();
+            combo->key = keycode;
+        }
+#endif
 
-            if (record->event.pressed) {
-                combo->state |= (1<<i);
-            } else { // Combo key released
-                if (!combo->state) {
-                    // The combo was sent, no need to send released key
-                    return true;
-                }
+    } else {
+        if (is_combo_active && combo->state) { /* Combo key was tapped */
+            RESET_COMBO_TIMER_AND_KEY(combo);            
+            SEND_KEY(keycode);
+        }
 
-                combo->state &= ~(1<<i);
-                SEND_KEY(key);
-            }
+#if COMBO_TERM
+        if (!is_combo_active && keycode == combo->key) { /* Held combo key was released */
+            unregister_code16(combo->key);
         }
+#endif
+
+        KEY_STATE_UP(index);
     }
 
-    if (ALL_COMBO_KEYS_ARE_DOWN) {
+    if (ALL_COMBO_KEYS_ARE_DOWN && is_combo_active) {
         SEND_KEY(combo->action);
-        combo->state = 0;    
+        reset_combo(combo);
+    } 
+    
+    if(NO_COMBO_KEYS_ARE_DOWN && !is_combo_active) {
+        reset_combo(combo);
     }
 
-    return is_combo_key;
+    return is_combo_active;
 }
 
-
 bool process_combo(uint16_t keycode, keyrecord_t *record)
 {
     bool is_combo_key = false;
 
-    for (int i = 0; i < NUM_ELEMS(key_combos); ++i) {
+    for (int i = 0; i < COMBO_COUNT; ++i) {
         combo_t *combo = &key_combos[i];
         is_combo_key |= process_single_combo(combo, keycode, record);
     }    
 
     return !is_combo_key;
+}
+
+void matrix_scan_combo(void)
+{
+#if COMBO_TERM
+    for (int i = 0; i < COMBO_COUNT; ++i) {
+        combo_t *combo = &key_combos[i];
+        if (combo->timer && 
+            combo->timer != COMBO_TIMER_ELAPSED && 
+            timer_elapsed(combo->timer) > COMBO_TERM) {
+
+            combo->timer = COMBO_TIMER_ELAPSED;
+            unregister_code16(combo->key);
+            register_code16(combo->key);
+        }
+    }
+#endif
 }
\ No newline at end of file
diff --git a/quantum/process_keycode/process_combo.h b/quantum/process_keycode/process_combo.h
index 68786c0f1..c475acd33 100644
--- a/quantum/process_keycode/process_combo.h
+++ b/quantum/process_keycode/process_combo.h
@@ -5,21 +5,35 @@
 #include "progmem.h"
 #include "quantum.h"
 
+#ifndef COMBO_TERM
+#define COMBO_TERM TAPPING_TERM
+#endif
 
 typedef struct
 {
     const uint16_t *keys;
     uint16_t action;        
     uint32_t state;
+#if COMBO_TERM
+    uint16_t timer;
+    uint16_t key;
+#endif
 } combo_t;
 
 
+#if COMBO_TERM
+#define COMBO(ck, ca) {.keys = &(ck)[0], .action = (ca), .state = 0, .timer = 0, .key = 0}
+#else
+#define COMBO(ck, ca) {.keys = &(ck)[0], .action = (ca), .state = 0 }
+#endif
 #define COMBO_END 0
-#define NUM_ELEMS(a) (sizeof(a)/sizeof 0[a])
+#ifndef COMBO_COUNT
+#define COMBO_COUNT 0
+#endif
 
-
-extern combo_t key_combos[1];
+extern combo_t key_combos[COMBO_COUNT];
 
 bool process_combo(uint16_t keycode, keyrecord_t *record);
+void matrix_scan_combo(void);
 
 #endif
\ No newline at end of file
-- 
cgit v1.2.3


From ae95834f5af7404c04e6fe3446019046278d814b Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Mon, 12 Dec 2016 16:06:41 -0500
Subject: specialise music variables

---
 quantum/process_keycode/process_music.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
index 2d52e47a7..bae43943e 100644
--- a/quantum/process_keycode/process_music.c
+++ b/quantum/process_keycode/process_music.c
@@ -1,8 +1,8 @@
 #include "process_music.h"
 
 bool music_activated = false;
-uint8_t starting_note = 0x0C;
-int offset = 7;
+uint8_t music_starting_note = 0x0C;
+int music_offset = 7;
 
 // music sequencer
 static bool music_sequence_recording = false;
@@ -115,7 +115,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
         return false;
       }
 
-      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
+      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(music_starting_note + SCALE[record->event.key.col + music_offset])/12.0+(MATRIX_ROWS - record->event.key.row));
       if (record->event.pressed) {
         play_note(freq, 0xF);
         if (music_sequence_recording) {
-- 
cgit v1.2.3


From 6e7cfa83b9424061914793b02757fa4ec75b356b Mon Sep 17 00:00:00 2001
From: Ofer Plesser <plesserofer@gmail.com>
Date: Fri, 16 Dec 2016 21:50:28 +0200
Subject: Refactored as well as added support for action keys in combos

---
 quantum/process_keycode/process_combo.c | 123 ++++++++++++++++++--------------
 quantum/process_keycode/process_combo.h |  34 +++++----
 2 files changed, 89 insertions(+), 68 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_combo.c b/quantum/process_keycode/process_combo.c
index ff7e8aba5..e2189ad98 100644
--- a/quantum/process_keycode/process_combo.c
+++ b/quantum/process_keycode/process_combo.c
@@ -1,39 +1,39 @@
 #include "process_combo.h"
 #include "print.h"
 
-#define SEND_KEY(key) \
-do { \
-    register_code16(key); \
-    send_keyboard_report(); \
-    unregister_code16(key); \
-} while(0)
 
 #define COMBO_TIMER_ELAPSED -1
 
-#if COMBO_TERM
-#define IS_COMBO_KEY_HELD(combo)            (COMBO_TIMER_ELAPSED == combo->timer ? false : true)
-#define RESET_COMBO_TIMER_AND_KEY(combo)    combo->timer = 0; combo->key = 0
-#else
-#define IS_COMBO_KEY_HELD(combo)            (true)
-#define RESET_COMBO_TIMER_AND_KEY(combo)    do {} while (0)
-#endif
-
 
 __attribute__ ((weak))
-combo_t key_combos[COMBO_COUNT] = {
+combo_t key_combos[] = {
 
 };
 
-static inline void reset_combo(combo_t *combo)
+__attribute__ ((weak))
+void process_combo_event(uint8_t combo_index, bool pressed) {
+
+}
+
+static uint8_t current_combo_index = 0;
+
+static inline void send_combo(uint16_t action, bool pressed)
 {
-    combo->state = 0;
-    RESET_COMBO_TIMER_AND_KEY(combo);
+    if (action) {
+        if (pressed) {
+            register_code16(action);
+        } else {
+            unregister_code16(action);
+        }
+    } else {
+        process_combo_event(current_combo_index, pressed);
+    }
 }
 
-#define ALL_COMBO_KEYS_ARE_DOWN (((1<<count)-1) == combo->state)
-#define NO_COMBO_KEYS_ARE_DOWN  (0 == combo->state)
-#define KEY_STATE_DOWN(key)     do{ combo->state |= (1<<key); } while(0)
-#define KEY_STATE_UP(key)       do{ combo->state &= ~(1<<key); } while(0)
+#define ALL_COMBO_KEYS_ARE_DOWN     (((1<<count)-1) == combo->state)
+#define NO_COMBO_KEYS_ARE_DOWN      (0 == combo->state)
+#define KEY_STATE_DOWN(key)         do{ combo->state |= (1<<key); } while(0)
+#define KEY_STATE_UP(key)           do{ combo->state &= ~(1<<key); } while(0)
 static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *record) 
 {
     uint8_t count = 0;
@@ -46,42 +46,51 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
     }
 
     /* Return if not a combo key */
-    if (-1 == index) return false;
+    if (-1 == (int8_t)index) return false;
 
-    bool is_combo_active = IS_COMBO_KEY_HELD(combo);
+    /* The combos timer is used to signal whether the combo is active */
+    bool is_combo_active = COMBO_TIMER_ELAPSED == combo->timer ? false : true;
 
     if (record->event.pressed) {
         KEY_STATE_DOWN(index);
-        
-#if COMBO_TERM
+
         if (is_combo_active) {
-            combo->timer = timer_read();
-            combo->key = keycode;
-        }
+            if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was pressed */
+                send_combo(combo->keycode, true);
+                combo->timer = COMBO_TIMER_ELAPSED;
+            } else { /* Combo key was pressed */
+                combo->timer = timer_read();
+#ifdef COMBO_ALLOW_ACTION_KEYS
+                combo->prev_record = *record;
+#else
+                combo->prev_key = keycode;
 #endif
-
+            }
+        }
     } else {
-        if (is_combo_active && combo->state) { /* Combo key was tapped */
-            RESET_COMBO_TIMER_AND_KEY(combo);            
-            SEND_KEY(keycode);
+        if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was released */
+            send_combo(combo->keycode, false);
         }
 
-#if COMBO_TERM
-        if (!is_combo_active && keycode == combo->key) { /* Held combo key was released */
-            unregister_code16(combo->key);
-        }
+        if (is_combo_active) { /* Combo key was tapped */
+#ifdef COMBO_ALLOW_ACTION_KEYS
+            record->event.pressed = true;
+            process_action(record, store_or_get_action(record->event.pressed, record->event.key));
+            record->event.pressed = false;
+            process_action(record, store_or_get_action(record->event.pressed, record->event.key));
+#else
+            register_code16(keycode);
+            send_keyboard_report();
+            unregister_code16(keycode);
 #endif
+            combo->timer = 0;            
+        }
 
-        KEY_STATE_UP(index);
+        KEY_STATE_UP(index);        
     }
 
-    if (ALL_COMBO_KEYS_ARE_DOWN && is_combo_active) {
-        SEND_KEY(combo->action);
-        reset_combo(combo);
-    } 
-    
-    if(NO_COMBO_KEYS_ARE_DOWN && !is_combo_active) {
-        reset_combo(combo);
+    if (NO_COMBO_KEYS_ARE_DOWN) {
+        combo->timer = 0;
     }
 
     return is_combo_active;
@@ -91,8 +100,8 @@ bool process_combo(uint16_t keycode, keyrecord_t *record)
 {
     bool is_combo_key = false;
 
-    for (int i = 0; i < COMBO_COUNT; ++i) {
-        combo_t *combo = &key_combos[i];
+    for (current_combo_index = 0; current_combo_index < COMBO_COUNT; ++current_combo_index) {
+        combo_t *combo = &key_combos[current_combo_index];
         is_combo_key |= process_single_combo(combo, keycode, record);
     }    
 
@@ -101,17 +110,25 @@ bool process_combo(uint16_t keycode, keyrecord_t *record)
 
 void matrix_scan_combo(void)
 {
-#if COMBO_TERM
     for (int i = 0; i < COMBO_COUNT; ++i) {
         combo_t *combo = &key_combos[i];
         if (combo->timer && 
             combo->timer != COMBO_TIMER_ELAPSED && 
             timer_elapsed(combo->timer) > COMBO_TERM) {
-
+            
+            /* This disables the combo, meaning key events for this
+             * combo will be handled by the next processors in the chain 
+             */
             combo->timer = COMBO_TIMER_ELAPSED;
-            unregister_code16(combo->key);
-            register_code16(combo->key);
+
+#ifdef COMBO_ALLOW_ACTION_KEYS
+            process_action(&combo->prev_record, 
+                store_or_get_action(combo->prev_record.event.pressed, 
+                                    combo->prev_record.event.key));
+#else
+            unregister_code16(combo->prev_key);
+            register_code16(combo->prev_key);
+#endif
         }
     }
-#endif
-}
\ No newline at end of file
+}
diff --git a/quantum/process_keycode/process_combo.h b/quantum/process_keycode/process_combo.h
index c475acd33..847f2b737 100644
--- a/quantum/process_keycode/process_combo.h
+++ b/quantum/process_keycode/process_combo.h
@@ -5,35 +5,39 @@
 #include "progmem.h"
 #include "quantum.h"
 
-#ifndef COMBO_TERM
-#define COMBO_TERM TAPPING_TERM
-#endif
-
 typedef struct
 {
     const uint16_t *keys;
-    uint16_t action;        
+    uint16_t keycode;        
+#ifdef EXTRA_EXTRA_LONG_COMBOS
     uint32_t state;
-#if COMBO_TERM
+#elif EXTRA_LONG_COMBOS
+    uint16_t state;
+#else
+    uint8_t state;
+#endif
     uint16_t timer;
-    uint16_t key;
+#ifdef COMBO_ALLOW_ACTION_KEYS
+    keyrecord_t prev_record;
+#else
+    uint16_t prev_key;
 #endif
 } combo_t;
 
 
-#if COMBO_TERM
-#define COMBO(ck, ca) {.keys = &(ck)[0], .action = (ca), .state = 0, .timer = 0, .key = 0}
-#else
-#define COMBO(ck, ca) {.keys = &(ck)[0], .action = (ca), .state = 0 }
-#endif
+#define COMBO(ck, ca)       {.keys = &(ck)[0], .keycode = (ca)}
+#define COMBO_ACTION(ck)    {.keys = &(ck)[0]}
+
 #define COMBO_END 0
 #ifndef COMBO_COUNT
 #define COMBO_COUNT 0
 #endif
-
-extern combo_t key_combos[COMBO_COUNT];
+#ifndef COMBO_TERM
+#define COMBO_TERM TAPPING_TERM
+#endif
 
 bool process_combo(uint16_t keycode, keyrecord_t *record);
 void matrix_scan_combo(void);
+void process_combo_event(uint8_t combo_index, bool pressed);
 
-#endif
\ No newline at end of file
+#endif
-- 
cgit v1.2.3


From 273faa4d9cd5a84207548f83ba550c9efee90933 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Fri, 23 Dec 2016 20:59:00 -0500
Subject: add different scales for music mode

---
 quantum/process_keycode/process_music.c | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
index bae43943e..ca68bef6c 100644
--- a/quantum/process_keycode/process_music.c
+++ b/quantum/process_keycode/process_music.c
@@ -115,7 +115,16 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
         return false;
       }
 
+      #ifdef MUSIC_MODE_CHROMATIC
+      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(music_starting_note + record->event.key.col + music_offset)/12.0+(MATRIX_ROWS - record->event.key.row));
+      #elif defined(MUSIC_MODE_GUITAR)
+      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(music_starting_note + record->event.key.col + music_offset)/12.0+(float)(MATRIX_ROWS - record->event.key.row + 7)*5.0/12);
+      #elif defined(MUSIC_MODE_VIOLIN)
+      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(music_starting_note + record->event.key.col + music_offset)/12.0+(float)(MATRIX_ROWS - record->event.key.row + 5)*7.0/12);
+      #else
       float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(music_starting_note + SCALE[record->event.key.col + music_offset])/12.0+(MATRIX_ROWS - record->event.key.row));
+      #endif
+
       if (record->event.pressed) {
         play_note(freq, 0xF);
         if (music_sequence_recording) {
-- 
cgit v1.2.3


From 0aa413af44b292e4b44d8f8aee1a92f2cb113438 Mon Sep 17 00:00:00 2001
From: Jonas Oberschweiber <jonas.oberschweiber@d-velop.de>
Date: Sat, 31 Dec 2016 19:37:56 +0100
Subject: Add support for supplementary planes for OS X

---
 quantum/process_keycode/process_unicode.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index cd3a610b4..2606cf0c8 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -116,7 +116,16 @@ bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
     const uint32_t* map = unicode_map;
     uint16_t index = keycode & 0x7FF;
     uint32_t code = pgm_read_dword_far(&map[index]);
-    if ((code > 0xFFFF && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
+    if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
+      // Convert to UTF-16 surrogate pair
+      code -= 0x10000;
+      uint32_t lo = code & 0x3ff;
+      uint32_t hi = (code & 0xffc00) >> 10;
+      unicode_input_start();
+      register_hex32(hi + 0xd800);
+      register_hex32(lo + 0xdc00);
+      unicode_input_finish();
+    } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
       // when character is out of range supported by the OS
       unicode_map_input_error();
     } else {
-- 
cgit v1.2.3


From 30b80a23f3cafd846937b37b249f2df4411e1f5a Mon Sep 17 00:00:00 2001
From: Priyadi Iman Nurcahyo <priyadi@priyadi.net>
Date: Mon, 9 Jan 2017 02:59:10 +0700
Subject: Unregister all mods before inputting Unicode, and reregister
 afterwards

---
 quantum/process_keycode/process_unicode.c | 41 +++++++++++++++++++++++++------
 1 file changed, 33 insertions(+), 8 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index cd3a610b4..a30e93ae3 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -1,6 +1,8 @@
 #include "process_unicode.h"
+#include "action_util.h"
 
 static uint8_t input_mode;
+uint8_t mods;
 
 __attribute__((weak))
 uint16_t hex_to_keycode(uint8_t hex)
@@ -25,6 +27,19 @@ uint8_t get_unicode_input_mode(void) {
 
 __attribute__((weak))
 void unicode_input_start (void) {
+  // save current mods
+  mods = keyboard_report->mods;
+
+  // unregister all mods to start from clean state
+  if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
+  if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
+  if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
+  if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
+  if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
+  if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
+  if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
+  if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
+
   switch(input_mode) {
   case UC_OSX:
     register_code(KC_LALT);
@@ -54,15 +69,25 @@ void unicode_input_start (void) {
 __attribute__((weak))
 void unicode_input_finish (void) {
   switch(input_mode) {
-  case UC_OSX:
-  case UC_WIN:
-    unregister_code(KC_LALT);
-    break;
-  case UC_LNX:
-    register_code(KC_SPC);
-    unregister_code(KC_SPC);
-    break;
+    case UC_OSX:
+    case UC_WIN:
+      unregister_code(KC_LALT);
+      break;
+    case UC_LNX:
+      register_code(KC_SPC);
+      unregister_code(KC_SPC);
+      break;
   }
+
+  // reregister previously set mods
+  if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
+  if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
+  if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
+  if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
+  if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
+  if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
+  if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
+  if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
 }
 
 void register_hex(uint16_t hex) {
-- 
cgit v1.2.3


From 841d7e6a1d74b1fc45575ed551132ec27353ebf3 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Mon, 23 Jan 2017 13:55:24 -0500
Subject: turn off rgb_midi in ez

---
 quantum/process_keycode/process_music.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
index ca68bef6c..1e2648bff 100644
--- a/quantum/process_keycode/process_music.c
+++ b/quantum/process_keycode/process_music.c
@@ -114,6 +114,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
             music_sequence_interval+=10;
         return false;
       }
+      #define MUSIC_MODE_GUITAR
 
       #ifdef MUSIC_MODE_CHROMATIC
       float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(music_starting_note + record->event.key.col + music_offset)/12.0+(MATRIX_ROWS - record->event.key.row));
-- 
cgit v1.2.3


From 5a860b71a1943358d0722ace9d2c13bd5c77c971 Mon Sep 17 00:00:00 2001
From: SjB <steve@sagacity.ca>
Date: Sun, 29 Jan 2017 13:04:43 -0500
Subject: race condition between oneshot_mods and tap_dance

since the keycode for a tap dance process gets process only after the
TAPPING_TERM timeout, you really only have ONESHOT_TIMEOUT -
TAPPING_TERM time to tap or double tap on the key. This fix save the
oneshot_mods into the action.state structure and applies the mods with
the keycode when it's registered. It also unregisters the mod when the
the tap dance process gets reset.
---
 quantum/process_keycode/process_tap_dance.c | 7 ++++++-
 quantum/process_keycode/process_tap_dance.h | 1 +
 2 files changed, 7 insertions(+), 1 deletion(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 6ae362c4c..403dca538 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -43,12 +43,16 @@ static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_acti
   if (action->state.finished)
     return;
   action->state.finished = true;
+  add_mods(action->state.oneshot_mods);
+  send_keyboard_report();
   _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)
 {
   _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_reset);
+  del_mods(action->state.oneshot_mods);
+  send_keyboard_report();
 }
 
 bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
@@ -70,6 +74,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
       action->state.keycode = keycode;
       action->state.count++;
       action->state.timer = timer_read();
+      action->state.oneshot_mods = get_oneshot_mods();
       process_tap_dance_action_on_each_tap (action);
 
       if (last_td && last_td != keycode) {
@@ -109,7 +114,7 @@ void matrix_scan_tap_dance () {
   if (highest_td == -1)
     return;
 
-  for (int i = 0; i <= highest_td; i++) {
+for (int i = 0; i <= highest_td; i++) {
     qk_tap_dance_action_t *action = &tap_dance_actions[i];
 
     if (action->state.count && timer_elapsed (action->state.timer) > TAPPING_TERM) {
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index f753cbba6..726752ecc 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -9,6 +9,7 @@
 typedef struct
 {
   uint8_t count;
+  uint8_t oneshot_mods;
   uint16_t keycode;
   uint16_t timer;
   bool interrupted;
-- 
cgit v1.2.3


From 97816df7e7aa8710c8a0837b2abe008e0c765f2a Mon Sep 17 00:00:00 2001
From: Priyadi Iman Nurcahyo <priyadi@priyadi.net>
Date: Fri, 10 Feb 2017 06:06:59 +0700
Subject: Implement tap mod dual role for right side mods.

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

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 9995ba9bd..9d01a592d 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -139,7 +139,7 @@ void unicode_map_input_error() {}
 bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
   if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
     const uint32_t* map = unicode_map;
-    uint16_t index = keycode & 0x7FF;
+    uint16_t index = keycode - QK_UNICODE_MAP;
     uint32_t code = pgm_read_dword_far(&map[index]);
     if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
       // Convert to UTF-16 surrogate pair
-- 
cgit v1.2.3


From cbabb4d417ef58f5d484dc256b637f61619efaa8 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 15 Feb 2017 16:36:31 -0500
Subject: split up unicode systems into different files

---
 quantum/process_keycode/process_ucis.c       | 133 ++++++++++++++++++
 quantum/process_keycode/process_ucis.h       |  34 +++++
 quantum/process_keycode/process_unicode.c    | 200 ---------------------------
 quantum/process_keycode/process_unicode.h    |  36 -----
 quantum/process_keycode/process_unicodemap.c |  54 ++++++++
 quantum/process_keycode/process_unicodemap.h |   8 ++
 6 files changed, 229 insertions(+), 236 deletions(-)
 create mode 100644 quantum/process_keycode/process_ucis.c
 create mode 100644 quantum/process_keycode/process_ucis.h
 create mode 100644 quantum/process_keycode/process_unicodemap.c
 create mode 100644 quantum/process_keycode/process_unicodemap.h

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_ucis.c b/quantum/process_keycode/process_ucis.c
new file mode 100644
index 000000000..4ad2533b0
--- /dev/null
+++ b/quantum/process_keycode/process_ucis.c
@@ -0,0 +1,133 @@
+#include "process_ucis.h"
+
+qk_ucis_state_t qk_ucis_state;
+
+void qk_ucis_start(void) {
+  qk_ucis_state.count = 0;
+  qk_ucis_state.in_progress = true;
+
+  qk_ucis_start_user();
+}
+
+__attribute__((weak))
+void qk_ucis_start_user(void) {
+  unicode_input_start();
+  register_hex(0x2328);
+  unicode_input_finish();
+}
+
+static bool is_uni_seq(char *seq) {
+  uint8_t i;
+
+  for (i = 0; seq[i]; i++) {
+    uint16_t code;
+    if (('1' <= seq[i]) && (seq[i] <= '0'))
+      code = seq[i] - '1' + KC_1;
+    else
+      code = seq[i] - 'a' + KC_A;
+
+    if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
+      return false;
+  }
+
+  return (qk_ucis_state.codes[i] == KC_ENT ||
+          qk_ucis_state.codes[i] == KC_SPC);
+}
+
+__attribute__((weak))
+void qk_ucis_symbol_fallback (void) {
+  for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
+    uint8_t code = qk_ucis_state.codes[i];
+    register_code(code);
+    unregister_code(code);
+    wait_ms(UNICODE_TYPE_DELAY);
+  }
+}
+
+void register_ucis(const char *hex) {
+  for(int i = 0; hex[i]; i++) {
+    uint8_t kc = 0;
+    char c = hex[i];
+
+    switch (c) {
+    case '0':
+      kc = KC_0;
+      break;
+    case '1' ... '9':
+      kc = c - '1' + KC_1;
+      break;
+    case 'a' ... 'f':
+      kc = c - 'a' + KC_A;
+      break;
+    case 'A' ... 'F':
+      kc = c - 'A' + KC_A;
+      break;
+    }
+
+    if (kc) {
+      register_code (kc);
+      unregister_code (kc);
+      wait_ms (UNICODE_TYPE_DELAY);
+    }
+  }
+}
+
+bool process_ucis (uint16_t keycode, keyrecord_t *record) {
+  uint8_t i;
+
+  if (!qk_ucis_state.in_progress)
+    return true;
+
+  if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
+      !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
+    return false;
+  }
+
+  if (!record->event.pressed)
+    return true;
+
+  qk_ucis_state.codes[qk_ucis_state.count] = keycode;
+  qk_ucis_state.count++;
+
+  if (keycode == KC_BSPC) {
+    if (qk_ucis_state.count >= 2) {
+      qk_ucis_state.count -= 2;
+      return true;
+    } else {
+      qk_ucis_state.count--;
+      return false;
+    }
+  }
+
+  if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
+    bool symbol_found = false;
+
+    for (i = qk_ucis_state.count; i > 0; i--) {
+      register_code (KC_BSPC);
+      unregister_code (KC_BSPC);
+      wait_ms(UNICODE_TYPE_DELAY);
+    }
+
+    if (keycode == KC_ESC) {
+      qk_ucis_state.in_progress = false;
+      return false;
+    }
+
+    unicode_input_start();
+    for (i = 0; ucis_symbol_table[i].symbol; i++) {
+      if (is_uni_seq (ucis_symbol_table[i].symbol)) {
+        symbol_found = true;
+        register_ucis(ucis_symbol_table[i].code + 2);
+        break;
+      }
+    }
+    if (!symbol_found) {
+      qk_ucis_symbol_fallback();
+    }
+    unicode_input_finish();
+
+    qk_ucis_state.in_progress = false;
+    return false;
+  }
+  return true;
+}
\ No newline at end of file
diff --git a/quantum/process_keycode/process_ucis.h b/quantum/process_keycode/process_ucis.h
new file mode 100644
index 000000000..520db8042
--- /dev/null
+++ b/quantum/process_keycode/process_ucis.h
@@ -0,0 +1,34 @@
+#ifndef PROCESS_UCIS_H
+#define PROCESS_UCIS_H
+
+#include "quantum.h"
+
+#ifndef UCIS_MAX_SYMBOL_LENGTH
+#define UCIS_MAX_SYMBOL_LENGTH 32
+#endif
+
+typedef struct {
+  char *symbol;
+  char *code;
+} qk_ucis_symbol_t;
+
+typedef struct {
+  uint8_t count;
+  uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
+  bool in_progress:1;
+} qk_ucis_state_t;
+
+extern qk_ucis_state_t qk_ucis_state;
+
+#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
+#define UCIS_SYM(name, code) {name, #code}
+
+extern const qk_ucis_symbol_t ucis_symbol_table[];
+
+void qk_ucis_start(void);
+void qk_ucis_start_user(void);
+void qk_ucis_symbol_fallback (void);
+void register_ucis(const char *hex);
+bool process_ucis (uint16_t keycode, keyrecord_t *record);
+
+#endif
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 9d01a592d..898e168a3 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -4,18 +4,6 @@
 static uint8_t input_mode;
 uint8_t mods;
 
-__attribute__((weak))
-uint16_t hex_to_keycode(uint8_t hex)
-{
-  if (hex == 0x0) {
-    return KC_0;
-  } else if (hex < 0xA) {
-    return KC_1 + (hex - 0x1);
-  } else {
-    return KC_A + (hex - 0xA);
-  }
-}
-
 void set_unicode_input_mode(uint8_t os_target)
 {
   input_mode = os_target;
@@ -108,191 +96,3 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
   return true;
 }
 
-#ifdef UNICODEMAP_ENABLE
-__attribute__((weak))
-const uint32_t PROGMEM unicode_map[] = {
-};
-
-void register_hex32(uint32_t hex) {
-  uint8_t onzerostart = 1;
-  for(int i = 7; i >= 0; i--) {
-    if (i <= 3) {
-      onzerostart = 0;
-    }
-    uint8_t digit = ((hex >> (i*4)) & 0xF);
-    if (digit == 0) {
-      if (onzerostart == 0) {
-        register_code(hex_to_keycode(digit));
-        unregister_code(hex_to_keycode(digit));
-      }
-    } else {
-      register_code(hex_to_keycode(digit));
-      unregister_code(hex_to_keycode(digit));
-      onzerostart = 0;
-    }
-  }
-}
-
-__attribute__((weak))
-void unicode_map_input_error() {}
-
-bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
-  if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
-    const uint32_t* map = unicode_map;
-    uint16_t index = keycode - QK_UNICODE_MAP;
-    uint32_t code = pgm_read_dword_far(&map[index]);
-    if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
-      // Convert to UTF-16 surrogate pair
-      code -= 0x10000;
-      uint32_t lo = code & 0x3ff;
-      uint32_t hi = (code & 0xffc00) >> 10;
-      unicode_input_start();
-      register_hex32(hi + 0xd800);
-      register_hex32(lo + 0xdc00);
-      unicode_input_finish();
-    } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
-      // when character is out of range supported by the OS
-      unicode_map_input_error();
-    } else {
-      unicode_input_start();
-      register_hex32(code);
-      unicode_input_finish();
-    }
-  }
-  return true;
-}
-#endif
-
-#ifdef UCIS_ENABLE
-qk_ucis_state_t qk_ucis_state;
-
-void qk_ucis_start(void) {
-  qk_ucis_state.count = 0;
-  qk_ucis_state.in_progress = true;
-
-  qk_ucis_start_user();
-}
-
-__attribute__((weak))
-void qk_ucis_start_user(void) {
-  unicode_input_start();
-  register_hex(0x2328);
-  unicode_input_finish();
-}
-
-static bool is_uni_seq(char *seq) {
-  uint8_t i;
-
-  for (i = 0; seq[i]; i++) {
-    uint16_t code;
-    if (('1' <= seq[i]) && (seq[i] <= '0'))
-      code = seq[i] - '1' + KC_1;
-    else
-      code = seq[i] - 'a' + KC_A;
-
-    if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
-      return false;
-  }
-
-  return (qk_ucis_state.codes[i] == KC_ENT ||
-          qk_ucis_state.codes[i] == KC_SPC);
-}
-
-__attribute__((weak))
-void qk_ucis_symbol_fallback (void) {
-  for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
-    uint8_t code = qk_ucis_state.codes[i];
-    register_code(code);
-    unregister_code(code);
-    wait_ms(UNICODE_TYPE_DELAY);
-  }
-}
-
-void register_ucis(const char *hex) {
-  for(int i = 0; hex[i]; i++) {
-    uint8_t kc = 0;
-    char c = hex[i];
-
-    switch (c) {
-    case '0':
-      kc = KC_0;
-      break;
-    case '1' ... '9':
-      kc = c - '1' + KC_1;
-      break;
-    case 'a' ... 'f':
-      kc = c - 'a' + KC_A;
-      break;
-    case 'A' ... 'F':
-      kc = c - 'A' + KC_A;
-      break;
-    }
-
-    if (kc) {
-      register_code (kc);
-      unregister_code (kc);
-      wait_ms (UNICODE_TYPE_DELAY);
-    }
-  }
-}
-
-bool process_ucis (uint16_t keycode, keyrecord_t *record) {
-  uint8_t i;
-
-  if (!qk_ucis_state.in_progress)
-    return true;
-
-  if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
-      !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
-    return false;
-  }
-
-  if (!record->event.pressed)
-    return true;
-
-  qk_ucis_state.codes[qk_ucis_state.count] = keycode;
-  qk_ucis_state.count++;
-
-  if (keycode == KC_BSPC) {
-    if (qk_ucis_state.count >= 2) {
-      qk_ucis_state.count -= 2;
-      return true;
-    } else {
-      qk_ucis_state.count--;
-      return false;
-    }
-  }
-
-  if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
-    bool symbol_found = false;
-
-    for (i = qk_ucis_state.count; i > 0; i--) {
-      register_code (KC_BSPC);
-      unregister_code (KC_BSPC);
-      wait_ms(UNICODE_TYPE_DELAY);
-    }
-
-    if (keycode == KC_ESC) {
-      qk_ucis_state.in_progress = false;
-      return false;
-    }
-
-    unicode_input_start();
-    for (i = 0; ucis_symbol_table[i].symbol; i++) {
-      if (is_uni_seq (ucis_symbol_table[i].symbol)) {
-        symbol_found = true;
-        register_ucis(ucis_symbol_table[i].code + 2);
-        break;
-      }
-    }
-    if (!symbol_found) {
-      qk_ucis_symbol_fallback();
-    }
-    unicode_input_finish();
-
-    qk_ucis_state.in_progress = false;
-    return false;
-  }
-  return true;
-}
-#endif
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index f17cfa6cf..7ed9e54d5 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -21,42 +21,6 @@ void register_hex(uint16_t hex);
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
-#ifdef UNICODEMAP_ENABLE
-void unicode_map_input_error(void);
-bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
-#endif
-
-#ifdef UCIS_ENABLE
-#ifndef UCIS_MAX_SYMBOL_LENGTH
-#define UCIS_MAX_SYMBOL_LENGTH 32
-#endif
-
-typedef struct {
-  char *symbol;
-  char *code;
-} qk_ucis_symbol_t;
-
-typedef struct {
-  uint8_t count;
-  uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
-  bool in_progress:1;
-} qk_ucis_state_t;
-
-extern qk_ucis_state_t qk_ucis_state;
-
-#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
-#define UCIS_SYM(name, code) {name, #code}
-
-extern const qk_ucis_symbol_t ucis_symbol_table[];
-
-void qk_ucis_start(void);
-void qk_ucis_start_user(void);
-void qk_ucis_symbol_fallback (void);
-void register_ucis(const char *hex);
-bool process_ucis (uint16_t keycode, keyrecord_t *record);
-
-#endif
-
 #define UC_BSPC	UC(0x0008)
 
 #define UC_SPC	UC(0x0020)
diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c
new file mode 100644
index 000000000..b8cdeaa97
--- /dev/null
+++ b/quantum/process_keycode/process_unicodemap.c
@@ -0,0 +1,54 @@
+#include "process_unicode_map.h"
+
+__attribute__((weak))
+const uint32_t PROGMEM unicode_map[] = {
+};
+
+void register_hex32(uint32_t hex) {
+  uint8_t onzerostart = 1;
+  for(int i = 7; i >= 0; i--) {
+    if (i <= 3) {
+      onzerostart = 0;
+    }
+    uint8_t digit = ((hex >> (i*4)) & 0xF);
+    if (digit == 0) {
+      if (onzerostart == 0) {
+        register_code(hex_to_keycode(digit));
+        unregister_code(hex_to_keycode(digit));
+      }
+    } else {
+      register_code(hex_to_keycode(digit));
+      unregister_code(hex_to_keycode(digit));
+      onzerostart = 0;
+    }
+  }
+}
+
+__attribute__((weak))
+void unicode_map_input_error() {}
+
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
+  if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
+    const uint32_t* map = unicode_map;
+    uint16_t index = keycode - QK_UNICODE_MAP;
+    uint32_t code = pgm_read_dword_far(&map[index]);
+    if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
+      // Convert to UTF-16 surrogate pair
+      code -= 0x10000;
+      uint32_t lo = code & 0x3ff;
+      uint32_t hi = (code & 0xffc00) >> 10;
+      unicode_input_start();
+      register_hex32(hi + 0xd800);
+      register_hex32(lo + 0xdc00);
+      unicode_input_finish();
+    } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
+      // when character is out of range supported by the OS
+      unicode_map_input_error();
+    } else {
+      unicode_input_start();
+      register_hex32(code);
+      unicode_input_finish();
+    }
+  }
+  return true;
+}
\ No newline at end of file
diff --git a/quantum/process_keycode/process_unicodemap.h b/quantum/process_keycode/process_unicodemap.h
new file mode 100644
index 000000000..291bd8de0
--- /dev/null
+++ b/quantum/process_keycode/process_unicodemap.h
@@ -0,0 +1,8 @@
+#ifndef PROCESS_UNICODEMAP_H
+#define PROCESS_UNICODEMAP_H
+
+#include "quantum.h"
+
+void unicode_map_input_error(void);
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
+#endif
\ No newline at end of file
-- 
cgit v1.2.3


From 09add35e7f0b17f720862bc9b0f8478763937328 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 15 Feb 2017 17:09:35 -0500
Subject: add unicode common file, get names right

---
 quantum/process_keycode/process_ucis.h           |   1 +
 quantum/process_keycode/process_unicode.c        |  85 ---------------
 quantum/process_keycode/process_unicode.h        | 124 +--------------------
 quantum/process_keycode/process_unicode_common.h | 130 +++++++++++++++++++++++
 quantum/process_keycode/process_unicodemap.c     |   2 +-
 quantum/process_keycode/process_unicodemap.h     |   1 +
 6 files changed, 134 insertions(+), 209 deletions(-)
 create mode 100644 quantum/process_keycode/process_unicode_common.h

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_ucis.h b/quantum/process_keycode/process_ucis.h
index 520db8042..4332f57b3 100644
--- a/quantum/process_keycode/process_ucis.h
+++ b/quantum/process_keycode/process_ucis.h
@@ -2,6 +2,7 @@
 #define PROCESS_UCIS_H
 
 #include "quantum.h"
+#include "process_unicode_common.h"
 
 #ifndef UCIS_MAX_SYMBOL_LENGTH
 #define UCIS_MAX_SYMBOL_LENGTH 32
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 898e168a3..ccae6fdca 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -1,91 +1,6 @@
 #include "process_unicode.h"
 #include "action_util.h"
 
-static uint8_t input_mode;
-uint8_t mods;
-
-void set_unicode_input_mode(uint8_t os_target)
-{
-  input_mode = os_target;
-}
-
-uint8_t get_unicode_input_mode(void) {
-  return input_mode;
-}
-
-__attribute__((weak))
-void unicode_input_start (void) {
-  // save current mods
-  mods = keyboard_report->mods;
-
-  // unregister all mods to start from clean state
-  if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
-  if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
-  if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
-  if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
-  if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
-  if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
-  if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
-  if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
-
-  switch(input_mode) {
-  case UC_OSX:
-    register_code(KC_LALT);
-    break;
-  case UC_LNX:
-    register_code(KC_LCTL);
-    register_code(KC_LSFT);
-    register_code(KC_U);
-    unregister_code(KC_U);
-    unregister_code(KC_LSFT);
-    unregister_code(KC_LCTL);
-    break;
-  case UC_WIN:
-    register_code(KC_LALT);
-    register_code(KC_PPLS);
-    unregister_code(KC_PPLS);
-    break;
-  case UC_WINC:
-    register_code(KC_RALT);
-    unregister_code(KC_RALT);
-    register_code(KC_U);
-    unregister_code(KC_U);
-  }
-  wait_ms(UNICODE_TYPE_DELAY);
-}
-
-__attribute__((weak))
-void unicode_input_finish (void) {
-  switch(input_mode) {
-    case UC_OSX:
-    case UC_WIN:
-      unregister_code(KC_LALT);
-      break;
-    case UC_LNX:
-      register_code(KC_SPC);
-      unregister_code(KC_SPC);
-      break;
-  }
-
-  // reregister previously set mods
-  if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
-  if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
-  if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
-  if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
-  if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
-  if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
-  if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
-  if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
-}
-
-void register_hex(uint16_t hex) {
-  for(int i = 3; i >= 0; i--) {
-    uint8_t digit = ((hex >> (i*4)) & 0xF);
-    register_code(hex_to_keycode(digit));
-    unregister_code(hex_to_keycode(digit));
-  }
-}
-
 bool process_unicode(uint16_t keycode, keyrecord_t *record) {
   if (keycode > QK_UNICODE && record->event.pressed) {
     uint16_t unicode = keycode & 0x7FFF;
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index 7ed9e54d5..4c21f11eb 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -2,130 +2,8 @@
 #define PROCESS_UNICODE_H
 
 #include "quantum.h"
-
-#define UC_OSX 0  // Mac OS X
-#define UC_LNX 1  // Linux
-#define UC_WIN 2  // Windows 'HexNumpad'
-#define UC_BSD 3  // BSD (not implemented)
-#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
-
-#ifndef UNICODE_TYPE_DELAY
-#define UNICODE_TYPE_DELAY 10
-#endif
-
-void set_unicode_input_mode(uint8_t os_target);
-uint8_t get_unicode_input_mode(void);
-void unicode_input_start(void);
-void unicode_input_finish(void);
-void register_hex(uint16_t hex);
+#include "process_unicode_common.h"
 
 bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
-#define UC_BSPC	UC(0x0008)
-
-#define UC_SPC	UC(0x0020)
-
-#define UC_EXLM	UC(0x0021)
-#define UC_DQUT	UC(0x0022)
-#define UC_HASH	UC(0x0023)
-#define UC_DLR	UC(0x0024)
-#define UC_PERC	UC(0x0025)
-#define UC_AMPR	UC(0x0026)
-#define UC_QUOT	UC(0x0027)
-#define UC_LPRN	UC(0x0028)
-#define UC_RPRN	UC(0x0029)
-#define UC_ASTR	UC(0x002A)
-#define UC_PLUS	UC(0x002B)
-#define UC_COMM	UC(0x002C)
-#define UC_DASH	UC(0x002D)
-#define UC_DOT	UC(0x002E)
-#define UC_SLSH	UC(0x002F)
-
-#define UC_0	UC(0x0030)
-#define UC_1	UC(0x0031)
-#define UC_2	UC(0x0032)
-#define UC_3	UC(0x0033)
-#define UC_4	UC(0x0034)
-#define UC_5	UC(0x0035)
-#define UC_6	UC(0x0036)
-#define UC_7	UC(0x0037)
-#define UC_8	UC(0x0038)
-#define UC_9	UC(0x0039)
-
-#define UC_COLN UC(0x003A)
-#define UC_SCLN UC(0x003B)
-#define UC_LT	UC(0x003C)
-#define UC_EQL	UC(0x003D)
-#define UC_GT	UC(0x003E)
-#define UC_QUES	UC(0x003F)
-#define UC_AT 	UC(0x0040)
-
-#define UC_A 	UC(0x0041)
-#define UC_B 	UC(0x0042)
-#define UC_C 	UC(0x0043)
-#define UC_D 	UC(0x0044)
-#define UC_E 	UC(0x0045)
-#define UC_F 	UC(0x0046)
-#define UC_G 	UC(0x0047)
-#define UC_H 	UC(0x0048)
-#define UC_I 	UC(0x0049)
-#define UC_J 	UC(0x004A)
-#define UC_K 	UC(0x004B)
-#define UC_L 	UC(0x004C)
-#define UC_M 	UC(0x004D)
-#define UC_N 	UC(0x004E)
-#define UC_O 	UC(0x004F)
-#define UC_P 	UC(0x0050)
-#define UC_Q 	UC(0x0051)
-#define UC_R 	UC(0x0052)
-#define UC_S 	UC(0x0053)
-#define UC_T 	UC(0x0054)
-#define UC_U 	UC(0x0055)
-#define UC_V 	UC(0x0056)
-#define UC_W 	UC(0x0057)
-#define UC_X 	UC(0x0058)
-#define UC_Y 	UC(0x0059)
-#define UC_Z 	UC(0x005A)
-
-#define UC_LBRC	UC(0x005B)
-#define UC_BSLS	UC(0x005C)
-#define UC_RBRC	UC(0x005D)
-#define UC_CIRM	UC(0x005E)
-#define UC_UNDR	UC(0x005F)
-
-#define UC_GRV 	UC(0x0060)
-
-#define UC_a 	UC(0x0061)
-#define UC_b 	UC(0x0062)
-#define UC_c 	UC(0x0063)
-#define UC_d 	UC(0x0064)
-#define UC_e 	UC(0x0065)
-#define UC_f 	UC(0x0066)
-#define UC_g 	UC(0x0067)
-#define UC_h 	UC(0x0068)
-#define UC_i 	UC(0x0069)
-#define UC_j 	UC(0x006A)
-#define UC_k 	UC(0x006B)
-#define UC_l 	UC(0x006C)
-#define UC_m 	UC(0x006D)
-#define UC_n 	UC(0x006E)
-#define UC_o 	UC(0x006F)
-#define UC_p 	UC(0x0070)
-#define UC_q 	UC(0x0071)
-#define UC_r 	UC(0x0072)
-#define UC_s 	UC(0x0073)
-#define UC_t 	UC(0x0074)
-#define UC_u 	UC(0x0075)
-#define UC_v 	UC(0x0076)
-#define UC_w 	UC(0x0077)
-#define UC_x 	UC(0x0078)
-#define UC_y 	UC(0x0079)
-#define UC_z 	UC(0x007A)
-
-#define UC_LCBR	UC(0x007B)
-#define UC_PIPE	UC(0x007C)
-#define UC_RCBR	UC(0x007D)
-#define UC_TILD	UC(0x007E)
-#define UC_DEL	UC(0x007F)
-
 #endif
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
new file mode 100644
index 000000000..171ecbca1
--- /dev/null
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -0,0 +1,130 @@
+#ifndef PROCESS_UNICODE_COMMON_H
+#define PROCESS_UNICODE_COMMON_H
+
+#include "quantum.h"
+
+#ifndef UNICODE_TYPE_DELAY
+#define UNICODE_TYPE_DELAY 10
+#endif
+
+void set_unicode_input_mode(uint8_t os_target);
+uint8_t get_unicode_input_mode(void);
+void unicode_input_start(void);
+void unicode_input_finish(void);
+void register_hex(uint16_t hex);
+
+
+#define UC_OSX 0  // Mac OS X
+#define UC_LNX 1  // Linux
+#define UC_WIN 2  // Windows 'HexNumpad'
+#define UC_BSD 3  // BSD (not implemented)
+#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
+
+#define UC_BSPC	UC(0x0008)
+
+#define UC_SPC	UC(0x0020)
+
+#define UC_EXLM	UC(0x0021)
+#define UC_DQUT	UC(0x0022)
+#define UC_HASH	UC(0x0023)
+#define UC_DLR	UC(0x0024)
+#define UC_PERC	UC(0x0025)
+#define UC_AMPR	UC(0x0026)
+#define UC_QUOT	UC(0x0027)
+#define UC_LPRN	UC(0x0028)
+#define UC_RPRN	UC(0x0029)
+#define UC_ASTR	UC(0x002A)
+#define UC_PLUS	UC(0x002B)
+#define UC_COMM	UC(0x002C)
+#define UC_DASH	UC(0x002D)
+#define UC_DOT	UC(0x002E)
+#define UC_SLSH	UC(0x002F)
+
+#define UC_0	UC(0x0030)
+#define UC_1	UC(0x0031)
+#define UC_2	UC(0x0032)
+#define UC_3	UC(0x0033)
+#define UC_4	UC(0x0034)
+#define UC_5	UC(0x0035)
+#define UC_6	UC(0x0036)
+#define UC_7	UC(0x0037)
+#define UC_8	UC(0x0038)
+#define UC_9	UC(0x0039)
+
+#define UC_COLN UC(0x003A)
+#define UC_SCLN UC(0x003B)
+#define UC_LT	UC(0x003C)
+#define UC_EQL	UC(0x003D)
+#define UC_GT	UC(0x003E)
+#define UC_QUES	UC(0x003F)
+#define UC_AT 	UC(0x0040)
+
+#define UC_A 	UC(0x0041)
+#define UC_B 	UC(0x0042)
+#define UC_C 	UC(0x0043)
+#define UC_D 	UC(0x0044)
+#define UC_E 	UC(0x0045)
+#define UC_F 	UC(0x0046)
+#define UC_G 	UC(0x0047)
+#define UC_H 	UC(0x0048)
+#define UC_I 	UC(0x0049)
+#define UC_J 	UC(0x004A)
+#define UC_K 	UC(0x004B)
+#define UC_L 	UC(0x004C)
+#define UC_M 	UC(0x004D)
+#define UC_N 	UC(0x004E)
+#define UC_O 	UC(0x004F)
+#define UC_P 	UC(0x0050)
+#define UC_Q 	UC(0x0051)
+#define UC_R 	UC(0x0052)
+#define UC_S 	UC(0x0053)
+#define UC_T 	UC(0x0054)
+#define UC_U 	UC(0x0055)
+#define UC_V 	UC(0x0056)
+#define UC_W 	UC(0x0057)
+#define UC_X 	UC(0x0058)
+#define UC_Y 	UC(0x0059)
+#define UC_Z 	UC(0x005A)
+
+#define UC_LBRC	UC(0x005B)
+#define UC_BSLS	UC(0x005C)
+#define UC_RBRC	UC(0x005D)
+#define UC_CIRM	UC(0x005E)
+#define UC_UNDR	UC(0x005F)
+
+#define UC_GRV 	UC(0x0060)
+
+#define UC_a 	UC(0x0061)
+#define UC_b 	UC(0x0062)
+#define UC_c 	UC(0x0063)
+#define UC_d 	UC(0x0064)
+#define UC_e 	UC(0x0065)
+#define UC_f 	UC(0x0066)
+#define UC_g 	UC(0x0067)
+#define UC_h 	UC(0x0068)
+#define UC_i 	UC(0x0069)
+#define UC_j 	UC(0x006A)
+#define UC_k 	UC(0x006B)
+#define UC_l 	UC(0x006C)
+#define UC_m 	UC(0x006D)
+#define UC_n 	UC(0x006E)
+#define UC_o 	UC(0x006F)
+#define UC_p 	UC(0x0070)
+#define UC_q 	UC(0x0071)
+#define UC_r 	UC(0x0072)
+#define UC_s 	UC(0x0073)
+#define UC_t 	UC(0x0074)
+#define UC_u 	UC(0x0075)
+#define UC_v 	UC(0x0076)
+#define UC_w 	UC(0x0077)
+#define UC_x 	UC(0x0078)
+#define UC_y 	UC(0x0079)
+#define UC_z 	UC(0x007A)
+
+#define UC_LCBR	UC(0x007B)
+#define UC_PIPE	UC(0x007C)
+#define UC_RCBR	UC(0x007D)
+#define UC_TILD	UC(0x007E)
+#define UC_DEL	UC(0x007F)
+
+#endif
\ No newline at end of file
diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c
index b8cdeaa97..37f10df86 100644
--- a/quantum/process_keycode/process_unicodemap.c
+++ b/quantum/process_keycode/process_unicodemap.c
@@ -1,4 +1,4 @@
-#include "process_unicode_map.h"
+#include "process_unicodemap.h"
 
 __attribute__((weak))
 const uint32_t PROGMEM unicode_map[] = {
diff --git a/quantum/process_keycode/process_unicodemap.h b/quantum/process_keycode/process_unicodemap.h
index 291bd8de0..64a7a0109 100644
--- a/quantum/process_keycode/process_unicodemap.h
+++ b/quantum/process_keycode/process_unicodemap.h
@@ -2,6 +2,7 @@
 #define PROCESS_UNICODEMAP_H
 
 #include "quantum.h"
+#include "process_unicode_common.h"
 
 void unicode_map_input_error(void);
 bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
-- 
cgit v1.2.3


From 1bb574fe48bf73af4f3a4dadcff62599fd5dbb9a Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 15 Feb 2017 17:09:47 -0500
Subject: add unicode common file, get names right

---
 quantum/process_keycode/process_unicode_common.c | 86 ++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 quantum/process_keycode/process_unicode_common.c

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
new file mode 100644
index 000000000..1a9d470c9
--- /dev/null
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -0,0 +1,86 @@
+#include "process_unicode_common.h"
+
+static uint8_t input_mode;
+uint8_t mods;
+
+void set_unicode_input_mode(uint8_t os_target)
+{
+  input_mode = os_target;
+}
+
+uint8_t get_unicode_input_mode(void) {
+  return input_mode;
+}
+
+__attribute__((weak))
+void unicode_input_start (void) {
+  // save current mods
+  mods = keyboard_report->mods;
+
+  // unregister all mods to start from clean state
+  if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
+  if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
+  if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
+  if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
+  if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
+  if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
+  if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
+  if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
+
+  switch(input_mode) {
+  case UC_OSX:
+    register_code(KC_LALT);
+    break;
+  case UC_LNX:
+    register_code(KC_LCTL);
+    register_code(KC_LSFT);
+    register_code(KC_U);
+    unregister_code(KC_U);
+    unregister_code(KC_LSFT);
+    unregister_code(KC_LCTL);
+    break;
+  case UC_WIN:
+    register_code(KC_LALT);
+    register_code(KC_PPLS);
+    unregister_code(KC_PPLS);
+    break;
+  case UC_WINC:
+    register_code(KC_RALT);
+    unregister_code(KC_RALT);
+    register_code(KC_U);
+    unregister_code(KC_U);
+  }
+  wait_ms(UNICODE_TYPE_DELAY);
+}
+
+__attribute__((weak))
+void unicode_input_finish (void) {
+  switch(input_mode) {
+    case UC_OSX:
+    case UC_WIN:
+      unregister_code(KC_LALT);
+      break;
+    case UC_LNX:
+      register_code(KC_SPC);
+      unregister_code(KC_SPC);
+      break;
+  }
+
+  // reregister previously set mods
+  if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
+  if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
+  if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
+  if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
+  if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
+  if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
+  if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
+  if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
+}
+
+void register_hex(uint16_t hex) {
+  for(int i = 3; i >= 0; i--) {
+    uint8_t digit = ((hex >> (i*4)) & 0xF);
+    register_code(hex_to_keycode(digit));
+    unregister_code(hex_to_keycode(digit));
+  }
+}
\ No newline at end of file
-- 
cgit v1.2.3


From c2a9acffd712145dc8b924005feb060c5ac3e2ff Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 15 Feb 2017 17:39:51 -0500
Subject: publicise variables

---
 quantum/process_keycode/process_unicode_common.c | 3 ---
 quantum/process_keycode/process_unicode_common.h | 4 +++-
 2 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
index 1a9d470c9..baeee6d08 100644
--- a/quantum/process_keycode/process_unicode_common.c
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -1,8 +1,5 @@
 #include "process_unicode_common.h"
 
-static uint8_t input_mode;
-uint8_t mods;
-
 void set_unicode_input_mode(uint8_t os_target)
 {
   input_mode = os_target;
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
index 171ecbca1..9c26cfb07 100644
--- a/quantum/process_keycode/process_unicode_common.h
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -7,13 +7,15 @@
 #define UNICODE_TYPE_DELAY 10
 #endif
 
+static uint8_t input_mode;
+uint8_t mods;
+
 void set_unicode_input_mode(uint8_t os_target);
 uint8_t get_unicode_input_mode(void);
 void unicode_input_start(void);
 void unicode_input_finish(void);
 void register_hex(uint16_t hex);
 
-
 #define UC_OSX 0  // Mac OS X
 #define UC_LNX 1  // Linux
 #define UC_WIN 2  // Windows 'HexNumpad'
-- 
cgit v1.2.3


From f89499e255afbe5f8adeae5e71367f3d358af527 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 15 Feb 2017 18:14:07 -0500
Subject: unique variable name

---
 quantum/process_keycode/process_unicode_common.c | 36 ++++++++++++------------
 quantum/process_keycode/process_unicode_common.h |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
index baeee6d08..d924c364a 100644
--- a/quantum/process_keycode/process_unicode_common.c
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -12,17 +12,17 @@ uint8_t get_unicode_input_mode(void) {
 __attribute__((weak))
 void unicode_input_start (void) {
   // save current mods
-  mods = keyboard_report->mods;
+  unicode_mods = keyboard_report->mods;
 
   // unregister all mods to start from clean state
-  if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
-  if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
-  if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
-  if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
-  if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
-  if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
-  if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
-  if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
+  if (unicode_mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
+  if (unicode_mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
+  if (unicode_mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
+  if (unicode_mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
+  if (unicode_mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
+  if (unicode_mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
+  if (unicode_mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
+  if (unicode_mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
 
   switch(input_mode) {
   case UC_OSX:
@@ -63,15 +63,15 @@ void unicode_input_finish (void) {
       break;
   }
 
-  // reregister previously set mods
-  if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
-  if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
-  if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
-  if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
-  if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
-  if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
-  if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
-  if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
+  // reregister previously set unicode_mods
+  if (unicode_mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
+  if (unicode_mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
+  if (unicode_mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
+  if (unicode_mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
+  if (unicode_mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
+  if (unicode_mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
+  if (unicode_mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
+  if (unicode_mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
 }
 
 void register_hex(uint16_t hex) {
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
index 9c26cfb07..aa233db22 100644
--- a/quantum/process_keycode/process_unicode_common.h
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -8,7 +8,7 @@
 #endif
 
 static uint8_t input_mode;
-uint8_t mods;
+uint8_t unicode_mods;
 
 void set_unicode_input_mode(uint8_t os_target);
 uint8_t get_unicode_input_mode(void);
-- 
cgit v1.2.3


From 58823b4e0324f5b2861fc5a0f74f6faa3673f5dc Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Wed, 15 Feb 2017 23:20:35 -0500
Subject: fix weirdness with arm and mods

---
 quantum/process_keycode/process_unicode_common.c | 38 +++++++++++++-----------
 quantum/process_keycode/process_unicode_common.h |  1 -
 2 files changed, 20 insertions(+), 19 deletions(-)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
index d924c364a..31bc3b7ab 100644
--- a/quantum/process_keycode/process_unicode_common.c
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -1,5 +1,7 @@
 #include "process_unicode_common.h"
 
+uint8_t mods;
+
 void set_unicode_input_mode(uint8_t os_target)
 {
   input_mode = os_target;
@@ -12,17 +14,17 @@ uint8_t get_unicode_input_mode(void) {
 __attribute__((weak))
 void unicode_input_start (void) {
   // save current mods
-  unicode_mods = keyboard_report->mods;
+  mods = keyboard_report->mods;
 
   // unregister all mods to start from clean state
-  if (unicode_mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
-  if (unicode_mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
-  if (unicode_mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
-  if (unicode_mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
-  if (unicode_mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
-  if (unicode_mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
-  if (unicode_mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
-  if (unicode_mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
+  if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
+  if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
+  if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
+  if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
+  if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
+  if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
+  if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
+  if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
 
   switch(input_mode) {
   case UC_OSX:
@@ -63,15 +65,15 @@ void unicode_input_finish (void) {
       break;
   }
 
-  // reregister previously set unicode_mods
-  if (unicode_mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
-  if (unicode_mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
-  if (unicode_mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
-  if (unicode_mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
-  if (unicode_mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
-  if (unicode_mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
-  if (unicode_mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
-  if (unicode_mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
+  // reregister previously set mods
+  if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
+  if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
+  if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
+  if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
+  if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
+  if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
+  if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
+  if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
 }
 
 void register_hex(uint16_t hex) {
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
index aa233db22..1f25eae7d 100644
--- a/quantum/process_keycode/process_unicode_common.h
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -8,7 +8,6 @@
 #endif
 
 static uint8_t input_mode;
-uint8_t unicode_mods;
 
 void set_unicode_input_mode(uint8_t os_target);
 uint8_t get_unicode_input_mode(void);
-- 
cgit v1.2.3


From 1ac5dc9e524444ef98cfab1d9822151a6bfb9621 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Thu, 16 Feb 2017 11:37:46 -0500
Subject: fix travis and reduce warnings

---
 quantum/process_keycode/process_unicode_common.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'quantum/process_keycode')

diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
index 1f25eae7d..864693cdd 100644
--- a/quantum/process_keycode/process_unicode_common.h
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -7,6 +7,7 @@
 #define UNICODE_TYPE_DELAY 10
 #endif
 
+__attribute__ ((unused))
 static uint8_t input_mode;
 
 void set_unicode_input_mode(uint8_t os_target);
-- 
cgit v1.2.3