Merge branch 'layer_stack'

12 files changed, 500 insertions, 134 deletions

diff --git a/common.mk b/common.mk
index 86518f03fb..de22f2c8ce 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 6528cd46c8..9a8d75596a 100644
--- a/common/action.c
+++ b/common/action.c
@@ -24,6 +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"
 
 
 /* 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 b9a6cb5b40..96b8ba2ed7 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 7bb2a23f19..c5b9f0431c 100644
--- a/common/command.c
+++ b/common/command.c
@@ -27,6 +27,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #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 0000000000..0076bf7795
--- /dev/null
+++ b/common/layer_stack.c
@@ -0,0 +1,108 @@
+#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;
+}
diff --git a/common/layer_stack.h b/common/layer_stack.h
new file mode 100644
index 0000000000..25bf37a5b1
--- /dev/null
+++ b/common/layer_stack.h
@@ -0,0 +1,45 @@
+/*
+Copyright 2013 Jun Wako <wakojun@gmail.com>
+
+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 <http://www.gnu.org/licenses/>.
+*/
+#ifndef LAYER_STACK_H
+#define LAYER_STACK_H
+
+#include <stdint.h>
+#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/keyboard/gh60/Makefile.lufa b/keyboard/gh60/Makefile.lufa
index c8d3fa4943..7548d47855 100644
--- a/keyboard/gh60/Makefile.lufa
+++ b/keyboard/gh60/Makefile.lufa
@@ -124,3 +124,6 @@ plain: all
 
 poker: OPT_DEFS += -DKEYMAP_POKER
 poker: all
+
+poker_stack: OPT_DEFS += -DKEYMAP_POKER_STACK
+poker_stack: all
diff --git a/keyboard/gh60/Makefile.pjrc b/keyboard/gh60/Makefile.pjrc
index f253704faa..8bca1659bf 100644
--- a/keyboard/gh60/Makefile.pjrc
+++ b/keyboard/gh60/Makefile.pjrc
@@ -94,3 +94,6 @@ plain: all
 
 poker: OPT_DEFS += -DKEYMAP_POKER
 poker: all
+
+poker_stack: OPT_DEFS += -DKEYMAP_POKER_STACK
+poker_stack: all
diff --git a/keyboard/gh60/keymap.c b/keyboard/gh60/keymap.c
index a17c11fc3b..9438782f2e 100644
--- a/keyboard/gh60/keymap.c
+++ b/keyboard/gh60/keymap.c
@@ -64,6 +64,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     #include "keymap_plain.h"
 #elif defined(KEYMAP_POKER)
     #include "keymap_poker.h"
+#elif defined(KEYMAP_POKER_STACK)
+    #include "keymap_poker_stack.h"
 #else
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     /*
diff --git a/keyboard/gh60/keymap_poker.h b/keyboard/gh60/keymap_poker.h
index 186020b3bd..7dc4efe019 100644
--- a/keyboard/gh60/keymap_poker.h
+++ b/keyboard/gh60/keymap_poker.h
@@ -48,31 +48,52 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     /* Layer x100: Poker Default + Fn'd */
     KEYMAP_ANSI(
         ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS, \
-        TRNS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
+        CAPS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
         TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END,      TRNS, \
         TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL,           TRNS, \
         TRNS,TRNS,TRNS,          FN0,                     FN2, TRNS,TRNS,TRNS),
     /* Layer x101: Poker with Arrow + Fn'd */
     KEYMAP_ANSI(
         ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS, \
-        TRNS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
+        CAPS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
         TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END,      TRNS, \
-        TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL,           UP,   \
-        TRNS,TRNS,TRNS,          FN0,                     FN2, LEFT,DOWN,RGHT),
+        TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL,           PGUP, \
+        TRNS,TRNS,TRNS,          FN0,                     FN2, HOME,PGDN,END),
     /* Layer x110: Poker with Esc + Fn'd */
     KEYMAP_ANSI(
         GRV, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS, \
-        TRNS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
+        CAPS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
         TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END,      TRNS, \
         TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL,           TRNS, \
         TRNS,TRNS,TRNS,          FN0,                     FN2, TRNS,TRNS,TRNS),
     /* Layer x111: Poker with Arrow and Esc + Fn'd */
     KEYMAP_ANSI(
         GRV, F9,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS, \
-        TRNS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
+        CAPS,FN1, UP,  TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \
         TRN