diff options
| -rw-r--r-- | README.md | 125 | ||||
| -rw-r--r-- | common.mk | 1 | ||||
| -rw-r--r-- | common/action.c | 394 | ||||
| -rw-r--r-- | common/action.h | 221 | ||||
| -rw-r--r-- | common/command.c | 29 | ||||
| -rw-r--r-- | common/keymap.c | 91 | ||||
| -rw-r--r-- | common/keymap.h | 17 | ||||
| -rw-r--r-- | common/layer_switch.c | 201 | ||||
| -rw-r--r-- | common/layer_switch.h | 80 | ||||
| -rw-r--r-- | common/util.c | 11 | ||||
| -rw-r--r-- | common/util.h | 1 | ||||
| -rw-r--r-- | keyboard/gh60/Makefile.lufa | 6 | ||||
| -rw-r--r-- | keyboard/gh60/Makefile.pjrc | 6 | ||||
| -rw-r--r-- | keyboard/gh60/README.md | 7 | ||||
| -rw-r--r-- | keyboard/gh60/config.h | 2 | ||||
| -rw-r--r-- | keyboard/gh60/keymap.c | 126 | ||||
| -rw-r--r-- | keyboard/gh60/keymap_plain.h | 20 | ||||
| -rw-r--r-- | keyboard/gh60/keymap_poker.h | 142 | ||||
| -rw-r--r-- | keyboard/gh60/keymap_poker_bit.h | 50 | ||||
| -rw-r--r-- | keyboard/gh60/keymap_poker_set.h | 81 | ||||
| -rw-r--r-- | keyboard/hhkb/config.h | 2 | ||||
| -rw-r--r-- | keyboard/hhkb/config_iwrap.h | 2 | ||||
| -rw-r--r-- | keyboard/hhkb/keymap.c | 51 | ||||
| -rw-r--r-- | rules.mk | 3 |
24 files changed, 1191 insertions, 478 deletions
@@ -211,26 +211,34 @@ Many of existent projects offer keymap framework to define your own keymap easil This is keymap example for [HHKB](http://en.wikipedia.org/wiki/Happy_Hacking_Keyboard) keyboard. Keymap is defined in `keymaps[]` array. static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - /* Layer 0: Default Layer + /* Keymap 0: Default Layer * ,-----------------------------------------------------------. * |Esc| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =| \| `| * |-----------------------------------------------------------| * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]|Backs| * |-----------------------------------------------------------| - * |Contro| A| S| D| F| G| H| J| K| L| ;| '|Enter | + * |Contro| A| S| D| F| G| H| J| K| L|Fn1| '|Enter | * |-----------------------------------------------------------| - * |Shift | Z| X| C| V| B| N| M| ,| .| /|Shift |Fn1| + * |Shift | Z| X| C| V| B| N| M| ,| .| /|Shift |Fn0| * `-----------------------------------------------------------' * |Gui|Alt |Space |Alt |Fn2| * `-------------------------------------------' */ KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \ TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \ - LCTL,A, S, D, F, G, H, J, K, L, FN2, QUOT,ENT, \ - LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH,RSFT,FN1, \ + LCTL,A, S, D, F, G, H, J, K, L, FN1, QUOT,ENT, \ + LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH,RSFT,FN0, \ LGUI,LALT, SPC, RALT,FN3), + /* Keymap 1: colemak */ + KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \ + TAB, Q, W, F, P, G, J, L, U, Y, SCLN,LBRC,RBRC,BSPC, \ + BSPC,A, R, S, T, D, H, N, E, I, O, QUOT,ENT, \ + LSFT,Z, X, C, V, B, K, M, COMM,DOT, SLSH,RSFT,FN0, \ + LGUI,LALT, SPC, RALT,FN2), + }; - /* Layer 1: HHKB mode (HHKB Fn) + static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = { + /* Overlay 0: HHKB mode (HHKB Fn) * ,-----------------------------------------------------------. * |Pwr| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| * |-----------------------------------------------------------| @@ -238,42 +246,41 @@ This is keymap example for [HHKB](http://en.wikipedia.org/wiki/Happy_Hacking_Key * |-----------------------------------------------------------| * |Contro|VoD|VoU|Mut| | | *| /|Hom|PgU|Lef|Rig|Enter | * |-----------------------------------------------------------| - * |Shift | | | | | | +| -|End|PgD|Dow|Shift |Fn1| + * |Shift | | | | | | +| -|End|PgD|Dow|Shift | | * `-----------------------------------------------------------' * |Gui |Alt |Space |Alt |Gui| * `--------------------------------------------' */ KEYMAP(PWR, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ - CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,PAUS,UP, NO, BSPC, \ - LCTL,VOLD,VOLU,MUTE,NO, NO, PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \ - LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,FN0, \ + CAPS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PSCR,SLCK,PAUS,UP, TRNS,BSPC, \ + LCTL,VOLD,VOLU,MUTE,TRNS,TRNS,PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \ + LSFT,TRNS,TRNS,TRNS,TRNS,TRNS,PPLS,PMNS,END, PGDN,DOWN,RSFT,TRNS, \ LGUI,LALT, SPC, RALT,RGUI), - /* Layer 2: Mouse mode (Semicolon) + /* Overlay 1: Mouse mode (Semicolon) * ,-----------------------------------------------------------. * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| * |-----------------------------------------------------------| * |Tab | | | | | |MwL|MwD|MwU|MwR| | | |Backs| * |-----------------------------------------------------------| - * |Contro| | | | | |McL|McD|McU|McR|Fn0| |Return | + * |Contro| | | | | |McL|McD|McU|McR| | |Return | * |-----------------------------------------------------------| * |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | | * `-----------------------------------------------------------' - * |Gui |Alt |Mb1 |Alt |Fn0| + * |Gui |Alt |Mb1 |Alt | | * `--------------------------------------------' * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel */ KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ - TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ - LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN0, QUOT,ENT, \ - LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,SLSH,RSFT,NO, \ - LGUI,LALT, BTN1, RALT,FN0), + TAB, TRNS,TRNS,TRNS,TRNS,TRNS,WH_L,WH_D,WH_U,WH_R,TRNS,TRNS,TRNS,BSPC, \ + LCTL,TRNS,ACL0,ACL1,ACL2,TRNS,MS_L,MS_D,MS_U,MS_R,TRNS,QUOT,ENT, \ + LSFT,TRNS,TRNS,TRNS,TRNS,BTN3,BTN2,BTN1,BTN4,BTN5,SLSH,RSFT,TRNS, \ + LGUI,LALT, BTN1, RALT,TRNS), }; static const uint16_t PROGMEM fn_actions[] = { - ACTION_LAYER_DEFAULT, // FN0 - ACTION_LAYER_SET(1), // FN1 - ACTION_LAYER_SET_TAP_KEY(2, KC_SCLN), // FN2 - ACTION_LAYER_BIT_TOGGLE(2), // FN3 + ACTION_OVERLAY(0), // FN0 + ACTION_OVERLAY_TAP_KEY(1, KC_SCLN), // FN1 + ACTION_OVERLAY_TOGGLE(1), // FN2 }; @@ -303,21 +310,21 @@ There are 8 modifiers which has discrimination between left and right. - `KC_LALT` and `KC_RALT` for Alt - `KC_LGUI` and `KC_RGUI` for Windows key or Command key in Mac -#### 1.3 Fn key -`KC_FNnn` are `Fn` keys which not given any action at the beginning unlike most of keycodes has its own action. To use these keys in `KEYMAP` you need to assign action you want at first. Action of `Fn` is defined in `fn_actions[]` and index of the array is identical with number part of `KC_FNnn`. Thus `KC_FN0` designates action defined in first element of the array. ***32 `Fn` keys can be defined at most.*** - -#### 1.4 Mousekey +#### 1.3 Mousekey - `KC_MS_U`, `KC_MS_D`, `KC_MS_L`, `KC_MS_R` for mouse cursor - `KC_WH_U`, `KC_WH_D`, `KC_WH_L`, `KC_WH_R` for mouse wheel - `KC_BTN1`, `KC_BTN2`, `KC_BTN3`, `KC_BTN4`, `KC_BTN5` for mouse buttons -#### 1.5 System & Media key +#### 1.4 System & Media key - `KC_PWR`, `KC_SLEP`, `KC_WAKE` for Power, Sleep, Wake - `KC_MUTE`, `KC_VOLU`, `KC_VOLD` for audio volume control - `KC_MNXT`, `KC_MPRV`, `KC_MSTP`, `KC_MPLY`, `KC_MSEL` for media control - `KC_MAIL`, `KC_CALC`, `KC_MYCM` for application launch - `KC_WSCH`, `KC_WHOM`, `KC_WBAK`, `KC_WFWD`, `KC_WSTP`, `KC_WREF`, `KC_WFAV` for web browser operation +#### 1.5 Fn key +`KC_FNnn` are `Fn` keys which not given any action at the beginning unlike most of keycodes has its own action. To use these keys in `KEYMAP` you need to assign action you want at first. Action of `Fn` is defined in `fn_actions[]` and index of the array is identical with number part of `KC_FNnn`. Thus `KC_FN0` designates action defined in first element of the array. ***32 `Fn` keys can be defined at most.*** + #### Keycode Table See [keycode table](doc/keycode.txt) in `doc/keycode.txt` or `common/keycode.h` for the detail or other keycodes. @@ -329,16 +336,23 @@ There are 8 modifiers which has discrimination between left and right. ### 2. Action See `common/action.h`. Action is a 16bit code and defines function to perform on events of a key like press, release, hold and tap. You can define various actions to use various action codes. -Most of keys just register 8bit keycode as HID usage(or scan code) to host, but to support other complex features needs 16bit extended action codes internally. But using 16bit action codes in keymap results in double size in memory against keycodes. To avoid this waste 8bit keycodes are used in `KEYMAP` to define instead of action codes. ***Keycodes can be considered as subset of action codes.*** Like `KC_A`(0x04) is equal to a `Key` action(0x0004) that transmit keycode of *'A'*. +Most of keys just register 8bit keycodes(HID usage) to host, while to support other complex features needs 16bit extended action codes internally. But using 16bit action codes in keymap results in double size in memory against keycodes. To avoid this waste 8bit keycodes are used in `KEYMAP` to define instead of action codes. + +You can just use keycodes of `Normal key`, `Modifier`, `Mousekey` and `System & Media key` in keymap to indicate corresponding actions, instead of action code itself. In the end you can map most of keys just with 8bit keycodes. + +To use other special actions you should use `Fn key` keycode defined with such action yourself. + #### 2.1 Key action -Key is simple action that registers keycode on press of key and unregister on release. +Key is simple action that registers keycode on press event of key and unregister on release. + +##### 2.1.1 Normal key and Modifier You can define `Key` action on *'A'* key with: ACTION_KEY(KC_A) + ACTION_KEY(KC_LSHIFT) -But you don't need to use this expression directly because you can just put symbol `A` in `KEYMAP` definition. - +***** 2.1.2 Key with modifiers Say you want to assign a key to `Shift + 1` to get charactor *'!'* or `Alt + Tab` to switch windows. ACTION_MOD_KEY(KC_LSHIFT, KC_1) @@ -351,31 +365,38 @@ Or `Alt,Shift + Tab` can be defined. These actions are comprised of strokes of modifiers and a key. `Macro` action is needed if you want more complex key strokes. #### 2.2 Layer Actions + +##### 2.2.0 Return to Default Layer This sets `default layer` into `current layer`. With this action you can return to `default layer`. +with clear other layers. - ACTION_LAYER_DEFAULT + ACTION_DEFAULT_LAYER -`Layer Set` action sets given layer argument to `current layer`. `Layer Set` action can take 0 to 15 as argument. +##### 2.2.1 Keymap +`Keymap` action validate given layer which ranges from 0 to 15. - ACTION_LAYER_SET(layer) - ACTION_LAYER_SET_TOGGLE(layer) - ACTION_LAYER_SET_TAP_KEY(layer, key) - ACTION_LAYER_SET_TAP_TOGGLE(layer) + ACTION_KEYMAP_MOMENTARY(layer) + ACTION_KEYMAP_TOGGLE(layer) + ACTION_KEYMAP_TAP_KEY(layer, key) + ACTION_KEYMAP_TAP_TOGGLE(layer) + +##### 2.2.2 Overlay +`Overlay` action validate -`Layer Bit` action XOR given bits with `current layer`. `Layer Bit` action can take 0 to 15 as argument. + ACTION_KEYMAP_MOMENTARY(layer) + ACTION_KEYMAP_TOGGLE(layer) + ACTION_KEYMAP_TAP_KEY(layer, key) + ACTION_KEYMAP_TAP_TOGGLE(layer) - ACTION_LAYER_BIT(bits) - ACTION_LAYER_BIT_TOGGLE(bits) - ACTION_LAYER_BIT_TAP_KEY(bits, key) - ACTION_LAYER_BIT_TAP_TOGGLE(bits) +##### 2.2.3 Set Default layer +These acitons change `default layer` to given layer. -These acitons change `default layer`. - ACTION_LAYER_SET_DEFAULT(layer) - ACTION_LAYER_BIT_DEFAULT(bits) + ACTION_SET_DEFAULT_LAYER(layer) #### 2.3 Macro action -***NOT FIXED*** +***TBD*** + `Macro` action indicates complex key strokes. MACRO( MD(LSHIFT), D(D), END ) @@ -399,7 +420,8 @@ See `keyboard/hhkb/keymap.c` for sample. #### 2.4 Function action -***NOT FIXED*** +***TBD*** + There are two type of action, normal `Function` and tappable `Function`. These actions call user defined function with `id`, `opt`, and key event information as arguments. @@ -446,9 +468,11 @@ See `keyboard/hhkb/keymap.c` for sample. ### 3. Layer - Layer is key-action map to assign action to every physical key. You can define multiple layers in keymap and select a layer out of keymap during operation at will. + Layer is key-action map to assign action to every physical key. You can define multiple layers in keymap and make layers active out of keymap during operation at will. - First layer is indexed by `Layer 0` which usually become **`default layer`** and active in initial state. **`current layer`** is active layer at that time and can be changed with user interaction. You can define **16 layers** at most in default keymap framework. + First layer is indexed by `0` which usually become **`default layer`** and active in initial state. + +You can define **16 layers** at most in each keymaps[] and overlays[]. you can define a layer with placing keycode symbols separated with `comma` in `KEYMAP`, which is formed with resemblance to physical keyboard layout so as you can easily put keycode on place you want to map. ***You can define most of keys with just using keycodes*** except for `Fn` key serving special actions. @@ -462,9 +486,10 @@ There are two kind of layer switch action `Layer Set` and `Layer Bit` and two ty Momentary switching changes layer only while holding Fn key. ##### 4.1.1 Momentary Set -This `Layer Set` action sets new layer `Layer 1` to `current layer` on key press event. +This action makes `Layer 1` active on key press event and inactive on release event.. + + ACTION_KEYMAP_MOMENTARY(1) - ACTION_LAYER_SET(1) It switches to destination layer immediately when key is pressed, after that actions on keymap of destination layer is perfomed. ***Thus you shall need to place action to come back on destination layer***, or you will be stuck in destination layer without way to get back. To get back to `default layer` you can use this action. @@ -3,6 +3,7 @@ SRC += $(COMMON_DIR)/host.c \ $(COMMON_DIR)/keyboard.c \ $(COMMON_DIR)/action.c \ $(COMMON_DIR)/action_macro.c \ + $(COMMON_DIR)/layer_switch.c \ $(COMMON_DIR)/keymap.c \ $(COMMON_DIR)/command.c \ $(COMMON_DIR)/timer.c \ diff --git a/common/action.c b/common/action.c index 6528cd46c8..294ce00fb1 100644 --- a/common/action.c +++ b/common/action.c @@ -24,12 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "util.h" #include "debug.h" #include "action.h" - - -/* default layer indicates base layer */ -uint8_t default_layer = 0; -/* current layer indicates active layer at this time */ -uint8_t current_layer = 0; +#include "layer_switch.h" static void process_action(keyrecord_t *record); @@ -207,19 +202,6 @@ void action_exec(keyevent_t event) } } -static action_t get_action(key_t key) -{ - action_t action = action_for_key(current_layer, key); - - /* Transparently use 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"); - } - return action; -} - static void process_action(keyrecord_t *record) { keyevent_t event = record->event; @@ -227,8 +209,11 @@ static void process_action(keyrecord_t *record) if (IS_NOEVENT(event)) { return; } - action_t action = get_action(event.key); - debug("ACTION: "); debug_action(action); debug("\n"); + 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"); switch (action.kind.id) { /* Key and Mods */ @@ -287,7 +272,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); } @@ -368,145 +353,316 @@ static void process_action(keyrecord_t *record) #endif break; - /* Layer key */ - case ACT_LAYER: + case ACT_KEYMAP: switch (action.layer.code) { - case LAYER_MOMENTARY: /* momentary */ - if (event.pressed) { - layer_switch(action.layer.val); - } - else { - // NOTE: This is needed by legacy keymap support - layer_switch(default_layer); - } - break; - case LAYER_ON_PRESS: - if (event.pressed) { - layer_switch(action.layer.val); - } - break; - case LAYER_ON_RELEASE: - if (!event.pressed) { - layer_switch(action.layer.val); - } - break; - case LAYER_DEFAULT: /* default layer */ - switch (action.layer.val) { - case DEFAULT_ON_BOTH: - layer_switch(default_layer); + /* Keymap clear */ + case OP_RESET: + switch (action.layer.val & 0x03) { + case 0: + overlay_clear(); + keymap_clear(); break; - case DEFAULT_ON_PRESS: + case ON_PRESS: if (event.pressed) { - layer_switch(default_layer); + overlay_clear(); + keymap_clear(); } break; - case DEFAULT_ON_RELEASE: + case ON_RELEASE: if (!event.pressed) { - layer_switch(default_layer); + overlay_clear(); + keymap_clear(); } break; + case ON_BOTH: + overlay_clear(); + keymap_clear(); + break; } break; - case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ + /* Keymap Reset default layer */ + case (OP_RESET | ON_PRESS): + if (event.pressed) { + overlay_clear(); + keymap_clear(); + default_layer_set(action.layer.val); + } + break; + case (OP_RESET | ON_RELEASE): + if (!event.pressed) { + overlay_clear(); + keymap_clear(); + default_layer_set(action.layer.val); + } + break; + case (OP_RESET | ON_BOTH): + overlay_clear(); + keymap_clear(); + default_layer_set(action.layer.val); + break; + + /* Keymap Bit invert */ + case OP_INV: + /* with tap toggle */ if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { - layer_switch(action.layer.val); + debug("KEYMAP_INV: tap toggle(press).\n"); + keymap_invert(action.layer.val); } } else { - if (tap_count >= TAPPING_TOGGLE) { - debug("LAYER_PRESSED: tap toggle.\n"); - layer_switch(action.layer.val); + if (tap_count <= TAPPING_TOGGLE) { + debug("KEYMAP_INV: tap toggle(release).\n"); + keymap_invert(action.layer.val); } } break; - case LAYER_CHANGE_DEFAULT: /* change default layer */ + case (OP_INV | ON_PRESS): if (event.pressed) { - default_layer = action.layer.val; - layer_switch(default_layer); + keymap_invert(action.layer.val); + } + break; + case (OP_INV | ON_RELEASE): + if (!event.pressed) { + keymap_invert(action.layer.val); } break; - default: /* switch layer on hold and key on tap*/ + case (OP_INV | ON_BOTH): + keymap_invert(action.layer.val); + break; + + /* Keymap Bit on */ + case OP_ON: if (event.pressed) { - if (tap_count > 0) { - debug("LAYER_PRESSED: Tap: register_code\n"); + 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: + if (event.pressed) { + if (tap_count > 0) { + debug("KEYMAP_TAP_KEY: Tap: register_code\n"); register_code(action.layer.code); - } else { - debug("LAYER_PRESSED: No tap: layer_switch\n"); - layer_switch(action.layer.val); - } + } else { + debug("KEYMAP_TAP_KEY: No tap: On on press\n"); + keymap_on(action.layer.val); + } } else { if (tap_count > 0) { - debug("LAYER_PRESSED: Tap: unregister_code\n"); + debug("KEYMAP_TAP_KEY: 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"); - layer_switch(default_layer); + debug("KEYMAP_TAP_KEY: No tap: Off on release\n"); + keymap_off(action.layer.val); } } break; } break; - case ACT_LAYER_BIT: + + case ACT_OVERLAY: switch (action.layer.code) { - case LAYER_MOMENTARY: /* momentary */ - if (event.pressed) { - layer_switch(current_layer ^ action.layer.val); + // Overlay Invert bit4 + case OP_INV4 | 0: + if (action.layer.val == 0) { + overlay_clear(); } else { - layer_switch(current_layer ^ action.layer.val); + overlay_set(overlay_stat ^ action.layer.val); } break; - case LAYER_ON_PRESS: - if (event.pressed) { - layer_switch(current_layer ^ action.layer.val); + case OP_INV4 | 1: + if (action.layer.val == 0) { + if (event.pressed) overlay_clear(); + } else { + overlay_set(overlay_stat ^ action.layer.val<<4); } break; - case LAYER_ON_RELEASE: - if (!event.pressed) { - layer_switch(current_layer ^ action.layer.val); + case OP_INV4 | 2: + if (action.layer.val == 0) { + if (!event.pressed) overlay_clear(); + } else { + overlay_set(overlay_stat ^ action.layer.val<<8); + } + break; + case OP_INV4 | 3: + if (action.layer.val == 0) { + overlay_clear(); + } else { + overlay_set(overlay_stat ^ action.layer.val<<12); } break; - case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ + + /* Overlay Bit invert */ + case OP_INV: + /* with tap toggle */ if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { - debug("LAYER_BIT: tap toggle(press).\n"); - layer_switch(current_layer ^ action.layer.val); + debug("OVERLAY_INV: tap toggle(press).\n"); + overlay_invert(action.layer.val); } } else { if (tap_count <= TAPPING_TOGGLE) { - debug("LAYER_BIT: tap toggle(release).\n"); - layer_switch(current_layer ^ action.layer.val); + debug("OVERLAY_INV: tap toggle(release).\n"); + overlay_invert(action.layer.val); } } break; - case 0xFF: - // change default layer + 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) { - default_layer = current_layer ^ action.layer.val; - layer_switch(default_layer); + overlay_off(action.layer.val); } else { - default_layer = current_layer ^ action.layer.val; - layer_switch(default_layer); + 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: - // with tap key if (event.pressed) { - if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_BIT: Tap: register_code\n"); + if (tap_count > 0) { + debug("OVERLAY_TAP_KEY: Tap: register_code\n"); register_code(action.layer.code); } else { - debug("LAYER_BIT: No tap: layer_switch(bit on)\n"); - layer_switch(current_layer ^ action.layer.val); + debug("OVERLAY_TAP_KEY: No tap: On on press\n"); + overlay_on(action.layer.val); } } else { - if (IS_TAPPING_KEY(event.key) && tap_count > 0) { - debug("LAYER_BIT: Tap: unregister_code\n"); + if (tap_count > 0) { + debug("OVERLAY_TAP_KEY: Tap: unregister_code\n"); unregister_code(action.layer.code); } else { - debug("LAYER_BIT: No tap: layer_switch(bit off)\n"); - layer_switch(current_layer ^ action.layer.val); + debug("OVERLAY_TAP_KEY: No tap: Off on release\n"); + overlay_off(action.layer.val); } } break; @@ -813,39 +969,23 @@ bool sending_anykey(void) host_last_sysytem_report() || host_last_consumer_report()); } -void layer_switch(uint8_t new_layer) -{ - if (current_layer != new_layer) { - debug("Layer Switch: "); debug_hex(current_layer); - debug(" -> "); debug_hex(new_layer); debug("\n"); - - current_layer = new_layer; - clear_keyboard_but_mods(); // To avoid stuck keys - // NOTE: update mods with full scan of matrix? if modifier changes between layers - } -} - bool is_tap_key(key_t key) { - action_t action = get_action(key); + action_t action = layer_switch_get_action(key); switch (action.kind.id) { case ACT_LMODS_TAP: case ACT_RMODS_TAP: return true; - case ACT_LAYER: - case ACT_LAYER_BIT: + case ACT_KEYMAP: + case ACT_OVERLAY: switch (action.layer.code) { - case LAYER_MOMENTARY: - case LAYER_ON_PRESS: - case LAYER_ON_RELEASE: - case LAYER_DEFAULT: - return false; - case LAYER_TAP_TOGGLE: - default: /* tap key */ + case 0x04 ... 0xEF: /* tap key */ + case OP_INV: return true; + default: + return false; } - return false; case ACT_FUNCTION: if (action.func.opt & FUNC_TAP) { return true; } return false; @@ -876,8 +1016,8 @@ 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_BIT: debug("ACT_LAYER_BIT"); break; + case ACT_KEYMAP: debug("ACT_KEYMAP"); break; + case ACT_OVERLAY: debug("ACT_OVERLAY"); 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 b9a6cb5b40..4892cc7fd9 100644 --- a/common/action.h +++ b/common/action.h @@ -76,11 +76,6 @@ typedef union { -/* layer used currently */ -extern uint8_t current_layer; -/* layer to return or start with */ -extern uint8_t default_layer; - /* Execute action per keyevent */ void action_exec(keyevent_t event); @@ -155,32 +150,41 @@ bool waiting_buffer_has_anykey_pressed(void); * * Mouse Keys * ---------- - * TODO: can be combined with 'Other HID Usage'? to save action kind id. * ACT_MOUSEKEY(0110): * 0101|XXXX| keycode Mouse key * * * Layer Actions * ------------- - * ACT_LAYER(1000): Set layer - * ACT_LAYER_BIT(1001): Bit-op layer - * - * 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) - * - * 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) + * 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) + * 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} * * * Extensions(11XX) @@ -208,8 +212,8 @@ enum action_kind_id { ACT_USAGE = 0b0100, ACT_MOUSEKEY = 0b0101, - ACT_LAYER = 0b1000, - ACT_LAYER_BIT = 0b1001, + ACT_KEYMAP = 0b1000, + ACT_OVERLAY = 0b1001, ACT_MACRO = 0b1100, ACT_COMMAND = 0b1110, @@ -223,20 +227,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,81 +248,122 @@ 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)) #define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT) -/* - * Switch layer +/* Layer Operation: + * Invert layer ^= (1<<layer) + * On layer |= (1<<layer) + * Off layer &= ~(1<<layer) + * Set layer = (1<<layer) + * Clear layer = 0 */ -enum layer_codes { - LAYER_MOMENTARY = 0, - LAYER_ON_PRESS = 1, - LAYER_ON_RELEASE = 2, - LAYER_DEFAULT =3, - LAYER_TAP_TOGGLE = 0xF0, - LAYER_CHANGE_DEFAULT = 0xFF -}; -enum layer_vals_default { - DEFAULT_ON_PRESS = 1, - DEFAULT_ON_RELEASE = 2, - DEFAULT_ON_BOTH = 3, +enum layer_params { + ON_PRESS = 1, + ON_RELEASE = 2, + ON_BOTH = 3, + + OP_RESET = 0x00, + OP_INV4 = 0x00, + OP_INV = 0xF0, + OP_ON = 0xF4, + OP_OFF = 0xF8, + OP_SET = 0xFC, }; +/* + * Default Layer + */ +#define ACTION_DEFAULT_LAYER ACTION(ACT_KEYMAP, 0<<8 | OP_RESET | 0) +#define ACTION_SET_DEFAULT_LAYER(layer) ACTION_KEYMAP_RESET(layer) +#define ACTION_SET_DEFAULT_LAYER_P(layer) ACTION_KEYMAP_RESET_P(layer) +#define ACTION_SET_DEFAULT_LAYER_R(layer) ACTION_KEYMAP_RESET_R(layer) +#define ACTION_SET_DEFAULT_LAYER_B(layer) ACTION_KEYMAP_RESET_B(layer) /* - * return to default layer + * Keymap 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_KEYMAP(layer) ACTION_KEYMAP_MOMENTARY(layer) +#define ACTION_KEYMAP_MOMENTARY(layer) ACTION_KEYMAP_ON_OFF(layer) +#define ACTION_KEYMAP_TOGGLE(layer) ACTION_KEYMAP_INV_R(layer) +/* Keymap Set and clear overaly */ +#define ACTION_KEYMAP_RESET(layer) ACTION_KEYMAP_RESET_R(layer) +#define ACTION_KEYMAP_RESET_P(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_PRESS) +#define ACTION_KEYMAP_RESET_R(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_RELEASE) +#define ACTION_KEYMAP_RESET_B(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_BOTH) +/* Keymap Invert */ +#define ACTION_KEYMAP_INV(layer) ACTION_KEYMAP_INV_B(layer) +#define ACTION_KEYMAP_TAP_TOGGLE(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | 0) +#define ACTION_KEYMAP_INV_P(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_PRESS) +#define ACTION_KEYMAP_INV_R(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_RELEASE) +#define ACTION_KEYMAP_INV_B(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_BOTH) +/* Keymap On */ +#define ACTION_KEYMAP_ON(layer) ACTION_KEYMAP_ON_OFF(layer) +#define ACTION_KEYMAP_ON_OFF(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | 0) +#define ACTION_KEYMAP_ON_P(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | ON_PRESS) +#define ACTION_KEYMAP_ON_R(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | ON_RELEASE) +#define ACTION_KEYMAP_ON_B(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | ON_BOTH) +/* Keymap Off */ +#define ACTION_KEYMAP_OFF(layer) ACTION_KEYMAP_OFF_ON(layer) +#define ACTION_KEYMAP_OFF_ON(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | 0) +#define ACTION_KEYMAP_OFF_P(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_PRESS) +#define ACTION_KEYMAP_OFF_R(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_RELEASE) +#define ACTION_KEYMAP_OFF_B(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_BOTH) +/* Keymap Set */ +#define ACTION_KEYMAP_SET(layer) ACTION_KEYMAP_SET_CLEAR(layer) +#define ACTION_KEYMAP_SET_CLEAR(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | 0) +#define ACTION_KEYMAP_SET_P(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_PRESS) +#define ACTION_KEYMAP_SET_R(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_RELEASE) +#define ACTION_KEYMAP_SET_B(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_BOTH) +/* Keymap Invert with tap key */ +#define ACTION_KEYMAP_TAP_KEY(layer, key) ACTION(ACT_KEYMAP, (layer)<<8 | (key)) /* - * Set layer + * Overlay Layer */ -/* 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_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_OVERLAY(layer) ACTION_OVERLAY_MOMENTARY(layer) +#define ACTION_OVERLAY_MOMENTARY(layer) ACTION_OVERLAY_ON_OFF(layer) +#define ACTION_OVERLAY_TOGGLE(layer) ACTION_OVERLAY_INV_R(layer) +/* Overlay Clear */ +#define ACTION_OVERLAY_CLEAR ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | 0) +#define ACTION_OVERLAY_CLEAR_P ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_PRESS) +#define ACTION_OVERLAY_CLEAR_R ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_RELEASE) +#define ACTION_OVERLAY_CLEAR_B ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_BOTH) +/* 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) ACTION_OVERLAY_INV_B(layer) +#define ACTION_OVERLAY_TAP_TOGGLE(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0) +#define ACTION_OVERLAY_INV_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_PRESS) +#define ACTION_OVERLAY_INV_R(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_RELEASE) +#define ACTION_OVERLAY_INV_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_BOTH) +/* Overlay On */ +#define ACTION_OVERLAY_ON(layer) ACTION_OVERLAY_ON_OFF(layer) +#define ACTION_OVERLAY_ON_OFF(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | 0) +#define ACTION_OVERLAY_ON_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | ON_PRESS) +#define ACTION_OVERLAY_ON_R(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | ON_RELEASE) +#define ACTION_OVERLAY_ON_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | ON_BOTH) +/* Overlay Off */ +#define ACTION_OVERLAY_OFF(layer) ACTION_OVERLAY_OFF_ON(layer) +#define ACTION_OVERLAY_OFF_ON(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0) +#define ACTION_OVERLAY_OFF_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_PRESS) +#define ACTION_OVERLAY_OFF_R(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_RELEASE) +#define ACTION_OVERLAY_OFF_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_BOTH) +/* Overlay Set */ +#define ACTION_OVERLAY_SET(layer) ACTION_OVERLAY_SET_CLEAR(layer) +#define ACTION_OVERLAY_SET_CLEAR(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0) +#define ACTION_OVERLAY_SET_P(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_PRESS) +#define ACTION_OVERLAY_SET_R(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_RELEASE) +#define ACTION_OVERLAY_SET_B(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_BOTH) +/* Overlay Invert with tap key */ +#define ACTION_OVERLAY_TAP_KEY(layer, key) ACTION(ACT_OVERLAY, (layer)<<8 | (key)) + /* - * Bit-op layer + * HID Usage */ -/* 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_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) - - -/* HID Usage */ enum usage_pages { PAGE_SYSTEM, PAGE_CONSUMER diff --git a/common/command.c b/common/command.c index 7bb2a23f19..202d531fd8 100644 --- a/common/command.c +++ b/common/command.c @@ -26,7 +26,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "timer.h" #include "keyboard.h" #include "bootloader.h" +#include "layer_switch.h" #include "command.h" + #ifdef MOUSEKEY_ENABLE #include "mousekey.h" #endif @@ -53,7 +55,7 @@ static void mousekey_console_help(void); #endif static uint8_t numkey2num(uint8_t code); -static void switch_layer(uint8_t layer); +static void switch_default_layer(uint8_t layer); typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t; @@ -261,18 +263,16 @@ static bool command_common(uint8_t code) #endif break; #endif + case KC_ESC: + case KC_GRV: case KC_0: - case KC_F10: - clear_keyboard(); - switch_layer(0); + switch_default_layer(0); break; case KC_1 ... KC_9: - clear_keyboard(); - switch_layer((code - KC_1) + 1); + switch_default_layer((code - KC_1) + 1); break; - case KC_F1 ... KC_F9: - clear_keyboard(); - switch_layer((code - KC_F1) + 1); + case KC_F1 ... KC_F12: + switch_default_layer((code - KC_F1) + 1); break; default: print("?"); @@ -541,11 +541,10 @@ static uint8_t numkey2num(uint8_t code) return 0; } -static void switch_layer(uint8_t layer) +static void switch_default_layer(uint8_t layer) { - print_val_hex8(current_layer); - print_val_hex8(default_layer); - current_layer = layer; - default_layer = layer; - print("switch to "); print_val_hex8(layer); + print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n"); + default_layer_set(layer); + overlay_clear(); + clear_keyboard(); } diff --git a/common/keymap.c b/common/keymap.c index 078615814e..ddc3210524 100644 --- a/common/keymap.c +++ b/common/keymap.c @@ -14,13 +14,71 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ +#include <avr/pgmspace.h> #include "keymap.h" #include "report.h" #include "keycode.h" +#include "layer_switch.h" #include "action.h" +#include "debug.h" -action_t keymap_keycode_to_action(uint8_t keycode) +static action_t keycode_to_action(uint8_t keycode); + +#ifdef USE_KEYMAP_V2 +/* converts key to action */ +action_t action_for_key(uint8_t layer, key_t key) +{ + uint8_t keycode = keymap_key_to_keycode(layer, key); + switch (keycode) { + case KC_FN0 ... KC_FN31: + return keymap_fn_to_action(keycode); + default: + return keycode_to_action(keycode); + } +} + +__attribute__ ((weak)) +void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) +{ +} +#else +/* + * legacy keymap support + */ +/* translation for legacy keymap */ +action_t action_for_key(uint8_t layer, key_t key) +{ + /* convert from legacy keycode to action */ + /* layer 16-31 indicate 'overlay' but not supported in legacy keymap */ + uint8_t keycode = keymap_get_keycode((layer & OVERLAY_MASK), key.row, key.col); + action_t action; + switch (keycode) { + case KC_FN0 ... KC_FN31: + { + uint8_t layer = keymap_fn_layer(FN_INDEX(keycode)); + uint8_t key = keymap_fn_keycode(FN_INDEX(keycode)); + if (key) { + action.code = ACTION_KEYMAP_TAP_KEY(layer, key); + } else { + action.code = ACTION_KEYMAP_MOMENTARY(layer); + } + } + return action; + default: + return keycode_to_action(keycode); + } +} +/* not used for legacy keymap */ +void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) +{ +} +#endif + + + +/* translates keycode to action */ +static action_t keycode_to_action(uint8_t keycode) { action_t action; switch (keycode) { @@ -51,34 +109,3 @@ action_t keymap_keycode_to_action(uint8_t keycode) } return action; } - -#ifndef NO_LEGACY_KEYMAP_SUPPORT -/* legacy support with weak reference */ -__attribute__ ((weak)) -action_t action_for_key(uint8_t layer, key_t key) -{ - /* convert from legacy keycode to action */ - uint8_t keycode = keymap_get_keycode(layer, key.row, key.col); - action_t action; - switch (keycode) { - case KC_FN0 ... KC_FN31: - { - uint8_t layer = keymap_fn_layer(FN_INDEX(keycode)); - uint8_t key = keymap_fn_keycode(FN_INDEX(keycode)); - if (key) { - action.code = ACTION_LAYER_SET_TAP_KEY(layer, key); - } else { - action.code = ACTION_LAYER_SET_MOMENTARY(layer); - } - } - return action; - default: - return keymap_keycode_to_action(keycode); - } -} -#endif - -__attribute__ ((weak)) -void action_function(keyrecord_t *event, uint8_t id, uint8_t opt) -{ -} diff --git a/common/keymap.h b/common/keymap.h index 63bf14482b..0c483483fb 100644 --- a/common/keymap.h +++ b/common/keymap.h @@ -23,16 +23,19 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "action.h" -/* translates key_t to keycode */ +#ifdef USE_KEYMAP_V2 +/* translates key to keycode + * layer: 0-15 for base layers + * 16-31 for overlays + */ uint8_t keymap_key_to_keycode(uint8_t layer, key_t key); -/* translates keycode to action */ -action_t keymap_keycode_to_action(uint8_t keycode); /* translates Fn keycode to action */ action_t keymap_fn_to_action(uint8_t keycode); - - - -#ifndef NO_LEGACY_KEYMAP_SUPPORT +#else +#warning "You are using LEGACY KEYAMP. Consider using NEW KEYMAP." +/* + * legacy keymap support + */ /* keycode of key */ uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col); /* layer to move during press Fn key */ diff --git a/common/layer_switch.c b/common/layer_switch.c new file mode 100644 index 0000000000..19e286f885 --- /dev/null +++ b/common/layer_switch.c @@ -0,0 +1,201 @@ +#include <stdint.h> +#include "keyboard.h" +#include "action.h" +#include "debug.h" +#include "util.h" +#include "layer_switch.h" + + +/* + * Default Layer (0-15) + */ +uint8_t default_layer = 0; + +void default_layer_set(uint8_t layer) +{ + debug("default_layer_set: "); + debug_dec(default_layer); debug(" to "); + + default_layer = layer; + + debug_dec(default_layer); debug("\n"); + + clear_keyboard_but_mods(); // To avoid stuck keys +} + + +/* + * Keymap Layer (0-15) + */ +uint16_t keymap_stat = 0; + +/* return highest layer whose state is on */ +uint8_t keymap_get_layer(void) +{ + return biton16(keymap_stat); +} + +static void keymap_stat_set(uint16_t stat) +{ + debug("keymap: "); + keymap_debug(); debug(" to "); + + keymap_stat = stat; + + keymap_debug(); debug("\n"); + + clear_keyboard_but_mods(); // To avoid stuck keys +} + +void keymap_clear(void) +{ + keymap_stat_set(0); +} + + +void keymap_set(uint16_t stat) +{ + keymap_stat_set(stat); +} + +void keymap_move(uint8_t layer) +{ + keymap_stat_set(1<<layer); +} + +void keymap_on(uint8_t layer) +{ + keymap_stat_set(keymap_stat | (1<<layer)); +} + +void keymap_off(uint8_t layer) +{ + keymap_stat_set(keymap_stat & ~(1<<layer)); +} + +void keymap_invert(uint8_t layer) +{ + keymap_stat_set(keymap_stat ^ (1<<layer)); +} + +void keymap_or(uint16_t stat) +{ + keymap_stat_set(keymap_stat | stat); +} +void keymap_and(uint16_t stat) +{ + keymap_stat_set(keymap_stat & stat); +} +void keymap_xor(uint16_t stat) +{ + keymap_stat_set(keymap_stat ^ stat); +} + +void keymap_debug(void) +{ + debug_hex16(keymap_stat); debug("("); debug_dec(keymap_get_layer()); debug(")"); +} + + + +/* + * 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(")"); +} + +action_t layer_switch_get_action(key_t key) +{ + action_t action; + action.code = ACTION_TRANSPARENT; + + /* 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; + } + } + } + + /* keymap: top layer first */ + for (int8_t i = 15; i >= 0; i--) { + if (keymap_stat & (1<<i)) { + action = action_for_key(i, key); + if (action.code != ACTION_TRANSPARENT) { + return action; + } + } + } + + /* default layer */ + action = action_for_key(default_layer, key); + return action; +} diff --git a/common/layer_switch.h b/common/layer_switch.h new file mode 100644 index 0000000000..a566ab12b7 --- /dev/null +++ b/common/layer_switch.h @@ -0,0 +1,80 @@ +/* +Copyright 2013 Jun Wako <wakojun@gmail.com> + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ +#ifndef LAYER_SWITCH_H +#define LAYER_SWITCH_H + +#include <stdint.h> +#include "keyboard.h" +#include "action.h" + + +/* overlays are asigned at layer 16-31 */ +#define OVERLAY_BIT 0x10 +#define OVERLAY_MASK 0x0F + + +/* + * Default Layer + */ +/* base layer to fall back */ +extern uint8_t default_layer; +void default_layer_set(uint8_t layer); + + +/* + * Keymap 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); +/* bitwise operation */ +void keymap_or(uint16_t stat); +void keymap_and(uint16_t stat); +void keymap_xor(uint16_t stat); +void keymap_debug(void); + + +/* + * Overlay Layer + */ +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); + + + +/* return action depending on current layer status */ +action_t layer_switch_get_action(key_t key); + +#endif diff --git a/common/util.c b/common/util.c index 9d8fb93219..ff1926d7d1 100644 --- a/common/util.c +++ b/common/util.c @@ -39,6 +39,7 @@ uint8_t bitpop16(uint16_t bits) } // 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) { uint8_t n = 0; @@ -47,3 +48,13 @@ uint8_t biton(uint8_t bits) if (bits >> 1) { bits >>= 1; n += 1;} return n; } + +uint8_t biton16(uint16_t bits) +{ + uint8_t n = 0; + 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; +} diff --git a/common/util.h b/common/util.h index c3734487f9..58b7fdf145 100644 --- a/common/util.h +++ b/common/util.h @@ -31,5 +31,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. uint8_t bitpop(uint8_t bits); uint8_t bitpop16(uint16_t bits); uint8_t biton(uint8_t bits); +uint8_t biton16(uint16_t bits); #endif diff --git a/keyboard/gh60/Makefile.lufa b/keyboard/gh60/Makefile.lufa index c8d3fa4943..7a83032969 100644 --- a/keyboard/gh60/Makefile.lufa +++ b/keyboard/gh60/Makefile.lufa @@ -124,3 +124,9 @@ plain: all poker: OPT_DEFS += -DKEYMAP_POKER poker: all + +poker_set: OPT_DEFS += -DKEYMAP_POKER_SET +poker_set: all + +poker_bit: OPT_DEFS += -DKEYMAP_POKER_BIT +poker_bit: all diff --git a/keyboard/gh60/Makefile.pjrc b/keyboard/gh60/Makefile.pjrc index f253704faa..af6ef63ec4 100644 --- a/keyboard/gh60/Makefile.pjrc +++ b/keyboard/gh60/Makefile.pjrc @@ -94,3 +94,9 @@ plain: all poker: OPT_DEFS += -DKEYMAP_POKER poker: all + +poker_set: OPT_DEFS += -DKEYMAP_POKER_SET +poker_set: all + +poker_bit: OPT_DEFS += -DKEYMAP_POKER_BIT +poker_bit: all diff --git a/keyboard/gh60/README.md b/keyboard/gh60/README.md index 405ab3dffc..4dc4e5ee2e 100644 --- a/keyboard/gh60/README.md +++ b/keyboard/gh60/README.md @@ -47,9 +47,10 @@ See [keymap_plain.h](keymap_plain.h) for detail. `-----------------------------------------------------------' ### 2 Poker keymap -Poker layer emulation without Esc/grave bug :) -See [keymap_poker.h](keymap_poker.h) for detail. +See [keymap_poker.h](keymap_poker.h) for Poker layer emulation, [keymap_poker_bit.h](keymap_poker_bit.h) and [keymap_poker_set.h](keymap_poker_set.h) for better support of Esc and arrow. + + These keymap supports Colemak, Dvorak and Workmans, use `Magic` + {`1`, `2`, `3`} to switch and `Magic` + `0` to return to Qwerty. #### 2.0 Poker Default Layer ,-----------------------------------------------------------. @@ -108,7 +109,7 @@ See [keymap_poker.h](keymap_poker.h) for detail. ### 3. Funky keymap This is my keymap(default) with HHKB, Vi cursor and Mousekey layer. -See [keymap.h](keymap.h) for detail. +See [keymap.c](keymap.c) for detail. #### 3.0 Funky Default Layer ,-----------------------------------------------------------. diff --git a/keyboard/gh60/config.h b/keyboard/gh60/config.h index a760d5dfb3..ef0c9a1735 100644 --- a/keyboard/gh60/config.h +++ b/keyboard/gh60/config.h @@ -41,6 +41,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Set 0 if need no debouncing */ #define DEBOUNCE 5 +/* To use new keymap framework */ +#define USE_KEYMAP_V2 /* key combination for command */ #define IS_COMMAND() ( \ diff --git a/keyboard/gh60/keymap.c b/keyboard/gh60/keymap.c index a17c11fc3b..77ec09cfd6 100644 --- a/keyboard/gh60/keymap.c +++ b/keyboard/gh60/keymap.c @@ -20,6 +20,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "keycode.h" #include "action.h" #include "action_macro.h" +#include "layer_switch.h" #include "report.h" #include "host.h" #include "print.h" @@ -64,12 +65,16 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "keymap_plain.h" #elif defined(KEYMAP_POKER) #include "keymap_poker.h" +#elif defined(KEYMAP_POKER_SET) + #include "keymap_poker_set.h" +#elif defined(KEYMAP_POKER_BIT) + #include "keymap_poker_bit.h" #else static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /* * Funky */ - /* Layer 0: Default Layer + /* Keymap 0: Default Layer * ,-----------------------------------------------------------. * |Esc| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backsp | * |-----------------------------------------------------------| @@ -85,10 +90,37 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KEYMAP_ANSI( 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, FN3, QUOT, ENT, \ - LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT, \ - LCTL,LGUI,LALT, SPC, RALT,FN4, FN4, FN1), - /* Layer 1: HHKB mode + 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, \ + LCTL,LGUI,LALT, SPC, RALT,FN3, FN3, FN0), + /* Keymap 1: colemak */ + KEYMAP_ANSI( + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ + TAB, Q, W, F, P, G, J, L, U, Y, SCLN,LBRC,RBRC,BSLS, \ + BSPC,A, R, S, T, D, H, N, E, I, O, QUOT, ENT, \ + LSFT,Z, X, C, V, B, K, M, COMM,DOT, SLSH, RSFT, \ + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, FN0), + /* Keymap 2: dvorak */ + KEYMAP_ANSI( + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, LBRC,RBRC,BSPC, \ + TAB, QUOT,COMM,DOT, P, Y, F, G, C, R, L, SLSH,EQL, BSLS, \ + CAPS,A, O, E, U, I, D, H, T, N, S, MINS, ENT, \ + LSFT,SCLN,Q, J, K, X, B, M, W, V, Z, RSFT, \ + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, FN0), + /* Keymap: workman */ + KEYMAP_ANSI( + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ + TAB, Q, D, R, W, B, J, F, U, P, SCLN,LBRC,RBRC,BSLS, \ + BSPC,A, S, H, T, G, Y, N, E, O, I, QUOT, ENT, \ + LSFT,Z, X, M, C, V, K, L, COMM,DOT, SLSH, RSFT, \ + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, FN0), +}; + +static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = { + /* + * Funky + */ + /* Overlay 0: HHKB mode * ,-----------------------------------------------------------. * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delete | * |-----------------------------------------------------------| @@ -98,16 +130,16 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |-----------------------------------------------------------| * |Shift | | | | | | +| -|End|PgD|Dow|Shift | * |-----------------------------------------------------------| - * |Ctrl|Gui |Alt | Space |Alt |Gui |App |Fn0 | + * |Ctrl|Gui |Alt | Space |Alt |Gui |App | | * `-----------------------------------------------------------' */ KEYMAP_ANSI( PWR, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, \ - CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,PAUS,UP, NO, INS, \ - LCTL,VOLD,VOLU,MUTE,NO, NO, PAST,PSLS,HOME,PGUP,LEFT,RGHT, ENT, \ - LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN, RSFT, \ - LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, FN0), - /* Layer 2: Vi mode (Slash) + CAPS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PSCR,SLCK,PAUS,UP, TRNS,INS, \ + LCTL,VOLD,VOLU,MUTE,TRNS,TRNS,PAST,PSLS,HOME,PGUP,LEFT,RGHT, ENT, \ + LSFT,TRNS,TRNS,TRNS,TRNS,TRNS,PPLS,PMNS,END, PGDN,DOWN, RSFT, \ + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, TRNS), + /* Overlay 1: Vi mode (Slash) * ,-----------------------------------------------------------. * | `| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Backsp | * |-----------------------------------------------------------| @@ -115,79 +147,89 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |-----------------------------------------------------------| * |Contro| |Lef|Dow|Rig| |Lef|Dow|Up |Rig| | |Return | * |-----------------------------------------------------------| - * |Shift | | | | | |Hom|PgD|PgU|End|Fn0|Shift | + * |Shift | | | | | |Hom|PgD|PgU|End| |Shift | * |-----------------------------------------------------------| * |Ctrl|Gui |Alt | Space |Alt |Gui |App |Ctrl| * `-----------------------------------------------------------' */ KEYMAP_ANSI( GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, BSPC, \ - TAB, HOME,PGDN,UP, PGUP,END, HOME,PGDN,PGUP,END, NO, NO, NO, NO, \ - LCTL,NO, LEFT,DOWN,RGHT,NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, \ - LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, FN0, RSFT, \ + TAB, HOME,PGDN,UP, PGUP,END, HOME,PGDN,PGUP,END, TRNS,TRNS,TRNS,TRNS, \ + LCTL,TRNS,LEFT,DOWN,RGHT,TRNS,LEFT,DOWN,UP, RGHT,TRNS,TRNS, ENT, \ + LSFT,TRNS,TRNS,TRNS,TRNS,TRNS,HOME,PGDN,PGUP,END, TRNS, RSFT, \ LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL), - /* Layer 3: Mouse mode (Semicolon/App) + /* Overlay 2: Mouse mode (Semicolon/App) * ,-----------------------------------------------------------. * | `| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Backsp | * |-----------------------------------------------------------| * |Tab | | | | | |MwL|MwD|MwU|MwR| | | | | * |-----------------------------------------------------------| - * |Contro| |Ac0|Ac1|Ac1| |McL|McD|McU|McR|Fn0| |Return | + * |Contro| |Ac0|Ac1|Ac1| |McL|McD|McU|McR| | |Return | * |-----------------------------------------------------------| * |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | * |-----------------------------------------------------------| - * |Ctrl|Gui |Alt | Space | |Fn0 |Fn0 | | + * |Ctrl|Gui |Alt | Space | | | | | * `-----------------------------------------------------------' * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel */ KEYMAP_ANSI( GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, BSPC, \ - TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, NO, \ - LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN0, NO, ENT, \ - LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT, \ - LCTL,LGUI,LALT, BTN1, NO, FN0, FN0, NO ), + TAB, TRNS,TRNS,TRNS,TRNS,TRNS,WH_L,WH_D,WH_U,WH_R,TRNS,TRNS,TRNS,TRNS, \ + LCTL,TRNS,ACL0,ACL1,ACL2,TRNS,MS_L,MS_D,MS_U,MS_R,TRNS,TRNS, ENT, \ + LSFT,TRNS,TRNS,TRNS,TRNS,BTN3,BTN2,BTN1,BTN4,BTN5,TRNS, RSFT, \ + LCTL,LGUI,LALT, BTN1, TRNS,TRNS,TRNS,RCTL), }; /* * Fn action definition */ static const uint16_t PROGMEM fn_actions[] = { - ACTION_LAYER_DEFAULT, // FN0 - ACTION_LAYER_SET(1), // FN1 - ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2 Layer with Slash - ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // FN3 Layer with Semicolon - ACTION_LAYER_SET(3), // FN4 + ACTION_OVERLAY_TAP_TOGGLE(0), // FN0 + ACTION_OVERLAY_TAP_KEY(1, KC_SLASH), // FN1 + ACTION_OVERLAY_TAP_KEY(2, KC_SCLN), // FN2 + ACTION_OVERLAY(2), // FN3 }; #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) { - return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]); + /* 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 { + 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 { + // fall back to layer 0 + debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n"); + return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]); + } + } } -/* translates Fn index to action */ +/* translates Fn keycode to action */ action_t keymap_fn_to_action(uint8_t keycode) { action_t action; - if (FN_INDEX(keycode) < sizeof(fn_actions) / sizeof(fn_actions[0])) { + if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) { action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]); } else { action.code = ACTION_NO; } return action; } - -/* convert key to action */ -action_t action_for_key(uint8_t layer, key_t key) -{ - uint8_t keycode = keymap_key_to_keycode(layer, key); - switch (keycode) { - case KC_FN0 ... KC_FN31: - return keymap_fn_to_action(keycode); - default: - return keymap_keycode_to_action(keycode); - } -} diff --git a/keyboard/gh60/keymap_plain.h b/keyboard/gh60/keymap_plain.h index ad0bc2f269..85331715dc 100644 --- a/keyboard/gh60/keymap_plain.h +++ b/keyboard/gh60/keymap_plain.h @@ -1,24 +1,10 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - /* - * Plain - */ - /* Layer 0: Default Layer - * ,-----------------------------------------------------------. - * |Esc| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backsp | - * |-----------------------------------------------------------| - * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| - * |-----------------------------------------------------------| - * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return | - * |-----------------------------------------------------------| - * |Shift | Z| X| C| V| B| N| M| ,| .| /|Shift | - * |-----------------------------------------------------------| - * |Ctrl|Gui |Alt | Space |Alt |Gui |App |Ctrl| - * `-----------------------------------------------------------' - */ + /* Keymap 0: qwerty */ KEYMAP(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, \ CAPS,A, S, D, F, G, H, J, K, L, SCLN,QUOT,NO, ENT, \ LSFT,NO, Z, X, C, V, B, N, M, COMM,DOT, SLSH,NO, RSFT, \ LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL), }; - +static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = {}; +static const uint16_t PROGMEM fn_actions[] = {}; diff --git a/keyboard/gh60/keymap_poker.h b/keyboard/gh60/keymap_poker.h index 186020b3bd..2bbda61064 100644 --- a/keyboard/gh60/keymap_poker.h +++ b/keyboard/gh60/keymap_poker.h @@ -1,88 +1,104 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - /* - * Poker Layer - */ - /* Layer x000: Poker Default Layer - * ,-----------------------------------------------------------. - * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backsp | - * |-----------------------------------------------------------| - * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| - * |-----------------------------------------------------------| - * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return | - * |-----------------------------------------------------------| - * |Shift | Z| X| C| V| B| N| M| ,| .| /|Shift | - * |-----------------------------------------------------------| - * |Ctrl|Gui |Alt | Space |Fn |Gui |App |Ctrl| - * `-----------------------------------------------------------' - */ + /* Keymap 0: qwerty */ KEYMAP_ANSI( GRV, 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, SCLN,QUOT, ENT, \ + CAPS,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, \ LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, \ - LCTL,LGUI,LALT, SPC, FN2, RGUI,APP, RCTL), - /* Layer x001: Poker with Arrow */ + LCTL,LGUI,LALT, SPC, FN0, RGUI,APP, RCTL), + /* Keymap 1: colemak */ + KEYMAP_ANSI( + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ + TAB, Q, W, F, P, G, J, L, U, Y, SCLN,LBRC,RBRC,BSLS, \ + BSPC,A, R, S, T, D, H, N, E, I, O, QUOT, ENT, \ + LSFT,Z, X, C, V, B, K, M, COMM,DOT, SLSH, RSFT, \ + LCTL,LGUI,LALT, SPC, FN0, RGUI,APP, RCTL), + /* Keymap 2: dvorak */ + KEYMAP_ANSI( + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, LBRC,RBRC,BSPC, \ + TAB, QUOT,COMM,DOT, P, Y, F, G, C, R, L, SLSH,EQL, BSLS, \ + CAPS,A, O, E, U, I, D, H, T, N, S, MINS, ENT, \ + LSFT,SCLN,Q, J, K, X, B, M, W, V, Z, RSFT, \ + LCTL,LGUI,LALT, SPC, FN0, RGUI,APP, RCTL), + /* Keymap: workman */ + KEYMAP_ANSI( + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ + TAB, Q, D, R, W, B, J, F, U, P, SCLN,LBRC,RBRC,BSLS, \ + BSPC,A, S, H, T, G, Y, N, E, O, I, QUOT, ENT, \ + LSFT,Z, X, M, C, V, K, L, COMM,DOT, SLSH, RSFT, \ + LCTL,LGUI,LALT, SPC, FN0, RGUI,APP, RCTL), +}; +static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = { + /* Overlay 0: Poker with Arrow */ KEYMAP_ANSI( TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ - TRNS,TRNS,TRNS, TRNS, FN2, LEFT,DOWN,RGHT), - /* Layer x010: Poker with Esc */ + TRNS,TRNS,TRNS, TRNS, TRNS,LEFT,DOWN,RGHT), + /* Overlay 1: Poker with Esc */ KEYMAP_ANSI( ESC, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ - TRNS,TRNS,TRNS, TRNS, FN2, TRNS,TRNS,TRNS), - /* Layer x011: Poker with Arrow and Esc */ - KEYMAP_ANSI( - ESC, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ - TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ - TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ - TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ - TRNS,TRNS,TRNS, TRNS, FN2, LEFT,DOWN,RGHT), - /* - * Poker Momentary Fn Layer + TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), + /* Overlay 2: Poker Fn + * ,-----------------------------------------------------------. + * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12| | + * |-----------------------------------------------------------| + * | |FnQ| Up| | | | | | |Cal| |Hom|Ins|FnL | + * |-----------------------------------------------------------| + * | |Lef|Dow|Rig| | |Psc|Slk|Pau| |Tsk|End| | + * |-----------------------------------------------------------| + * | |Del| |Web|Mut|VoU|VoD| |PgU|PgD|Del| | + * |-----------------------------------------------------------| + * | | | | FnS | | | | | + * `-----------------------------------------------------------' + * Fn: to Fn overlay + * FnL: to Layout selector overaly + * FnQ: toggle Esc overlay + * FnS: toggle Arrow overlay */ - /* Layer x100: Poker Default + Fn'd */ KEYMAP_ANSI( ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ - TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ + TRNS,FN2, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, FN4, \ TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ - TRNS,TRNS,TRNS, FN0, FN2, TRNS,TRNS,TRNS), - /* Layer x101: Poker with Arrow + Fn'd */ - KEYMAP_ANSI( - ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ - TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ - TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ - TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, UP, \ - TRNS,TRNS,TRNS, FN0, FN2, LEFT,DOWN,RGHT), - /* Layer x110: Poker with Esc + Fn'd */ - KEYMAP_ANSI( - GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ - TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ - TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ - TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ - TRNS,TRNS,TRNS, FN0, FN2, TRNS,TRNS,TRNS), - /* Layer x111: Poker with Arrow and Esc + Fn'd */ + TRNS,TRNS,TRNS, FN1, TRNS,TRNS,TRNS,TRNS), + /* Overlay 3: Layout selector + * ,-----------------------------------------------------------. + * | Lq| Lc| Ld| Lw| | | | | | | | | | | + * |-----------------------------------------------------------| + * | |Lq |Lw | | | | | | | | | | | | + * |-----------------------------------------------------------| + * | | | |Ld | | | | | | | | | | + * |-----------------------------------------------------------| + * | | | |Lc | | | | | | | | | + * |-----------------------------------------------------------| + * | | | | | | | | | + * `-----------------------------------------------------------' + * Lq: set Qwerty layout + * Lc: set Colemak layout + * Ld: set Dvorak layout + * Lw: set Workman layout + */ KEYMAP_ANSI( - GRV, F9, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ - TRNS,FN1, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ - TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN3, END, TRNS, \ - TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, UP, \ - TRNS,TRNS,TRNS, FN0, FN2, LEFT,DOWN,RGHT), + FN5, FN6, FN7, FN8, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,FN5, FN8, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,FN7, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,FN6, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), }; - -/* - * Fn action definition - */ static const uint16_t PROGMEM fn_actions[] = { /* Poker Layout */ - [0] = ACTION_LAYER_BIT_TOGGLE(1), // FN0 Poker Arrow toggle(Space) - [1] = ACTION_LAYER_BIT_TOGGLE(2), // FN1 Poker Esc toggle(Q) - [2] = ACTION_LAYER_BIT(4), // FN2 Poker Fn - [3] = ACTION_RMODS_KEY(MOD_BIT(KC_RCTL)|MOD_BIT(KC_RSFT), KC_ESC), // FN3 Task(RControl,RShift+Esc) + [0] = ACTION_OVERLAY(2), // to Fn overlay + [1] = ACTION_OVERLAY_TOGGLE(0), // toggle arrow overlay + [2] = ACTION_OVERLAY_TOGGLE(1), // toggle Esc overlay + [3] = ACTION_RMODS_KEY(MOD_BIT(KC_RCTL)|MOD_BIT(KC_RSFT), KC_ESC), // Task(RControl,RShift+Esc) + [4] = ACTION_OVERLAY(3), // to Layout selector + [5] = ACTION_SET_DEFAULT_LAYER(0), // set qwerty layout + [6] = ACTION_SET_DEFAULT_LAYER(1), // set colemak layout + [7] = ACTION_SET_DEFAULT_LAYER(2), // set dvorak layout + [8] = ACTION_SET_DEFAULT_LAYER(3), // set workman layout }; - diff --git a/keyboard/gh60/keymap_poker_bit.h b/keyboard/gh60/keymap_poker_bit.h new file mode 100644 index 0000000000..982632d05b --- /dev/null +++ b/keyboard/gh60/keymap_poker_bit.h @@ -0,0 +1,50 @@ +// Poker fix with toggle and bit operation +// Fn + Esc = ` +// Fn + {left, down, up, right} = {home, pgdown, pgup, end} +static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + /* Keymap 0: qwerty */ + KEYMAP_ANSI( + GRV, 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, SCLN,QUOT, ENT, \ + LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, \ + LCTL,LGUI,LALT, SPC, FN0, RGUI,APP, RCTL), +}; +static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = { + /* Overlay 0: Poker Default + Fn'd */ + KEYMAP_ANSI( + TRNS,F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ + CAPS,FN2, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ + TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN4, END, TRNS, \ + TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ + TRNS,TRNS,TRNS, FN1, TRNS,TRNS,TRNS,TRNS), + /* Overlay 1: Poker with Arrow */ + KEYMAP_ANSI( + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, PGUP, \ + TRNS,TRNS,TRNS, TRNS, FN3, HOME,PGDN,END), + /* Overlay 2: Poker with Esc */ + KEYMAP_ANSI( + ESC, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), + /* Overlay 3: Poker with Arrow + Fn'd */ + KEYMAP_ANSI( + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ + TRNS,TRNS,TRNS, TRNS, TRNS,LEFT,DOWN,RGHT), +}; +static const uint16_t PROGMEM fn_actions[] = { + /* Poker Layout */ + [0] = ACTION_OVERLAY_INV4(0b0101, 0), // Poker Fn(with fix for Esc) + [1] = ACTION_OVERLAY_TOGGLE(1), // Poker Arrow toggle + [2] = ACTION_OVERLAY_TOGGLE(2), // Poker Esc toggle + [3] = ACTION_OVERLAY_INV4(0b1101, 0), // Poker Fn(with fix for Arrow) + [4] = ACTION_RMODS_KEY(MOD_BIT(KC_RCTL)|MOD_BIT(KC_RSFT), KC_ESC), // FN3 Task(RControl,RShift+Esc) +}; diff --git a/keyboard/gh60/keymap_poker_set.h b/keyboard/gh60/keymap_poker_set.h new file mode 100644 index 0000000000..bf4d8959f1 --- /dev/null +++ b/keyboard/gh60/keymap_poker_set.h @@ -0,0 +1,81 @@ +// Poker fix with set(state transition) +// Fn + Esc = ` +// Fn + {left, down, up, right} = {home, pgdown, pgup, end} +static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + /* Keymap 0: qwerty */ + KEYMAP_ANSI( + GRV, 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, SCLN,QUOT, ENT, \ + LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, \ + LCTL,LGUI,LALT, SPC, FN0, RGUI,APP, RCTL), +}; +static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = { + /* Overlay 0: Poker with Arrow */ + KEYMAP_ANSI( + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ + TRNS,TRNS,TRNS, TRNS, FN1, LEFT,DOWN,RGHT), + /* Overlay 1: Poker with Esc */ + KEYMAP_ANSI( + ESC, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS, TRNS, FN2, TRNS,TRNS,TRNS), + /* Overlay 2: Poker with Arrow and Esc */ + KEYMAP_ANSI( + ESC, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ + TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ + TRNS,TRNS,TRNS, TRNS, FN3, LEFT,DOWN,RGHT), + /* Overlay 3: Poker Fn'd */ + KEYMAP_ANSI( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ + TRNS,FN6, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ + TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN8, END, TRNS, \ + TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ + TRNS,TRNS,TRNS, FN5, FN4, TRNS,TRNS,TRNS), + /* Overlay 4: Poker Fn'd arrow */ + KEYMAP_ANSI( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ + TRNS,FN7, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ + TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN8, END, TRNS, \ + TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, PGUP, \ + TRNS,TRNS,TRNS, FN4, FN5, HOME,PGDN,END), + /* Overlay 5: Poker Fn'd Esc */ + KEYMAP_ANSI( + GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ + TRNS,FN4, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ + TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN8, END, TRNS, \ + TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, TRNS, \ + TRNS,TRNS,TRNS, FN7, FN6, TRNS,TRNS,TRNS), + /* Overlay 6: Poker Fn'd Arrow + Esc */ + KEYMAP_ANSI( + GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS, \ + TRNS,FN5, UP, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,CALC,TRNS,HOME,INS, TRNS, \ + TRNS,LEFT,DOWN,RGHT,TRNS,TRNS,PSCR,SLCK,PAUS,TRNS,FN8, END, TRNS, \ + TRNS,DEL, TRNS,WHOM,MUTE,VOLU,VOLD,TRNS,PGUP,PGDN,DEL, PGUP, \ + TRNS,TRNS,TRNS, FN6, FN7, HOME,PGDN,END), +}; + +/* + * Fn action definition + */ +static const uint16_t PROGMEM fn_actions[] = { + /* Poker Layout */ + [0] = ACTION_OVERLAY_SET_P(3), // FN0 move to Fn'd when press + [1] = ACTION_OVERLAY_SET_P(4), // FN1 move to Fn'd arrow when press + [2] = ACTION_OVERLAY_SET_P(5), // FN2 move to Fn'd Esc when press + [3] = ACTION_OVERLAY_SET_P(6), // FN3 move to Fn'd arrow + Esc when press + + [4] = ACTION_OVERLAY_CLEAR, // FN4 clear overlay when release + [5] = ACTION_OVERLAY_SET_R(0), // FN5 move to arrow when release + [6] = ACTION_OVERLAY_SET_R(1), // FN6 move to Esc when release + [7] = ACTION_OVERLAY_SET_R(2), // FN7 move to arrow + Esc when release + + [8] = ACTION_RMODS_KEY(MOD_BIT(KC_RCTL)|MOD_BIT(KC_RSFT), KC_ESC), // FN8 Task(RControl,RShift+Esc) +}; diff --git a/keyboard/hhkb/config.h b/keyboard/hhkb/config.h index 5fcec95eb2..72e4d26e92 100644 --- a/keyboard/hhkb/config.h +++ b/keyboard/hhkb/config.h @@ -36,6 +36,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define MATRIX_ROWS 8 #define MATRIX_COLS 8 +/* To use new keymap framework */ +#define USE_KEYMAP_V2 /* * Boot magic keys diff --git a/keyboard/hhkb/config_iwrap.h b/keyboard/hhkb/config_iwrap.h index 734d669774..d50b704d72 100644 --- a/keyboard/hhkb/config_iwrap.h +++ b/keyboard/hhkb/config_iwrap.h @@ -31,6 +31,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define MATRIX_ROWS 8 #define MATRIX_COLS 8 +/* To use new keymap framework */ +#define USE_KEYMAP_V2 /* key combination for command */ #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c index ef21282ff1..1fb65873d1 100644 --- a/keyboard/hhkb/keymap.c +++ b/keyboard/hhkb/keymap.c @@ -85,7 +85,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KEYMAP(PWR, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,PAUS, UP, NO, BSPC, \ LCTL,VOLD,VOLU,MUTE,NO, NO, PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \ - LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,FN0, \ + LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,TRNS, \ LGUI,LALT, SPC, RALT,RGUI), /* Layer 2: Vi mode (Slash) @@ -104,7 +104,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ TAB, HOME,PGDN,UP, PGUP,END, HOME,PGDN,PGUP,END, NO, NO, NO, BSPC, \ LCTL,NO, LEFT,DOWN,RGHT,NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, \ - LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, FN0, RSFT,NO, \ + LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, TRNS,RSFT,NO, \ LGUI,LALT, SPC, RALT,RGUI), /* Layer 3: Mouse mode (Semicolon) @@ -123,9 +123,9 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { */ KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ - LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN0, QUOT,ENT, \ + LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,TRNS,QUOT,ENT, \ LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,SLSH,RSFT,NO, \ - LGUI,LALT, BTN1, RALT,FN0), + LGUI,LALT, BTN1, RALT,TRNS), /* Layer 4: Matias half keyboard style (Space) * ,-----------------------------------------------------------. @@ -144,7 +144,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { BSPC,P, O, I, U, Y, T, R, E, W, Q, NO, NO, TAB, \ LCTL,SCLN,L, K, J, H, G, F, D, S, A, RCTL,RCTL, \ LSFT,SLSH,DOT, COMM,M, N, B, V, C, X, Z, RSFT,NO, \ - LGUI,LALT, FN0, RALT,RGUI), + LGUI,LALT, TRNS, RALT,RGUI), /* Layer5: another Mouse mode (Space) * ,-----------------------------------------------------------. @@ -164,7 +164,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,NO, NO, ENT, \ LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \ - LGUI,LALT, FN0, RALT,RGUI), + LGUI,LALT, TRNS, RALT,RGUI), }; @@ -182,26 +182,23 @@ enum function_id { */ // TODO: use [1] = KEYMAP(...) to prevent from changing index of element? static const uint16_t PROGMEM fn_actions[] = { - ACTION_LAYER_DEFAULT, // FN0 - ACTION_LAYER_SET(1), // FN1 - ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2 Layer with Slash - ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // FN3 Layer with Semicolon + ACTION_DEFAULT_LAYER, // FN0 + ACTION_KEYMAP(1), // FN1 + ACTION_KEYMAP_TAP_KEY(2, KC_SLASH), // FN2 Layer with Slash + ACTION_KEYMAP_TAP_KEY(3, KC_SCLN), // FN3 Layer with Semicolon - ACTION_LAYER_SET(3), // FN4 -// ACTION_LAYER_SET_TOGGLE(3), // FN4 + ACTION_KEYMAP(3), // FN4 +// ACTION_KEYMAP_TOGGLE(3), // FN4 // ACTION_FUNCTION(MACRO, 0), // FN4 - ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // FN5 + ACTION_KEYMAP_TAP_KEY(5, KC_SPC), // FN5 // ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // FN6 Control with tap Backspace ACTION_LMOD_TAP_KEY(KC_LCTL, KC_ESC), // FN6 Control with tap Backspace ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT), // FN7 Control with tap Enter ACTION_LMOD_ONESHOT(KC_LSFT), // FN8 Oneshot Shift - ACTION_LAYER_SET_TAP_TOGGLE(1), // FN9 - ACTION_LAYER_BIT_TAP_KEY(1, KC_GRV), // FN10 Layer with Grave - //ACTION_LAYER_BIT(1), // FN10 - //ACTION_LAYER_BIT_TAP_TOGGLE(1), // FN10 - ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11 Function: LShift with tap '(' - ACTION_FUNCTION_TAP(RSHIFT_RPAREN), // FN12 Function: RShift with tap ')' - ACTION_FUNCTION(MACRO, 1), // FN13 Macro: + [9] = ACTION_KEYMAP_TAP_TOGGLE(1), // FN9 + [11] = ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11 Function: LShift with tap '(' + [12] = ACTION_FUNCTION_TAP(RSHIFT_RPAREN), // FN12 Function: RShift with tap ')' + [13] = ACTION_FUNCTION(MACRO, 1), // FN13 Macro: }; @@ -230,7 +227,7 @@ static const prog_macro_t *get_macro(uint8_t id, bool pressed) /* * user defined action function */ -void keymap_call_function(keyrecord_t *record, uint8_t id, uint8_t opt) +void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { keyevent_t event = record->event; uint8_t tap_count = record->tap_count; @@ -328,15 +325,3 @@ action_t keymap_fn_to_action(uint8_t keycode) } return action; } - -/* convert key to action */ -action_t action_for_key(uint8_t layer, key_t key) -{ - uint8_t keycode = keymap_key_to_keycode(layer, key); - switch (keycode) { - case KC_FN0 ... KC_FN31: - return keymap_fn_to_action(keycode); - default: - return keymap_keycode_to_action(keycode); - } -} @@ -340,7 +340,8 @@ LST = $(patsubst %.c,$(OBJDIR)/%.lst,$(patsubst %.cpp,$(OBJDIR)/%.lst,$(patsubst # Compiler flags to generate dependency files. -GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d +#GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d +GENDEPFLAGS = -MMD -MP -MF .dep/$(subst /,_,$@).d # Combine all necessary flags and optional flags. |