From 10f33a3e484e24065ed5eaab1c56c35156bace89 Mon Sep 17 00:00:00 2001 From: tmk Date: Sun, 31 Mar 2013 22:47:19 +0900 Subject: Remove ACT_KEYMAP and ACT_OVERLAY - Remove ACT_OVERLAY - Rename ACT_KEYMAP to ACT_LAYER - Add ACT_LAYER_BITOP --- common/action.c | 172 ++------------------------------------------------ common/action.h | 148 ++++++++++++++++++++++--------------------- common/command.c | 1 - common/layer_switch.c | 90 +------------------------- common/layer_switch.h | 42 +----------- 5 files changed, 86 insertions(+), 367 deletions(-) (limited to 'common') diff --git a/common/action.c b/common/action.c index 07a3a64d6c..ef04851b11 100644 --- a/common/action.c +++ b/common/action.c @@ -56,7 +56,6 @@ void process_action(keyrecord_t *record) action_t action = layer_switch_get_action(event.key); debug("ACTION: "); debug_action(action); - debug(" overlays: "); overlay_debug(); debug(" keymaps: "); keymap_debug(); debug(" default_layer: "); debug_dec(default_layer); debug("\n"); @@ -199,31 +198,28 @@ void process_action(keyrecord_t *record) } break; #endif -#ifndef NO_ACTION_KEYMAP - case ACT_KEYMAP: +#ifndef NO_ACTION_LAYER + case ACT_LAYER: + case ACT_LAYER1: switch (action.layer.code) { /* Keymap clear */ case OP_RESET: switch (action.layer.val & 0x03) { case 0: // NOTE: reserved - overlay_clear(); keymap_clear(); break; case ON_PRESS: if (event.pressed) { - overlay_clear(); keymap_clear(); } break; case ON_RELEASE: if (!event.pressed) { - overlay_clear(); keymap_clear(); } break; case ON_BOTH: - overlay_clear(); keymap_clear(); break; /* NOTE: 4-7 rserved */ @@ -361,161 +357,6 @@ void process_action(keyrecord_t *record) break; } break; -#endif -#ifndef NO_ACTION_OVERLAY - case ACT_OVERLAY: - switch (action.layer.code) { - // Overlay Invert bit4 - case OP_INV4 | 0: - if (action.layer.val == 0) { - // NOTE: reserved for future use - overlay_clear(); - } else { - overlay_set(overlay_stat ^ action.layer.val); - } - break; - case OP_INV4 | 1: - if (action.layer.val == 0) { - // on pressed - if (event.pressed) overlay_clear(); - } else { - overlay_set(overlay_stat ^ action.layer.val<<4); - } - break; - case OP_INV4 | 2: - if (action.layer.val == 0) { - // on released - if (!event.pressed) overlay_clear(); - } else { - overlay_set(overlay_stat ^ action.layer.val<<8); - } - break; - case OP_INV4 | 3: - if (action.layer.val == 0) { - // on both - overlay_clear(); - } else { - overlay_set(overlay_stat ^ action.layer.val<<12); - } - break; - - /* Overlay Bit invert */ - case OP_INV: - /* with tap toggle */ - if (event.pressed) { - if (tap_count < TAPPING_TOGGLE) { - debug("OVERLAY_INV: tap toggle(press).\n"); - overlay_invert(action.layer.val); - } - } else { - if (tap_count <= TAPPING_TOGGLE) { - debug("OVERLAY_INV: tap toggle(release).\n"); - overlay_invert(action.layer.val); - } - } - break; - case (OP_INV | ON_PRESS): - if (event.pressed) { - overlay_invert(action.layer.val); - } - break; - case (OP_INV | ON_RELEASE): - if (!event.pressed) { - overlay_invert(action.layer.val); - } - break; - case (OP_INV | ON_BOTH): - overlay_invert(action.layer.val); - break; - - /* Overlay Bit on */ - case OP_ON: - if (event.pressed) { - overlay_on(action.layer.val); - } else { - overlay_off(action.layer.val); - } - break; - case (OP_ON | ON_PRESS): - if (event.pressed) { - overlay_on(action.layer.val); - } - break; - case (OP_ON | ON_RELEASE): - if (!event.pressed) { - overlay_on(action.layer.val); - } - break; - case (OP_ON | ON_BOTH): - overlay_on(action.layer.val); - break; - - /* Overlay Bit off */ - case OP_OFF: - if (event.pressed) { - overlay_off(action.layer.val); - } else { - overlay_on(action.layer.val); - } - break; - case (OP_OFF | ON_PRESS): - if (event.pressed) { - overlay_off(action.layer.val); - } - break; - case (OP_OFF | ON_RELEASE): - if (!event.pressed) { - overlay_off(action.layer.val); - } - break; - case (OP_OFF | ON_BOTH): - overlay_off(action.layer.val); - break; - - /* Overlay Bit set */ - case OP_SET: - if (event.pressed) { - overlay_move(action.layer.val); - } else { - overlay_clear(); - } - break; - case (OP_SET | ON_PRESS): - if (event.pressed) { - overlay_move(action.layer.val); - } - break; - case (OP_SET | ON_RELEASE): - if (!event.pressed) { - overlay_move(action.layer.val); - } - break; - case (OP_SET | ON_BOTH): - overlay_move(action.layer.val); - break; - - /* Overlay Bit invert with tap key */ - default: - if (event.pressed) { - if (tap_count > 0) { - debug("OVERLAY_TAP_KEY: Tap: register_code\n"); - register_code(action.layer.code); - } else { - debug("OVERLAY_TAP_KEY: No tap: On on press\n"); - overlay_on(action.layer.val); - } - } else { - if (tap_count > 0) { - debug("OVERLAY_TAP_KEY: Tap: unregister_code\n"); - unregister_code(action.layer.code); - } else { - debug("OVERLAY_TAP_KEY: No tap: Off on release\n"); - overlay_off(action.layer.val); - } - } - break; - } - break; #endif /* Extentions */ #ifndef NO_ACTION_MACRO @@ -668,8 +509,7 @@ bool is_tap_key(key_t key) case ACT_LMODS_TAP: case ACT_RMODS_TAP: return true; - case ACT_KEYMAP: - case ACT_OVERLAY: + case ACT_LAYER: switch (action.layer.code) { case 0x04 ... 0xEF: /* tap key */ case OP_INV: @@ -714,8 +554,8 @@ void debug_action(action_t action) case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break; case ACT_USAGE: debug("ACT_USAGE"); break; case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; - case ACT_KEYMAP: debug("ACT_KEYMAP"); break; - case ACT_OVERLAY: debug("ACT_OVERLAY"); break; + case ACT_LAYER: debug("ACT_LAYER"); break; + case ACT_LAYER_BITOP: debug("ACT_LAYER_BITOP"); break; case ACT_MACRO: debug("ACT_MACRO"); break; case ACT_COMMAND: debug("ACT_COMMAND"); break; case ACT_FUNCTION: debug("ACT_FUNCTION"); break; diff --git a/common/action.h b/common/action.h index a6cb453840..2c4f306a44 100644 --- a/common/action.h +++ b/common/action.h @@ -65,8 +65,8 @@ typedef union { } key; struct action_layer { uint8_t code :8; - uint8_t val :4; - uint8_t kind :4; + uint8_t val :5; + uint8_t kind :3; } layer; struct action_usage { uint16_t code :10; @@ -170,35 +170,42 @@ void debug_action(action_t action); * * Layer Actions(10XX) * ------------------- - * ACT_KEYMAP: - * 1000|--xx|0000 0000 Clear keyamp and overlay - * 1000|LLLL|0000 00xx Reset default layer and clear keymap and overlay - * 1000|LLLL| keycode Invert with tap key - * 1000|LLLL|1111 0000 Invert with tap toggle - * 1000|LLLL|1111 00xx Invert[^= 1<>(0bBB*8)) & 0xff) BITOP 0bxxxxxxxx)<<(0bBB*8) + * layer_state: 32-bit layer switch state + * + * * * * Extensions(11XX) @@ -216,16 +223,20 @@ void debug_action(action_t action); * */ enum action_kind_id { + ACT_MODS = 0b0000, ACT_LMODS = 0b0000, ACT_RMODS = 0b0001, + ACT_MODS_TAP = 0b0010, ACT_LMODS_TAP = 0b0010, ACT_RMODS_TAP = 0b0011, ACT_USAGE = 0b0100, ACT_MOUSEKEY = 0b0101, - ACT_KEYMAP = 0b1000, - ACT_OVERLAY = 0b1001, + ACT_LAYER = 0b1000, + ACT_LAYER1 = 0b1001, + ACT_LAYER_BITOP = 0b1010, + ACT_LAYER1_BITOP = 0b1011, ACT_MACRO = 0b1100, ACT_COMMAND = 0b1110, @@ -285,12 +296,14 @@ enum usage_pages { * Set layer = (1<= 0; i--) { - if (overlay_stat & (1<= 0; i--) { if (keymap_stat & (1<. #include "action.h" -/* overlays are asigned at layer 16-31 */ -#define OVERLAY_BIT 0x10 -#define OVERLAY_MASK 0x0F - - /* * Default Layer */ @@ -38,7 +33,7 @@ void default_layer_set(uint8_t layer); /* * Keymap Layer */ -#ifndef NO_ACTION_KEYMAP +#ifndef NO_ACTION_LAYER extern uint16_t keymap_stat; /* return current active layer */ uint8_t keymap_get_layer(void); @@ -69,41 +64,6 @@ void keymap_debug(void); #endif -/* - * Overlay Layer - */ -#ifndef NO_ACTION_OVERLAY -extern uint16_t overlay_stat; -/* return current active layer */ -uint8_t overlay_get_layer(void); -void overlay_clear(void); -void overlay_set(uint16_t stat); -void overlay_move(uint8_t layer); -void overlay_on(uint8_t layer); -void overlay_off(uint8_t layer); -void overlay_invert(uint8_t layer); -/* bitwise operation */ -void overlay_or(uint16_t stat); -void overlay_and(uint16_t stat); -void overlay_xor(uint16_t stat); -void overlay_debug(void); -#else -#define overlay_stat 0 -#define overlay_get_layer() -#define overlay_clear() -#define overlay_set(stat) -#define overlay_move(layer) -#define overlay_on(layer) -#define overlay_off(layer) -#define overlay_invert(layer) -#define overlay_or(stat) -#define overlay_and(stat) -#define overlay_xor(stat) -#define overlay_debug() -#endif - - - /* return action depending on current layer status */ action_t layer_switch_get_action(key_t key); -- cgit v1.2.3 From cc8e66754b1a5d0c11985cb0feb51ead49668744 Mon Sep 17 00:00:00 2001 From: tmk Date: Tue, 2 Apr 2013 16:09:43 +0900 Subject: Refine ACT_LAYER and ACT_LAYER_TAP - Remove ACT_LAYER_BITOP --- common/action.c | 201 +++++++++++++++--------------------------------- common/action.h | 166 ++++++++++++++++++--------------------- common/action_tapping.h | 3 +- common/command.c | 3 +- common/layer_switch.c | 122 ++++++++++++++++------------- common/layer_switch.h | 61 ++++++++------- common/util.c | 19 +++++ common/util.h | 3 + 8 files changed, 263 insertions(+), 315 deletions(-) (limited to 'common') diff --git a/common/action.c b/common/action.c index ef04851b11..596831d4de 100644 --- a/common/action.c +++ b/common/action.c @@ -50,14 +50,19 @@ void action_exec(keyevent_t event) void process_action(keyrecord_t *record) { keyevent_t event = record->event; +#ifndef NO_ACTION_TAPPING uint8_t tap_count = record->tap.count; +#endif if (IS_NOEVENT(event)) { return; } action_t action = layer_switch_get_action(event.key); debug("ACTION: "); debug_action(action); - debug(" keymaps: "); keymap_debug(); - debug(" default_layer: "); debug_dec(default_layer); debug("\n"); +#ifndef NO_ACTION_LAYER + debug(" layer_state: "); layer_debug(); + debug(" default_layer_state: "); default_layer_debug(); +#endif + debug("\n"); switch (action.kind.id) { /* Key and Mods */ @@ -92,7 +97,7 @@ void process_action(keyrecord_t *record) { uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods : action.key.mods<<4; - switch (action.layer.code) { + switch (action.layer_tap.code) { #ifndef NO_ACTION_ONESHOT case 0x00: // Oneshot modifier @@ -200,163 +205,86 @@ void process_action(keyrecord_t *record) #endif #ifndef NO_ACTION_LAYER case ACT_LAYER: - case ACT_LAYER1: - switch (action.layer.code) { - /* Keymap clear */ - case OP_RESET: - switch (action.layer.val & 0x03) { - case 0: - // NOTE: reserved - keymap_clear(); - break; - case ON_PRESS: - if (event.pressed) { - keymap_clear(); - } - break; - case ON_RELEASE: - if (!event.pressed) { - keymap_clear(); - } - break; - case ON_BOTH: - keymap_clear(); - break; - /* NOTE: 4-7 rserved */ + 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("KEYMAP_TAP_KEY: Tap: register_code\n"); - register_code(action.layer.code); + register_code(action.layer_tap.code); } else { debug("KEYMAP_TAP_KEY: No tap: On on press\n"); - keymap_on(action.layer.val); + layer_on(action.layer_tap.val); } } else { if (tap_count > 0) { debug("KEYMAP_TAP_KEY: Tap: unregister_code\n"); - unregister_code(action.layer.code); + unregister_code(action.layer_tap.code); } else { debug("KEYMAP_TAP_KEY: No tap: Off on release\n"); - keymap_off(action.layer.val); + layer_off(action.layer_tap.val); } } break; } break; + #endif #endif /* Extentions */ #ifndef NO_ACTION_MACRO @@ -508,15 +436,9 @@ bool is_tap_key(key_t key) switch (action.kind.id) { case ACT_LMODS_TAP: case ACT_RMODS_TAP: + case ACT_LAYER_TAP: + case ACT_LAYER_TAP1: return true; - case ACT_LAYER: - switch (action.layer.code) { - case 0x04 ... 0xEF: /* tap key */ - case OP_INV: - return true; - default: - return false; - } case ACT_MACRO: case ACT_FUNCTION: if (action.func.opt & FUNC_TAP) { return true; } @@ -555,7 +477,8 @@ void debug_action(action_t action) case ACT_USAGE: debug("ACT_USAGE"); break; case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; case ACT_LAYER: debug("ACT_LAYER"); break; - case ACT_LAYER_BITOP: debug("ACT_LAYER_BITOP"); break; + case ACT_LAYER_TAP: debug("ACT_LAYER_TAP"); break; + case ACT_LAYER_TAP1: debug("ACT_LAYER_TAP1"); break; case ACT_MACRO: debug("ACT_MACRO"); break; case ACT_COMMAND: debug("ACT_COMMAND"); break; case ACT_FUNCTION: debug("ACT_FUNCTION"); break; diff --git a/common/action.h b/common/action.h index 2c4f306a44..4daae1d04f 100644 --- a/common/action.h +++ b/common/action.h @@ -63,11 +63,19 @@ typedef union { uint8_t mods :4; uint8_t kind :4; } key; - struct action_layer { + struct action_layer_bitop { + uint8_t bits :4; + uint8_t xbit :1; + uint8_t part :3; + uint8_t on :2; + uint8_t op :2; + uint8_t kind :4; + } layer_bitop; + struct action_layer_tap { uint8_t code :8; uint8_t val :5; uint8_t kind :3; - } layer; + } layer_tap; struct action_usage { uint16_t code :10; uint8_t page :2; @@ -170,40 +178,27 @@ void debug_action(action_t action); * * Layer Actions(10XX) * ------------------- - * ACT_LAYER: - * 1000|--xx|0000 0000 Clear keyamp - * 100X|LLLL|0000 00xx Reset default layer and clear keymap - * 100X|LLLL| keycode Invert with tap key - * 100X|LLLL|1111 0000 Invert with tap toggle - * 100X|LLLL|1111 00xx Invert[^= 1<>(0bBB*8)) & 0xff) BITOP 0bxxxxxxxx)<<(0bBB*8) - * layer_state: 32-bit layer switch state * * * @@ -234,9 +229,8 @@ enum action_kind_id { ACT_MOUSEKEY = 0b0101, ACT_LAYER = 0b1000, - ACT_LAYER1 = 0b1001, - ACT_LAYER_BITOP = 0b1010, - ACT_LAYER1_BITOP = 0b1011, + ACT_LAYER_TAP = 0b1010, + ACT_LAYER_TAP1 = 0b1011, ACT_MACRO = 0b1100, ACT_COMMAND = 0b1110, @@ -289,71 +283,61 @@ enum usage_pages { -/* Layer Actions: - * Invert layer ^= (1<. #define ACTION_TAPPING_H -#ifndef NO_ACTION_TAPPING /* period of tapping(ms) */ #ifndef TAPPING_TERM @@ -33,8 +32,8 @@ along with this program. If not, see . #define WAITING_BUFFER_SIZE 8 +#ifndef NO_ACTION_TAPPING void action_tapping_process(keyrecord_t record); - #endif #endif diff --git a/common/command.c b/common/command.c index e197a8f80a..c954ff02f4 100644 --- a/common/command.c +++ b/common/command.c @@ -573,7 +573,8 @@ static uint8_t numkey2num(uint8_t code) static void switch_default_layer(uint8_t layer) { - print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n"); + print("switch_default_layer: "); print_dec(biton32(default_layer_state)); default_layer_set(layer); + print(" to "); print_dec(biton32(default_layer_state)); print("\n"); clear_keyboard(); } diff --git a/common/layer_switch.c b/common/layer_switch.c index 359e6b9d84..9905741f48 100644 --- a/common/layer_switch.c +++ b/common/layer_switch.c @@ -7,94 +7,103 @@ /* - * Default Layer (0-15) + * Default Layer State */ -uint8_t default_layer = 0; +uint32_t default_layer_state = 0; -void default_layer_set(uint8_t layer) +static void default_layer_state_set(uint32_t state) { - debug("default_layer_set: "); - debug_dec(default_layer); debug(" to "); - - default_layer = layer; - - debug_dec(default_layer); debug("\n"); - + debug("default_layer_state: "); + default_layer_debug(); debug(" to "); + default_layer_state = state; + default_layer_debug(); debug("\n"); clear_keyboard_but_mods(); // To avoid stuck keys } - -#ifndef NO_ACTION_LAYER -/* - * Keymap Layer (0-15) - */ -uint16_t keymap_stat = 0; - -/* return highest layer whose state is on */ -uint8_t keymap_get_layer(void) +void default_layer_debug(void) { - return biton16(keymap_stat); + debug_hex32(default_layer_state); + debug("("); debug_dec(biton32(default_layer_state)); debug(")"); } -static void keymap_stat_set(uint16_t stat) +void default_layer_set(uint8_t layer) { - debug("keymap: "); - keymap_debug(); debug(" to "); + default_layer_state_set(1UL<= 0; i--) { - if (keymap_stat & (1<= 0; i--) { + if (layers & (1UL<. /* * Default Layer */ -/* base layer to fall back */ -extern uint8_t default_layer; +extern uint32_t default_layer_state; +void default_layer_debug(void); void default_layer_set(uint8_t layer); +#ifndef NO_ACTION_LAYER +/* bitwise operation */ +void default_layer_or(uint32_t state); +void default_layer_and(uint32_t state); +void default_layer_xor(uint32_t state); +#else +#define default_layer_or(state) +#define default_layer_and(state) +#define default_layer_xor(state) +#endif + /* * Keymap Layer */ #ifndef NO_ACTION_LAYER -extern uint16_t keymap_stat; -/* return current active layer */ -uint8_t keymap_get_layer(void); -void keymap_clear(void); -void keymap_set(uint16_t stat); -void keymap_move(uint8_t layer); -void keymap_on(uint8_t layer); -void keymap_off(uint8_t layer); -void keymap_invert(uint8_t layer); +extern uint32_t layer_state; +void layer_debug(void); +void layer_clear(void); +void layer_move(uint8_t layer); +void layer_on(uint8_t layer); +void layer_off(uint8_t layer); +void layer_invert(uint8_t layer); /* bitwise operation */ -void keymap_or(uint16_t stat); -void keymap_and(uint16_t stat); -void keymap_xor(uint16_t stat); -void keymap_debug(void); +void layer_or(uint32_t state); +void layer_and(uint32_t state); +void layer_xor(uint32_t state); #else -#define keymap_stat 0 -#define keymap_get_layer() -#define keymap_clear() -#define keymap_set(stat) -#define keymap_move(layer) -#define keymap_on(layer) -#define keymap_off(layer) -#define keymap_invert(layer) -#define keymap_or(stat) -#define keymap_and(stat) -#define keymap_xor(stat) -#define keymap_debug() +#define layer_state 0 +#define layer_clear() +#define layer_move(layer) +#define layer_on(layer) +#define layer_off(layer) +#define layer_invert(layer) + +#define layer_or(state) +#define layer_and(state) +#define layer_xor(state) +#define layer_debug() #endif diff --git a/common/util.c b/common/util.c index ff1926d7d1..6d4d6bfda1 100644 --- a/common/util.c +++ b/common/util.c @@ -38,6 +38,14 @@ uint8_t bitpop16(uint16_t bits) return c; } +uint8_t bitpop32(uint32_t bits) +{ + uint8_t c; + for (c = 0; bits; c++) + bits &= bits - 1; + return c; +} + // most significant on-bit - return highest location of on-bit // NOTE: return 0 when bit0 is on or all bits are off uint8_t biton(uint8_t bits) @@ -58,3 +66,14 @@ uint8_t biton16(uint16_t bits) if (bits >> 1) { bits >>= 1; n += 1;} return n; } + +uint8_t biton32(uint32_t bits) +{ + uint8_t n = 0; + if (bits >>16) { bits >>=16; n +=16;} + if (bits >> 8) { bits >>= 8; n += 8;} + if (bits >> 4) { bits >>= 4; n += 4;} + if (bits >> 2) { bits >>= 2; n += 2;} + if (bits >> 1) { bits >>= 1; n += 1;} + return n; +} diff --git a/common/util.h b/common/util.h index 58b7fdf145..4b8b5ca3a4 100644 --- a/common/util.h +++ b/common/util.h @@ -30,7 +30,10 @@ along with this program. If not, see . uint8_t bitpop(uint8_t bits); uint8_t bitpop16(uint16_t bits); +uint8_t bitpop32(uint32_t bits); + uint8_t biton(uint8_t bits); uint8_t biton16(uint16_t bits); +uint8_t biton32(uint32_t bits); #endif -- cgit v1.2.3 From c6d88d27956c4b76f8819fcdb076bf94a8f55868 Mon Sep 17 00:00:00 2001 From: tmk Date: Tue, 2 Apr 2013 17:44:24 +0900 Subject: Rename file layer_switch to action_layer --- common/action.c | 2 +- common/action_layer.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++++++ common/action_layer.h | 77 ++++++++++++++++++++++++++++ common/command.c | 2 +- common/keymap.c | 2 +- common/layer_switch.c | 135 -------------------------------------------------- common/layer_switch.h | 77 ---------------------------- 7 files changed, 215 insertions(+), 215 deletions(-) create mode 100644 common/action_layer.c create mode 100644 common/action_layer.h delete mode 100644 common/layer_switch.c delete mode 100644 common/layer_switch.h (limited to 'common') diff --git a/common/action.c b/common/action.c index 596831d4de..158522dd03 100644 --- a/common/action.c +++ b/common/action.c @@ -21,7 +21,7 @@ along with this program. If not, see . #include "command.h" #include "debug.h" #include "led.h" -#include "layer_switch.h" +#include "action_layer.h" #include "action_tapping.h" #include "action_oneshot.h" #include "action_macro.h" diff --git a/common/action_layer.c b/common/action_layer.c new file mode 100644 index 0000000000..3413c53e65 --- /dev/null +++ b/common/action_layer.c @@ -0,0 +1,135 @@ +#include +#include "keyboard.h" +#include "action.h" +#include "debug.h" +#include "util.h" +#include "action_layer.h" + + +/* + * Default Layer State + */ +uint32_t default_layer_state = 0; + +static void default_layer_state_set(uint32_t state) +{ + debug("default_layer_state: "); + default_layer_debug(); debug(" to "); + default_layer_state = state; + default_layer_debug(); debug("\n"); + clear_keyboard_but_mods(); // To avoid stuck keys +} + +void default_layer_debug(void) +{ + debug_hex32(default_layer_state); + debug("("); debug_dec(biton32(default_layer_state)); debug(")"); +} + +void default_layer_set(uint8_t layer) +{ + default_layer_state_set(1UL<= 0; i--) { + if (layers & (1UL< + +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 . +*/ +#ifndef ACTION_LAYER_H +#define ACTION_LAYER_H + +#include +#include "keyboard.h" +#include "action.h" + + +/* + * Default Layer + */ +extern uint32_t default_layer_state; +void default_layer_debug(void); +void default_layer_set(uint8_t layer); + +#ifndef NO_ACTION_LAYER +/* bitwise operation */ +void default_layer_or(uint32_t state); +void default_layer_and(uint32_t state); +void default_layer_xor(uint32_t state); +#else +#define default_layer_or(state) +#define default_layer_and(state) +#define default_layer_xor(state) +#endif + + +/* + * Keymap Layer + */ +#ifndef NO_ACTION_LAYER +extern uint32_t layer_state; +void layer_debug(void); +void layer_clear(void); +void layer_move(uint8_t layer); +void layer_on(uint8_t layer); +void layer_off(uint8_t layer); +void layer_invert(uint8_t layer); +/* bitwise operation */ +void layer_or(uint32_t state); +void layer_and(uint32_t state); +void layer_xor(uint32_t state); +#else +#define layer_state 0 +#define layer_clear() +#define layer_move(layer) +#define layer_on(layer) +#define layer_off(layer) +#define layer_invert(layer) + +#define layer_or(state) +#define layer_and(state) +#define layer_xor(state) +#define layer_debug() +#endif + + +/* return action depending on current layer status */ +action_t layer_switch_get_action(key_t key); + +#endif diff --git a/common/command.c b/common/command.c index c954ff02f4..dc06c6da35 100644 --- a/common/command.c +++ b/common/command.c @@ -26,7 +26,7 @@ along with this program. If not, see . #include "timer.h" #include "keyboard.h" #include "bootloader.h" -#include "layer_switch.h" +#include "action_layer.h" #include "eeconfig.h" #include "sleep_led.h" #include "led.h" diff --git a/common/keymap.c b/common/keymap.c index ace3f49b69..c98ce09b66 100644 --- a/common/keymap.c +++ b/common/keymap.c @@ -18,7 +18,7 @@ along with this program. If not, see . #include "keymap.h" #include "report.h" #include "keycode.h" -#include "layer_switch.h" +#include "action_layer.h" #include "action.h" #include "action_macro.h" #include "debug.h" diff --git a/common/layer_switch.c b/common/layer_switch.c deleted file mode 100644 index 9905741f48..0000000000 --- a/common/layer_switch.c +++ /dev/null @@ -1,135 +0,0 @@ -#include -#include "keyboard.h" -#include "action.h" -#include "debug.h" -#include "util.h" -#include "layer_switch.h" - - -/* - * Default Layer State - */ -uint32_t default_layer_state = 0; - -static void default_layer_state_set(uint32_t state) -{ - debug("default_layer_state: "); - default_layer_debug(); debug(" to "); - default_layer_state = state; - default_layer_debug(); debug("\n"); - clear_keyboard_but_mods(); // To avoid stuck keys -} - -void default_layer_debug(void) -{ - debug_hex32(default_layer_state); - debug("("); debug_dec(biton32(default_layer_state)); debug(")"); -} - -void default_layer_set(uint8_t layer) -{ - default_layer_state_set(1UL<= 0; i--) { - if (layers & (1UL< - -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 . -*/ -#ifndef LAYER_SWITCH_H -#define LAYER_SWITCH_H - -#include -#include "keyboard.h" -#include "action.h" - - -/* - * Default Layer - */ -extern uint32_t default_layer_state; -void default_layer_debug(void); -void default_layer_set(uint8_t layer); - -#ifndef NO_ACTION_LAYER -/* bitwise operation */ -void default_layer_or(uint32_t state); -void default_layer_and(uint32_t state); -void default_layer_xor(uint32_t state); -#else -#define default_layer_or(state) -#define default_layer_and(state) -#define default_layer_xor(state) -#endif - - -/* - * Keymap Layer - */ -#ifndef NO_ACTION_LAYER -extern uint32_t layer_state; -void layer_debug(void); -void layer_clear(void); -void layer_move(uint8_t layer); -void layer_on(uint8_t layer); -void layer_off(uint8_t layer); -void layer_invert(uint8_t layer); -/* bitwise operation */ -void layer_or(uint32_t state); -void layer_and(uint32_t state); -void layer_xor(uint32_t state); -#else -#define layer_state 0 -#define layer_clear() -#define layer_move(layer) -#define layer_on(layer) -#define layer_off(layer) -#define layer_invert(layer) - -#define layer_or(state) -#define layer_and(state) -#define layer_xor(state) -#define layer_debug() -#endif - - -/* return action depending on current layer status */ -action_t layer_switch_get_action(key_t key); - -#endif -- cgit v1.2.3 From d6122426923fd8f9efaaad06162c48de90e782bb Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 3 Apr 2013 01:33:04 +0900 Subject: Fix ACTION_LAYER macros --- common/action.h | 49 +++++++++++++++++++++++-------------------------- 1 file changed, 23 insertions(+), 26 deletions(-) (limited to 'common') diff --git a/common/action.h b/common/action.h index 4daae1d04f..49c7879e6d 100644 --- a/common/action.h +++ b/common/action.h @@ -290,10 +290,6 @@ enum layer_param_on { ON_BOTH = 3, }; -enum layer_param_op { - OP_DEFAULT_LAYER = 0, -}; - enum layer_param_bit_op { OP_BIT_AND = 0, OP_BIT_OR, @@ -308,35 +304,36 @@ enum layer_pram_tap_op { OP_SET_CLEAR, }; -/* Layer Operation 1000|ee00|ooov vvvv */ -#define ACTION_LAYER(op, val, on) (ACT_LAYER<<12 | (on)<<10 | (op)<<5 | val) /* Layer Bitwise Operation 1000|ooee|pppx BBBB */ -#define ACTION_LAYER_BITOP(op, part, bits, on) (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | (bits)&0x1f) +#define ACTION_LAYER_BITOP(op, part, bits, on) (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | ((bits)&0x1f)) /* Layer with Tapping 101x|LLLL| keycode */ -#define ACTION_LAYER_TAP(layer, key) (ACT_LAYER_TAP<<12 | (layer)<<8 | (key)) +#define ACTION_LAYER_TAP(layer, key) (ACT_LAYER_TAP<<12 | (layer)<<8 | (key)) /* Default Layer Operation */ -#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER(layer, ON_RELEASE) -#define ACTION_DEFAULT_LAYER(layer, on) ACTION_LAYER(OP_DEFAULT_LAYER, layer, on) +#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer)/4, 1<<((layer)%4)) /* Layer Operation */ -#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_AND(0x1f, (on)) -#define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer) -#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE) -#define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer)/4, 1<<((layer)%4), (on)) -#define ACTION_LAYER_ON(layer, on) ACTION_LAYER_BIT_OR((layer)/4, 1<<((layer)%4), (on)) -#define ACTION_LAYER_OFF(layer, on) ACTION_LAYER_BIT_AND((layer)/4, ~(1<<((layer)%4)), (on)) -#define ACTION_LAYER_SET(layer, on) ACTION_LAYER_BIT_SET((layer)/4, 1<<((layer)%4), (on)) -#define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF) -#define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON) -#define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR) +#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_AND(0x1f, (on)) +#define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer) +#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE) +#define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer)/4, 1<<((layer)%4), (on)) +#define ACTION_LAYER_ON(layer, on) ACTION_LAYER_BIT_OR( (layer)/4, 1<<((layer)%4), (on)) +#define ACTION_LAYER_OFF(layer, on) ACTION_LAYER_BIT_AND((layer)/4, ~(1<<((layer)%4)), (on)) +#define ACTION_LAYER_SET(layer, on) ACTION_LAYER_BIT_SET((layer)/4, 1<<((layer)%4), (on)) +#define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF) +#define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON) +#define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR) /* Bitwise Operation */ -#define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, part, bits) -#define ACTION_LAYER_BIT_OR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, part, bits) -#define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, part, bits) -#define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, part, bits) +#define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), (on)) +#define ACTION_LAYER_BIT_OR( part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), (on)) +#define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), (on)) +#define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), (on)) +#define ACTION_DEFAULT_LAYER_BIT_AND(part, bits) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), 0) +#define ACTION_DEFAULT_LAYER_BIT_OR( part, bits) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), 0) +#define ACTION_DEFAULT_LAYER_BIT_XOR(part, bits) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), 0) +#define ACTION_DEFAULT_LAYER_BIT_SET(part, bits) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), 0) /* with Tapping */ -#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key)) -#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE) +#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key)) +#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE) /* -- cgit v1.2.3 From ebe798f081ce018826dc882a40fc77ec8a0ad023 Mon Sep 17 00:00:00 2001 From: tmk Date: Thu, 4 Apr 2013 15:16:03 +0900 Subject: Add file action_code.h --- common/action.h | 288 +-------------------------------------------------- common/action_code.h | 288 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 290 insertions(+), 286 deletions(-) create mode 100644 common/action_code.h (limited to 'common') diff --git a/common/action.h b/common/action.h index 49c7879e6d..5f659337f9 100644 --- a/common/action.h +++ b/common/action.h @@ -21,9 +21,11 @@ along with this program. If not, see . #include #include "keyboard.h" #include "keycode.h" +#include "action_code.h" #include "action_macro.h" +/* Key event container for recording */ typedef struct { keyevent_t event; #ifndef NO_ACTION_TAPPING @@ -38,62 +40,6 @@ typedef struct { #endif } keyrecord_t; -/* Action struct. - * - * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15). - * AVR looks like a little endian in avr-gcc. - * - * NOTE: not portable across compiler/endianness? - * Byte order and bit order of 0x1234: - * Big endian: 15 ... 8 7 ... 210 - * | 0x12 | 0x34 | - * 0001 0010 0011 0100 - * Little endian: 012 ... 7 8 ... 15 - * | 0x34 | 0x12 | - * 0010 1100 0100 1000 - */ -typedef union { - uint16_t code; - struct action_kind { - uint16_t param :12; - uint8_t id :4; - } kind; - struct action_key { - uint8_t code :8; - uint8_t mods :4; - uint8_t kind :4; - } key; - struct action_layer_bitop { - uint8_t bits :4; - uint8_t xbit :1; - uint8_t part :3; - uint8_t on :2; - uint8_t op :2; - uint8_t kind :4; - } layer_bitop; - struct action_layer_tap { - uint8_t code :8; - uint8_t val :5; - uint8_t kind :3; - } layer_tap; - struct action_usage { - uint16_t code :10; - uint8_t page :2; - uint8_t kind :4; - } usage; - struct action_command { - uint8_t id :8; - uint8_t opt :4; - uint8_t kind :4; - } command; - struct action_function { - uint8_t id :8; - uint8_t opt :4; - uint8_t kind :4; - } func; -} action_t; - - /* Execute action per keyevent */ void action_exec(keyevent_t event); @@ -125,234 +71,4 @@ void debug_event(keyevent_t event); void debug_record(keyrecord_t record); void debug_action(action_t action); - - -/* - * Action codes - * ============ - * 16bit code: action_kind(4bit) + action_parameter(12bit) - * - * Keyboard Keys(00XX) - * ------------------- - * ACT_LMODS(0000): - * 0000|0000|000000|00 No action - * 0000|0000|000000|01 Transparent - * 0000|0000| keycode Key - * 0000|mods|000000|00 Left mods - * 0000|mods| keycode Key & Left mods - * - * ACT_RMODS(0001): - * 0001|0000|000000|00 No action(not used) - * 0001|0000|000000|01 Transparent(not used) - * 0001|0000| keycode Key(no used) - * 0001|mods|000000|00 Right mods - * 0001|mods| keycode Key & Right mods - * - * ACT_LMODS_TAP(0010): - * 0010|mods|000000|00 Left mods OneShot - * 0010|mods|000000|01 (reserved) - * 0010|mods|000000|10 (reserved) - * 0010|mods|000000|11 (reserved) - * 0010|mods| keycode Left mods + tap Key - * - * ACT_RMODS_TAP(0011): - * 0011|mods|000000|00 Right mods OneShot - * 0011|mods|000000|01 (reserved) - * 0011|mods|000000|10 (reserved) - * 0011|mods|000000|11 (reserved) - * 0011|mods| keycode Right mods + tap Key - * - * - * Other keys(01XX) - * -------------------- - * This action handles other usages than keyboard. - * ACT_USAGE(0100): - * 0100|00| usage(10) System control(0x80) - General Desktop page(0x01) - * 0100|01| usage(10) Consumer control(0x01) - Consumer page(0x0C) - * 0100|10| usage(10) (reserved) - * 0100|11| usage(10) (reserved) - * - * ACT_MOUSEKEY(0110): - * 0101|XXXX| keycode Mouse key - * - * - * Layer Actions(10XX) - * ------------------- - * ACT_LAYER: - * 1000|oo00|pppx BBBB Default Layer Bitwise operation - * oo: operation(00:AND, 01:OR, 10:XOR, 11:SET) - * ppp: 4-bit chunk part(0-7) - * xBBBB: bits and extra bit - * 1000|ooee|pppx BBBB Layer Bitwise Operation - * oo: operation(00:AND, 01:OR, 10:XOR, 11:SET) - * ppp: 4-bit chunk part(0-7) - * xBBBB: bits and extra bit - * ee: on event(00:default layer, 01:press, 10:release, 11:both) - * - * ACT_LAYER_TAP: - * 101x|LLLL| keycode Invert with tap key - * 101x|LLLL|1110 xxxx Reserved(0xE0-EF) - * 101x|LLLL|1111 0000 Invert with tap toggle(0xF0) - * 101x|LLLL|1111 0001 On Off - * 101x|LLLL|1111 0010 Off On - * 101x|LLLL|1111 0011 Set Clear - * 101x|LLLL|1111 xxxx Reserved(0xF4-FF) - * xLLLL: layer(0-31) - * - * - * - * - * - * Extensions(11XX) - * ---------------- - * ACT_MACRO(1100): - * 1100|opt | id(8) Macro play? - * 1100|1111| id(8) Macro record? - * - * ACT_COMMAND(1110): - * 1110|opt | id(8) Built-in Command exec - * - * ACT_FUNCTION(1111): - * 1111| address(12) Function? - * 1111|opt | id(8) Function? - * - */ -enum action_kind_id { - ACT_MODS = 0b0000, - ACT_LMODS = 0b0000, - ACT_RMODS = 0b0001, - ACT_MODS_TAP = 0b0010, - ACT_LMODS_TAP = 0b0010, - ACT_RMODS_TAP = 0b0011, - - ACT_USAGE = 0b0100, - ACT_MOUSEKEY = 0b0101, - - ACT_LAYER = 0b1000, - ACT_LAYER_TAP = 0b1010, - ACT_LAYER_TAP1 = 0b1011, - - ACT_MACRO = 0b1100, - ACT_COMMAND = 0b1110, - ACT_FUNCTION = 0b1111 -}; - - -/* action utility */ -#define ACTION_NO 0 -#define ACTION_TRANSPARENT 1 -#define ACTION(kind, param) ((kind)<<12 | (param)) -#define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F) - -/* - * Key - */ -#define ACTION_KEY(key) ACTION(ACT_LMODS, key) -/* Mods & key */ -#define ACTION_LMODS(mods) ACTION(ACT_LMODS, MODS4(mods)<<8 | 0x00) -#define ACTION_LMODS_KEY(mods, key) ACTION(ACT_LMODS, MODS4(mods)<<8 | (key)) -#define ACTION_RMODS(mods) ACTION(ACT_RMODS, MODS4(mods)<<8 | 0x00) -#define ACTION_RMODS_KEY(mods, key) ACTION(ACT_RMODS, MODS4(mods)<<8 | (key)) -#define ACTION_LMOD(mod) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | 0x00) -#define ACTION_LMOD_KEY(mod, key) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | (key)) -#define ACTION_RMOD(mod) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | 0x00) -#define ACTION_RMOD_KEY(mod, key) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | (key)) -/* Tap key */ -enum mods_codes { - MODS_ONESHOT = 0x00, -}; -#define ACTION_LMODS_TAP_KEY(mods, key) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | (key)) -#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT) -#define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key)) -#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT) -#define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) -#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) -#define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) -#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) - -/* HID Usage */ -enum usage_pages { - PAGE_SYSTEM, - PAGE_CONSUMER -}; -#define ACTION_USAGE_SYSTEM(id) ACTION(ACT_USAGE, PAGE_SYSTEM<<10 | (id)) -#define ACTION_USAGE_CONSUMER(id) ACTION(ACT_USAGE, PAGE_CONSUMER<<10 | (id)) - -/* Mousekey */ -#define ACTION_MOUSEKEY(key) ACTION(ACT_MOUSEKEY, key) - - - -/* Layer Actions */ -enum layer_param_on { - ON_PRESS = 1, - ON_RELEASE = 2, - ON_BOTH = 3, -}; - -enum layer_param_bit_op { - OP_BIT_AND = 0, - OP_BIT_OR, - OP_BIT_XOR, - OP_BIT_SET, -}; - -enum layer_pram_tap_op { - OP_TAP_TOGGLE = 0xF0, - OP_ON_OFF, - OP_OFF_ON, - OP_SET_CLEAR, -}; - -/* Layer Bitwise Operation 1000|ooee|pppx BBBB */ -#define ACTION_LAYER_BITOP(op, part, bits, on) (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | ((bits)&0x1f)) -/* Layer with Tapping 101x|LLLL| keycode */ -#define ACTION_LAYER_TAP(layer, key) (ACT_LAYER_TAP<<12 | (layer)<<8 | (key)) - -/* Default Layer Operation */ -#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer)/4, 1<<((layer)%4)) -/* Layer Operation */ -#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_AND(0x1f, (on)) -#define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer) -#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE) -#define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer)/4, 1<<((layer)%4), (on)) -#define ACTION_LAYER_ON(layer, on) ACTION_LAYER_BIT_OR( (layer)/4, 1<<((layer)%4), (on)) -#define ACTION_LAYER_OFF(layer, on) ACTION_LAYER_BIT_AND((layer)/4, ~(1<<((layer)%4)), (on)) -#define ACTION_LAYER_SET(layer, on) ACTION_LAYER_BIT_SET((layer)/4, 1<<((layer)%4), (on)) -#define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF) -#define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON) -#define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR) -/* Bitwise Operation */ -#define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), (on)) -#define ACTION_LAYER_BIT_OR( part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), (on)) -#define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), (on)) -#define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), (on)) -#define ACTION_DEFAULT_LAYER_BIT_AND(part, bits) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), 0) -#define ACTION_DEFAULT_LAYER_BIT_OR( part, bits) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), 0) -#define ACTION_DEFAULT_LAYER_BIT_XOR(part, bits) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), 0) -#define ACTION_DEFAULT_LAYER_BIT_SET(part, bits) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), 0) -/* with Tapping */ -#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key)) -#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE) - - -/* - * Extensions - */ -/* Macro */ -#define ACTION_MACRO(id) ACTION(ACT_MACRO, (id)) -#define ACTION_MACRO_TAP(id) ACTION(ACT_MACRO, FUNC_TAP<<8 | (id)) -#define ACTION_MACRO_OPT(id, opt) ACTION(ACT_MACRO, (opt)<<8 | (id)) - -/* Command */ -#define ACTION_COMMAND(id, opt) ACTION(ACT_COMMAND, (opt)<<8 | (addr)) - -/* Function */ -enum function_opts { - FUNC_TAP = 0x8, /* indciates function is tappable */ -}; -#define ACTION_FUNCTION(id) ACTION(ACT_FUNCTION, (id)) -#define ACTION_FUNCTION_TAP(id) ACTION(ACT_FUNCTION, FUNC_TAP<<8 | (id)) -#define ACTION_FUNCTION_OPT(id, opt) ACTION(ACT_FUNCTION, (opt)<<8 | (id)) - #endif /* ACTION_H */ diff --git a/common/action_code.h b/common/action_code.h new file mode 100644 index 0000000000..8ebcc833dc --- /dev/null +++ b/common/action_code.h @@ -0,0 +1,288 @@ +/* +Copyright 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 . +*/ +#ifndef ACTION_CODE_H +#define ACTION_CODE_H + +/* Action codes + * ============ + * 16bit code: action_kind(4bit) + action_parameter(12bit) + * + * + * Key Actions(00xx) + * ----------------- + * ACT_MODS(000r): + * 000r|0000|0000 0000 No action code + * 000r|0000|0000 0001 Transparent code + * 000r|0000| keycode Key + * 000r|mods|0000 0000 Modifiers + * 000r|mods| keycode Key and Modifiers + * r: Left/Right flag(Left:0, Right:1) + * + * ACT_MODS_TAP(001r): + * 0010|mods|0000 0000 Modifiers with OneShot + * 0010|mods|0000 00xx (reserved) + * 0010|mods| keycode Modifiers with Tap Key + * + * + * Other Keys(01xx) + * ---------------- + * ACT_USAGE(0100): + * 0100|00| usage(10) System control(0x80) - General Desktop page(0x01) + * 0100|01| usage(10) Consumer control(0x01) - Consumer page(0x0C) + * 0100|10| usage(10) (reserved) + * 0100|11| usage(10) (reserved) + * + * ACT_MOUSEKEY(0110): TODO: Not needed? + * 0101|xxxx| keycode Mouse key + * + * 011x|xxxx xxxx xxxx (reseved) + * + * + * Layer Actions(10xx) + * ------------------- + * ACT_LAYER(1000): + * 1000|oo00|pppE BBBB Default Layer Bitwise operation + * oo: operation(00:AND, 01:OR, 10:XOR, 11:SET) + * ppp: 4-bit chunk part(0-7) + * EBBBB: bits and extra bit + * 1000|ooee|pppE BBBB Layer Bitwise Operation + * oo: operation(00:AND, 01:OR, 10:XOR, 11:SET) + * ppp: 4-bit chunk part(0-7) + * eBBBB: bits and extra bit + * ee: on event(00:default layer, 01:press, 10:release, 11:both) + * + * 1001|xxxx|xxxx xxxx (reserved) + * + * ACT_LAYER_TAP(101x): + * 101E|LLLL| keycode Invert with tap key + * 101E|LLLL|1110 xxxx Reserved(0xE0-EF) + * 101E|LLLL|1111 0000 Invert with tap toggle(0xF0) + * 101E|LLLL|1111 0001 On/Off + * 101E|LLLL|1111 0010 Off/On + * 101E|LLLL|1111 0011 Set/Clear + * 101E|LLLL|1111 xxxx Reserved(0xF4-FF) + * ELLLL: layer(0-31) + * + * + * Extensions(11xx) + * ---------------- + * ACT_MACRO(1100): + * 1100|opt | id(8) Macro play? + * 1100|1111| id(8) Macro record? + * + * ACT_COMMAND(1110): + * 1110|opt | id(8) Built-in Command exec + * + * ACT_FUNCTION(1111): + * 1111| address(12) Function? + * 1111|opt | id(8) Function? + */ +enum action_kind_id { + /* Key Actions */ + ACT_MODS = 0b0000, + ACT_LMODS = 0b0000, + ACT_RMODS = 0b0001, + ACT_MODS_TAP = 0b0010, + ACT_LMODS_TAP = 0b0010, + ACT_RMODS_TAP = 0b0011, + /* Other Keys */ + ACT_USAGE = 0b0100, + ACT_MOUSEKEY = 0b0101, + /* Layer Actions */ + ACT_LAYER = 0b1000, + ACT_LAYER_TAP = 0b1010, + ACT_LAYER_TAP1 = 0b1011, + /* Extensions */ + ACT_MACRO = 0b1100, + ACT_COMMAND = 0b1110, + ACT_FUNCTION = 0b1111 +}; + + +/* Action Code Struct + * + * NOTE: + * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15). + * AVR looks like a little endian in avr-gcc. + * Not portable across compiler/endianness? + * + * Byte order and bit order of 0x1234: + * Big endian: Little endian: + * -------------------- -------------------- + * FEDC BA98 7654 3210 0123 4567 89AB CDEF + * 0001 0010 0011 0100 0010 1100 0100 1000 + * 0x12 0x34 0x34 0x12 + */ +typedef union { + uint16_t code; + struct action_kind { + uint16_t param :12; + uint8_t id :4; + } kind; + struct action_key { + uint8_t code :8; + uint8_t mods :4; + uint8_t kind :4; + } key; + struct action_layer_bitop { + uint8_t bits :4; + uint8_t xbit :1; + uint8_t part :3; + uint8_t on :2; + uint8_t op :2; + uint8_t kind :4; + } layer_bitop; + struct action_layer_tap { + uint8_t code :8; + uint8_t val :5; + uint8_t kind :3; + } layer_tap; + struct action_usage { + uint16_t code :10; + uint8_t page :2; + uint8_t kind :4; + } usage; + struct action_command { + uint8_t id :8; + uint8_t opt :4; + uint8_t kind :4; + } command; + struct action_function { + uint8_t id :8; + uint8_t opt :4; + uint8_t kind :4; + } func; +} action_t; + + +/* action utility */ +#define ACTION_NO 0 +#define ACTION_TRANSPARENT 1 +#define ACTION(kind, param) ((kind)<<12 | (param)) + + +/* + * Key Actions + */ +/* Mod bits: 43210 + * bit 0 ||||+- Control + * bit 1 |||+-- Shift + * bit 2 ||+--- Alt + * bit 3 |+---- Gui + * bit 4 +----- LR flag(Left:0, Right:1) + */ +enum mods_bit { + MOD_LCTL = 0x01, + MOD_LSFT = 0x02, + MOD_LALT = 0x04, + MOD_LGUI = 0x08, + MOD_RCTL = 0x11, + MOD_RSFT = 0x12, + MOD_RALT = 0x14, + MOD_RGUI = 0x18, +}; +enum mods_codes { + MODS_ONESHOT = 0x00, +}; +#define ACTION_KEY(key) ACTION(ACT_MODS, (key)) +#define ACTION_MODS(mods) ACTION(ACT_MODS, (mods)<<8 | 0) +#define ACTION_MODS_KEY(mods, key) ACTION(ACT_MODS, (mods)<<8 | (key)) +#define ACTION_MODS_TAP_KEY(mods, key) ACTION(ACT_MODS_TAP, (mods)<<8 | (key)) +#define ACTION_MODS_ONESHOT(mods) ACTION(ACT_MODS_TAP, (mods)<<8 | MODS_ONESHOT) + + +/* + * Other Keys + */ +enum usage_pages { + PAGE_SYSTEM, + PAGE_CONSUMER +}; +#define ACTION_USAGE_SYSTEM(id) ACTION(ACT_USAGE, PAGE_SYSTEM<<10 | (id)) +#define ACTION_USAGE_CONSUMER(id) ACTION(ACT_USAGE, PAGE_CONSUMER<<10 | (id)) +#define ACTION_MOUSEKEY(key) ACTION(ACT_MOUSEKEY, key) + + + +/* + * Layer Actions + */ +enum layer_param_on { + ON_PRESS = 1, + ON_RELEASE = 2, + ON_BOTH = 3, +}; +enum layer_param_bit_op { + OP_BIT_AND = 0, + OP_BIT_OR = 1, + OP_BIT_XOR = 2, + OP_BIT_SET = 3, +}; +enum layer_pram_tap_op { + OP_TAP_TOGGLE = 0xF0, + OP_ON_OFF, + OP_OFF_ON, + OP_SET_CLEAR, +}; +#define ACTION_LAYER_BITOP(op, part, bits, on) (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | ((bits)&0x1f)) +#define ACTION_LAYER_TAP(layer, key) (ACT_LAYER_TAP<<12 | (layer)<<8 | (key)) +/* Layer Operation */ +#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_AND(0x1f, (on)) +#define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer) +#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE) +#define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer)/4, 1<<((layer)%4), (on)) +#define ACTION_LAYER_ON(layer, on) ACTION_LAYER_BIT_OR( (layer)/4, 1<<((layer)%4), (on)) +#define ACTION_LAYER_OFF(layer, on) ACTION_LAYER_BIT_AND((layer)/4, ~(1<<((layer)%4)), (on)) +#define ACTION_LAYER_SET(layer, on) ACTION_LAYER_BIT_SET((layer)/4, 1<<((layer)%4), (on)) +#define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF) +#define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON) +#define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR) +/* Bitwise Operation */ +#define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), (on)) +#define ACTION_LAYER_BIT_OR( part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), (on)) +#define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), (on)) +#define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), (on)) +/* Default Layer */ +#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer)/4, 1<<((layer)%4)) +/* Default Layer Bitwise Operation */ +#define ACTION_DEFAULT_LAYER_BIT_AND(part, bits) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), 0) +#define ACTION_DEFAULT_LAYER_BIT_OR( part, bits) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), 0) +#define ACTION_DEFAULT_LAYER_BIT_XOR(part, bits) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), 0) +#define ACTION_DEFAULT_LAYER_BIT_SET(part, bits) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), 0) +/* With Tapping */ +#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key)) +#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE) + + +/* + * Extensions + */ +/* Macro */ +#define ACTION_MACRO(id) ACTION(ACT_MACRO, (id)) +#define ACTION_MACRO_TAP(id) ACTION(ACT_MACRO, FUNC_TAP<<8 | (id)) +#define ACTION_MACRO_OPT(id, opt) ACTION(ACT_MACRO, (opt)<<8 | (id)) +/* Command */ +#define ACTION_COMMAND(id, opt) ACTION(ACT_COMMAND, (opt)<<8 | (addr)) +/* Function */ +enum function_opts { + FUNC_TAP = 0x8, /* indciates function is tappable */ +}; +#define ACTION_FUNCTION(id) ACTION(ACT_FUNCTION, (id)) +#define ACTION_FUNCTION_TAP(id) ACTION(ACT_FUNCTION, FUNC_TAP<<8 | (id)) +#define ACTION_FUNCTION_OPT(id, opt) ACTION(ACT_FUNCTION, (opt)<<8 | (id)) + +#endif /* ACTION_CODE_H */ -- cgit v1.2.3 From f9a7e224a4de28e52d268c801dc12c8de8c79b3f Mon Sep 17 00:00:00 2001 From: tmk Date: Thu, 4 Apr 2013 16:29:44 +0900 Subject: Fix ACT_MODS action and switch_default_layer command --- common/action.c | 9 ++------- common/command.c | 2 +- 2 files changed, 3 insertions(+), 8 deletions(-) (limited to 'common') diff --git a/common/action.c b/common/action.c index 158522dd03..0651887444 100644 --- a/common/action.c +++ b/common/action.c @@ -72,22 +72,17 @@ void process_action(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(); } 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) { + unregister_code(action.key.code); + if (mods) { host_del_mods(mods); host_send_keyboard_report(); } - unregister_code(action.key.code); } } break; diff --git a/common/command.c b/common/command.c index dc06c6da35..3a1fcb186e 100644 --- a/common/command.c +++ b/common/command.c @@ -574,7 +574,7 @@ static uint8_t numkey2num(uint8_t code) static void switch_default_layer(uint8_t layer) { print("switch_default_layer: "); print_dec(biton32(default_layer_state)); + print(" to "); print_dec(layer); print("\n"); default_layer_set(layer); - print(" to "); print_dec(biton32(default_layer_state)); print("\n"); clear_keyboard(); } -- cgit v1.2.3 From 489fd75fdfa279e82e92af73e3489ff012c4eef1 Mon Sep 17 00:00:00 2001 From: tmk Date: Fri, 5 Apr 2013 01:39:17 +0900 Subject: Fix keymap of gh60 --- common/action_code.h | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) (limited to 'common') diff --git a/common/action_code.h b/common/action_code.h index 8ebcc833dc..0933dce136 100644 --- a/common/action_code.h +++ b/common/action_code.h @@ -40,7 +40,7 @@ along with this program. If not, see . * * Other Keys(01xx) * ---------------- - * ACT_USAGE(0100): + * ACT_USAGE(0100): TODO: Not needed? * 0100|00| usage(10) System control(0x80) - General Desktop page(0x01) * 0100|01| usage(10) Consumer control(0x01) - Consumer page(0x0C) * 0100|10| usage(10) (reserved) @@ -66,6 +66,7 @@ along with this program. If not, see . * ee: on event(00:default layer, 01:press, 10:release, 11:both) * * 1001|xxxx|xxxx xxxx (reserved) + * 1001|oopp|BBBB BBBB 8-bit Bitwise Operation??? * * ACT_LAYER_TAP(101x): * 101E|LLLL| keycode Invert with tap key @@ -240,8 +241,10 @@ enum layer_pram_tap_op { }; #define ACTION_LAYER_BITOP(op, part, bits, on) (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | ((bits)&0x1f)) #define ACTION_LAYER_TAP(layer, key) (ACT_LAYER_TAP<<12 | (layer)<<8 | (key)) +/* Default Layer */ +#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer)/4, 1<<((layer)%4)) /* Layer Operation */ -#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_AND(0x1f, (on)) +#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_BIT_AND(0, 0, (on)) #define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer) #define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE) #define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer)/4, 1<<((layer)%4), (on)) @@ -251,21 +254,19 @@ enum layer_pram_tap_op { #define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF) #define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON) #define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR) +/* With Tapping */ +#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key)) +#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE) /* Bitwise Operation */ #define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), (on)) #define ACTION_LAYER_BIT_OR( part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), (on)) #define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), (on)) #define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), (on)) -/* Default Layer */ -#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer)/4, 1<<((layer)%4)) /* Default Layer Bitwise Operation */ #define ACTION_DEFAULT_LAYER_BIT_AND(part, bits) ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), 0) #define ACTION_DEFAULT_LAYER_BIT_OR( part, bits) ACTION_LAYER_BITOP(OP_BIT_OR, (part), (bits), 0) #define ACTION_DEFAULT_LAYER_BIT_XOR(part, bits) ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), 0) #define ACTION_DEFAULT_LAYER_BIT_SET(part, bits) ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), 0) -/* With Tapping */ -#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key)) -#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE) /* -- cgit v1.2.3 From fbea2a3aae5d66ecb00fcd3473f76337d34688fa Mon Sep 17 00:00:00 2001 From: tmk Date: Fri, 5 Apr 2013 03:27:10 +0900 Subject: Fix keymap of hhkb for new actions --- common/action.h | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'common') diff --git a/common/action.h b/common/action.h index 5f659337f9..98c4ef81a6 100644 --- a/common/action.h +++ b/common/action.h @@ -25,18 +25,20 @@ along with this program. If not, see . #include "action_macro.h" +/* tapping count and state */ +typedef struct { + bool interrupted :1; + bool reserved2 :1; + bool reserved1 :1; + bool reserved0 :1; + uint8_t count :4; +} tap_t; + /* Key event container for recording */ typedef struct { keyevent_t event; #ifndef NO_ACTION_TAPPING - /* tapping count and state */ - struct { - bool interrupted :1; - bool reserved2 :1; - bool reserved1 :1; - bool reserved0 :1; - uint8_t count :4; - } tap; + tap_t tap; #endif } keyrecord_t; -- cgit v1.2.3