#include "debug.h"
#include "action.h"
-#define Kdebug(s) do { if (debug_keyboard) debug(s); } while(0)
-#define Kdebug_P(s) do { if (debug_keyboard) debug_P(s); } while(0)
-#define Kdebug_hex(s) do { if (debug_keyboard) debug_hex(s); } while(0)
-/*
- *
- * Event/State|IDLE PRESSING DELAYING[f] WAITING[f,k]
- * -----------+------------------------------------------------------------------
- * Fn Down |(L+) -*1 WAITING(Sk) IDLE(Rf,Ps)*7
- * Up |(L-) IDLE(L-)*8 IDLE(L-)*8 IDLE(L-)*8
- * Fnk Down |DELAYING(Sf)* (Rf) WAITING(Sk) IDLE(Rf,Ps,Rf)
- * Up |(L-) IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3
- * Key Down |PRESSING(Rk) (Rk) WAITING(Sk) IDLE(Rf,Ps,Rk)
- * Up |(Uk) IDLE(Uk)*4 (Uk) IDLE(L+,Ps,Pk)/(Uk)*a
- * |
- * Delay |- - IDLE(L+) IDLE(L+,Ps)
- * Magic Key |COMMAND*5
- *
- * *1: ignore Fn if other key is down.
- * *2: register Fnk if any key is pressing
- * *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
- * *4: if no keys registered to host
- * *5: unregister all keys
- * *6: only if no keys down
- * *7: ignore Fn because Fnk key and stored key are down.
- * *8: move to IDLE if layer switch(off) occurs, else stay at current state
- * *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
- * *a: layer switch and process waiting key and code if code == wainting key, else unregister key
- *
- * States:
- * IDLE: No key is down except modifiers
- * DELAYING: delay layer switch after pressing Fn with alt keycode
- * WAITING: key is pressed during DELAYING
- *
- * Events:
- * Fn: Fn key without alternative keycode
- * Fnk: Fn key with alternative keycode
- * -: ignore
- * Delay: layer switch delay term is elapsed
- *
- * Actions:
- * Rk: register key
- * Uk: unregister key
- * Rf: register Fn(alt keycode)
- * Uf: unregister Fn(alt keycode)
- * Rs: register stored key
- * Us: unregister stored key
- * Sk: Store key(waiting Key)
- * Sf: Store Fn(delayed Fn)
- * Ps: Process stored key
- * Ps: Process key
- * Is: Interpret stored keys in current layer
- * L+: Switch to new layer(*unregister* all keys but modifiers)
- * L-: Switch back to last layer(*unregister* all keys but modifiers)
- * Ld: Switch back to default layer(*unregister* all keys but modifiers)
- */
-
-
-typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
-#define NEXT(state) do { \
- Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
- kbdstate = state; \
- Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
-} while (0)
-
-
-static kbdstate_t kbdstate = IDLE;
-static uint8_t fn_state_bits = 0;
-
-static const char *state_str(kbdstate_t state)
-{
- if (state == IDLE) return PSTR("IDLE");
- if (state == DELAYING) return PSTR("DELAYING");
- if (state == WAITING) return PSTR("WAITING");
- if (state == PRESSING) return PSTR("PRESSING");
- return PSTR("UNKNOWN");
-}
-static bool anykey_sent_to_host(void)
-{
- return (host_has_anykey() || host_mouse_in_use() ||
- host_last_sysytem_report() || host_last_consumer_report());
-}
-
+static void process(keyevent_t event, action_t action);
static void register_code(uint8_t code);
static void unregister_code(uint8_t code);
-static void register_mods(uint8_t mods);
-static void unregister_mods(uint8_t mods);
static void clear_keyboard(void);
static void clear_keyboard_but_mods(void);
+static bool sending_anykey(void);
static void layer_switch(uint8_t new_layer);
/* tap */
#define TAP_TIME 200
-#define LAYER_DELAY 200
static keyevent_t last_event = {};
static uint16_t last_event_time = 0;
static uint8_t tap_count = 0;
uint8_t current_layer = 0;
keyrecord_t delaying_layer = {};
-keyrecord_t waiting_key = {};
-
-// TODO: ring buffer: waiting_keys[]
-/*
#define WAITING_KEYS_BUFFER 3
static keyrecord_t waiting_keys[WAITING_KEYS_BUFFER] = {};
static uint8_t waiting_keys_head = 0;
-static uint8_t waiting_keys_tail = 0;
-static void waiting_key_queue(keyevent_t event)
+static bool waiting_keys_enqueue(keyevent_t event, action_t action)
{
+ debug("waiting_keys["); debug_dec(waiting_keys_head); debug("] = ");
+ debug_hex16(action.code); debug("\n");
+ if (waiting_keys_head < WAITING_KEYS_BUFFER) {
+ waiting_keys[waiting_keys_head++] = (keyrecord_t){ .event = event,
+ .action = action,
+ .mods = host_get_mods() };
+ } else {
+ return true;
+ }
}
-static void waiting_key_dequeue(keyevent_t event)
+static void waiting_keys_clear(void)
{
+ waiting_keys_head = 0;
}
-*/
+static bool waiting_keys_has(keypos_t key)
+{
+ for (uint8_t i = 0; i < waiting_keys_head; i++) {
+ if KEYEQ(key, waiting_keys[i].event.key) return true;
+ }
+ return false;
+}
+static void waiting_keys_process_in_current_layer(void)
+{
+ // TODO: in case of including layer key in waiting keys
+ uint8_t tmp_mods = host_get_mods();
+ for (uint8_t i = 0; i < waiting_keys_head; i++) {
+ /* revive status of mods */
+ host_set_mods(waiting_keys[i].mods);
+ process(waiting_keys[i].event, keymap_get_action(current_layer,
+ waiting_keys[i].event.key.row,
+ waiting_keys[i].event.key.col));
+ debug("waiting_keys_process_in_current_layer["); debug_dec(i); debug("]\n");
+ }
+ host_set_mods(tmp_mods);
+ waiting_keys_clear();
+}
+
static void process(keyevent_t event, action_t action)
{
//action_t action = keymap_get_action(current_layer, event.key.row, event.key.col);
-
debug("action: "); debug_hex16(action.code); debug("\n");
- debug("kind.id: "); debug_hex(action.kind.id); debug("\n");
- debug("kind.param: "); debug_hex16(action.kind.param); debug("\n");
- debug("key.code: "); debug_hex(action.key.code); debug("\n");
- debug("key.mods: "); debug_hex(action.key.mods); debug("\n");
+
switch (action.kind.id) {
/* Key and Mods */
break;
default:
// with tap key
- debug("tap: "); debug_hex(tap_count); debug("\n");
if (event.pressed) {
if (tap_count == 0) {
if (host_has_anykey()) {
register_code(action.layer.code);
} else {
+ debug("Delay switching layer("); debug_hex8(action.layer.opt); debug(")\n");
delaying_layer = (keyrecord_t){
.event = event,
.action = action,
};
}
} else if (tap_count > 0) {
+ debug("tap: "); debug_hex(tap_count); debug("\n");
register_code(action.layer.code);
}
} else {
// tap key
if (KEYEQ(event.key, delaying_layer.event.key) &&
- timer_elapsed(delaying_layer.event.time) < TAP_TIME) {
+ timer_elapsed(delaying_layer.event.time) <= TAP_TIME) {
uint8_t tmp_mods = host_get_mods();
host_set_mods(delaying_layer.mods);
register_code(delaying_layer.action.layer.code);
break;
default:
// with tap key
- debug("tap: "); debug_hex(tap_count); debug("\n");
if (event.pressed) {
if (tap_count == 0) {
if (host_has_anykey()) {
};
}
} else if (tap_count > 0) {
+ debug("tap: "); debug_hex(tap_count); debug("\n");
register_code(action.layer.code);
}
} else {
void action_exec(keyevent_t event)
{
- /* count tap when key is up */
- if (KEYEQ(event.key, last_event.key) && timer_elapsed(last_event_time) < TAP_TIME) {
- if (!event.pressed) tap_count++;
- } else {
- tap_count = 0;
- }
+/*
+ debug("key["); debug_hex8(event.key.row); debug(":"); debug_hex8(event.key.col);
+ if (event.pressed) debug("]down\n"); else debug("]up\n");
+*/
/* When delaying layer switch */
if (delaying_layer.action.code) {
- /* Layer switch when delay time elapses or waiting key is released */
- if ((timer_elapsed(delaying_layer.event.time) > LAYER_DELAY) ||
- (!event.pressed && KEYEQ(event.key, waiting_key.event.key))) {
+ /* Layer switch when tap time elapses or waiting key is released */
+ if ((timer_elapsed(delaying_layer.event.time) > TAP_TIME) ||
+ (!event.pressed && waiting_keys_has(event.key))) {
/* layer switch */
switch (delaying_layer.action.kind.id) {
case ACT_LAYER_PRESSED:
delaying_layer = (keyrecord_t){};
/* Process waiting keys in new layer */
- if (waiting_key.event.time) {
- uint8_t tmp_mods = host_get_mods();
- host_set_mods(waiting_key.mods);
- process(waiting_key.event, keymap_get_action(current_layer,
- waiting_key.event.key.row,
- waiting_key.event.key.col));
- host_set_mods(tmp_mods);
- waiting_key = (keyrecord_t){};
- }
+ waiting_keys_process_in_current_layer();
}
/* when delaying layer key is released within delay term */
else if (!event.pressed && KEYEQ(event.key, delaying_layer.event.key)) {
host_set_mods(delaying_layer.mods);
register_code(delaying_layer.action.layer.code);
delaying_layer = (keyrecord_t){};
+ host_set_mods(tmp_mods);
/* process waiting keys */
- if (waiting_key.event.time) {
- host_set_mods(waiting_key.mods);
- process(waiting_key.event, waiting_key.action);
- waiting_key = (keyrecord_t){};
- }
- host_set_mods(tmp_mods);
+ waiting_keys_process_in_current_layer();
}
}
+ // not real event. event just to update delaying layer.
+ if (IS_NOEVENT(event)) {
+ return;
+ }
+
+ /* count tap when key is up */
+ if (KEYEQ(event.key, last_event.key) && timer_elapsed(last_event.time) <= TAP_TIME) {
+ if (!event.pressed) tap_count++;
+ } else {
+ tap_count = 0;
+ }
+
action_t action = keymap_get_action(current_layer, event.key.row, event.key.col);
+ // TODO: all key events(pressed, released) should be recorded?
/* postpone key-down events while delaying layer */
if (delaying_layer.action.code) {
if (event.pressed) {
- // TODO: waiting_keys[]
- waiting_key = (keyrecord_t){
- .event = event,
- .action = action,
- .mods = host_get_mods()
- };
+ waiting_keys_enqueue(event, action);
} else {
process(event, action);
}
/* last event */
last_event = event;
- last_event_time = timer_read();
}
}
}
-static void register_mods(uint8_t mods)
-{
- if (!mods) return;
- host_add_mods(mods);
- host_send_keyboard_report();
-}
-
-static void unregister_mods(uint8_t mods)
-{
- if (!mods) return;
- host_del_mods(mods);
- host_send_keyboard_report();
-}
-
static void clear_keyboard(void)
{
host_clear_mods();
#endif
}
+static bool sending_anykey(void)
+{
+ return (host_has_anykey() || host_mouse_in_use() ||
+ host_last_sysytem_report() || host_last_consumer_report());
+}
+
static void layer_switch(uint8_t new_layer)
{
if (current_layer != new_layer) {
- Kdebug("Layer Switch: "); Kdebug_hex(current_layer);
- Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
+ debug("Layer Switch: "); debug_hex(current_layer);
+ debug(" -> "); debug_hex(new_layer); debug("\n");
current_layer = new_layer;
clear_keyboard_but_mods(); // To avoid stuck keys
projects / max / tmk_keyboard.git / commitdiff