7 files changed, 585 insertions(+), 341 deletions(-)

M common/action.c
M common/action.h
M common/command.c
M common/keymap.c
M common/keymap.h
M common/layer_switch.c
M common/layer_switch.h

@@ 202,23 202,6 @@ void action_exec(keyevent_t event)
     }
 }
 
-static action_t get_action(key_t key)
-{
-    action_t action;
-    action.code = ACTION_NO;
-
-    /* layer_switch */
-    action = layer_switch_get_action(key);
-    if (action.code != ACTION_TRANSPARENT) {
-        return action;
-    }
-
-    /* default layer */
-    //debug("get_aciton: default layer: "); debug_dec(default_layer); debug("\n");
-    action = action_for_key(default_layer, key);
-    return action;
-}
-
 static void process_action(keyrecord_t *record)
 {
     keyevent_t event = record->event;


@@ 226,9 209,11 @@ static void process_action(keyrecord_t *record)
 
     if (IS_NOEVENT(event)) { return; }
 
-    action_t action = get_action(event.key);
-    debug("ACTION: "); debug_action(action); debug(" ");
-    layer_switch_debug(); debug("["); debug_dec(default_layer); debug("]\n");
+    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");
 
     switch (action.kind.id) {
         /* Key and Mods */


@@ 368,207 353,292 @@ static void process_action(keyrecord_t *record)
 #endif
             break;
 
-        /* Layer key */
-        case ACT_LAYER_SET:
+        case ACT_KEYMAP:
             switch (action.layer.code) {
-                case LAYER_MOMENTARY:  /* momentary */
-                    if (event.pressed) {
-                        layer_switch_move(action.layer.val);
-                    }
-                    else {
-                        // NOTE: This is needed by legacy keymap support
-                        layer_switch_move(0);
-                    }
+                /* Keymap Reset */
+                case OP_RESET:
+                    default_layer_set(action.layer.val);
                     break;
-                case LAYER_ON_PRESS:
+                /* Keymap Reset default layer */
+                case (OP_RESET | ON_PRESS):
                     if (event.pressed) {
-                        layer_switch_move(action.layer.val);
+                        default_layer_set(action.layer.val);
+                        overlay_clear();
                     }
                     break;
-                case LAYER_ON_RELEASE:
+                case (OP_RESET | ON_RELEASE):
                     if (!event.pressed) {
-                        layer_switch_move(action.layer.val);
+                        default_layer_set(action.layer.val);
+                        overlay_clear();
                     }
                     break;
-                case LAYER_ON_BOTH:
-                    layer_switch_move(action.layer.val);
+                case (OP_RESET | ON_BOTH):
+                    default_layer_set(action.layer.val);
+                    overlay_clear();
                     break;
-                case LAYER_TAP_TOGGLE:  /* switch on hold and toggle on several taps */
+
+                /* Keymap Bit invert */
+                case OP_INV:
+                    /* with tap toggle */
                     if (event.pressed) {
                         if (tap_count < TAPPING_TOGGLE) {
-                            layer_switch_move(action.layer.val);
+                            debug("KEYMAP_INV: tap toggle(press).\n");
+                            keymap_invert(action.layer.val);
                         }
                     } else {
-                        if (tap_count >= TAPPING_TOGGLE) {
-                            debug("LAYER_PRESSED: tap toggle.\n");
-                            layer_switch_move(action.layer.val);
+                        if (tap_count <= TAPPING_TOGGLE) {
+                            debug("KEYMAP_INV: tap toggle(release).\n");
+                            keymap_invert(action.layer.val);
                         }
                     }
                     break;
-                case LAYER_SET_DEFAULT_ON_PRESS:
+                case (OP_INV | ON_PRESS):
                     if (event.pressed) {
-                        default_layer = action.layer.val;
-                        layer_switch_move(0);
+                        keymap_invert(action.layer.val);
                     }
                     break;
-                case LAYER_SET_DEFAULT_ON_RELEASE:
+                case (OP_INV | ON_RELEASE):
                     if (!event.pressed) {
-                        default_layer = action.layer.val;
-                        layer_switch_move(0);
+                        keymap_invert(action.layer.val);
                     }
                     break;
-                case LAYER_SET_DEFAULT_ON_BOTH:
-                    default_layer = action.layer.val;
-                    layer_switch_move(0);
+                case (OP_INV | ON_BOTH):
+                    keymap_invert(action.layer.val);
                     break;
-                default:
-                    /* tap key */
+
+                /* Keymap Bit on */
+                case OP_ON:
                     if (event.pressed) {
-                        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_move(action.layer.val);
-                        }
+                        keymap_on(action.layer.val);
                     } else {
-                        if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
-                            debug("LAYER_SET: Tap: unregister_code\n");
-                            unregister_code(action.layer.code);
-                        } else {
-                            // NOTE: This is needed by legacy keymap support
-                            debug("LAYER_SET: No tap: return to default layer(on release)\n");
-                            layer_switch_move(0);
-                        }
+                        keymap_off(action.layer.val);
                     }
                     break;
-            }
-            break;
-        case ACT_LAYER_BIT:
-            switch (action.layer.code) {
-                case LAYER_MOMENTARY:  /* momentary */
+                case (OP_ON | ON_PRESS):
                     if (event.pressed) {
-                        layer_switch_move(layer_switch_get_layer() | action.layer.val);
+                        keymap_on(action.layer.val);
+                    }
+                    break;
+                case (OP_ON | ON_RELEASE):
+                    if (!event.pressed) {
+                        keymap_on(action.layer.val);
+                    }
+                    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 {
-                        layer_switch_move(layer_switch_get_layer() & ~action.layer.val);
+                        keymap_on(action.layer.val);
                     }
                     break;
-                case LAYER_ON_PRESS:
+                case (OP_OFF | ON_PRESS):
                     if (event.pressed) {
-                        layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
+                        keymap_off(action.layer.val);
                     }
                     break;
-                case LAYER_ON_RELEASE:
+                case (OP_OFF | ON_RELEASE):
                     if (!event.pressed) {
-                        layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
+                        keymap_off(action.layer.val);
                     }
                     break;
-                case LAYER_ON_BOTH:
-                    layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
+                case (OP_OFF | ON_BOTH):
+                    keymap_off(action.layer.val);
                     break;
-                case LAYER_TAP_TOGGLE:  /* switch on hold and toggle on several taps */
+
+                /* Keymap Bit set */
+                case OP_SET:
                     if (event.pressed) {
-                        if (tap_count < TAPPING_TOGGLE) {
-                            debug("LAYER_BIT: tap toggle(press).\n");
-                            layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
-                        }
+                        keymap_set(action.layer.val);
                     } else {
-                        if (tap_count <= TAPPING_TOGGLE) {
-                            debug("LAYER_BIT: tap toggle(release).\n");
-                            layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
-                        }
+                        keymap_clear();
                     }
                     break;
-                case LAYER_SET_DEFAULT_ON_PRESS:
+                case (OP_SET | ON_PRESS):
                     if (event.pressed) {
-                        default_layer = default_layer ^ action.layer.val;
-                        layer_switch_move(default_layer);
+                        keymap_set(action.layer.val);
                     }
                     break;
-                case LAYER_SET_DEFAULT_ON_RELEASE:
+                case (OP_SET | ON_RELEASE):
                     if (!event.pressed) {
-                        default_layer = default_layer ^ action.layer.val;
-                        layer_switch_move(default_layer);
+                        keymap_set(action.layer.val);
                     }
                     break;
-                case LAYER_SET_DEFAULT_ON_BOTH:
-                    default_layer = default_layer ^ action.layer.val;
-                    layer_switch_move(default_layer);
+                case (OP_SET | ON_BOTH):
+                    keymap_set(action.layer.val);
                     break;
+
+                /* Keymap Bit invert with tap key */
                 default:
-                    // tap key
                     if (event.pressed) {
                         if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
-                            debug("LAYER_BIT: Tap: register_code\n");
+                            debug("KEYMAP_TAP_KEY: Tap: register_code\n");
                             register_code(action.layer.code);
                         } else {
-                            debug("LAYER_BIT: No tap: layer_bit(on press)\n");
-                            layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
+                            debug("KEYMAP_TAP_KEY: No tap: invert on press\n");
+                            keymap_invert(action.layer.val);
                         }
                     } else {
                         if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
-                            debug("LAYER_BIT: Tap: unregister_code\n");
+                            debug("KEYMAP_TAP_KEY: Tap: unregister_code\n");
                             unregister_code(action.layer.code);
                         } else {
-                            debug("LAYER_BIT: No tap: layer_bit(on release)\n");
-                            layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
+                            debug("KEYMAP_TAP_KEY: No tap: invert on release\n");
+                            keymap_invert(action.layer.val);
                         }
                     }
                     break;
             }
             break;
