Remove ACT_KEYMAP and ACT_OVERLAY

- Remove ACT_OVERLAY
- Rename ACT_KEYMAP to ACT_LAYER
- Add ACT_LAYER_BITOP

5 files changed, 86 insertions, 367 deletions

diff --git a/common/action.c b/common/action.c
index 07a3a64d6..ef04851b1 100644
--- a/common/action.c
+++ b/common/action.c
@@ -56,7 +56,6 @@ void process_action(keyrecord_t *record)
 
     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");
 
@@ -199,31 +198,28 @@ void process_action(keyrecord_t *record)
             }
             break;
 #endif
-#ifndef NO_ACTION_KEYMAP
-        case ACT_KEYMAP:
+#ifndef NO_ACTION_LAYER
+        case ACT_LAYER:
+        case ACT_LAYER1:
             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 */
@@ -362,161 +358,6 @@ void process_action(keyrecord_t *record)
             }
             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);
-                        }
-                    }
-                    break;
-            }
-            break;
-#endif
         /* Extentions */
 #ifndef NO_ACTION_MACRO
         case ACT_MACRO:
@@ -668,8 +509,7 @@ bool is_tap_key(key_t key)
         case ACT_LMODS_TAP:
         case ACT_RMODS_TAP:
             return true;
-        case ACT_KEYMAP:
-        case ACT_OVERLAY:
+        case ACT_LAYER:
             switch (action.layer.code) {
                 case 0x04 ... 0xEF:    /* tap key */
                 case OP_INV:
@@ -714,8 +554,8 @@ 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_BITOP:       debug("ACT_LAYER_BITOP");       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 a6cb45384..2c4f306a4 100644
--- a/common/action.h
+++ b/common/action.h
@@ -65,8 +65,8 @@ typedef union {
     } key;
     struct action_layer {
         uint8_t  code   :8;
-        uint8_t  val    :4;
-        uint8_t  kind   :4;
+        uint8_t  val    :5;
+        uint8_t  kind   :3;
     } layer;
     struct action_usage {
         uint16_t code   :10;
@@ -170,35 +170,42 @@ void debug_action(action_t action);
  *
  * 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)
+ * ACT_LAYER: 
+ * 1000|--xx|0000 0000   Clear keyamp
+ * 100X|LLLL|0000 00xx   Reset default layer and clear keymap
+ * 100X|LLLL| keycode    Invert with tap key
+ * 100X|LLLL|1111 0000   Invert with tap toggle
+ * 100X|LLLL|1111 00xx   Invert[^= 1<<L]
+ * 100X|LLLL|1111 0100   On/Off
+ * 100X|LLLL|1111 01xx   On[|= 1<<L]
+ * 100X|LLLL|1111 1000   Off/On
+ * 100X|LLLL|1111 10xx   Off[&= ~(1<<L)]
+ * 100X|LLLL|1111 1100   Set/Clear
+ * 100X|LLLL|1111 11xx   Set[= 1<<L]
+ * XLLLL: Layer 0-31
  * 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}
+ * ACT_LAYER_BITOP:
+ * 101B|Booo|xxxx xxxx   bit operation
+ * BB: operand. which part of layer state bits
+ *      00: 0-7th bit
+ *      01: 8-15th bit
+ *      10: 16-23th bit
+ *      11: 24-31th bit
+ * ooo: operation.
+ *      000: AND
+ *      001: OR
+ *      010: XOR
+ *      011: 
+ *      100: LSHIFT
+ *      101: RSHIFT
+ *      110: 
+ *      111: 
+ * bbbb bbbb: bits
+ * layer_state |= (((layer_state>>(0bBB*8)) & 0xff) BITOP 0bxxxxxxxx)<<(0bBB*8)
+ * layer_state: 32-bit layer switch state
+ *
+ *
  *
  *
  * Extensions(11XX)
