#include "keymap.h"
#include "host.h"
#include "led.h"
-#include "usb_keycodes.h"
+#include "keycode.h"
#include "timer.h"
#include "print.h"
#include "debug.h"
FNK_DOWN, FNK_UP,
KEY_DOWN, KEY_UP,
MOD_DOWN, MOD_UP,
- MOUSEKEY_DOWN, MOUSEKEY_UP,
- DELAY
} keykind_t;
typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
static inline keykind_t get_keykind(uint8_t code, bool pressed)
{
- if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP);
- if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP);
+ if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP);
+ if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP);
if IS_FN(code) {
if (keymap_fn_keycode(FN_INDEX(code)))
return (pressed ? FNK_DOWN : FNK_UP);
else
return (pressed ? FN_DOWN : FN_UP);
}
- if IS_MOUSEKEY(code) return (pressed ? MOUSEKEY_DOWN : MOUSEKEY_UP);
+ if IS_MOUSEKEY(code) return (pressed ? KEY_DOWN : KEY_UP);
+ if IS_SYSTEM(code) return (pressed ? KEY_DOWN : KEY_UP);
+ if IS_CONSUMER(code) return (pressed ? KEY_DOWN : KEY_UP);
return NONE;
}
if (!IS_FN(code)) return;
fn_state_bits |= FN_BIT(code);
if (current_layer != keymap_fn_layer(FN_INDEX(code))) {
- //TODO: clear all key execpt Mod key
+ // clear all key execpt Mod key
+ host_clear_all_keys_but_mods();
+ host_system_send(0);
+ host_consumer_send(0);
+ mousekey_clear();
+ mousekey_send();
+
debug("Layer Switch(on): "); debug_hex(current_layer);
current_layer = keymap_fn_layer(FN_INDEX(code));
debug(" -> "); debug_hex(current_layer); debug("\n");
if (!IS_FN(code)) return;
fn_state_bits &= ~FN_BIT(code);
if (current_layer != keymap_fn_layer(biton(fn_state_bits))) {
- //TODO: clear all key execpt Mod key
+ // clear all key execpt Mod key
+ host_clear_all_keys_but_mods();
+ host_system_send(0);
+ host_consumer_send(0);
+ mousekey_clear();
+ mousekey_send();
+
debug("Layer Switch(off): "); debug_hex(current_layer);
current_layer = keymap_fn_layer(biton(fn_state_bits));
debug(" -> "); debug_hex(current_layer); debug("\n");
static void register_code(uint8_t code)
{
+debug("register_code\n");
if IS_KEY(code) {
host_add_key(code);
host_send_keyboard_report();
mousekey_on(code);
mousekey_send();
}
+ else if IS_CONSUMER(code) {
+debug("consumer\n");
+ uint16_t usage = 0;
+ switch (code) {
+ case KC_AUDIO_MUTE:
+ usage = AUDIO_MUTE;
+ break;
+ case KC_AUDIO_VOL_UP:
+ usage = AUDIO_VOL_UP;
+ break;
+ case KC_AUDIO_VOL_DOWN:
+ usage = AUDIO_VOL_DOWN;
+ break;
+ case KC_MEDIA_NEXT_TRACK:
+ usage = TRANSPORT_NEXT_TRACK;
+ break;
+ case KC_MEDIA_PREV_TRACK:
+ usage = TRANSPORT_PREV_TRACK;
+ break;
+ case KC_MEDIA_STOP:
+ usage = TRANSPORT_STOP;
+ break;
+ case KC_MEDIA_PLAY_PAUSE:
+ usage = TRANSPORT_PLAY_PAUSE;
+ break;
+ case KC_MEDIA_SELECT:
+ usage = AL_CC_CONFIG;
+ break;
+ case KC_MAIL:
+ usage = AL_EMAIL;
+ break;
+ case KC_CALCULATOR:
+ usage = AL_CALCULATOR;
+ break;
+ case KC_MY_COMPUTER:
+ usage = AL_LOCAL_BROWSER;
+ break;
+ case KC_WWW_SEARCH:
+ usage = AC_SEARCH;
+ break;
+ case KC_WWW_HOME:
+ usage = AC_HOME;
+ break;
+ case KC_WWW_BACK:
+ usage = AC_BACK;
+ break;
+ case KC_WWW_FORWARD:
+ usage = AC_FORWARD;
+ break;
+ case KC_WWW_STOP:
+ usage = AC_STOP;
+ break;
+ case KC_WWW_REFRESH:
+ usage = AC_REFRESH;
+ break;
+ case KC_WWW_FAVORITES:
+ usage = AC_BOOKMARKS;
+ break;
+ }
+debug("usage: "); phex16(usage); debug("\n");
+ host_consumer_send(usage);
+ }
+ else if IS_SYSTEM(code) {
+ uint16_t usage = 0;
+ switch (code) {
+ case KC_SYSTEM_POWER:
+ usage = SYSTEM_POWER_DOWN;
+ break;
+ case KC_SYSTEM_SLEEP:
+ usage = SYSTEM_SLEEP;
+ break;
+ case KC_SYSTEM_WAKE:
+ usage = SYSTEM_WAKE_UP;
+ break;
+ }
+ host_system_send(usage);
+ }
+
}
static void unregister_code(uint8_t code)
mousekey_off(code);
mousekey_send();
}
+ else if IS_CONSUMER(code) {
+ host_consumer_send(0x0000);
+ }
+ else if IS_SYSTEM(code) {
+ host_system_send(0x0000);
+ }
}
/*
* Event/State|IDLE DELAYING[f] WAITING[f,k] PRESSING
* -----------+------------------------------------------------------------------
* Fn Down |IDLE(L+) WAITING(Sk) WAITING(Sk) -
- * Up |IDLE(L-) IDLE(L-) IDLE(L-) IDLE(L-)
+ * Up |IDLE(L-) IDLE(L-) IDLE(L-) IDLE(L-)
* Fnk Down |DELAYING(Sf) WAITING(Sk) WAINTING(Sk) PRESSING(Rf)
* Up |IDLE(L-) IDLE(Rf,Uf) IDLE(Rf,Ps,Uf)*3 PRESSING(Uf)
* Key Down |PRESSING(Rk) WAITING(Sk) WAITING(Sk) PRESSING(Rk)
static inline void process_key(keyevent_t event)
{
-
/* TODO: ring buffer
static keyrecord_t waiting_keys[5];
static uint8_t waiting_keys_head = 0;
uint8_t tmp_mods;
- //debug("kbdstate: "); debug_hex(kbdstate);
debug("state: "); print_P(state_str(kbdstate));
debug(" kind: "); debug_hex(kind);
debug(" code: "); debug_hex(code);
if (event.pressed) { debug("d"); } else { debug("u"); }
debug("\n");
+
switch (kbdstate) {
case IDLE:
switch (kind) {
layer_switch_off(code);
break;
case FNK_DOWN:
- // store event
- delayed_fn = (keyrecord_t) { .event = event, .code = code, .mods = keyboard_report->mods, .time = timer_read() };
- NEXT(DELAYING);
+ // repeat Fn alt key when press Fn key down, up then down again quickly
+ if (KEYEQ(delayed_fn.event.key, event.key) &&
+ timer_elapsed(delayed_fn.time) < LAYER_DELAY) {
+ register_code(keymap_fn_keycode(FN_INDEX(code)));
+ NEXT(PRESSING);
+ } else {
+ delayed_fn = (keyrecord_t) {
+ .event = event,
+ .code = code,
+ .mods = keyboard_report->mods,
+ .time = timer_read()
+ };
+ NEXT(DELAYING);
+ }
break;
case FNK_UP:
layer_switch_off(code);
break;
case KEY_DOWN:
- case MOUSEKEY_DOWN:
register_code(code);
NEXT(PRESSING);
break;
register_code(code);
break;
case KEY_UP:
- case MOUSEKEY_UP:
case MOD_UP:
unregister_code(code);
break;
register_code(keymap_fn_keycode(FN_INDEX(code)));
break;
case FNK_UP:
+ // can't know whether layer switched or not
+ layer_switch_off(code);
unregister_code(keymap_fn_keycode(FN_INDEX(code)));
break;
case KEY_DOWN:
case MOD_DOWN:
- case MOUSEKEY_DOWN:
register_code(code);
break;
case KEY_UP:
case MOD_UP:
- case MOUSEKEY_UP:
unregister_code(code);
// no key registered? mousekey, mediakey, systemkey
if (!host_has_anykey())
case FN_DOWN:
case FNK_DOWN:
case KEY_DOWN:
- case MOUSEKEY_DOWN:
- waiting_key = (keyrecord_t) { .event = event, .code = code, .mods = keyboard_report->mods, .time = timer_read() };
+ waiting_key = (keyrecord_t) {
+ .event = event,
+ .code = code,
+ .mods = keyboard_report->mods,
+ .time = timer_read()
+ };
NEXT(WAITING);
break;
case MOD_DOWN:
}
break;
case KEY_UP:
- case MOUSEKEY_UP:
unregister_code(code);
NEXT(IDLE);
break;
case FN_DOWN:
case FNK_DOWN:
case KEY_DOWN:
- case MOUSEKEY_DOWN:
tmp_mods = keyboard_report->mods;
host_set_mods(delayed_fn.mods);
register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
}
break;
case KEY_UP:
- case MOUSEKEY_UP:
if (code == waiting_key.code) {
layer_switch_on(delayed_fn.code);
NEXT(IDLE);
matrix_row = matrix_get_row(r);
matrix_change = matrix_row ^ matrix_prev[r];
if (matrix_change) {
- // TODO: print once per scan
if (debug_matrix) matrix_print();
for (int c = 0; c < MATRIX_COLS; c++) {