From d9f287586635a401b8d6a80614bee6dbebe2f18c Mon Sep 17 00:00:00 2001 From: tmk Date: Fri, 15 Feb 2013 18:48:36 +0900 Subject: Replace layer_stack with layer_switch --- common/action.c | 50 ++++++++++------------- common/action.h | 39 +++++++++--------- common/command.c | 4 +- common/layer_stack.c | 108 -------------------------------------------------- common/layer_stack.h | 45 --------------------- common/layer_switch.c | 68 +++++++++++++++++++++++++++++++ common/layer_switch.h | 36 +++++++++++++++++ 7 files changed, 146 insertions(+), 204 deletions(-) delete mode 100644 common/layer_stack.c delete mode 100644 common/layer_stack.h create mode 100644 common/layer_switch.c create mode 100644 common/layer_switch.h (limited to 'common') diff --git a/common/action.c b/common/action.c index 9a8d75596a..4f0a5f9064 100644 --- a/common/action.c +++ b/common/action.c @@ -24,7 +24,7 @@ along with this program. If not, see . #include "util.h" #include "debug.h" #include "action.h" -#include "layer_stack.h" +#include "layer_switch.h" /* default layer indicates base layer */ @@ -213,8 +213,8 @@ static action_t get_action(key_t key) action_t action; action.code = ACTION_NO; - /* layer stack */ - action = layer_stack_get_action(key); + /* layer_switch */ + action = layer_switch_get_action(key); if (action.code != ACTION_TRANSPARENT) { return action; } @@ -531,45 +531,38 @@ static void process_action(keyrecord_t *record) break; } break; - case ACT_LAYER_STACK: + case ACT_LAYER_SWITCH: switch (action.layer.code) { case LAYER_MOMENTARY: /* momentary */ if (event.pressed) { - layer_stack_remove_then_push(action.layer.val); - layer_stack_debug(); + layer_switch_on(action.layer.val); } else { - layer_stack_remove(action.layer.val); - layer_stack_debug(); + layer_switch_off(action.layer.val); } break; case LAYER_ON_PRESS: if (event.pressed) { - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + layer_switch_inv(action.layer.val); } break; case LAYER_ON_RELEASE: if (!event.pressed) { - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + layer_switch_inv(action.layer.val); } break; case LAYER_ON_BOTH: - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + layer_switch_inv(action.layer.val); break; case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { - debug("LAYER_STACK: tap toggle(press).\n"); - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + debug("LAYER_SWITCH: tap toggle(press).\n"); + layer_switch_inv(action.layer.val); } } else { if (tap_count <= TAPPING_TOGGLE) { - debug("LAYER_STACK: tap toggle(release).\n"); - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + debug("LAYER_SWITCH: tap toggle(release).\n"); + layer_switch_inv(action.layer.val); } } break; @@ -577,21 +570,19 @@ static void process_action(keyrecord_t *record) // tap key if (event.pressed) { if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_STACK: Tap: register_code\n"); + debug("LAYER_SWITCH: Tap: register_code\n"); register_code(action.layer.code); } else { - debug("LAYER_STACK: No tap: layer_stack(on press)\n"); - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + debug("LAYER_SWITCH: No tap: layer_switch(on press)\n"); + layer_switch_inv(action.layer.val); } } else { if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_STACK: Tap: unregister_code\n"); + debug("LAYER_SWITCH: Tap: unregister_code\n"); unregister_code(action.layer.code); } else { - debug("LAYER_STACK: No tap: layer_stack(on release)\n"); - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + debug("LAYER_SWITCH: No tap: layer_switch(on release)\n"); + layer_switch_inv(action.layer.val); } } break; @@ -898,6 +889,7 @@ bool sending_anykey(void) host_last_sysytem_report() || host_last_consumer_report()); } +// TODO: rename or reinpl with new layer_switch.c void layer_switch(uint8_t new_layer) { if (current_layer != new_layer) { @@ -966,7 +958,7 @@ static void debug_action(action_t action) case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; case ACT_LAYER: debug("ACT_LAYER"); break; case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break; - case ACT_LAYER_STACK: debug("ACT_LAYER_STACK"); break; + case ACT_LAYER_SWITCH: debug("ACT_LAYER_SWITCH"); 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 96b8ba2ed7..1d00e02d54 100644 --- a/common/action.h +++ b/common/action.h @@ -163,9 +163,6 @@ bool waiting_buffer_has_anykey_pressed(void); * Layer Actions * ------------- * ACT_LAYER(1000): Set layer - * ACT_LAYER_BIT(1001): Bit-op layer - * ACT_LAYER_STACK: Layer stack - * * 1000|LLLL|0000 0000 set current layer on press and return to default on release(momentary) * 1000|LLLL|0000 0001 set current layer on press * 1000|LLLL|0000 0010 set current layer on release @@ -175,6 +172,7 @@ bool waiting_buffer_has_anykey_pressed(void); * 1000|DDDD|1111 1111 set default layer on press * L: 0 means default layer * + * ACT_LAYER_BIT(1001): Bit-op layer * 1001|BBBB|0000 0000 bit-on current layer on press and bit-off on release(momentary) * 1001|BBBB|0000 0001 bit-xor current layer on press * 1001|BBBB|0000 0010 bit-xor current layer on release @@ -183,12 +181,13 @@ bool waiting_buffer_has_anykey_pressed(void); * 1001|BBBB|1111 0000 bit-xor current layer on hold and toggle on several taps * 1001|BBBB|1111 1111 bit-xor default layer on both * - * 1011|LLLL|0000 0000 push on press and remove on release(momentary) - * 1011|LLLL|0000 0001 push or remove on press - * 1011|LLLL|0000 0010 push or remove on release - * 1011|LLLL|0000 0011 push or remove on both - * 1011|LLLL| keycode push or remove on hold and send key on tap - * 1011|LLLL|1111 0000 push or remove on hold and toggle on several taps + * ACT_LAYER_SWITCH: Switch + * 1011|LLLL|0000 0000 On on press and Off on release(momentary) + * 1011|LLLL|0000 0001 Invert on press + * 1011|LLLL|0000 0010 Invert on release + * 1011|LLLL|0000 0011 Invert on both + * 1011|LLLL| keycode Invert on hold and send key on tap + * 1011|LLLL|1111 0000 Invert on hold and toggle on several taps * 1011|LLLL|1111 1111 (not used) * * @@ -219,7 +218,7 @@ enum action_kind_id { ACT_LAYER = 0b1000, ACT_LAYER_BIT = 0b1001, - ACT_LAYER_STACK = 0b1011, + ACT_LAYER_SWITCH = 0b1011, ACT_MACRO = 0b1100, ACT_COMMAND = 0b1110, @@ -233,7 +232,7 @@ enum action_kind_id { #define ACTION(kind, param) ((kind)<<12 | (param)) #define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F) -/* +/* * Key */ #define ACTION_KEY(key) ACTION(ACT_LMODS, key) @@ -316,17 +315,17 @@ enum layer_codes { #define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE) #define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) /* - * Layer Stack + * Layer SWITCH */ /* momentary */ -#define ACTION_LAYER_STACK(layer) ACTION_LAYER_STACK_MOMENTARY(layer) -#define ACTION_LAYER_STACK_MOMENTARY(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_MOMENTARY) -#define ACTION_LAYER_STACK_TOGGLE(layer) ACTION_LAYER_STACK_R(layer) -#define ACTION_LAYER_STACK_P(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_PRESS) -#define ACTION_LAYER_STACK_R(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_RELEASE) -#define ACTION_LAYER_STACK_B(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_BOTH) -#define ACTION_LAYER_STACK_TAP_TOGGLE(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_TAP_TOGGLE) -#define ACTION_LAYER_STACK_TAP_KEY(layer, key) ACTION(ACT_LAYER_STACK, (layer)<<8 | (key)) +#define ACTION_LAYER_SWITCH(layer) ACTION_LAYER_SWITCH_MOMENTARY(layer) +#define ACTION_LAYER_SWITCH_MOMENTARY(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_MOMENTARY) +#define ACTION_LAYER_SWITCH_TOGGLE(layer) ACTION_LAYER_SWITCH_R(layer) +#define ACTION_LAYER_SWITCH_P(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_PRESS) +#define ACTION_LAYER_SWITCH_R(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_RELEASE) +#define ACTION_LAYER_SWITCH_B(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_BOTH) +#define ACTION_LAYER_SWITCH_TAP_TOGGLE(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_TAP_TOGGLE) +#define ACTION_LAYER_SWITCH_TAP_KEY(layer, key) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | (key)) /* diff --git a/common/command.c b/common/command.c index c5b9f0431c..82f647c8f3 100644 --- a/common/command.c +++ b/common/command.c @@ -26,8 +26,8 @@ along with this program. If not, see . #include "timer.h" #include "keyboard.h" #include "bootloader.h" +#include "layer_switch.h" #include "command.h" -#include "layer_stack.h" #ifdef MOUSEKEY_ENABLE #include "mousekey.h" @@ -549,6 +549,6 @@ static void switch_default_layer(uint8_t layer) default_layer = layer; current_layer = 0; /* 0 means default_layer */ - layer_stack_clear(); + layer_switch_clear(); clear_keyboard(); } diff --git a/common/layer_stack.c b/common/layer_stack.c deleted file mode 100644 index 0076bf7795..0000000000 --- a/common/layer_stack.c +++ /dev/null @@ -1,108 +0,0 @@ -#include -#include "keyboard.h" -#include "layer_stack.h" -#include "debug.h" - - -static uint8_t top_layer = 0; - -/* [0] always works as sentinel and not used for store.*/ -static layer_item_t layer_stack[LAYER_STACK_SIZE] = {}; - - -void layer_stack_clear(void) -{ - for (uint8_t i = 0; i < LAYER_STACK_SIZE; i++) { - layer_stack[i] = (layer_item_t){ .layer = 0, - .next = 0, - .used = false }; - } -} - -bool layer_stack_push(uint8_t layer) -{ - for (uint8_t i = 1; i < LAYER_STACK_SIZE; i++) { - if (!layer_stack[i].used) { - layer_stack[i] = (layer_item_t){ .layer = layer, - .next = top_layer, - .used = true }; - top_layer = i; - return true; - } - } - return false; -} - -bool layer_stack_pop(void) -{ - if (layer_stack[top_layer].used) { - uint8_t popped = top_layer; - top_layer = layer_stack[popped].next; - layer_stack[popped] = (layer_item_t){}; - return true; - } - return false; -} - -bool layer_stack_remove(uint8_t layer) -{ - if (layer_stack[top_layer].used && layer_stack[top_layer].layer == layer) { - layer_stack_pop(); - debug("layer_stack_remove: top_layer\n"); - return true; - } - - for (uint8_t i = top_layer; layer_stack[i].used; i = layer_stack[i].next) { - debug("layer_stack_remove: ["); debug_dec(i); debug("]"); - debug_dec(layer_stack[i].layer); debug("\n"); - uint8_t removed = layer_stack[i].next; - if (layer_stack[removed].used && layer_stack[removed].layer == layer) { - layer_stack[i].next = layer_stack[removed].next; - layer_stack[removed] = (layer_item_t){}; - debug("layer_stack_remove: removed.\n"); - return true; - } - } - return false; -} - -bool layer_stack_remove_then_push(uint8_t layer) -{ - layer_stack_remove(layer); - return layer_stack_push(layer); -} - -bool layer_stack_remove_or_push(uint8_t layer) -{ - return (layer_stack_remove(layer)) || layer_stack_push(layer); -} - -void layer_stack_debug(void) -{ - debug("layer_stack: "); - layer_item_t item = layer_stack[top_layer]; - while (item.used) { - debug_dec(item.layer); - debug("["); debug_dec(item.next); debug("] "); - item = layer_stack[item.next]; - } - debug("\n"); -} - -action_t layer_stack_get_action(key_t key) -{ - action_t action; - action.code = ACTION_TRANSPARENT; - - /* layer stack */ - for (layer_item_t i = layer_stack[top_layer]; i.used; i = layer_stack[i.next]) { - action = action_for_key(i.layer, key); - if (action.code != ACTION_TRANSPARENT) { - layer_stack_debug(); - debug("layer_stack: used. "); debug_dec(i.layer); debug("\n"); - return action; - } - debug("layer_stack: through. "); debug_dec(i.layer); debug("\n"); - } - return action; -} diff --git a/common/layer_stack.h b/common/layer_stack.h deleted file mode 100644 index 25bf37a5b1..0000000000 --- a/common/layer_stack.h +++ /dev/null @@ -1,45 +0,0 @@ -/* -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 LAYER_STACK_H -#define LAYER_STACK_H - -#include -#include "action.h" - - -/* - * Layer stack - */ -#define LAYER_STACK_SIZE 8 -typedef struct { - uint8_t layer:4; - uint8_t next:3; - bool used; -} layer_item_t; - - -void layer_stack_clear(void); -bool layer_stack_push(uint8_t layer); -bool layer_stack_pop(void); -bool layer_stack_remove(uint8_t layer); -bool layer_stack_remove_then_push(uint8_t layer); -bool layer_stack_remove_or_push(uint8_t layer); -void layer_stack_debug(void); -action_t layer_stack_get_action(key_t key); - -#endif - diff --git a/common/layer_switch.c b/common/layer_switch.c new file mode 100644 index 0000000000..9bc804e641 --- /dev/null +++ b/common/layer_switch.c @@ -0,0 +1,68 @@ +#include +#include "keyboard.h" +#include "action.h" +#include "debug.h" +#include "layer_switch.h" + + +uint16_t layer_switch_stat = 0; + + +uint16_t layer_switch_stat_get(void) +{ + return layer_switch_stat; +} + +void layer_switch_stat_set(uint16_t stat) +{ + layer_switch_stat = stat; + layer_switch_debug(); +} + +void layer_switch_clear(void) +{ + layer_switch_stat = 0; + layer_switch_debug(); +} + +void layer_switch_on(uint8_t layer) +{ + layer_switch_stat |= (1<= 0; i--) { + if (layer_switch_stat & (1< + +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" + +uint16_t layer_switch_stat; + +uint16_t layer_switch_stat_get(void); +void layer_switch_stat_set(uint16_t stat); +void layer_switch_clear(void); +void layer_switch_on(uint8_t layer); +void layer_switch_off(uint8_t layer); +/* invert state */ +void layer_switch_inv(uint8_t layer); +void layer_switch_debug(void); +action_t layer_switch_get_action(key_t key); + +#endif -- cgit v1.2.3