di0ib/tmk_keyboard
1
0
Fork 0
Code Releases Activity

Merge branch 'layer_stack'

Browse Source
This commit is contained in:
tmk 2013-02-15 15:34:46 +09:00
commit f8d289e669
12 changed files with 500 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common.mk
View File

@ -3,6 +3,7 @@ SRC += $(COMMON_DIR)/host.c \
$(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 \

185
common/action.c
View File

@ -24,6 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#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 */
@ -209,14 +210,27 @@ void action_exec(keyevent_t event)
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 */ /* layer stack */
if (action.code == ACTION_TRANSPARENT) { action = layer_stack_get_action(key);
// TODO: layer stacking if (action.code != ACTION_TRANSPARENT) {
action = action_for_key(default_layer, key); return action;
debug("TRNASPARENT: "); debug_hex16(action.code); debug("\n");
} }
/* 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;
} }
@ -287,7 +301,7 @@ static void process_action(keyrecord_t *record)
} 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);
} }
@ -377,7 +391,7 @@ static void process_action(keyrecord_t *record)
} }
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:
@ -390,22 +404,8 @@ static void process_action(keyrecord_t *record)
layer_switch(action.layer.val); layer_switch(action.layer.val);
} }
break; break;
case LAYER_DEFAULT: /* default layer */ case LAYER_ON_BOTH:
switch (action.layer.val) { 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;
}
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) {
@ -419,30 +419,40 @@ static void process_action(keyrecord_t *record)
} }
} }
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) { if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
debug("LAYER_PRESSED: Tap: register_code\n"); debug("LAYER_SET: Tap: register_code\n");
register_code(action.layer.code); register_code(action.layer.code);
} else { } else {
debug("LAYER_PRESSED: No tap: layer_switch\n"); debug("LAYER_SET: No tap: layer_set(on press)\n");
layer_switch(action.layer.val); layer_switch(action.layer.val);
} }
} else { } else {
if (tap_count > 0) { if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
debug("LAYER_PRESSED: Tap: unregister_code\n"); 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"); debug("LAYER_SET: No tap: return to default layer(on release)\n");
layer_switch(default_layer); layer_switch(0);
} }
} }
break; break;
@ -452,9 +462,9 @@ static void process_action(keyrecord_t *record)
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:
@ -467,6 +477,9 @@ static void process_action(keyrecord_t *record)
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) {
@ -480,24 +493,30 @@ static void process_action(keyrecord_t *record)
} }
} }
break; break;
case 0xFF: case LAYER_SET_DEFAULT_ON_PRESS:
// change default layer
if (event.pressed) { if (event.pressed) {
default_layer = current_layer ^ action.layer.val; default_layer = default_layer ^ action.layer.val;
layer_switch(default_layer); layer_switch(0);
} else {
default_layer = current_layer ^ action.layer.val;
layer_switch(default_layer);
} }
break; break;
case LAYER_SET_DEFAULT_ON_RELEASE:
if (!event.pressed) {
default_layer = default_layer ^ action.layer.val;
layer_switch(0);
}
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 {
@ -505,13 +524,79 @@ static void process_action(keyrecord_t *record)
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:
@ -839,7 +924,10 @@ bool is_tap_key(key_t key)
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 */
@ -878,6 +966,7 @@ static void debug_action(action_t action)
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;

129
common/action.h
View File

@ -164,23 +164,32 @@ bool waiting_buffer_has_anykey_pressed(void);
* ------------- * -------------
* ACT_LAYER(1000): Set layer * ACT_LAYER(1000): Set layer
* ACT_LAYER_BIT(1001): Bit-op 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 0000 set current layer on press and return to default on release(momentary)
* 1000|LLLL|0000 0001 set L to layer on press * 1000|LLLL|0000 0001 set current layer on press
* 1000|LLLL|0000 0010 set L to layer on release * 1000|LLLL|0000 0010 set current layer on release
* 1000|----|0000 0011 set default to layer on both(return to default layer) * 1000|LLLL|0000 0011 set current layer on both
* 1000|LLLL| keycode set L to layer while hold and send key on tap * 1000|LLLL| keycode set current layer on hold and send key on tap
* 1000|LLLL|1111 0000 set L to layer while hold and toggle on several taps * 1000|LLLL|1111 0000 set current layer on hold and toggle on several taps
* 1000|LLLL|1111 1111 set L to default and layer(on press) * 1000|DDDD|1111 1111 set default layer on press
* L: 0 means default layer
* *
* 1001|BBBB|0000 0000 (not used) * 1001|BBBB|0000 0000 bit-on current layer on press and bit-off on release(momentary)
* 1001|BBBB|0000 0001 bit-xor layer with B on press * 1001|BBBB|0000 0001 bit-xor current layer on press
* 1001|BBBB|0000 0010 bit-xor layer with B on release * 1001|BBBB|0000 0010 bit-xor current layer on release
* 1001|BBBB|0000 0011 bit-xor layer with B on both(momentary) * 1001|BBBB|0000 0011 bit-xor current layer on both
* 1001|BBBB| keycode bit-xor layer with B while hold and send key on tap * 1001|BBBB| keycode bit-xor current layer on 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 0000 bit-xor current layer on hold and toggle on several taps
* 1001|BBBB|1111 1111 bit-xor default with B and set layer(on press) * 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)
@ -210,6 +219,7 @@ enum action_kind_id {
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,
@ -223,20 +233,20 @@ enum action_kind_id {
#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))
/* Tap key */
/* Mods + Tap key */
enum mods_codes { enum mods_codes {
MODS_ONESHOT = 0x00, MODS_ONESHOT = 0x00,
}; };
@ -244,7 +254,6 @@ enum mods_codes {
#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))
@ -252,73 +261,77 @@ enum mods_codes {
/* /*
* 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_LAYER_SET_P(0)
#define ACTION_LAYER_DEFAULT_P ACTION(ACT_LAYER, DEFAULT_ON_PRESS<<8 | LAYER_DEFAULT) #define ACTION_LAYER_DEFAULT_R ACTION_LAYER_SET_R(0)
/* set default layer on release */ #define ACTION_LAYER_DEFAULT_B ACTION_LAYER_SET_B(0)
#define ACTION_LAYER_DEFAULT_R ACTION(ACT_LAYER, DEFAULT_ON_RELEASE<<8 | LAYER_DEFAULT)
/* change default layer and set layer */
/* /*
* 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_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
#define ACTION_LAYER_SET_DEFAULT(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_CHANGE_DEFAULT)
/* /*
* 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_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key))
#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_CHANGE_DEFAULT) /*
* 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

27
common/command.c
View File

@ -27,6 +27,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#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
@ -53,7 +55,7 @@ static void mousekey_console_help(void);
#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;
@ -261,18 +263,16 @@ static bool command_common(uint8_t code)
#endif #endif
break; break;
#endif #endif
case KC_ESC:
case KC_GRV:
case KC_0: case KC_0:
case KC_F10: switch_default_layer(0);
clear_keyboard();
switch_layer(0);
break; break;
case KC_1 ... KC_9: case KC_1 ... KC_9:
clear_keyboard(); switch_default_layer((code - KC_1) + 1);
switch_layer((code - KC_1) + 1);
break; break;
case KC_F1 ... KC_F9: case KC_F1 ... KC_F12:
clear_keyboard(); switch_default_layer((code - KC_F1) + 1);
switch_layer((code - KC_F1) + 1);
break; break;
default: default:
print("?"); print("?");
@ -541,11 +541,14 @@ static uint8_t numkey2num(uint8_t code)
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();
} }

108
common/layer_stack.c Normal file
View File

@ -0,0 +1,108 @@
#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;
}

45
common/layer_stack.h Normal file
View File

@ -0,0 +1,45 @@
/*
Copyright 2013 Jun Wako <wakojun@gmail.com>
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

3
keyboard/gh60/Makefile.lufa
View File

@ -124,3 +124,6 @@ plain: 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

3
keyboard/gh60/Makefile.pjrc
View File

@ -94,3 +94,6 @@ plain: 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

2
keyboard/gh60/keymap.c
View File

@ -64,6 +64,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#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] = {
/* /*

37
keyboard/gh60/keymap_poker.h
View File

@ -48,31 +48,52 @@ 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,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, PGUP, \
TRNS,TRNS,TRNS, FN0, FN2, LEFT,DOWN,RGHT), 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,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, PGUP, \
TRNS,TRNS,TRNS, FN0, FN2, LEFT,DOWN,RGHT), 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),
}; };
/* /*

77
keyboard/gh60/keymap_poker_stack.h Normal file
View File

@ -0,0 +1,77 @@
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)
};

3
rules.mk
View File

@ -340,7 +340,8 @@ LST = $(patsubst %.c,$(OBJDIR)/%.lst,$(patsubst %.cpp,$(OBJDIR)/%.lst,$(patsubst
# 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.