diff --git a/common.mk b/common.mk index de22f2c8..5fb76e73 100644 --- a/common.mk +++ b/common.mk @@ -3,7 +3,7 @@ SRC += $(COMMON_DIR)/host.c \ $(COMMON_DIR)/keyboard.c \ $(COMMON_DIR)/action.c \ $(COMMON_DIR)/action_macro.c \ - $(COMMON_DIR)/layer_stack.c \ + $(COMMON_DIR)/layer_switch.c \ $(COMMON_DIR)/keymap.c \ $(COMMON_DIR)/command.c \ $(COMMON_DIR)/timer.c \ diff --git a/common/action.c b/common/action.c index 9a8d7559..246fd99d 100644 --- a/common/action.c +++ b/common/action.c @@ -24,13 +24,7 @@ along with this program. If not, see . #include "util.h" #include "debug.h" #include "action.h" -#include "layer_stack.h" - - -/* default layer indicates base layer */ -uint8_t default_layer = 0; -/* current layer indicates active layer at this time */ -uint8_t current_layer = 0; +#include "layer_switch.h" static void process_action(keyrecord_t *record); @@ -213,23 +207,14 @@ 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; } - /* current layer: 0 means default layer */ - if (current_layer) { - action = action_for_key(current_layer, key); - if (action.code != ACTION_TRANSPARENT) { - debug("current layer: used. "); debug_dec(current_layer); debug("\n"); - return action; - } - } - /* default layer */ - debug("default layer: used. \n"); + //debug("get_aciton: default layer: "); debug_dec(default_layer); debug("\n"); action = action_for_key(default_layer, key); return action; } @@ -242,7 +227,8 @@ static void process_action(keyrecord_t *record) if (IS_NOEVENT(event)) { return; } action_t action = get_action(event.key); - debug("ACTION: "); debug_action(action); debug("\n"); + debug("ACTION: "); debug_action(action); debug(" "); + layer_switch_debug(); debug("["); debug_dec(default_layer); debug("]\n"); switch (action.kind.id) { /* Key and Mods */ @@ -383,57 +369,57 @@ static void process_action(keyrecord_t *record) break; /* Layer key */ - case ACT_LAYER: + case ACT_LAYER_SET: switch (action.layer.code) { case LAYER_MOMENTARY: /* momentary */ if (event.pressed) { - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); } else { // NOTE: This is needed by legacy keymap support - layer_switch(0); + layer_switch_move(0); } break; case LAYER_ON_PRESS: if (event.pressed) { - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); } break; case LAYER_ON_RELEASE: if (!event.pressed) { - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); } break; case LAYER_ON_BOTH: - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); break; case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); } } else { if (tap_count >= TAPPING_TOGGLE) { debug("LAYER_PRESSED: tap toggle.\n"); - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); } } break; case LAYER_SET_DEFAULT_ON_PRESS: if (event.pressed) { default_layer = action.layer.val; - layer_switch(0); + layer_switch_move(0); } break; case LAYER_SET_DEFAULT_ON_RELEASE: if (!event.pressed) { default_layer = action.layer.val; - layer_switch(0); + layer_switch_move(0); } break; case LAYER_SET_DEFAULT_ON_BOTH: default_layer = action.layer.val; - layer_switch(0); + layer_switch_move(0); break; default: /* tap key */ @@ -443,7 +429,7 @@ static void process_action(keyrecord_t *record) register_code(action.layer.code); } else { debug("LAYER_SET: No tap: layer_set(on press)\n"); - layer_switch(action.layer.val); + layer_switch_move(action.layer.val); } } else { if (IS_TAPPING_KEY(event.key) && tap_count > 0) { @@ -452,7 +438,7 @@ static void process_action(keyrecord_t *record) } else { // NOTE: This is needed by legacy keymap support debug("LAYER_SET: No tap: return to default layer(on release)\n"); - layer_switch(0); + layer_switch_move(0); } } break; @@ -462,52 +448,52 @@ static void process_action(keyrecord_t *record) switch (action.layer.code) { case LAYER_MOMENTARY: /* momentary */ if (event.pressed) { - layer_switch(current_layer | action.layer.val); + layer_switch_move(layer_switch_get_layer() | action.layer.val); } else { - layer_switch(current_layer & ~action.layer.val); + layer_switch_move(layer_switch_get_layer() & ~action.layer.val); } break; case LAYER_ON_PRESS: if (event.pressed) { - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ action.layer.val); } break; case LAYER_ON_RELEASE: if (!event.pressed) { - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ action.layer.val); } break; case LAYER_ON_BOTH: - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ 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_BIT: tap toggle(press).\n"); - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ action.layer.val); } } else { if (tap_count <= TAPPING_TOGGLE) { debug("LAYER_BIT: tap toggle(release).\n"); - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ action.layer.val); } } break; case LAYER_SET_DEFAULT_ON_PRESS: if (event.pressed) { default_layer = default_layer ^ action.layer.val; - layer_switch(0); + layer_switch_move(default_layer); } break; case LAYER_SET_DEFAULT_ON_RELEASE: if (!event.pressed) { default_layer = default_layer ^ action.layer.val; - layer_switch(0); + layer_switch_move(default_layer); } break; case LAYER_SET_DEFAULT_ON_BOTH: default_layer = default_layer ^ action.layer.val; - layer_switch(0); + layer_switch_move(default_layer); break; default: // tap key @@ -517,7 +503,7 @@ static void process_action(keyrecord_t *record) register_code(action.layer.code); } else { debug("LAYER_BIT: No tap: layer_bit(on press)\n"); - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ action.layer.val); } } else { if (IS_TAPPING_KEY(event.key) && tap_count > 0) { @@ -525,51 +511,44 @@ static void process_action(keyrecord_t *record) unregister_code(action.layer.code); } else { debug("LAYER_BIT: No tap: layer_bit(on release)\n"); - layer_switch(current_layer ^ action.layer.val); + layer_switch_move(layer_switch_get_layer() ^ action.layer.val); } } 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_invert(action.layer.val); } break; case LAYER_ON_RELEASE: if (!event.pressed) { - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + layer_switch_invert(action.layer.val); } break; case LAYER_ON_BOTH: - layer_stack_remove_or_push(action.layer.val); - layer_stack_debug(); + layer_switch_invert(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_invert(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_invert(action.layer.val); } } break; @@ -577,21 +556,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_invert(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_invert(action.layer.val); } } break; @@ -898,18 +875,6 @@ bool sending_anykey(void) host_last_sysytem_report() || host_last_consumer_report()); } -void layer_switch(uint8_t new_layer) -{ - if (current_layer != new_layer) { - debug("Layer Switch: "); debug_hex(current_layer); - debug(" -> "); debug_hex(new_layer); debug("\n"); - - current_layer = new_layer; - clear_keyboard_but_mods(); // To avoid stuck keys - // NOTE: update mods with full scan of matrix? if modifier changes between layers - } -} - bool is_tap_key(key_t key) { action_t action = get_action(key); @@ -918,7 +883,7 @@ bool is_tap_key(key_t key) case ACT_LMODS_TAP: case ACT_RMODS_TAP: return true; - case ACT_LAYER: + case ACT_LAYER_SET: case ACT_LAYER_BIT: switch (action.layer.code) { case LAYER_MOMENTARY: @@ -964,9 +929,9 @@ static 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_LAYER: debug("ACT_LAYER"); break; + case ACT_LAYER_SET: debug("ACT_LAYER_SET"); 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 96b8ba2e..46ae809c 100644 --- a/common/action.h +++ b/common/action.h @@ -76,11 +76,6 @@ typedef union { -/* layer used currently */ -extern uint8_t current_layer; -/* layer to return or start with */ -extern uint8_t default_layer; - /* Execute action per keyevent */ void action_exec(keyevent_t event); @@ -155,17 +150,14 @@ bool waiting_buffer_has_anykey_pressed(void); * * Mouse Keys * ---------- - * TODO: can be combined with 'Other HID Usage'? to save action kind id. + * NOTE: can be combined with 'Other HID Usage'? to save action kind id. * ACT_MOUSEKEY(0110): * 0101|XXXX| keycode Mouse key * * * Layer Actions * ------------- - * ACT_LAYER(1000): Set layer - * ACT_LAYER_BIT(1001): Bit-op layer - * ACT_LAYER_STACK: Layer stack - * + * ACT_LAYER_SET(1000): Set layer * 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 +167,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 +176,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) * * @@ -217,9 +211,9 @@ enum action_kind_id { ACT_USAGE = 0b0100, ACT_MOUSEKEY = 0b0101, - ACT_LAYER = 0b1000, + ACT_LAYER_SET = 0b1000, ACT_LAYER_BIT = 0b1001, - ACT_LAYER_STACK = 0b1011, + ACT_LAYER_SWITCH = 0b1011, ACT_MACRO = 0b1100, ACT_COMMAND = 0b1110, @@ -233,7 +227,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) @@ -278,14 +272,14 @@ enum layer_codes { */ /* set default layer */ #define ACTION_LAYER_SET_DEFAULT(layer) ACTION_LAYER_SET_DEFAULT_R(layer) -#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS) -#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) -#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH) +#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS) +#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) +#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH) /* bit-xor default layer */ #define ACTION_LAYER_BIT_DEFAULT(bits) ACTION_LAYER_BIT_DEFAULT_R(bits) -#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS) -#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) -#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH) +#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS) +#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) +#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH) /* * Current layer: Return to default layer */ @@ -297,13 +291,13 @@ enum layer_codes { * Current layer: Set */ #define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) -#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY) +#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_MOMENTARY) #define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer) -#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS) -#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE) -#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_BOTH) -#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_TAP_TOGGLE) -#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key)) +#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_PRESS) +#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_RELEASE) +#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_BOTH) +#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_TAP_TOGGLE) +#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER_SET, (layer)<<8 | (key)) /* * Current layer: Bit-op */ @@ -316,17 +310,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 c5b9f043..2d01c95e 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" @@ -543,12 +543,9 @@ static uint8_t numkey2num(uint8_t code) static void switch_default_layer(uint8_t layer) { - print_val_hex8(current_layer); - print_val_hex8(default_layer); - print("switch to "); print_val_hex8(layer); - + // TODO check existence of layer or whether it can be used as default layer + print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(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 0076bf77..00000000 --- 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 25bf37a5..00000000 --- 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 00000000..22bfb34f --- /dev/null +++ b/common/layer_switch.c @@ -0,0 +1,104 @@ +#include +#include "keyboard.h" +#include "action.h" +#include "debug.h" +#include "util.h" +#include "layer_switch.h" + + +uint8_t default_layer = 0; + +uint16_t layer_switch_stat = 0; + + +uint16_t layer_switch_get_stat(void) +{ + return layer_switch_stat; +} + +/* return highest layer whose state is on */ +uint8_t layer_switch_get_layer(void) +{ + return biton16(layer_switch_stat); +} + +static inline void stat_set(uint16_t stat) +{ + debug("layer_switch: "); + layer_switch_debug(); debug(" to "); + + layer_switch_stat = stat; + + layer_switch_debug(); debug("\n"); + + clear_keyboard_but_mods(); // To avoid stuck keys +} + +void layer_switch_clear(void) +{ + stat_set(0); +} + + +void layer_switch_set(uint16_t stat) +{ + stat_set(stat); +} + +void layer_switch_move(uint8_t layer) +{ + if (layer) + stat_set(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" + + +/* base layer to fall back */ +extern uint8_t default_layer; + +/* layer status */ +extern uint16_t layer_switch_stat; + +/* return layer status */ +uint16_t layer_switch_get_stat(void); +/* return current active layer */ +uint8_t layer_switch_get_layer(void); + +/* switch off all layers */ +void layer_switch_clear(void); +/* set layer status */ +void layer_switch_set(uint16_t stat); +/* move to layer */ +void layer_switch_move(uint8_t layer); +/* switch on layer */ +void layer_switch_on(uint8_t layer); +/* switch off layer */ +void layer_switch_off(uint8_t layer); +/* switch state of layer */ +void layer_switch_invert(uint8_t layer); + +/* bitwise operation against layer status */ +void layer_switch_or(uint16_t stat); +void layer_switch_and(uint16_t stat); +void layer_switch_xor(uint16_t stat); + +void layer_switch_debug(void); + +/* return action depending on current layer status */ +action_t layer_switch_get_action(key_t key); + +#endif diff --git a/common/util.c b/common/util.c index 9d8fb932..ff1926d7 100644 --- a/common/util.c +++ b/common/util.c @@ -39,6 +39,7 @@ uint8_t bitpop16(uint16_t bits) } // 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) { uint8_t n = 0; @@ -47,3 +48,13 @@ uint8_t biton(uint8_t bits) if (bits >> 1) { bits >>= 1; n += 1;} return n; } + +uint8_t biton16(uint16_t bits) +{ + uint8_t n = 0; + 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 c3734487..58b7fdf1 100644 --- a/common/util.h +++ b/common/util.h @@ -31,5 +31,6 @@ along with this program. If not, see . uint8_t bitpop(uint8_t bits); uint8_t bitpop16(uint16_t bits); uint8_t biton(uint8_t bits); +uint8_t biton16(uint16_t bits); #endif