mirror of
https://github.com/Keychron/qmk_firmware.git
synced 2024-11-23 08:56:47 +06:00
Add overlay framework
This commit is contained in:
tmk
parent
abf0b04d14
commit
e0f960a576
398
common/action.c
398
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 */
|
||||
/* Keymap Reset */
|
||||
case OP_RESET:
|
||||
default_layer_set(action.layer.val);
|
||||
break;
|
||||
/* Keymap Reset default layer */
|
||||
case (OP_RESET | ON_PRESS):
|
||||
if (event.pressed) {
|
||||
layer_switch_move(action.layer.val);
|
||||
}
|
||||
else {
|
||||
// NOTE: This is needed by legacy keymap support
|
||||
layer_switch_move(0);
|
||||
default_layer_set(action.layer.val);
|
||||
overlay_clear();
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_PRESS:
|
||||
if (event.pressed) {
|
||||
layer_switch_move(action.layer.val);
|
||||
}
|
||||
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;
|
||||
|
||||
/* 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:
|
||||
/* 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);
|
||||
debug("KEYMAP_TAP_KEY: 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);
|
||||
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_SET: Tap: unregister_code\n");
|
||||
debug("KEYMAP_TAP_KEY: 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);
|
||||
debug("KEYMAP_TAP_KEY: No tap: invert on release\n");
|
||||
keymap_invert(action.layer.val);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case ACT_LAYER_BIT:
|
||||
|
||||
case ACT_OVERLAY:
|
||||
switch (action.layer.code) {
|
||||
case LAYER_MOMENTARY: /* momentary */
|
||||
if (event.pressed) {
|
||||
layer_switch_move(layer_switch_get_layer() | action.layer.val);
|
||||
// Overlay Invert bit4
|
||||
case OP_INV4 | 0:
|
||||
if (action.layer.val == 0) {
|
||||
overlay_clear();
|
||||
} else {
|
||||
layer_switch_move(layer_switch_get_layer() & ~action.layer.val);
|
||||
overlay_set(overlay_stat ^ action.layer.val);
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_PRESS:
|
||||
if (event.pressed) {
|
||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
|
||||
case OP_INV4 | 1:
|
||||
if (action.layer.val == 0) {
|
||||
if (event.pressed) overlay_clear();
|
||||
} else {
|
||||
overlay_set(overlay_stat ^ action.layer.val<<4);
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_RELEASE:
|
||||
if (!event.pressed) {
|
||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
|
||||
case OP_INV4 | 2:
|
||||
if (action.layer.val == 0) {
|
||||
if (!event.pressed) overlay_clear();
|
||||
} else {
|
||||
overlay_set(overlay_stat ^ action.layer.val<<8);
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_BOTH:
|
||||
layer_switch_move(layer_switch_get_layer() ^ 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_BIT: tap toggle(press).\n");
|
||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
|
||||
debug("OVERLAY_INV: tap toggle(press).\n");
|
||||
overlay_invert(action.layer.val);
|
||||
}
|
||||
} else {
|
||||
if (tap_count <= TAPPING_TOGGLE) {
|
||||
debug("LAYER_BIT: tap toggle(release).\n");
|
||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
|
||||
debug("OVERLAY_INV: tap toggle(release).\n");
|
||||
overlay_invert(action.layer.val);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case LAYER_SET_DEFAULT_ON_PRESS:
|
||||
case (OP_INV | ON_PRESS):
|
||||
if (event.pressed) {
|
||||
default_layer = default_layer ^ action.layer.val;
|
||||
layer_switch_move(default_layer);
|
||||
overlay_invert(action.layer.val);
|
||||
}
|
||||
break;
|
||||
case LAYER_SET_DEFAULT_ON_RELEASE:
|
||||
case (OP_INV | ON_RELEASE):
|
||||
if (!event.pressed) {
|
||||
default_layer = default_layer ^ action.layer.val;
|
||||
layer_switch_move(default_layer);
|
||||
overlay_invert(action.layer.val);
|
||||
}
|
||||
break;
|
||||
case LAYER_SET_DEFAULT_ON_BOTH:
|
||||
default_layer = default_layer ^ action.layer.val;
|
||||
layer_switch_move(default_layer);
|
||||
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_BIT: Tap: register_code\n");
|
||||
debug("OVERLAY_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("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_BIT: Tap: unregister_code\n");
|
||||
debug("OVERLAY_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);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case ACT_LAYER_SWITCH:
|
||||
switch (action.layer.code) {
|
||||
case LAYER_MOMENTARY: /* momentary */
|
||||
if (event.pressed) {
|
||||
layer_switch_on(action.layer.val);
|
||||
} else {
|
||||
layer_switch_off(action.layer.val);
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_PRESS:
|
||||
if (event.pressed) {
|
||||
layer_switch_invert(action.layer.val);
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_RELEASE:
|
||||
if (!event.pressed) {
|
||||
layer_switch_invert(action.layer.val);
|
||||
}
|
||||
break;
|
||||
case LAYER_ON_BOTH:
|
||||
layer_switch_invert(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_SWITCH: tap toggle(press).\n");
|
||||
layer_switch_invert(action.layer.val);
|
||||
}
|
||||
} else {
|
||||
if (tap_count <= TAPPING_TOGGLE) {
|
||||
debug("LAYER_SWITCH: tap toggle(release).\n");
|
||||
layer_switch_invert(action.layer.val);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
// tap key
|
||||
if (event.pressed) {
|
||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
|
||||
debug("LAYER_SWITCH: 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);
|
||||
}
|
||||
} else {
|
||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
|
||||
debug("LAYER_SWITCH: 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;
|
||||
|
|
|
|||
217
common/action.h
217
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
|
||||
* 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)
|
||||
#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))
|
||||
|
||||
/*
|
||||
* Current layer: Return to default layer
|
||||
* Overlay 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
|
||||
*/
|
||||
#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))
|
||||
/*
|
||||
* Layer SWITCH
|
||||
*/
|
||||
/* 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))
|
||||
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -6,84 +6,168 @@
|
|||
#include "layer_switch.h"
|
||||
|
||||
|
||||
/*
|
||||
* Default Layer (0-15)
|
||||
*/
|
||||
uint8_t default_layer = 0;
|
||||
|
||||
uint16_t layer_switch_stat = 0;
|
||||
|
||||
|
||||
uint16_t layer_switch_get_stat(void)
|
||||
void default_layer_set(uint8_t layer)
|
||||
{
|
||||
return layer_switch_stat;
|
||||
}
|
||||
debug("default_layer_set: ");
|
||||
debug_dec(default_layer); debug(" to ");
|
||||
|
||||
/* return highest layer whose state is on */
|
||||
uint8_t layer_switch_get_layer(void)
|
||||
{
|
||||
return biton16(layer_switch_stat);
|
||||
}
|
||||
default_layer = layer;
|
||||
|
||||
static inline void stat_set(uint16_t stat)
|
||||
{
|
||||
debug("layer_switch: ");
|
||||
layer_switch_debug(); debug(" to ");
|
||||
|
||||
layer_switch_stat = stat;
|
||||
|
||||
layer_switch_debug(); debug("\n");
|
||||
debug_dec(default_layer); debug("\n");
|
||||
|
||||
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)
|
||||
stat_set(1<<layer);
|
||||
else
|
||||
stat_set(0); // fall back to default layer
|
||||
keymap_stat_set(1<<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)
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
/* 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 */
|
||||
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);
|
||||
void layer_switch_and(uint16_t stat);
|
||||
void layer_switch_xor(uint16_t stat);
|
||||
/*
|
||||
* Overlay Layer
|
||||
*/
|
||||
extern uint16_t overlay_stat;
|
||||
/* return current active layer */
|
||||
uint8_t overlay_get_layer(void);
|
||||
void overlay_clear(void);
|
||||
void overlay_set(uint16_t stat);
|
||||
void overlay_move(uint8_t layer);
|
||||
void overlay_on(uint8_t layer);
|
||||
void overlay_off(uint8_t layer);
|
||||
void overlay_invert(uint8_t layer);
|
||||
/* bitwise operation */
|
||||
void overlay_or(uint16_t stat);
|
||||
void overlay_and(uint16_t stat);
|
||||
void overlay_xor(uint16_t stat);
|
||||
void overlay_debug(void);
|
||||
|
||||
|
||||
void layer_switch_debug(void);
|
||||
|
||||
/* return action depending on current layer status */
|
||||
action_t layer_switch_get_action(key_t key);
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user