@@ -216,16 +223,20 @@ void debug_action(action_t action);
  *
  */
 enum action_kind_id {
+    ACT_MODS            = 0b0000,
     ACT_LMODS           = 0b0000,
     ACT_RMODS           = 0b0001,
+    ACT_MODS_TAP        = 0b0010,
     ACT_LMODS_TAP       = 0b0010,
     ACT_RMODS_TAP       = 0b0011,
 
     ACT_USAGE           = 0b0100,
     ACT_MOUSEKEY        = 0b0101,
 
-    ACT_KEYMAP          = 0b1000,
-    ACT_OVERLAY         = 0b1001,
+    ACT_LAYER           = 0b1000,
+    ACT_LAYER1          = 0b1001,
+    ACT_LAYER_BITOP     = 0b1010,
+    ACT_LAYER1_BITOP    = 0b1011,
 
     ACT_MACRO           = 0b1100,
     ACT_COMMAND         = 0b1110,
@@ -285,12 +296,14 @@ enum usage_pages {
  *      Set     layer = (1<<layer)
  *      Clear   layer = 0
  */
-enum layer_params {
+enum layer_param_on {
     ON_PRESS    = 1,
     ON_RELEASE  = 2,
     ON_BOTH     = 3,
+};
 
-    OP_RESET  = 0x00,
+enum layer_pram_op {
+    OP_RESET = 0x00,
     OP_INV4  = 0x00,
     OP_INV   = 0xF0,
     OP_ON    = 0xF4,
@@ -298,56 +311,49 @@ enum layer_params {
     OP_SET   = 0xFC,
 };
 
+enum layer_pram_bitop {
+    BITOP_AND,
+    BITOP_OR,
+    BITOP_XOR,
+    BITOP_LSHIFT,
+    BITOP_RSHIFT,
+};
+
 /* 
  * Default Layer
  */
-#define ACTION_DEFAULT_LAYER                     ACTION(ACT_KEYMAP, ON_RELEASE<<8 | OP_RESET | 0)
+#define ACTION_DEFAULT_LAYER                     ACTION(ACT_LAYER, 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))
+#define ACTION_DEFAULT_LAYER_TO(layer, on)       ACTION(ACT_LAYER, (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)
+#define ACTION_LAYER_MOMENTARY(layer)           ACTION_LAYER_ON_OFF(layer)
+#define ACTION_LAYER_TOGGLE(layer)              ACTION_LAYER_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)
+#define ACTION_LAYER_INV(layer, on)             ACTION(ACT_LAYER, (layer)<<8 | OP_INV | (on))
+#define ACTION_LAYER_TAP_TOGGLE(layer)          ACTION(ACT_LAYER, (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)
+#define ACTION_LAYER_ON(layer, on)              ACTION(ACT_LAYER, (layer)<<8 | OP_ON  | (on))
+#define ACTION_LAYER_ON_OFF(layer)              ACTION(ACT_LAYER, (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)
+#define ACTION_LAYER_OFF(layer, on)             ACTION(ACT_LAYER, (layer)<<8 | OP_OFF | (on))
+#define ACTION_LAYER_OFF_ON(layer)              ACTION(ACT_LAYER, (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)
+#define ACTION_LAYER_SET(layer, on)             ACTION(ACT_LAYER, (layer)<<8 | OP_SET | (on))
+#define ACTION_LAYER_SET_CLEAR(layer)           ACTION(ACT_LAYER, (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))
-
+#define ACTION_LAYER_TAP_KEY(layer, key)        ACTION(ACT_LAYER, (layer)<<8 | (key))
+
+/* Layer BitOp: 101|BB|ooo|xxxxxxxx */
+#define ACTION_LAYER_BITOP(op, part, bits)      (ACT_LAYER_BITOP<<12 | (part&0x3)<<11 | (op&0x7)<<8 | bits)
+#define ACTION_LAYER_AND(part, bits)            ACTION_LAYER_BITOP(BITOP_AND, part, bits)
+#define ACTION_LAYER_OR(part, bits)             ACTION_LAYER_BITOP(BITOP_OR, part, bits)
+#define ACTION_LAYER_XOR(part, bits)            ACTION_LAYER_BITOP(BITOP_XOR, part, bits)
+#define ACTION_LAYER_LSHIFT(part, bits)         ACTION_LAYER_BITOP(BITOP_LSHIFT, part, bits)
+#define ACTION_LAYER_RSHIFT(part, bits)         ACTION_LAYER_BITOP(BITOP_RSHIFT, part, bits)
+ 
 
 /*
  * Extensions
diff --git a/common/command.c b/common/command.c
index b29333883..e197a8f80 100644
--- a/common/command.c
+++ b/common/command.c
@@ -575,6 +575,5 @@ static void switch_default_layer(uint8_t layer)
 {
     print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
     default_layer_set(layer);
-    overlay_clear();
     clear_keyboard();
 }
diff --git a/common/layer_switch.c b/common/layer_switch.c
index a5d426a89..359e6b9d8 100644
--- a/common/layer_switch.c
+++ b/common/layer_switch.c
@@ -24,7 +24,7 @@ void default_layer_set(uint8_t layer)
 }
 
 
-#ifndef NO_ACTION_KEYMAP
+#ifndef NO_ACTION_LAYER
 /* 
  * Keymap Layer (0-15)
  */
@@ -100,98 +100,12 @@ void keymap_debug(void)
 
 
 
-#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
+#ifndef NO_ACTION_LAYER
     /* keymap: top layer first */
     for (int8_t i = 15; i >= 0; i--) {
         if (keymap_stat & (1<<i)) {
diff --git a/common/layer_switch.h b/common/layer_switch.h
index eb4cf61ba..423dafb5b 100644
--- a/common/layer_switch.h
+++ b/common/layer_switch.h
@@ -22,11 +22,6 @@ 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
  */
@@ -38,7 +33,7 @@ void default_layer_set(uint8_t layer);
 /*
  * Keymap Layer
  */
-#ifndef NO_ACTION_KEYMAP
+#ifndef NO_ACTION_LAYER
 extern uint16_t keymap_stat;
 /* return current active layer */
 uint8_t keymap_get_layer(void);
@@ -69,41 +64,6 @@ void keymap_debug(void);
 #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);