X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=common%2Faction.c;h=94498fe6cb33e456069537ab9feffc721016e52c;hb=1f96edaed60def1f513ddd8adcdfa3e12b971006;hp=425a2b00ff17bc6a7e884fe2bf6774dbef5e16b2;hpb=411de9cc22e927313a5a768f3bf41f2f99bca126;p=tmk_firmware.git diff --git a/common/action.c b/common/action.c index 425a2b0..94498fe 100644 --- a/common/action.c +++ b/common/action.c @@ -1,185 +1,186 @@ +/* +Copyright 2012,2013 Jun Wako + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ #include "host.h" -#include "timer.h" -#include "keymap.h" #include "keycode.h" #include "keyboard.h" #include "mousekey.h" #include "command.h" -#include "util.h" -#include "debug.h" +#include "led.h" +#include "backlight.h" +#include "action_layer.h" +#include "action_tapping.h" +#include "action_macro.h" +#include "action_util.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) - +#ifdef DEBUG_ACTION +#include "debug.h" +#else +#include "nodebug.h" +#endif -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) +void action_exec(keyevent_t event) { - return (host_has_anykey() || host_mouse_in_use() || - host_last_sysytem_report() || host_last_consumer_report()); -} - - -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 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; + if (!IS_NOEVENT(event)) { + dprint("\n---- action_exec: start -----\n"); + dprint("EVENT: "); debug_event(event); dprintln(); + } -/* layer */ -uint8_t default_layer = 0; -uint8_t current_layer = 0; -keyrecord_t delaying_layer = {}; + keyrecord_t record = { .event = event }; +#ifndef NO_ACTION_TAPPING + action_tapping_process(record); +#else + process_action(&record); + if (!IS_NOEVENT(record.event)) { + dprint("processed: "); debug_record(record); dprintln(); + } +#endif +} -void action_exec(keyevent_t event) +void process_action(keyrecord_t *record) { - /* 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; - } + keyevent_t event = record->event; +#ifndef NO_ACTION_TAPPING + uint8_t tap_count = record->tap.count; +#endif - /* layer switch after LAYER_DELAY */ - if (delaying_layer.action.code && timer_elapsed(delaying_layer.event.time) > LAYER_DELAY) { - switch (delaying_layer.action.kind.id) { - case ACT_LAYER_PRESSED: - layer_switch(delaying_layer.action.layer.opt); - break; - case ACT_LAYER_BIT: - layer_switch(current_layer | delaying_layer.action.layer.opt); - break; - } - delaying_layer = (keyrecord_t){}; - } - action_t action = keymap_get_action(current_layer, event.key.row, event.key.col); + if (IS_NOEVENT(event)) { return; } - 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"); + action_t action = layer_switch_get_action(event.key); + dprint("ACTION: "); debug_action(action); +#ifndef NO_ACTION_LAYER + dprint(" layer_state: "); layer_debug(); + dprint(" default_layer_state: "); default_layer_debug(); +#endif + dprintln(); switch (action.kind.id) { + /* Key and Mods */ case ACT_LMODS: - // normal key or key plus mods - if (event.pressed) { - register_mods(action.key.mods); - register_code(action.key.code); - } else { - unregister_code(action.key.code); - unregister_mods(action.key.mods); - } - break; case ACT_RMODS: - if (event.pressed) { - register_mods(action.key.mods<<4); - register_code(action.key.code); - } else { - unregister_code(action.key.code); - unregister_mods(action.key.mods<<4); + { + uint8_t mods = (action.kind.id == ACT_LMODS) ? action.key.mods : + action.key.mods<<4; + if (event.pressed) { + if (mods) { + add_weak_mods(mods); + send_keyboard_report(); + } + register_code(action.key.code); + } else { + unregister_code(action.key.code); + if (mods) { + del_weak_mods(mods); + send_keyboard_report(); + } + } } break; - case ACT_LMOD_TAP: - break; - case ACT_RMOD_TAP: +#ifndef NO_ACTION_TAPPING + case ACT_LMODS_TAP: + case ACT_RMODS_TAP: + { + uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods : + action.key.mods<<4; + switch (action.layer_tap.code) { + #ifndef NO_ACTION_ONESHOT + case MODS_ONESHOT: + // Oneshot modifier + if (event.pressed) { + if (tap_count == 0) { + register_mods(mods); + } + else if (tap_count == 1) { + dprint("MODS_TAP: Oneshot: start\n"); + set_oneshot_mods(mods); + } + else { + register_mods(mods); + } + } else { + if (tap_count == 0) { + clear_oneshot_mods(); + unregister_mods(mods); + } + else if (tap_count == 1) { + // Retain Oneshot mods + } + else { + clear_oneshot_mods(); + unregister_mods(mods); + } + } + break; + #endif + case MODS_TAP_TOGGLE: + if (event.pressed) { + if (tap_count <= TAPPING_TOGGLE) { + register_mods(mods); + } + } else { + if (tap_count < TAPPING_TOGGLE) { + unregister_mods(mods); + } + } + break; + default: + if (event.pressed) { + if (tap_count > 0) { + if (record->tap.interrupted) { + dprint("MODS_TAP: Tap: Cancel: add_mods\n"); + // ad hoc: set 0 to cancel tap + record->tap.count = 0; + register_mods(mods); + } else { + dprint("MODS_TAP: Tap: register_code\n"); + register_code(action.key.code); + } + } else { + dprint("MODS_TAP: No tap: add_mods\n"); + register_mods(mods); + } + } else { + if (tap_count > 0) { + dprint("MODS_TAP: Tap: unregister_code\n"); + unregister_code(action.key.code); + } else { + dprint("MODS_TAP: No tap: add_mods\n"); + unregister_mods(mods); + } + } + break; + } + } break; - case ACT_USAGE: +#endif #ifdef EXTRAKEY_ENABLE + /* other HID usage */ + case ACT_USAGE: switch (action.usage.page) { - case ACTION_USAGE_PAGE_SYSTEM: + case PAGE_SYSTEM: if (event.pressed) { host_system_send(action.usage.code); } else { host_system_send(0); } break; - case ACTION_USAGE_PAGE_CONSUMER: + case PAGE_CONSUMER: if (event.pressed) { host_consumer_send(action.usage.code); } else { @@ -187,10 +188,11 @@ void action_exec(keyevent_t event) } break; } -#endif break; - case ACT_MOUSEKEY: +#endif #ifdef MOUSEKEY_ENABLE + /* Mouse key */ + case ACT_MOUSEKEY: if (event.pressed) { mousekey_on(action.key.code); mousekey_send(); @@ -198,241 +200,295 @@ void action_exec(keyevent_t event) mousekey_off(action.key.code); mousekey_send(); } -#endif break; - case ACT_LAYER_PRESSED: - // layer action when pressed - switch (action.layer.code) { - case 0x00: - if (event.pressed) { - layer_switch(action.layer.opt); +#endif +#ifndef NO_ACTION_LAYER + case ACT_LAYER: + if (action.layer_bitop.on == 0) { + /* Default Layer Bitwise Operation */ + if (!event.pressed) { + uint8_t shift = action.layer_bitop.part*4; + uint32_t bits = ((uint32_t)action.layer_bitop.bits)<mods - }; - } - } else if (tap_count > 0) { - register_code(action.layer.code); + if (tap_count < TAPPING_TOGGLE) { + layer_invert(action.layer_tap.val); } } else { - // type key after tap - if (tap_count == 1) { - delaying_layer = (keyrecord_t){}; - register_code(action.layer.code); + if (tap_count <= TAPPING_TOGGLE) { + layer_invert(action.layer_tap.val); } - unregister_code(action.layer.code); } break; - } - break; - case ACT_LAYER_RELEASED: - switch (action.layer.code) { - case 0x00: - if (event.pressed) { - layer_switch(action.layer.opt); - } + case OP_ON_OFF: + event.pressed ? layer_on(action.layer_tap.val) : + layer_off(action.layer_tap.val); break; - case 0xF0: - // Ignored. LAYER_RELEASED with tap toggle is invalid action. + case OP_OFF_ON: + event.pressed ? layer_off(action.layer_tap.val) : + layer_on(action.layer_tap.val); break; - case 0xFF: - if (!event.pressed) { - default_layer = action.layer.opt; - layer_switch(default_layer); - } + case OP_SET_CLEAR: + event.pressed ? layer_move(action.layer_tap.val) : + layer_clear(); break; default: - // Ignored. LAYER_RELEASED with tap key is invalid action. - break; - } - break; - case ACT_LAYER_BIT: - switch (action.layer.code) { - case 0x00: + /* tap key */ if (event.pressed) { - layer_switch(current_layer | action.layer.opt); - } else { - layer_switch(current_layer & ~action.layer.opt); - } - break; - case 0xF0: - // TODO: tap toggle - break; - case 0xFF: - // change default layer - if (event.pressed) { - default_layer = current_layer | action.layer.opt; - layer_switch(default_layer); - } else { - default_layer = current_layer & ~action.layer.opt; - layer_switch(default_layer); - } - 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 { - delaying_layer = (keyrecord_t){ - .event = event, - .action = action, - .mods = keyboard_report->mods - }; - } - } else if (tap_count > 0) { - register_code(action.layer.code); + if (tap_count > 0) { + dprint("KEYMAP_TAP_KEY: Tap: register_code\n"); + register_code(action.layer_tap.code); + } else { + dprint("KEYMAP_TAP_KEY: No tap: On on press\n"); + layer_on(action.layer_tap.val); } } else { - if (tap_count == 0) { - // no tap - layer_switch(current_layer & ~action.layer.opt); - } else if (tap_count == 1) { - // tap - register_code(action.layer.code); + if (tap_count > 0) { + dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n"); + unregister_code(action.layer_tap.code); + } else { + dprint("KEYMAP_TAP_KEY: No tap: Off on release\n"); + layer_off(action.layer_tap.val); } - unregister_code(action.layer.code); - } - break; - } - case ACT_LAYER_EXT: - switch (action.layer.opt) { - case 0x00: - // set default layer when pressed - switch (action.layer.code) { - case 0x00: - if (event.pressed) { - layer_switch(default_layer); - } - break; - case 0xF0: - // TODO: tap toggle - break; - case 0xFF: - if (event.pressed) { - default_layer = current_layer; - layer_switch(default_layer); - } - break; - default: - // TODO: tap key - break; - } - break; - case 0x01: - // set default layer when released - switch (action.layer.code) { - case 0x00: - if (!event.pressed) { - layer_switch(default_layer); - } - break; - case 0xFF: - if (!event.pressed) { - default_layer = current_layer; - layer_switch(default_layer); - } - break; - case 0xF0: - default: - // Ignore tap. - if (!event.pressed) { - layer_switch(default_layer); - } - break; } break; } break; + #endif +#endif + /* Extentions */ +#ifndef NO_ACTION_MACRO case ACT_MACRO: + action_macro_play(action_get_macro(record, action.func.id, action.func.opt)); + break; +#endif +#ifdef BACKLIGHT_ENABLE + case ACT_BACKLIGHT: + if (!event.pressed) { + switch (action.backlight.opt) { + case BACKLIGHT_INCREASE: + backlight_increase(); + break; + case BACKLIGHT_DECREASE: + backlight_decrease(); + break; + case BACKLIGHT_TOGGLE: + backlight_toggle(); + break; + case BACKLIGHT_STEP: + backlight_step(); + break; + case BACKLIGHT_LEVEL: + backlight_level(action.backlight.level); + break; + } + } + break; +#endif case ACT_COMMAND: + break; +#ifndef NO_ACTION_FUNCTION case ACT_FUNCTION: + action_function(record, action.func.id, action.func.opt); + break; +#endif default: break; } - - /* last event */ - last_event = event; - last_event_time = timer_read(); } -static void register_code(uint8_t code) + + +/* + * Utilities for actions. + */ +void register_code(uint8_t code) { if (code == KC_NO) { return; } + +#ifdef LOCKING_SUPPORT_ENABLE + else if (KC_LOCKING_CAPS == code) { +#ifdef LOCKING_RESYNC_ENABLE + // Resync: ignore if caps lock already is on + if (host_keyboard_leds() & (1< "); Kdebug_hex(new_layer); Kdebug("\n"); + action_t action = layer_switch_get_action(key); - current_layer = new_layer; - clear_keyboard_but_mods(); // To avoid stuck keys + switch (action.kind.id) { + case ACT_LMODS_TAP: + case ACT_RMODS_TAP: + case ACT_LAYER_TAP: + case ACT_LAYER_TAP_EXT: + return true; + case ACT_MACRO: + case ACT_FUNCTION: + if (action.func.opt & FUNC_TAP) { return true; } + return false; + } + return false; +} + + +/* + * debug print + */ +void debug_event(keyevent_t event) +{ + dprintf("%04X%c(%u)", (event.key.row<<8 | event.key.col), (event.pressed ? 'd' : 'u'), event.time); +} + +void debug_record(keyrecord_t record) +{ + debug_event(record.event); +#ifndef NO_ACTION_TAPPING + dprintf(":%u%c", record.tap.count, (record.tap.interrupted ? '-' : ' ')); +#endif +} + +void debug_action(action_t action) +{ + switch (action.kind.id) { + case ACT_LMODS: dprint("ACT_LMODS"); break; + case ACT_RMODS: dprint("ACT_RMODS"); break; + case ACT_LMODS_TAP: dprint("ACT_LMODS_TAP"); break; + case ACT_RMODS_TAP: dprint("ACT_RMODS_TAP"); break; + case ACT_USAGE: dprint("ACT_USAGE"); break; + case ACT_MOUSEKEY: dprint("ACT_MOUSEKEY"); break; + case ACT_LAYER: dprint("ACT_LAYER"); break; + case ACT_LAYER_TAP: dprint("ACT_LAYER_TAP"); break; + case ACT_LAYER_TAP_EXT: dprint("ACT_LAYER_TAP_EXT"); break; + case ACT_MACRO: dprint("ACT_MACRO"); break; + case ACT_COMMAND: dprint("ACT_COMMAND"); break; + case ACT_FUNCTION: dprint("ACT_FUNCTION"); break; + default: dprint("UNKNOWN"); break; } + dprintf("[%X:%02X]", action.kind.param>>8, action.kind.param&0xff); }