-        case ACT_LAYER_SWITCH:
+
+        case ACT_OVERLAY:
             switch (action.layer.code) {
-                case LAYER_MOMENTARY:  /* momentary */
-                    if (event.pressed) {
-                        layer_switch_on(action.layer.val);
+                // Overlay Invert bit4
+                case OP_INV4 | 0:
+                    if (action.layer.val == 0) {
+                        overlay_clear();
                     } else {
-                        layer_switch_off(action.layer.val);
+                        overlay_set(overlay_stat ^ action.layer.val);
                     }
                     break;
-                case LAYER_ON_PRESS:
-                    if (event.pressed) {
-                        layer_switch_invert(action.layer.val);
+                case OP_INV4 | 1:
+                    if (action.layer.val == 0) {
+                        if (event.pressed) overlay_clear();
+                    } else {
+                        overlay_set(overlay_stat ^ action.layer.val<<4);
                     }
                     break;
-                case LAYER_ON_RELEASE:
-                    if (!event.pressed) {
-                        layer_switch_invert(action.layer.val);
+                case OP_INV4 | 2:
+                    if (action.layer.val == 0) {
+                        if (!event.pressed) overlay_clear();
+                    } else {
+                        overlay_set(overlay_stat ^ action.layer.val<<8);
                     }
                     break;
-                case LAYER_ON_BOTH:
-                    layer_switch_invert(action.layer.val);
+                case OP_INV4 | 3:
+                    if (action.layer.val == 0) {
+                        overlay_clear();
+                    } else {
+                        overlay_set(overlay_stat ^ action.layer.val<<12);
+                    }
                     break;
-                case LAYER_TAP_TOGGLE:  /* switch on hold and toggle on several taps */
+
+                /* Overlay Bit invert */
+                case OP_INV:
+                    /* with tap toggle */
                     if (event.pressed) {
                         if (tap_count < TAPPING_TOGGLE) {
-                            debug("LAYER_SWITCH: tap toggle(press).\n");
-                            layer_switch_invert(action.layer.val);
+                            debug("OVERLAY_INV: tap toggle(press).\n");
+                            overlay_invert(action.layer.val);
                         }
                     } else {
                         if (tap_count <= TAPPING_TOGGLE) {
-                            debug("LAYER_SWITCH: tap toggle(release).\n");
-                            layer_switch_invert(action.layer.val);
+                            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:
-                    // tap key
                     if (event.pressed) {
                         if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
-                            debug("LAYER_SWITCH: Tap: register_code\n");
+                            debug("OVERLAY_TAP_KEY: Tap: register_code\n");
                             register_code(action.layer.code);
                         } else {
-                            debug("LAYER_SWITCH: No tap: layer_switch on press\n");
-                            layer_switch_invert(action.layer.val);
+                            debug("OVERLAY_TAP_KEY: No tap: invert on press\n");
+                            overlay_invert(action.layer.val);
                         }
                     } else {
                         if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
-                            debug("LAYER_SWITCH: Tap: unregister_code\n");
+                            debug("OVERLAY_TAP_KEY: Tap: unregister_code\n");
                             unregister_code(action.layer.code);
                         } else {
-                            debug("LAYER_SWITCH: No tap: layer_switch on release\n");
-                            layer_switch_invert(action.layer.val);
+                            debug("OVERLAY_TAP_KEY: No tap: invert on release\n");
+                            overlay_invert(action.layer.val);
                         }
                     }
                     break;


@@ 877,28 947,21 @@ bool sending_anykey(void)
 
 bool is_tap_key(key_t key)
 {
-    action_t action = get_action(key);
+    action_t action = layer_switch_get_action(key);
 
     switch (action.kind.id) {
         case ACT_LMODS_TAP:
         case ACT_RMODS_TAP:
             return true;
-        case ACT_LAYER_SET:
-        case ACT_LAYER_BIT:
+        case ACT_KEYMAP:
+        case ACT_OVERLAY:
             switch (action.layer.code) {
-                case LAYER_MOMENTARY:
-                case LAYER_ON_PRESS:
-                case LAYER_ON_RELEASE:
-                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 */
+                case 0x04 ... 0xEF:    /* tap key */
+                case OP_INV:
                     return true;
+                default:
+                    return false;
             }
-            return false;
         case ACT_FUNCTION:
             if (action.func.opt & FUNC_TAP) { return true; }
             return false;


@@ 929,9 992,8 @@ 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_SET:         debug("ACT_LAYER_SET");         break;
-        case ACT_LAYER_BIT:         debug("ACT_LAYER_BIT");         break;
-        case ACT_LAYER_SWITCH:      debug("ACT_LAYER_SWITCH");      break;
+        case ACT_KEYMAP:            debug("ACT_KEYMAP");            break;
+        case ACT_OVERLAY:           debug("ACT_OVERLAY");           break;
         case ACT_MACRO:             debug("ACT_MACRO");             break;
         case ACT_COMMAND:           debug("ACT_COMMAND");           break;
         case ACT_FUNCTION:          debug("ACT_FUNCTION");          break;

@@ 150,40 150,41 @@ bool waiting_buffer_has_anykey_pressed(void);
  *
  * Mouse Keys
  * ----------
- * NOTE: can be combined with 'Other HID Usage'? to save action kind id.
  * ACT_MOUSEKEY(0110):
  * 0101|XXXX| keycode     Mouse key
  *
  *
  * Layer Actions
  * -------------
- * ACT_LAYER_SET(1000):         Set layer
- * 1000|LLLL|0000 0000   set current layer on press and return to default on release(momentary)
- * 1000|LLLL|0000 0001   set current layer on press
- * 1000|LLLL|0000 0010   set current layer on release
- * 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
+ * ACT_KEYMAP:
+ * 1000|LLLL|0000 0000   Reset default layer
+ * 1000|LLLL|0000 00xx   Reset default layer and clear overlay
+ * 1000|LLLL| keycode    Invert with tap key
+ * 1000|LLLL|1111 0000   Invert with tap toggle
+ * 1000|LLLL|1111 00xx   Invert[^= L]
+ * 1000|LLLL|1111 0100   On/Off
+ * 1000|LLLL|1111 01xx   On[|= L]
+ * 1000|LLLL|1111 1000   Off/On
+ * 1000|LLLL|1111 10xx   Off[&= ~L]
+ * 1000|LLLL|1111 1100   Set/Set(0)
+ * 1000|LLLL|1111 11xx   Set[= L]
+ * default layer: 0-15(4bit)
+ * xx: On {00:for special use, 01:press, 10:release, 11:both}
  *
- * ACT_LAYER_BIT(1001):         Bit-op layer
- * 1001|BBBB|0000 0000   bit-on current layer on press and bit-off on release(momentary)
- * 1001|BBBB|0000 0001   bit-xor current layer on press
- * 1001|BBBB|0000 0010   bit-xor current layer on release
- * 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
- *
- * ACT_LAYER_SWITCH:            Switch
- * 1011|LLLL|0000 0000   On on press and Off on release(momentary)
- * 1011|LLLL|0000 0001   Invert on press
- * 1011|LLLL|0000 0010   Invert on release
- * 1011|LLLL|0000 0011   Invert on both
- * 1011|LLLL| keycode    Invert on hold and send key on tap
- * 1011|LLLL|1111 0000   Invert on hold and toggle on several taps
- * 1011|LLLL|1111 1111   (not used)
+ * 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[= 1<<L]/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)


@@ 211,9 212,8 @@ enum action_kind_id {
     ACT_USAGE           = 0b0100,
     ACT_MOUSEKEY        = 0b0101,
 
-    ACT_LAYER_SET       = 0b1000,
-    ACT_LAYER_BIT       = 0b1001,
-    ACT_LAYER_SWITCH    = 0b1011,
+    ACT_KEYMAP          = 0b1000,
+    ACT_OVERLAY         = 0b1001,
 
     ACT_MACRO           = 0b1100,
     ACT_COMMAND         = 0b1110,


@@ 254,73 254,108 @@ enum mods_codes {
 #define ACTION_RMOD_ONESHOT(mod)        ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
 
 
-/*
- * Layer switching
+/* Layer Operation:
+ *      Invert  layer ^= (1<<layer)
+ *      On      layer |= (1<<layer)
+ *      Off     layer &= ~(1<<layer)
+ *      Set     layer = (1<<layer)
+ *      Clear   layer = 0
  */
-enum layer_codes {
-    LAYER_MOMENTARY = 0,
-    LAYER_ON_PRESS = 1,
-    LAYER_ON_RELEASE = 2,
-    LAYER_ON_BOTH =3,
-    LAYER_TAP_TOGGLE = 0xF0,
-    LAYER_SET_DEFAULT_ON_PRESS = 0xFD,
-    LAYER_SET_DEFAULT_ON_RELEASE = 0xFE,
-    LAYER_SET_DEFAULT_ON_BOTH = 0xFF
+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
- */
-/* 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_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS)
-#define ACTION_LAYER_SET_DEFAULT_R(layer)       ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE)
-#define ACTION_LAYER_SET_DEFAULT_B(layer)       ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH)
-/* bit-xor default layer */
-#define ACTION_LAYER_BIT_DEFAULT(bits)          ACTION_LAYER_BIT_DEFAULT_R(bits)
-#define ACTION_LAYER_BIT_DEFAULT_P(bits)        ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS)
-#define ACTION_LAYER_BIT_DEFAULT_R(bits)        ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE)
-#define ACTION_LAYER_BIT_DEFAULT_B(bits)        ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH)
-/*
- * Current layer: Return to default layer
- */
-#define ACTION_LAYER_DEFAULT                    ACTION_LAYER_DEFAULT_R
-#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)
-/*
- * Current layer: Set
- */
-#define ACTION_LAYER_SET(layer)                 ACTION_LAYER_SET_P(layer)
-#define ACTION_LAYER_SET_MOMENTARY(layer)       ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_MOMENTARY)
-#define ACTION_LAYER_SET_TOGGLE(layer)          ACTION_LAYER_SET_R(layer)
-#define ACTION_LAYER_SET_P(layer)               ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_PRESS)
-#define ACTION_LAYER_SET_R(layer)               ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_RELEASE)
-#define ACTION_LAYER_SET_B(layer)               ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_BOTH)
-#define ACTION_LAYER_SET_TAP_TOGGLE(layer)      ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_TAP_TOGGLE)
-#define ACTION_LAYER_SET_TAP_KEY(layer, key)    ACTION(ACT_LAYER_SET, (layer)<<8 | (key))
-/*
- * Current layer: Bit-op
+ * Default Layer
  */
-#define ACTION_LAYER_BIT(bits)                  ACTION_LAYER_BIT_MOMENTARY(bits)
-#define ACTION_LAYER_BIT_MOMENTARY(bits)        ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_MOMENTARY)
-#define ACTION_LAYER_BIT_TOGGLE(bits)           ACTION_LAYER_BIT_R(bits)
-#define ACTION_LAYER_BIT_P(bits)                ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS)
-#define ACTION_LAYER_BIT_R(bits)                ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE)
-#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)
-#define ACTION_LAYER_BIT_TAP_KEY(bits, key)     ACTION(ACT_LAYER_BIT, (bits)<<8 | (key))
+#define ACTION_KEYMAP(layer)                     ACTION_KEYMAP_MOMENTARY(layer)
+#define ACTION_KEYMAP_MOMENTARY(layer)           ACTION_KEYMAP_INV_B(layer)
+#define ACTION_KEYMAP_TOGGLE(layer)              ACTION_KEYMAP_INV_R(layer)
+/* Set default layer */
+#define ACTION_SET_DEFAULT_LAYER(layer)           ACTION_KEYMAP_RESET(layer)
+#define ACTION_SET_DEFAULT_LAYER_P(layer)         ACTION_KEYMAP_RESET_P(layer)
+#define ACTION_SET_DEFAULT_LAYER_R(layer)         ACTION_KEYMAP_RESET_R(layer)
+#define ACTION_SET_DEFAULT_LAYER_B(layer)         ACTION_KEYMAP_RESET_B(layer)
+/* Keymap Set and clear overaly */
+#define ACTION_KEYMAP_RESET(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | 0)
+#define ACTION_KEYMAP_RESET_P(layer)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_PRESS)
+#define ACTION_KEYMAP_RESET_R(layer)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_PRESS)
+#define ACTION_KEYMAP_RESET_B(layer)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_PRESS)
+/* Keymap Invert */
+#define ACTION_KEYMAP_INV(layer)                 ACTION_KEYMAP_INV_B(layer)
+#define ACTION_KEYMAP_TAP_TOGGLE(layer)          ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | 0)
+#define ACTION_KEYMAP_INV_P(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_PRESS)
+#define ACTION_KEYMAP_INV_R(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_RELEASE)
+#define ACTION_KEYMAP_INV_B(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_BOTH)
+/* Keymap On */
+#define ACTION_KEYMAP_ON(layer)                  ACTION_KEYMAP_ON_OFF(layer)
+#define ACTION_KEYMAP_ON_OFF(layer)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | 0)
+#define ACTION_KEYMAP_ON_P(layer)                ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | ON_PRESS)
+#define ACTION_KEYMAP_ON_R(layer)                ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | ON_RELEASE)
+#define ACTION_KEYMAP_ON_B(layer)                ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | ON_BOTH)
+/* Keymap Off */
+#define ACTION_KEYMAP_OFF(layer)                 ACTION_KEYMAP_OFF_ON(layer)
+#define ACTION_KEYMAP_OFF_ON(layer)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | 0)
+#define ACTION_KEYMAP_OFF_P(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_PRESS)
+#define ACTION_KEYMAP_OFF_R(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_RELEASE)
+#define ACTION_KEYMAP_OFF_B(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_BOTH)
+/* Keymap Set */
+#define ACTION_KEYMAP_SET(layer)                 ACTION_KEYMAP_SET_CLEAR(layer)
+#define ACTION_KEYMAP_SET_CLEAR(layer)           ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | 0)
+#define ACTION_KEYMAP_SET_P(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_PRESS)
+#define ACTION_KEYMAP_SET_R(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_RELEASE)
+#define ACTION_KEYMAP_SET_B(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_BOTH)
+/* Keymap Invert with tap key */
+#define ACTION_KEYMAP_TAP_KEY(layer, key)        ACTION(ACT_KEYMAP, (layer)<<8 | (key))
+
 /*
- * Layer SWITCH
+ * Overlay Layer
  */
-/* momentary */
-#define ACTION_LAYER_SWITCH(layer)              ACTION_LAYER_SWITCH_MOMENTARY(layer)
-#define ACTION_LAYER_SWITCH_MOMENTARY(layer)    ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_MOMENTARY)
-#define ACTION_LAYER_SWITCH_TOGGLE(layer)       ACTION_LAYER_SWITCH_R(layer)
-#define ACTION_LAYER_SWITCH_P(layer)            ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_PRESS)
-#define ACTION_LAYER_SWITCH_R(layer)            ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_RELEASE)
-#define ACTION_LAYER_SWITCH_B(layer)            ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_BOTH)
-#define ACTION_LAYER_SWITCH_TAP_TOGGLE(layer)   ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_TAP_TOGGLE)
-#define ACTION_LAYER_SWITCH_TAP_KEY(layer, key) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | (key))
+#define ACTION_OVERLAY(layer)                     ACTION_OVERLAY_MOMENTARY(layer)
+#define ACTION_OVERLAY_MOMENTARY(layer)           ACTION_OVERLAY_ON_OFF(layer)
+#define ACTION_OVERLAY_TOGGLE(layer)              ACTION_OVERLAY_INV_R(layer)
+/* Overlay Clear */
+#define ACTION_OVERLAY_CLEAR                      ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | 0)
+#define ACTION_OVERLAY_CLEAR_P                    ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_PRESS)
+#define ACTION_OVERLAY_CLEAR_R                    ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_RELEASE)
+#define ACTION_OVERLAY_CLEAR_B                    ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_BOTH)
+/* 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)                 ACTION_OVERLAY_INV_B(layer)
+#define ACTION_OVERLAY_TAP_TOGGLE(layer)          ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0)
+#define ACTION_OVERLAY_INV_P(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_PRESS)
+#define ACTION_OVERLAY_INV_R(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_RELEASE)
+#define ACTION_OVERLAY_INV_B(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_BOTH)
+/* Overlay On */
+#define ACTION_OVERLAY_ON(layer)                  ACTION_OVERLAY_ON_OFF(layer)
+#define ACTION_OVERLAY_ON_OFF(layer)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | 0)
+#define ACTION_OVERLAY_ON_P(layer)                ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | ON_PRESS)
+#define ACTION_OVERLAY_ON_R(layer)                ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | ON_RELEASE)
+#define ACTION_OVERLAY_ON_B(layer)                ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | ON_BOTH)
+/* Overlay Off */
+#define ACTION_OVERLAY_OFF(layer)                 ACTION_OVERLAY_OFF_ON(layer)
+#define ACTION_OVERLAY_OFF_ON(layer)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0)
+#define ACTION_OVERLAY_OFF_P(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_PRESS)
+#define ACTION_OVERLAY_OFF_R(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_RELEASE)
+#define ACTION_OVERLAY_OFF_B(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_BOTH)
+/* Overlay Set */
+#define ACTION_OVERLAY_SET(layer)                 ACTION_OVERLAY_SET_CLEAR(layer)
+#define ACTION_OVERLAY_SET_CLEAR(layer)           ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0)
+#define ACTION_OVERLAY_SET_P(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_PRESS)
+#define ACTION_OVERLAY_SET_R(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_RELEASE)
+#define ACTION_OVERLAY_SET_B(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_BOTH)
+/* Overlay Invert with tap key */
+#define ACTION_OVERLAY_TAP_KEY(layer, key)        ACTION(ACT_OVERLAY, (layer)<<8 | (key))
 
 
 /*

@@ 543,9 543,8 @@ static uint8_t numkey2num(uint8_t code)
 
 static void switch_default_layer(uint8_t layer)
 {
-    // TODO check existence of layer or whether it can be used as default layer
-    print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); 
-    default_layer = layer;
-    layer_switch_clear();
+    print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
+    default_layer_set(layer);
+    overlay_clear();
     clear_keyboard();
 }

@@ 14,13 14,71 @@ 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/>.
 */
+#include <avr/pgmspace.h>
 #include "keymap.h"
 #include "report.h"
 #include "keycode.h"
+#include "layer_switch.h"
 #include "action.h"
+#include "debug.h"
 
 
-action_t keymap_keycode_to_action(uint8_t keycode)
+static action_t keycode_to_action(uint8_t keycode);
+
+#ifdef USE_KEYMAP_V2
+/* converts key to action */
+action_t action_for_key(uint8_t layer, key_t key)
+{
+    uint8_t keycode = keymap_key_to_keycode(layer, key);
+    switch (keycode) {
+        case KC_FN0 ... KC_FN31:
+            return keymap_fn_to_action(keycode);
+        default:
+            return keycode_to_action(keycode);
+    }
+}
+
+__attribute__ ((weak))
+void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
+{
+}
+#else
+/* 
+ * legacy keymap support
+ */
+/* translation for legacy keymap */
+action_t action_for_key(uint8_t layer, key_t key)
+{
+    /* convert from legacy keycode to action */
+    /* layer 16-31 indicate 'overlay' but not supported in legacy keymap */
+    uint8_t keycode = keymap_get_keycode((layer & OVERLAY_MASK), key.row, key.col);
+    action_t action;
+    switch (keycode) {
+        case KC_FN0 ... KC_FN31:
+            {
+                uint8_t layer = keymap_fn_layer(FN_INDEX(keycode));
+                uint8_t key = keymap_fn_keycode(FN_INDEX(keycode));
+                if (key) {
+                    action.code = ACTION_KEYMAP_TAP_KEY(layer, key);
+                } else {
+                    action.code = ACTION_KEYMAP_MOMENTARY(layer);
+                }
+            }
+            return action;
+        default:
+            return keycode_to_action(keycode);
+    }
+}
+/* not used for legacy keymap */
+void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
+{
+}
+#endif
+
+
+
+/* translates keycode to action */
+static action_t keycode_to_action(uint8_t keycode)
 {
     action_t action;
     switch (keycode) {


@@ 51,34 109,3 @@ action_t keymap_keycode_to_action(uint8_t keycode)
     }
     return action;
 }
-
-#ifndef NO_LEGACY_KEYMAP_SUPPORT
-/* legacy support with weak reference */
-__attribute__ ((weak))
-action_t action_for_key(uint8_t layer, key_t key)
-{
-    /* convert from legacy keycode to action */
-    uint8_t keycode = keymap_get_keycode(layer, key.row, key.col);
-    action_t action;
-    switch (keycode) {
-        case KC_FN0 ... KC_FN31:
-            {
-                uint8_t layer = keymap_fn_layer(FN_INDEX(keycode));
-                uint8_t key = keymap_fn_keycode(FN_INDEX(keycode));
-                if (key) {
-                    action.code = ACTION_LAYER_SET_TAP_KEY(layer, key);
-                } else {
-                    action.code = ACTION_LAYER_SET_MOMENTARY(layer);
-                }
-            }
-            return action;
-        default:
-            return keymap_keycode_to_action(keycode);
-    }
-}
-#endif
-
-__attribute__ ((weak))
-void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
-{
-}

@@ 23,16 23,19 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "action.h"
 
 
-/* translates key_t to keycode */
+#ifdef USE_KEYMAP_V2
+/* translates key to keycode
+ *      layer:  0-15 for base layers
+ *              16-31 for overlays
+ */
 uint8_t keymap_key_to_keycode(uint8_t layer, key_t key);
-/* translates keycode to action */
-action_t keymap_keycode_to_action(uint8_t keycode);
 /* translates Fn keycode to action */
 action_t keymap_fn_to_action(uint8_t keycode);
-
-
-
-#ifndef NO_LEGACY_KEYMAP_SUPPORT
+#else
+#warning "You are using LEGACY KEYAMP. Consider using NEW KEYMAP."
+/* 
+ * legacy keymap support
+ */
 /* keycode of key */
 uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col);
 /* layer to move during press Fn key */

@@ 6,84 6,168 @@
 #include "layer_switch.h"
 
 
+/* 
+ * Default Layer (0-15)
+ */
 uint8_t default_layer = 0;
 
-uint16_t layer_switch_stat = 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
+}
+
+
+/* 
+ * 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);
+}
 
-uint16_t layer_switch_get_stat(void)
+void keymap_on(uint8_t layer)
 {
-    return layer_switch_stat;
+    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(")");
+}
+
+
+
+/* 
+ * Overlay Layer (16-31 = 0-15|0x10)
+ */
+uint16_t overlay_stat = 0;
+
 /* return highest layer whose state is on */
-uint8_t layer_switch_get_layer(void)
+uint8_t overlay_get_layer(void)
 {
-    return biton16(layer_switch_stat);
+    return biton16(overlay_stat);
 }
 
-static inline void stat_set(uint16_t stat)
+static void overlay_stat_set(uint16_t stat)
 {
-    debug("layer_switch: ");
-    layer_switch_debug(); debug(" to ");
+    debug("overlay: ");
+    overlay_debug(); debug(" to ");
 
-    layer_switch_stat = stat;
+    overlay_stat = stat;
 
-    layer_switch_debug(); debug("\n");
+    overlay_debug(); debug("\n");
 
     clear_keyboard_but_mods(); // To avoid stuck keys
 }
 
-void layer_switch_clear(void)
+void overlay_clear(void)
 {
-    stat_set(0);
+    overlay_stat_set(0);
 }
 
 
-void layer_switch_set(uint16_t stat)
+void overlay_set(uint16_t stat)
 {
-    stat_set(stat);
+    overlay_stat_set(stat);
 }
 
-void layer_switch_move(uint8_t layer)
+void overlay_move(uint8_t layer)
 {
-    if (layer)
-        stat_set(1<<layer);
-    else
-        stat_set(0);    // fall back to default layer
+    overlay_stat_set(1<<layer);
 }
 
-void layer_switch_on(uint8_t layer)
+void overlay_on(uint8_t layer)
 {
-    stat_set(layer_switch_stat | (1<<layer));
+    overlay_stat_set(overlay_stat | (1<<layer));
 }
 
-void layer_switch_off(uint8_t layer)
+void overlay_off(uint8_t layer)
 {
-    stat_set(layer_switch_stat & ~(1<<layer));
+    overlay_stat_set(overlay_stat & ~(1<<layer));
 }
 
-void layer_switch_invert(uint8_t layer)
+void overlay_invert(uint8_t layer)
 {
-    stat_set(layer_switch_stat ^ (1<<layer));
+    overlay_stat_set(overlay_stat ^ (1<<layer));
 }
 
-void layer_switch_or(uint16_t stat)
+void overlay_or(uint16_t stat)
 {
-    stat_set(layer_switch_stat | stat);
+    overlay_stat_set(overlay_stat | stat);
 }
-void layer_switch_and(uint16_t stat)
+void overlay_and(uint16_t stat)
 {
-    stat_set(layer_switch_stat & stat);
+    overlay_stat_set(overlay_stat & stat);
 }
-void layer_switch_xor(uint16_t stat)
+void overlay_xor(uint16_t stat)
 {
-    stat_set(layer_switch_stat ^ stat);
+    overlay_stat_set(overlay_stat ^ stat);
 }
 
-void layer_switch_debug(void)
+void overlay_debug(void)
 {
-    debug_hex16(layer_switch_stat); debug("("); debug_dec(layer_switch_get_layer()); debug(")");
+    debug_hex16(overlay_stat); debug("("); debug_dec(overlay_get_layer()); debug(")");
 }
 
 action_t layer_switch_get_action(key_t key)


@@ 91,14 175,27 @@ action_t layer_switch_get_action(key_t key)
     action_t action;
     action.code = ACTION_TRANSPARENT;
 
-    /* higher layer first */
+    /* overlay: top layer first */
     for (int8_t i = 15; i >= 0; i--) {
-        if (layer_switch_stat & (1<<i)) {
+        if (overlay_stat & (1<<i)) {
+            action = action_for_key(i | OVERLAY_BIT, key);
+            if (action.code != ACTION_TRANSPARENT) {
+                return action;
+            }
+        }
+    }
+
+    /* 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;
             }
         }
     }
+
+    /* default layer */
+    action = action_for_key(default_layer, key);
     return action;
 }

@@ 22,36 22,57 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #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
+ */
+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);
 
-/* layer status */
-extern uint16_t layer_switch_stat;
 
-/* return layer status */
-uint16_t layer_switch_get_stat(void);
+/*
+ * Overlay Layer
+ */
+extern uint16_t overlay_stat;
 /* return current active layer */
-uint8_t layer_switch_get_layer(void);
-
-/* switch off all layers */
-void layer_switch_clear(void);
-/* set layer status */
-void layer_switch_set(uint16_t stat);
-/* move to layer */
-void layer_switch_move(uint8_t layer);
-/* switch on layer */
-void layer_switch_on(uint8_t layer);
-/* switch off layer */
-void layer_switch_off(uint8_t layer);
-/* switch state of layer */
-void layer_switch_invert(uint8_t layer);
-
-/* bitwise operation against layer status */
-void layer_switch_or(uint16_t stat);
-void layer_switch_and(uint16_t stat);
-void layer_switch_xor(uint16_t stat);
-
-void layer_switch_debug(void);
+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);
+
+
 
 /* return action depending on current layer status */
 action_t layer_switch_get_action(key_t key);