- Remove ACT_OVERLAY - Rename ACT_KEYMAP to ACT_LAYER - Add ACT_LAYER_BITOPcore
@@ -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 */ | |||
@@ -361,161 +357,6 @@ void process_action(keyrecord_t *record) | |||
break; | |||
} | |||
break; | |||
#endif | |||
#ifndef NO_ACTION_OVERLAY | |||
case ACT_OVERLAY: | |||
switch (action.layer.code) { | |||
// Overlay Invert bit4 | |||
case OP_INV4 | 0: | |||
if (action.layer.val == 0) { | |||
// NOTE: reserved for future use | |||
overlay_clear(); | |||
} else { | |||
overlay_set(overlay_stat ^ action.layer.val); | |||
} | |||
break; | |||
case OP_INV4 | 1: | |||
if (action.layer.val == 0) { | |||
// on pressed | |||
if (event.pressed) overlay_clear(); | |||
} else { | |||
overlay_set(overlay_stat ^ action.layer.val<<4); | |||
} | |||
break; | |||
case OP_INV4 | 2: | |||
if (action.layer.val == 0) { | |||
// on released | |||
if (!event.pressed) overlay_clear(); | |||
} else { | |||
overlay_set(overlay_stat ^ action.layer.val<<8); | |||
} | |||
break; | |||
case OP_INV4 | 3: | |||
if (action.layer.val == 0) { | |||
// on both | |||
overlay_clear(); | |||
} else { | |||
overlay_set(overlay_stat ^ action.layer.val<<12); | |||
} | |||
break; | |||
/* Overlay Bit invert */ | |||
case OP_INV: | |||
/* with tap toggle */ | |||
if (event.pressed) { | |||
if (tap_count < TAPPING_TOGGLE) { | |||
debug("OVERLAY_INV: tap toggle(press).\n"); | |||
overlay_invert(action.layer.val); | |||
} | |||
} else { | |||
if (tap_count <= TAPPING_TOGGLE) { | |||
debug("OVERLAY_INV: tap toggle(release).\n"); | |||
overlay_invert(action.layer.val); | |||
} | |||
} | |||
break; | |||
case (OP_INV | ON_PRESS): | |||
if (event.pressed) { | |||
overlay_invert(action.layer.val); | |||
} | |||
break; | |||
case (OP_INV | ON_RELEASE): | |||
if (!event.pressed) { | |||
overlay_invert(action.layer.val); | |||
} | |||
break; | |||
case (OP_INV | ON_BOTH): | |||
overlay_invert(action.layer.val); | |||
break; | |||
/* Overlay Bit on */ | |||
case OP_ON: | |||
if (event.pressed) { | |||
overlay_on(action.layer.val); | |||
} else { | |||
overlay_off(action.layer.val); | |||
} | |||
break; | |||
case (OP_ON | ON_PRESS): | |||
if (event.pressed) { | |||
overlay_on(action.layer.val); | |||
} | |||
break; | |||
case (OP_ON | ON_RELEASE): | |||
if (!event.pressed) { | |||
overlay_on(action.layer.val); | |||
} | |||
break; | |||
case (OP_ON | ON_BOTH): | |||
overlay_on(action.layer.val); | |||
break; | |||
/* Overlay Bit off */ | |||
case OP_OFF: | |||
if (event.pressed) { | |||
overlay_off(action.layer.val); | |||
} else { | |||
overlay_on(action.layer.val); | |||
} | |||
break; | |||
case (OP_OFF | ON_PRESS): | |||
if (event.pressed) { | |||
overlay_off(action.layer.val); | |||
} | |||
break; | |||
case (OP_OFF | ON_RELEASE): | |||
if (!event.pressed) { | |||
overlay_off(action.layer.val); | |||
} | |||
break; | |||
case (OP_OFF | ON_BOTH): | |||
overlay_off(action.layer.val); | |||
break; | |||
/* Overlay Bit set */ | |||
case OP_SET: | |||
if (event.pressed) { | |||
overlay_move(action.layer.val); | |||
} else { | |||
overlay_clear(); | |||
} | |||
break; | |||
case (OP_SET | ON_PRESS): | |||
if (event.pressed) { | |||
overlay_move(action.layer.val); | |||
} | |||
break; | |||
case (OP_SET | ON_RELEASE): | |||
if (!event.pressed) { | |||
overlay_move(action.layer.val); | |||
} | |||
break; | |||
case (OP_SET | ON_BOTH): | |||
overlay_move(action.layer.val); | |||
break; | |||
/* Overlay Bit invert with tap key */ | |||
default: | |||
if (event.pressed) { | |||
if (tap_count > 0) { | |||
debug("OVERLAY_TAP_KEY: Tap: register_code\n"); | |||
register_code(action.layer.code); | |||
} else { | |||
debug("OVERLAY_TAP_KEY: No tap: On on press\n"); | |||
overlay_on(action.layer.val); | |||
} | |||
} else { | |||
if (tap_count > 0) { | |||
debug("OVERLAY_TAP_KEY: Tap: unregister_code\n"); | |||
unregister_code(action.layer.code); | |||
} else { | |||
debug("OVERLAY_TAP_KEY: No tap: Off on release\n"); | |||
overlay_off(action.layer.val); | |||
} | |||
} | |||
break; | |||
} | |||
break; | |||
#endif | |||
/* Extentions */ | |||
#ifndef NO_ACTION_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; |
@@ -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 |
@@ -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(); | |||
} |
@@ -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)) { |
@@ -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); | |||