diff --git a/common.mk b/common.mk
index 86518f03..de22f2c8 100644
--- a/common.mk
+++ b/common.mk
@@ -3,6 +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)/keymap.c \
$(COMMON_DIR)/command.c \
$(COMMON_DIR)/timer.c \
diff --git a/common/action.c b/common/action.c
index 6528cd46..9a8d7559 100644
--- a/common/action.c
+++ b/common/action.c
@@ -24,6 +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 */
@@ -209,14 +210,27 @@ void action_exec(keyevent_t event)
static action_t get_action(key_t key)
{
- action_t action = action_for_key(current_layer, key);
+ action_t action;
+ action.code = ACTION_NO;
- /* Transparently use default layer */
- if (action.code == ACTION_TRANSPARENT) {
- // TODO: layer stacking
- action = action_for_key(default_layer, key);
- debug("TRNASPARENT: "); debug_hex16(action.code); debug("\n");
+ /* layer stack */
+ action = layer_stack_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");
+ action = action_for_key(default_layer, key);
return action;
}
@@ -287,7 +301,7 @@ static void process_action(keyrecord_t *record)
} else {
if (tap_count == 0) {
debug("MODS_TAP: Oneshot: cancel/del_mods\n");
- // cancel oneshot by holding.
+ // cancel oneshot on hold
oneshot_cancel();
del_mods(mods);
}
@@ -377,7 +391,7 @@ static void process_action(keyrecord_t *record)
}
else {
// NOTE: This is needed by legacy keymap support
- layer_switch(default_layer);
+ layer_switch(0);
}
break;
case LAYER_ON_PRESS:
@@ -390,22 +404,8 @@ static void process_action(keyrecord_t *record)
layer_switch(action.layer.val);
}
break;
- case LAYER_DEFAULT: /* default layer */
- switch (action.layer.val) {
- case DEFAULT_ON_BOTH:
- layer_switch(default_layer);
- break;
- case DEFAULT_ON_PRESS:
- if (event.pressed) {
- layer_switch(default_layer);
- }
- break;
- case DEFAULT_ON_RELEASE:
- if (!event.pressed) {
- layer_switch(default_layer);
- }
- break;
- }
+ case LAYER_ON_BOTH:
+ layer_switch(action.layer.val);
break;
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */
if (event.pressed) {
@@ -419,30 +419,40 @@ static void process_action(keyrecord_t *record)
}
}
break;
- case LAYER_CHANGE_DEFAULT: /* change default layer */
+ case LAYER_SET_DEFAULT_ON_PRESS:
if (event.pressed) {
default_layer = action.layer.val;
- layer_switch(default_layer);
+ layer_switch(0);
}
break;
- default: /* switch layer on hold and key on tap*/
+ case LAYER_SET_DEFAULT_ON_RELEASE:
+ if (!event.pressed) {
+ default_layer = action.layer.val;
+ layer_switch(0);
+ }
+ break;
+ case LAYER_SET_DEFAULT_ON_BOTH:
+ default_layer = action.layer.val;
+ layer_switch(0);
+ break;
+ default:
+ /* tap key */
if (event.pressed) {
- if (tap_count > 0) {
- debug("LAYER_PRESSED: Tap: register_code\n");
- register_code(action.layer.code);
- } else {
- debug("LAYER_PRESSED: No tap: layer_switch\n");
- layer_switch(action.layer.val);
- }
+ if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
+ debug("LAYER_SET: Tap: register_code\n");
+ register_code(action.layer.code);
+ } else {
+ debug("LAYER_SET: No tap: layer_set(on press)\n");
+ layer_switch(action.layer.val);
+ }
} else {
- if (tap_count > 0) {
- debug("LAYER_PRESSED: Tap: unregister_code\n");
+ if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
+ debug("LAYER_SET: Tap: unregister_code\n");
unregister_code(action.layer.code);
} else {
- //debug("LAYER_PRESSED: No tap: NO ACTION\n");
// NOTE: This is needed by legacy keymap support
- debug("LAYER_PRESSED: No tap: return to default layer\n");
- layer_switch(default_layer);
+ debug("LAYER_SET: No tap: return to default layer(on release)\n");
+ layer_switch(0);
}
}
break;
@@ -452,9 +462,9 @@ 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(current_layer | action.layer.val);
} else {
- layer_switch(current_layer ^ action.layer.val);
+ layer_switch(current_layer & ~action.layer.val);
}
break;
case LAYER_ON_PRESS:
@@ -467,6 +477,9 @@ static void process_action(keyrecord_t *record)
layer_switch(current_layer ^ action.layer.val);
}
break;
+ case LAYER_ON_BOTH:
+ layer_switch(current_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) {
@@ -480,24 +493,30 @@ static void process_action(keyrecord_t *record)
}
}
break;
- case 0xFF:
- // change default layer
+ case LAYER_SET_DEFAULT_ON_PRESS:
if (event.pressed) {
- default_layer = current_layer ^ action.layer.val;
- layer_switch(default_layer);
- } else {
- default_layer = current_layer ^ action.layer.val;
- layer_switch(default_layer);
+ default_layer = default_layer ^ action.layer.val;
+ layer_switch(0);
}
break;
+ case LAYER_SET_DEFAULT_ON_RELEASE:
+ if (!event.pressed) {
+ default_layer = default_layer ^ action.layer.val;
+ layer_switch(0);
+ }
+ break;
+ case LAYER_SET_DEFAULT_ON_BOTH:
+ default_layer = default_layer ^ action.layer.val;
+ layer_switch(0);
+ break;
default:
- // with tap key
+ // tap key
if (event.pressed) {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
debug("LAYER_BIT: Tap: register_code\n");
register_code(action.layer.code);
} else {
- debug("LAYER_BIT: No tap: layer_switch(bit on)\n");
+ debug("LAYER_BIT: No tap: layer_bit(on press)\n");
layer_switch(current_layer ^ action.layer.val);
}
} else {
@@ -505,13 +524,79 @@ static void process_action(keyrecord_t *record)
debug("LAYER_BIT: Tap: unregister_code\n");
unregister_code(action.layer.code);
} else {
- debug("LAYER_BIT: No tap: layer_switch(bit off)\n");
+ debug("LAYER_BIT: No tap: layer_bit(on release)\n");
layer_switch(current_layer ^ action.layer.val);
}
}
break;
}
break;
+ case ACT_LAYER_STACK:
+ switch (action.layer.code) {
+ case LAYER_MOMENTARY: /* momentary */
+ if (event.pressed) {
+ layer_stack_remove_then_push(action.layer.val);
+ layer_stack_debug();
+ } else {
+ layer_stack_remove(action.layer.val);
+ layer_stack_debug();
+ }
+ break;
+ case LAYER_ON_PRESS:
+ if (event.pressed) {
+ layer_stack_remove_or_push(action.layer.val);
+ layer_stack_debug();
+ }
+ break;
+ case LAYER_ON_RELEASE:
+ if (!event.pressed) {
+ layer_stack_remove_or_push(action.layer.val);
+ layer_stack_debug();
+ }
+ break;
+ case LAYER_ON_BOTH:
+ layer_stack_remove_or_push(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");
+ layer_stack_remove_or_push(action.layer.val);
+ layer_stack_debug();
+ }
+ } else {
+ if (tap_count <= TAPPING_TOGGLE) {
+ debug("LAYER_STACK: tap toggle(release).\n");
+ layer_stack_remove_or_push(action.layer.val);
+ layer_stack_debug();
+ }
+ }
+ break;
+ default:
+ // tap key
+ if (event.pressed) {
+ if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
+ debug("LAYER_STACK: 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();
+ }
+ } else {
+ if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
+ debug("LAYER_STACK: 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();
+ }
+ }
+ break;
+ }
+ break;
/* Extentions */
case ACT_MACRO:
@@ -839,7 +924,10 @@ bool is_tap_key(key_t key)
case LAYER_MOMENTARY:
case LAYER_ON_PRESS:
case LAYER_ON_RELEASE:
- case LAYER_DEFAULT:
+ case LAYER_ON_BOTH:
+ case LAYER_SET_DEFAULT_ON_PRESS:
+ case LAYER_SET_DEFAULT_ON_RELEASE:
+ case LAYER_SET_DEFAULT_ON_BOTH:
return false;
case LAYER_TAP_TOGGLE:
default: /* tap key */
@@ -876,8 +964,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: debug("ACT_LAYER"); break;
case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break;
+ case ACT_LAYER_STACK: debug("ACT_LAYER_STACK"); 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 b9a6cb5b..96b8ba2e 100644
--- a/common/action.h
+++ b/common/action.h
@@ -162,25 +162,34 @@ bool waiting_buffer_has_anykey_pressed(void);
*
* Layer Actions
* -------------
- * ACT_LAYER(1000): Set layer
- * ACT_LAYER_BIT(1001): Bit-op layer
+ * ACT_LAYER(1000): Set layer
+ * ACT_LAYER_BIT(1001): Bit-op layer
+ * ACT_LAYER_STACK: Layer stack
*
- * 1000|LLLL|0000 0000 set L to layer on press and set default on release(momentary)
- * 1000|LLLL|0000 0001 set L to layer on press
- * 1000|LLLL|0000 0010 set L to layer on release
- * 1000|----|0000 0011 set default to layer on both(return to default layer)
- * 1000|LLLL| keycode set L to layer while hold and send key on tap
- * 1000|LLLL|1111 0000 set L to layer while hold and toggle on several taps
- * 1000|LLLL|1111 1111 set L to default and layer(on press)
+ * 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
+ * 1000|LLLL|0000 0011 set current layer on both
+ * 1000|LLLL| keycode set current layer on hold and send key on tap
+ * 1000|LLLL|1111 0000 set current layer on hold and toggle on several taps
+ * 1000|DDDD|1111 1111 set default layer on press
+ * L: 0 means default layer
*
- * 1001|BBBB|0000 0000 (not used)
- * 1001|BBBB|0000 0001 bit-xor layer with B on press
- * 1001|BBBB|0000 0010 bit-xor layer with B on release
- * 1001|BBBB|0000 0011 bit-xor layer with B on both(momentary)
- * 1001|BBBB| keycode bit-xor layer with B while hold and send key on tap
- * 1001|BBBB|1111 0000 bit-xor layer with B while hold and toggle on several taps
- * 1001|BBBB|1111 1111 bit-xor default with B and set layer(on press)
+ * 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
+ * 1001|BBBB|0000 0011 bit-xor current layer on both
+ * 1001|BBBB| keycode bit-xor current layer on hold and send key on tap
+ * 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
+ * 1011|LLLL|1111 1111 (not used)
*
*
* Extensions(11XX)
@@ -210,6 +219,7 @@ enum action_kind_id {
ACT_LAYER = 0b1000,
ACT_LAYER_BIT = 0b1001,
+ ACT_LAYER_STACK = 0b1011,
ACT_MACRO = 0b1100,
ACT_COMMAND = 0b1110,
@@ -223,20 +233,20 @@ enum action_kind_id {
#define ACTION(kind, param) ((kind)<<12 | (param))
#define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F)
-/* Key */
+/*
+ * 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))
-/* Mod & 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))
-
-/* Mods + Tap key */
+/* Tap key */
enum mods_codes {
MODS_ONESHOT = 0x00,
};
@@ -244,7 +254,6 @@ enum mods_codes {
#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)
-/* Mod + Tap key */
#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))
@@ -252,73 +261,77 @@ enum mods_codes {
/*
- * Switch layer
+ * Layer switching
*/
enum layer_codes {
LAYER_MOMENTARY = 0,
LAYER_ON_PRESS = 1,
LAYER_ON_RELEASE = 2,
- LAYER_DEFAULT =3,
+ LAYER_ON_BOTH =3,
LAYER_TAP_TOGGLE = 0xF0,
- LAYER_CHANGE_DEFAULT = 0xFF
+ LAYER_SET_DEFAULT_ON_PRESS = 0xFD,
+ LAYER_SET_DEFAULT_ON_RELEASE = 0xFE,
+ LAYER_SET_DEFAULT_ON_BOTH = 0xFF
};
-enum layer_vals_default {
- DEFAULT_ON_PRESS = 1,
- DEFAULT_ON_RELEASE = 2,
- DEFAULT_ON_BOTH = 3,
-};
-
/*
- * return to default layer
+ * Default layer
+ */
+/* 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)
+/* 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)
+/*
+ * Current layer: Return to default layer
*/
#define ACTION_LAYER_DEFAULT ACTION_LAYER_DEFAULT_R
-/* set default layer on press */
-#define ACTION_LAYER_DEFAULT_P ACTION(ACT_LAYER, DEFAULT_ON_PRESS<<8 | LAYER_DEFAULT)
-/* set default layer on release */
-#define ACTION_LAYER_DEFAULT_R ACTION(ACT_LAYER, DEFAULT_ON_RELEASE<<8 | LAYER_DEFAULT)
-/* change default layer and set layer */
-
+#define ACTION_LAYER_DEFAULT_P ACTION_LAYER_SET_P(0)
+#define ACTION_LAYER_DEFAULT_R ACTION_LAYER_SET_R(0)
+#define ACTION_LAYER_DEFAULT_B ACTION_LAYER_SET_B(0)
/*
- * Set layer
+ * Current layer: Set
*/
-/* set layer on press and none on release */
#define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer)
-/* set layer on press and set default on release (This is needed by legacy keymap support.) */
#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY)
-/* set layer on press and none on release */
#define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer)
-/* set layer while hold and send key on tap */
-#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
-/* set layer on press */
#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS)
-/* set layer on release */
#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE)
-/* set layer on hold and toggle on several taps */
+#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)
-/* set default layer on both press and release */
-#define ACTION_LAYER_SET_DEFAULT(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_CHANGE_DEFAULT)
-
+#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
/*
- * Bit-op layer
+ * Current layer: Bit-op
*/
-/* bit-xor on both press and release */
#define ACTION_LAYER_BIT(bits) ACTION_LAYER_BIT_MOMENTARY(bits)
#define ACTION_LAYER_BIT_MOMENTARY(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_MOMENTARY)
-/* bit-xor on press */
#define ACTION_LAYER_BIT_TOGGLE(bits) ACTION_LAYER_BIT_R(bits)
-/* bit-xor while hold and send key on tap */
-#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key))
-/* bit-xor on press */
#define ACTION_LAYER_BIT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS)
-/* bit-xor on release */
#define ACTION_LAYER_BIT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE)
-/* bit-xor while hold and toggle on several taps */
+#define ACTION_LAYER_BIT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_BOTH)
#define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE)
-/* bit-xor default layer and set layer */
-#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_CHANGE_DEFAULT)
+#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key))
+/*
+ * Layer Stack
+ */
+/* 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))
-/* HID Usage */
+/*
+ * HID Usage
+ */
enum usage_pages {
PAGE_SYSTEM,
PAGE_CONSUMER
diff --git a/common/command.c b/common/command.c
index 7bb2a23f..c5b9f043 100644
--- a/common/command.c
+++ b/common/command.c
@@ -27,6 +27,8 @@ along with this program. If not, see .
#include "keyboard.h"
#include "bootloader.h"
#include "command.h"
+#include "layer_stack.h"
+
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#endif
@@ -53,7 +55,7 @@ static void mousekey_console_help(void);
#endif
static uint8_t numkey2num(uint8_t code);
-static void switch_layer(uint8_t layer);
+static void switch_default_layer(uint8_t layer);
typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t;
@@ -261,18 +263,16 @@ static bool command_common(uint8_t code)
#endif
break;
#endif
+ case KC_ESC:
+ case KC_GRV:
case KC_0:
- case KC_F10:
- clear_keyboard();
- switch_layer(0);
+ switch_default_layer(0);
break;
case KC_1 ... KC_9:
- clear_keyboard();
- switch_layer((code - KC_1) + 1);
+ switch_default_layer((code - KC_1) + 1);
break;
- case KC_F1 ... KC_F9:
- clear_keyboard();
- switch_layer((code - KC_F1) + 1);
+ case KC_F1 ... KC_F12:
+ switch_default_layer((code - KC_F1) + 1);
break;
default:
print("?");
@@ -541,11 +541,14 @@ static uint8_t numkey2num(uint8_t code)
return 0;
}
-static void switch_layer(uint8_t layer)
+static void switch_default_layer(uint8_t layer)
{
print_val_hex8(current_layer);
print_val_hex8(default_layer);
- current_layer = layer;
- default_layer = layer;
print("switch to "); print_val_hex8(layer);
+
+ default_layer = layer;
+ current_layer = 0; /* 0 means default_layer */
+ layer_stack_clear();
+ clear_keyboard();
}
diff --git a/common/layer_stack.c b/common/layer_stack.c
new file mode 100644
index 00000000..0076bf77
--- /dev/null
+++ b/common/layer_stack.c
@@ -0,0 +1,108 @@
+#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
new file mode 100644
index 00000000..25bf37a5
--- /dev/null
+++ b/common/layer_stack.h
@@ -0,0 +1,45 @@
+/*
+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/rules.mk b/rules.mk
index 2e4fce51..7a40d1de 100644
--- a/rules.mk
+++ b/rules.mk
@@ -340,7 +340,8 @@ LST = $(patsubst %.c,$(OBJDIR)/%.lst,$(patsubst %.cpp,$(OBJDIR)/%.lst,$(patsubst
# Compiler flags to generate dependency files.
-GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d
+#GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d
+GENDEPFLAGS = -MMD -MP -MF .dep/$(subst /,_,$@).d
# Combine all necessary flags and optional flags.