mirrors/qmk_firmware
1
0
Fork 1
mirror of https://github.com/qmk/qmk_firmware synced 2024-11-13 23:44:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

Add overlay framework

Browse source
This commit is contained in:
tmk 2013-02-20 11:16:13 +09:00
parent abf0b04d14
commit e0f960a576
7 changed files with 612 additions and 368 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

408
common/action.c
View file

@ -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) static void process_action(keyrecord_t *record)
{ {
keyevent_t event = record->event; keyevent_t event = record->event;
@ -226,9 +209,11 @@ static void process_action(keyrecord_t *record)
if (IS_NOEVENT(event)) { return; } if (IS_NOEVENT(event)) { return; }
action_t action = get_action(event.key); action_t action = layer_switch_get_action(event.key);
debug("ACTION: "); debug_action(action); debug(" "); debug("ACTION: "); debug_action(action);
layer_switch_debug(); debug("["); debug_dec(default_layer); debug("]\n"); debug(" overlays: "); overlay_debug();
debug(" keymaps: "); keymap_debug();
debug(" default_layer: "); debug_dec(default_layer); debug("\n");
switch (action.kind.id) { switch (action.kind.id) {
/* Key and Mods */ /* Key and Mods */
@ -368,207 +353,292 @@ static void process_action(keyrecord_t *record)
#endif #endif
break; break;
/* Layer key */ case ACT_KEYMAP:
case ACT_LAYER_SET:
switch (action.layer.code) { switch (action.layer.code) {
case LAYER_MOMENTARY: /* momentary */ /* Keymap Reset */
case OP_RESET:
default_layer_set(action.layer.val);
break;
/* Keymap Reset default layer */
case (OP_RESET | ON_PRESS):
if (event.pressed) { if (event.pressed) {
layer_switch_move(action.layer.val); default_layer_set(action.layer.val);
} overlay_clear();
else {
// NOTE: This is needed by legacy keymap support
layer_switch_move(0);
} }
break; break;
case LAYER_ON_PRESS: case (OP_RESET | ON_RELEASE):
if (event.pressed) {
layer_switch_move(action.layer.val);
}
break;
case LAYER_ON_RELEASE:
if (!event.pressed) { if (!event.pressed) {
layer_switch_move(action.layer.val); default_layer_set(action.layer.val);
overlay_clear();
} }
break; break;
case LAYER_ON_BOTH: case (OP_RESET | ON_BOTH):
layer_switch_move(action.layer.val); default_layer_set(action.layer.val);
overlay_clear();
break; 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 (event.pressed) {
if (tap_count < TAPPING_TOGGLE) { 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);
}
}
break;
case LAYER_SET_DEFAULT_ON_PRESS:
if (event.pressed) {
default_layer = action.layer.val;
layer_switch_move(0);
}
break;
case LAYER_SET_DEFAULT_ON_RELEASE:
if (!event.pressed) {
default_layer = action.layer.val;
layer_switch_move(0);
}
break;
case LAYER_SET_DEFAULT_ON_BOTH:
default_layer = action.layer.val;
layer_switch_move(0);
break;
default:
/* tap key */
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);
}
} 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);
}
}
break;
}
break;
case ACT_LAYER_BIT:
switch (action.layer.code) {
case LAYER_MOMENTARY: /* momentary */
if (event.pressed) {
layer_switch_move(layer_switch_get_layer() | action.layer.val);
} else {
layer_switch_move(layer_switch_get_layer() & ~action.layer.val);
}
break;
case LAYER_ON_PRESS:
if (event.pressed) {
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
break;
case LAYER_ON_RELEASE:
if (!event.pressed) {
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
break;
case LAYER_ON_BOTH:
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
break;
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */
if (event.pressed) {
if (tap_count < TAPPING_TOGGLE) {
debug("LAYER_BIT: tap toggle(press).\n");
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
} }
} else { } else {
if (tap_count <= TAPPING_TOGGLE) { if (tap_count <= TAPPING_TOGGLE) {
debug("LAYER_BIT: tap toggle(release).\n"); debug("KEYMAP_INV: tap toggle(release).\n");
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); keymap_invert(action.layer.val);
} }
} }
break; break;
case LAYER_SET_DEFAULT_ON_PRESS: case (OP_INV | ON_PRESS):
if (event.pressed) { if (event.pressed) {
default_layer = default_layer ^ action.layer.val; keymap_invert(action.layer.val);
layer_switch_move(default_layer);
} }
break; break;
case LAYER_SET_DEFAULT_ON_RELEASE: case (OP_INV | ON_RELEASE):
if (!event.pressed) { if (!event.pressed) {
default_layer = default_layer ^ action.layer.val; keymap_invert(action.layer.val);
layer_switch_move(default_layer);
} }
break; break;
case LAYER_SET_DEFAULT_ON_BOTH: case (OP_INV | ON_BOTH):
default_layer = default_layer ^ action.layer.val; keymap_invert(action.layer.val);
layer_switch_move(default_layer);
break; break;
/* Keymap Bit on */
case OP_ON:
if (event.pressed) {
keymap_on(action.layer.val);
} else {
keymap_off(action.layer.val);
}
break;
case (OP_ON | ON_PRESS):
if (event.pressed) {
keymap_on(action.layer.val);
}
break;
case (OP_ON | ON_RELEASE):
if (!event.pressed) {
keymap_on(action.layer.val);
}
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: default:
// tap key
if (event.pressed) { if (event.pressed) {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { 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); register_code(action.layer.code);
} else { } else {
debug("LAYER_BIT: No tap: layer_bit(on press)\n"); debug("KEYMAP_TAP_KEY: No tap: invert on press\n");
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); keymap_invert(action.layer.val);
} }
} else { } else {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { 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); unregister_code(action.layer.code);
} else { } else {
debug("LAYER_BIT: No tap: layer_bit(on release)\n"); debug("KEYMAP_TAP_KEY: No tap: invert on release\n");
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); keymap_invert(action.layer.val);
} }
} }
break; break;
} }
break; break;
case ACT_LAYER_SWITCH:
case ACT_OVERLAY:
switch (action.layer.code) { switch (action.layer.code) {
case LAYER_MOMENTARY: /* momentary */ // Overlay Invert bit4
if (event.pressed) { case OP_INV4 | 0:
layer_switch_on(action.layer.val); if (action.layer.val == 0) {
overlay_clear();
} else { } else {
layer_switch_off(action.layer.val); overlay_set(overlay_stat ^ action.layer.val);
} }
break; break;
case LAYER_ON_PRESS: case OP_INV4 | 1:
if (event.pressed) { if (action.layer.val == 0) {
layer_switch_invert(action.layer.val); if (event.pressed) overlay_clear();
} else {
overlay_set(overlay_stat ^ action.layer.val<<4);
} }
break; break;
case LAYER_ON_RELEASE: case OP_INV4 | 2:
if (!event.pressed) { if (action.layer.val == 0) {
layer_switch_invert(action.layer.val); if (!event.pressed) overlay_clear();
} else {
overlay_set(overlay_stat ^ action.layer.val<<8);
} }
break; break;
case LAYER_ON_BOTH: case OP_INV4 | 3:
layer_switch_invert(action.layer.val); if (action.layer.val == 0) {
overlay_clear();
} else {
overlay_set(overlay_stat ^ action.layer.val<<12);
}
break; 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 (event.pressed) {
if (tap_count < TAPPING_TOGGLE) { if (tap_count < TAPPING_TOGGLE) {
debug("LAYER_SWITCH: tap toggle(press).\n"); debug("OVERLAY_INV: tap toggle(press).\n");
layer_switch_invert(action.layer.val); overlay_invert(action.layer.val);
} }
} else { } else {
if (tap_count <= TAPPING_TOGGLE) { if (tap_count <= TAPPING_TOGGLE) {
debug("LAYER_SWITCH: tap toggle(release).\n"); debug("OVERLAY_INV: tap toggle(release).\n");
layer_switch_invert(action.layer.val); overlay_invert(action.layer.val);
} }
} }
break; 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: default:
// tap key
if (event.pressed) { if (event.pressed) {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { 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); register_code(action.layer.code);
} else { } else {
debug("LAYER_SWITCH: No tap: layer_switch on press\n"); debug("OVERLAY_TAP_KEY: No tap: invert on press\n");
layer_switch_invert(action.layer.val); overlay_invert(action.layer.val);
} }
} else { } else {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { 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); unregister_code(action.layer.code);
} else { } else {
debug("LAYER_SWITCH: No tap: layer_switch on release\n"); debug("OVERLAY_TAP_KEY: No tap: invert on release\n");
layer_switch_invert(action.layer.val); overlay_invert(action.layer.val);
} }
} }
break; break;
@ -877,28 +947,21 @@ bool sending_anykey(void)
bool is_tap_key(key_t key) 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) { switch (action.kind.id) {
case ACT_LMODS_TAP: case ACT_LMODS_TAP:
case ACT_RMODS_TAP: case ACT_RMODS_TAP:
return true; return true;
case ACT_LAYER_SET: case ACT_KEYMAP:
case ACT_LAYER_BIT: case ACT_OVERLAY:
switch (action.layer.code) { switch (action.layer.code) {
case LAYER_MOMENTARY: case 0x04 ... 0xEF: /* tap key */
case LAYER_ON_PRESS: case OP_INV:
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 */
return true; return true;
} default:
return false; return false;
}
case ACT_FUNCTION: case ACT_FUNCTION:
if (action.func.opt & FUNC_TAP) { return true; } if (action.func.opt & FUNC_TAP) { return true; }
return false; return false;
@ -929,9 +992,8 @@ static void debug_action(action_t action)
case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break; case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break;
case ACT_USAGE: debug("ACT_USAGE"); break; case ACT_USAGE: debug("ACT_USAGE"); break;
case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break;
case ACT_LAYER_SET: debug("ACT_LAYER_SET"); break; case ACT_KEYMAP: debug("ACT_KEYMAP"); break;
case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break; case ACT_OVERLAY: debug("ACT_OVERLAY"); break;
case ACT_LAYER_SWITCH: debug("ACT_LAYER_SWITCH"); break;
case ACT_MACRO: debug("ACT_MACRO"); break; case ACT_MACRO: debug("ACT_MACRO"); break;
case ACT_COMMAND: debug("ACT_COMMAND"); break; case ACT_COMMAND: debug("ACT_COMMAND"); break;
case ACT_FUNCTION: debug("ACT_FUNCTION"); break; case ACT_FUNCTION: debug("ACT_FUNCTION"); break;

217
common/action.h
View file

@ -150,40 +150,41 @@ bool waiting_buffer_has_anykey_pressed(void);
* *
* Mouse Keys * Mouse Keys
* ---------- * ----------
* NOTE: can be combined with 'Other HID Usage'? to save action kind id.
* ACT_MOUSEKEY(0110): * ACT_MOUSEKEY(0110):
* 0101|XXXX| keycode Mouse key * 0101|XXXX| keycode Mouse key
* *
* *
* Layer Actions * Layer Actions
* ------------- * -------------
* ACT_LAYER_SET(1000): Set layer * ACT_KEYMAP:
* 1000|LLLL|0000 0000 set current layer on press and return to default on release(momentary) * 1000|LLLL|0000 0000 Reset default layer
* 1000|LLLL|0000 0001 set current layer on press * 1000|LLLL|0000 00xx Reset default layer and clear overlay
* 1000|LLLL|0000 0010 set current layer on release * 1000|LLLL| keycode Invert with tap key
* 1000|LLLL|0000 0011 set current layer on both * 1000|LLLL|1111 0000 Invert with tap toggle
* 1000|LLLL| keycode set current layer on hold and send key on tap * 1000|LLLL|1111 00xx Invert[^= L]
* 1000|LLLL|1111 0000 set current layer on hold and toggle on several taps * 1000|LLLL|1111 0100 On/Off
* 1000|DDDD|1111 1111 set default layer on press * 1000|LLLL|1111 01xx On[|= L]
* L: 0 means default layer * 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 * ACT_OVERLAY:
* 1001|BBBB|0000 0000 bit-on current layer on press and bit-off on release(momentary) * 1011|0000|0000 0000 Clear overlay
* 1001|BBBB|0000 0001 bit-xor current layer on press * 1011|LLLL|0000 00ss Invert 4-bit chunk [^= L<<(4*ss)]
* 1001|BBBB|0000 0010 bit-xor current layer on release * 1011|LLLL| keycode Invert with tap key
* 1001|BBBB|0000 0011 bit-xor current layer on both * 1011|LLLL|1111 0000 Invert with tap toggle
* 1001|BBBB| keycode bit-xor current layer on hold and send key on tap * 1011|LLLL|1111 00xx Invert[^= 1<<L]
* 1001|BBBB|1111 0000 bit-xor current layer on hold and toggle on several taps * 1011|LLLL|1111 0100 On/Off(momentary)
* 1001|BBBB|1111 1111 bit-xor default layer on both * 1011|LLLL|1111 01xx On[|= 1<<L]
* * 1011|LLLL|1111 1000 Off/On
* ACT_LAYER_SWITCH: Switch * 1011|LLLL|1111 10xx Off[&= ~1<<L]
* 1011|LLLL|0000 0000 On on press and Off on release(momentary) * 1011|LLLL|1111 1100 Set[= 1<<L]/Clear
* 1011|LLLL|0000 0001 Invert on press * 1011|LLLL|1111 11xx Set[= 1<<L]
* 1011|LLLL|0000 0010 Invert on release * overlays: 16-layer on/off status(16bit)
* 1011|LLLL|0000 0011 Invert on both * xx: On {00:for special use, 01:press, 10:release, 11: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)
* *
* *
* Extensions(11XX) * Extensions(11XX)
@ -211,9 +212,8 @@ enum action_kind_id {
ACT_USAGE = 0b0100, ACT_USAGE = 0b0100,
ACT_MOUSEKEY = 0b0101, ACT_MOUSEKEY = 0b0101,
ACT_LAYER_SET = 0b1000, ACT_KEYMAP = 0b1000,
ACT_LAYER_BIT = 0b1001, ACT_OVERLAY = 0b1001,
ACT_LAYER_SWITCH = 0b1011,
ACT_MACRO = 0b1100, ACT_MACRO = 0b1100,
ACT_COMMAND = 0b1110, 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) #define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
/* /* Layer Operation:
* Layer switching * Invert layer ^= (1<<layer)
* On layer |= (1<<layer)
* Off layer &= ~(1<<layer)
* Set layer = (1<<layer)
* Clear layer = 0
*/ */
enum layer_codes { enum layer_params {
LAYER_MOMENTARY = 0, ON_PRESS = 1,
LAYER_ON_PRESS = 1, ON_RELEASE = 2,
LAYER_ON_RELEASE = 2, ON_BOTH = 3,
LAYER_ON_BOTH =3,
LAYER_TAP_TOGGLE = 0xF0, OP_RESET = 0x00,
LAYER_SET_DEFAULT_ON_PRESS = 0xFD, OP_INV4 = 0x00,
LAYER_SET_DEFAULT_ON_RELEASE = 0xFE, OP_INV = 0xF0,
LAYER_SET_DEFAULT_ON_BOTH = 0xFF OP_ON = 0xF4,
OP_OFF = 0xF8,
OP_SET = 0xFC,
}; };
/* /*
* Default layer * Default Layer
*/ */
/* set default layer */ #define ACTION_KEYMAP(layer) ACTION_KEYMAP_MOMENTARY(layer)
#define ACTION_LAYER_SET_DEFAULT(layer) ACTION_LAYER_SET_DEFAULT_R(layer) #define ACTION_KEYMAP_MOMENTARY(layer) ACTION_KEYMAP_INV_B(layer)
#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS) #define ACTION_KEYMAP_TOGGLE(layer) ACTION_KEYMAP_INV_R(layer)
#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) /* Set default layer */
#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH) #define ACTION_SET_DEFAULT_LAYER(layer) ACTION_KEYMAP_RESET(layer)
/* bit-xor default layer */ #define ACTION_SET_DEFAULT_LAYER_P(layer) ACTION_KEYMAP_RESET_P(layer)
#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION_LAYER_BIT_DEFAULT_R(bits) #define ACTION_SET_DEFAULT_LAYER_R(layer) ACTION_KEYMAP_RESET_R(layer)
#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS) #define ACTION_SET_DEFAULT_LAYER_B(layer) ACTION_KEYMAP_RESET_B(layer)
#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) /* Keymap Set and clear overaly */
#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH) #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))
/* /*
* Current layer: Return to default layer * Overlay Layer
*/ */
#define ACTION_LAYER_DEFAULT ACTION_LAYER_DEFAULT_R #define ACTION_OVERLAY(layer) ACTION_OVERLAY_MOMENTARY(layer)
#define ACTION_LAYER_DEFAULT_P ACTION_LAYER_SET_P(0) #define ACTION_OVERLAY_MOMENTARY(layer) ACTION_OVERLAY_ON_OFF(layer)
#define ACTION_LAYER_DEFAULT_R ACTION_LAYER_SET_R(0) #define ACTION_OVERLAY_TOGGLE(layer) ACTION_OVERLAY_INV_R(layer)
#define ACTION_LAYER_DEFAULT_B ACTION_LAYER_SET_B(0) /* Overlay Clear */
/* #define ACTION_OVERLAY_CLEAR ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | 0)
* Current layer: Set #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_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) #define ACTION_OVERLAY_CLEAR_B ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_BOTH)
#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_MOMENTARY) /* Overlay Invert 4-bit chunk */
#define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer) #define ACTION_OVERLAY_INV4(bits, shift) ACTION(ACT_OVERLAY, (bits)<<8 | OP_INV4 | shift)
#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_PRESS) /* Overlay Invert */
#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_RELEASE) #define ACTION_OVERLAY_INV(layer) ACTION_OVERLAY_INV_B(layer)
#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_BOTH) #define ACTION_OVERLAY_TAP_TOGGLE(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0)
#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_TAP_TOGGLE) #define ACTION_OVERLAY_INV_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_PRESS)
#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER_SET, (layer)<<8 | (key)) #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)
* Current layer: Bit-op /* Overlay On */
*/ #define ACTION_OVERLAY_ON(layer) ACTION_OVERLAY_ON_OFF(layer)
#define ACTION_LAYER_BIT(bits) ACTION_LAYER_BIT_MOMENTARY(bits) #define ACTION_OVERLAY_ON_OFF(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | 0)
#define ACTION_LAYER_BIT_MOMENTARY(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_MOMENTARY) #define ACTION_OVERLAY_ON_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | ON_PRESS)
#define ACTION_LAYER_BIT_TOGGLE(bits) ACTION_LAYER_BIT_R(bits) #define ACTION_OVERLAY_ON_R(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | ON_RELEASE)
#define ACTION_LAYER_BIT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS) #define ACTION_OVERLAY_ON_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | ON_BOTH)
#define ACTION_LAYER_BIT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE) /* Overlay Off */
#define ACTION_LAYER_BIT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_BOTH) #define ACTION_OVERLAY_OFF(layer) ACTION_OVERLAY_OFF_ON(layer)
#define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE) #define ACTION_OVERLAY_OFF_ON(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0)
#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) #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)
* Layer SWITCH #define ACTION_OVERLAY_OFF_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_BOTH)
*/ /* Overlay Set */
/* momentary */ #define ACTION_OVERLAY_SET(layer) ACTION_OVERLAY_SET_CLEAR(layer)
#define ACTION_LAYER_SWITCH(layer) ACTION_LAYER_SWITCH_MOMENTARY(layer) #define ACTION_OVERLAY_SET_CLEAR(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0)
#define ACTION_LAYER_SWITCH_MOMENTARY(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_MOMENTARY) #define ACTION_OVERLAY_SET_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_PRESS)
#define ACTION_LAYER_SWITCH_TOGGLE(layer) ACTION_LAYER_SWITCH_R(layer) #define ACTION_OVERLAY_SET_R(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_RELEASE)
#define ACTION_LAYER_SWITCH_P(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_PRESS) #define ACTION_OVERLAY_SET_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_BOTH)
#define ACTION_LAYER_SWITCH_R(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_RELEASE) /* Overlay Invert with tap key */
#define ACTION_LAYER_SWITCH_B(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_BOTH) #define ACTION_OVERLAY_TAP_KEY(layer, key) ACTION(ACT_OVERLAY, (layer)<<8 | (key))
#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))
/* /*

7
common/command.c
View file

@ -543,9 +543,8 @@ static uint8_t numkey2num(uint8_t code)
static void switch_default_layer(uint8_t layer) 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); print("\n");
print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); default_layer_set(layer);
default_layer = layer; overlay_clear();
layer_switch_clear();
clear_keyboard(); clear_keyboard();
} }

91
common/keymap.c
View file

@ -14,13 +14,71 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <avr/pgmspace.h>
#include "keymap.h" #include "keymap.h"
#include "report.h" #include "report.h"
#include "keycode.h" #include "keycode.h"
#include "layer_switch.h"
#include "action.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; action_t action;
switch (keycode) { switch (keycode) {
@ -51,34 +109,3 @@ action_t keymap_keycode_to_action(uint8_t keycode)
} }
return action; 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)
{
}

17
common/keymap.h
View file

@ -23,16 +23,19 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "action.h" #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); 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 */ /* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode); action_t keymap_fn_to_action(uint8_t keycode);
#else
#warning "You are using LEGACY KEYAMP. Consider using NEW KEYMAP."
/*
#ifndef NO_LEGACY_KEYMAP_SUPPORT * legacy keymap support
*/
/* keycode of key */ /* keycode of key */
uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col); uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col);
/* layer to move during press Fn key */ /* layer to move during press Fn key */

