action_t action = layer_switch_get_action(event.key);
debug("ACTION: "); debug_action(action);
- debug(" overlays: "); overlay_debug();
debug(" keymaps: "); keymap_debug();
debug(" default_layer: "); debug_dec(default_layer); debug("\n");
}
break;
#endif
-#ifndef NO_ACTION_KEYMAP
- case ACT_KEYMAP:
+#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
- overlay_clear();
keymap_clear();
break;
case ON_PRESS:
if (event.pressed) {
- overlay_clear();
keymap_clear();
}
break;
case ON_RELEASE:
if (!event.pressed) {
- overlay_clear();
keymap_clear();
}
break;
case ON_BOTH:
- overlay_clear();
keymap_clear();
break;
/* NOTE: 4-7 rserved */
break;
}
break;
-#endif
-#ifndef NO_ACTION_OVERLAY
- case ACT_OVERLAY:
- switch (action.layer.code) {
- // Overlay Invert bit4
- case OP_INV4 | 0:
- if (action.layer.val == 0) {
- // NOTE: reserved for future use
- overlay_clear();
- } else {
- overlay_set(overlay_stat ^ action.layer.val);
- }
- break;
- case OP_INV4 | 1:
- if (action.layer.val == 0) {
- // on pressed
- if (event.pressed) overlay_clear();
- } else {
- overlay_set(overlay_stat ^ action.layer.val<<4);
- }
- break;
- case OP_INV4 | 2:
- if (action.layer.val == 0) {
- // on released
- if (!event.pressed) overlay_clear();
- } else {
- overlay_set(overlay_stat ^ action.layer.val<<8);
- }
- break;
- case OP_INV4 | 3:
- if (action.layer.val == 0) {
- // on both
- overlay_clear();
- } else {
- overlay_set(overlay_stat ^ action.layer.val<<12);
- }
- break;
-
- /* Overlay Bit invert */
- case OP_INV:
- /* with tap toggle */
- if (event.pressed) {
- if (tap_count < TAPPING_TOGGLE) {
- debug("OVERLAY_INV: tap toggle(press).\n");
- overlay_invert(action.layer.val);
- }
- } else {
- if (tap_count <= TAPPING_TOGGLE) {
- debug("OVERLAY_INV: tap toggle(release).\n");
- overlay_invert(action.layer.val);
- }
- }
- break;
- case (OP_INV | ON_PRESS):
- if (event.pressed) {
- overlay_invert(action.layer.val);
- }
- break;
- case (OP_INV | ON_RELEASE):
- if (!event.pressed) {
- overlay_invert(action.layer.val);
- }
- break;
- case (OP_INV | ON_BOTH):
- overlay_invert(action.layer.val);
- break;
-
- /* Overlay Bit on */
- case OP_ON:
- if (event.pressed) {
- overlay_on(action.layer.val);
- } else {
- overlay_off(action.layer.val);
- }
- break;
- case (OP_ON | ON_PRESS):
- if (event.pressed) {
- overlay_on(action.layer.val);
- }
- break;
- case (OP_ON | ON_RELEASE):
- if (!event.pressed) {
- overlay_on(action.layer.val);
- }
- break;
- case (OP_ON | ON_BOTH):
- overlay_on(action.layer.val);
- break;
-
- /* Overlay Bit off */
- case OP_OFF:
- if (event.pressed) {
- overlay_off(action.layer.val);
- } else {
- overlay_on(action.layer.val);
- }
- break;
- case (OP_OFF | ON_PRESS):
- if (event.pressed) {
- overlay_off(action.layer.val);
- }
- break;
- case (OP_OFF | ON_RELEASE):
- if (!event.pressed) {
- overlay_off(action.layer.val);
- }
- break;
- case (OP_OFF | ON_BOTH):
- overlay_off(action.layer.val);
- break;
-
- /* Overlay Bit set */
- case OP_SET:
- if (event.pressed) {
- overlay_move(action.layer.val);
- } else {
- overlay_clear();
- }
- break;
- case (OP_SET | ON_PRESS):
- if (event.pressed) {
- overlay_move(action.layer.val);
- }
- break;
- case (OP_SET | ON_RELEASE):
- if (!event.pressed) {
- overlay_move(action.layer.val);
- }
- break;
- case (OP_SET | ON_BOTH):
- overlay_move(action.layer.val);
- break;
-
- /* Overlay Bit invert with tap key */
- default:
- if (event.pressed) {
- if (tap_count > 0) {
- debug("OVERLAY_TAP_KEY: Tap: register_code\n");
- register_code(action.layer.code);
- } else {
- debug("OVERLAY_TAP_KEY: No tap: On on press\n");
- overlay_on(action.layer.val);
- }
- } else {
- if (tap_count > 0) {
- debug("OVERLAY_TAP_KEY: Tap: unregister_code\n");
- unregister_code(action.layer.code);
- } else {
- debug("OVERLAY_TAP_KEY: No tap: Off on release\n");
- overlay_off(action.layer.val);
- }
- }
- break;
- }
- break;
#endif
/* Extentions */
#ifndef NO_ACTION_MACRO
case ACT_LMODS_TAP:
case ACT_RMODS_TAP:
return true;
- case ACT_KEYMAP:
- case ACT_OVERLAY:
+ case ACT_LAYER:
switch (action.layer.code) {
case 0x04 ... 0xEF: /* tap key */
case OP_INV:
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_KEYMAP: debug("ACT_KEYMAP"); break;
- case ACT_OVERLAY: debug("ACT_OVERLAY"); break;
+ case ACT_LAYER: debug("ACT_LAYER"); break;
+ case ACT_LAYER_BITOP: debug("ACT_LAYER_BITOP"); break;
case ACT_MACRO: debug("ACT_MACRO"); break;
case ACT_COMMAND: debug("ACT_COMMAND"); break;
case ACT_FUNCTION: debug("ACT_FUNCTION"); break;
} key;
struct action_layer {
uint8_t code :8;
- uint8_t val :4;
- uint8_t kind :4;
+ uint8_t val :5;
+ uint8_t kind :3;
} layer;
struct action_usage {
uint16_t code :10;
*
* Layer Actions(10XX)
* -------------------
- * ACT_KEYMAP:
- * 1000|--xx|0000 0000 Clear keyamp and overlay
- * 1000|LLLL|0000 00xx Reset default layer and clear keymap and overlay
- * 1000|LLLL| keycode Invert with tap key
- * 1000|LLLL|1111 0000 Invert with tap toggle
- * 1000|LLLL|1111 00xx Invert[^= 1<<L]
- * 1000|LLLL|1111 0100 On/Off
- * 1000|LLLL|1111 01xx On[|= 1<<L]
- * 1000|LLLL|1111 1000 Off/On
- * 1000|LLLL|1111 10xx Off[&= ~(1<<L)]
- * 1000|LLLL|1111 1100 Set/Clear
- * 1000|LLLL|1111 11xx Set[= 1<<L]
- * default layer: 0-15(4bit)
+ * 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_OVERLAY:
- * 1011|0000|0000 0000 Clear overlay
- * 1011|LLLL|0000 00ss Invert 4-bit chunk [^= L<<(4*ss)]
- * 1011|LLLL| keycode Invert with tap key
- * 1011|LLLL|1111 0000 Invert with tap toggle
- * 1011|LLLL|1111 00xx Invert[^= 1<<L]
- * 1011|LLLL|1111 0100 On/Off(momentary)
- * 1011|LLLL|1111 01xx On[|= 1<<L]
- * 1011|LLLL|1111 1000 Off/On
- * 1011|LLLL|1111 10xx Off[&= ~(1<<L)]
- * 1011|LLLL|1111 1100 Set/Clear
- * 1011|LLLL|1111 11xx Set[= 1<<L]
- * overlays: 16-layer on/off status(16bit)
- * xx: On {00:for special use, 01:press, 10:release, 11:both}
+ * 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
+ *
+ *
*
*
* Extensions(11XX)
*
*/
enum action_kind_id {
+ ACT_MODS = 0b0000,
ACT_LMODS = 0b0000,
ACT_RMODS = 0b0001,
+ ACT_MODS_TAP = 0b0010,
ACT_LMODS_TAP = 0b0010,
ACT_RMODS_TAP = 0b0011,
ACT_USAGE = 0b0100,
ACT_MOUSEKEY = 0b0101,
- ACT_KEYMAP = 0b1000,
- ACT_OVERLAY = 0b1001,
+ ACT_LAYER = 0b1000,
+ ACT_LAYER1 = 0b1001,
+ ACT_LAYER_BITOP = 0b1010,
+ ACT_LAYER1_BITOP = 0b1011,
ACT_MACRO = 0b1100,
ACT_COMMAND = 0b1110,
* Set layer = (1<<layer)
* Clear layer = 0
*/
-enum layer_params {
+enum layer_param_on {
ON_PRESS = 1,
ON_RELEASE = 2,
ON_BOTH = 3,
+};
- OP_RESET = 0x00,
+enum layer_pram_op {
+ OP_RESET = 0x00,
OP_INV4 = 0x00,
OP_INV = 0xF0,
OP_ON = 0xF4,
OP_SET = 0xFC,
};
+enum layer_pram_bitop {
+ BITOP_AND,
+ BITOP_OR,
+ BITOP_XOR,
+ BITOP_LSHIFT,
+ BITOP_RSHIFT,
+};
+
/*
* Default Layer
*/
-#define ACTION_DEFAULT_LAYER ACTION(ACT_KEYMAP, ON_RELEASE<<8 | OP_RESET | 0)
+#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_KEYMAP, (layer)<<8 | OP_RESET | (on))
+#define ACTION_DEFAULT_LAYER_TO(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_RESET | (on))
+
/*
* Keymap Layer
*/
-#define ACTION_KEYMAP_MOMENTARY(layer) ACTION_KEYMAP_ON_OFF(layer)
-#define ACTION_KEYMAP_TOGGLE(layer) ACTION_KEYMAP_INV(layer, ON_RELEASE)
+#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_KEYMAP_INV(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | (on))
-#define ACTION_KEYMAP_TAP_TOGGLE(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | 0)
+#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_KEYMAP_ON(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | (on))
-#define ACTION_KEYMAP_ON_OFF(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | 0)
+#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_KEYMAP_OFF(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | (on))
-#define ACTION_KEYMAP_OFF_ON(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | 0)
+#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_KEYMAP_SET(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | (on))
-#define ACTION_KEYMAP_SET_CLEAR(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | 0)
+#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_KEYMAP_TAP_KEY(layer, key) ACTION(ACT_KEYMAP, (layer)<<8 | (key))
-
-/*
- * Overlay Layer
- */
-#define ACTION_OVERLAY_MOMENTARY(layer) ACTION_OVERLAY_ON_OFF(layer)
-#define ACTION_OVERLAY_TOGGLE(layer) ACTION_OVERLAY_INV(layer, ON_RELEASE)
-/* Overlay Clear */
-#define ACTION_OVERLAY_CLEAR(on) ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | (on))
-/* Overlay Invert 4-bit chunk */
-#define ACTION_OVERLAY_INV4(bits, shift) ACTION(ACT_OVERLAY, (bits)<<8 | OP_INV4 | shift)
-/* Overlay Invert */
-#define ACTION_OVERLAY_INV(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | (on))
-#define ACTION_OVERLAY_TAP_TOGGLE(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0)
-/* Overlay On */
-#define ACTION_OVERLAY_ON(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | (on))
-#define ACTION_OVERLAY_ON_OFF(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | 0)
-/* Overlay Off */
-#define ACTION_OVERLAY_OFF(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | (on))
-#define ACTION_OVERLAY_OFF_ON(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0)
-/* Overlay Set */
-#define ACTION_OVERLAY_SET(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | (on))
-#define ACTION_OVERLAY_SET_CLEAR(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0)
-/* Overlay Invert with tap key */
-#define ACTION_OVERLAY_TAP_KEY(layer, key) ACTION(ACT_OVERLAY, (layer)<<8 | (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)
+
/*
* Extensions
{
print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
default_layer_set(layer);
- overlay_clear();
clear_keyboard();
}
}
-#ifndef NO_ACTION_KEYMAP
+#ifndef NO_ACTION_LAYER
/*
* Keymap Layer (0-15)
*/
-#ifndef NO_ACTION_OVERLAY
-/*
- * Overlay Layer (16-31 = 0-15|0x10)
- */
-uint16_t overlay_stat = 0;
-
-/* return highest layer whose state is on */
-uint8_t overlay_get_layer(void)
-{
- return biton16(overlay_stat);
-}
-
-static void overlay_stat_set(uint16_t stat)
-{
- debug("overlay: ");
- overlay_debug(); debug(" to ");
-
- overlay_stat = stat;
-
- overlay_debug(); debug("\n");
-
- clear_keyboard_but_mods(); // To avoid stuck keys
-}
-
-void overlay_clear(void)
-{
- overlay_stat_set(0);
-}
-
-
-void overlay_set(uint16_t stat)
-{
- overlay_stat_set(stat);
-}
-
-void overlay_move(uint8_t layer)
-{
- overlay_stat_set(1<<layer);
-}
-
-void overlay_on(uint8_t layer)
-{
- overlay_stat_set(overlay_stat | (1<<layer));
-}
-
-void overlay_off(uint8_t layer)
-{
- overlay_stat_set(overlay_stat & ~(1<<layer));
-}
-
-void overlay_invert(uint8_t layer)
-{
- overlay_stat_set(overlay_stat ^ (1<<layer));
-}
-
-void overlay_or(uint16_t stat)
-{
- overlay_stat_set(overlay_stat | stat);
-}
-void overlay_and(uint16_t stat)
-{
- overlay_stat_set(overlay_stat & stat);
-}
-void overlay_xor(uint16_t stat)
-{
- overlay_stat_set(overlay_stat ^ stat);
-}
-
-void overlay_debug(void)
-{
- debug_hex16(overlay_stat); debug("("); debug_dec(overlay_get_layer()); debug(")");
-}
-#endif
-
action_t layer_switch_get_action(key_t key)
{
action_t action;
action.code = ACTION_TRANSPARENT;
-#ifndef NO_ACTION_OVERLAY
- /* overlay: top layer first */
- for (int8_t i = 15; i >= 0; i--) {
- if (overlay_stat & (1<<i)) {
- action = action_for_key(i | OVERLAY_BIT, key);
- if (action.code != ACTION_TRANSPARENT) {
- return action;
- }
- }
- }
-#endif
-
-#ifndef NO_ACTION_KEYMAP
+#ifndef NO_ACTION_LAYER
/* keymap: top layer first */
for (int8_t i = 15; i >= 0; i--) {
if (keymap_stat & (1<<i)) {
#include "action.h"
-/* overlays are asigned at layer 16-31 */
-#define OVERLAY_BIT 0x10
-#define OVERLAY_MASK 0x0F
-
-
/*
* Default Layer
*/
/*
* Keymap Layer
*/
-#ifndef NO_ACTION_KEYMAP
+#ifndef NO_ACTION_LAYER
extern uint16_t keymap_stat;
/* return current active layer */
uint8_t keymap_get_layer(void);
#endif
-/*
- * Overlay Layer
- */
-#ifndef NO_ACTION_OVERLAY
-extern uint16_t overlay_stat;
-/* return current active layer */
-uint8_t overlay_get_layer(void);
-void overlay_clear(void);
-void overlay_set(uint16_t stat);
-void overlay_move(uint8_t layer);
-void overlay_on(uint8_t layer);
-void overlay_off(uint8_t layer);
-void overlay_invert(uint8_t layer);
-/* bitwise operation */
-void overlay_or(uint16_t stat);
-void overlay_and(uint16_t stat);
-void overlay_xor(uint16_t stat);
-void overlay_debug(void);
-#else
-#define overlay_stat 0
-#define overlay_get_layer()
-#define overlay_clear()
-#define overlay_set(stat)
-#define overlay_move(layer)
-#define overlay_on(layer)
-#define overlay_off(layer)
-#define overlay_invert(layer)
-#define overlay_or(stat)
-#define overlay_and(stat)
-#define overlay_xor(stat)
-#define overlay_debug()
-#endif
-
-
-
/* return action depending on current layer status */
action_t layer_switch_get_action(key_t key);
//#define NO_PRINT
/* disable action features */
-//#define NO_ACTION_KEYMAP
-//#define NO_ACTION_OVERLAY
+//#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT
//#define NO_ACTION_MACRO
ESC, 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, FN2, QUOT, ENT, \
- LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, RSFT, \
+ LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, FN9, \
LCTL,LGUI,LALT, SPC, RALT,FN3, FN3, FN0),
/* Keymap 1: colemak */
KEYMAP_ANSI(
TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS),
};
-static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = {};
-
/*
* Fn action definition
*/
static const uint16_t PROGMEM fn_actions[] = {
- [0] = ACTION_KEYMAP_MOMENTARY(4),
- [1] = ACTION_KEYMAP_TAP_KEY(5, KC_SLASH),
- [2] = ACTION_KEYMAP_TAP_KEY(6, KC_SCLN),
- [3] = ACTION_KEYMAP_MOMENTARY(6),
- [4] = ACTION_KEYMAP_MOMENTARY(7), // to Layout selector
+ [0] = ACTION_LAYER_MOMENTARY(4),
+ [1] = ACTION_LAYER_TAP_KEY(5, KC_SLASH),
+ [2] = ACTION_LAYER_TAP_KEY(6, KC_SCLN),
+ [3] = ACTION_LAYER_MOMENTARY(6),
+ [4] = ACTION_LAYER_MOMENTARY(7), // to Layout selector
[5] = ACTION_DEFAULT_LAYER_SET(0), // set qwerty layout
[6] = ACTION_DEFAULT_LAYER_SET(1), // set colemak layout
[7] = ACTION_DEFAULT_LAYER_SET(2), // set dvorak layout
[8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout
+ [9] = ACTION_RMOD_TAP_KEY(KC_RSFT, KC_GRV),
};
#endif
#define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0]))
-#define OVERLAYS_SIZE (sizeof(overlays) / sizeof(overlays[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))
/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
{
- /* Overlay: 16-31(OVERLAY_BIT(0x10) | overlay_layer) */
- if (layer & OVERLAY_BIT) {
- layer &= OVERLAY_MASK;
- if (layer < OVERLAYS_SIZE) {
- return pgm_read_byte(&overlays[(layer)][(key.row)][(key.col)]);
- } else {
- // XXX: this may cuaes bootlaoder_jump incositent fail.
- //debug("key_to_keycode: overlay "); debug_dec(layer); debug(" is invalid.\n");
- return KC_TRANSPARENT;
- }
- }
- /* Keymap: 0-15 */
- else {
- if (layer < KEYMAPS_SIZE) {
- return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
- } else {
- // XXX: this may cuaes bootlaoder_jump incositent fail.
- //debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n");
- // fall back to layer 0
- return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
- }
+ if (layer < KEYMAPS_SIZE) {
+ return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
+ } else {
+ // XXX: this may cuaes bootlaoder_jump inconsistent fail.
+ //debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n");
+ // fall back to layer 0
+ return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
}
}
//#define NO_PRINT
/* disable action features */
-//#define NO_ACTION_KEYMAP
-//#define NO_ACTION_OVERLAY
+//#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT
//#define NO_ACTION_MACRO
projects / tmk_firmware.git / commitdiff