$(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)/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 */ | /* default layer indicates base layer */ | ||||
static action_t get_action(key_t key) | static action_t get_action(key_t key) | ||||
{ | { | ||||
action_t action = action_for_key(current_layer, key); | |||||
action_t action; | |||||
action.code = ACTION_NO; | |||||
/* Transparently use default layer */ | |||||
if (action.code == ACTION_TRANSPARENT) { | |||||
// TODO: layer stacking | |||||
action = action_for_key(default_layer, key); | |||||
debug("TRNASPARENT: "); debug_hex16(action.code); debug("\n"); | |||||
/* layer stack */ | |||||
action = layer_stack_get_action(key); | |||||
if (action.code != ACTION_TRANSPARENT) { | |||||
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 */ | |||||
debug("default layer: used. \n"); | |||||
action = action_for_key(default_layer, key); | |||||
return action; | return action; | ||||
} | } | ||||
} else { | } else { | ||||
if (tap_count == 0) { | if (tap_count == 0) { | ||||
debug("MODS_TAP: Oneshot: cancel/del_mods\n"); | debug("MODS_TAP: Oneshot: cancel/del_mods\n"); | ||||
// cancel oneshot by holding. | |||||
// cancel oneshot on hold | |||||
oneshot_cancel(); | oneshot_cancel(); | ||||
del_mods(mods); | del_mods(mods); | ||||
} | } | ||||
} | } | ||||
else { | else { | ||||
// NOTE: This is needed by legacy keymap support | // NOTE: This is needed by legacy keymap support | ||||
layer_switch(default_layer); | |||||
layer_switch(0); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_PRESS: | case LAYER_ON_PRESS: | ||||
layer_switch(action.layer.val); | layer_switch(action.layer.val); | ||||
} | } | ||||
break; | break; | ||||
case LAYER_DEFAULT: /* default layer */ | |||||
switch (action.layer.val) { | |||||
case DEFAULT_ON_BOTH: | |||||
layer_switch(default_layer); | |||||
break; | |||||
case DEFAULT_ON_PRESS: | |||||
if (event.pressed) { | |||||
layer_switch(default_layer); | |||||
} | |||||
break; | |||||
case DEFAULT_ON_RELEASE: | |||||
if (!event.pressed) { | |||||
layer_switch(default_layer); | |||||
} | |||||
break; | |||||
} | |||||
case LAYER_ON_BOTH: | |||||
layer_switch(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) { | ||||
} | } | ||||
} | } | ||||
break; | break; | ||||
case LAYER_CHANGE_DEFAULT: /* change default layer */ | |||||
case LAYER_SET_DEFAULT_ON_PRESS: | |||||
if (event.pressed) { | if (event.pressed) { | ||||
default_layer = action.layer.val; | default_layer = action.layer.val; | ||||
layer_switch(default_layer); | |||||
layer_switch(0); | |||||
} | } | ||||
break; | break; | ||||
default: /* switch layer on hold and key on tap*/ | |||||
case LAYER_SET_DEFAULT_ON_RELEASE: | |||||
if (!event.pressed) { | |||||
default_layer = action.layer.val; | |||||
layer_switch(0); | |||||
} | |||||
break; | |||||
case LAYER_SET_DEFAULT_ON_BOTH: | |||||
default_layer = action.layer.val; | |||||
layer_switch(0); | |||||
break; | |||||
default: | |||||
/* tap key */ | |||||
if (event.pressed) { | if (event.pressed) { | ||||
if (tap_count > 0) { | |||||
debug("LAYER_PRESSED: Tap: register_code\n"); | |||||
register_code(action.layer.code); | |||||
} else { | |||||
debug("LAYER_PRESSED: No tap: layer_switch\n"); | |||||
layer_switch(action.layer.val); | |||||
} | |||||
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(action.layer.val); | |||||
} | |||||
} else { | } else { | ||||
if (tap_count > 0) { | |||||
debug("LAYER_PRESSED: Tap: unregister_code\n"); | |||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | |||||
debug("LAYER_SET: Tap: unregister_code\n"); | |||||
unregister_code(action.layer.code); | unregister_code(action.layer.code); | ||||
} else { | } else { | ||||
//debug("LAYER_PRESSED: No tap: NO ACTION\n"); | |||||
// NOTE: This is needed by legacy keymap support | // NOTE: This is needed by legacy keymap support | ||||
debug("LAYER_PRESSED: No tap: return to default layer\n"); | |||||
layer_switch(default_layer); | |||||
debug("LAYER_SET: No tap: return to default layer(on release)\n"); | |||||
layer_switch(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(current_layer | action.layer.val); | |||||
} else { | } else { | ||||
layer_switch(current_layer ^ action.layer.val); | |||||
layer_switch(current_layer & ~action.layer.val); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_PRESS: | case LAYER_ON_PRESS: | ||||
layer_switch(current_layer ^ action.layer.val); | layer_switch(current_layer ^ action.layer.val); | ||||
} | } | ||||
break; | break; | ||||
case LAYER_ON_BOTH: | |||||
layer_switch(current_layer ^ action.layer.val); | |||||
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) { | ||||
} | } | ||||
} | } | ||||
break; | break; | ||||
case 0xFF: | |||||
// change default layer | |||||
case LAYER_SET_DEFAULT_ON_PRESS: | |||||
if (event.pressed) { | if (event.pressed) { | ||||
default_layer = current_layer ^ action.layer.val; | |||||
layer_switch(default_layer); | |||||
} else { | |||||
default_layer = current_layer ^ action.layer.val; | |||||
layer_switch(default_layer); | |||||
default_layer = default_layer ^ action.layer.val; | |||||
layer_switch(0); | |||||
} | |||||
break; | |||||
case LAYER_SET_DEFAULT_ON_RELEASE: | |||||
if (!event.pressed) { | |||||
default_layer = default_layer ^ action.layer.val; | |||||
layer_switch(0); | |||||
} | } | ||||
break; | break; | ||||
case LAYER_SET_DEFAULT_ON_BOTH: | |||||
default_layer = default_layer ^ action.layer.val; | |||||
layer_switch(0); | |||||
break; | |||||
default: | default: | ||||
// with 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_BIT: Tap: register_code\n"); | debug("LAYER_BIT: Tap: register_code\n"); | ||||
register_code(action.layer.code); | register_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_BIT: No tap: layer_switch(bit on)\n"); | |||||
debug("LAYER_BIT: No tap: layer_bit(on press)\n"); | |||||
layer_switch(current_layer ^ action.layer.val); | layer_switch(current_layer ^ action.layer.val); | ||||
} | } | ||||
} else { | } else { | ||||
debug("LAYER_BIT: Tap: unregister_code\n"); | debug("LAYER_BIT: Tap: unregister_code\n"); | ||||
unregister_code(action.layer.code); | unregister_code(action.layer.code); | ||||
} else { | } else { | ||||
debug("LAYER_BIT: No tap: layer_switch(bit off)\n"); | |||||
debug("LAYER_BIT: No tap: layer_bit(on release)\n"); | |||||
layer_switch(current_layer ^ action.layer.val); | layer_switch(current_layer ^ action.layer.val); | ||||
} | } | ||||
} | } | ||||
break; | break; | ||||
} | } | ||||
break; | break; | ||||
case ACT_LAYER_STACK: | |||||
switch (action.layer.code) { | |||||
case LAYER_MOMENTARY: /* momentary */ | |||||
if (event.pressed) { | |||||
layer_stack_remove_then_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} else { | |||||
layer_stack_remove(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
break; | |||||
case LAYER_ON_PRESS: | |||||
if (event.pressed) { | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
break; | |||||
case LAYER_ON_RELEASE: | |||||
if (!event.pressed) { | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
break; | |||||
case LAYER_ON_BOTH: | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
break; | |||||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | |||||
if (event.pressed) { | |||||
if (tap_count < TAPPING_TOGGLE) { | |||||
debug("LAYER_STACK: tap toggle(press).\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
} else { | |||||
if (tap_count <= TAPPING_TOGGLE) { | |||||
debug("LAYER_STACK: tap toggle(release).\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
} | |||||
break; | |||||
default: | |||||
// tap key | |||||
if (event.pressed) { | |||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | |||||
debug("LAYER_STACK: Tap: register_code\n"); | |||||
register_code(action.layer.code); | |||||
} else { | |||||
debug("LAYER_STACK: No tap: layer_stack(on press)\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
} else { | |||||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | |||||
debug("LAYER_STACK: Tap: unregister_code\n"); | |||||
unregister_code(action.layer.code); | |||||
} else { | |||||
debug("LAYER_STACK: No tap: layer_stack(on release)\n"); | |||||
layer_stack_remove_or_push(action.layer.val); | |||||
layer_stack_debug(); | |||||
} | |||||
} | |||||
break; | |||||
} | |||||
break; | |||||
/* Extentions */ | /* Extentions */ | ||||
case ACT_MACRO: | case ACT_MACRO: | ||||
case LAYER_MOMENTARY: | case LAYER_MOMENTARY: | ||||
case LAYER_ON_PRESS: | case LAYER_ON_PRESS: | ||||
case LAYER_ON_RELEASE: | case LAYER_ON_RELEASE: | ||||
case LAYER_DEFAULT: | |||||
case LAYER_ON_BOTH: | |||||
case LAYER_SET_DEFAULT_ON_PRESS: | |||||
case LAYER_SET_DEFAULT_ON_RELEASE: | |||||
case LAYER_SET_DEFAULT_ON_BOTH: | |||||
return false; | return false; | ||||
case LAYER_TAP_TOGGLE: | case LAYER_TAP_TOGGLE: | ||||
default: /* tap key */ | default: /* tap key */ | ||||
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: debug("ACT_LAYER"); 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_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 Actions | * Layer Actions | ||||
* ------------- | * ------------- | ||||
* ACT_LAYER(1000): Set layer | |||||
* ACT_LAYER_BIT(1001): Bit-op layer | |||||
* ACT_LAYER(1000): Set layer | |||||
* ACT_LAYER_BIT(1001): Bit-op layer | |||||
* ACT_LAYER_STACK: Layer stack | |||||
* | * | ||||
* 1000|LLLL|0000 0000 set L to layer on press and set default on release(momentary) | |||||
* 1000|LLLL|0000 0001 set L to layer on press | |||||
* 1000|LLLL|0000 0010 set L to layer on release | |||||
* 1000|----|0000 0011 set default to layer on both(return to default layer) | |||||
* 1000|LLLL| keycode set L to layer while hold and send key on tap | |||||
* 1000|LLLL|1111 0000 set L to layer while hold and toggle on several taps | |||||
* 1000|LLLL|1111 1111 set L to default and layer(on press) | |||||
* 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 | |||||
* | * | ||||
* 1001|BBBB|0000 0000 (not used) | |||||
* 1001|BBBB|0000 0001 bit-xor layer with B on press | |||||
* 1001|BBBB|0000 0010 bit-xor layer with B on release | |||||
* 1001|BBBB|0000 0011 bit-xor layer with B on both(momentary) | |||||
* 1001|BBBB| keycode bit-xor layer with B while hold and send key on tap | |||||
* 1001|BBBB|1111 0000 bit-xor layer with B while hold and toggle on several taps | |||||
* 1001|BBBB|1111 1111 bit-xor default with B and set layer(on press) | |||||
* 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 | |||||
* | * | ||||
* 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 | |||||
* 1011|LLLL|1111 1111 (not used) | |||||
* | * | ||||
* | * | ||||
* Extensions(11XX) | * Extensions(11XX) | ||||
ACT_LAYER = 0b1000, | ACT_LAYER = 0b1000, | ||||
ACT_LAYER_BIT = 0b1001, | ACT_LAYER_BIT = 0b1001, | ||||
ACT_LAYER_STACK = 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) | ||||
/* Mods & key */ | /* Mods & key */ | ||||
#define ACTION_LMODS(mods) ACTION(ACT_LMODS, MODS4(mods)<<8 | 0x00) | #define ACTION_LMODS(mods) ACTION(ACT_LMODS, MODS4(mods)<<8 | 0x00) | ||||
#define ACTION_LMODS_KEY(mods, key) ACTION(ACT_LMODS, MODS4(mods)<<8 | (key)) | #define ACTION_LMODS_KEY(mods, key) ACTION(ACT_LMODS, MODS4(mods)<<8 | (key)) | ||||
#define ACTION_RMODS(mods) ACTION(ACT_RMODS, MODS4(mods)<<8 | 0x00) | #define ACTION_RMODS(mods) ACTION(ACT_RMODS, MODS4(mods)<<8 | 0x00) | ||||
#define ACTION_RMODS_KEY(mods, key) ACTION(ACT_RMODS, MODS4(mods)<<8 | (key)) | #define ACTION_RMODS_KEY(mods, key) ACTION(ACT_RMODS, MODS4(mods)<<8 | (key)) | ||||
/* Mod & key */ | |||||
#define ACTION_LMOD(mod) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | 0x00) | #define ACTION_LMOD(mod) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | 0x00) | ||||
#define ACTION_LMOD_KEY(mod, key) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | (key)) | #define ACTION_LMOD_KEY(mod, key) ACTION(ACT_LMODS, MODS4(MOD_BIT(mod))<<8 | (key)) | ||||
#define ACTION_RMOD(mod) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | 0x00) | #define ACTION_RMOD(mod) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | 0x00) | ||||
#define ACTION_RMOD_KEY(mod, key) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | (key)) | #define ACTION_RMOD_KEY(mod, key) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | (key)) | ||||
/* Mods + Tap key */ | |||||
/* Tap key */ | |||||
enum mods_codes { | enum mods_codes { | ||||
MODS_ONESHOT = 0x00, | MODS_ONESHOT = 0x00, | ||||
}; | }; | ||||
#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT) | #define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT) | ||||
#define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key)) | #define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key)) | ||||
#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT) | #define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT) | ||||
/* Mod + Tap key */ | |||||
#define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) | #define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) | ||||
#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) | #define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) | ||||
#define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) | #define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) | ||||
/* | /* | ||||
* Switch layer | |||||
* Layer switching | |||||
*/ | */ | ||||
enum layer_codes { | enum layer_codes { | ||||
LAYER_MOMENTARY = 0, | LAYER_MOMENTARY = 0, | ||||
LAYER_ON_PRESS = 1, | LAYER_ON_PRESS = 1, | ||||
LAYER_ON_RELEASE = 2, | LAYER_ON_RELEASE = 2, | ||||
LAYER_DEFAULT =3, | |||||
LAYER_ON_BOTH =3, | |||||
LAYER_TAP_TOGGLE = 0xF0, | LAYER_TAP_TOGGLE = 0xF0, | ||||
LAYER_CHANGE_DEFAULT = 0xFF | |||||
LAYER_SET_DEFAULT_ON_PRESS = 0xFD, | |||||
LAYER_SET_DEFAULT_ON_RELEASE = 0xFE, | |||||
LAYER_SET_DEFAULT_ON_BOTH = 0xFF | |||||
}; | }; | ||||
enum layer_vals_default { | |||||
DEFAULT_ON_PRESS = 1, | |||||
DEFAULT_ON_RELEASE = 2, | |||||
DEFAULT_ON_BOTH = 3, | |||||
}; | |||||
/* | /* | ||||
* return to 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, (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) | |||||
/* 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, (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) | |||||
/* | |||||
* Current layer: Return to default layer | |||||
*/ | */ | ||||
#define ACTION_LAYER_DEFAULT ACTION_LAYER_DEFAULT_R | #define ACTION_LAYER_DEFAULT ACTION_LAYER_DEFAULT_R | ||||
/* set default layer on press */ | |||||
#define ACTION_LAYER_DEFAULT_P ACTION(ACT_LAYER, DEFAULT_ON_PRESS<<8 | LAYER_DEFAULT) | |||||
/* set default layer on release */ | |||||
#define ACTION_LAYER_DEFAULT_R ACTION(ACT_LAYER, DEFAULT_ON_RELEASE<<8 | LAYER_DEFAULT) | |||||
/* change default layer and set layer */ | |||||
#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) | |||||
/* | /* | ||||
* Set layer | |||||
* Current layer: Set | |||||
*/ | */ | ||||
/* set layer on press and none on release */ | |||||
#define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) | #define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer) | ||||
/* set layer on press and set default on release (This is needed by legacy keymap support.) */ | |||||
#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY) | #define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY) | ||||
/* set layer on press and none on release */ | |||||
#define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer) | #define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer) | ||||
/* set layer while hold and send key on tap */ | |||||
#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key)) | |||||
/* set layer on press */ | |||||
#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS) | #define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS) | ||||
/* set layer on release */ | |||||
#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE) | #define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE) | ||||
/* set layer on hold and toggle on several taps */ | |||||
#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_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_TAP_TOGGLE) | ||||
/* set default layer on both press and release */ | |||||
#define ACTION_LAYER_SET_DEFAULT(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_CHANGE_DEFAULT) | |||||
#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key)) | |||||
/* | /* | ||||
* Bit-op layer | |||||
* Current layer: Bit-op | |||||
*/ | */ | ||||
/* bit-xor on both press and release */ | |||||
#define ACTION_LAYER_BIT(bits) ACTION_LAYER_BIT_MOMENTARY(bits) | #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_MOMENTARY(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_MOMENTARY) | ||||
/* bit-xor on press */ | |||||
#define ACTION_LAYER_BIT_TOGGLE(bits) ACTION_LAYER_BIT_R(bits) | #define ACTION_LAYER_BIT_TOGGLE(bits) ACTION_LAYER_BIT_R(bits) | ||||
/* bit-xor while hold and send key on tap */ | |||||
#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) | |||||
/* bit-xor on press */ | |||||
#define ACTION_LAYER_BIT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS) | #define ACTION_LAYER_BIT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_PRESS) | ||||
/* bit-xor on release */ | |||||
#define ACTION_LAYER_BIT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE) | #define ACTION_LAYER_BIT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_ON_RELEASE) | ||||
/* bit-xor while hold and toggle on several taps */ | |||||
#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_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE) | ||||
/* bit-xor default layer and set layer */ | |||||
#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_CHANGE_DEFAULT) | |||||
#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) | |||||
/* | |||||
* Layer Stack | |||||
*/ | |||||
/* 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)) | |||||
/* HID Usage */ | |||||
/* | |||||
* HID Usage | |||||
*/ | |||||
enum usage_pages { | enum usage_pages { | ||||
PAGE_SYSTEM, | PAGE_SYSTEM, | ||||
PAGE_CONSUMER | PAGE_CONSUMER |
#include "keyboard.h" | #include "keyboard.h" | ||||
#include "bootloader.h" | #include "bootloader.h" | ||||
#include "command.h" | #include "command.h" | ||||
#include "layer_stack.h" | |||||
#ifdef MOUSEKEY_ENABLE | #ifdef MOUSEKEY_ENABLE | ||||
#include "mousekey.h" | #include "mousekey.h" | ||||
#endif | #endif | ||||
#endif | #endif | ||||
static uint8_t numkey2num(uint8_t code); | static uint8_t numkey2num(uint8_t code); | ||||
static void switch_layer(uint8_t layer); | |||||
static void switch_default_layer(uint8_t layer); | |||||
typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t; | typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t; | ||||
#endif | #endif | ||||
break; | break; | ||||
#endif | #endif | ||||
case KC_ESC: | |||||
case KC_GRV: | |||||
case KC_0: | case KC_0: | ||||
case KC_F10: | |||||
clear_keyboard(); | |||||
switch_layer(0); | |||||
switch_default_layer(0); | |||||
break; | break; | ||||
case KC_1 ... KC_9: | case KC_1 ... KC_9: | ||||
clear_keyboard(); | |||||
switch_layer((code - KC_1) + 1); | |||||
switch_default_layer((code - KC_1) + 1); | |||||
break; | break; | ||||
case KC_F1 ... KC_F9: | |||||
clear_keyboard(); | |||||
switch_layer((code - KC_F1) + 1); | |||||
case KC_F1 ... KC_F12: | |||||
switch_default_layer((code - KC_F1) + 1); | |||||
break; | break; | ||||
default: | default: | ||||
print("?"); | print("?"); | ||||
return 0; | return 0; | ||||
} | } | ||||
static void switch_layer(uint8_t layer) | |||||
static void switch_default_layer(uint8_t layer) | |||||
{ | { | ||||
print_val_hex8(current_layer); | print_val_hex8(current_layer); | ||||
print_val_hex8(default_layer); | print_val_hex8(default_layer); | ||||
current_layer = layer; | |||||
default_layer = layer; | |||||
print("switch to "); print_val_hex8(layer); | print("switch to "); print_val_hex8(layer); | ||||
default_layer = layer; | |||||
current_layer = 0; /* 0 means default_layer */ | |||||
layer_stack_clear(); | |||||
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 | |||||
poker: OPT_DEFS += -DKEYMAP_POKER | poker: OPT_DEFS += -DKEYMAP_POKER | ||||
poker: all | poker: all | ||||
poker_stack: OPT_DEFS += -DKEYMAP_POKER_STACK | |||||
poker_stack: all |
poker: OPT_DEFS += -DKEYMAP_POKER | poker: OPT_DEFS += -DKEYMAP_POKER | ||||
poker: all | poker: all | ||||
poker_stack: OPT_DEFS += -DKEYMAP_POKER_STACK | |||||
poker_stack: all |
#include "keymap_plain.h" | #include "keymap_plain.h" | ||||
#elif defined(KEYMAP_POKER) | #elif defined(KEYMAP_POKER) | ||||
#include "keymap_poker.h" | #include "keymap_poker.h" | ||||
#elif defined(KEYMAP_POKER_STACK) | |||||
#include "keymap_poker_stack.h" | |||||
#else | #else | ||||
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | ||||
/* | /* |
/* Layer x100: Poker Default + Fn'd */ | /* Layer x100: Poker Default + Fn'd */ | ||||
KEYMAP_ANSI( | KEYMAP_ANSI( | ||||
ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | ||||
TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
CAPS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | ||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ | TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ | ||||
TRNS,TRNS,TRNS, FN0, FN2, TRNS,TRNS,TRNS), | TRNS,TRNS,TRNS, FN0, FN2, TRNS,TRNS,TRNS), | ||||
/* Layer x101: Poker with Arrow + Fn'd */ | /* Layer x101: Poker with Arrow + Fn'd */ | ||||
KEYMAP_ANSI( | KEYMAP_ANSI( | ||||
ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | ||||
TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
CAPS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | ||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, UP, \ | |||||
TRNS,TRNS,TRNS, FN0, FN2, LEFT,DOWN,RGHT), | |||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, PGUP, \ | |||||
TRNS,TRNS,TRNS, FN0, FN2, HOME,PGDN,END), | |||||
/* Layer x110: Poker with Esc + Fn'd */ | /* Layer x110: Poker with Esc + Fn'd */ | ||||
KEYMAP_ANSI( | KEYMAP_ANSI( | ||||
GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | ||||
TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
CAPS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | ||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ | TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ | ||||
TRNS,TRNS,TRNS, FN0, FN2, TRNS,TRNS,TRNS), | TRNS,TRNS,TRNS, FN0, FN2, TRNS,TRNS,TRNS), | ||||
/* Layer x111: Poker with Arrow and Esc + Fn'd */ | /* Layer x111: Poker with Arrow and Esc + Fn'd */ | ||||
KEYMAP_ANSI( | KEYMAP_ANSI( | ||||
GRV, F9, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | GRV, F9, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | ||||
TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
CAPS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | ||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, UP, \ | |||||
TRNS,TRNS,TRNS, FN0, FN2, LEFT,DOWN,RGHT), | |||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, PGUP, \ | |||||
TRNS,TRNS,TRNS, FN0, FN2, HOME,PGDN,END), | |||||
/* colemak */ | |||||
[8] = KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | |||||
TAB, Q, W, F, P, G, J, L, U, Y, SCLN,LBRC,RBRC,BSLS, \ | |||||
BSPC,A, R, S, T, D, H, N, E, I, O, QUOT, ENT, \ | |||||
LSFT,Z, X, C, V, B, K, M, COMM,DOT, SLSH, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
/* dvorak */ | |||||
KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, LBRC,RBRC,BSPC, \ | |||||
TAB, QUOT,COMM,DOT, P, Y, F, G, C, R, L, SLSH,EQL, BSLS, \ | |||||
LCTL,A, O, E, U, I, D, H, T, N, S, MINS, ENT, \ | |||||
LSFT,SCLN,Q, J, K, X, B, M, W, V, Z, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
/* workman */ | |||||
KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | |||||
TAB, Q, D, R, W, B, J, F, U, P, SCLN,LBRC,RBRC,BSLS, \ | |||||
BSPC,A, S, H, T, G, Y, N, E, O, I, QUOT, ENT, \ | |||||
LSFT,Z, X, M, C, V, K, L, COMM,DOT, SLSH, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
}; | }; | ||||
/* | /* |
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||||
/* | |||||
* Poker Layer | |||||
*/ | |||||
/* Layer x000: Poker Default Layer | |||||
* ,-----------------------------------------------------------. | |||||
* | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backsp | | |||||
* |-----------------------------------------------------------| | |||||
* |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | |||||
* |-----------------------------------------------------------| | |||||
* |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return | | |||||
* |-----------------------------------------------------------| | |||||
* |Shift | Z| X| C| V| B| N| M| ,| .| /|Shift | | |||||
* |-----------------------------------------------------------| | |||||
* |Ctrl|Gui |Alt | Space |Fn |Gui |App |Ctrl| | |||||
* `-----------------------------------------------------------' | |||||
*/ | |||||
KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | |||||
TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \ | |||||
LCTL,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, \ | |||||
LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
/* Layer 1: Poker with Arrow */ | |||||
KEYMAP_ANSI( | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ | |||||
TRNS,TRNS,TRNS, TRNS, TRNS,LEFT,DOWN,RGHT), | |||||
/* Layer 2: Poker with Esc */ | |||||
KEYMAP_ANSI( | |||||
ESC, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ | |||||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ | |||||
TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), | |||||
/* Layer 3: Poker Fn'd */ | |||||
KEYMAP_ANSI( | |||||
ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ | |||||
TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ | |||||
TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ | |||||
TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ | |||||
TRNS,TRNS,TRNS, FN0, TRNS,TRNS,TRNS,TRNS), | |||||
/* colemak */ | |||||
[4] = KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | |||||
TAB, Q, W, F, P, G, J, L, U, Y, SCLN,LBRC,RBRC,BSLS, \ | |||||
BSPC,A, R, S, T, D, H, N, E, I, O, QUOT, ENT, \ | |||||
LSFT,Z, X, C, V, B, K, M, COMM,DOT, SLSH, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
/* dvorak */ | |||||
KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, LBRC,RBRC,BSPC, \ | |||||
TAB, QUOT,COMM,DOT, P, Y, F, G, C, R, L, SLSH,EQL, BSLS, \ | |||||
CAPS,A, O, E, U, I, D, H, T, N, S, MINS, ENT, \ | |||||
LSFT,SCLN,Q, J, K, X, B, M, W, V, Z, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
/* workman */ | |||||
KEYMAP_ANSI( | |||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ | |||||
TAB, Q, D, R, W, B, J, F, U, P, SCLN,LBRC,RBRC,BSLS, \ | |||||
BSPC,A, S, H, T, G, Y, N, E, O, I, QUOT, ENT, \ | |||||
LSFT,Z, X, M, C, V, K, L, COMM,DOT, SLSH, RSFT, \ | |||||
LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), | |||||
}; | |||||
/* | |||||
* Fn action definition | |||||
*/ | |||||
static const uint16_t PROGMEM fn_actions[] = { | |||||
/* Poker Layout */ | |||||
[0] = ACTION_LAYER_STACK_TOGGLE(1), // FN0 Poker Arrow toggle(Space) | |||||
[1] = ACTION_LAYER_STACK_TOGGLE(2), // FN1 Poker Esc toggle(Q) | |||||
[2] = ACTION_LAYER_STACK(3), // FN2 Poker Fn | |||||
[3] = ACTION_RMODS_KEY(MOD_BIT(KC_RCTL)|MOD_BIT(KC_RSFT), KC_ESC), // FN3 Task(RControl,RShift+Esc) | |||||
}; |
# Compiler flags to generate dependency files. | # Compiler flags to generate dependency files. | ||||
GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d | |||||
#GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d | |||||
GENDEPFLAGS = -MMD -MP -MF .dep/$(subst /,_,$@).d | |||||
# Combine all necessary flags and optional flags. | # Combine all necessary flags and optional flags. |