Replace layer_stack with layer_switch

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 \

common/action.c

@@ -24,7 +24,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #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 */
+    /* layer_switch */
-    action = layer_stack_get_action(key);
+    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_switch_on(action.layer.val);
-                        layer_stack_debug();
                     } else {
-                        layer_stack_remove(action.layer.val);
+                        layer_switch_off(action.layer.val);
-                        layer_stack_debug();
                     }
                     break;
                 case LAYER_ON_PRESS:
                     if (event.pressed) {
-                        layer_stack_remove_or_push(action.layer.val);
+                        layer_switch_inv(action.layer.val);
-                        layer_stack_debug();
                     }
                     break;
                 case LAYER_ON_RELEASE:
                     if (!event.pressed) {
-                        layer_stack_remove_or_push(action.layer.val);
+                        layer_switch_inv(action.layer.val);
-                        layer_stack_debug();
                     }
                     break;
                 case LAYER_ON_BOTH:
-                    layer_stack_remove_or_push(action.layer.val);
+                    layer_switch_inv(action.layer.val);
-                    layer_stack_debug();
                     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");
+                            debug("LAYER_SWITCH: tap toggle(press).\n");
-                            layer_stack_remove_or_push(action.layer.val);
+                            layer_switch_inv(action.layer.val);
-                            layer_stack_debug();
                         }
                     } else {
                         if (tap_count <= TAPPING_TOGGLE) {
-                            debug("LAYER_STACK: tap toggle(release).\n");
+                            debug("LAYER_SWITCH: tap toggle(release).\n");
-                            layer_stack_remove_or_push(action.layer.val);
+                            layer_switch_inv(action.layer.val);
-                            layer_stack_debug();
                         }
                     }
                     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");
+                            debug("LAYER_SWITCH: No tap: layer_switch(on press)\n");
-                            layer_stack_remove_or_push(action.layer.val);
+                            layer_switch_inv(action.layer.val);
-                            layer_stack_debug();
                         }
                     } 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");
+                            debug("LAYER_SWITCH: No tap: layer_switch(on release)\n");
-                            layer_stack_remove_or_push(action.layer.val);
+                            layer_switch_inv(action.layer.val);
-                            layer_stack_debug();
                         }
                     }
                     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;

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)
+ * ACT_LAYER_SWITCH:            Switch
- * 1011|LLLL|0000 0001   push or remove on press
+ * 1011|LLLL|0000 0000   On on press and Off on release(momentary)
- * 1011|LLLL|0000 0010   push or remove on release
+ * 1011|LLLL|0000 0001   Invert on press
- * 1011|LLLL|0000 0011   push or remove on both
+ * 1011|LLLL|0000 0010   Invert on release
- * 1011|LLLL| keycode    push or remove on hold and send key on tap
+ * 1011|LLLL|0000 0011   Invert on both
- * 1011|LLLL|1111 0000   push or remove on hold and toggle on several taps
+ * 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,
@@ -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_SWITCH(layer)              ACTION_LAYER_SWITCH_MOMENTARY(layer)
-#define ACTION_LAYER_STACK_MOMENTARY(layer)     ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_MOMENTARY)
+#define ACTION_LAYER_SWITCH_MOMENTARY(layer)    ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_MOMENTARY)
-#define ACTION_LAYER_STACK_TOGGLE(layer)        ACTION_LAYER_STACK_R(layer)
+#define ACTION_LAYER_SWITCH_TOGGLE(layer)       ACTION_LAYER_SWITCH_R(layer)
-#define ACTION_LAYER_STACK_P(layer)             ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_PRESS)
+#define ACTION_LAYER_SWITCH_P(layer)            ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_PRESS)
-#define ACTION_LAYER_STACK_R(layer)             ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_RELEASE)
+#define ACTION_LAYER_SWITCH_R(layer)            ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_RELEASE)
-#define ACTION_LAYER_STACK_B(layer)             ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_BOTH)
+#define ACTION_LAYER_SWITCH_B(layer)            ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_BOTH)
-#define ACTION_LAYER_STACK_TAP_TOGGLE(layer)    ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_TAP_TOGGLE)
+#define ACTION_LAYER_SWITCH_TAP_TOGGLE(layer)   ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_TAP_TOGGLE)
-#define ACTION_LAYER_STACK_TAP_KEY(layer, key)  ACTION(ACT_LAYER_STACK, (layer)<<8 | (key))
+#define ACTION_LAYER_SWITCH_TAP_KEY(layer, key) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | (key))
 
 
 /*

common/command.c

@@ -26,8 +26,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #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();
 }

common/layer_stack.c

@@ -1,108 +0,0 @@
-#include <stdint.h>
-#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;
-}

common/layer_switch.c

@@ -0,0 +1,68 @@
+#include <stdint.h>
+#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<<layer);
+    layer_switch_debug();
+}
+
+void layer_switch_off(uint8_t layer)
+{
+    layer_switch_stat &= ~(1<<layer);
+    layer_switch_debug();
+}
+
+void layer_switch_inv(uint8_t layer)
+{
+    layer_switch_stat ^= (1<<layer);
+    layer_switch_debug();
+}
+
+void layer_switch_debug(void)
+{
+    debug("layer_switch_stat: "); debug_bin16(layer_switch_stat); debug("\n");
+}
+
+action_t layer_switch_get_action(key_t key)
+{
+    action_t action;
+    action.code = ACTION_TRANSPARENT;
+
+    /* higher layer first */
+    for (int8_t i = 15; i >= 0; i--) {
+        if (layer_switch_stat & (1<<i)) {
+            action = action_for_key(i, key);
+            if (action.code != ACTION_TRANSPARENT) {
+                layer_switch_debug();
+                debug("layer_switch: used. "); debug_dec(i); debug("\n");
+                return action;
+            }
+        }
+    }
+    return action;
+}

common/layer_switch.h

@@ -14,32 +14,23 @@ 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 <http://www.gnu.org/licenses/>.
 */
-#ifndef LAYER_STACK_H
+#ifndef LAYER_SWITCH_H
-#define LAYER_STACK_H
+#define LAYER_SWITCH_H
 
 #include <stdint.h>
+#include "keyboard.h"
 #include "action.h"
 
+uint16_t layer_switch_stat;
 
-/*
+uint16_t layer_switch_stat_get(void);
- * Layer stack
+void layer_switch_stat_set(uint16_t stat);
- */
+void layer_switch_clear(void);
-#define LAYER_STACK_SIZE 8
+void layer_switch_on(uint8_t layer);
-typedef struct {
+void layer_switch_off(uint8_t layer);
-    uint8_t layer:4;
+/* invert state */
-    uint8_t next:3;
+void layer_switch_inv(uint8_t layer);
-    bool    used;
+void layer_switch_debug(void);
-} layer_item_t;
+action_t layer_switch_get_action(key_t key);
-
-
-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
-