Merge branch 'action_refine'

12 files changed, 608 insertions, 942 deletions

diff --git a/common/action.c b/common/action.c
index 07a3a64d6c..0651887444 100644
--- a/common/action.c
+++ b/common/action.c
@@ -21,7 +21,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "command.h"
 #include "debug.h"
 #include "led.h"
-#include "layer_switch.h"
+#include "action_layer.h"
 #include "action_tapping.h"
 #include "action_oneshot.h"
 #include "action_macro.h"
@@ -50,15 +50,19 @@ void action_exec(keyevent_t event)
 void process_action(keyrecord_t *record)
 {
     keyevent_t event = record->event;
+#ifndef NO_ACTION_TAPPING
     uint8_t tap_count = record->tap.count;
+#endif
 
     if (IS_NOEVENT(event)) { return; }
 
     action_t action = layer_switch_get_action(event.key);
     debug("ACTION: "); debug_action(action);
-    debug(" overlays: "); overlay_debug();
-    debug(" keymaps: "); keymap_debug();
-    debug(" default_layer: "); debug_dec(default_layer); debug("\n");
+#ifndef NO_ACTION_LAYER
+    debug(" layer_state: "); layer_debug();
+    debug(" default_layer_state: "); default_layer_debug();
+#endif
+    debug("\n");
 
     switch (action.kind.id) {
         /* Key and Mods */
@@ -68,22 +72,17 @@ void process_action(keyrecord_t *record)
                 uint8_t mods = (action.kind.id == ACT_LMODS) ?  action.key.mods :
                                                                 action.key.mods<<4;
                 if (event.pressed) {
-                    uint8_t tmp_mods = host_get_mods();
                     if (mods) {
                         host_add_mods(mods);
                         host_send_keyboard_report();
                     }
                     register_code(action.key.code);
-                    if (mods && action.key.code) {
-                        host_set_mods(tmp_mods);
-                        host_send_keyboard_report();
-                    }
                 } else {
-                    if (mods && !action.key.code) {
+                    unregister_code(action.key.code);
+                    if (mods) {
                         host_del_mods(mods);
                         host_send_keyboard_report();
                     }
-                    unregister_code(action.key.code);
                 }
             }
             break;
@@ -93,7 +92,7 @@ void process_action(keyrecord_t *record)
             {
                 uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ?  action.key.mods :
                                                                     action.key.mods<<4;
-                switch (action.layer.code) {
+                switch (action.layer_tap.code) {
     #ifndef NO_ACTION_ONESHOT
                     case 0x00:
                         // Oneshot modifier
@@ -199,323 +198,88 @@ void process_action(keyrecord_t *record)
             }
             break;
 #endif
-#ifndef NO_ACTION_KEYMAP
-        case ACT_KEYMAP:
-            switch (action.layer.code) {
-                /* Keymap clear */
-                case OP_RESET:
-                    switch (action.layer.val & 0x03) {
-                        case 0:
-                            // NOTE: reserved
-                            overlay_clear();
-                            keymap_clear();
-                            break;
-                        case ON_PRESS:
-                            if (event.pressed) {
-                                overlay_clear();
-                                keymap_clear();
-                            }
-                            break;
-                        case ON_RELEASE:
-                            if (!event.pressed) {
-                                overlay_clear();
-                                keymap_clear();
-                            }
-                            break;
-                        case ON_BOTH:
-                            overlay_clear();
-                            keymap_clear();
-                            break;
-                        /* NOTE: 4-7 rserved */
+#ifndef NO_ACTION_LAYER
+        case ACT_LAYER:
+            if (action.layer_bitop.on == 0) {
+                /* Default Layer Bitwise Operation */
+                if (!event.pressed) {
+                    uint8_t shift = action.layer_bitop.part*4;
+                    uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
+                    uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
+                    switch (action.layer_bitop.op) {
+                        case OP_BIT_AND: default_layer_and(bits | mask); break;
+                        case OP_BIT_OR:  default_layer_or(bits | mask);  break;
+                        case OP_BIT_XOR: default_layer_xor(bits | mask); break;
+                        case OP_BIT_SET: default_layer_and(mask); default_layer_or(bits); break;
                     }
-                    break;
-                /* Keymap Reset default layer */
-                case (OP_RESET | ON_PRESS):
-                    if (event.pressed) {
-                        default_layer_set(action.layer.val);
-                    }
-                    break;
-                case (OP_RESET | ON_RELEASE):
-                    if (!event.pressed) {
-                        default_layer_set(action.layer.val);
+                }
+            } else {
+                /* Layer Bitwise Operation */
+                if (event.pressed ? (action.layer_bitop.on & ON_PRESS) :
+                                    (action.layer_bitop.on & ON_RELEASE)) {
+                    uint8_t shift = action.layer_bitop.part*4;
+                    uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
+                    uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
+                    switch (action.layer_bitop.op) {
+                        case OP_BIT_AND: layer_and(bits | mask); break;
+                        case OP_BIT_OR:  layer_or(bits | mask);  break;
+                        case OP_BIT_XOR: layer_xor(bits | mask); break;
+                        case OP_BIT_SET: layer_and(mask); layer_or(bits); break;
                     }
-                    break;
-                case (OP_RESET | ON_BOTH):
-                    default_layer_set(action.layer.val);
-                    break;
-
-                /* Keymap Bit invert */
-                case OP_INV:
-                    /* with tap toggle */
+                }
+            }
+            break;
+    #ifndef NO_ACTION_TAPPING
+        case ACT_LAYER_TAP:
+        case ACT_LAYER_TAP1:
+            switch (action.layer_tap.code) {
+                case OP_TAP_TOGGLE:
+                    /* tap toggle */
                     if (event.pressed) {
                         if (tap_count < TAPPING_TOGGLE) {
-                            debug("KEYMAP_INV: tap toggle(press).\n");
-                            keymap_invert(action.layer.val);
+                            layer_invert(action.layer_tap.val);
                         }
                     } else {
                         if (tap_count <= TAPPING_TOGGLE) {
-                            debug("KEYMAP_INV: tap toggle(release).\n");
-                            keymap_invert(action.layer.val);
+                            layer_invert(action.layer_tap.val);
                         }
                     }
                     break;
-                case (OP_INV | ON_PRESS):
-                    if (event.pressed) {
-                        keymap_invert(action.layer.val);
-                    }
-                    break;
-                case (OP_INV | ON_RELEASE):
-                    if (!event.pressed) {
-                        keymap_invert(action.layer.val);
-                    }
+                case OP_ON_OFF:
+                    event.pressed ? layer_on(action.layer_tap.val) :
+                                    layer_off(action.layer_tap.val);
                     break;
-                case (OP_INV | ON_BOTH):
-                    keymap_invert(action.layer.val);
+                case OP_OFF_ON:
+                    event.pressed ? layer_off(action.layer_tap.val) :
+                                    layer_on(action.layer_tap.val);
                     break;
-
-                /* Keymap Bit on */
-                case OP_ON:
-                    if (event.pressed) {
-                        keymap_on(action.layer.val);
-                    } else {
-                        keymap_off(action.layer.val);
-                    }
-                    break;
-                case (OP_ON | ON_PRESS):
-                    if (event.pressed) {
-                        keymap_on(action.layer.val);
-                    }
-                    break;
-                case (OP_ON | ON_RELEASE):
-                    if (!event.pressed) {
-                        keymap_on(action.layer.val);
-                    }
+                case OP_SET_CLEAR:
+                    event.pressed ? layer_move(action.layer_tap.val) :
+                                    layer_clear();
                     break;
-                case (OP_ON | ON_BOTH):
-                    keymap_on(action.layer.val);
-                    break;
-
-                /* Keymap Bit off */
-                case OP_OFF:
-                    if (event.pressed) {
-                        keymap_off(action.layer.val);
-                    } else {
-                        keymap_on(action.layer.val);
-                    }
-                    break;
-                case (OP_OFF | ON_PRESS):
-                    if (event.pressed) {
-                        keymap_off(action.layer.val);
-                    }
-                    break;
-                case (OP_OFF | ON_RELEASE):
-                    if (!event.pressed) {
-                        keymap_off(action.layer.val);
-                    }
-                    break;
-                case (OP_OFF | ON_BOTH):
-                    keymap_off(action.layer.val);
-                    break;
-
-                /* Keymap Bit set */
-                case OP_SET:
-                    if (event.pressed) {
-                        keymap_set(action.layer.val);
-                    } else {
-                        keymap_clear();
-                    }
-                    break;
-                case (OP_SET | ON_PRESS):
-                    if (event.pressed) {
-                        keymap_set(action.layer.val);
-                    }
-                    break;
-                case (OP_SET | ON_RELEASE):
-                    if (!event.pressed) {
-                        keymap_set(action.layer.val);
-                    }
-                    break;
-                case (OP_SET | ON_BOTH):
-                    keymap_set(action.layer.val);
-                    break;
-
-                /* Keymap Bit invert with tap key */
                 default:
+                    /* tap key */
                     if (event.pressed) {
                         if (tap_count > 0) {
                             debug("KEYMAP_TAP_KEY: Tap: register_code\n");
-                            register_code(action.layer.code);
+                            register_code(action.layer_tap.code);
                         } else {
                             debug("KEYMAP_TAP_KEY: No tap: On on press\n");
-                            keymap_on(action.layer.val);
+                            layer_on(action.layer_tap.val);
                         }
                     } else {
                         if (tap_count > 0) {
                             debug("KEYMAP_TAP_KEY: Tap: unregister_code\n");
-                            unregister_code(action.layer.code);
+                            unregister_code(action.layer_tap.code);
                         } else {
                             debug("KEYMAP_TAP_KEY: No tap: Off on release\n");
-                            keymap_off(action.layer.val);
-                        }
-                    }
-                    break;
-            }
-            break;
-#endif
-#ifndef NO_ACTION_OVERLAY
-        case ACT_OVERLAY:
-            switch (action.layer.code) {
-                // Overlay Invert bit4
-                case OP_INV4 | 0:
-                    if (action.layer.val == 0) {
-                        // NOTE: reserved for future use
-                        overlay_clear();
-                    } else {
-                        overlay_set(overlay_stat ^ action.layer.val);
-                    }
-                    break;
-                case OP_INV4 | 1:
-                    if (action.layer.val == 0) {
-                        // on pressed
-                        if (event.pressed) overlay_clear();
-                    } else {
-                        overlay_set(overlay_stat ^ action.layer.val<<4);
-                    }
-                    break;
-                case OP_INV4 | 2:
-                    if (action.layer.val == 0) {
-                        // on released
-                        if (!event.pressed) overlay_clear();
-                    } else {
-                        overlay_set(overlay_stat ^ action.layer.val<<8);
-                    }
-                    break;
-                case OP_INV4 | 3:
-                    if (action.layer.val == 0) {
-                        // on both
-                        overlay_clear();
-                    } else {
-                        overlay_set(overlay_stat ^ action.layer.val<<12);
-                    }
-                    break;
-
-                /* Overlay Bit invert */
-                case OP_INV:
-                    /* with tap toggle */
-                    if (event.pressed) {
-                        if (tap_count < TAPPING_TOGGLE) {
-                            debug("OVERLAY_INV: tap toggle(press).\n");
-                            overlay_invert(action.layer.val);
-                        }
-                    } else {
-                        if (tap_count <= TAPPING_TOGGLE) {
-                            debug("OVERLAY_INV: tap toggle(release).\n");
-                            overlay_invert(action.layer.val);
-                        }
-                    }
-                    break;
-                case (OP_INV | ON_PRESS):
-                    if (event.pressed) {
-                        overlay_invert(action.layer.val);
-                    }
-                    break;
-                case (OP_INV | ON_RELEASE):
-                    if (!event.pressed) {
-                        overlay_invert(action.layer.val);
-                    }
-                    break;
-                case (OP_INV | ON_BOTH):
-                    overlay_invert(action.layer.val);
-                    break;
-
-                /* Overlay Bit on */
-                case OP_ON:
-                    if (event.pressed) {
-                        overlay_on(action.layer.val);
-                    } else {
-                        overlay_off(action.layer.val);
-                    }
-                    break;
-                case (OP_ON | ON_PRESS):
-                    if (event.pressed) {
-                        overlay_on(action.layer.val);
-                    }
-                    break;
-                case (OP_ON | ON_RELEASE):
-                    if (!event.pressed) {
-                        overlay_on(action.layer.val);
-                    }
-                    break;
-                case (OP_ON | ON_BOTH):
-                    overlay_on(action.layer.val);
-                    break;
-
-                /* Overlay Bit off */
-                case OP_OFF:
-                    if (event.pressed) {
-                        overlay_off(action.layer.val);
-                    } else {
-                        overlay_on(action.layer.val);
-                    }
-                    break;
-                case (OP_OFF | ON_PRESS):
-                    if (event.pressed) {
-                        overlay_off(action.layer.val);
-                    }
-                    break;
-                case (OP_OFF | ON_RELEASE):
-                    if (!event.pressed) {
-                        overlay_off(action.layer.val);
-                    }
-                    break;
-                case (OP_OFF | ON_BOTH):
-                    overlay_off(action.layer.val);
-                    break;
-
-                /* Overlay Bit set */
-                case OP_SET:
-                    if (event.pressed) {
-                        overlay_move(action.layer.val);
-                    } else {
-                        overlay_clear();
-                    }
-                    break;
-                case (OP_SET | ON_PRESS):
-                    if (event.pressed) {
-                        overlay_move(action.layer.val);
-                    }
-                    break;
-                case (OP_SET | ON_RELEASE):
-                    if (!event.pressed) {
-                        overlay_move(action.layer.val);
-                    }
-                    break;
-                case (OP_SET | ON_BOTH):
-                    overlay_move(action.layer.val);
-                    break;
-
-                /* Overlay Bit invert with tap key */
-                default:
-                    if (event.pressed) {
-                        if (tap_count > 0) {
-                            debug("OVERLAY_TAP_KEY: Tap: register_code\n");
-                            register_code(action.layer.code);
-                        } else {
-                            debug("OVERLAY_TAP_KEY: No tap: On on press\n");
-                            overlay_on(action.layer.val);
-                        }
-                    } else {
-                        if (tap_count > 0) {
-                            debug("OVERLAY_TAP_KEY: Tap: unregister_code\n");
-                            unregister_code(action.layer.code);
-                        } else {
-                            debug("OVERLAY_TAP_KEY: No tap: Off on release\n");
-                            overlay_off(action.layer.val);
+                            layer_off(action.layer_tap.val);
                         }
                     }
                     break;
             }
             break;
+    #endif
 #endif
         /* Extentions */
 #ifndef NO_ACTION_MACRO
@@ -667,16 +431,9 @@ bool is_tap_key(key_t key)
     switch (action.kind.id) {
         case ACT_LMODS_TAP:
         case ACT_RMODS_TAP:
+        case ACT_LAYER_TAP:
+        case ACT_LAYER_TAP1:
             return true;
-        case ACT_KEYMAP:
-        case ACT_OVERLAY:
-            switch (action.layer.code) {
-                case 0x04 ... 0xEF:    /* tap key */
-                case OP_INV:
-                    return true;
-                default:
-                    return false;
-            }
         case ACT_MACRO:
         case ACT_FUNCTION:
             if (action.func.opt & FUNC_TAP) { return true; }
@@ -714,8 +471,9 @@ 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_KEYMAP:            debug("ACT_KEYMAP");            break;
-        case ACT_OVERLAY:           debug("ACT_OVERLAY");           break;
+        case ACT_LAYER:             debug("ACT_LAYER");             break;
+        case ACT_LAYER_TAP:         debug("ACT_LAYER_TAP");         break;
+        case ACT_LAYER_TAP1:        debug("ACT_LAYER_TAP1");        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 a6cb453840..98c4ef81a6 100644
--- a/common/action.h
+++ b/common/action.h
@@ -21,71 +21,27 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <stdbool.h>
 #include "keyboard.h"
 #include "keycode.h"
+#include "action_code.h"
 #include "action_macro.h"
 
 
+/* tapping count and state */
+typedef struct {
+    bool    interrupted :1;
+    bool    reserved2   :1;
+    bool    reserved1   :1;
+    bool    reserved0   :1;
+    uint8_t count       :4;
+} tap_t;
+
+/* Key event container for recording */
 typedef struct {
     keyevent_t  event;
 #ifndef NO_ACTION_TAPPING
-    /* tapping count and state */
-    struct {
-        bool    interrupted :1;
-        bool    reserved2   :1;
-        bool    reserved1   :1;
-        bool    reserved0   :1;
-        uint8_t count       :4;
-    } tap;
+    tap_t tap;
 #endif
 } keyrecord_t;
 
-/* Action struct.
- *
- * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15).
- * AVR looks like a little endian in avr-gcc.
- *
- * NOTE: not portable across compiler/endianness?
- * Byte order and bit order of 0x1234:
- * Big endian:     15 ...  8 7 ... 210
- *                |  0x12   |  0x34   |
- *                 0001 0010 0011 0100
- * Little endian:  012 ... 7  8 ... 15
- *                |  0x34   |  0x12   |
- *                 0010 1100 0100 1000
- */
-typedef union {
-    uint16_t code;
-    struct action_kind {
-        uint16_t param  :12;
-        uint8_t  id     :4;
-    } kind;
-    struct action_key {
-        uint8_t  code   :8;
-        uint8_t  mods   :4;
-        uint8_t  kind   :4;
-    } key;
-    struct action_layer {
-        uint8_t  code   :8;
-        uint8_t  val    :4;
-        uint8_t  kind   :4;
-    } layer;
-    struct action_usage {
-        uint16_t code   :10;
-        uint8_t  page   :2;
-        uint8_t  kind   :4;
-    } usage;
-    struct action_command {
-        uint8_t  id     :8;
-        uint8_t  opt    :4;
-        uint8_t  kind   :4;
-    } command;
-    struct action_function {
-        uint8_t  id     :8;
-        uint8_t  opt    :4;
-        uint8_t  kind   :4;
-    } func;
-} action_t;
-
-
 
 /* Execute action per keyevent */
 void action_exec(keyevent_t event);
@@ -117,255 +73,4 @@ void debug_event(keyevent_t event);
 void debug_record(keyrecord_t record);
 void debug_action(action_t action);
 
-
-
-/*
- * Action codes
- * ============
- * 16bit code: action_kind(4bit) + action_parameter(12bit)
- *
- * Keyboard Keys(00XX)
- * -------------------
- * ACT_LMODS(0000):
- * 0000|0000|000000|00    No action
- * 0000|0000|000000|01    Transparent
- * 0000|0000| keycode     Key
- * 0000|mods|000000|00    Left mods
- * 0000|mods| keycode     Key & Left mods
- *
- * ACT_RMODS(0001):
- * 0001|0000|000000|00    No action(not used)
- * 0001|0000|000000|01    Transparent(not used)
- * 0001|0000| keycode     Key(no used)
- * 0001|mods|000000|00    Right mods
- * 0001|mods| keycode     Key & Right mods
- *
- * ACT_LMODS_TAP(0010):
- * 0010|mods|000000|00    Left mods OneShot
- * 0010|mods|000000|01    (reserved)
- * 0010|mods|000000|10    (reserved)
- * 0010|mods|000000|11    (reserved)
- * 0010|mods| keycode     Left mods + tap Key
- *
- * ACT_RMODS_TAP(0011):
- * 0011|mods|000000|00    Right mods OneShot
- * 0011|mods|000000|01    (reserved)
- * 0011|mods|000000|10    (reserved)
- * 0011|mods|000000|11    (reserved)
- * 0011|mods| keycode     Right mods + tap Key
- *
- *
- * Other keys(01XX)
- * --------------------
- * This action handles other usages than keyboard.
- * ACT_USAGE(0100):
- * 0100|00| usage(10)     System control(0x80) - General Desktop page(0x01)
- * 0100|01| usage(10)     Consumer control(0x01) - Consumer page(0x0C)
- * 0100|10| usage(10)     (reserved)
- * 0100|11| usage(10)     (reserved)
- *
- * ACT_MOUSEKEY(0110):
- * 0101|XXXX| keycode     Mouse key
- *
- *
- * Layer Actions(10XX)
- * -------------------
- * ACT_KEYMAP:
- * 1000|--xx|0000 0000   Clear keyamp and overlay
- * 1000|LLLL|0000 00xx   Reset default layer and clear keymap and overlay
- * 1000|LLLL| keycode    Invert with tap key
- * 1000|LLLL|1111 0000   Invert with tap toggle
- * 1000|LLLL|1111 00xx   Invert[^=  1<<L]
- * 1000|LLLL|1111 0100   On/Off
- * 1000|LLLL|1111 01xx   On[|= 1<<L]
- * 1000|LLLL|1111 1000   Off/On
- * 1000|LLLL|1111 10xx   Off[&= ~(1<<L)]
- * 1000|LLLL|1111 1100   Set/Clear
- * 1000|LLLL|1111 11xx   Set[= 1<<L]
- * default layer: 0-15(4bit)
- * xx: On {00:for special use, 01:press, 10:release, 11:both}
- *
- * ACT_OVERLAY:
- * 1011|0000|0000 0000   Clear overlay
- * 1011|LLLL|0000 00ss   Invert 4-bit chunk [^= L<<(4*ss)]
- * 1011|LLLL| keycode    Invert with tap key
- * 1011|LLLL|1111 0000   Invert with tap toggle
- * 1011|LLLL|1111 00xx   Invert[^= 1<<L]
- * 1011|LLLL|1111 0100   On/Off(momentary)
- * 1011|LLLL|1111 01xx   On[|= 1<<L]
- * 1011|LLLL|1111 1000   Off/On
- * 1011|LLLL|1111 10xx   Off[&= ~(1<<L)]
- * 1011|LLLL|1111 1100   Set/Clear
- * 1011|LLLL|1111 11xx   Set[= 1<<L]
- * overlays: 16-layer on/off status(16bit)
- * xx: On {00:for special use, 01:press, 10:release, 11:both}
- *
- *
- * Extensions(11XX)
- * ----------------
- * ACT_MACRO(1100):
- * 1100|opt | id(8)      Macro play?
- * 1100|1111| id(8)      Macro record?
- *
- * ACT_COMMAND(1110):
- * 1110|opt | id(8)      Built-in Command exec
- *
- * ACT_FUNCTION(1111):
- * 1111| address(12)     Function?
- * 1111|opt | id(8)      Function?
- *
- */
-enum action_kind_id {
-    ACT_LMODS           = 0b0000,
-    ACT_RMODS           = 0b0001,
-    ACT_LMODS_TAP       = 0b0010,
-    ACT_RMODS_TAP       = 0b0011,
-
-    ACT_USAGE           = 0b0100,
-    ACT_MOUSEKEY        = 0b0101,
-
-    ACT_KEYMAP          = 0b1000,
-    ACT_OVERLAY         = 0b1001,
-
-    ACT_MACRO           = 0b1100,
-    ACT_COMMAND         = 0b1110,
-    ACT_FUNCTION        = 0b1111
-};
-
-
-/* action utility */
-#define ACTION_NO                       0
-#define ACTION_TRANSPARENT              1
-#define ACTION(kind, param)             ((kind)<<12 | (param))
-#define MODS4(mods)                     (((mods)>>4 | (mods)) & 0x0F)
-
-/*
- * 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))
-#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))
-/* Tap key */
-enum mods_codes {
-    MODS_ONESHOT           = 0x00,
-};
-#define ACTION_LMODS_TAP_KEY(mods, key) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | (key))
-#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)
-#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))
-#define ACTION_RMOD_ONESHOT(mod)        ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
-
-/* HID Usage */
-enum usage_pages {
-    PAGE_SYSTEM,
-    PAGE_CONSUMER
-};
-#define ACTION_USAGE_SYSTEM(id)         ACTION(ACT_USAGE, PAGE_SYSTEM<<10 | (id))
-#define ACTION_USAGE_CONSUMER(id)       ACTION(ACT_USAGE, PAGE_CONSUMER<<10 | (id))
-
-/* Mousekey */
-#define ACTION_MOUSEKEY(key)            ACTION(ACT_MOUSEKEY, key)
-
-
-
-/* Layer Actions:
- *      Invert  layer ^= (1<<layer)
- *      On      layer |= (1<<layer)
- *      Off     layer &= ~(1<<layer)
- *      Set     layer = (1<<layer)
- *      Clear   layer = 0
- */
-enum layer_params {
-    ON_PRESS    = 1,
-    ON_RELEASE  = 2,
-    ON_BOTH     = 3,
-
-    OP_RESET  = 0x00,
-    OP_INV4  = 0x00,
-    OP_INV   = 0xF0,
-    OP_ON    = 0xF4,
-    OP_OFF   = 0xF8,
-    OP_SET   = 0xFC,
-};
-
-/* 
- * Default Layer
- */
-#define ACTION_DEFAULT_LAYER                     ACTION(ACT_KEYMAP, ON_RELEASE<<8 | OP_RESET | 0)
-#define ACTION_DEFAULT_LAYER_SET(layer)          ACTION_DEFAULT_LAYER_TO(layer, ON_RELEASE)
-#define ACTION_DEFAULT_LAYER_TO(layer, on)       ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | (on))
-/*
- * Keymap Layer
- */
-#define ACTION_KEYMAP_MOMENTARY(layer)           ACTION_KEYMAP_ON_OFF(layer)
-#define ACTION_KEYMAP_TOGGLE(layer)              ACTION_KEYMAP_INV(layer, ON_RELEASE)
-/* Keymap Invert */
-#define ACTION_KEYMAP_INV(layer, on)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | (on))
-#define ACTION_KEYMAP_TAP_TOGGLE(layer)          ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | 0)
-/* Keymap On */
-#define ACTION_KEYMAP_ON(layer, on)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | (on))
-#define ACTION_KEYMAP_ON_OFF(layer)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | 0)
-/* Keymap Off */
-#define ACTION_KEYMAP_OFF(layer, on)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | (on))
-#define ACTION_KEYMAP_OFF_ON(layer)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | 0)
-/* Keymap Set */
-#define ACTION_KEYMAP_SET(layer, on)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | (on))
-#define ACTION_KEYMAP_SET_CLEAR(layer)           ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | 0)
-/* Keymap Invert with tap key */
-#define ACTION_KEYMAP_TAP_KEY(layer, key)        ACTION(ACT_KEYMAP, (layer)<<8 | (key))
-
-/*
- * Overlay Layer
- */
-#define ACTION_OVERLAY_MOMENTARY(layer)           ACTION_OVERLAY_ON_OFF(layer)
-#define ACTION_OVERLAY_TOGGLE(layer)              ACTION_OVERLAY_INV(layer, ON_RELEASE)
-/* Overlay Clear */
-#define ACTION_OVERLAY_CLEAR(on)                  ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | (on))
-/* Overlay Invert 4-bit chunk */
-#define ACTION_OVERLAY_INV4(bits, shift)          ACTION(ACT_OVERLAY, (bits)<<8 | OP_INV4 | shift)
-/* Overlay Invert */
-#define ACTION_OVERLAY_INV(layer, on)             ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | (on))
-#define ACTION_OVERLAY_TAP_TOGGLE(layer)          ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0)
-/* Overlay On */
-#define ACTION_OVERLAY_ON(layer, on)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | (on))
-#define ACTION_OVERLAY_ON_OFF(layer)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | 0)
-/* Overlay Off */
-#define ACTION_OVERLAY_OFF(layer, on)             ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | (on))
-#define ACTION_OVERLAY_OFF_ON(layer)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0)
-/* Overlay Set */
-#define ACTION_OVERLAY_SET(layer, on)             ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | (on))
-#define ACTION_OVERLAY_SET_CLEAR(layer)           ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0)
-/* Overlay Invert with tap key */
-#define ACTION_OVERLAY_TAP_KEY(layer, key)        ACTION(ACT_OVERLAY, (layer)<<8 | (key))
-
-
-/*
- * Extensions
- */
-/* Macro */
-#define ACTION_MACRO(id)                ACTION(ACT_MACRO, (id))
-#define ACTION_MACRO_TAP(id)            ACTION(ACT_MACRO, FUNC_TAP<<8 | (id))
-#define ACTION_MACRO_OPT(id, opt)       ACTION(ACT_MACRO, (opt)<<8 | (id))
-
-/* Command */
-#define ACTION_COMMAND(id, opt)         ACTION(ACT_COMMAND,  (opt)<<8 | (addr))
-
-/* Function */
-enum function_opts {
-    FUNC_TAP        = 0x8,      /* indciates function is tappable */
-};
-#define ACTION_FUNCTION(id)             ACTION(ACT_FUNCTION, (id))
-#define ACTION_FUNCTION_TAP(id)         ACTION(ACT_FUNCTION, FUNC_TAP<<8 | (id))
-#define ACTION_FUNCTION_OPT(id, opt)    ACTION(ACT_FUNCTION, (opt)<<8 | (id))
-
 #endif  /* ACTION_H */
diff --git a/common/action_code.h b/common/action_code.h
new file mode 100644
index 0000000000..0933dce136
--- /dev/null
+++ b/common/action_code.h
@@ -0,0 +1,289 @@
+/*
+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 ACTION_CODE_H
+#define ACTION_CODE_H
+
+/* Action codes
+ * ============
+ * 16bit code: action_kind(4bit) + action_parameter(12bit)
+ *
+ *
+ * Key Actions(00xx)
+ * -----------------
+ * ACT_MODS(000r):
+ * 000r|0000|0000 0000    No action code
+ * 000r|0000|0000 0001    Transparent code
+ * 000r|0000| keycode     Key
+ * 000r|mods|0000 0000    Modifiers
+ * 000r|mods| keycode     Key and Modifiers
+ *   r: Left/Right flag(Left:0, Right:1)
+ *
+ * ACT_MODS_TAP(001r):
+ * 0010|mods|0000 0000    Modifiers with OneShot
+ * 0010|mods|0000 00xx    (reserved)
+ * 0010|mods| keycode     Modifiers with Tap Key
+ *
+ *
+ * Other Keys(01xx)
+ * ----------------
+ * ACT_USAGE(0100): TODO: Not needed?
+ * 0100|00| usage(10)     System control(0x80) - General Desktop page(0x01)
+ * 0100|01| usage(10)     Consumer control(0x01) - Consumer page(0x0C)
+ * 0100|10| usage(10)     (reserved)
+ * 0100|11| usage(10)     (reserved)
+ *
+ * ACT_MOUSEKEY(0110): TODO: Not needed?
+ * 0101|xxxx| keycode     Mouse key
+ *
+ * 011x|xxxx xxxx xxxx    (reseved)
+ *
+ *
+ * Layer Actions(10xx)
+ * -------------------
+ * ACT_LAYER(1000):
+ * 1000|oo00|pppE BBBB   Default Layer Bitwise operation
+ *   oo:    operation(00:AND, 01:OR, 10:XOR, 11:SET)
+ *   ppp:   4-bit chunk part(0-7)
+ *   EBBBB: bits and extra bit
+ * 1000|ooee|pppE BBBB   Layer Bitwise Operation
+ *   oo:    operation(00:AND, 01:OR, 10:XOR, 11:SET)
+ *   ppp:   4-bit chunk part(0-7)
+ *   eBBBB: bits and extra bit
+ *   ee:    on event(00:default layer, 01:press, 10:release, 11:both)
+ *
+ * 1001|xxxx|xxxx xxxx   (reserved)
+ * 1001|oopp|BBBB BBBB   8-bit Bitwise Operation???
+ *
+ * ACT_LAYER_TAP(101x):
+ * 101E|LLLL| keycode    Invert with tap key
+ * 101E|LLLL|1110 xxxx   Reserved(0xE0-EF)
+ * 101E|LLLL|1111 0000   Invert with tap toggle(0xF0)
+ * 101E|LLLL|1111 0001   On/Off
+ * 101E|LLLL|1111 0010   Off/On
+ * 101E|LLLL|1111 0011   Set/Clear
+ * 101E|LLLL|1111 xxxx   Reserved(0xF4-FF)
+ *   ELLLL: layer(0-31)
+ *
+ *
+ * Extensions(11xx)
+ * ----------------
+ * ACT_MACRO(1100):
+ * 1100|opt | id(8)      Macro play?
+ * 1100|1111| id(8)      Macro record?
+ *
+ * ACT_COMMAND(1110):
+ * 1110|opt | id(8)      Built-in Command exec
+ *
+ * ACT_FUNCTION(1111):
+ * 1111| address(12)     Function?
+ * 1111|opt | id(8)      Function?
+ */
+enum action_kind_id {
+    /* Key Actions */
+    ACT_MODS            = 0b0000,
+    ACT_LMODS           = 0b0000,
+    ACT_RMODS           = 0b0001,
+    ACT_MODS_TAP        = 0b0010,
+    ACT_LMODS_TAP       = 0b0010,
+    ACT_RMODS_TAP       = 0b0011,
+    /* Other Keys */
+    ACT_USAGE           = 0b0100,
+    ACT_MOUSEKEY        = 0b0101,
+    /* Layer Actions */
+    ACT_LAYER           = 0b1000,
+    ACT_LAYER_TAP       = 0b1010,
+    ACT_LAYER_TAP1      = 0b1011,
+    /* Extensions */
+    ACT_MACRO           = 0b1100,
+    ACT_COMMAND         = 0b1110,
+    ACT_FUNCTION        = 0b1111
+};
+
+
+/* Action Code Struct
+ *
+ * NOTE:
+ * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15).
+ * AVR looks like a little endian in avr-gcc.
+ * Not portable across compiler/endianness?
+ *
+ * Byte order and bit order of 0x1234:
+ *   Big endian:                Little endian:
+ *   --------------------       --------------------
+ *   FEDC BA98  7654 3210       0123 4567  89AB CDEF
+ *   0001 0010  0011 0100       0010 1100  0100 1000
+ *     0x12       0x34            0x34       0x12
+ */
+typedef union {
+    uint16_t code;
+    struct action_kind {
+        uint16_t param  :12;
+        uint8_t  id     :4;
+    } kind;
+    struct action_key {
+        uint8_t  code   :8;
+        uint8_t  mods   :4;
+        uint8_t  kind   :4;
+    } key;
+    struct action_layer_bitop {
+        uint8_t  bits   :4;
+        uint8_t  xbit   :1;
+        uint8_t  part   :3;
+        uint8_t  on     :2;
+        uint8_t  op     :2;
+        uint8_t  kind   :4;
+    } layer_bitop;
+    struct action_layer_tap {
+        uint8_t  code   :8;
+        uint8_t  val    :5;
+        uint8_t  kind   :3;
+    } layer_tap;
+    struct action_usage {
+        uint16_t code   :10;
+        uint8_t  page   :2;
+        uint8_t  kind   :4;
+    } usage;
+    struct action_command {
+        uint8_t  id     :8;
+        uint8_t  opt    :4;
+        uint8_t  kind   :4;
+    } command;
+    struct action_function {
+        uint8_t  id     :8;
+        uint8_t  opt    :4;
+        uint8_t  kind   :4;
+    } func;
+} action_t;
+
+
+/* action utility */
+#define ACTION_NO                       0
+#define ACTION_TRANSPARENT              1
+#define ACTION(kind, param)             ((kind)<<12 | (param))
+
+
+/*
+ * Key Actions
+ */
+/* Mod bits:    43210
+ *   bit 0      ||||+- Control
+ *   bit 1      |||+-- Shift
+ *   bit 2      ||+--- Alt
+ *   bit 3      |+---- Gui
+ *   bit 4      +----- LR flag(Left:0, Right:1)
+ */
+enum mods_bit {
+    MOD_LCTL = 0x01,
+    MOD_LSFT = 0x02,
+    MOD_LALT = 0x04,
+    MOD_LGUI = 0x08,
+    MOD_RCTL = 0x11,
+    MOD_RSFT = 0x12,
+    MOD_RALT = 0x14,
+    MOD_RGUI = 0x18,
+};
+enum mods_codes {
+    MODS_ONESHOT = 0x00,
+};
+#define ACTION_KEY(key)                 ACTION(ACT_MODS, (key))
+#define ACTION_MODS(mods)               ACTION(ACT_MODS, (mods)<<8 | 0)
+#define ACTION_MODS_KEY(mods, key)      ACTION(ACT_MODS, (mods)<<8 | (key))
+#define ACTION_MODS_TAP_KEY(mods, key)  ACTION(ACT_MODS_TAP, (mods)<<8 | (key))
+#define ACTION_MODS_ONESHOT(mods)       ACTION(ACT_MODS_TAP, (mods)<<8 | MODS_ONESHOT)
+
+
+/*
+ * Other Keys
+ */
+enum usage_pages {
+    PAGE_SYSTEM,
+    PAGE_CONSUMER
+};
+#define ACTION_USAGE_SYSTEM(id)         ACTION(ACT_USAGE, PAGE_SYSTEM<<10 | (id))
+#define ACTION_USAGE_CONSUMER(id)       ACTION(ACT_USAGE, PAGE_CONSUMER<<10 | (id))
+#define ACTION_MOUSEKEY(key)            ACTION(ACT_MOUSEKEY, key)
+
+
+
+/* 
+ * Layer Actions
+ */
+enum layer_param_on {
+    ON_PRESS    = 1,
+    ON_RELEASE  = 2,
+    ON_BOTH     = 3,
+};
+enum layer_param_bit_op {
+    OP_BIT_AND = 0,
+    OP_BIT_OR  = 1,
+    OP_BIT_XOR = 2,
+    OP_BIT_SET = 3,
+};
+enum layer_pram_tap_op {
+    OP_TAP_TOGGLE = 0xF0,
+    OP_ON_OFF,
+    OP_OFF_ON,
+    OP_SET_CLEAR,
+};
+#define ACTION_LAYER_BITOP(op, part, bits, on)      (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | ((bits)&0x1f))
+#define ACTION_LAYER_TAP(layer, key)                (ACT_LAYER_TAP<<12 | (layer)<<8 | (key))
+/* Default Layer */
+#define ACTION_DEFAULT_LAYER_SET(layer)             ACTION_DEFAULT_LAYER_BIT_SET((layer)/4, 1<<((layer)%4))
+/* Layer Operation */
+#define ACTION_LAYER_CLEAR(on)                      ACTION_LAYER_BIT_AND(0, 0, (on))
+#define ACTION_LAYER_MOMENTARY(layer)               ACTION_LAYER_ON_OFF(layer)
+#define ACTION_LAYER_TOGGLE(layer)                  ACTION_LAYER_INVERT(layer, ON_RELEASE)
+#define ACTION_LAYER_INVERT(layer, on)              ACTION_LAYER_BIT_XOR((layer)/4,   1<<((layer)%4),  (on))
+#define ACTION_LAYER_ON(layer, on)                  ACTION_LAYER_BIT_OR( (layer)/4,   1<<((layer)%4),  (on))
+#define ACTION_LAYER_OFF(layer, on)                 ACTION_LAYER_BIT_AND((layer)/4, ~(1<<((layer)%4)), (on))
+#define ACTION_LAYER_SET(layer, on)                 ACTION_LAYER_BIT_SET((layer)/4,   1<<((layer)%4),  (on))
+#define ACTION_LAYER_ON_OFF(layer)                  ACTION_LAYER_TAP((layer), OP_ON_OFF)
+#define ACTION_LAYER_OFF_ON(layer)                  ACTION_LAYER_TAP((layer), OP_OFF_ON)
+#define ACTION_LAYER_SET_CLEAR(layer)               ACTION_LAYER_TAP((layer), OP_SET_CLEAR)
+/* With Tapping */
+#define ACTION_LAYER_TAP_KEY(layer, key)            ACTION_LAYER_TAP((layer), (key))
+#define ACTION_LAYER_TAP_TOGGLE(layer)              ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE)
+/* Bitwise Operation */
+#define ACTION_LAYER_BIT_AND(part, bits, on)        ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), (on))
+#define ACTION_LAYER_BIT_OR( part, bits, on)        ACTION_LAYER_BITOP(OP_BIT_OR,  (part), (bits), (on))
+#define ACTION_LAYER_BIT_XOR(part, bits, on)        ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), (on))
+#define ACTION_LAYER_BIT_SET(part, bits, on)        ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), (on))
+/* Default Layer Bitwise Operation */
+#define ACTION_DEFAULT_LAYER_BIT_AND(part, bits)    ACTION_LAYER_BITOP(OP_BIT_AND, (part), (bits), 0)
+#define ACTION_DEFAULT_LAYER_BIT_OR( part, bits)    ACTION_LAYER_BITOP(OP_BIT_OR,  (part), (bits), 0)
+#define ACTION_DEFAULT_LAYER_BIT_XOR(part, bits)    ACTION_LAYER_BITOP(OP_BIT_XOR, (part), (bits), 0)
+#define ACTION_DEFAULT_LAYER_BIT_SET(part, bits)    ACTION_LAYER_BITOP(OP_BIT_SET, (part), (bits), 0)
+
+
+/*
+ * Extensions
+ */
+/* Macro */
+#define ACTION_MACRO(id)                ACTION(ACT_MACRO, (id))
+#define ACTION_MACRO_TAP(id)            ACTION(ACT_MACRO, FUNC_TAP<<8 | (id))
+#define ACTION_MACRO_OPT(id, opt)       ACTION(ACT_MACRO, (opt)<<8 | (id))
+/* Command */
+#define ACTION_COMMAND(id, opt)         ACTION(ACT_COMMAND,  (opt)<<8 | (addr))
+/* Function */
+enum function_opts {
+    FUNC_TAP = 0x8,     /* indciates function is tappable */
+};
+#define ACTION_FUNCTION(id)             ACTION(ACT_FUNCTION, (id))
+#define ACTION_FUNCTION_TAP(id)         ACTION(ACT_FUNCTION, FUNC_TAP<<8 | (id))
+#define ACTION_FUNCTION_OPT(id, opt)    ACTION(ACT_FUNCTION, (opt)<<8 | (id))
+
+#endif /* ACTION_CODE_H */
diff --git a/common/action_layer.c b/common/action_layer.c
new file mode 100644
index 0000000000..3413c53e65
--- /dev/null
+++ b/common/action_layer.c
@@ -0,0 +1,135 @@
+#include <stdint.h>
+#include "keyboard.h"
+#include "action.h"
+#include "debug.h"
+#include "util.h"
+#include "action_layer.h"
+
+
+/* 
+ * Default Layer State
+ */
+uint32_t default_layer_state = 0;
+
+static void default_layer_state_set(uint32_t state)
+{
+    debug("default_layer_state: ");
+    default_layer_debug(); debug(" to ");
+    default_layer_state = state;
+    default_layer_debug(); debug("\n");
+    clear_keyboard_but_mods(); // To avoid stuck keys
+}
+
+void default_layer_debug(void)
+{
+    debug_hex32(default_layer_state);
+    debug("("); debug_dec(biton32(default_layer_state)); debug(")");
+}
+
+void default_layer_set(uint8_t layer)
+{
+    default_layer_state_set(1UL<<layer);
+}
+
+#ifndef NO_ACTION_LAYER
+void default_layer_or(uint32_t state)
+{
+    default_layer_state_set(default_layer_state | state);
+}
+void default_layer_and(uint32_t state)
+{
+    default_layer_state_set(default_layer_state & state);
+}
+void default_layer_xor(uint32_t state)
+{
+    default_layer_state_set(default_layer_state ^ state);
+}
+#endif
+
+
+#ifndef NO_ACTION_LAYER
+/* 
+ * Keymap Layer State
+ */
+uint32_t layer_state = 0;
+
+static void layer_state_set(uint32_t state)
+{
+    debug("layer_state: ");
+    layer_debug(); debug(" to ");
+    layer_state = state;
+    layer_debug(); debug("\n");
+    clear_keyboard_but_mods(); // To avoid stuck keys
+}
+
+void layer_clear(void)
+{
+    layer_state_set(0);
+}
+
+void layer_move(uint8_t layer)
+{
+    layer_state_set(1UL<<layer);
+}
+
+void layer_on(uint8_t layer)
+{
+    layer_state_set(layer_state | (1UL<<layer));
+}
+
+void layer_off(uint8_t layer)
+{
+    layer_state_set(layer_state & ~(1UL<<layer));
+}
+
+void layer_invert(uint8_t layer)
+{
+    layer_state_set(layer_state ^ (1UL<<layer));
+}
+
+void layer_or(uint32_t state)
+{
+    layer_state_set(layer_state | state);
+}
+void layer_and(uint32_t state)
+{
+    layer_state_set(layer_state & state);
+}
+void layer_xor(uint32_t state)
+{
+    layer_state_set(layer_state ^ state);
+}
+
+void layer_debug(void)
+{
+    debug_hex32(layer_state);
+    debug("("); debug_dec(biton32(layer_state)); debug(")");
+}
+#endif
+
+
+
+action_t layer_switch_get_action(key_t key)
+{
+    action_t action;
+    action.code = ACTION_TRANSPARENT;
+
+#ifndef NO_ACTION_LAYER
+    uint32_t layers = layer_state | default_layer_state;
+    /* check top layer first */
+    for (int8_t i = 31; i >= 0; i--) {
+        if (layers & (1UL<<i)) {
+            action = action_for_key(i, key);
+            if (action.code != ACTION_TRANSPARENT) {
+                return action;
+            }
+        }
+    }
+    /* fall back to layer 0 */
+    action = action_for_key(0, key);
+    return action;
+#else
+    action = action_for_key(biton32(default_layer_state), key);
+    return action;
+#endif
+}
diff --git a/common/action_layer.h b/common/action_layer.h
new file mode 100644
index 0000000000..23f8a00bb7
--- /dev/null
+++ b/common/action_layer.h
@@ -0,0 +1,77 @@
+/*
+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 ACTION_LAYER_H
+#define ACTION_LAYER_H
+
+#include <stdint.h>
+#include "keyboard.h"
+#include "action.h"
+
+
+/*
+ * Default Layer
+ */
+extern uint32_t default_layer_state;
+void default_layer_debug(void);
+void default_layer_set(uint8_t layer);
+
+#ifndef NO_ACTION_LAYER
+/* bitwise operation */
+void default_layer_or(uint32_t state);
+void default_layer_and(uint32_t state);
+void default_layer_xor(uint32_t state);
+#else
+#define default_layer_or(state)
+#define default_layer_and(state)
+#define default_layer_xor(state)
+#endif
+
+
+/*
+ * Keymap Layer
+ */
+#ifndef NO_ACTION_LAYER
+extern uint32_t layer_state;
+void layer_debug(void);
+void layer_clear(void);
+void layer_move(uint8_t layer);
+void layer_on(uint8_t layer);
+void layer_off(uint8_t layer);
+void layer_invert(uint8_t layer);
+/* bitwise operation */
+void layer_or(uint32_t state);
+void layer_and(uint32_t state);
+void layer_xor(uint32_t state);
+#else
+#define layer_state             0
+#define layer_clear()
+#define layer_move(layer)
+#define layer_on(layer)
+#define layer_off(layer)
+#define layer_invert(layer)
+
+#define layer_or(state)
+#define layer_and(state)
+#define layer_xor(state)
+#define layer_debug()
+#endif
+
+
+/* return action depending on current layer status */
+action_t layer_switch_get_action(key_t key);
+
+#endif
diff --git a/common/action_tapping.h b/common/action_tapping.h
index c9f09f576d..9b42d50dc3 100644
--- a/common/action_tapping.h
+++ b/common/action_tapping.h
@@ -18,7 +18,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ACTION_TAPPING_H
 
 
-#ifndef NO_ACTION_TAPPING
 
 /* period of tapping(ms) */
 #ifndef TAPPING_TERM
@@ -33,8 +32,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define WAITING_BUFFER_SIZE 8
 
 
+#ifndef NO_ACTION_TAPPING
 void action_tapping_process(keyrecord_t record);
-
 #endif
 
 #endif
diff --git a/common/command.c b/common/command.c
index b29333883e..3a1fcb186e 100644
--- a/common/command.c
+++ b/common/command.c
@@ -26,7 +26,7 @@ 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 "action_layer.h"
 #include "eeconfig.h"
 #include "sleep_led.h"
 #include "led.h"
@@ -573,8 +573,8 @@ static uint8_t numkey2num(uint8_t code)
 
 static void switch_default_layer(uint8_t layer)
 {
-    print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
+    print("switch_default_layer: "); print_dec(biton32(default_layer_state));
+    print(" to "); print_dec(layer); print("\n");
     default_layer_set(layer);
-    overlay_clear();
     clear_keyboard();
 }
diff --git a/common/keymap.c b/common/keymap.c
index ace3f49b69..c98ce09b66 100644
--- a/common/keymap.c
+++ b/common/keymap.c
@@ -18,7 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "keymap.h"
 #include "report.h"
 #include "keycode.h"
-#include "layer_switch.h"
+#include "action_layer.h"
 #include "action.h"
 #include "action_macro.h"
 #include "debug.h"
diff --git a/common/layer_switch.c b/common/layer_switch.c
deleted file mode 100644
index a5d426a899..0000000000
--- a/common/layer_switch.c
+++ /dev/null
@@ -1,209 +0,0 @@
-#include <stdint.h>
-#include "keyboard.h"
-#include "action.h"
-#include "debug.h"
-#include "util.h"
-#include "layer_switch.h"
-
-
-/* 
- * Default Layer (0-15)
- */
-uint8_t default_layer = 0;
-
-void default_layer_set(uint8_t layer)
-{
-    debug("default_layer_set: ");
-    debug_dec(default_layer); debug(" to ");
-
-    default_layer = layer;
-
-    debug_dec(default_layer); debug("\n");
-
-    clear_keyboard_but_mods(); // To avoid stuck keys
-}
-
-
-#ifndef NO_ACTION_KEYMAP
-/* 
- * Keymap Layer (0-15)
- */
-uint16_t keymap_stat = 0;
-
-/* return highest layer whose state is on */
-uint8_t keymap_get_layer(void)
-{
-    return biton16(keymap_stat);
-}
-
-static void keymap_stat_set(uint16_t stat)
-{
-    debug("keymap: ");
-    keymap_debug(); debug(" to ");
-
-    keymap_stat = stat;
-
-    keymap_debug(); debug("\n");
-
-    clear_keyboard_but_mods(); // To avoid stuck keys
-}
-
-void keymap_clear(void)
-{
-    keymap_stat_set(0);
-}
-
-
-void keymap_set(uint16_t stat)
-{
-    keymap_stat_set(stat);
-}
-
-void keymap_move(uint8_t layer)
-{
-    keymap_stat_set(1<<layer);
-}
-
-void keymap_on(uint8_t layer)
-{
-    keymap_stat_set(keymap_stat | (1<<layer));
-}
-
-void keymap_off(uint8_t layer)
-{
-    keymap_stat_set(keymap_stat & ~(1<<layer));
-}
-
-void keymap_invert(uint8_t layer)
-{
-    keymap_stat_set(keymap_stat ^ (1<<layer));
-}
-
-void keymap_or(uint16_t stat)
-{
-    keymap_stat_set(keymap_stat | stat);
-}
-void keymap_and(uint16_t stat)
-{
-    keymap_stat_set(keymap_stat & stat);
-}
-void keymap_xor(uint16_t stat)
-{
-    keymap_stat_set(keymap_stat ^ stat);
-}
-
-void keymap_debug(void)
-{
-    debug_hex16(keymap_stat); debug("("); debug_dec(keymap_get_layer()); debug(")");
-}
-#endif
-
-
-
-#ifndef NO_ACTION_OVERLAY
-/* 
- * Overlay Layer (16-31 = 0-15|0x10)
- */
-uint16_t overlay_stat = 0;
-
-/* return highest layer whose state is on */
-uint8_t overlay_get_layer(void)
-{
-    return biton16(overlay_stat);
-}
-
-static void overlay_stat_set(uint16_t stat)
-{
-    debug("overlay: ");
-    overlay_debug(); debug(" to ");
-
-    overlay_stat = stat;
-
-    overlay_debug(); debug("\n");
-
-    clear_keyboard_but_mods(); // To avoid stuck keys
-}
-
-void overlay_clear(void)
-{
-    overlay_stat_set(0);
-}
-
-
-void overlay_set(uint16_t stat)
-{
-    overlay_stat_set(stat);
-}
-
-void overlay_move(uint8_t layer)
-{
-    overlay_stat_set(1<<layer);
-}
-
-void overlay_on(uint8_t layer)
-{
-    overlay_stat_set(overlay_stat | (1<<layer));
-}
-
-void overlay_off(uint8_t layer)
-{
-    overlay_stat_set(overlay_stat & ~(1<<layer));
-}
-
-void overlay_invert(uint8_t layer)
-{
-    overlay_stat_set(overlay_stat ^ (1<<layer));
-}
-
-void overlay_or(uint16_t stat)
-{
-    overlay_stat_set(overlay_stat | stat);
-}
-void overlay_and(uint16_t stat)
-{
-    overlay_stat_set(overlay_stat & stat);
-}
-void overlay_xor(uint16_t stat)
-{
-    overlay_stat_set(overlay_stat ^ stat);
-}
-
-void overlay_debug(void)
-{
-    debug_hex16(overlay_stat); debug("("); debug_dec(overlay_get_layer()); debug(")");
-}
-#endif
-
-action_t layer_switch_get_action(key_t key)
-{
-    action_t action;
-    action.code = ACTION_TRANSPARENT;
-
-#ifndef NO_ACTION_OVERLAY
-    /* overlay: top layer first */
-    for (int8_t i = 15; i >= 0; i--) {
-        if (overlay_stat & (1<<i)) {
-            action = action_for_key(i | OVERLAY_BIT, key);
-            if (action.code != ACTION_TRANSPARENT) {
-                return action;
-            }
-        }
-    }
-#endif
-
-#ifndef NO_ACTION_KEYMAP
-    /* keymap: top layer first */
-    for (int8_t i = 15; i >= 0; i--) {
-        if (keymap_stat & (1<<i)) {
-            action = action_for_key(i, key);
-            if (action.code != ACTION_TRANSPARENT) {
-                return action;
-            }
-        }
-    }
-#endif
-
-    /* default layer */
-    action = action_for_key(default_layer, key);
-    return action;
-}
diff --git a/common/layer_switch.h b/common/layer_switch.h
deleted file mode 100644
index eb4cf61ba3..0000000000
--- a/common/layer_switch.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-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_SWITCH_H
-#define LAYER_SWITCH_H
-
-#include <stdint.h>
-#include "keyboard.h"
-#include "action.h"
-
-
-/* overlays are asigned at layer 16-31 */
-#define OVERLAY_BIT      0x10
-#define OVERLAY_MASK     0x0F
-
-
-/*
- * Default Layer
- */
-/* base layer to fall back */
-extern uint8_t default_layer;
-void default_layer_set(uint8_t layer);
-
-
-/*
- * Keymap Layer
- */
-#ifndef NO_ACTION_KEYMAP
-extern uint16_t keymap_stat;
-/* return current active layer */
-uint8_t keymap_get_layer(void);
-void keymap_clear(void);
-void keymap_set(uint16_t stat);
-void keymap_move(uint8_t layer);
-void keymap_on(uint8_t layer);
-void keymap_off(uint8_t layer);
-void keymap_invert(uint8_t layer);
-/* bitwise operation */
-void keymap_or(uint16_t stat);
-void keymap_and(uint16_t stat);
-void keymap_xor(uint16_t stat);
-void keymap_debug(void);
-#else
-#define keymap_stat             0
-#define keymap_get_layer()
-#define keymap_clear()
-#define keymap_set(stat)
-#define keymap_move(layer)
-#define keymap_on(layer)
-#define keymap_off(layer)
-#define keymap_invert(layer)
-#define keymap_or(stat)
-#define keymap_and(stat)
-#define keymap_xor(stat)
-#define keymap_debug()
-#endif
-
-
-/*
- * Overlay Layer
- */
-#ifndef NO_ACTION_OVERLAY
-extern uint16_t overlay_stat;
-/* return current active layer */
-uint8_t overlay_get_layer(void);
-void overlay_clear(void);
-void overlay_set(uint16_t stat);
-void overlay_move(uint8_t layer);
-void overlay_on(uint8_t layer);
-void overlay_off(uint8_t layer);
-void overlay_invert(uint8_t layer);
-/* bitwise operation */
-void overlay_or(uint16_t stat);
-void overlay_and(uint16_t stat);
-void overlay_xor(uint16_t stat);
-void overlay_debug(void);
-#else
-#define overlay_stat            0
-#define overlay_get_layer()
-#define overlay_clear()
-#define overlay_set(stat)
-#define overlay_move(layer)
-#define overlay_on(layer)
-#define overlay_off(layer)
-#define overlay_invert(layer)
-#define overlay_or(stat)
-#define overlay_and(stat)
-#define overlay_xor(stat)
-#define overlay_debug()
-#endif
-
-
-
-/* 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 ff1926d7d1..6d4d6bfda1 100644
--- a/common/util.c
+++ b/common/util.c
@@ -38,6 +38,14 @@ uint8_t bitpop16(uint16_t bits)
     return c;
 }
 
+uint8_t bitpop32(uint32_t bits)
+{
+    uint8_t c;
+    for (c = 0; bits; c++)
+        bits &= bits - 1;
+    return c;
+}
+
 // 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)
@@ -58,3 +66,14 @@ uint8_t biton16(uint16_t bits)
     if (bits >> 1) { bits >>= 1; n += 1;}
     return n;
 }
+
+uint8_t biton32(uint32_t bits)
+{
+    uint8_t n = 0;
+    if (bits >>16) { bits >>=16; n +=16;}
+    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 58b7fdf145..4b8b5ca3a4 100644
--- a/common/util.h
+++ b/common/util.h
@@ -30,7 +30,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 uint8_t bitpop(uint8_t bits);
 uint8_t bitpop16(uint16_t bits);
+uint8_t bitpop32(uint32_t bits);
+
 uint8_t biton(uint8_t bits);
 uint8_t biton16(uint16_t bits);
+uint8_t biton32(uint32_t bits);
 
 #endif