diff options
| -rw-r--r-- | common/action.c | 356 | ||||
| -rw-r--r-- | common/action.h | 217 | ||||
| -rw-r--r-- | common/command.c | 7 | ||||
| -rw-r--r-- | common/keymap.c | 91 | ||||
| -rw-r--r-- | common/keymap.h | 17 | ||||
| -rw-r--r-- | common/layer_switch.c | 167 | ||||
| -rw-r--r-- | common/layer_switch.h | 71 |
7 files changed, 585 insertions, 341 deletions
diff --git a/common/action.c b/common/action.c index 246fd99d8a..3703b4e8cc 100644 --- a/common/action.c +++ b/common/action.c @@ -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) { keyevent_t event = record->event; @@ -226,9 +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(" "); - layer_switch_debug(); debug("["); debug_dec(default_layer); 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 */ @@ -368,207 +353,292 @@ static void process_action(keyrecord_t *record) #endif break; - /* Layer key */ - case ACT_LAYER_SET: + case ACT_KEYMAP: switch (action.layer.code) { - case LAYER_MOMENTARY: /* momentary */ - if (event.pressed) { - layer_switch_move(action.layer.val); - } - else { - // NOTE: This is needed by legacy keymap support - layer_switch_move(0); - } + /* Keymap Reset */ + case OP_RESET: + default_layer_set(action.layer.val); break; - case LAYER_ON_PRESS: + /* Keymap Reset default layer */ + case (OP_RESET | ON_PRESS): if (event.pressed) { - layer_switch_move(action.layer.val); + default_layer_set(action.layer.val); + overlay_clear(); } break; - case LAYER_ON_RELEASE: + case (OP_RESET | ON_RELEASE): if (!event.pressed) { - layer_switch_move(action.layer.val); + default_layer_set(action.layer.val); + overlay_clear(); } break; - case LAYER_ON_BOTH: - layer_switch_move(action.layer.val); + case (OP_RESET | ON_BOTH): + default_layer_set(action.layer.val); + overlay_clear(); 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 (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); + if (tap_count <= TAPPING_TOGGLE) { + debug("KEYMAP_INV: tap toggle(release).\n"); + keymap_invert(action.layer.val); } } break; - case LAYER_SET_DEFAULT_ON_PRESS: + case (OP_INV | ON_PRESS): if (event.pressed) { - default_layer = action.layer.val; - layer_switch_move(0); + keymap_invert(action.layer.val); } break; - case LAYER_SET_DEFAULT_ON_RELEASE: + case (OP_INV | ON_RELEASE): if (!event.pressed) { - default_layer = action.layer.val; - layer_switch_move(0); + keymap_invert(action.layer.val); } break; - case LAYER_SET_DEFAULT_ON_BOTH: - default_layer = action.layer.val; - layer_switch_move(0); + case (OP_INV | ON_BOTH): + keymap_invert(action.layer.val); break; - default: - /* tap key */ + + /* Keymap Bit on */ + case OP_ON: 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); - } + keymap_on(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); - } + keymap_off(action.layer.val); } break; - } - break; - case ACT_LAYER_BIT: - switch (action.layer.code) { - case LAYER_MOMENTARY: /* momentary */ + case (OP_ON | ON_PRESS): if (event.pressed) { - layer_switch_move(layer_switch_get_layer() | action.layer.val); + 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 { - layer_switch_move(layer_switch_get_layer() & ~action.layer.val); + keymap_on(action.layer.val); } break; - case LAYER_ON_PRESS: + case (OP_OFF | ON_PRESS): if (event.pressed) { - layer_switch_move(layer_switch_get_layer() ^ action.layer.val); + keymap_off(action.layer.val); } break; - case LAYER_ON_RELEASE: + case (OP_OFF | ON_RELEASE): if (!event.pressed) { - layer_switch_move(layer_switch_get_layer() ^ action.layer.val); + keymap_off(action.layer.val); } break; - case LAYER_ON_BOTH: - layer_switch_move(layer_switch_get_layer() ^ action.layer.val); + case (OP_OFF | ON_BOTH): + keymap_off(action.layer.val); break; - case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ + + /* Keymap Bit set */ + case OP_SET: 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); - } + keymap_set(action.layer.val); } else { - if (tap_count <= TAPPING_TOGGLE) { - debug("LAYER_BIT: tap toggle(release).\n"); - layer_switch_move(layer_switch_get_layer() ^ action.layer.val); - } + keymap_clear(); } break; - case LAYER_SET_DEFAULT_ON_PRESS: + case (OP_SET | ON_PRESS): if (event.pressed) { - default_layer = default_layer ^ action.layer.val; - layer_switch_move(default_layer); + keymap_set(action.layer.val); } break; - case LAYER_SET_DEFAULT_ON_RELEASE: + case (OP_SET | ON_RELEASE): if (!event.pressed) { - default_layer = default_layer ^ action.layer.val; - layer_switch_move(default_layer); + keymap_set(action.layer.val); } break; - case LAYER_SET_DEFAULT_ON_BOTH: - default_layer = default_layer ^ action.layer.val; - layer_switch_move(default_layer); + case (OP_SET | ON_BOTH): + keymap_set(action.layer.val); break; + + /* Keymap Bit invert with tap key */ default: - // tap key if (event.pressed) { 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); } else { - debug("LAYER_BIT: No tap: layer_bit(on press)\n"); - layer_switch_move(layer_switch_get_layer() ^ action.layer.val); + debug("KEYMAP_TAP_KEY: No tap: invert on press\n"); + keymap_invert(action.layer.val); } } else { 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); } else { - debug("LAYER_BIT: No tap: layer_bit(on release)\n"); - layer_switch_move(layer_switch_get_layer() ^ action.layer.val); + debug("KEYMAP_TAP_KEY: No tap: invert on release\n"); + keymap_invert(action.layer.val); } } break; } break; - case ACT_LAYER_SWITCH: + + case ACT_OVERLAY: switch (action.layer.code) { - case LAYER_MOMENTARY: /* momentary */ - if (event.pressed) { - layer_switch_on(action.layer.val); + // Overlay Invert bit4 + case OP_INV4 | 0: + if (action.layer.val == 0) { + overlay_clear(); } else { - layer_switch_off(action.layer.val); + overlay_set(overlay_stat ^ action.layer.val); } break; - case LAYER_ON_PRESS: - if (event.pressed) { - layer_switch_invert(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_invert(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 LAYER_ON_BOTH: - layer_switch_invert(action.layer.val); + 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_SWITCH: tap toggle(press).\n"); - layer_switch_invert(action.layer.val); + debug("OVERLAY_INV: tap toggle(press).\n"); + overlay_invert(action.layer.val); } } else { if (tap_count <= TAPPING_TOGGLE) { - debug("LAYER_SWITCH: tap toggle(release).\n"); - layer_switch_invert(action.layer.val); + 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: - // tap key if (event.pressed) { 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); } else { - debug("LAYER_SWITCH: No tap: layer_switch on press\n"); - layer_switch_invert(action.layer.val); + debug("OVERLAY_TAP_KEY: No tap: invert on press\n"); + overlay_invert(action.layer.val); } } else { 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); } else { - debug("LAYER_SWITCH: No tap: layer_switch on release\n"); - layer_switch_invert(action.layer.val); + debug("OVERLAY_TAP_KEY: No tap: invert on release\n"); + overlay_invert(action.layer.val); } } break; @@ -877,28 +947,21 @@ bool sending_anykey(void) 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_SET: - 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_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 */ + 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; @@ -929,9 +992,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_SET: debug("ACT_LAYER_SET"); break; - case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break; - case ACT_LAYER_SWITCH: debug("ACT_LAYER_SWITCH"); 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 46ae809cb7..c02a2e71fc 100644 --- a/common/action.h +++ b/common/action.h @@ -150,40 +150,41 @@ bool waiting_buffer_has_anykey_pressed(void); * * Mouse Keys * ---------- - * NOTE: can be combined with 'Other HID Usage'? to save action kind id. * ACT_MOUSEKEY(0110): * 0101|XXXX| keycode Mouse key * * * Layer Actions * ------------- - * ACT_LAYER_SET(1000): Set layer - * 1000|LLLL|0000 0000 set current layer on press and return to default on release(momentary) - * 1000|LLLL|0000 0001 set current layer on press - * 1000|LLLL|0000 0010 set current layer on release - * 1000|LLLL|0000 0011 set current layer on both - * 1000|LLLL| keycode set current layer on hold and send key on tap - * 1000|LLLL|1111 0000 set current layer on hold and toggle on several taps - * 1000|DDDD|1111 1111 set default layer on press - * L: 0 means default layer + * ACT_KEYMAP: + * 1000|LLLL|0000 0000 Reset default layer + * 1000|LLLL|0000 00xx Reset default layer and clear overlay + * 1000|LLLL| keycode Invert with tap key + * 1000|LLLL|1111 0000 Invert with tap toggle + * 1000|LLLL|1111 00xx Invert[^= L] + * 1000|LLLL|1111 0100 On/Off + * 1000|LLLL|1111 01xx On[|= L] + * 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 - * 1001|BBBB|0000 0000 bit-on current layer on press and bit-off on release(momentary) - * 1001|BBBB|0000 0001 bit-xor current layer on press - * 1001|BBBB|0000 0010 bit-xor current layer on release - * 1001|BBBB|0000 0011 bit-xor current layer on both - * 1001|BBBB| keycode bit-xor current layer on hold and send key on tap - * 1001|BBBB|1111 0000 bit-xor current layer on hold and toggle on several taps - * 1001|BBBB|1111 1111 bit-xor default layer on both - * - * ACT_LAYER_SWITCH: Switch - * 1011|LLLL|0000 0000 On on press and Off on release(momentary) - * 1011|LLLL|0000 0001 Invert on press - * 1011|LLLL|0000 0010 Invert on release - * 1011|LLLL|0000 0011 Invert on 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) + * 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[= 1<<L]/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) @@ -211,9 +212,8 @@ enum action_kind_id { ACT_USAGE = 0b0100, ACT_MOUSEKEY = 0b0101, - ACT_LAYER_SET = 0b1000, - ACT_LAYER_BIT = 0b1001, - ACT_LAYER_SWITCH = 0b1011, + ACT_KEYMAP = 0b1000, + ACT_OVERLAY = 0b1001, ACT_MACRO = 0b1100, 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) -/* - * Layer switching +/* 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_ON_BOTH =3, - LAYER_TAP_TOGGLE = 0xF0, - LAYER_SET_DEFAULT_ON_PRESS = 0xFD, - LAYER_SET_DEFAULT_ON_RELEASE = 0xFE, - LAYER_SET_DEFAULT_ON_BOTH = 0xFF +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 - */ -/* set default layer */ -#define ACTION_LAYER_SET_DEFAULT(layer) ACTION_LAYER_SET_DEFAULT_R(layer) -#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS) -#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) -#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH) -/* bit-xor default layer */ -#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION_LAYER_BIT_DEFAULT_R(bits) -#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS) -#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) -#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH) -/* - * Current layer: Return to default layer - */ -#define ACTION_LAYER_DEFAULT ACTION_LAYER_DEFAULT_R -#define ACTION_LAYER_DEFAULT_P ACTION_LAYER_SET_P(0) -#define ACTION_LAYER_DEFAULT_R ACTION_LAYER_SET_R(0) -#define ACTION_LAYER_DEFAULT_B ACTION_LAYER_SET_B(0) -/* - * Current layer: Set - */ -#define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) -#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_MOMENTARY) -#define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer) -#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_PRESS) -#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_RELEASE) -#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_BOTH) -#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_TAP_TOGGLE) -#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER_SET, (layer)<<8 | (key)) -/* - * Current layer: Bit-op + * Default Layer */ -#define ACTION_LAYER_BIT(bits) ACTION_LAYER_BIT_MOMENTARY(bits) -#define ACTION_LAYER_BIT_MOMENTARY(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_MOMENTARY) -#define ACTION_LAYER_BIT_TOGGLE(bits) ACTION_LAYER_BIT_R(bits) -#define ACTION_LAYER_BIT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS) -#define ACTION_LAYER_BIT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE) -#define ACTION_LAYER_BIT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_BOTH) -#define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE) -#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) +#define ACTION_KEYMAP(layer) ACTION_KEYMAP_MOMENTARY(layer) +#define ACTION_KEYMAP_MOMENTARY(layer) ACTION_KEYMAP_INV_B(layer) +#define ACTION_KEYMAP_TOGGLE(layer) ACTION_KEYMAP_INV_R(layer) +/* Set default layer */ +#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) +/* Keymap Set and clear overaly */ +#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)) + /* - * Layer SWITCH + * Overlay Layer */ -/* momentary */ -#define ACTION_LAYER_SWITCH(layer) ACTION_LAYER_SWITCH_MOMENTARY(layer) -#define ACTION_LAYER_SWITCH_MOMENTARY(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_MOMENTARY) -#define ACTION_LAYER_SWITCH_TOGGLE(layer) ACTION_LAYER_SWITCH_R(layer) -#define ACTION_LAYER_SWITCH_P(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_PRESS) -#define ACTION_LAYER_SWITCH_R(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_RELEASE) -#define ACTION_LAYER_SWITCH_B(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_BOTH) -#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)) +#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)) /* diff --git a/common/command.c b/common/command.c index 2d01c95e6a..202d531fd8 100644 --- a/common/command.c +++ b/common/command.c @@ -543,9 +543,8 @@ static uint8_t numkey2num(uint8_t code) 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); - default_layer = layer; - layer_switch_clear(); + 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..3f13d4497a 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 *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; 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 index 22bfb34f65..19e286f885 100644 --- a/common/layer_switch.c +++ b/common/layer_switch.c @@ -6,84 +6,168 @@ #include "layer_switch.h" +/* + * Default Layer (0-15) + */ uint8_t default_layer = 0; -uint16_t layer_switch_stat = 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); +} -uint16_t layer_switch_get_stat(void) +void keymap_on(uint8_t layer) { - return layer_switch_stat; + 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 layer_switch_get_layer(void) +uint8_t overlay_get_layer(void) { - return biton16(layer_switch_stat); + return biton16(overlay_stat); } -static inline void stat_set(uint16_t stat) +static void overlay_stat_set(uint16_t stat) { - debug("layer_switch: "); - layer_switch_debug(); debug(" to "); + debug("overlay: "); + overlay_debug(); debug(" to "); - layer_switch_stat = stat; + overlay_stat = stat; - layer_switch_debug(); debug("\n"); + overlay_debug(); debug("\n"); clear_keyboard_but_mods(); // To avoid stuck keys } -void layer_switch_clear(void) +void overlay_clear(void) { - stat_set(0); + overlay_stat_set(0); } -void layer_switch_set(uint16_t stat) +void overlay_set(uint16_t stat) { - stat_set(stat); + overlay_stat_set(stat); } -void layer_switch_move(uint8_t layer) +void overlay_move(uint8_t layer) { - if (layer) - stat_set(1<<layer); - else - stat_set(0); // fall back to default layer + overlay_stat_set(1<<layer); } -void layer_switch_on(uint8_t layer) +void overlay_on(uint8_t layer) { - stat_set(layer_switch_stat | (1<<layer)); + overlay_stat_set(overlay_stat | (1<<layer)); } -void layer_switch_off(uint8_t layer) +void overlay_off(uint8_t layer) { - stat_set(layer_switch_stat & ~(1<<layer)); + overlay_stat_set(overlay_stat & ~(1<<layer)); } -void layer_switch_invert(uint8_t layer) +void overlay_invert(uint8_t layer) { - stat_set(layer_switch_stat ^ (1<<layer)); + overlay_stat_set(overlay_stat ^ (1<<layer)); } -void layer_switch_or(uint16_t stat) +void overlay_or(uint16_t stat) { - stat_set(layer_switch_stat | stat); + overlay_stat_set(overlay_stat | stat); } -void layer_switch_and(uint16_t stat) +void overlay_and(uint16_t stat) { - stat_set(layer_switch_stat & stat); + overlay_stat_set(overlay_stat & stat); } -void layer_switch_xor(uint16_t stat) +void overlay_xor(uint16_t stat) { - stat_set(layer_switch_stat ^ stat); + overlay_stat_set(overlay_stat ^ stat); } -void layer_switch_debug(void) +void overlay_debug(void) { - debug_hex16(layer_switch_stat); debug("("); debug_dec(layer_switch_get_layer()); debug(")"); + debug_hex16(overlay_stat); debug("("); debug_dec(overlay_get_layer()); debug(")"); } 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.code = ACTION_TRANSPARENT; - /* higher layer first */ + /* overlay: top layer first */ 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); 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 index 25c81a5dc2..a566ab12b7 100644 --- a/common/layer_switch.h +++ b/common/layer_switch.h @@ -22,36 +22,57 @@ 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 + */ /* 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); -/* layer status */ -extern uint16_t layer_switch_stat; -/* return layer status */ -uint16_t layer_switch_get_stat(void); +/* + * Overlay Layer + */ +extern uint16_t overlay_stat; /* return current active layer */ -uint8_t layer_switch_get_layer(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); -void layer_switch_and(uint16_t stat); -void layer_switch_xor(uint16_t stat); - -void layer_switch_debug(void); +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); |