15 static void process(keyevent_t event, action_t action);
16 static void register_code(uint8_t code);
17 static void unregister_code(uint8_t code);
18 static void clear_keyboard(void);
19 static void clear_keyboard_but_mods(void);
20 static bool sending_anykey(void);
21 static void layer_switch(uint8_t new_layer);
26 static keyevent_t last_event = {};
27 static uint16_t last_event_time = 0;
28 static uint8_t tap_count = 0;
31 uint8_t default_layer = 0;
32 uint8_t current_layer = 0;
33 keyrecord_t delaying_layer = {};
35 #define WAITING_KEYS_BUFFER 3
36 static keyrecord_t waiting_keys[WAITING_KEYS_BUFFER] = {};
37 static uint8_t waiting_keys_head = 0;
38 static bool waiting_keys_enqueue(keyevent_t event, action_t action)
40 debug("waiting_keys["); debug_dec(waiting_keys_head); debug("] = ");
41 debug_hex16(action.code); debug("\n");
42 if (waiting_keys_head < WAITING_KEYS_BUFFER) {
43 waiting_keys[waiting_keys_head++] = (keyrecord_t){ .event = event,
45 .mods = host_get_mods() };
50 static void waiting_keys_clear(void)
52 waiting_keys_head = 0;
54 static bool waiting_keys_has(keypos_t key)
56 for (uint8_t i = 0; i < waiting_keys_head; i++) {
57 if KEYEQ(key, waiting_keys[i].event.key) return true;
61 static void waiting_keys_process_in_current_layer(void)
63 // TODO: in case of including layer key in waiting keys
64 uint8_t tmp_mods = host_get_mods();
65 for (uint8_t i = 0; i < waiting_keys_head; i++) {
66 /* revive status of mods */
67 host_set_mods(waiting_keys[i].mods);
68 process(waiting_keys[i].event, keymap_get_action(current_layer,
69 waiting_keys[i].event.key.row,
70 waiting_keys[i].event.key.col));
71 debug("waiting_keys_process_in_current_layer["); debug_dec(i); debug("]\n");
73 host_set_mods(tmp_mods);
78 static void process(keyevent_t event, action_t action)
80 //action_t action = keymap_get_action(current_layer, event.key.row, event.key.col);
81 debug("action: "); debug_hex16(action.code); debug("\n");
84 switch (action.kind.id) {
87 // normal key or key plus mods
89 uint8_t tmp_mods = host_get_mods();
90 if (action.key.mods) {
91 host_add_mods(action.key.mods);
92 host_send_keyboard_report();
94 register_code(action.key.code);
95 if (action.key.mods && action.key.code) {
96 host_set_mods(tmp_mods);
97 host_send_keyboard_report();
100 if (action.key.mods && !action.key.code) {
101 host_del_mods(action.key.mods);
102 host_send_keyboard_report();
104 unregister_code(action.key.code);
109 uint8_t tmp_mods = host_get_mods();
110 if (action.key.mods) {
111 host_add_mods(action.key.mods<<4);
112 host_send_keyboard_report();
114 register_code(action.key.code);
115 if (action.key.mods && action.key.code) {
116 host_set_mods(tmp_mods);
117 host_send_keyboard_report();
120 if (action.key.mods && !action.key.code) {
121 host_del_mods(action.key.mods<<4);
122 host_send_keyboard_report();
124 unregister_code(action.key.code);
132 /* other HID usage */
134 #ifdef EXTRAKEY_ENABLE
135 switch (action.usage.page) {
136 case ACTION_USAGE_PAGE_SYSTEM:
138 host_system_send(action.usage.code);
143 case ACTION_USAGE_PAGE_CONSUMER:
145 host_consumer_send(action.usage.code);
147 host_consumer_send(0);
156 #ifdef MOUSEKEY_ENABLE
158 mousekey_on(action.key.code);
161 mousekey_off(action.key.code);
168 case ACT_LAYER_PRESSED:
169 // layer action when pressed
170 switch (action.layer.code) {
173 layer_switch(action.layer.opt);
181 default_layer = action.layer.opt;
182 layer_switch(default_layer);
188 if (tap_count == 0) {
189 if (host_has_anykey()) {
190 register_code(action.layer.code);
192 debug("Delay switching layer("); debug_hex8(action.layer.opt); debug(")\n");
193 delaying_layer = (keyrecord_t){
196 .mods = host_get_mods()
199 } else if (tap_count > 0) {
200 debug("tap: "); debug_hex(tap_count); debug("\n");
201 register_code(action.layer.code);
205 if (KEYEQ(event.key, delaying_layer.event.key) &&
206 timer_elapsed(delaying_layer.event.time) <= TAP_TIME) {
207 uint8_t tmp_mods = host_get_mods();
208 host_set_mods(delaying_layer.mods);
209 register_code(delaying_layer.action.layer.code);
210 host_set_mods(tmp_mods);
211 unregister_code(delaying_layer.action.layer.code);
213 unregister_code(action.layer.code);
215 delaying_layer = (keyrecord_t){};
220 case ACT_LAYER_RELEASED:
221 switch (action.layer.code) {
224 layer_switch(action.layer.opt);
228 // Ignored. LAYER_RELEASED with tap toggle is invalid action.
231 if (!event.pressed) {
232 default_layer = action.layer.opt;
233 layer_switch(default_layer);
237 // Ignored. LAYER_RELEASED with tap key is invalid action.
242 switch (action.layer.code) {
245 layer_switch(current_layer | action.layer.opt);
247 layer_switch(current_layer & ~action.layer.opt);
254 // change default layer
256 default_layer = current_layer | action.layer.opt;
257 layer_switch(default_layer);
259 default_layer = current_layer & ~action.layer.opt;
260 layer_switch(default_layer);
266 if (tap_count == 0) {
267 if (host_has_anykey()) {
268 register_code(action.layer.code);
270 delaying_layer = (keyrecord_t){
273 .mods = keyboard_report->mods
276 } else if (tap_count > 0) {
277 debug("tap: "); debug_hex(tap_count); debug("\n");
278 register_code(action.layer.code);
281 if (tap_count == 0) {
283 layer_switch(current_layer & ~action.layer.opt);
284 } else if (tap_count == 1) {
286 register_code(action.layer.code);
288 unregister_code(action.layer.code);
293 switch (action.layer.opt) {
295 // set default layer when pressed
296 switch (action.layer.code) {
299 layer_switch(default_layer);
307 default_layer = current_layer;
308 layer_switch(default_layer);
317 // set default layer when released
318 switch (action.layer.code) {
320 if (!event.pressed) {
321 layer_switch(default_layer);
325 if (!event.pressed) {
326 default_layer = current_layer;
327 layer_switch(default_layer);
333 if (!event.pressed) {
334 layer_switch(default_layer);
351 void action_exec(keyevent_t event)
354 debug("key["); debug_hex8(event.key.row); debug(":"); debug_hex8(event.key.col);
355 if (event.pressed) debug("]down\n"); else debug("]up\n");
358 /* When delaying layer switch */
359 if (delaying_layer.action.code) {
360 /* Layer switch when tap time elapses or waiting key is released */
361 if ((timer_elapsed(delaying_layer.event.time) > TAP_TIME) ||
362 (!event.pressed && waiting_keys_has(event.key))) {
364 switch (delaying_layer.action.kind.id) {
365 case ACT_LAYER_PRESSED:
366 layer_switch(delaying_layer.action.layer.opt);
369 layer_switch(current_layer | delaying_layer.action.layer.opt);
372 delaying_layer = (keyrecord_t){};
374 /* Process waiting keys in new layer */
375 waiting_keys_process_in_current_layer();
377 /* when delaying layer key is released within delay term */
378 else if (!event.pressed && KEYEQ(event.key, delaying_layer.event.key)) {
380 uint8_t tmp_mods = host_get_mods();
381 host_set_mods(delaying_layer.mods);
382 register_code(delaying_layer.action.layer.code);
383 delaying_layer = (keyrecord_t){};
384 host_set_mods(tmp_mods);
386 /* process waiting keys */
387 waiting_keys_process_in_current_layer();
391 // not real event. event just to update delaying layer.
392 if (IS_NOEVENT(event)) {
396 /* count tap when key is up */
397 if (KEYEQ(event.key, last_event.key) && timer_elapsed(last_event.time) <= TAP_TIME) {
398 if (!event.pressed) tap_count++;
403 action_t action = keymap_get_action(current_layer, event.key.row, event.key.col);
405 // TODO: all key events(pressed, released) should be recorded?
406 /* postpone key-down events while delaying layer */
407 if (delaying_layer.action.code) {
409 waiting_keys_enqueue(event, action);
411 process(event, action);
414 process(event, action);
422 static void register_code(uint8_t code)
427 else if IS_KEY(code) {
428 // TODO: should push command_proc out of this block?
429 if (!command_proc(code)) {
431 host_send_keyboard_report();
434 else if IS_MOD(code) {
435 host_add_mods(MOD_BIT(code));
436 host_send_keyboard_report();
440 static void unregister_code(uint8_t code)
444 host_send_keyboard_report();
446 else if IS_MOD(code) {
447 host_del_mods(MOD_BIT(code));
448 host_send_keyboard_report();
452 static void clear_keyboard(void)
455 clear_keyboard_but_mods();
458 static void clear_keyboard_but_mods(void)
461 host_send_keyboard_report();
462 #ifdef MOUSEKEY_ENABLE
466 #ifdef EXTRAKEY_ENABLE
468 host_consumer_send(0);
472 static bool sending_anykey(void)
474 return (host_has_anykey() || host_mouse_in_use() ||
475 host_last_sysytem_report() || host_last_consumer_report());
478 static void layer_switch(uint8_t new_layer)
480 if (current_layer != new_layer) {
481 debug("Layer Switch: "); debug_hex(current_layer);
482 debug(" -> "); debug_hex(new_layer); debug("\n");
484 current_layer = new_layer;
485 clear_keyboard_but_mods(); // To avoid stuck keys
486 // TODO: update mods with full scan of matrix? if modifier changes between layers