summaryrefslogtreecommitdiff
path: root/common
diff options
context:
space:
mode:
Diffstat (limited to 'common')
-rw-r--r--common/action.c394
-rw-r--r--common/action.h221
-rw-r--r--common/command.c29
-rw-r--r--common/keymap.c91
-rw-r--r--common/keymap.h17
-rw-r--r--common/layer_switch.c201
-rw-r--r--common/layer_switch.h80
-rw-r--r--common/util.c11
-rw-r--r--common/util.h1
9 files changed, 776 insertions, 269 deletions
diff --git a/common/action.c b/common/action.c
index 6528cd46c8..294ce00fb1 100644
--- a/common/action.c
+++ b/common/action.c
@@ -24,12 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "util.h"
#include "debug.h"
#include "action.h"
-
-
-/* default layer indicates base layer */
-uint8_t default_layer = 0;
-/* current layer indicates active layer at this time */
-uint8_t current_layer = 0;
+#include "layer_switch.h"
static void process_action(keyrecord_t *record);
@@ -207,19 +202,6 @@ void action_exec(keyevent_t event)
}
}
-static action_t get_action(key_t key)
-{
- action_t action = action_for_key(current_layer, key);
-
- /* Transparently use default layer */
- if (action.code == ACTION_TRANSPARENT) {
- // TODO: layer stacking
- action = action_for_key(default_layer, key);
- debug("TRNASPARENT: "); debug_hex16(action.code); debug("\n");
- }
- return action;
-}
-
static void process_action(keyrecord_t *record)
{
keyevent_t event = record->event;
@@ -227,8 +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("\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 */
@@ -287,7 +272,7 @@ static void process_action(keyrecord_t *record)
} else {
if (tap_count == 0) {
debug("MODS_TAP: Oneshot: cancel/del_mods\n");
- // cancel oneshot by holding.
+ // cancel oneshot on hold
oneshot_cancel();
del_mods(mods);
}
@@ -368,145 +353,316 @@ static void process_action(keyrecord_t *record)
#endif
break;
- /* Layer key */
- case ACT_LAYER:
+ case ACT_KEYMAP:
switch (action.layer.code) {
- case LAYER_MOMENTARY: /* momentary */
- if (event.pressed) {
- layer_switch(action.layer.val);
- }
- else {
- // NOTE: This is needed by legacy keymap support
- layer_switch(default_layer);
- }
- break;
- case LAYER_ON_PRESS:
- if (event.pressed) {
- layer_switch(action.layer.val);
- }
- break;
- case LAYER_ON_RELEASE:
- if (!event.pressed) {
- layer_switch(action.layer.val);
- }
- break;
- case LAYER_DEFAULT: /* default layer */
- switch (action.layer.val) {
- case DEFAULT_ON_BOTH:
- layer_switch(default_layer);
+ /* Keymap clear */
+ case OP_RESET:
+ switch (action.layer.val & 0x03) {
+ case 0:
+ overlay_clear();
+ keymap_clear();
break;
- case DEFAULT_ON_PRESS:
+ case ON_PRESS:
if (event.pressed) {
- layer_switch(default_layer);
+ overlay_clear();
+ keymap_clear();
}
break;
- case DEFAULT_ON_RELEASE:
+ case ON_RELEASE:
if (!event.pressed) {
- layer_switch(default_layer);
+ overlay_clear();
+ keymap_clear();
}
break;
+ case ON_BOTH:
+ overlay_clear();
+ keymap_clear();
+ break;
}
break;
- case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */
+ /* Keymap Reset default layer */
+ case (OP_RESET | ON_PRESS):
+ if (event.pressed) {
+ overlay_clear();
+ keymap_clear();
+ default_layer_set(action.layer.val);
+ }
+ break;
+ case (OP_RESET | ON_RELEASE):
+ if (!event.pressed) {
+ overlay_clear();
+ keymap_clear();
+ default_layer_set(action.layer.val);
+ }
+ break;
+ case (OP_RESET | ON_BOTH):
+ overlay_clear();
+ keymap_clear();
+ default_layer_set(action.layer.val);
+ break;
+
+ /* Keymap Bit invert */
+ case OP_INV:
+ /* with tap toggle */
if (event.pressed) {
if (tap_count < TAPPING_TOGGLE) {
- layer_switch(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(action.layer.val);
+ if (tap_count <= TAPPING_TOGGLE) {
+ debug("KEYMAP_INV: tap toggle(release).\n");
+ keymap_invert(action.layer.val);
}
}
break;
- case LAYER_CHANGE_DEFAULT: /* change default layer */
+ case (OP_INV | ON_PRESS):
if (event.pressed) {
- default_layer = action.layer.val;
- layer_switch(default_layer);
+ keymap_invert(action.layer.val);
+ }
+ break;
+ case (OP_INV | ON_RELEASE):
+ if (!event.pressed) {
+ keymap_invert(action.layer.val);
}
break;
- default: /* switch layer on hold and key on tap*/
+ case (OP_INV | ON_BOTH):
+ keymap_invert(action.layer.val);
+ break;
+
+ /* Keymap Bit on */
+ case OP_ON:
if (event.pressed) {
- if (tap_count > 0) {
- debug("LAYER_PRESSED: Tap: register_code\n");
+ 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);
+ }
+ 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:
+ if (event.pressed) {
+ if (tap_count > 0) {
+ debug("KEYMAP_TAP_KEY: Tap: register_code\n");
register_code(action.layer.code);
- } else {
- debug("LAYER_PRESSED: No tap: layer_switch\n");
- layer_switch(action.layer.val);
- }
+ } else {
+ debug("KEYMAP_TAP_KEY: No tap: On on press\n");
+ keymap_on(action.layer.val);
+ }
} else {
if (tap_count > 0) {
- debug("LAYER_PRESSED: Tap: unregister_code\n");
+ debug("KEYMAP_TAP_KEY: Tap: unregister_code\n");
unregister_code(action.layer.code);
} else {
- //debug("LAYER_PRESSED: No tap: NO ACTION\n");
- // NOTE: This is needed by legacy keymap support
- debug("LAYER_PRESSED: No tap: return to default layer\n");
- layer_switch(default_layer);
+ debug("KEYMAP_TAP_KEY: No tap: Off on release\n");
+ keymap_off(action.layer.val);
}
}
break;
}
break;
- case ACT_LAYER_BIT:
+
+ case ACT_OVERLAY:
switch (action.layer.code) {
- case LAYER_MOMENTARY: /* momentary */
- if (event.pressed) {
- layer_switch(current_layer ^ action.layer.val);
+ // Overlay Invert bit4
+ case OP_INV4 | 0:
+ if (action.layer.val == 0) {
+ overlay_clear();
} else {
- layer_switch(current_layer ^ action.layer.val);
+ overlay_set(overlay_stat ^ action.layer.val);
}
break;
- case LAYER_ON_PRESS:
- if (event.pressed) {
- layer_switch(current_layer ^ 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(current_layer ^ 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 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_BIT: tap toggle(press).\n");
- layer_switch(current_layer ^ action.layer.val);
+ debug("OVERLAY_INV: tap toggle(press).\n");
+ overlay_invert(action.layer.val);
}
} else {
if (tap_count <= TAPPING_TOGGLE) {
- debug("LAYER_BIT: tap toggle(release).\n");
- layer_switch(current_layer ^ action.layer.val);
+ debug("OVERLAY_INV: tap toggle(release).\n");
+ overlay_invert(action.layer.val);
}
}
break;
- case 0xFF:
- // change default layer
+ 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) {
- default_layer = current_layer ^ action.layer.val;
- layer_switch(default_layer);
+ overlay_off(action.layer.val);
} else {
- default_layer = current_layer ^ action.layer.val;
- layer_switch(default_layer);
+ 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:
- // with tap key
if (event.pressed) {
- if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
- debug("LAYER_BIT: Tap: register_code\n");
+ if (tap_count > 0) {
+ debug("OVERLAY_TAP_KEY: Tap: register_code\n");
register_code(action.layer.code);
} else {
- debug("LAYER_BIT: No tap: layer_switch(bit on)\n");
- layer_switch(current_layer ^ action.layer.val);
+ debug("OVERLAY_TAP_KEY: No tap: On on press\n");
+ overlay_on(action.layer.val);
}
} else {
- if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
- debug("LAYER_BIT: Tap: unregister_code\n");
+ if (tap_count > 0) {
+ debug("OVERLAY_TAP_KEY: Tap: unregister_code\n");
unregister_code(action.layer.code);
} else {
- debug("LAYER_BIT: No tap: layer_switch(bit off)\n");
- layer_switch(current_layer ^ action.layer.val);
+ debug("OVERLAY_TAP_KEY: No tap: Off on release\n");
+ overlay_off(action.layer.val);
}
}
break;
@@ -813,39 +969,23 @@ bool sending_anykey(void)
host_last_sysytem_report() || host_last_consumer_report());
}
-void layer_switch(uint8_t new_layer)
-{
- if (current_layer != new_layer) {
- debug("Layer Switch: "); debug_hex(current_layer);
- debug(" -> "); debug_hex(new_layer); debug("\n");
-
- current_layer = new_layer;
- clear_keyboard_but_mods(); // To avoid stuck keys
- // NOTE: update mods with full scan of matrix? if modifier changes between layers
- }
-}
-
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:
- 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_DEFAULT:
- 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;
@@ -876,8 +1016,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: debug("ACT_LAYER"); break;
- case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); 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;
diff --git a/common/action.h b/common/action.h
index b9a6cb5b40..4892cc7fd9 100644
--- a/common/action.h
+++ b/common/action.h
@@ -76,11 +76,6 @@ typedef union {
-/* layer used currently */
-extern uint8_t current_layer;
-/* layer to return or start with */
-extern uint8_t default_layer;
-
/* Execute action per keyevent */
void action_exec(keyevent_t event);
@@ -155,32 +150,41 @@ bool waiting_buffer_has_anykey_pressed(void);
*
* Mouse Keys
* ----------
- * TODO: can be combined with 'Other HID Usage'? to save action kind id.
* ACT_MOUSEKEY(0110):
* 0101|XXXX| keycode Mouse key
*
*
* Layer Actions
* -------------
- * ACT_LAYER(1000): Set layer
- * ACT_LAYER_BIT(1001): Bit-op layer
- *
- * 1000|LLLL|0000 0000 set L to layer on press and set default on release(momentary)
- * 1000|LLLL|0000 0001 set L to layer on press
- * 1000|LLLL|0000 0010 set L to layer on release
- * 1000|----|0000 0011 set default to layer on both(return to default layer)
- * 1000|LLLL| keycode set L to layer while hold and send key on tap
- * 1000|LLLL|1111 0000 set L to layer while hold and toggle on several taps
- * 1000|LLLL|1111 1111 set L to default and layer(on press)
- *
- * 1001|BBBB|0000 0000 (not used)
- * 1001|BBBB|0000 0001 bit-xor layer with B on press
- * 1001|BBBB|0000 0010 bit-xor layer with B on release
- * 1001|BBBB|0000 0011 bit-xor layer with B on both(momentary)
- * 1001|BBBB| keycode bit-xor layer with B while hold and send key on tap
- * 1001|BBBB|1111 0000 bit-xor layer with B while hold and toggle on several taps
- * 1001|BBBB|1111 1111 bit-xor default with B and set layer(on press)
+ * 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)
@@ -208,8 +212,8 @@ enum action_kind_id {
ACT_USAGE = 0b0100,
ACT_MOUSEKEY = 0b0101,
- ACT_LAYER = 0b1000,
- ACT_LAYER_BIT = 0b1001,
+ ACT_KEYMAP = 0b1000,
+ ACT_OVERLAY = 0b1001,
ACT_MACRO = 0b1100,
ACT_COMMAND = 0b1110,
@@ -223,20 +227,20 @@ enum action_kind_id {
#define ACTION(kind, param) ((kind)<<12 | (param))
#define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F)
-/* Key */
+/*
+ * Key
+ */
#define ACTION_KEY(key) ACTION(ACT_LMODS, key)
/* Mods & key */
#define ACTION_LMODS(mods) ACTION(ACT_LMODS, MODS4(mods)<<8 | 0x00)
#define ACTION_LMODS_KEY(mods, key) ACTION(ACT_LMODS, MODS4(mods)<<8 | (key))
#define ACTION_RMODS(mods) ACTION(ACT_RMODS, MODS4(mods)<<8 | 0x00)
#define ACTION_RMODS_KEY(mods, key) ACTION(ACT_RMODS, MODS4(mods)<<8 | (key))
-/* Mod & key */
#define ACTION_LMOD(mod) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | 0x00)
#define ACTION_LMOD_KEY(mod, key) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | (key))
#define ACTION_RMOD(mod) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | 0x00)
#define ACTION_RMOD_KEY(mod, key) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | (key))
-
-/* Mods + Tap key */
+/* Tap key */
enum mods_codes {
MODS_ONESHOT = 0x00,
};
@@ -244,81 +248,122 @@ enum mods_codes {
#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT)
#define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key))
#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT)
-/* Mod + Tap key */
#define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key))
#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
#define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key))
#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
-/*
- * Switch layer
+/* 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_DEFAULT =3,
- LAYER_TAP_TOGGLE = 0xF0,
- LAYER_CHANGE_DEFAULT = 0xFF
-};
-enum layer_vals_default {
- DEFAULT_ON_PRESS = 1,
- DEFAULT_ON_RELEASE = 2,
- DEFAULT_ON_BOTH = 3,
+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, 0<<8 | OP_RESET | 0)
+#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)
/*
- * return to default layer
+ * Keymap Layer
*/
-#define ACTION_LAYER_DEFAULT ACTION_LAYER_DEFAULT_R
-/* set default layer on press */
-#define ACTION_LAYER_DEFAULT_P ACTION(ACT_LAYER, DEFAULT_ON_PRESS<<8 | LAYER_DEFAULT)
-/* set default layer on release */
-#define ACTION_LAYER_DEFAULT_R ACTION(ACT_LAYER, DEFAULT_ON_RELEASE<<8 | LAYER_DEFAULT)
-/* change default layer and set layer */
+#define ACTION_KEYMAP(layer) ACTION_KEYMAP_MOMENTARY(layer)
+#define ACTION_KEYMAP_MOMENTARY(layer) ACTION_KEYMAP_ON_OFF(layer)
+#define ACTION_KEYMAP_TOGGLE(layer) ACTION_KEYMAP_INV_R(layer)
+/* Keymap Set and clear overaly */
+#define ACTION_KEYMAP_RESET(layer) ACTION_KEYMAP_RESET_R(layer)
+#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_RELEASE)
+#define ACTION_KEYMAP_RESET_B(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_BOTH)
+/* 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))
/*
- * Set layer
+ * Overlay Layer
*/
-/* set layer on press and none on release */
-#define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer)
-/* set layer on press and set default on release (This is needed by legacy keymap support.) */
-#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY)
-/* set layer on press and none on release */
-#define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer)
-/* set layer while hold and send key on tap */
-#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
-/* set layer on press */
-#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS)
-/* set layer on release */
-#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE)
-/* set layer on hold and toggle on several taps */
-#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_TAP_TOGGLE)
-/* set default layer on both press and release */
-#define ACTION_LAYER_SET_DEFAULT(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_CHANGE_DEFAULT)
+#define ACTION_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))
+
/*
- * Bit-op layer
+ * HID Usage
*/
-/* bit-xor on both press and release */
-#define ACTION_LAYER_BIT(bits) ACTION_LAYER_BIT_MOMENTARY(bits)
-#define ACTION_LAYER_BIT_MOMENTARY(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_MOMENTARY)
-/* bit-xor on press */
-#define ACTION_LAYER_BIT_TOGGLE(bits) ACTION_LAYER_BIT_R(bits)
-/* bit-xor while hold and send key on tap */
-#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key))
-/* bit-xor on press */
-#define ACTION_LAYER_BIT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS)
-/* bit-xor on release */
-#define ACTION_LAYER_BIT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE)
-/* bit-xor while hold and toggle on several taps */
-#define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE)
-/* bit-xor default layer and set layer */
-#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_CHANGE_DEFAULT)
-
-
-/* HID Usage */
enum usage_pages {
PAGE_SYSTEM,
PAGE_CONSUMER
diff --git a/common/command.c b/common/command.c
index 7bb2a23f19..202d531fd8 100644
--- a/common/command.c
+++ b/common/command.c
@@ -26,7 +26,9 @@ 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 "command.h"
+
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#endif
@@ -53,7 +55,7 @@ static void mousekey_console_help(void);
#endif
static uint8_t numkey2num(uint8_t code);
-static void switch_layer(uint8_t layer);
+static void switch_default_layer(uint8_t layer);
typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t;
@@ -261,18 +263,16 @@ static bool command_common(uint8_t code)
#endif
break;
#endif
+ case KC_ESC:
+ case KC_GRV:
case KC_0:
- case KC_F10:
- clear_keyboard();
- switch_layer(0);
+ switch_default_layer(0);
break;
case KC_1 ... KC_9:
- clear_keyboard();
- switch_layer((code - KC_1) + 1);
+ switch_default_layer((code - KC_1) + 1);
break;
- case KC_F1 ... KC_F9:
- clear_keyboard();
- switch_layer((code - KC_F1) + 1);
+ case KC_F1 ... KC_F12:
+ switch_default_layer((code - KC_F1) + 1);
break;
default:
print("?");
@@ -541,11 +541,10 @@ static uint8_t numkey2num(uint8_t code)
return 0;
}
-static void switch_layer(uint8_t layer)
+static void switch_default_layer(uint8_t layer)
{
- print_val_hex8(current_layer);
- print_val_hex8(default_layer);
- current_layer = layer;
- default_layer = layer;
- print("switch to "); print_val_hex8(layer);
+ 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/keymap.c b/common/keymap.c
index 078615814e..ddc3210524 100644
--- a/common/keymap.c
+++ b/common/keymap.c
@@ -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 *record, 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 *record, 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)
-{
-}
diff --git a/common/keymap.h b/common/keymap.h
index 63bf14482b..0c483483fb 100644
--- a/common/keymap.h
+++ b/common/keymap.h
@@ -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 */
diff --git a/common/layer_switch.c b/common/layer_switch.c
new file mode 100644
index 0000000000..19e286f885
--- /dev/null
+++ b/common/layer_switch.c
@@ -0,0 +1,201 @@
+#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
+}
+
+
+/*
+ * 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(")");
+}
+
+
+
+/*
+ * 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(")");
+}
+
+action_t layer_switch_get_action(key_t key)
+{
+ action_t action;
+ action.code = ACTION_TRANSPARENT;
+
+ /* 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;
+ }
+ }
+ }
+
+ /* 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;
+}
diff --git a/common/layer_switch.h b/common/layer_switch.h
new file mode 100644
index 0000000000..a566ab12b7
--- /dev/null
+++ b/common/layer_switch.h
@@ -0,0 +1,80 @@
+/*
+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
+ */
+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);
+
+
+/*
+ * Overlay Layer
+ */
+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);
+
+
+
+/* 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 9d8fb93219..ff1926d7d1 100644
--- a/common/util.c
+++ b/common/util.c
@@ -39,6 +39,7 @@ uint8_t bitpop16(uint16_t bits)
}
// 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)
{
uint8_t n = 0;
@@ -47,3 +48,13 @@ uint8_t biton(uint8_t bits)
if (bits >> 1) { bits >>= 1; n += 1;}
return n;
}
+
+uint8_t biton16(uint16_t bits)
+{
+ uint8_t n = 0;
+ 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 c3734487f9..58b7fdf145 100644
--- a/common/util.h
+++ b/common/util.h
@@ -31,5 +31,6 @@ 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 biton(uint8_t bits);
+uint8_t biton16(uint16_t bits);
#endif