Nulo/qmk_firmware
1
0
Fork 0
Code Releases Activity

Remove ACT_KEYMAP and ACT_OVERLAY

Browse source 
- Remove ACT_OVERLAY
- Rename ACT_KEYMAP to ACT_LAYER
- Add ACT_LAYER_BITOP
This commit is contained in:
tmk 2013-03-31 22:47:19 +09:00
parent 353a9b56e6
commit 10f33a3e48
8 changed files with 101 additions and 400 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

172
common/action.c
View file

@ -56,7 +56,6 @@ void process_action(keyrecord_t *record)
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");
@ -199,31 +198,28 @@ void process_action(keyrecord_t *record)
}
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 */
@ -361,161 +357,6 @@ void process_action(keyrecord_t *record)
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
@ -668,8 +509,7 @@ bool is_tap_key(key_t key)
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:
@ -714,8 +554,8 @@ 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_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;

146
common/action.h
View file

@ -65,8 +65,8 @@ typedef union {
} 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;
@ -170,35 +170,42 @@ void debug_action(action_t action);
*
* 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)
@ -216,16 +223,20 @@ void debug_action(action_t action);
*
*/
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,
@ -285,12 +296,14 @@ enum usage_pages {
* 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,
@ -298,56 +311,49 @@ enum layer_params {
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

1
common/command.c
View file

@ -575,6 +575,5 @@ static void switch_default_layer(uint8_t layer)
{
print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
default_layer_set(layer);
overlay_clear();
clear_keyboard();
}

90
common/layer_switch.c
View file

@ -24,7 +24,7 @@ void default_layer_set(uint8_t layer)
}
#ifndef NO_ACTION_KEYMAP
#ifndef NO_ACTION_LAYER
/*
* Keymap Layer (0-15)
*/
@ -100,98 +100,12 @@ void keymap_debug(void)
#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)) {

42
common/layer_switch.h
View file

@ -22,11 +22,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "action.h"
/* overlays are asigned at layer 16-31 */
#define OVERLAY_BIT 0x10
#define OVERLAY_MASK 0x0F
/*
* Default Layer
*/
@ -38,7 +33,7 @@ void default_layer_set(uint8_t 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);
@ -69,41 +64,6 @@ void keymap_debug(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);

3
keyboard/gh60/config.h
View file

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

44
keyboard/gh60/keymap.c
View file

@ -91,7 +91,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
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(
@ -198,54 +198,38 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
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)]);
}
}

3
keyboard/hhkb/config.h
View file

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