} | } | ||||
} | } | ||||
static action_t get_action(key_t key) | |||||
{ | |||||
action_t action; | |||||
action.code = ACTION_NO; | |||||
/* layer_switch */ | |||||
action = layer_switch_get_action(key); | |||||
if (action.code != ACTION_TRANSPARENT) { | |||||
return action; | |||||
} | |||||
/* default layer */ | |||||
//debug("get_aciton: default layer: "); debug_dec(default_layer); debug("\n"); | |||||
action = action_for_key(default_layer, key); | |||||
return action; | |||||
} | |||||
static void process_action(keyrecord_t *record) | static void process_action(keyrecord_t *record) | ||||
{ | { | ||||
keyevent_t event = record->event; | keyevent_t event = record->event; | ||||
if (IS_NOEVENT(event)) { return; } | 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) { | switch (action.kind.id) { | ||||
/* Key and Mods */ | /* Key and Mods */ | ||||
#endif | #endif | ||||
break; | break; | ||||
/* Layer key */ | |||||
case ACT_LAYER_SET: | |||||
case ACT_KEYMAP: | |||||
switch (action.layer.code) { | 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; | break; | ||||
case LAYER_ON_PRESS: | |||||
/* Keymap Reset default layer */ | |||||
case (OP_RESET | ON_PRESS): | |||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_switch_move(action.layer.val); | |||||
default_layer_set(action.layer.val); | |||||
overlay_clear(); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_RELEASE: | |||||
case (OP_RESET | ON_RELEASE): | |||||
if (!event.pressed) { | if (!event.pressed) { | ||||
layer_switch_move(action.layer.val); | |||||
default_layer_set(action.layer.val); | |||||
overlay_clear(); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_BOTH: | |||||
layer_switch_move(action.layer.val); | |||||
case (OP_RESET | ON_BOTH): | |||||
default_layer_set(action.layer.val); | |||||
overlay_clear(); | |||||
break; | break; | ||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | |||||
/* Keymap Bit invert */ | |||||
case OP_INV: | |||||
/* with tap toggle */ | |||||
if (event.pressed) { | if (event.pressed) { | ||||
if (tap_count < TAPPING_TOGGLE) { | if (tap_count < TAPPING_TOGGLE) { | ||||
layer_switch_move(action.layer.val); | |||||
debug("KEYMAP_INV: tap toggle(press).\n"); | |||||
keymap_invert(action.layer.val); | |||||
} | } | ||||
} else { | } 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; | break; | ||||
case LAYER_SET_DEFAULT_ON_PRESS: | |||||
case (OP_INV | ON_PRESS): | |||||
if (event.pressed) { | if (event.pressed) { | ||||
default_layer = action.layer.val; | |||||
layer_switch_move(0); | |||||
keymap_invert(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_RELEASE: | |||||
case (OP_INV | ON_RELEASE): | |||||
if (!event.pressed) { | if (!event.pressed) { | ||||
default_layer = action.layer.val; | |||||
layer_switch_move(0); | |||||
keymap_invert(action.layer.val); | |||||
} | } | ||||
break; | 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; | break; | ||||
default: | |||||
/* tap key */ | |||||
/* Keymap Bit on */ | |||||
case OP_ON: | |||||
if (event.pressed) { | 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 { | } 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; | ||||
} | |||||
break; | |||||
case ACT_LAYER_BIT: | |||||
switch (action.layer.code) { | |||||
case LAYER_MOMENTARY: /* momentary */ | |||||
case (OP_ON | ON_PRESS): | |||||
if (event.pressed) { | 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 { | } else { | ||||
layer_switch_move(layer_switch_get_layer() & ~action.layer.val); | |||||
keymap_on(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_PRESS: | |||||
case (OP_OFF | ON_PRESS): | |||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
keymap_off(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_RELEASE: | |||||
case (OP_OFF | ON_RELEASE): | |||||
if (!event.pressed) { | if (!event.pressed) { | ||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
keymap_off(action.layer.val); | |||||
} | } | ||||
break; | 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; | break; | ||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | |||||
/* Keymap Bit set */ | |||||
case OP_SET: | |||||
if (event.pressed) { | 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 { | } 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; | break; | ||||
case LAYER_SET_DEFAULT_ON_PRESS: | |||||
case (OP_SET | ON_PRESS): | |||||
if (event.pressed) { | if (event.pressed) { | ||||
default_layer = default_layer ^ action.layer.val; | |||||
layer_switch_move(default_layer); | |||||
keymap_set(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_RELEASE: | |||||
case (OP_SET | ON_RELEASE): | |||||
if (!event.pressed) { | if (!event.pressed) { | ||||
default_layer = default_layer ^ action.layer.val; | |||||
layer_switch_move(default_layer); | |||||
keymap_set(action.layer.val); | |||||
} | } | ||||
break; | 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; | break; | ||||
/* Keymap Bit invert with tap key */ | |||||
default: | default: | ||||
// tap key | |||||
if (event.pressed) { | if (event.pressed) { | ||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | ||||
debug("LAYER_BIT: Tap: register_code\n"); | |||||
debug("KEYMAP_TAP_KEY: Tap: register_code\n"); | |||||
register_code(action.layer.code); | register_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_BIT: No tap: layer_bit(on press)\n"); | |||||
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 { | } else { | ||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | ||||
debug("LAYER_BIT: Tap: unregister_code\n"); | |||||
debug("KEYMAP_TAP_KEY: Tap: unregister_code\n"); | |||||
unregister_code(action.layer.code); | unregister_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_BIT: No tap: layer_bit(on release)\n"); | |||||
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; | ||||
} | } | ||||
break; | break; | ||||
case ACT_LAYER_SWITCH: | |||||
case ACT_OVERLAY: | |||||
switch (action.layer.code) { | 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 { | } else { | ||||
layer_switch_off(action.layer.val); | |||||
overlay_set(overlay_stat ^ action.layer.val); | |||||
} | } | ||||
break; | 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; | 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; | 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; | break; | ||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | |||||
/* Overlay Bit invert */ | |||||
case OP_INV: | |||||
/* with tap toggle */ | |||||
if (event.pressed) { | if (event.pressed) { | ||||
if (tap_count < TAPPING_TOGGLE) { | if (tap_count < TAPPING_TOGGLE) { | ||||
debug("LAYER_SWITCH: tap toggle(press).\n"); | |||||
layer_switch_invert(action.layer.val); | |||||
debug("OVERLAY_INV: tap toggle(press).\n"); | |||||
overlay_invert(action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (tap_count <= TAPPING_TOGGLE) { | 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; | break; | ||||
case (OP_INV | ON_PRESS): | |||||
if (event.pressed) { | |||||
overlay_invert(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_INV | ON_RELEASE): | |||||
if (!event.pressed) { | |||||
overlay_invert(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_INV | ON_BOTH): | |||||
overlay_invert(action.layer.val); | |||||
break; | |||||
/* Overlay Bit on */ | |||||
case OP_ON: | |||||
if (event.pressed) { | |||||
overlay_on(action.layer.val); | |||||
} else { | |||||
overlay_off(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_ON | ON_PRESS): | |||||
if (event.pressed) { | |||||
overlay_on(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_ON | ON_RELEASE): | |||||
if (!event.pressed) { | |||||
overlay_on(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_ON | ON_BOTH): | |||||
overlay_on(action.layer.val); | |||||
break; | |||||
/* Overlay Bit off */ | |||||
case OP_OFF: | |||||
if (event.pressed) { | |||||
overlay_off(action.layer.val); | |||||
} else { | |||||
overlay_on(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_OFF | ON_PRESS): | |||||
if (event.pressed) { | |||||
overlay_off(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_OFF | ON_RELEASE): | |||||
if (!event.pressed) { | |||||
overlay_off(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_OFF | ON_BOTH): | |||||
overlay_off(action.layer.val); | |||||
break; | |||||
/* Overlay Bit set */ | |||||
case OP_SET: | |||||
if (event.pressed) { | |||||
overlay_move(action.layer.val); | |||||
} else { | |||||
overlay_clear(); | |||||
} | |||||
break; | |||||
case (OP_SET | ON_PRESS): | |||||
if (event.pressed) { | |||||
overlay_move(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_SET | ON_RELEASE): | |||||
if (!event.pressed) { | |||||
overlay_move(action.layer.val); | |||||
} | |||||
break; | |||||
case (OP_SET | ON_BOTH): | |||||
overlay_move(action.layer.val); | |||||
break; | |||||
/* Overlay Bit invert with tap key */ | |||||
default: | default: | ||||
// tap key | |||||
if (event.pressed) { | if (event.pressed) { | ||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | ||||
debug("LAYER_SWITCH: Tap: register_code\n"); | |||||
debug("OVERLAY_TAP_KEY: Tap: register_code\n"); | |||||
register_code(action.layer.code); | register_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_SWITCH: No tap: layer_switch on press\n"); | |||||
layer_switch_invert(action.layer.val); | |||||
debug("OVERLAY_TAP_KEY: No tap: invert on press\n"); | |||||
overlay_invert(action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | ||||
debug("LAYER_SWITCH: Tap: unregister_code\n"); | |||||
debug("OVERLAY_TAP_KEY: Tap: unregister_code\n"); | |||||
unregister_code(action.layer.code); | unregister_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_SWITCH: No tap: layer_switch on release\n"); | |||||
layer_switch_invert(action.layer.val); | |||||
debug("OVERLAY_TAP_KEY: No tap: invert on release\n"); | |||||
overlay_invert(action.layer.val); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
bool is_tap_key(key_t key) | bool is_tap_key(key_t key) | ||||
{ | { | ||||
action_t action = get_action(key); | |||||
action_t action = layer_switch_get_action(key); | |||||
switch (action.kind.id) { | switch (action.kind.id) { | ||||
case ACT_LMODS_TAP: | case ACT_LMODS_TAP: | ||||
case ACT_RMODS_TAP: | case ACT_RMODS_TAP: | ||||
return true; | return true; | ||||
case ACT_LAYER_SET: | |||||
case ACT_LAYER_BIT: | |||||
case ACT_KEYMAP: | |||||
case ACT_OVERLAY: | |||||
switch (action.layer.code) { | 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; | return true; | ||||
default: | |||||
return false; | |||||
} | } | ||||
return false; | |||||
case ACT_FUNCTION: | case ACT_FUNCTION: | ||||
if (action.func.opt & FUNC_TAP) { return true; } | if (action.func.opt & FUNC_TAP) { return true; } | ||||
return false; | return false; | ||||
case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break; | case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break; | ||||
case ACT_USAGE: debug("ACT_USAGE"); break; | case ACT_USAGE: debug("ACT_USAGE"); break; | ||||
case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; | case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; | ||||
case ACT_LAYER_SET: debug("ACT_LAYER_SET"); break; | |||||
case ACT_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_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; |
* | * | ||||
* Mouse Keys | * Mouse Keys | ||||
* ---------- | * ---------- | ||||
* NOTE: can be combined with 'Other HID Usage'? to save action kind id. | |||||
* ACT_MOUSEKEY(0110): | * ACT_MOUSEKEY(0110): | ||||
* 0101|XXXX| keycode Mouse key | * 0101|XXXX| keycode Mouse key | ||||
* | * | ||||
* | * | ||||
* Layer Actions | * Layer Actions | ||||
* ------------- | * ------------- | ||||
* ACT_LAYER_SET(1000): Set layer | |||||
* 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) | * Extensions(11XX) | ||||
ACT_USAGE = 0b0100, | ACT_USAGE = 0b0100, | ||||
ACT_MOUSEKEY = 0b0101, | 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_MACRO = 0b1100, | ||||
ACT_COMMAND = 0b1110, | ACT_COMMAND = 0b1110, | ||||
#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) | #define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) | ||||
/* | |||||
* Layer 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)) | |||||
/* | /* |
static void switch_default_layer(uint8_t layer) | static void switch_default_layer(uint8_t layer) | ||||
{ | { | ||||
// TODO check existence of layer or whether it can be used as default layer | |||||
print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); | |||||
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(); | clear_keyboard(); | ||||
} | } |
You should have received a copy of the GNU General Public License | You should have received a copy of the GNU General Public License | ||||
along with this program. If not, see <http://www.gnu.org/licenses/>. | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||||
*/ | */ | ||||
#include <avr/pgmspace.h> | |||||
#include "keymap.h" | #include "keymap.h" | ||||
#include "report.h" | #include "report.h" | ||||
#include "keycode.h" | #include "keycode.h" | ||||
#include "layer_switch.h" | |||||
#include "action.h" | #include "action.h" | ||||
#include "debug.h" | |||||
action_t keymap_keycode_to_action(uint8_t keycode) | |||||
static action_t keycode_to_action(uint8_t keycode); | |||||
#ifdef USE_KEYMAP_V2 | |||||
/* converts key to action */ | |||||
action_t action_for_key(uint8_t layer, key_t key) | |||||
{ | |||||
uint8_t keycode = keymap_key_to_keycode(layer, key); | |||||
switch (keycode) { | |||||
case KC_FN0 ... KC_FN31: | |||||
return keymap_fn_to_action(keycode); | |||||
default: | |||||
return keycode_to_action(keycode); | |||||
} | |||||
} | |||||
__attribute__ ((weak)) | |||||
void action_function(keyrecord_t *event, uint8_t id, uint8_t opt) | |||||
{ | |||||
} | |||||
#else | |||||
/* | |||||
* legacy keymap support | |||||
*/ | |||||
/* translation for legacy keymap */ | |||||
action_t action_for_key(uint8_t layer, key_t key) | |||||
{ | |||||
/* convert from legacy keycode to action */ | |||||
/* layer 16-31 indicate 'overlay' but not supported in legacy keymap */ | |||||
uint8_t keycode = keymap_get_keycode((layer & OVERLAY_MASK), key.row, key.col); | |||||
action_t action; | |||||
switch (keycode) { | |||||
case KC_FN0 ... KC_FN31: | |||||
{ | |||||
uint8_t layer = keymap_fn_layer(FN_INDEX(keycode)); | |||||
uint8_t key = keymap_fn_keycode(FN_INDEX(keycode)); | |||||
if (key) { | |||||
action.code = ACTION_KEYMAP_TAP_KEY(layer, key); | |||||
} else { | |||||
action.code = ACTION_KEYMAP_MOMENTARY(layer); | |||||
} | |||||
} | |||||
return action; | |||||
default: | |||||
return keycode_to_action(keycode); | |||||
} | |||||
} | |||||
/* not used for legacy keymap */ | |||||
void action_function(keyrecord_t *event, uint8_t id, uint8_t opt) | |||||
{ | |||||
} | |||||
#endif | |||||
/* translates keycode to action */ | |||||
static action_t keycode_to_action(uint8_t keycode) | |||||
{ | { | ||||
action_t action; | action_t action; | ||||
switch (keycode) { | switch (keycode) { | ||||
} | } | ||||
return action; | return action; | ||||
} | } | ||||
#ifndef NO_LEGACY_KEYMAP_SUPPORT | |||||
/* legacy support with weak reference */ | |||||
__attribute__ ((weak)) | |||||
action_t action_for_key(uint8_t layer, key_t key) | |||||
{ | |||||
/* convert from legacy keycode to action */ | |||||
uint8_t keycode = keymap_get_keycode(layer, key.row, key.col); | |||||
action_t action; | |||||
switch (keycode) { | |||||
case KC_FN0 ... KC_FN31: | |||||
{ | |||||
uint8_t layer = keymap_fn_layer(FN_INDEX(keycode)); | |||||
uint8_t key = keymap_fn_keycode(FN_INDEX(keycode)); | |||||
if (key) { | |||||
action.code = ACTION_LAYER_SET_TAP_KEY(layer, key); | |||||
} else { | |||||
action.code = ACTION_LAYER_SET_MOMENTARY(layer); | |||||
} | |||||
} | |||||
return action; | |||||
default: | |||||
return keymap_keycode_to_action(keycode); | |||||
} | |||||
} | |||||
#endif | |||||
__attribute__ ((weak)) | |||||
void action_function(keyrecord_t *event, uint8_t id, uint8_t opt) | |||||
{ | |||||
} |
#include "action.h" | #include "action.h" | ||||
/* translates key_t to keycode */ | |||||
#ifdef USE_KEYMAP_V2 | |||||
/* translates key to keycode | |||||
* layer: 0-15 for base layers | |||||
* 16-31 for overlays | |||||
*/ | |||||
uint8_t keymap_key_to_keycode(uint8_t layer, key_t key); | uint8_t keymap_key_to_keycode(uint8_t layer, key_t key); | ||||
/* translates keycode to action */ | |||||
action_t keymap_keycode_to_action(uint8_t keycode); | |||||
/* translates Fn keycode to action */ | /* translates Fn keycode to action */ | ||||
action_t keymap_fn_to_action(uint8_t keycode); | action_t keymap_fn_to_action(uint8_t keycode); | ||||
#ifndef NO_LEGACY_KEYMAP_SUPPORT | |||||
#else | |||||
#warning "You are using LEGACY KEYAMP. Consider using NEW KEYMAP." | |||||
/* | |||||
* legacy keymap support | |||||
*/ | |||||
/* keycode of key */ | /* keycode of key */ | ||||
uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col); | uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col); | ||||
/* layer to move during press Fn key */ | /* layer to move during press Fn key */ |
#include "layer_switch.h" | #include "layer_switch.h" | ||||
/* | |||||
* Default Layer (0-15) | |||||
*/ | |||||
uint8_t default_layer = 0; | uint8_t default_layer = 0; | ||||
uint16_t layer_switch_stat = 0; | |||||
void default_layer_set(uint8_t layer) | |||||
{ | |||||
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 */ | /* 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 | 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) | action_t layer_switch_get_action(key_t key) | ||||
action_t action; | action_t action; | ||||
action.code = ACTION_TRANSPARENT; | action.code = ACTION_TRANSPARENT; | ||||
/* higher layer first */ | |||||
/* overlay: top layer first */ | |||||
for (int8_t i = 15; i >= 0; i--) { | for (int8_t i = 15; i >= 0; i--) { | ||||
if (layer_switch_stat & (1<<i)) { | |||||
if (overlay_stat & (1<<i)) { | |||||
action = action_for_key(i | OVERLAY_BIT, key); | |||||
if (action.code != ACTION_TRANSPARENT) { | |||||
return action; | |||||
} | |||||
} | |||||
} | |||||
/* keymap: top layer first */ | |||||
for (int8_t i = 15; i >= 0; i--) { | |||||
if (keymap_stat & (1<<i)) { | |||||
action = action_for_key(i, key); | action = action_for_key(i, key); | ||||
if (action.code != ACTION_TRANSPARENT) { | if (action.code != ACTION_TRANSPARENT) { | ||||
return action; | return action; | ||||
} | } | ||||
} | } | ||||
} | } | ||||
/* default layer */ | |||||
action = action_for_key(default_layer, key); | |||||
return action; | return action; | ||||
} | } |
#include "action.h" | #include "action.h" | ||||
/* overlays are asigned at layer 16-31 */ | |||||
#define OVERLAY_BIT 0x10 | |||||
#define OVERLAY_MASK 0x0F | |||||
/* | |||||
* Default Layer | |||||
*/ | |||||
/* base layer to fall back */ | /* base layer to fall back */ | ||||
extern uint8_t default_layer; | extern uint8_t default_layer; | ||||
void default_layer_set(uint8_t layer); | |||||
/* | |||||
* 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 */ | /* 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 */ | /* 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); |