From 0018e19f07661cbae722d64d94cdf6ee388252ff Mon Sep 17 00:00:00 2001 From: tmk Date: Thu, 14 Feb 2013 15:22:59 +0900 Subject: [PATCH] Add layer stack --- common/action.c | 259 +++++++++++++++++++++++++++++++++++++++--------- common/action.h | 133 ++++++++++++++----------- 2 files changed, 286 insertions(+), 106 deletions(-) diff --git a/common/action.c b/common/action.c index 6528cd46c..d0c9ddb0a 100644 --- a/common/action.c +++ b/common/action.c @@ -163,6 +163,85 @@ static void oneshot_toggle(void) } +/* + * Layer stack + */ +#define LAYER_STACK_SIZE 8 +typedef struct { + uint8_t layer:4; + uint8_t next:3; + bool used; +} layer_item_t; + +static uint8_t top_layer = 0; +// [0] is sentinel and not used. [0] is null item. +static layer_item_t layer_stack[LAYER_STACK_SIZE] = {}; + +static bool layer_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; +} +static bool layer_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; +} +static bool layer_remove(uint8_t layer) +{ + if (layer_stack[top_layer].used && layer_stack[top_layer].layer == layer) { + layer_pop(); + debug("layer_remove: top_layer\n"); + return true; + } + + for (uint8_t i = top_layer; layer_stack[i].used; i = layer_stack[i].next) { + debug("layer_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_remove: removed.\n"); + return true; + } + } + return false; +} +static bool layer_remove_then_push(uint8_t layer) +{ + layer_remove(layer); + return layer_push(layer); +} +static bool layer_remove_or_push(uint8_t layer) +{ + return (layer_remove(layer)) || layer_push(layer); +} +static void debug_layer_stack(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"); +} + void action_exec(keyevent_t event) { @@ -209,13 +288,26 @@ void action_exec(keyevent_t event) static action_t get_action(key_t key) { - action_t action = action_for_key(current_layer, key); + action_t action; - /* Transparently use default layer */ + /* 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) { + debug_layer_stack(); + debug("layer_stack: used. "); debug_dec(i.layer); debug("\n"); + return action; + } + debug("layer_stack: through. "); debug_dec(i.layer); debug("\n"); + } + + /* current layer */ + action = action_for_key(current_layer, key); + + /* 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"); + action = action_for_key(default_layer, key); } return action; } @@ -287,7 +379,7 @@ static void process_action(keyrecord_t *record) } else { if (tap_count == 0) { debug("MODS_TAP: Oneshot: cancel/del_mods\n"); - // cancel oneshot by holding. + // cancel oneshot on hold oneshot_cancel(); del_mods(mods); } @@ -390,22 +482,8 @@ static void process_action(keyrecord_t *record) layer_switch(action.layer.val); } 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; case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ if (event.pressed) { @@ -419,29 +497,39 @@ static void process_action(keyrecord_t *record) } } break; - case LAYER_CHANGE_DEFAULT: /* change default layer */ + case LAYER_SET_DEFAULT_ON_PRESS: if (event.pressed) { default_layer = action.layer.val; layer_switch(default_layer); } 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(default_layer); + } + break; + case LAYER_SET_DEFAULT_ON_BOTH: + default_layer = action.layer.val; + layer_switch(default_layer); + break; + default: + /* tap key */ 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 { - 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); } else { - //debug("LAYER_PRESSED: No tap: NO ACTION\n"); // 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); } } @@ -452,9 +540,9 @@ static void process_action(keyrecord_t *record) switch (action.layer.code) { case LAYER_MOMENTARY: /* momentary */ if (event.pressed) { - layer_switch(current_layer ^ action.layer.val); + layer_switch(current_layer | action.layer.val); } else { - layer_switch(current_layer ^ action.layer.val); + layer_switch(current_layer & ~action.layer.val); } break; case LAYER_ON_PRESS: @@ -467,6 +555,9 @@ static void process_action(keyrecord_t *record) layer_switch(current_layer ^ action.layer.val); } 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 */ if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { @@ -480,24 +571,30 @@ static void process_action(keyrecord_t *record) } } break; - case 0xFF: - // change default layer + case LAYER_SET_DEFAULT_ON_PRESS: 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); } break; + case LAYER_SET_DEFAULT_ON_RELEASE: + if (!event.pressed) { + default_layer = current_layer ^ action.layer.val; + layer_switch(default_layer); + } + break; + case LAYER_SET_DEFAULT_ON_BOTH: + default_layer = current_layer ^ action.layer.val; + layer_switch(default_layer); + break; default: - // with tap key + // tap key if (event.pressed) { if (IS_TAPPING_KEY(event.key) && tap_count > 0) { debug("LAYER_BIT: Tap: register_code\n"); register_code(action.layer.code); } 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); } } else { @@ -505,13 +602,79 @@ static void process_action(keyrecord_t *record) debug("LAYER_BIT: Tap: unregister_code\n"); unregister_code(action.layer.code); } 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); } } break; } break; + case ACT_LAYER_STACK: + switch (action.layer.code) { + case LAYER_MOMENTARY: /* momentary */ + if (event.pressed) { + layer_remove_then_push(action.layer.val); + debug_layer_stack(); + } else { + layer_remove(action.layer.val); + debug_layer_stack(); + } + break; + case LAYER_ON_PRESS: + if (event.pressed) { + layer_remove_or_push(action.layer.val); + debug_layer_stack(); + } + break; + case LAYER_ON_RELEASE: + if (!event.pressed) { + layer_remove_or_push(action.layer.val); + debug_layer_stack(); + } + break; + case LAYER_ON_BOTH: + layer_remove_or_push(action.layer.val); + debug_layer_stack(); + 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_remove_or_push(action.layer.val); + debug_layer_stack(); + } + } else { + if (tap_count <= TAPPING_TOGGLE) { + debug("LAYER_STACK: tap toggle(release).\n"); + layer_remove_or_push(action.layer.val); + debug_layer_stack(); + } + } + 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_remove_or_push(action.layer.val); + debug_layer_stack(); + } + } 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_remove_or_push(action.layer.val); + debug_layer_stack(); + } + } + break; + } + break; /* Extentions */ case ACT_MACRO: @@ -839,7 +1002,10 @@ bool is_tap_key(key_t key) case LAYER_MOMENTARY: case LAYER_ON_PRESS: 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; case LAYER_TAP_TOGGLE: default: /* tap key */ @@ -876,8 +1042,9 @@ static void debug_action(action_t action) case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break; case ACT_USAGE: debug("ACT_USAGE"); break; case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; - case ACT_LAYER: debug("ACT_LAYER"); break; + case ACT_LAYER: debug("ACT_LAYER"); 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_COMMAND: debug("ACT_COMMAND"); break; case ACT_FUNCTION: debug("ACT_FUNCTION"); break; diff --git a/common/action.h b/common/action.h index b9a6cb5b4..96b8ba2ed 100644 --- a/common/action.h +++ b/common/action.h @@ -162,25 +162,34 @@ bool waiting_buffer_has_anykey_pressed(void); * * 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) @@ -210,6 +219,7 @@ enum action_kind_id { ACT_LAYER = 0b1000, ACT_LAYER_BIT = 0b1001, + ACT_LAYER_STACK = 0b1011, ACT_MACRO = 0b1100, ACT_COMMAND = 0b1110, @@ -223,20 +233,20 @@ enum action_kind_id { #define ACTION(kind, param) ((kind)<<12 | (param)) #define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F) -/* Key */ +/* + * Key + */ #define ACTION_KEY(key) ACTION(ACT_LMODS, key) /* Mods & key */ #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_RMODS(mods) ACTION(ACT_RMODS, MODS4(mods)<<8 | 0x00) #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_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_KEY(mod, key) ACTION(ACT_RMODS, MODS4(MOD_BIT(mod))<<8 | (key)) - -/* Mods + Tap key */ +/* Tap key */ enum mods_codes { 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_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) -/* Mod + Tap 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_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 { LAYER_MOMENTARY = 0, LAYER_ON_PRESS = 1, LAYER_ON_RELEASE = 2, - LAYER_DEFAULT =3, + LAYER_ON_BOTH =3, 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 -/* 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) -/* 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) -/* set layer on press and none on release */ #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) -/* set 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) -/* 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_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) -/* 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) -/* bit-xor 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) -/* 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 { PAGE_SYSTEM, PAGE_CONSUMER