void process_action(keyrecord_t *record)
{
keyevent_t event = record->event;
+#ifndef NO_ACTION_TAPPING
uint8_t tap_count = record->tap.count;
+#endif
if (IS_NOEVENT(event)) { return; }
action_t action = layer_switch_get_action(event.key);
debug("ACTION: "); debug_action(action);
- debug(" keymaps: "); keymap_debug();
- debug(" default_layer: "); debug_dec(default_layer); debug("\n");
+#ifndef NO_ACTION_LAYER
+ debug(" layer_state: "); layer_debug();
+ debug(" default_layer_state: "); default_layer_debug();
+#endif
+ debug("\n");
switch (action.kind.id) {
/* Key and Mods */
{
uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods :
action.key.mods<<4;
- switch (action.layer.code) {
+ switch (action.layer_tap.code) {
#ifndef NO_ACTION_ONESHOT
case 0x00:
// Oneshot modifier
#endif
#ifndef NO_ACTION_LAYER
case ACT_LAYER:
- case ACT_LAYER1:
- switch (action.layer.code) {
- /* Keymap clear */
- case OP_RESET:
- switch (action.layer.val & 0x03) {
- case 0:
- // NOTE: reserved
- keymap_clear();
- break;
- case ON_PRESS:
- if (event.pressed) {
- keymap_clear();
- }
- break;
- case ON_RELEASE:
- if (!event.pressed) {
- keymap_clear();
- }
- break;
- case ON_BOTH:
- keymap_clear();
- break;
- /* NOTE: 4-7 rserved */
+ if (action.layer_bitop.on == 0) {
+ /* Default Layer Bitwise Operation */
+ if (!event.pressed) {
+ uint8_t shift = action.layer_bitop.part*4;
+ uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
+ uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
+ switch (action.layer_bitop.op) {
+ case OP_BIT_AND: default_layer_and(bits | mask); break;
+ case OP_BIT_OR: default_layer_or(bits | mask); break;
+ case OP_BIT_XOR: default_layer_xor(bits | mask); break;
+ case OP_BIT_SET: default_layer_and(mask); default_layer_or(bits); break;
}
- break;
- /* Keymap Reset default layer */
- case (OP_RESET | ON_PRESS):
- if (event.pressed) {
- default_layer_set(action.layer.val);
- }
- break;
- case (OP_RESET | ON_RELEASE):
- if (!event.pressed) {
- default_layer_set(action.layer.val);
+ }
+ } else {
+ /* Layer Bitwise Operation */
+ if (event.pressed ? (action.layer_bitop.on & ON_PRESS) :
+ (action.layer_bitop.on & ON_RELEASE)) {
+ uint8_t shift = action.layer_bitop.part*4;
+ uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
+ uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
+ switch (action.layer_bitop.op) {
+ case OP_BIT_AND: layer_and(bits | mask); break;
+ case OP_BIT_OR: layer_or(bits | mask); break;
+ case OP_BIT_XOR: layer_xor(bits | mask); break;
+ case OP_BIT_SET: layer_and(mask); layer_or(bits); break;
}
- break;
- case (OP_RESET | ON_BOTH):
- default_layer_set(action.layer.val);
- break;
-
- /* Keymap Bit invert */
- case OP_INV:
- /* with tap toggle */
+ }
+ }
+ break;
+ #ifndef NO_ACTION_TAPPING
+ case ACT_LAYER_TAP:
+ case ACT_LAYER_TAP1:
+ switch (action.layer_tap.code) {
+ case OP_TAP_TOGGLE:
+ /* tap toggle */
if (event.pressed) {
if (tap_count < TAPPING_TOGGLE) {
- debug("KEYMAP_INV: tap toggle(press).\n");
- keymap_invert(action.layer.val);
+ layer_invert(action.layer_tap.val);
}
} else {
if (tap_count <= TAPPING_TOGGLE) {
- debug("KEYMAP_INV: tap toggle(release).\n");
- keymap_invert(action.layer.val);
+ layer_invert(action.layer_tap.val);
}
}
break;
- case (OP_INV | ON_PRESS):
- if (event.pressed) {
- keymap_invert(action.layer.val);
- }
+ case OP_ON_OFF:
+ event.pressed ? layer_on(action.layer_tap.val) :
+ layer_off(action.layer_tap.val);
break;
- case (OP_INV | ON_RELEASE):
- if (!event.pressed) {
- keymap_invert(action.layer.val);
- }
+ case OP_OFF_ON:
+ event.pressed ? layer_off(action.layer_tap.val) :
+ layer_on(action.layer_tap.val);
break;
- case (OP_INV | ON_BOTH):
- keymap_invert(action.layer.val);
+ case OP_SET_CLEAR:
+ event.pressed ? layer_move(action.layer_tap.val) :
+ layer_clear();
break;
-
- /* Keymap Bit on */
- case OP_ON:
- if (event.pressed) {
- keymap_on(action.layer.val);
- } else {
- keymap_off(action.layer.val);
- }
- break;
- case (OP_ON | ON_PRESS):
- if (event.pressed) {
- keymap_on(action.layer.val);
- }
- break;
- case (OP_ON | ON_RELEASE):
- if (!event.pressed) {
- keymap_on(action.layer.val);
- }
- break;
- case (OP_ON | ON_BOTH):
- keymap_on(action.layer.val);
- break;
-
- /* Keymap Bit off */
- case OP_OFF:
- if (event.pressed) {
- keymap_off(action.layer.val);
- } else {
- keymap_on(action.layer.val);
- }
- break;
- case (OP_OFF | ON_PRESS):
- if (event.pressed) {
- keymap_off(action.layer.val);
- }
- break;
- case (OP_OFF | ON_RELEASE):
- if (!event.pressed) {
- keymap_off(action.layer.val);
- }
- break;
- case (OP_OFF | ON_BOTH):
- keymap_off(action.layer.val);
- break;
-
- /* Keymap Bit set */
- case OP_SET:
- if (event.pressed) {
- keymap_set(action.layer.val);
- } else {
- keymap_clear();
- }
- break;
- case (OP_SET | ON_PRESS):
- if (event.pressed) {
- keymap_set(action.layer.val);
- }
- break;
- case (OP_SET | ON_RELEASE):
- if (!event.pressed) {
- keymap_set(action.layer.val);
- }
- break;
- case (OP_SET | ON_BOTH):
- keymap_set(action.layer.val);
- break;
-
- /* Keymap Bit invert with tap key */
default:
+ /* tap key */
if (event.pressed) {
if (tap_count > 0) {
debug("KEYMAP_TAP_KEY: Tap: register_code\n");
- register_code(action.layer.code);
+ register_code(action.layer_tap.code);
} else {
debug("KEYMAP_TAP_KEY: No tap: On on press\n");
- keymap_on(action.layer.val);
+ layer_on(action.layer_tap.val);
}
} else {
if (tap_count > 0) {
debug("KEYMAP_TAP_KEY: Tap: unregister_code\n");
- unregister_code(action.layer.code);
+ unregister_code(action.layer_tap.code);
} else {
debug("KEYMAP_TAP_KEY: No tap: Off on release\n");
- keymap_off(action.layer.val);
+ layer_off(action.layer_tap.val);
}
}
break;
}
break;
+ #endif
#endif
/* Extentions */
#ifndef NO_ACTION_MACRO
switch (action.kind.id) {
case ACT_LMODS_TAP:
case ACT_RMODS_TAP:
+ case ACT_LAYER_TAP:
+ case ACT_LAYER_TAP1:
return true;
- case ACT_LAYER:
- switch (action.layer.code) {
- case 0x04 ... 0xEF: /* tap key */
- case OP_INV:
- return true;
- default:
- return false;
- }
case ACT_MACRO:
case ACT_FUNCTION:
if (action.func.opt & FUNC_TAP) { return true; }
case ACT_USAGE: debug("ACT_USAGE"); break;
case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break;
case ACT_LAYER: debug("ACT_LAYER"); break;
- case ACT_LAYER_BITOP: debug("ACT_LAYER_BITOP"); break;
+ case ACT_LAYER_TAP: debug("ACT_LAYER_TAP"); break;
+ case ACT_LAYER_TAP1: debug("ACT_LAYER_TAP1"); break;
case ACT_MACRO: debug("ACT_MACRO"); break;
case ACT_COMMAND: debug("ACT_COMMAND"); break;
case ACT_FUNCTION: debug("ACT_FUNCTION"); break;
uint8_t mods :4;
uint8_t kind :4;
} key;
- struct action_layer {
+ struct action_layer_bitop {
+ uint8_t bits :4;
+ uint8_t xbit :1;
+ uint8_t part :3;
+ uint8_t on :2;
+ uint8_t op :2;
+ uint8_t kind :4;
+ } layer_bitop;
+ struct action_layer_tap {
uint8_t code :8;
uint8_t val :5;
uint8_t kind :3;
- } layer;
+ } layer_tap;
struct action_usage {
uint16_t code :10;
uint8_t page :2;
*
* Layer Actions(10XX)
* -------------------
- * ACT_LAYER:
- * 1000|--xx|0000 0000 Clear keyamp
- * 100X|LLLL|0000 00xx Reset default layer and clear keymap
- * 100X|LLLL| keycode Invert with tap key
- * 100X|LLLL|1111 0000 Invert with tap toggle
- * 100X|LLLL|1111 00xx Invert[^= 1<<L]
- * 100X|LLLL|1111 0100 On/Off
- * 100X|LLLL|1111 01xx On[|= 1<<L]
- * 100X|LLLL|1111 1000 Off/On
- * 100X|LLLL|1111 10xx Off[&= ~(1<<L)]
- * 100X|LLLL|1111 1100 Set/Clear
- * 100X|LLLL|1111 11xx Set[= 1<<L]
- * XLLLL: Layer 0-31
- * xx: On {00:for special use, 01:press, 10:release, 11:both}
+ * ACT_LAYER:
+ * 1000|oo00|pppx BBBB Default Layer Bitwise operation
+ * oo: operation(00:AND, 01:OR, 10:XOR, 11:SET)
+ * ppp: 4-bit chunk part(0-7)
+ * xBBBB: bits and extra bit
+ * 1000|ooee|pppx BBBB Layer Bitwise Operation
+ * oo: operation(00:AND, 01:OR, 10:XOR, 11:SET)
+ * ppp: 4-bit chunk part(0-7)
+ * xBBBB: bits and extra bit
+ * ee: on event(00:default layer, 01:press, 10:release, 11:both)
+ *
+ * ACT_LAYER_TAP:
+ * 101x|LLLL| keycode Invert with tap key
+ * 101x|LLLL|1110 xxxx Reserved(0xE0-EF)
+ * 101x|LLLL|1111 0000 Invert with tap toggle(0xF0)
+ * 101x|LLLL|1111 0001 On Off
+ * 101x|LLLL|1111 0010 Off On
+ * 101x|LLLL|1111 0011 Set Clear
+ * 101x|LLLL|1111 xxxx Reserved(0xF4-FF)
+ * xLLLL: layer(0-31)
*
- * ACT_LAYER_BITOP:
- * 101B|Booo|xxxx xxxx bit operation
- * BB: operand. which part of layer state bits
- * 00: 0-7th bit
- * 01: 8-15th bit
- * 10: 16-23th bit
- * 11: 24-31th bit
- * ooo: operation.
- * 000: AND
- * 001: OR
- * 010: XOR
- * 011:
- * 100: LSHIFT
- * 101: RSHIFT
- * 110:
- * 111:
- * bbbb bbbb: bits
- * layer_state |= (((layer_state>>(0bBB*8)) & 0xff) BITOP 0bxxxxxxxx)<<(0bBB*8)
- * layer_state: 32-bit layer switch state
*
*
*
ACT_MOUSEKEY = 0b0101,
ACT_LAYER = 0b1000,
- ACT_LAYER1 = 0b1001,
- ACT_LAYER_BITOP = 0b1010,
- ACT_LAYER1_BITOP = 0b1011,
+ ACT_LAYER_TAP = 0b1010,
+ ACT_LAYER_TAP1 = 0b1011,
ACT_MACRO = 0b1100,
ACT_COMMAND = 0b1110,
-/* Layer Actions:
- * Invert layer ^= (1<<layer)
- * On layer |= (1<<layer)
- * Off layer &= ~(1<<layer)
- * Set layer = (1<<layer)
- * Clear layer = 0
- */
+/* Layer Actions */
enum layer_param_on {
ON_PRESS = 1,
ON_RELEASE = 2,
ON_BOTH = 3,
};
-enum layer_pram_op {
- OP_RESET = 0x00,
- OP_INV4 = 0x00,
- OP_INV = 0xF0,
- OP_ON = 0xF4,
- OP_OFF = 0xF8,
- OP_SET = 0xFC,
+enum layer_param_op {
+ OP_DEFAULT_LAYER = 0,
};
-enum layer_pram_bitop {
- BITOP_AND,
- BITOP_OR,
- BITOP_XOR,
- BITOP_LSHIFT,
- BITOP_RSHIFT,
+enum layer_param_bit_op {
+ OP_BIT_AND = 0,
+ OP_BIT_OR,
+ OP_BIT_XOR,
+ OP_BIT_SET,
};
-/*
- * Default Layer
- */
-#define ACTION_DEFAULT_LAYER ACTION(ACT_LAYER, ON_RELEASE<<8 | OP_RESET | 0)
-#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_TO(layer, ON_RELEASE)
-#define ACTION_DEFAULT_LAYER_TO(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_RESET | (on))
+enum layer_pram_tap_op {
+ OP_TAP_TOGGLE = 0xF0,
+ OP_ON_OFF,
+ OP_OFF_ON,
+ OP_SET_CLEAR,
+};
-/*
- * Keymap Layer
- */
+/* Layer Operation 1000|ee00|ooov vvvv */
+#define ACTION_LAYER(op, val, on) (ACT_LAYER<<12 | (on)<<10 | (op)<<5 | val)
+/* Layer Bitwise Operation 1000|ooee|pppx BBBB */
+#define ACTION_LAYER_BITOP(op, part, bits, on) (ACT_LAYER<<12 | (op)<<10 | (on)<<8 | (part)<<5 | (bits)&0x1f)
+/* Layer with Tapping 101x|LLLL| keycode */
+#define ACTION_LAYER_TAP(layer, key) (ACT_LAYER_TAP<<12 | (layer)<<8 | (key))
+
+/* Default Layer Operation */
+#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER(layer, ON_RELEASE)
+#define ACTION_DEFAULT_LAYER(layer, on) ACTION_LAYER(OP_DEFAULT_LAYER, layer, on)
+/* Layer Operation */
+#define ACTION_LAYER_CLEAR(on) ACTION_LAYER_AND(0x1f, (on))
#define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer)
-#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INV(layer, ON_RELEASE)
-/* Keymap Invert */
-#define ACTION_LAYER_INV(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_INV | (on))
-#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_INV | 0)
-/* Keymap On */
-#define ACTION_LAYER_ON(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_ON | (on))
-#define ACTION_LAYER_ON_OFF(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_ON | 0)
-/* Keymap Off */
-#define ACTION_LAYER_OFF(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_OFF | (on))
-#define ACTION_LAYER_OFF_ON(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_OFF | 0)
-/* Keymap Set */
-#define ACTION_LAYER_SET(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_SET | (on))
-#define ACTION_LAYER_SET_CLEAR(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_SET | 0)
-/* Keymap Invert with tap key */
-#define ACTION_LAYER_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
-
-/* Layer BitOp: 101|BB|ooo|xxxxxxxx */
-#define ACTION_LAYER_BITOP(op, part, bits) (ACT_LAYER_BITOP<<12 | (part&0x3)<<11 | (op&0x7)<<8 | bits)
-#define ACTION_LAYER_AND(part, bits) ACTION_LAYER_BITOP(BITOP_AND, part, bits)
-#define ACTION_LAYER_OR(part, bits) ACTION_LAYER_BITOP(BITOP_OR, part, bits)
-#define ACTION_LAYER_XOR(part, bits) ACTION_LAYER_BITOP(BITOP_XOR, part, bits)
-#define ACTION_LAYER_LSHIFT(part, bits) ACTION_LAYER_BITOP(BITOP_LSHIFT, part, bits)
-#define ACTION_LAYER_RSHIFT(part, bits) ACTION_LAYER_BITOP(BITOP_RSHIFT, part, bits)
-
+#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INVERT(layer, ON_RELEASE)
+#define ACTION_LAYER_INVERT(layer, on) ACTION_LAYER_BIT_XOR((layer)/4, 1<<((layer)%4), (on))
+#define ACTION_LAYER_ON(layer, on) ACTION_LAYER_BIT_OR((layer)/4, 1<<((layer)%4), (on))
+#define ACTION_LAYER_OFF(layer, on) ACTION_LAYER_BIT_AND((layer)/4, ~(1<<((layer)%4)), (on))
+#define ACTION_LAYER_SET(layer, on) ACTION_LAYER_BIT_SET((layer)/4, 1<<((layer)%4), (on))
+#define ACTION_LAYER_ON_OFF(layer) ACTION_LAYER_TAP((layer), OP_ON_OFF)
+#define ACTION_LAYER_OFF_ON(layer) ACTION_LAYER_TAP((layer), OP_OFF_ON)
+#define ACTION_LAYER_SET_CLEAR(layer) ACTION_LAYER_TAP((layer), OP_SET_CLEAR)
+/* Bitwise Operation */
+#define ACTION_LAYER_BIT_AND(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_AND, part, bits)
+#define ACTION_LAYER_BIT_OR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_OR, part, bits)
+#define ACTION_LAYER_BIT_XOR(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_XOR, part, bits)
+#define ACTION_LAYER_BIT_SET(part, bits, on) ACTION_LAYER_BITOP(OP_BIT_SET, part, bits)
+/* with Tapping */
+#define ACTION_LAYER_TAP_KEY(layer, key) ACTION_LAYER_TAP((layer), (key))
+#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION_LAYER_TAP((layer), OP_TAP_TOGGLE)
+
/*
* Extensions
#define ACTION_TAPPING_H
-#ifndef NO_ACTION_TAPPING
/* period of tapping(ms) */
#ifndef TAPPING_TERM
#define WAITING_BUFFER_SIZE 8
+#ifndef NO_ACTION_TAPPING
void action_tapping_process(keyrecord_t record);
-
#endif
#endif
static void switch_default_layer(uint8_t layer)
{
- print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
+ print("switch_default_layer: "); print_dec(biton32(default_layer_state));
default_layer_set(layer);
+ print(" to "); print_dec(biton32(default_layer_state)); print("\n");
clear_keyboard();
}
/*
- * Default Layer (0-15)
+ * Default Layer State
*/
-uint8_t default_layer = 0;
+uint32_t default_layer_state = 0;
-void default_layer_set(uint8_t layer)
+static void default_layer_state_set(uint32_t state)
{
- debug("default_layer_set: ");
- debug_dec(default_layer); debug(" to ");
-
- default_layer = layer;
-
- debug_dec(default_layer); debug("\n");
-
+ debug("default_layer_state: ");
+ default_layer_debug(); debug(" to ");
+ default_layer_state = state;
+ default_layer_debug(); debug("\n");
clear_keyboard_but_mods(); // To avoid stuck keys
}
-
-#ifndef NO_ACTION_LAYER
-/*
- * Keymap Layer (0-15)
- */
-uint16_t keymap_stat = 0;
-
-/* return highest layer whose state is on */
-uint8_t keymap_get_layer(void)
+void default_layer_debug(void)
{
- return biton16(keymap_stat);
+ debug_hex32(default_layer_state);
+ debug("("); debug_dec(biton32(default_layer_state)); debug(")");
}
-static void keymap_stat_set(uint16_t stat)
+void default_layer_set(uint8_t layer)
{
- debug("keymap: ");
- keymap_debug(); debug(" to ");
+ default_layer_state_set(1UL<<layer);
+}
- keymap_stat = stat;
+#ifndef NO_ACTION_LAYER
+void default_layer_or(uint32_t state)
+{
+ default_layer_state_set(default_layer_state | state);
+}
+void default_layer_and(uint32_t state)
+{
+ default_layer_state_set(default_layer_state & state);
+}
+void default_layer_xor(uint32_t state)
+{
+ default_layer_state_set(default_layer_state ^ state);
+}
+#endif
- keymap_debug(); debug("\n");
- clear_keyboard_but_mods(); // To avoid stuck keys
-}
+#ifndef NO_ACTION_LAYER
+/*
+ * Keymap Layer State
+ */
+uint32_t layer_state = 0;
-void keymap_clear(void)
+static void layer_state_set(uint32_t state)
{
- keymap_stat_set(0);
+ debug("layer_state: ");
+ layer_debug(); debug(" to ");
+ layer_state = state;
+ layer_debug(); debug("\n");
+ clear_keyboard_but_mods(); // To avoid stuck keys
}
-
-void keymap_set(uint16_t stat)
+void layer_clear(void)
{
- keymap_stat_set(stat);
+ layer_state_set(0);
}
-void keymap_move(uint8_t layer)
+void layer_move(uint8_t layer)
{
- keymap_stat_set(1<<layer);
+ layer_state_set(1UL<<layer);
}
-void keymap_on(uint8_t layer)
+void layer_on(uint8_t layer)
{
- keymap_stat_set(keymap_stat | (1<<layer));
+ layer_state_set(layer_state | (1UL<<layer));
}
-void keymap_off(uint8_t layer)
+void layer_off(uint8_t layer)
{
- keymap_stat_set(keymap_stat & ~(1<<layer));
+ layer_state_set(layer_state & ~(1UL<<layer));
}
-void keymap_invert(uint8_t layer)
+void layer_invert(uint8_t layer)
{
- keymap_stat_set(keymap_stat ^ (1<<layer));
+ layer_state_set(layer_state ^ (1UL<<layer));
}
-void keymap_or(uint16_t stat)
+void layer_or(uint32_t state)
{
- keymap_stat_set(keymap_stat | stat);
+ layer_state_set(layer_state | state);
}
-void keymap_and(uint16_t stat)
+void layer_and(uint32_t state)
{
- keymap_stat_set(keymap_stat & stat);
+ layer_state_set(layer_state & state);
}
-void keymap_xor(uint16_t stat)
+void layer_xor(uint32_t state)
{
- keymap_stat_set(keymap_stat ^ stat);
+ layer_state_set(layer_state ^ state);
}
-void keymap_debug(void)
+void layer_debug(void)
{
- debug_hex16(keymap_stat); debug("("); debug_dec(keymap_get_layer()); debug(")");
+ debug_hex32(layer_state);
+ debug("("); debug_dec(biton32(layer_state)); debug(")");
}
#endif
action.code = ACTION_TRANSPARENT;
#ifndef NO_ACTION_LAYER
- /* keymap: top layer first */
- for (int8_t i = 15; i >= 0; i--) {
- if (keymap_stat & (1<<i)) {
+ uint32_t layers = layer_state | default_layer_state;
+ /* check top layer first */
+ for (int8_t i = 31; i >= 0; i--) {
+ if (layers & (1UL<<i)) {
action = action_for_key(i, key);
if (action.code != ACTION_TRANSPARENT) {
return action;
}
}
}
-#endif
-
- /* default layer */
- action = action_for_key(default_layer, key);
+ /* fall back to layer 0 */
+ action = action_for_key(0, key);
+ return action;
+#else
+ action = action_for_key(biton32(default_layer_state), key);
return action;
+#endif
}
/*
* Default Layer
*/
-/* base layer to fall back */
-extern uint8_t default_layer;
+extern uint32_t default_layer_state;
+void default_layer_debug(void);
void default_layer_set(uint8_t layer);
+#ifndef NO_ACTION_LAYER
+/* bitwise operation */
+void default_layer_or(uint32_t state);
+void default_layer_and(uint32_t state);
+void default_layer_xor(uint32_t state);
+#else
+#define default_layer_or(state)
+#define default_layer_and(state)
+#define default_layer_xor(state)
+#endif
+
/*
* Keymap Layer
*/
#ifndef NO_ACTION_LAYER
-extern uint16_t keymap_stat;
-/* return current active layer */
-uint8_t keymap_get_layer(void);
-void keymap_clear(void);
-void keymap_set(uint16_t stat);
-void keymap_move(uint8_t layer);
-void keymap_on(uint8_t layer);
-void keymap_off(uint8_t layer);
-void keymap_invert(uint8_t layer);
+extern uint32_t layer_state;
+void layer_debug(void);
+void layer_clear(void);
+void layer_move(uint8_t layer);
+void layer_on(uint8_t layer);
+void layer_off(uint8_t layer);
+void layer_invert(uint8_t layer);
/* bitwise operation */
-void keymap_or(uint16_t stat);
-void keymap_and(uint16_t stat);
-void keymap_xor(uint16_t stat);
-void keymap_debug(void);
+void layer_or(uint32_t state);
+void layer_and(uint32_t state);
+void layer_xor(uint32_t state);
#else
-#define keymap_stat 0
-#define keymap_get_layer()
-#define keymap_clear()
-#define keymap_set(stat)
-#define keymap_move(layer)
-#define keymap_on(layer)
-#define keymap_off(layer)
-#define keymap_invert(layer)
-#define keymap_or(stat)
-#define keymap_and(stat)
-#define keymap_xor(stat)
-#define keymap_debug()
+#define layer_state 0
+#define layer_clear()
+#define layer_move(layer)
+#define layer_on(layer)
+#define layer_off(layer)
+#define layer_invert(layer)
+
+#define layer_or(state)
+#define layer_and(state)
+#define layer_xor(state)
+#define layer_debug()
#endif
return c;
}
+uint8_t bitpop32(uint32_t bits)
+{
+ uint8_t c;
+ for (c = 0; bits; c++)
+ bits &= bits - 1;
+ return c;
+}
+
// most significant on-bit - return highest location of on-bit
// NOTE: return 0 when bit0 is on or all bits are off
uint8_t biton(uint8_t bits)
if (bits >> 1) { bits >>= 1; n += 1;}
return n;
}
+
+uint8_t biton32(uint32_t bits)
+{
+ uint8_t n = 0;
+ if (bits >>16) { bits >>=16; n +=16;}
+ if (bits >> 8) { bits >>= 8; n += 8;}
+ if (bits >> 4) { bits >>= 4; n += 4;}
+ if (bits >> 2) { bits >>= 2; n += 2;}
+ if (bits >> 1) { bits >>= 1; n += 1;}
+ return n;
+}
uint8_t bitpop(uint8_t bits);
uint8_t bitpop16(uint16_t bits);
+uint8_t bitpop32(uint32_t bits);
+
uint8_t biton(uint8_t bits);
uint8_t biton16(uint16_t bits);
+uint8_t biton32(uint32_t bits);
#endif
projects / tmk_firmware.git / commitdiff