185
common/layer_switch.c
View file

@ -6,84 +6,168 @@
#include "layer_switch.h" #include "layer_switch.h"
/*
* Default Layer (0-15)
*/
uint8_t default_layer = 0; uint8_t default_layer = 0;
uint16_t layer_switch_stat = 0; void default_layer_set(uint8_t layer)
uint16_t layer_switch_get_stat(void)
{ {
return layer_switch_stat; debug("default_layer_set: ");
} debug_dec(default_layer); debug(" to ");
/* return highest layer whose state is on */ default_layer = layer;
uint8_t layer_switch_get_layer(void)
{
return biton16(layer_switch_stat);
}
static inline void stat_set(uint16_t stat) debug_dec(default_layer); debug("\n");
{
debug("layer_switch: ");
layer_switch_debug(); debug(" to ");
layer_switch_stat = stat;
layer_switch_debug(); debug("\n");
clear_keyboard_but_mods(); // To avoid stuck keys clear_keyboard_but_mods(); // To avoid stuck keys
} }
void layer_switch_clear(void)
/*
* Keymap Layer (0-15)
*/
uint16_t keymap_stat = 0;
/* return highest layer whose state is on */
uint8_t keymap_get_layer(void)
{ {
stat_set(0); 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 layer_switch_set(uint16_t stat) void keymap_set(uint16_t stat)
{ {
stat_set(stat); keymap_stat_set(stat);
} }
void layer_switch_move(uint8_t layer) void keymap_move(uint8_t layer)
{ {
if (layer) keymap_stat_set(1<<layer);
stat_set(1<<layer);
else
stat_set(0); // fall back to default layer
} }
void layer_switch_on(uint8_t layer) void keymap_on(uint8_t layer)
{ {
stat_set(layer_switch_stat | (1<<layer)); keymap_stat_set(keymap_stat | (1<<layer));
} }
void layer_switch_off(uint8_t layer) void keymap_off(uint8_t layer)
{ {
stat_set(layer_switch_stat & ~(1<<layer)); keymap_stat_set(keymap_stat & ~(1<<layer));
} }
void layer_switch_invert(uint8_t layer) void keymap_invert(uint8_t layer)
{ {
stat_set(layer_switch_stat ^ (1<<layer)); keymap_stat_set(keymap_stat ^ (1<<layer));
} }
void layer_switch_or(uint16_t stat) void keymap_or(uint16_t stat)
{ {
stat_set(layer_switch_stat | stat); keymap_stat_set(keymap_stat | stat);
} }
void layer_switch_and(uint16_t stat) void keymap_and(uint16_t stat)
{ {
stat_set(layer_switch_stat & stat); keymap_stat_set(keymap_stat & stat);
} }
void layer_switch_xor(uint16_t stat) void keymap_xor(uint16_t stat)
{ {
stat_set(layer_switch_stat ^ stat); keymap_stat_set(keymap_stat ^ stat);
} }
void layer_switch_debug(void) void keymap_debug(void)
{ {
debug_hex16(layer_switch_stat); debug("("); debug_dec(layer_switch_get_layer()); debug(")"); 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 layer_switch_get_action(key_t key)
@ -91,14 +175,27 @@ action_t layer_switch_get_action(key_t key)
action_t action; action_t action;
action.code = ACTION_TRANSPARENT; action.code = ACTION_TRANSPARENT;
/* higher layer first */ /* overlay: top layer first */
for (int8_t i = 15; i >= 0; i--) { 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); action = action_for_key(i, key);
if (action.code != ACTION_TRANSPARENT) { if (action.code != ACTION_TRANSPARENT) {
return action; return action;
} }
} }
} }
/* default layer */
action = action_for_key(default_layer, key);
return action; return action;
} }

65
common/layer_switch.h
View file

@ -22,36 +22,57 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "action.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 */ /* base layer to fall back */
extern uint8_t default_layer; extern uint8_t default_layer;
void default_layer_set(uint8_t layer);
/* layer status */
extern uint16_t layer_switch_stat;
/* return layer status */ /*
uint16_t layer_switch_get_stat(void); * Keymap Layer
*/
extern uint16_t keymap_stat;
/* return current active layer */ /* return current active layer */
uint8_t layer_switch_get_layer(void); 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);
/* 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); * Overlay Layer
void layer_switch_and(uint16_t stat); */
void layer_switch_xor(uint16_t stat); 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);
void layer_switch_debug(void);
/* return action depending on current layer status */ /* return action depending on current layer status */
action_t layer_switch_get_action(key_t key); action_t layer_switch_get_action(key_t key);