X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=common%2Faction.c;h=fddb97c508dbd96865c73ef08bfd68cc1739b1ac;hb=b9e265368fde73daff069788dcb58c8230d01b32;hp=22f0bf0a0db9edac1f417ae2985c3d39fc7a35e9;hpb=bfd7fe586297d70f824a402fd476c3daa889fa56;p=tmk_firmware.git diff --git a/common/action.c b/common/action.c index 22f0bf0..fddb97c 100644 --- a/common/action.c +++ b/common/action.c @@ -1,306 +1,74 @@ +/* +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" - -static void process(keyrecord_t *record); - -// TODO -/* layer */ -uint8_t default_layer = 0; -uint8_t current_layer = 0; - -/* tap term(ms) */ -#define TAP_TERM 200 - -/* This counts up when tap occurs */ -uint8_t tap_count = 0; -keyevent_t tapping_event = {}; -keyrecord_t tapping_key = {}; - -/* TAPPING: This indicates that whether tap or not is not decided yet. */ -// NOTE: keyevent_t.time 0 means no event. -#define IS_TAPPING() (tapping_key.event.time != 0) -#define IS_TAPPING_PRESSED() (IS_TAPPING() && tapping_key.event.pressed) -#define IS_TAPPING_RELEASED() (IS_TAPPING() && !tapping_key.event.pressed) -#define IS_TAPPING_KEY(k) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (k))) -#define WITHIN_TAP_TERM(e) (TIMER_DIFF_16(e.time, tapping_key.event.time) < TAP_TERM) - -/* waiting keys buffer */ -#define WAITING_BUFFER_SIZE 8 -static keyrecord_t waiting_buffer[WAITING_BUFFER_SIZE] = {}; -/* point to empty cell to enq */ -static uint8_t waiting_buffer_head = 0; -/* point to the oldest data cell to deq */ -static uint8_t waiting_buffer_tail = 0; - -static bool waiting_buffer_enq(keyrecord_t record) -{ - if (IS_NOEVENT(record.event)) { - return true; - } - - if ((waiting_buffer_head + 1) % WAITING_BUFFER_SIZE == waiting_buffer_tail) { - debug("waiting_buffer_enq: Over flow.\n"); - return false; - } - - debug("waiting_buffer_enq["); debug_dec(waiting_buffer_head); debug("] = "); - debug_hex16(record.event.key.raw); debug("\n"); - - waiting_buffer[waiting_buffer_head] = record; - waiting_buffer_head = (waiting_buffer_head + 1) % WAITING_BUFFER_SIZE; - return true; -} -static keyrecord_t waiting_buffer_deq(void) -{ - if (waiting_buffer_head == waiting_buffer_tail) { - return (keyrecord_t){}; - } - uint8_t last_tail = waiting_buffer_tail; - waiting_buffer_tail = waiting_buffer_tail + 1 % WAITING_BUFFER_SIZE; - return waiting_buffer[last_tail]; -} -static bool waiting_buffer_is_empty(void) -{ - return (waiting_buffer_head == waiting_buffer_tail); -} -static void waiting_buffer_clear(void) -{ - waiting_buffer_head = 0; - waiting_buffer_tail = 0; -} -static bool waiting_buffer_typed(keyevent_t event) -{ - for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) { - if (KEYEQ(event.key, waiting_buffer[i].event.key) && event.pressed != waiting_buffer[i].event.pressed) { - return true; - } - } - return false; -} -static bool waiting_buffer_has_anykey_pressed(void) -{ - for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) { - if (waiting_buffer[i].event.pressed) return true; - } - return false; -} -static void waiting_buffer_process(void) -{ -} - -/* Oneshot modifier - * - * Problem: Want to capitalize like 'The' but the result tends to be 'THe'. - * Solution: Oneshot modifier have its effect on only one key coming next. - * Tap Shift, then type 't', 'h' and 'e'. Not need to hold Shift key. - * - * Hold: works as normal modifier. - * Tap: one shot modifier. - * 2 Tap: cancel one shot modifier. - * 5-Tap: toggles enable/disable oneshot feature. - */ -static struct { - uint8_t mods; - uint8_t time; - bool ready; - bool disabled; -} oneshot_state; -static void oneshot_start(uint8_t mods, uint16_t time) -{ - oneshot_state.mods = mods; - oneshot_state.time = time; - oneshot_state.ready = true; -} -static void oneshot_cancel(void) -{ - oneshot_state.mods = 0; - oneshot_state.time = 0; - oneshot_state.ready = false; -} -static void oneshot_toggle(void) -{ - oneshot_state.disabled = !oneshot_state.disabled; -} +#ifdef DEBUG_ACTION +#include "debug.h" +#else +#include "nodebug.h" +#endif -/* - * Rule to judge tap: - * Tap key is typed(pressed and released) within TAP_TERM - * without interfaring by typing other key. - */ -/* return true when key event is processed. */ -static bool process_tap(keyrecord_t *keyp) -{ - keyevent_t event = keyp->event; - - // if tapping - if (IS_TAPPING_PRESSED()) { - if (WITHIN_TAP_TERM(event)) { - if (tapping_key.tap_count == 0) { - if (IS_TAPPING_KEY(event.key) && !event.pressed) { - // first tap! - debug("Tapping: First tap.\n"); - tapping_key.tap_count = 1; - process(&tapping_key); - - // enqueue - keyp->tap_count = tapping_key.tap_count; - return false; - } else if (!event.pressed && waiting_buffer_typed(event)) { - // other key typed. not tap. - debug("Tapping: End(No tap. Interfered by typing key).\n"); - process(&tapping_key); - tapping_key = (keyrecord_t){}; - - // enqueue - return false; - } else { - // other key events shall be stored till tapping state settles. - return false; - } - } else { - if (IS_TAPPING_KEY(event.key) && !event.pressed) { - keyp->tap_count = tapping_key.tap_count; - debug("Tapping: tap release("); debug_dec(keyp->tap_count); debug(")\n"); - tapping_key = *keyp; - return false; - } - else if (is_tap_key(keyp->event.key) && event.pressed) { - debug("Tapping: Start with forcing to release last tap.\n"); - process(&(keyrecord_t){ - .tap_count = tapping_key.tap_count, - .event.key = tapping_key.event.key, - .event.time = event.time, - .event.pressed = false - }); - tapping_key = *keyp; - return false; - } - else { - if (!IS_NOEVENT(keyp->event)) debug("Tapping: key event while tap.\n"); - process(keyp); - return true; - } - } - } - // not within TAP_TERM - else { - if (tapping_key.tap_count == 0) { - // timeout. not tap. - debug("Tapping: End. Not tap(time out).\n"); - process(&tapping_key); - tapping_key = (keyrecord_t){}; - return false; - } else { - if (IS_TAPPING_KEY(event.key) && !event.pressed) { - debug("Tapping: End. tap release."); - keyp->tap_count = tapping_key.tap_count; - process(keyp); - tapping_key = (keyrecord_t){}; - return true; - } else { - // other key after tap time out. - process(keyp); - return true; - } - } - } - } else if (IS_TAPPING_RELEASED()) { - if (WITHIN_TAP_TERM(event)) { - if (tapping_key.tap_count > 0 && IS_TAPPING_KEY(event.key) && event.pressed) { - // sequential tap. - keyp->tap_count = tapping_key.tap_count + 1; - debug("Tapping: tap press("); debug_dec(keyp->tap_count); debug(")\n"); - process(keyp); - tapping_key = *keyp; - return true; - } else if (event.pressed && is_tap_key(event.key)) { - // Sequential tap can be interfered with other tap key. - debug("Tapping: Start with interfering other tap.\n"); - tapping_key = *keyp; - return true; - } else { - if (!IS_NOEVENT(keyp->event)) debug("Tapping: other key just after tap.\n"); - process(keyp); - return true; - } - } else { - // timeout. no sequential tap. - debug("Tapping: End(Time out after releasing last tap).\n"); - tapping_key = (keyrecord_t){}; - process(keyp); - return true; - } - } else { - if (event.pressed && is_tap_key(event.key)) { - debug("Tapping: Start(Press tap key).\n"); - tapping_key = *keyp; - return true; - } else { - process(keyp); - return true; - } - } -} - void action_exec(keyevent_t event) { if (!IS_NOEVENT(event)) { - debug("event: "); - debug_hex16(event.time); debug(": "); - debug_hex16(event.key.raw); - debug("["); - if (event.pressed) debug("down"); else debug("up"); - debug("]\n"); + dprint("\n---- action_exec: start -----\n"); + dprint("EVENT: "); debug_event(event); dprintln(); } keyrecord_t record = { .event = event }; - // pre-process on tapping - if (process_tap(&record)) { - if (!IS_NOEVENT(record.event)) debug("processed.\n"); - } else { - if (!IS_NOEVENT(record.event)) debug("enqueued.\n"); - if (!waiting_buffer_enq(record)) { - // clear all in case of overflow. - clear_keyboard(); - waiting_buffer_clear(); - tapping_key = (keyrecord_t){}; - } - } - - // TODO: need to process every time? - // process waiting_buffer - for (; waiting_buffer_tail != waiting_buffer_head; waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE) { - if (process_tap(&waiting_buffer[waiting_buffer_tail])) { - debug("processed: waiting_buffer["); debug_dec(waiting_buffer_tail); debug("] = "); - debug_hex16(waiting_buffer[waiting_buffer_tail].event.key.raw); debug("\n"); - } else { - break; - } +#ifndef NO_ACTION_TAPPING + action_tapping_process(record); +#else + process_action(&record); + if (!IS_NOEVENT(record.event)) { + dprint("processed: "); debug_record(record); dprintln(); } +#endif } -static void process(keyrecord_t *record) +void process_action(keyrecord_t *record) { - // TODO: use record keyevent_t event = record->event; - uint8_t tap_count = record->tap_count; +#ifndef NO_ACTION_TAPPING + uint8_t tap_count = record->tap.count; +#endif if (IS_NOEVENT(event)) { return; } - action_t action = keymap_get_action(current_layer, event.key.pos.row, event.key.pos.col); - debug("action: "); debug_hex16(action.code); - if (event.pressed) debug("[down]\n"); else debug("[up]\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 */ @@ -310,113 +78,109 @@ static void process(keyrecord_t *record) uint8_t mods = (action.kind.id == ACT_LMODS) ? action.key.mods : action.key.mods<<4; if (event.pressed) { - uint8_t tmp_mods = host_get_mods(); if (mods) { - host_add_mods(mods); - host_send_keyboard_report(); + add_weak_mods(mods); + send_keyboard_report(); } register_code(action.key.code); - if (mods && action.key.code) { - host_set_mods(tmp_mods); - host_send_keyboard_report(); - } } else { - if (mods && !action.key.code) { - host_del_mods(mods); - host_send_keyboard_report(); - } unregister_code(action.key.code); + if (mods) { + del_weak_mods(mods); + send_keyboard_report(); + } } } break; +#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.code) { - case 0x00: + switch (action.layer_tap.code) { + #ifndef NO_ACTION_ONESHOT + case MODS_ONESHOT: // Oneshot modifier if (event.pressed) { if (tap_count == 0) { - debug("MODS_TAP: Oneshot: add_mods\n"); - add_mods(mods); + register_mods(mods); } else if (tap_count == 1) { - debug("MODS_TAP: Oneshot: start\n"); - oneshot_start(mods, event.time); - } - else if (tap_count == 5) { - debug("MODS_TAP: Oneshot: toggle\n"); - oneshot_toggle(); + dprint("MODS_TAP: Oneshot: start\n"); + set_oneshot_mods(mods); } else { - debug("MODS_TAP: Oneshot: cancel&add_mods\n"); - // double tap cancels oneshot and works as normal modifier. - oneshot_cancel(); - add_mods(mods); + register_mods(mods); } } else { if (tap_count == 0) { - debug("MODS_TAP: Oneshot: cancel/del_mods\n"); - // cancel oneshot by holding. - oneshot_cancel(); - del_mods(mods); + clear_oneshot_mods(); + unregister_mods(mods); } else if (tap_count == 1) { - debug("MODS_TAP: Oneshot: del_mods\n"); - // retain Oneshot - del_mods(mods); + // Retain Oneshot mods } else { - debug("MODS_TAP: Oneshot: del_mods\n"); - // cancel Mods - del_mods(mods); + 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 (waiting_buffer_has_anykey_pressed()) { - debug("MODS_TAP: Tap: Cancel: add_mods\n"); + if (record->tap.interrupted) { + dprint("MODS_TAP: Tap: Cancel: add_mods\n"); // ad hoc: set 0 to cancel tap - record->tap_count = 0; - add_mods(mods); + record->tap.count = 0; + register_mods(mods); } else { - debug("MODS_TAP: Tap: register_code\n"); + dprint("MODS_TAP: Tap: register_code\n"); register_code(action.key.code); } } else { - debug("MODS_TAP: No tap: add_mods\n"); - add_mods(mods); + dprint("MODS_TAP: No tap: add_mods\n"); + register_mods(mods); } } else { if (tap_count > 0) { - debug("MODS_TAP: Tap: unregister_code\n"); + dprint("MODS_TAP: Tap: unregister_code\n"); unregister_code(action.key.code); } else { - debug("MODS_TAP: No tap: add_mods\n"); - del_mods(mods); + dprint("MODS_TAP: No tap: add_mods\n"); + unregister_mods(mods); } } break; } } break; - +#endif +#ifdef EXTRAKEY_ENABLE /* other HID usage */ case ACT_USAGE: -#ifdef EXTRAKEY_ENABLE 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 { @@ -424,12 +188,11 @@ static void process(keyrecord_t *record) } break; } -#endif break; - +#endif +#ifdef MOUSEKEY_ENABLE /* Mouse key */ case ACT_MOUSEKEY: -#ifdef MOUSEKEY_ENABLE if (event.pressed) { mousekey_on(action.key.code); mousekey_send(); @@ -437,191 +200,135 @@ static void process(keyrecord_t *record) mousekey_off(action.key.code); mousekey_send(); } -#endif break; - - /* Layer key */ - 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)< 0) { - debug("LAYER_PRESSED: Tap: register_code\n"); - register_code(action.layer.code); - } else { - debug("LAYER_PRESSED: No tap: layer_switch\n"); - layer_switch(action.layer.opt); - } - } else { - // TODO: while other key tapping - debug("LAYER_PRESSED: No tap: layer_switch\n"); - layer_switch(action.layer.opt); - } -/* - if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_PRESSED: Tap: register_code\n"); - register_code(action.layer.code); - } else { - debug("LAYER_PRESSED: No tap: layer_switch\n"); - layer_switch(action.layer.opt); + if (tap_count < TAPPING_TOGGLE) { + layer_invert(action.layer_tap.val); } -*/ } else { - if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_PRESSED: Tap: unregister_code\n"); - unregister_code(action.layer.code); - } else { - debug("LAYER_PRESSED: No tap: NO ACTION\n"); + if (tap_count <= TAPPING_TOGGLE) { + layer_invert(action.layer_tap.val); } } 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 - if (event.pressed) { - if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_BIT: Tap: register_code\n"); - register_code(action.layer.code); + if (tap_count > 0) { + dprint("KEYMAP_TAP_KEY: Tap: register_code\n"); + register_code(action.layer_tap.code); } else { - debug("LAYER_BIT: No tap: layer_switch(bit on)\n"); - layer_switch(current_layer | action.layer.opt); + dprint("KEYMAP_TAP_KEY: No tap: On on press\n"); + layer_on(action.layer_tap.val); } } else { - if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_BIT: Tap: unregister_code\n"); - unregister_code(action.layer.code); + if (tap_count > 0) { + dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n"); + unregister_code(action.layer_tap.code); } else { - debug("LAYER_BIT: No tap: layer_switch(bit off)\n"); - layer_switch(current_layer & ~action.layer.opt); + dprint("KEYMAP_TAP_KEY: No tap: Off on release\n"); + layer_off(action.layer_tap.val); } } 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_call_function(event, action.func.id); + action_function(record, action.func.id, action.func.opt); break; +#endif default: break; } } + + /* * Utilities for actions. */ @@ -630,73 +337,158 @@ 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< "); debug_hex(new_layer); debug("\n"); - - current_layer = new_layer; - clear_keyboard_but_mods(); // To avoid stuck keys - // TODO: update mods with full scan of matrix? if modifier changes between layers - } -} - bool is_tap_key(key_t key) { - action_t action = keymap_get_action(current_layer, key.pos.row, key.pos.col); + action_t action = layer_switch_get_action(key); + 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_LAYER_PRESSED: - case ACT_LAYER_BIT: - switch (action.layer.code) { - case 0x00: - case 0xF1 ... 0xFF: - return false; - case 0xF0: - default: - return true; - } - return false; + case ACT_MACRO: case ACT_FUNCTION: - if (action.func.opt & 0x1) { - return true; - } + 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); +}