$(COMMON_DIR)/keyboard.c \ | $(COMMON_DIR)/keyboard.c \ | ||||
$(COMMON_DIR)/action.c \ | $(COMMON_DIR)/action.c \ | ||||
$(COMMON_DIR)/action_macro.c \ | $(COMMON_DIR)/action_macro.c \ | ||||
$(COMMON_DIR)/layer_stack.c \ | |||||
$(COMMON_DIR)/layer_switch.c \ | |||||
$(COMMON_DIR)/keymap.c \ | $(COMMON_DIR)/keymap.c \ | ||||
$(COMMON_DIR)/command.c \ | $(COMMON_DIR)/command.c \ | ||||
$(COMMON_DIR)/timer.c \ | $(COMMON_DIR)/timer.c \ |
#include "util.h" | #include "util.h" | ||||
#include "debug.h" | #include "debug.h" | ||||
#include "action.h" | #include "action.h" | ||||
#include "layer_stack.h" | |||||
/* default layer indicates base layer */ | |||||
uint8_t default_layer = 0; | |||||
/* current layer indicates active layer at this time */ | |||||
uint8_t current_layer = 0; | |||||
#include "layer_switch.h" | |||||
static void process_action(keyrecord_t *record); | static void process_action(keyrecord_t *record); | ||||
action_t action; | action_t action; | ||||
action.code = ACTION_NO; | action.code = ACTION_NO; | ||||
/* layer stack */ | |||||
action = layer_stack_get_action(key); | |||||
/* layer_switch */ | |||||
action = layer_switch_get_action(key); | |||||
if (action.code != ACTION_TRANSPARENT) { | if (action.code != ACTION_TRANSPARENT) { | ||||
return action; | return action; | ||||
} | } | ||||
/* current layer: 0 means default layer */ | |||||
if (current_layer) { | |||||
action = action_for_key(current_layer, key); | |||||
if (action.code != ACTION_TRANSPARENT) { | |||||
debug("current layer: used. "); debug_dec(current_layer); debug("\n"); | |||||
return action; | |||||
} | |||||
} | |||||
/* default layer */ | /* default layer */ | ||||
debug("default layer: used. \n"); | |||||
//debug("get_aciton: default layer: "); debug_dec(default_layer); debug("\n"); | |||||
action = action_for_key(default_layer, key); | action = action_for_key(default_layer, key); | ||||
return action; | return action; | ||||
} | } | ||||
if (IS_NOEVENT(event)) { return; } | if (IS_NOEVENT(event)) { return; } | ||||
action_t action = get_action(event.key); | action_t action = get_action(event.key); | ||||
debug("ACTION: "); debug_action(action); debug("\n"); | |||||
debug("ACTION: "); debug_action(action); debug(" "); | |||||
layer_switch_debug(); debug("["); debug_dec(default_layer); debug("]\n"); | |||||
switch (action.kind.id) { | switch (action.kind.id) { | ||||
/* Key and Mods */ | /* Key and Mods */ | ||||
break; | break; | ||||
/* Layer key */ | /* Layer key */ | ||||
case ACT_LAYER: | |||||
case ACT_LAYER_SET: | |||||
switch (action.layer.code) { | switch (action.layer.code) { | ||||
case LAYER_MOMENTARY: /* momentary */ | case LAYER_MOMENTARY: /* momentary */ | ||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
} | } | ||||
else { | else { | ||||
// NOTE: This is needed by legacy keymap support | // NOTE: This is needed by legacy keymap support | ||||
layer_switch(0); | |||||
layer_switch_move(0); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_PRESS: | case LAYER_ON_PRESS: | ||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_RELEASE: | case LAYER_ON_RELEASE: | ||||
if (!event.pressed) { | if (!event.pressed) { | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_BOTH: | case LAYER_ON_BOTH: | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
break; | break; | ||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | ||||
if (event.pressed) { | if (event.pressed) { | ||||
if (tap_count < TAPPING_TOGGLE) { | if (tap_count < TAPPING_TOGGLE) { | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (tap_count >= TAPPING_TOGGLE) { | if (tap_count >= TAPPING_TOGGLE) { | ||||
debug("LAYER_PRESSED: tap toggle.\n"); | debug("LAYER_PRESSED: tap toggle.\n"); | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_PRESS: | case LAYER_SET_DEFAULT_ON_PRESS: | ||||
if (event.pressed) { | if (event.pressed) { | ||||
default_layer = action.layer.val; | default_layer = action.layer.val; | ||||
layer_switch(0); | |||||
layer_switch_move(0); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_RELEASE: | case LAYER_SET_DEFAULT_ON_RELEASE: | ||||
if (!event.pressed) { | if (!event.pressed) { | ||||
default_layer = action.layer.val; | default_layer = action.layer.val; | ||||
layer_switch(0); | |||||
layer_switch_move(0); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_BOTH: | case LAYER_SET_DEFAULT_ON_BOTH: | ||||
default_layer = action.layer.val; | default_layer = action.layer.val; | ||||
layer_switch(0); | |||||
layer_switch_move(0); | |||||
break; | break; | ||||
default: | default: | ||||
/* tap key */ | /* tap key */ | ||||
register_code(action.layer.code); | register_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_SET: No tap: layer_set(on press)\n"); | debug("LAYER_SET: No tap: layer_set(on press)\n"); | ||||
layer_switch(action.layer.val); | |||||
layer_switch_move(action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | ||||
} else { | } else { | ||||
// NOTE: This is needed by legacy keymap support | // NOTE: This is needed by legacy keymap support | ||||
debug("LAYER_SET: No tap: return to default layer(on release)\n"); | debug("LAYER_SET: No tap: return to default layer(on release)\n"); | ||||
layer_switch(0); | |||||
layer_switch_move(0); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
switch (action.layer.code) { | switch (action.layer.code) { | ||||
case LAYER_MOMENTARY: /* momentary */ | case LAYER_MOMENTARY: /* momentary */ | ||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_switch(current_layer | action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() | action.layer.val); | |||||
} else { | } else { | ||||
layer_switch(current_layer & ~action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() & ~action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_PRESS: | case LAYER_ON_PRESS: | ||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_RELEASE: | case LAYER_ON_RELEASE: | ||||
if (!event.pressed) { | if (!event.pressed) { | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_BOTH: | case LAYER_ON_BOTH: | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
break; | break; | ||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | ||||
if (event.pressed) { | if (event.pressed) { | ||||
if (tap_count < TAPPING_TOGGLE) { | if (tap_count < TAPPING_TOGGLE) { | ||||
debug("LAYER_BIT: tap toggle(press).\n"); | debug("LAYER_BIT: tap toggle(press).\n"); | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (tap_count <= TAPPING_TOGGLE) { | if (tap_count <= TAPPING_TOGGLE) { | ||||
debug("LAYER_BIT: tap toggle(release).\n"); | debug("LAYER_BIT: tap toggle(release).\n"); | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_PRESS: | case LAYER_SET_DEFAULT_ON_PRESS: | ||||
if (event.pressed) { | if (event.pressed) { | ||||
default_layer = default_layer ^ action.layer.val; | default_layer = default_layer ^ action.layer.val; | ||||
layer_switch(0); | |||||
layer_switch_move(default_layer); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_RELEASE: | case LAYER_SET_DEFAULT_ON_RELEASE: | ||||
if (!event.pressed) { | if (!event.pressed) { | ||||
default_layer = default_layer ^ action.layer.val; | default_layer = default_layer ^ action.layer.val; | ||||
layer_switch(0); | |||||
layer_switch_move(default_layer); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_BOTH: | case LAYER_SET_DEFAULT_ON_BOTH: | ||||
default_layer = default_layer ^ action.layer.val; | default_layer = default_layer ^ action.layer.val; | ||||
layer_switch(0); | |||||
layer_switch_move(default_layer); | |||||
break; | break; | ||||
default: | default: | ||||
// tap key | // tap key | ||||
register_code(action.layer.code); | register_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_BIT: No tap: layer_bit(on press)\n"); | debug("LAYER_BIT: No tap: layer_bit(on press)\n"); | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | ||||
unregister_code(action.layer.code); | unregister_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_BIT: No tap: layer_bit(on release)\n"); | debug("LAYER_BIT: No tap: layer_bit(on release)\n"); | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch_move(layer_switch_get_layer() ^ action.layer.val); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
} | } | ||||
break; | break; | ||||
case ACT_LAYER_STACK: | |||||
case ACT_LAYER_SWITCH: | |||||
switch (action.layer.code) { | switch (action.layer.code) { | ||||
case LAYER_MOMENTARY: /* momentary */ | case LAYER_MOMENTARY: /* momentary */ | ||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_stack_remove_then_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
layer_switch_on(action.layer.val); | |||||
} else { | } else { | ||||
layer_stack_remove(action.layer.val); | |||||
layer_stack_debug(); | |||||
layer_switch_off(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_PRESS: | case LAYER_ON_PRESS: | ||||
if (event.pressed) { | if (event.pressed) { | ||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
layer_switch_invert(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_RELEASE: | case LAYER_ON_RELEASE: | ||||
if (!event.pressed) { | if (!event.pressed) { | ||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
layer_switch_invert(action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_BOTH: | case LAYER_ON_BOTH: | ||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
layer_switch_invert(action.layer.val); | |||||
break; | break; | ||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | ||||
if (event.pressed) { | if (event.pressed) { | ||||
if (tap_count < TAPPING_TOGGLE) { | if (tap_count < TAPPING_TOGGLE) { | ||||
debug("LAYER_STACK: tap toggle(press).\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
debug("LAYER_SWITCH: tap toggle(press).\n"); | |||||
layer_switch_invert(action.layer.val); | |||||
} | } | ||||
} else { | } else { | ||||
if (tap_count <= TAPPING_TOGGLE) { | if (tap_count <= TAPPING_TOGGLE) { | ||||
debug("LAYER_STACK: tap toggle(release).\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
debug("LAYER_SWITCH: tap toggle(release).\n"); | |||||
layer_switch_invert(action.layer.val); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
// tap key | // 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_STACK: Tap: register_code\n"); | |||||
debug("LAYER_SWITCH: Tap: register_code\n"); | |||||
register_code(action.layer.code); | register_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_STACK: No tap: layer_stack(on press)\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
debug("LAYER_SWITCH: No tap: layer_switch on press\n"); | |||||
layer_switch_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_STACK: Tap: unregister_code\n"); | |||||
debug("LAYER_SWITCH: Tap: unregister_code\n"); | |||||
unregister_code(action.layer.code); | unregister_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_STACK: No tap: layer_stack(on release)\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
debug("LAYER_SWITCH: No tap: layer_switch on release\n"); | |||||
layer_switch_invert(action.layer.val); | |||||
} | } | ||||
} | } | ||||
break; | break; | ||||
host_last_sysytem_report() || host_last_consumer_report()); | host_last_sysytem_report() || host_last_consumer_report()); | ||||
} | } | ||||
void layer_switch(uint8_t new_layer) | |||||
{ | |||||
if (current_layer != new_layer) { | |||||
debug("Layer Switch: "); debug_hex(current_layer); | |||||
debug(" -> "); debug_hex(new_layer); debug("\n"); | |||||
current_layer = new_layer; | |||||
clear_keyboard_but_mods(); // To avoid stuck keys | |||||
// NOTE: update mods with full scan of matrix? if modifier changes between layers | |||||
} | |||||
} | |||||
bool is_tap_key(key_t key) | bool is_tap_key(key_t key) | ||||
{ | { | ||||
action_t action = get_action(key); | action_t action = get_action(key); | ||||
case ACT_LMODS_TAP: | case ACT_LMODS_TAP: | ||||
case ACT_RMODS_TAP: | case ACT_RMODS_TAP: | ||||
return true; | return true; | ||||
case ACT_LAYER: | |||||
case ACT_LAYER_SET: | |||||
case ACT_LAYER_BIT: | case ACT_LAYER_BIT: | ||||
switch (action.layer.code) { | switch (action.layer.code) { | ||||
case LAYER_MOMENTARY: | case LAYER_MOMENTARY: | ||||
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: debug("ACT_LAYER"); break; | |||||
case ACT_LAYER_SET: debug("ACT_LAYER_SET"); break; | |||||
case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break; | case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break; | ||||
case ACT_LAYER_STACK: debug("ACT_LAYER_STACK"); break; | |||||
case ACT_LAYER_SWITCH: debug("ACT_LAYER_SWITCH"); 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; |
/* layer used currently */ | |||||
extern uint8_t current_layer; | |||||
/* layer to return or start with */ | |||||
extern uint8_t default_layer; | |||||
/* Execute action per keyevent */ | /* Execute action per keyevent */ | ||||
void action_exec(keyevent_t event); | void action_exec(keyevent_t event); | ||||
* | * | ||||
* Mouse Keys | * Mouse Keys | ||||
* ---------- | * ---------- | ||||
* TODO: can be combined with 'Other HID Usage'? to save action kind id. | |||||
* 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(1000): Set layer | |||||
* ACT_LAYER_BIT(1001): Bit-op layer | |||||
* ACT_LAYER_STACK: Layer stack | |||||
* | |||||
* 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 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 0001 set current layer on press | ||||
* 1000|LLLL|0000 0010 set current layer on release | * 1000|LLLL|0000 0010 set current layer on release | ||||
* 1000|DDDD|1111 1111 set default layer on press | * 1000|DDDD|1111 1111 set default layer on press | ||||
* L: 0 means default layer | * L: 0 means default layer | ||||
* | * | ||||
* 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 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 0001 bit-xor current layer on press | ||||
* 1001|BBBB|0000 0010 bit-xor current layer on release | * 1001|BBBB|0000 0010 bit-xor current layer on release | ||||
* 1001|BBBB|1111 0000 bit-xor current layer on hold and toggle on several taps | * 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 | * 1001|BBBB|1111 1111 bit-xor default layer on both | ||||
* | * | ||||
* 1011|LLLL|0000 0000 push on press and remove on release(momentary) | |||||
* 1011|LLLL|0000 0001 push or remove on press | |||||
* 1011|LLLL|0000 0010 push or remove on release | |||||
* 1011|LLLL|0000 0011 push or remove on both | |||||
* 1011|LLLL| keycode push or remove on hold and send key on tap | |||||
* 1011|LLLL|1111 0000 push or remove on hold and toggle on several taps | |||||
* 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) | * 1011|LLLL|1111 1111 (not used) | ||||
* | * | ||||
* | * | ||||
ACT_USAGE = 0b0100, | ACT_USAGE = 0b0100, | ||||
ACT_MOUSEKEY = 0b0101, | ACT_MOUSEKEY = 0b0101, | ||||
ACT_LAYER = 0b1000, | |||||
ACT_LAYER_SET = 0b1000, | |||||
ACT_LAYER_BIT = 0b1001, | ACT_LAYER_BIT = 0b1001, | ||||
ACT_LAYER_STACK = 0b1011, | |||||
ACT_LAYER_SWITCH = 0b1011, | |||||
ACT_MACRO = 0b1100, | ACT_MACRO = 0b1100, | ||||
ACT_COMMAND = 0b1110, | ACT_COMMAND = 0b1110, | ||||
#define ACTION(kind, param) ((kind)<<12 | (param)) | #define ACTION(kind, param) ((kind)<<12 | (param)) | ||||
#define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F) | #define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F) | ||||
/* | |||||
/* | |||||
* Key | * Key | ||||
*/ | */ | ||||
#define ACTION_KEY(key) ACTION(ACT_LMODS, key) | #define ACTION_KEY(key) ACTION(ACT_LMODS, key) | ||||
*/ | */ | ||||
/* set default layer */ | /* set default layer */ | ||||
#define ACTION_LAYER_SET_DEFAULT(layer) ACTION_LAYER_SET_DEFAULT_R(layer) | #define ACTION_LAYER_SET_DEFAULT(layer) ACTION_LAYER_SET_DEFAULT_R(layer) | ||||
#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS) | |||||
#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) | |||||
#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH) | |||||
#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 */ | /* bit-xor default layer */ | ||||
#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION_LAYER_BIT_DEFAULT_R(bits) | #define ACTION_LAYER_BIT_DEFAULT(bits) ACTION_LAYER_BIT_DEFAULT_R(bits) | ||||
#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS) | |||||
#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE) | |||||
#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH) | |||||
#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 | * Current layer: Return to default layer | ||||
*/ | */ | ||||
* Current layer: Set | * Current layer: Set | ||||
*/ | */ | ||||
#define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) | #define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) | ||||
#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY) | |||||
#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_TOGGLE(layer) ACTION_LAYER_SET_R(layer) | ||||
#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS) | |||||
#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE) | |||||
#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_BOTH) | |||||
#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_TAP_TOGGLE) | |||||
#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key)) | |||||
#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 | * Current layer: Bit-op | ||||
*/ | */ | ||||
#define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE) | #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_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) | ||||
/* | /* | ||||
* Layer Stack | |||||
* Layer SWITCH | |||||
*/ | */ | ||||
/* momentary */ | /* momentary */ | ||||
#define ACTION_LAYER_STACK(layer) ACTION_LAYER_STACK_MOMENTARY(layer) | |||||
#define ACTION_LAYER_STACK_MOMENTARY(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_MOMENTARY) | |||||
#define ACTION_LAYER_STACK_TOGGLE(layer) ACTION_LAYER_STACK_R(layer) | |||||
#define ACTION_LAYER_STACK_P(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_PRESS) | |||||
#define ACTION_LAYER_STACK_R(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_RELEASE) | |||||
#define ACTION_LAYER_STACK_B(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_BOTH) | |||||
#define ACTION_LAYER_STACK_TAP_TOGGLE(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_TAP_TOGGLE) | |||||
#define ACTION_LAYER_STACK_TAP_KEY(layer, key) ACTION(ACT_LAYER_STACK, (layer)<<8 | (key)) | |||||
#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)) | |||||
/* | /* |
#include "timer.h" | #include "timer.h" | ||||
#include "keyboard.h" | #include "keyboard.h" | ||||
#include "bootloader.h" | #include "bootloader.h" | ||||
#include "layer_switch.h" | |||||
#include "command.h" | #include "command.h" | ||||
#include "layer_stack.h" | |||||
#ifdef MOUSEKEY_ENABLE | #ifdef MOUSEKEY_ENABLE | ||||
#include "mousekey.h" | #include "mousekey.h" | ||||
static void switch_default_layer(uint8_t layer) | static void switch_default_layer(uint8_t layer) | ||||
{ | { | ||||
print_val_hex8(current_layer); | |||||
print_val_hex8(default_layer); | |||||
print("switch to "); print_val_hex8(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; | default_layer = layer; | ||||
current_layer = 0; /* 0 means default_layer */ | |||||
layer_stack_clear(); | |||||
layer_switch_clear(); | |||||
clear_keyboard(); | clear_keyboard(); | ||||
} | } |
#include <stdint.h> | |||||
#include "keyboard.h" | |||||
#include "layer_stack.h" | |||||
#include "debug.h" | |||||
static uint8_t top_layer = 0; | |||||
/* [0] always works as sentinel and not used for store.*/ | |||||
static layer_item_t layer_stack[LAYER_STACK_SIZE] = {}; | |||||
void layer_stack_clear(void) | |||||
{ | |||||
for (uint8_t i = 0; i < LAYER_STACK_SIZE; i++) { | |||||
layer_stack[i] = (layer_item_t){ .layer = 0, | |||||
.next = 0, | |||||
.used = false }; | |||||
} | |||||
} | |||||
bool layer_stack_push(uint8_t layer) | |||||
{ | |||||
for (uint8_t i = 1; i < LAYER_STACK_SIZE; i++) { | |||||
if (!layer_stack[i].used) { | |||||
layer_stack[i] = (layer_item_t){ .layer = layer, | |||||
.next = top_layer, | |||||
.used = true }; | |||||
top_layer = i; | |||||
return true; | |||||
} | |||||
} | |||||
return false; | |||||
} | |||||
bool layer_stack_pop(void) | |||||
{ | |||||
if (layer_stack[top_layer].used) { | |||||
uint8_t popped = top_layer; | |||||
top_layer = layer_stack[popped].next; | |||||
layer_stack[popped] = (layer_item_t){}; | |||||
return true; | |||||
} | |||||
return false; | |||||
} | |||||
bool layer_stack_remove(uint8_t layer) | |||||
{ | |||||
if (layer_stack[top_layer].used && layer_stack[top_layer].layer == layer) { | |||||
layer_stack_pop(); | |||||
debug("layer_stack_remove: top_layer\n"); | |||||
return true; | |||||
} | |||||
for (uint8_t i = top_layer; layer_stack[i].used; i = layer_stack[i].next) { | |||||
debug("layer_stack_remove: ["); debug_dec(i); debug("]"); | |||||
debug_dec(layer_stack[i].layer); debug("\n"); | |||||
uint8_t removed = layer_stack[i].next; | |||||
if (layer_stack[removed].used && layer_stack[removed].layer == layer) { | |||||
layer_stack[i].next = layer_stack[removed].next; | |||||
layer_stack[removed] = (layer_item_t){}; | |||||
debug("layer_stack_remove: removed.\n"); | |||||
return true; | |||||
} | |||||
} | |||||
return false; | |||||
} | |||||
bool layer_stack_remove_then_push(uint8_t layer) | |||||
{ | |||||
layer_stack_remove(layer); | |||||
return layer_stack_push(layer); | |||||
} | |||||
bool layer_stack_remove_or_push(uint8_t layer) | |||||
{ | |||||
return (layer_stack_remove(layer)) || layer_stack_push(layer); | |||||
} | |||||
void layer_stack_debug(void) | |||||
{ | |||||
debug("layer_stack: "); | |||||
layer_item_t item = layer_stack[top_layer]; | |||||
while (item.used) { | |||||
debug_dec(item.layer); | |||||
debug("["); debug_dec(item.next); debug("] "); | |||||
item = layer_stack[item.next]; | |||||
} | |||||
debug("\n"); | |||||
} | |||||
action_t layer_stack_get_action(key_t key) | |||||
{ | |||||
action_t action; | |||||
action.code = ACTION_TRANSPARENT; | |||||
/* layer stack */ | |||||
for (layer_item_t i = layer_stack[top_layer]; i.used; i = layer_stack[i.next]) { | |||||
action = action_for_key(i.layer, key); | |||||
if (action.code != ACTION_TRANSPARENT) { | |||||
layer_stack_debug(); | |||||
debug("layer_stack: used. "); debug_dec(i.layer); debug("\n"); | |||||
return action; | |||||
} | |||||
debug("layer_stack: through. "); debug_dec(i.layer); debug("\n"); | |||||
} | |||||
return action; | |||||
} |
/* | |||||
Copyright 2013 Jun Wako <[email protected]> | |||||
This program is free software: you can redistribute it and/or modify | |||||
it under the terms of the GNU General Public License as published by | |||||
the Free Software Foundation, either version 2 of the License, or | |||||
(at your option) any later version. | |||||
This program is distributed in the hope that it will be useful, | |||||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
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/>. | |||||
*/ | |||||
#ifndef LAYER_STACK_H | |||||
#define LAYER_STACK_H | |||||
#include <stdint.h> | |||||
#include "action.h" | |||||
/* | |||||
* Layer stack | |||||
*/ | |||||
#define LAYER_STACK_SIZE 8 | |||||
typedef struct { | |||||
uint8_t layer:4; | |||||
uint8_t next:3; | |||||
bool used; | |||||
} layer_item_t; | |||||
void layer_stack_clear(void); | |||||
bool layer_stack_push(uint8_t layer); | |||||
bool layer_stack_pop(void); | |||||
bool layer_stack_remove(uint8_t layer); | |||||
bool layer_stack_remove_then_push(uint8_t layer); | |||||
bool layer_stack_remove_or_push(uint8_t layer); | |||||
void layer_stack_debug(void); | |||||
action_t layer_stack_get_action(key_t key); | |||||
#endif | |||||
#include <stdint.h> | |||||
#include "keyboard.h" | |||||
#include "action.h" | |||||
#include "debug.h" | |||||
#include "util.h" | |||||
#include "layer_switch.h" | |||||
uint8_t default_layer = 0; | |||||
uint16_t layer_switch_stat = 0; | |||||
uint16_t layer_switch_get_stat(void) | |||||
{ | |||||
return layer_switch_stat; | |||||
} | |||||
/* return highest layer whose state is on */ | |||||
uint8_t layer_switch_get_layer(void) | |||||
{ | |||||
return biton16(layer_switch_stat); | |||||
} | |||||
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"); | |||||
clear_keyboard_but_mods(); // To avoid stuck keys | |||||
} | |||||
void layer_switch_clear(void) | |||||
{ | |||||
stat_set(0); | |||||
} | |||||
void layer_switch_set(uint16_t stat) | |||||
{ | |||||
stat_set(stat); | |||||
} | |||||
void layer_switch_move(uint8_t layer) | |||||
{ | |||||
if (layer) | |||||
stat_set(1<<layer); | |||||
else | |||||
stat_set(0); // fall back to default layer | |||||
} | |||||
void layer_switch_on(uint8_t layer) | |||||
{ | |||||
stat_set(layer_switch_stat | (1<<layer)); | |||||
} | |||||
void layer_switch_off(uint8_t layer) | |||||
{ | |||||
stat_set(layer_switch_stat & ~(1<<layer)); | |||||
} | |||||
void layer_switch_invert(uint8_t layer) | |||||
{ | |||||
stat_set(layer_switch_stat ^ (1<<layer)); | |||||
} | |||||
void layer_switch_or(uint16_t stat) | |||||
{ | |||||
stat_set(layer_switch_stat | stat); | |||||
} | |||||
void layer_switch_and(uint16_t stat) | |||||
{ | |||||
stat_set(layer_switch_stat & stat); | |||||
} | |||||
void layer_switch_xor(uint16_t stat) | |||||
{ | |||||
stat_set(layer_switch_stat ^ stat); | |||||
} | |||||
void layer_switch_debug(void) | |||||
{ | |||||
debug_hex16(layer_switch_stat); debug("("); debug_dec(layer_switch_get_layer()); debug(")"); | |||||
} | |||||
action_t layer_switch_get_action(key_t key) | |||||
{ | |||||
action_t action; | |||||
action.code = ACTION_TRANSPARENT; | |||||
/* higher layer first */ | |||||
for (int8_t i = 15; i >= 0; i--) { | |||||
if (layer_switch_stat & (1<<i)) { | |||||
action = action_for_key(i, key); | |||||
if (action.code != ACTION_TRANSPARENT) { | |||||
return action; | |||||
} | |||||
} | |||||
} | |||||
return action; | |||||
} |
/* | |||||
Copyright 2013 Jun Wako <[email protected]> | |||||
This program is free software: you can redistribute it and/or modify | |||||
it under the terms of the GNU General Public License as published by | |||||
the Free Software Foundation, either version 2 of the License, or | |||||
(at your option) any later version. | |||||
This program is distributed in the hope that it will be useful, | |||||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
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/>. | |||||
*/ | |||||
#ifndef LAYER_SWITCH_H | |||||
#define LAYER_SWITCH_H | |||||
#include <stdint.h> | |||||
#include "keyboard.h" | |||||
#include "action.h" | |||||
/* base layer to fall back */ | |||||
extern uint8_t default_layer; | |||||
/* layer status */ | |||||
extern uint16_t layer_switch_stat; | |||||
/* return layer status */ | |||||
uint16_t layer_switch_get_stat(void); | |||||
/* 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); | |||||
/* return action depending on current layer status */ | |||||
action_t layer_switch_get_action(key_t key); | |||||
#endif |
} | } | ||||
// most significant on-bit - return highest location of on-bit | // most significant on-bit - return highest location of on-bit | ||||
// NOTE: return 0 when bit0 is on or all bits are off | |||||
uint8_t biton(uint8_t bits) | uint8_t biton(uint8_t bits) | ||||
{ | { | ||||
uint8_t n = 0; | uint8_t n = 0; | ||||
if (bits >> 1) { bits >>= 1; n += 1;} | if (bits >> 1) { bits >>= 1; n += 1;} | ||||
return n; | return n; | ||||
} | } | ||||
uint8_t biton16(uint16_t bits) | |||||
{ | |||||
uint8_t n = 0; | |||||
if (bits >> 8) { bits >>= 8; n += 8;} | |||||
if (bits >> 4) { bits >>= 4; n += 4;} | |||||
if (bits >> 2) { bits >>= 2; n += 2;} | |||||
if (bits >> 1) { bits >>= 1; n += 1;} | |||||
return n; | |||||
} |
uint8_t bitpop(uint8_t bits); | uint8_t bitpop(uint8_t bits); | ||||
uint8_t bitpop16(uint16_t bits); | uint8_t bitpop16(uint16_t bits); | ||||
uint8_t biton(uint8_t bits); | uint8_t biton(uint8_t bits); | ||||
uint8_t biton16(uint16_t bits); | |||||
#endif | #endif |