- Remove ACT_OVERLAY - Rename ACT_KEYMAP to ACT_LAYER - Add ACT_LAYER_BITOPtags/v1.9
action_t action = layer_switch_get_action(event.key); | action_t action = layer_switch_get_action(event.key); | ||||
debug("ACTION: "); debug_action(action); | debug("ACTION: "); debug_action(action); | ||||
debug(" overlays: "); overlay_debug(); | |||||
debug(" keymaps: "); keymap_debug(); | debug(" keymaps: "); keymap_debug(); | ||||
debug(" default_layer: "); debug_dec(default_layer); debug("\n"); | debug(" default_layer: "); debug_dec(default_layer); debug("\n"); | ||||
} | } | ||||
break; | break; | ||||
#endif | #endif | ||||
#ifndef NO_ACTION_KEYMAP | |||||
case ACT_KEYMAP: | |||||
#ifndef NO_ACTION_LAYER | |||||
case ACT_LAYER: | |||||
case ACT_LAYER1: | |||||
switch (action.layer.code) { | switch (action.layer.code) { | ||||
/* Keymap clear */ | /* Keymap clear */ | ||||
case OP_RESET: | case OP_RESET: | ||||
switch (action.layer.val & 0x03) { | switch (action.layer.val & 0x03) { | ||||
case 0: | case 0: | ||||
// NOTE: reserved | // NOTE: reserved | ||||
overlay_clear(); | |||||
keymap_clear(); | keymap_clear(); | ||||
break; | break; | ||||
case ON_PRESS: | case ON_PRESS: | ||||
if (event.pressed) { | if (event.pressed) { | ||||
overlay_clear(); | |||||
keymap_clear(); | keymap_clear(); | ||||
} | } | ||||
break; | break; | ||||
case ON_RELEASE: | case ON_RELEASE: | ||||
if (!event.pressed) { | if (!event.pressed) { | ||||
overlay_clear(); | |||||
keymap_clear(); | keymap_clear(); | ||||
} | } | ||||
break; | break; | ||||
case ON_BOTH: | case ON_BOTH: | ||||
overlay_clear(); | |||||
keymap_clear(); | keymap_clear(); | ||||
break; | break; | ||||
/* NOTE: 4-7 rserved */ | /* NOTE: 4-7 rserved */ | ||||
break; | break; | ||||
} | } | ||||
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 | #endif | ||||
/* Extentions */ | /* Extentions */ | ||||
#ifndef NO_ACTION_MACRO | #ifndef NO_ACTION_MACRO | ||||
case ACT_LMODS_TAP: | case ACT_LMODS_TAP: | ||||
case ACT_RMODS_TAP: | case ACT_RMODS_TAP: | ||||
return true; | return true; | ||||
case ACT_KEYMAP: | |||||
case ACT_OVERLAY: | |||||
case ACT_LAYER: | |||||
switch (action.layer.code) { | switch (action.layer.code) { | ||||
case 0x04 ... 0xEF: /* tap key */ | case 0x04 ... 0xEF: /* tap key */ | ||||
case OP_INV: | case OP_INV: | ||||
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_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_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; |
} key; | } key; | ||||
struct action_layer { | struct action_layer { | ||||
uint8_t code :8; | uint8_t code :8; | ||||
uint8_t val :4; | |||||
uint8_t kind :4; | |||||
uint8_t val :5; | |||||
uint8_t kind :3; | |||||
} layer; | } layer; | ||||
struct action_usage { | struct action_usage { | ||||
uint16_t code :10; | uint16_t code :10; | ||||
* | * | ||||
* Layer Actions(10XX) | * 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} | * 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) | * Extensions(11XX) | ||||
* | * | ||||
*/ | */ | ||||
enum action_kind_id { | enum action_kind_id { | ||||
ACT_MODS = 0b0000, | |||||
ACT_LMODS = 0b0000, | ACT_LMODS = 0b0000, | ||||
ACT_RMODS = 0b0001, | ACT_RMODS = 0b0001, | ||||
ACT_MODS_TAP = 0b0010, | |||||
ACT_LMODS_TAP = 0b0010, | ACT_LMODS_TAP = 0b0010, | ||||
ACT_RMODS_TAP = 0b0011, | ACT_RMODS_TAP = 0b0011, | ||||
ACT_USAGE = 0b0100, | ACT_USAGE = 0b0100, | ||||
ACT_MOUSEKEY = 0b0101, | 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_MACRO = 0b1100, | ||||
ACT_COMMAND = 0b1110, | ACT_COMMAND = 0b1110, | ||||
* Set layer = (1<<layer) | * Set layer = (1<<layer) | ||||
* Clear layer = 0 | * Clear layer = 0 | ||||
*/ | */ | ||||
enum layer_params { | |||||
enum layer_param_on { | |||||
ON_PRESS = 1, | ON_PRESS = 1, | ||||
ON_RELEASE = 2, | ON_RELEASE = 2, | ||||
ON_BOTH = 3, | ON_BOTH = 3, | ||||
}; | |||||
OP_RESET = 0x00, | |||||
enum layer_pram_op { | |||||
OP_RESET = 0x00, | |||||
OP_INV4 = 0x00, | OP_INV4 = 0x00, | ||||
OP_INV = 0xF0, | OP_INV = 0xF0, | ||||
OP_ON = 0xF4, | OP_ON = 0xF4, | ||||
OP_SET = 0xFC, | OP_SET = 0xFC, | ||||
}; | }; | ||||
enum layer_pram_bitop { | |||||
BITOP_AND, | |||||
BITOP_OR, | |||||
BITOP_XOR, | |||||
BITOP_LSHIFT, | |||||
BITOP_RSHIFT, | |||||
}; | |||||
/* | /* | ||||
* Default Layer | * 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_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 | * 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 */ | /* 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 */ | /* 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 */ | /* 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 */ | /* 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 */ | /* 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 | * Extensions |
{ | { | ||||
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); print("\n"); | ||||
default_layer_set(layer); | default_layer_set(layer); | ||||
overlay_clear(); | |||||
clear_keyboard(); | clear_keyboard(); | ||||
} | } |
} | } | ||||
#ifndef NO_ACTION_KEYMAP | |||||
#ifndef NO_ACTION_LAYER | |||||
/* | /* | ||||
* Keymap Layer (0-15) | * Keymap Layer (0-15) | ||||
*/ | */ | ||||
#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 layer_switch_get_action(key_t key) | ||||
{ | { | ||||
action_t action; | action_t action; | ||||
action.code = ACTION_TRANSPARENT; | 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 */ | /* keymap: top layer first */ | ||||
for (int8_t i = 15; i >= 0; i--) { | for (int8_t i = 15; i >= 0; i--) { | ||||
if (keymap_stat & (1<<i)) { | if (keymap_stat & (1<<i)) { |
#include "action.h" | #include "action.h" | ||||
/* overlays are asigned at layer 16-31 */ | |||||
#define OVERLAY_BIT 0x10 | |||||
#define OVERLAY_MASK 0x0F | |||||
/* | /* | ||||
* Default Layer | * Default Layer | ||||
*/ | */ | ||||
/* | /* | ||||
* Keymap Layer | * Keymap Layer | ||||
*/ | */ | ||||
#ifndef NO_ACTION_KEYMAP | |||||
#ifndef NO_ACTION_LAYER | |||||
extern uint16_t keymap_stat; | extern uint16_t keymap_stat; | ||||
/* return current active layer */ | /* return current active layer */ | ||||
uint8_t keymap_get_layer(void); | uint8_t keymap_get_layer(void); | ||||
#endif | #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 */ | /* 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); | ||||
//#define NO_PRINT | //#define NO_PRINT | ||||
/* disable action features */ | /* disable action features */ | ||||
//#define NO_ACTION_KEYMAP | |||||
//#define NO_ACTION_OVERLAY | |||||
//#define NO_ACTION_LAYER | |||||
//#define NO_ACTION_TAPPING | //#define NO_ACTION_TAPPING | ||||
//#define NO_ACTION_ONESHOT | //#define NO_ACTION_ONESHOT | ||||
//#define NO_ACTION_MACRO | //#define NO_ACTION_MACRO |
ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | ||||
TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \ | TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \ | ||||
LCTL,A, S, D, F, G, H, J, K, L, FN2, QUOT, ENT, \ | LCTL,A, S, D, F, G, H, J, K, L, FN2, QUOT, ENT, \ | ||||
LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, RSFT, \ | |||||
LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, FN9, \ | |||||
LCTL,LGUI,LALT, SPC, RALT,FN3, FN3, FN0), | LCTL,LGUI,LALT, SPC, RALT,FN3, FN3, FN0), | ||||
/* Keymap 1: colemak */ | /* Keymap 1: colemak */ | ||||
KEYMAP_ANSI( | KEYMAP_ANSI( | ||||
TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), | TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), | ||||
}; | }; | ||||
static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = {}; | |||||
/* | /* | ||||
* Fn action definition | * Fn action definition | ||||
*/ | */ | ||||
static const uint16_t PROGMEM fn_actions[] = { | static const uint16_t PROGMEM fn_actions[] = { | ||||
[0] = ACTION_KEYMAP_MOMENTARY(4), | |||||
[1] = ACTION_KEYMAP_TAP_KEY(5, KC_SLASH), | |||||
[2] = ACTION_KEYMAP_TAP_KEY(6, KC_SCLN), | |||||
[3] = ACTION_KEYMAP_MOMENTARY(6), | |||||
[4] = ACTION_KEYMAP_MOMENTARY(7), // to Layout selector | |||||
[0] = ACTION_LAYER_MOMENTARY(4), | |||||
[1] = ACTION_LAYER_TAP_KEY(5, KC_SLASH), | |||||
[2] = ACTION_LAYER_TAP_KEY(6, KC_SCLN), | |||||
[3] = ACTION_LAYER_MOMENTARY(6), | |||||
[4] = ACTION_LAYER_MOMENTARY(7), // to Layout selector | |||||
[5] = ACTION_DEFAULT_LAYER_SET(0), // set qwerty layout | [5] = ACTION_DEFAULT_LAYER_SET(0), // set qwerty layout | ||||
[6] = ACTION_DEFAULT_LAYER_SET(1), // set colemak layout | [6] = ACTION_DEFAULT_LAYER_SET(1), // set colemak layout | ||||
[7] = ACTION_DEFAULT_LAYER_SET(2), // set dvorak layout | [7] = ACTION_DEFAULT_LAYER_SET(2), // set dvorak layout | ||||
[8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout | [8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout | ||||
[9] = ACTION_RMOD_TAP_KEY(KC_RSFT, KC_GRV), | |||||
}; | }; | ||||
#endif | #endif | ||||
#define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0])) | #define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0])) | ||||
#define OVERLAYS_SIZE (sizeof(overlays) / sizeof(overlays[0])) | |||||
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0])) | #define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0])) | ||||
/* translates key to keycode */ | /* translates key to keycode */ | ||||
uint8_t keymap_key_to_keycode(uint8_t layer, key_t key) | uint8_t keymap_key_to_keycode(uint8_t layer, key_t key) | ||||
{ | { | ||||
/* Overlay: 16-31(OVERLAY_BIT(0x10) | overlay_layer) */ | |||||
if (layer & OVERLAY_BIT) { | |||||
layer &= OVERLAY_MASK; | |||||
if (layer < OVERLAYS_SIZE) { | |||||
return pgm_read_byte(&overlays[(layer)][(key.row)][(key.col)]); | |||||
} else { | |||||
// XXX: this may cuaes bootlaoder_jump incositent fail. | |||||
//debug("key_to_keycode: overlay "); debug_dec(layer); debug(" is invalid.\n"); | |||||
return KC_TRANSPARENT; | |||||
} | |||||
} | |||||
/* Keymap: 0-15 */ | |||||
else { | |||||
if (layer < KEYMAPS_SIZE) { | |||||
return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]); | |||||
} else { | |||||
// XXX: this may cuaes bootlaoder_jump incositent fail. | |||||
//debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n"); | |||||
// fall back to layer 0 | |||||
return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]); | |||||
} | |||||
if (layer < KEYMAPS_SIZE) { | |||||
return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]); | |||||
} else { | |||||
// XXX: this may cuaes bootlaoder_jump inconsistent fail. | |||||
//debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n"); | |||||
// fall back to layer 0 | |||||
return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]); | |||||
} | } | ||||
} | } | ||||
//#define NO_PRINT | //#define NO_PRINT | ||||
/* disable action features */ | /* disable action features */ | ||||
//#define NO_ACTION_KEYMAP | |||||
//#define NO_ACTION_OVERLAY | |||||
//#define NO_ACTION_LAYER | |||||
//#define NO_ACTION_TAPPING | //#define NO_ACTION_TAPPING | ||||
//#define NO_ACTION_ONESHOT | //#define NO_ACTION_ONESHOT | ||||
//#define NO_ACTION_MACRO | //#define NO_ACTION_MACRO |