Add layer stack
This commit is contained in:
tmk
parent
9874bf168a
commit
e9de2f1663
259
common/action.c
259
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;
|
||||
|
||||
133
common/action.h
133
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
|
||||
|
||||
Reference in New Issue
Block a user