diff --git a/Atreus/ATREUS-HD_RH.pdf b/Atreus/ATREUS-HD_RH.pdf new file mode 100644 index 0000000..b38c215 Binary files /dev/null and b/Atreus/ATREUS-HD_RH.pdf differ diff --git a/Atreus/atreus_hd_keymap.c b/Atreus/atreus_hd_keymap.c new file mode 100644 index 0000000..784a2a2 --- /dev/null +++ b/Atreus/atreus_hd_keymap.c @@ -0,0 +1,85 @@ +#include QMK_KEYBOARD_H + + +#ifdef COMBO_ENABLE +#include HD_combo_def // this has the combo definitions +#endif + +#define ______ KC_TRNS +#define __no__ KC_NO + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [L_QWERTY] = LAYOUT( + KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUM), LT(L_FUN,KC_MPLY), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + KC_LEFT, KC_RGHT, KC_APP, LT(L_CFG,KC_MUTE), LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_CFG,KC_MUTE), LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), LT(L_CFG,KC_MPLY), KC_UP, KC_DOWN), + + [L_HD] = LAYOUT( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_LBA, HD_RBA, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + KC_LEFT, KC_RGHT, HD_LH3, HD_LH2, HD_LH1, HD_LH0, HD_RH0, HD_RH1, HD_RH2, HD_RH3, KC_UP, KC_DOWN), + +/* + [L_SYM] = LAYOUT( + KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), + KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), + KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ______, ______, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, + ______, ______, ______, SK_DELWDL, SK_DELWDR, ______, LSA(KC_8), ______, ______, ______, ______, ______), +*/ + [L_SYM] = LAYOUT( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_LBA, LS_RBA, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + ______, ______, LS_LH3, LS_LH2, LS_LH1, LS_LH0, LS_RH0, LS_RH1, LS_RH2, LS_RH3, ______, ______), + +/* [L_FUN] = LAYOUT( + KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_BSLS, + LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_SCLN, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_SLSH), KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_PAUS, KC_TAB, KC_MINS, KC_4, KC_5, KC_6, KC_EQL, KC_PSCR, KC_LSCR, ______, KC_BSPC, KC_ENT, ______, KC_DEL, KC_0, KC_DOT, KC_COMM, ______, ______), +*/ + [L_FUN] = LAYOUT( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_LBA, LF_RBA, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + ______, ______, LF_LH3, LF_LH2, LF_LH1, LF_LH0, LF_RH0, LF_RH1, LF_RH2, LF_RH3, ______, ______), + +/* + [L_NUM] = LAYOUT( + KC_NUM, KC_PGDN, KC_UP, KC_PGUP, KC_TAB, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, + SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), RCTL_T(KC_PPLS), + SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, KC_ESC, KC_ESC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, + ______, ______, ______, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), KC_DEL, KC_C, KC_P0, KC_PDOT, ______, ______, ______), +*/ + [L_NUM] = LAYOUT( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_LBA, LN_RBA, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + ______, ______, LN_LH3, LN_LH2, LN_LH1, LN_LH0, LN_RH0, LN_RH1, LN_RH2, LN_RH3, ______, ______), +/* + [L_NAV] = LAYOUT( + SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, + KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, + SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_ESC, KC_TAB, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, + SK_HISTPRV, SK_HISTNXT, ______, ______, ______, ______, ______, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST, SK_ZOOMOUT, SK_ZOOMIN), +*/ + [L_NAV] = LAYOUT( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_LBA, LV_RBA, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, +SK_HISTPRV, SK_HISTNXT, LV_LH3, LV_LH2, LV_LH1, LV_LH0, LV_RH0, LV_RH1, LV_RH2, LV_RH3, SK_ZOOMOUT, SK_ZOOMIN), + +/* + [L_CFG] = LAYOUT( + QK_RBT, CG_SWAP, CG_NORM, EE_CLR, SK_KILL, LCA(KC_DEL), KC_NUM, KC_EJCT, __no__, SK_ZOOMRST, + HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, __no__, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, + QK_BOOT, AG_SWAP, AG_NORM, KC_VOLD, KC_BRID, __no__, __no__, __no__, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, + __no__, __no__, TG(L_NUM), __no__, __no__, __no__, __no__, __no__, __no__, __no__, __no__, __no__) +*/ + [L_CFG] = LAYOUT( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_LBA, LC_RBA, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + ______, ______, LC_LH3, LC_LH2, LC_LH1, LC_LH0, LC_RH0, LC_RH1, LC_RH2, LC_RH3, ______, ______), +}; + diff --git a/Atreus/config.h b/Atreus/config.h new file mode 100644 index 0000000..8b69ccb --- /dev/null +++ b/Atreus/config.h @@ -0,0 +1,26 @@ +/* Copyright (C) 2019, 2020 Keyboard.io, Inc + * + * 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 . + */ + +#pragma once + + +// Atreus hardware specific bits +// + +#ifdef PRODUCT +#undef PRODUCT +#define PRODUCT HD-Atreus +#endif diff --git a/config.h b/config.h index 830b1f9..654fdc3 100644 --- a/config.h +++ b/config.h @@ -55,14 +55,6 @@ #define COMBO_HOLD (TAPPING_TERM) // time to hold to trigger delayed combo #endif -#define ADAPTIVE_ENABLE -#define ADAPTIVE_TRAILER KC_3 - -//#define THUMB_REPEATER -#ifdef THUMB_REPEATER -#define HD_REPEATER_A HD_BSPC -#define HD_REPEATER_B KC_ENT -#endif #ifdef COMBO_HOLD #undef ADAPTIVE_TERM @@ -73,8 +65,16 @@ #define LINGER_TIME TAPPING_TERM * 1.2 // how long to hold before a time-depentant behavior begins // how long to leave a state active before resetting like APPMENU or SHIFTWORD -#define STATE_RESET_TIME LINGER_TIME * 4 +#define STATE_RESET_TIME LINGER_TIME * 3 +#define ADAPTIVE_ENABLE +#define ADAPTIVE_TRAILER KC_3 + +//#define THUMB_REPEATER +#ifdef THUMB_REPEATER +#define HD_REPEATER_A HD_BSPC +#define HD_REPEATER_B KC_ENT +#endif #define EN_PRONOUN_COMBOS // English First Person pronoun combos (I, I'm, I've I'd I'll etc) (184 bytes on AVR) #define EN_PRONOUN_COMBOS_ALL // combos for you('ve), We('ve), They('ve) etc. (616 bytes on AVR) diff --git a/ferris/config.h b/ferris/config.h new file mode 100644 index 0000000..f7170db --- /dev/null +++ b/ferris/config.h @@ -0,0 +1,11 @@ + +/* + * + */ + +#pragma once + +#ifdef PRODUCT +#undef PRODUCT +#define PRODUCT HD-Ferris +#endif diff --git a/ferris/ferris_hd_keymap.c b/ferris/ferris_hd_keymap.c new file mode 100644 index 0000000..0a05d83 --- /dev/null +++ b/ferris/ferris_hd_keymap.c @@ -0,0 +1,68 @@ +#include QMK_KEYBOARD_H + +#ifdef COMBO_ENABLE +#include HD_combo_def // this has the combo definitions +#endif + +#define ____ KC_TRNS +#define _no_ KC_NO + +// Alpha Layer for a 34 key (3x5+2) formfactor +// ╭─────────────────────╮ ╭─────────────────────╮ +// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ +// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ +// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ +// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭───────────╯ +// ╰─────────╯ ╰─────────╯ +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + + /* + [L_QWERTY] = LAYOUT_split_3x5_2( + KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT)), +*/ + [L_QWERTY] = LAYOUT_split_3x5_2( // Actually MITHRIL + KC_W, KC_P, KC_G, KC_D, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_X, KC_QUOT, + RCTL_T(KC_C), RALT_T(KC_N), RGUI_T(KC_S), RSFT_T(KC_T), LT(L_NUM,KC_K), LT(L_NUM,KC_COMM), RSFT_T(KC_I), RGUI_T(KC_E), RALT_T(KC_L), RCTL_T(KC_A), + KC_Y, KC_B, KC_F, KC_M, KC_V, KC_MINS, KC_U, KC_O, KC_H, KC_DQUO, + HD_LH2, HD_LH1, HD_RH1, HD_RH2), + + [L_HD] = LAYOUT_split_3x5_2( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + HD_LH2, HD_LH1, HD_RH1, HD_RH2), + + [L_SYM] = LAYOUT_split_3x5_2( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + LS_LH2, LS_LH1, LS_RH1, LS_RH2), + + [L_FUN] = LAYOUT_split_3x5_2( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + LF_LH2, LF_LH1, LF_RH1, LF_RH2), + + [L_NUM] = LAYOUT_split_3x5_2( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + LN_LH2, LN_LH1, LN_RH1, LN_RH2), + + [L_NAV] = LAYOUT_split_3x5_2( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, + LV_LH2, LV_LH1, LV_RH1, LV_RH2), + + [L_CFG] = LAYOUT_split_3x5_2( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + LC_LH2, LC_LH1, LC_RH1, LC_RH2), + +}; diff --git a/handsdown/au-config.h b/handsdown/au-config.h index 19cac43..3b684da 100644 --- a/handsdown/au-config.h +++ b/handsdown/au-config.h @@ -4,41 +4,12 @@ // #define HD_adaptive_code "handsdown/au-adaptive.c" // -// -// Alpha Layer for a 34 key formfactor -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ -// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ -// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ -// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭──────────╯ -// ╰─────────╯ ╰──────────╯ -// Hands Down Gold -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ J G M P V │ │ #$ .: /* "[ '] │ -// │ R S N D B | | ,; A E I H │ -// │ X F L C W │ │ -+ U O Y K │ -// ╰───────────╮ BSP T │ │ SPC RET ╭──────────╯ -// ╰─────────╯ ╰──────────╯ -// Q (LT3) & Z (LT4) are on the punc layer -// and on combos (defined below) -// -// for now... -// This will morph to being entirel properly abstracted -// similar to Miryoku, (maybe someone will make an HD Miryoku someday?) -// -// // -// We want to be able to define a combo either -// by location for variation independent, spatial referencing, or -// or by letter for mnemonic/phonetic referencing (variation dependent) -// -// BE CAREFUL to not double define a combo! -// -// First, let's add any hold-taps to the keycodes +// First, let's define HD alpha keycodes with any hold-taps/custom keycodes // #define HD_A RSFT_T(KC_A) -#define HD_B LT(L_NUMPAD,KC_B) +#define HD_B LT(L_NUM,KC_B) #define HD_C KC_C #define HD_D RSFT_T(KC_D) #define HD_E RGUI_T(KC_E) @@ -66,63 +37,112 @@ #define HD_MINS KC_MINS #define HD_HASH KC_HASH -#define HD_SPC LT(L_PUNCT,KC_SPC) -#define HD_BSPC LT(L_FN_NUM,KC_BSPC) +#define HD_SPC LT(L_SYM,KC_SPC) +#define HD_BSPC LT(L_FUN,KC_BSPC) #define HD_ENT LT(L_NAV,KC_ENT) #define HD_QUOT KC_QUOT #define HD_DQUO KC_DQUO #define HD_SLSH KC_SLSH #define HD_DOT KC_DOT -#define HD_COMM LT(L_FN_NUM, KC_COMM) +#define HD_COMM LT(L_FUN, KC_COMM) +// Now let's place these HD keycodes on the keymap +// for variation independent spatial referencing by key position +// +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 +// // -// Now let's also define the keycodes on the map for spatial referencing +// Base (alpha) Layer Hands Down Gold (HRMs /+ thumb mods) +// ╭─────────────────────╮ ╭─────────────────────╮ +// esc │ J G M P V │ L_CFG L_NUM │ #$ .: /* "[ '] │ LANG2/henk +// tab │ R S N D B | ( ) | ,; A E I H │ LANG1/mhen +// Z │ X F L C W │ [ copy pste ] │ -+ U O Y K │ Q +// ╰───────────╮ bsp T │ & | │ spc ret ╭──────────╯ +// left rght app ╰─────────╯ ╰──────────╯ tgLN up dn // -// (is there any way to combine these 2 steps?) +// For small boards, Q (LT3) & Z (LT4) are (also) on the sym layer +// and accessible combos (defined below) // + +#define HD_LT5 KC_ESC #define HD_LT4 HD_J #define HD_LT3 HD_G #define HD_LT2 HD_M #define HD_LT1 HD_P #define HD_LT0 HD_V +#define HD_LTA OSL(L_CFG) +#define HD_RTA TG(L_NUM) #define HD_RT0 HD_HASH #define HD_RT1 HD_DOT #define HD_RT2 HD_SLSH #define HD_RT3 HD_DQUO #define HD_RT4 HD_QUOT +#define HD_RT5 KC_LNG2 +#define HD_LM5 KC_TAB #define HD_LM4 HD_R #define HD_LM3 HD_S #define HD_LM2 HD_N #define HD_LM1 HD_D #define HD_LM0 HD_B +#define HD_LMA KC_LPRN +#define HD_RMA KC_RPRN #define HD_RM0 HD_COMM #define HD_RM1 HD_A #define HD_RM2 HD_E #define HD_RM3 HD_I #define HD_RM4 HD_H +#define HD_RM5 KC_LNG1 +#define HD_LB5 HD_Z #define HD_LB4 HD_X #define HD_LB3 HD_F #define HD_LB2 HD_L #define HD_LB1 HD_C #define HD_LB0 HD_W +#define HD_LBA LT(L_NUM, KC_LBRC) +#define HD_LBB LT(L_FUN,SK_COPY) +#define HD_RBB LT(L_FUN,SK_PSTE) +#define HD_RBA LT(L_NAV,KC_RBRC) #define HD_RB0 HD_MINS #define HD_RB1 HD_U #define HD_RB2 HD_O #define HD_RB3 HD_Y #define HD_RB4 HD_K +#define HD_RB5 HD_Q -//Primary Thumbs (others unique to the board) +//Primary Thumbs 1-3 (others are unique to the board) +#define HD_LH5 KC_LEFT +#define HD_LH4 LT(L_FUN,KC_MUTE) +#define HD_LH3 KC_APP #define HD_LH2 HD_BSPC #define HD_LH1 HD_T +#define HD_LH0 LT(L_CFG,KC_MUTE) +#define HD_LHA LT(L_NAV,KC_LNG2) +#define HD_RHA LT(L_SYM,KC_LNG1) +#define HD_RH0 LT(L_CFG,KC_MPLY) #define HD_RH1 HD_SPC #define HD_RH2 HD_ENT - - +#define HD_RH3 TG(L_NUM) +#define HD_RH4 LT(L_FUN,KC_MPLY) +#define HD_RH5 KC_DN #ifdef COMBO_ENABLE // +// We want to be able to define a combo by location +// for variation independent, spatial referencing, or +// by letter for mnemonic/phonetic referencing (variation dependent) +// put this sort of obscures the definitions…so… +// +// BE CAREFUL to not double define a combo! +// // Combo definitions that rely on phonetics/mnemonics for their locations. // // Combos that are spacially organized don't need to be redefined @@ -132,14 +152,16 @@ // notably the H-digraph combos that inhabit close areas. // #define HD_tab_keys HD_LM4, HD_LM3 // tab +#define HD_stab_keys HD_LM4, HD_LM3, HD_LM1 // shift-tab #define HD_spc_keys HD_LM1, HD_LM0 // SPACE #define HD_ent_keys HD_LB0, HD_LB1 // ENTER -#define HD_ent2_keys HD_LB0, HD_LB2, HD_LB1 // hard-ENTER/page break +#define HD_ent2_keys HD_LB0, HD_LB1, HD_LB2 // hard-ENTER/page break +#define APPMENU_keys HD_LB3, HD_LB1 // APPMENU -// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3) +// TEXT ENTRY - off map standard alphas (also on Layer L_SYM @ Z=LT4 & Q=LT3) // #define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u) -#define HD_L1_keys HD_LM3, HD_LM1 // ex. TYPE "z" +#define HD_L1_keys HD_LT1, HD_LT0 // ex. TYPE "z" #define HD_L1 HD_Z //#define HD_L2_keys HD_LM3, HD_LM1 // ex. TYPE "x" //#define HD_L2 HD_X @@ -158,10 +180,12 @@ #define HD_Gh_keys HD_LT3, HD_LT2 // TYPE "gh" #define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch" +// Should we put all the diacritic keys here? +// or get keep them all in the common area (if they all share +// HD Neu vowel block)? #define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ #define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ - #ifdef EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans @@ -178,16 +202,17 @@ #define HD_youre_keys HD_Y, HD_R // TYPE "you're" #define HD_youve_keys HD_Y, HD_V // TYPE "you've" #define HD_your_keys HD_Y, HD_P // TYPE "your" "P" for "possessive" case + #define HD_their_keys HD_T, HD_W // TYPE "their" #6 #define HD_they_keys HD_T, HD_Y // "they" #23 + 've #define HD_theyd_keys HD_T, HD_X // "they'd" #23 + 've #define HD_theyll_keys HD_T, HD_L // "they'll" #23 + 've #define HD_theyre_keys HD_T, HD_QUOT // "they're" +// deictics. Are these really necessary? #define HD_there_keys HD_T, HD_F // TYPE "there" #7 + 's #define HD_here_keys HD_H, HD_R // TYPE "here" #5 + 's - #ifdef EN_W_PRONOUNS #define HD_where_keys HD_X, HD_R // "where" + 's #define HD_wed_keys HD_X, HD_G // TYPE "we'd" + 've @@ -196,13 +221,14 @@ #define HD_weve_keys HD_X, HD_J // TYPE "we've" #endif // EN_W_PRONOUNS -#endif // EN_PRONOUN_keysS_ALL -#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans - - +#endif // EN_PRONOUNS_ALL +#endif // EN_PRONOUNS // the entirely unnecessary pronoun combo shenanigans // SEMANTIC FUNCTIONS ** uses SemKeys ** // Spatially arranged on the QWERTY ZXCV locations +// independent of the HD Alphas, though since some of +// the above combos may compete for the same locations, +// we'll define them all here. // #define HD_new_keys HD_LM2, HD_LB2 // new #define HD_open_keys HD_LM1, HD_LB1 // open @@ -213,12 +239,9 @@ #define HD_swrd_keys HD_LB4, HD_LB0 // select word #define HD_undo_keys HD_LB4, HD_LB3 // undo #define HD_redo_keys HD_LB4, HD_LB3, HD_LB2 // redo -//#define HD_cut_keys HD_LB4, HD_LB2 // cut #define HD_copy_keys HD_LB3, HD_LB2 // copy (hold for cut) #define HD_pste_keys HD_LB2, HD_LB1 // paste (hold for paste-match) - - #ifdef JP_MODE_ENABLE #ifdef JP_YOUON_COMBOS // Major Japanese contracted consonants as combos @@ -259,7 +282,9 @@ #define JP_the_keys HD_LM2, HD_LM1, HD_RM2 // てぇ #define JP_tho_keys HD_LM2, HD_LM1, HD_RB2 //　てょ #define JP_dha_keys HD_LB1, HD_RM1 // でゃ -#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ +#ifndef EN_PRONOUN_COMBOS +#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ conflicts with I'd (so handle it there if present) +#endif #define JP_dhu_keys HD_LB1, HD_RB1 //　でゅ #define JP_dhe_keys HD_LB1, HD_RM2 // でぇ #define JP_dho_keys HD_LB1, HD_RB2 //　でょ @@ -289,5 +314,4 @@ #endif // JP_YOUON_COMBOS // Major Japanese contracted sounds as combos #endif // JP_MODE_ENABLE // All Japanese mode features - #endif // COMBO_ENABLE diff --git a/handsdown/mi-config.h b/handsdown/mi-config.h index 028f479..174d29e 100644 --- a/handsdown/mi-config.h +++ b/handsdown/mi-config.h @@ -4,38 +4,9 @@ // #define HD_adaptive_code "handsdown/mi-adaptive.c" // -// -// Alpha Layer for a 34 key formfactor -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ -// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ -// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ -// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭──────────╯ -// ╰─────────╯ ╰──────────╯ -// Hands Down Mithril -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ W P G D Z │ │ #$ .: /* '[ J │ -// │ C N S T K | | ,; I E A H │ -// │ Y B F M V │ │ -+ U O "] L │ -// ╰───────────╮ BSP R │ │ SPC RET ╭──────────╯ -// ╰─────────╯ ╰──────────╯ -// Q (LT3) & X (LT4) are on the punc layer -// and on combos (defined below) -// -// for now... -// This will morph to being entirel properly abstracted -// similar to Miryoku, (maybe someone will make an HD Miryoku someday?) -// -// // -// We want to be able to define a combo either -// by location for variation independent, spatial referencing, or -// or by letter for mnemonic/phonetic referencing (variation dependent) -// -// BE CAREFUL to not double define a combo! -// -// First, let's add any hold-taps to the keycodes +// First, let's define HD alpha keycodes with any hold-taps/custom keycodes // #define HD_A RALT_T(KC_A) #define HD_B KC_B @@ -47,7 +18,7 @@ #define HD_H RCTL_T(KC_H) #define HD_I RSFT_T(KC_I) #define HD_J KC_J -#define HD_K LT(L_NUMPAD,KC_K) +#define HD_K LT(L_NUM,KC_K) #define HD_L KC_L #define HD_M KC_M #define HD_N RALT_T(KC_N) @@ -66,63 +37,112 @@ #define HD_MINS KC_MINS #define HD_HASH KC_HASH -#define HD_SPC LT(L_PUNCT,KC_SPC) -#define HD_BSPC LT(L_FN_NUM,KC_BSPC) +#define HD_SPC LT(L_SYM,KC_SPC) +#define HD_BSPC LT(L_FUN,KC_BSPC) #define HD_ENT LT(L_NAV,KC_ENT) #define HD_QUOT KC_QUOT #define HD_DQUO KC_DQUO #define HD_SLSH KC_SLSH #define HD_DOT KC_DOT -#define HD_COMM LT(L_FN_NUM, KC_COMM) +#define HD_COMM LT(L_FUN, KC_COMM) +// Now let's place these HD keycodes on the keymap +// for variation independent spatial referencing by key position // -// Now let's also define the keycodes on the map for spatial referencing +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 // -// (is there any way to combine these 2 steps?) // +// Base (alpha) Layer Hands Down Mithril (HRMs /+ thumb mods) +// ╭─────────────────────╮ ╭─────────────────────╮ +// esc │ W P G D Z │ L_CFG L_NUM │ #$ .: /* '[ J │ LANG2/henk +// tab │ C N S T K | ( ) | ,; I E A H │ LANG1/mhen +// Z │ Y B F M V │ [ copy pste ] │ -+ U O "] L │ Q +// ╰───────────╮ bsp R │ & | │ spc ret ╭──────────╯ +// left rght app ╰─────────╯ ╰──────────╯ tgLN up dn +// +// For small boards, Q (LT3) & Z (LT4) are (also) on the sym layer +// and accessible combos (defined below) +// + +#define HD_LT5 KC_ESC #define HD_LT4 HD_W #define HD_LT3 HD_P #define HD_LT2 HD_G #define HD_LT1 HD_D #define HD_LT0 HD_Z +#define HD_LTA OSL(L_CFG) +#define HD_RTA TG(L_NUM) #define HD_RT0 HD_HASH #define HD_RT1 HD_DOT #define HD_RT2 HD_SLSH #define HD_RT3 HD_QUOT #define HD_RT4 HD_J +#define HD_RT5 KC_LNG2 +#define HD_LM5 KC_TAB #define HD_LM4 HD_C #define HD_LM3 HD_N #define HD_LM2 HD_S #define HD_LM1 HD_T #define HD_LM0 HD_K +#define HD_LMA KC_LPRN +#define HD_RMA KC_RPRN #define HD_RM0 HD_COMM #define HD_RM1 HD_I #define HD_RM2 HD_E #define HD_RM3 HD_A #define HD_RM4 HD_H +#define HD_RM5 KC_LNG1 +#define HD_LB5 HD_Z #define HD_LB4 HD_Y #define HD_LB3 HD_B #define HD_LB2 HD_F #define HD_LB1 HD_M #define HD_LB0 HD_V +#define HD_LBA LT(L_NUM, KC_LBRC) +#define HD_LBB LT(L_FUN,SK_COPY) +#define HD_RBB LT(L_FUN,SK_PSTE) +#define HD_RBA LT(L_NAV,KC_RBRC) #define HD_RB0 HD_MINS #define HD_RB1 HD_U #define HD_RB2 HD_O #define HD_RB3 HD_DQUO #define HD_RB4 HD_L +#define HD_RB5 HD_Q -//Primary Thumbs (others unique to the board) +//Primary Thumbs 1-3 (others are unique to the board) +#define HD_LH5 KC_LEFT +#define HD_LH4 LT(L_FUN,KC_MUTE) +#define HD_LH3 KC_APP #define HD_LH2 HD_BSPC #define HD_LH1 HD_R +#define HD_LH0 LT(L_CFG,KC_MUTE) +#define HD_LHA LT(L_NAV,KC_LNG2) +#define HD_RHA LT(L_SYM,KC_LNG1) +#define HD_RH0 LT(L_CFG,KC_MPLY) #define HD_RH1 HD_SPC #define HD_RH2 HD_ENT - - +#define HD_RH3 TG(L_NUM) +#define HD_RH4 LT(L_FUN,KC_MPLY) +#define HD_RH5 KC_DN #ifdef COMBO_ENABLE // +// We want to be able to define a combo by location +// for variation independent, spatial referencing, or +// by letter for mnemonic/phonetic referencing (variation dependent) +// put this sort of obscures the definitions…so… +// +// BE CAREFUL to not double define a combo! +// // Combo definitions that rely on phonetics/mnemonics for their locations. // // Combos that are spacially organized don't need to be redefined @@ -131,20 +151,23 @@ // These few spatial combos may move to accommodate some mnemonic combos, // notably the H-digraph combos that inhabit close areas. // -#define HD_tab_keys HD_LT1, HD_LT0 // tab +#define HD_tab_keys HD_LM3, HD_LM1 // tab +#define HD_stab_keys HD_LM3, HD_LM2, HD_LM1 // hard-ENTER/page break #define HD_spc_keys HD_LM1, HD_LM0 // SPACE -#define HD_ent_keys HD_LB1, HD_LB0 // ENTER +#define HD_ent_keys HD_LB0, HD_LB1 // ENTER #define HD_ent2_keys HD_LB0, HD_LB1, HD_LB2 // hard-ENTER/page break +#define APPMENUKEYS HD_LB3, HD_LB1 // APPMENU -// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3) +// TEXT ENTRY - off map standard alphas (also on Layer L_SYM @ Z=LT4 & Q=LT3) // #define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u) -#define HD_L1_keys HD_LM3, HD_LM1 // ex. TYPE "z" +#define HD_L1_keys HD_LT1, HD_LT0 // ex. TYPE "z" #define HD_L1 HD_X //#define HD_L2_keys HD_LM3, HD_LM1 // ex. TYPE "x" //#define HD_L2 HD_X //#define HD_L3_keys HD_LM3, HD_LM1 // ex. TYPE "j" //#define HD_L3 HD_J + // // H digraph combos // try to make these use the lead letter and a neighbor. @@ -157,14 +180,14 @@ #define HD_Gh_keys HD_LT2, HD_LT1 // TYPE "gh" #define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch" +// Should we put all the diacritic keys here? +// or get keep them all in the common area (if they all share +// HD Neu vowel block)? #define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ #define HD_AE_lig_keys HD_RM3, HD_RB3 // Æ - #ifdef EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans -// -// Always check for double definitions! // PRONOUNS Fast 4-7grams #define HD_Icap_keys HD_I, HD_H // TYPE "I" @@ -179,16 +202,17 @@ #define HD_youre_keys HD_Y, HD_R // TYPE "you're" #define HD_youve_keys HD_Y, HD_V // TYPE "you've" #define HD_your_keys HD_Y, HD_P // TYPE "your" "P" for "possessive" case + #define HD_their_keys HD_T, HD_W // TYPE "their" #6 #define HD_they_keys HD_T, HD_Y // "they" #23 + 've #define HD_theyd_keys HD_T, HD_X // "they'd" #23 + 've #define HD_theyll_keys HD_T, HD_L // "they'll" #23 + 've #define HD_theyre_keys HD_T, HD_QUOT // "they're" +// deictics. Are these really necessary? #define HD_there_keys HD_T, HD_F // TYPE "there" #7 + 's #define HD_here_keys HD_H, HD_R // TYPE "here" #5 + 's - #ifdef EN_W_PRONOUNS #define HD_where_keys HD_X, HD_R // "where" + 's #define HD_wed_keys HD_X, HD_G // TYPE "we'd" + 've @@ -197,13 +221,14 @@ #define HD_weve_keys HD_X, HD_J // TYPE "we've" #endif // EN_W_PRONOUNS -#endif // EN_PRONOUN_keysS_ALL -#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans - - +#endif // EN_PRONOUNS_ALL +#endif // EN_PRONOUNS // the entirely unnecessary pronoun combo shenanigans // SEMANTIC FUNCTIONS ** uses SemKeys ** // Spatially arranged on the QWERTY ZXCV locations +// independent of the HD Alphas, though since some of +// the above combos may compete for the same locations, +// we'll define them all here. // #define HD_new_keys HD_LM2, HD_LB2 // new #define HD_open_keys HD_LM1, HD_LB1 // open @@ -214,12 +239,9 @@ #define HD_swrd_keys HD_LB4, HD_LB0 // select word #define HD_undo_keys HD_LB4, HD_LB3 // undo #define HD_redo_keys HD_LB4, HD_LB3, HD_LB2 // redo -//#define HD_cut_keys HD_LB4, HD_LB2 // cut #define HD_copy_keys HD_LB3, HD_LB2 // copy (hold for cut) #define HD_pste_keys HD_LB2, HD_LB1 // paste (hold for paste-match) - - #ifdef JP_MODE_ENABLE #ifdef JP_YOUON_COMBOS // Major Japanese contracted consonants as combos @@ -260,7 +282,9 @@ #define JP_the_keys HD_LM2, HD_LM1, HD_RM2 // てぇ #define JP_tho_keys HD_LM2, HD_LM1, HD_RB2 //　てょ #define JP_dha_keys HD_LB1, HD_RM1 // でゃ -#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ +#ifndef EN_PRONOUN_COMBOS +#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ conflicts with I'd (so handle it there if present) +#endif #define JP_dhu_keys HD_LB1, HD_RB1 //　でゅ #define JP_dhe_keys HD_LB1, HD_RM2 // でぇ #define JP_dho_keys HD_LB1, HD_RB2 //　でょ @@ -290,5 +314,4 @@ #endif // JP_YOUON_COMBOS // Major Japanese contracted sounds as combos #endif // JP_MODE_ENABLE // All Japanese mode features - #endif // COMBO_ENABLE diff --git a/handsdown/nu-adaptive.c b/handsdown/nu-adaptive.c new file mode 100644 index 0000000..46da78b --- /dev/null +++ b/handsdown/nu-adaptive.c @@ -0,0 +1,371 @@ +/* + Adaptive Keys + Called from within process_record_user + + Tailored for HD Neu (neu) + + NOTE: assumed dual-function keys (MOD_TAP, LAYER_TAP) have already been handled AND + FILTERED OUT! The combos handler will have already taken out combo candidates, + which have a shorter keydown threshhold (COMBO_TERM). + + All the goto shenanigans should be resolved after complete migration to STM/RP controllersr + (not totally possible, as many of my boards have embedded AVR mcus) + + */ +// Hands Down Neu +// ╭─────────────────────╮ ╭─────────────────────╮ +// │ W F M P V │ │ #$ .: /* "[ '] │ +// │ R S N T B | | ,; A E I H │ +// │ X C L D G │ │ -+ U O Y K │ +// ╰───────────╮ BSP SPC │ │ SPC RET ╭──────────╯ +// ╰─────────╯ ╰──────────╯ +// Q (LT3) & Z (LT4) are on the punc layer + +bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) { + bool return_state = true; // assume we don't do anything. + uint16_t keycode = *calling_keycode; + + // Are we in an adaptive context? (adaptive on is assumed). + if (timer_elapsed(prior_keydown) > ADAPTIVE_TERM) { // outside adaptive threshhold + prior_keycode = prior_keydown = 0; // turn off Adaptives. + return true; // no adaptive conditions, so return. + } + + // K, this could be adaptive, so process. + saved_mods = get_mods(); + + if (!caps_word_on) { // turn off shift, (first-words & Proper nouns) + unregister_mods(MOD_MASK_SHIFT); //CAPS_WORD/LOCK won't be affected. + } // may want more granular control than this… + + switch (keycode & QK_BASIC_MAX) { // process ignoring multi-function keys + +/* +// Left hand adaptives (most are single-handed neighbor fingers, bc speed, dexterity limits) +*/ + case KC_B: // avoid the index-middle split + switch (prior_keycode) { + case KC_P: // pull up M over + tap_code(KC_M); + return_state = false; // done. + case KC_D: // pull L over + goto PullUpLAndExit; // short jumps save bytes + break; + } + break; + case KC_M: // M becomes L (pull up "L" to same row) + switch (prior_keycode) { + case KC_P: // + case KC_F: // +PullUpLAndExit: + tap_code(KC_L); // + return_state = false; // done. + break; + case KC_W: // WM = LM (LM 20x more common) +ReplacePriorWithL: + tap_code(KC_BSPC); + tap_code(KC_L); + break; + } + break; + case KC_D: // + switch (prior_keycode) { // + case KC_G: + goto PullUpLAndExit; // short jumps save bytes + } + break; + case KC_P: + switch (prior_keycode) { + case KC_F: // avoid the scissor + goto ReplacePriorWithL; // short jumps save bytes + case KC_W: + tap_code(KC_BSPC); + send_string("lml"); // for "calmly" but not quite intuitive… + return_state = false; // done. + break; + case KC_V: // avoid the index-middle split + goto PullUpLAndExit; // short jumps save bytes + } + break; + case KC_G: // avoid the index-middle split + switch (prior_keycode) { + case KC_T: // pull N over + tap_code(KC_N); + return_state = false; // done. + case KC_D: // pull L over + goto ReplacePriorWithL; + } + break; + + case KC_T: // alt fingering remedy for middle-index splits + switch (prior_keycode) { + case KC_B: // + goto PullUpLAndExit; // short jumps save bytes + break; + case KC_G: + send_string("ght"); // GHT is much more common + return_state = false; // done. + break; + } + break; + + +/* +// right hand adaptives +*/ + + case KC_H: // How often are we likely to hit BS so quickly after? + switch (prior_keycode) { // maybe OK? What about xxR? resulting in a SFB on thumb? + case KC_A: // AE is a fraction less common, but I find the EAE trill harder than EAH. + tap_code(KC_U); // "AH" yields "AU" (8x more common) + return_state = false; // done. + break; + case KC_E: + tap_code(KC_O); // "EH" yields "EO" (1.75:1) + return_state = false; // done. + break; + case KC_O: + tap_code(KC_E); // "OH" yields "OE" (almost 1:1, but eliminates an SFB?) + return_state = false; // done. + break; + case KC_U: + tap_code(KC_A); // "UH" yields "UA" (126x more common) + return_state = false; // done. + break; + + } + break; + + case KC_K: + switch (prior_keycode) { + case KC_Y: // eliminate SFB on ring finger + tap_code(KC_I); + return_state = false; // done. + break; + } + break; + case KC_U: + switch (prior_keycode) { + case KC_K: // make KU send Qu + tap_code(KC_BSPC); + tap_code(KC_Q); + break; + } + break; + + +#ifdef THUMB_REPEATER + case HD_REPEATER_A: // Make a repeat key of the secondary thumb key on both sides + case HD_REPEATER_B: // for most common double letters (inherently SFBs) + switch (prior_keycode) { + case KC_A ... KC_SLASH: // Any alpha can be repeated? +/* double-letter frequencies from Peter Norvig's data + case KC_L: // 0.577% + case KC_S: // 0.405% + case KC_E: // 0.378% + case KC_O: // 0.210% + case KC_T: // 0.171% + case KC_F: // 0.146% + case KC_P: // 0.137% + case KC_R: // 0.121% + case KC_M: // 0.096% + case KC_C: // 0.083% + case KC_N: // 0.073% + case KC_D: // 0.043% + case KC_G: // 0.025% + case KC_I: // 0.023% + case KC_B: // 0.011% + case KC_A: // 0.003% + case KC_Z: // 0.003% + case KC_X: // 0.003% + case KC_U: // 0.001% + case KC_H: // 0.001% +*/ + tap_code(prior_keycode); // eliminate SFB on double + return_state = false; // done. + } + break; +#endif +#ifdef ADAPTIVE_TRAILER +// Using Adaptives for macros (like a flexible LeaderKey) + case ADAPTIVE_TRAILER: + switch (prior_keycode) { +#ifdef adaptAMINS + case KC_A: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptAMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptBMINS + case KC_B: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptBMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptCMINS + case KC_C: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptCMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptDMINS + case KC_D: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptDMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptEMINS + case KC_E: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptEMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptFMINS + case KC_F: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptFMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptGMINS + case KC_G: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptGMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptHMINS + case KC_H: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptHMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptIMINS + case KC_I: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptIMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptJMINS + case KC_J: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptJMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptKMINS + case KC_K: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptKMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptLMINS + case KC_L: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptLMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptMMINS + case KC_M: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptMMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptNMINS + case KC_N: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptNMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptOMINS + case KC_O: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptOMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptPMINS + case KC_P: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptPMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptRMINS + case KC_R: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptRMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptSMINS + case KC_S: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptSMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptTMINS + case KC_T: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptTMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptUMINS + case KC_U: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptUMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptVMINS + case KC_V: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptVMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptWMINS + case KC_W: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptWMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptYMINS + case KC_Y: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptYMINS); // + return_state = false; // done. + break; +#endif +#ifdef adaptYMINS + case KC_Y: // + tap_code(KC_BSPC); // may have been lowercase + send_string(adaptYMINS); // + return_state = false; // done. + break; +#endif + } + break; +#endif // ADAPTIVE_TRAILER + + } + if (return_state) { // no adaptive processed, cancel state and pass it on. + set_mods(saved_mods); + prior_keycode = keycode = 0; + } + return return_state; // +} diff --git a/handsdown/nu-config.h b/handsdown/nu-config.h new file mode 100644 index 0000000..d814784 --- /dev/null +++ b/handsdown/nu-config.h @@ -0,0 +1,317 @@ + +// +// The Hands Down Variation dependent defs & files +// +#define HD_adaptive_code "handsdown/nu-adaptive.c" +// Neu(tronium) is the basis for Hands Down Neu variations + +// +// First, let's add any hold-taps to the keycodes +// +#define HD_A RSFT_T(KC_A) +#define HD_B KC_B +#define HD_C RALT_T(KC_C) +#define HD_D KC_D +#define HD_E RGUI_T(KC_E) +#define HD_F KC_F +#define HD_G KC_G +#define HD_H RCTL_T(KC_H) +#define HD_I RALT_T(KC_I) +#define HD_J KC_J +#define HD_K KC_K +#define HD_L KC_L +#define HD_M KC_M +#define HD_N RGUI_T(KC_N) +#define HD_O KC_O +#define HD_P KC_P +#define HD_Q KC_Q +#define HD_R RCTL_T(KC_R) +#define HD_S RALT_T(KC_S) +#define HD_T RSFT_T(KC_T) +#define HD_U KC_U +#define HD_V KC_V +#define HD_W KC_W +#define HD_X KC_X +#define HD_Y KC_Y +#define HD_Z KC_Z + +#define HD_MINS KC_MINS +#define HD_HASH KC_HASH +#define HD_SPC LT(L_SYM,KC_SPC) +#define HD_BSPC LT(L_FUN,KC_BSPC) +#define HD_ENT LT(L_NAV,KC_ENT) +#define HD_QUOT KC_QUOT +#define HD_DQUO KC_DQUO +#define HD_SLSH KC_SLSH +#define HD_DOT KC_DOT +#define HD_COMM LT(L_FUN, KC_COMM) + +// Now let's place these HD keycodes on the keymap +// for variation independent spatial referencing by key position +// +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 +// +// +// Base (alpha) Layer Hands Down Neu (HRMs /+ thumb mods) +// ╭─────────────────────╮ ╭─────────────────────╮ +// esc │ W F M P V │ L_CFG L_NUM │ #$ .: '" /* J │ LANG2/henk +// tab │ R S N T B | ( ) | ,; A E I H │ LANG1/mhen +// Z │ X C L D G │ [ copy pste ] │ -+ U O Y K │ Q +// ╰───────────╮ bsp sft │ & | │ spc ret ╭──────────╯ +// left rght app ╰─────────╯ ╰──────────╯ tgLN up dn +// +// For small boards, Q (LT3) & Z (LT4) are (also) on the sym layer +// and accessible combos (defined below) +// + +#define HD_LT5 KC_ESC +#define HD_LT4 HD_W +#define HD_LT3 HD_F +#define HD_LT2 HD_M +#define HD_LT1 HD_P +#define HD_LT0 HD_V +#define HD_LTA OSL(L_CFG) +#define HD_RTA TG(L_NUM) +#define HD_RT0 HD_HASH +#define HD_RT1 HD_DOT +#define HD_RT2 HD_QUOT +#define HD_RT3 HD_SLSH +#define HD_RT4 HD_J +#define HD_RT5 KC_LNG2 + +#define HD_LM5 KC_TAB +#define HD_LM4 HD_R +#define HD_LM3 HD_S +#define HD_LM2 HD_N +#define HD_LM1 HD_T +#define HD_LM0 HD_B +#define HD_LMA KC_LPRN +#define HD_RMA KC_RPRN +#define HD_RM0 HD_COMM +#define HD_RM1 HD_A +#define HD_RM2 HD_E +#define HD_RM3 HD_I +#define HD_RM4 HD_H +#define HD_RM5 KC_LNG1 + +#define HD_LB5 HD_Z +#define HD_LB4 HD_X +#define HD_LB3 HD_C +#define HD_LB2 HD_L +#define HD_LB1 HD_D +#define HD_LB0 HD_G +#define HD_LBA LT(L_NUM, KC_LBRC) +#define HD_LBB LT(L_FUN,SK_COPY) +#define HD_RBB LT(L_FUN,SK_PSTE) +#define HD_RBA LT(L_NAV,KC_RBRC) +#define HD_RB0 HD_MINS +#define HD_RB1 HD_U +#define HD_RB2 HD_O +#define HD_RB3 HD_Y +#define HD_RB4 HD_K +#define HD_RB5 HD_Q + +//Primary Thumbs 1-3 (others are unique to the board) +#define HD_LH5 KC_LEFT +#define HD_LH4 LT(L_FUN,KC_MUTE) +#define HD_LH3 KC_APP +#define HD_LH2 HD_BSPC +#define HD_LH1 LT(L_NAV,KC_SPC) +#define HD_LH0 LT(L_CFG,KC_MUTE) +#define HD_LHA LT(L_NAV,KC_AMPR) +#define HD_RHA LT(L_SYM,KC_PIPE) +#define HD_RH0 LT(L_CFG,KC_MPLY) +#define HD_RH1 HD_SPC +#define HD_RH2 HD_ENT +#define HD_RH3 TG(L_NUM) +#define HD_RH4 LT(L_FUN,KC_MPLY) +#define HD_RH5 KC_NO + +#ifdef COMBO_ENABLE +// +// We want to be able to define a combo by location +// for variation independent, spatial referencing, or +// by letter for mnemonic/phonetic referencing (variation dependent) +// put this sort of obscures the definitions…so… +// +// BE CAREFUL to not double define a combo! +// +// Combo definitions that rely on phonetics/mnemonics for their locations. +// +// Combos that are spacially organized don't need to be redefined +// to match the base alpha layer, so they are not included here. +// +// These few spatial combos may move to accommodate some mnemonic combos, +// notably the H-digraph combos that inhabit close areas. +// +#define HD_tab_keys HD_LM3, HD_LM1 // tab +#define HD_stab_keys HD_LM3, HD_LM2, HD_LM1 // hard-ENTER/page break +#define HD_spc_keys HD_LM1, HD_LM0 // SPACE +#define HD_ent_keys HD_LH2, HD_LH1 // ENTER +#define HD_ent2_keys HD_LB0, HD_LB1, HD_LB2 // hard-ENTER/page break +//#define APPMENU_keys HD_LT1, HD_LT0 // APPMENU + +// TEXT ENTRY - off map standard alphas (also on Layer L_SYM @ Z=LT4 & Q=LT3) +// +#define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u) +#define HD_L1_keys HD_LT1, HD_LT0 // ex. TYPE "z" +#define HD_L1 HD_Z +//#define HD_L2_keys HD_LM3, HD_LM1 // ex. TYPE "x" +//#define HD_L2 HD_X +//#define HD_L3_keys HD_LM3, HD_LM1 // ex. TYPE "j" +//#define HD_L3 HD_J + +// +// H digraph combos +// try to make these use the lead letter and a neighbor. +// +#define HD_Th_keys HD_LM2, HD_LM1 // TYPE "th" +#define HD_Ch_keys HD_LM3, HD_LM2 // TYPE "ch" +#define HD_Wh_keys HD_LT4, HD_LT3 // TYPE "wh" +#define HD_Sh_keys HD_LM4, HD_LM3 // TYPE "sh" +#define HD_Ph_keys HD_LT2, HD_LT1 // TYPE "ph" +#define HD_Gh_keys HD_LB1, HD_LB0 // TYPE "gh" +#define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch" + +// Should we put all the diacritic keys here? +// or get keep them all in the common area (if they all share +// HD Neu vowel block)? +#define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ +#define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ + +#ifdef EN_PRONOUN_COMBOS +// the entirely unnecessary pronoun combo shenanigans + +// PRONOUNS Fast 4-7grams +#define HD_Icap_keys HD_I, HD_H // TYPE "I" +#define HD_Id_keys HD_I, HD_D // TYPE "I'd"+"'ve " +#define HD_Ill_keys HD_I, HD_L // TYPE "I'll"+"'ve " +#define HD_Im_keys HD_I, HD_M // TYPE "I'm " +#define HD_Iv_keys HD_I, HD_V // TYPE "I've " + +#ifdef EN_PRONOUN_COMBOS_ALL // Admittedly of questionable value +#define HD_youd_keys HD_Y, HD_D // TYPE "you'd" + 've +#define HD_youll_keys HD_Y, HD_L // TYPE "you'll" + 've +#define HD_youre_keys HD_Y, HD_R // TYPE "you're" +#define HD_youve_keys HD_Y, HD_V // TYPE "you've" +#define HD_your_keys HD_Y, HD_P // TYPE "your" "P" for "possessive" case + +#define HD_their_keys HD_T, HD_W // TYPE "their" #6 +#define HD_they_keys HD_T, HD_Y // "they" #23 + 've +#define HD_theyd_keys HD_T, HD_X // "they'd" #23 + 've +#define HD_theyll_keys HD_T, HD_L // "they'll" #23 + 've +#define HD_theyre_keys HD_T, HD_QUOT // "they're" + +// deictics. Are these really necessary? +#define HD_there_keys HD_T, HD_F // TYPE "there" #7 + 's +#define HD_here_keys HD_H, HD_R // TYPE "here" #5 + 's + +#ifdef EN_W_PRONOUNS +#define HD_where_keys HD_X, HD_R // "where" + 's +#define HD_wed_keys HD_X, HD_G // TYPE "we'd" + 've +#define HD_well_keys HD_X, HD_M // TYPE "we'll" + 've +#define HD_were_keys HD_X, HD_QUOT // TYPE "we're" +#define HD_weve_keys HD_X, HD_J // TYPE "we've" +#endif // EN_W_PRONOUNS + +#endif // EN_PRONOUN_keysS_ALL +#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans + +// SEMANTIC FUNCTIONS ** uses SemKeys ** +// Spatially arranged on the QWERTY ZXCV locations +// independent of the HD Alphas, though since some of +// the above combos may compete for the same locations, +// we'll define them all here. +// +#define HD_new_keys HD_LM2, HD_LB2 // new +#define HD_open_keys HD_LM1, HD_LB1 // open +#define HD_close_keys HD_LM3, HD_LB3 // close +#define HD_quit_keys HD_LB0, HD_LM0 // quit +#define HD_find_keys HD_LM4, HD_LM0 // find selection +#define HD_sall_keys HD_LB4, HD_LB1 // select all +#define HD_swrd_keys HD_LB4, HD_LB0 // select word +#define HD_undo_keys HD_LB4, HD_LB3 // undo +#define HD_redo_keys HD_LB4, HD_LB3, HD_LB2 // redo +#define HD_copy_keys HD_LB3, HD_LB2 // copy (hold for cut) +#define HD_pste_keys HD_LB2, HD_LB1 // paste (hold for paste-match) + +#ifdef JP_MODE_ENABLE +#ifdef JP_YOUON_COMBOS +// Major Japanese contracted consonants as combos +// +// These will conflict with some diacritics (noted below), +// so some sort of mode-switch in process_keys_event is necessary +// for both to be used on the same board. +// +// There is also risk of conflict with spatial any phonetically/mnemonically coded combos. +// +// Major (high frequency) Japanese contracted sounds +#define JP_kya_keys HD_LM0, HD_RM1 // きゃ +#define JP_kyu_keys HD_LM0, HD_RB1 //　きゅ +#define JP_kyo_keys HD_LM0, HD_RB2 //　きょ +#define JP_sya_keys HD_LM4, HD_RM1 // しゃ +#define JP_syu_keys HD_LM4, HD_RB1 //　しゅ +#define JP_sye_keys HD_LM4, HD_RM2 //　しぇ +#define JP_syo_keys HD_LM4, HD_RB2 //　しょ +#define JP_zya_keys HD_LM3, HD_RM1 // じゃ +#define JP_zyu_keys HD_LM3, HD_RB1 //　じゅ +#define JP_zyo_keys HD_LM3, HD_RB2 //　じょ +#define JP_tya_keys HD_LM1, HD_RM1 // ちゃ +#define JP_tyu_keys HD_LM1, HD_RB1 //　ちゅ +#define JP_tye_keys HD_LM1, HD_RM2 // ちぇ +#define JP_tyo_keys HD_LM1, HD_RB2 //　ちょ +#define JP_pya_keys HD_LB3, HD_RM1 // ぴゃ +#define JP_pyu_keys HD_LB3, HD_RB1 //　ぴゅ +#define JP_pyo_keys HD_LB3, HD_RB2 //　ぴょ + +#ifdef JP_YOUON_COMBOS_ALL // All Japanese contracted sounds + +#define JP_gya_keys HD_LT1, HD_RM1 // ぎゃ +#define JP_gyu_keys HD_LT1, HD_RB1 //　ぎゅ +#define JP_gyo_keys HD_LT1, HD_RB2 //　ぎょ +#define JP_tha_keys HD_LM2, HD_LM1, HD_RM1 // てゃ +#define JP_thi_keys HD_LM2, HD_LM1, HD_RM3 // てぃ +#define JP_thu_keys HD_LM2, HD_LM1, HD_RB1 //　てゅ +#define JP_the_keys HD_LM2, HD_LM1, HD_RM2 // てぇ +#define JP_tho_keys HD_LM2, HD_LM1, HD_RB2 //　てょ +#define JP_dha_keys HD_LB1, HD_RM1 // でゃ +#ifndef EN_PRONOUN_COMBOS +#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ conflicts with I'd (so handle it there if present) +#endif +#define JP_dhu_keys HD_LB1, HD_RB1 //　でゅ +#define JP_dhe_keys HD_LB1, HD_RM2 // でぇ +#define JP_dho_keys HD_LB1, HD_RB2 //　でょ +#define JP_nya_keys HD_LM2, HD_RM1 // にゃ +#define JP_nyu_keys HD_LM2, HD_RB1 //　にゅ +#define JP_nyo_keys HD_LM2, HD_RB2 //　にょ + +//#define JP_hya_keys HD_RM4, HD_RM1 // ひゃ conflicts with diacritic +#define JP_hyu_keys HD_RM4, HD_RB1 //　ひゅ +#define JP_hyo_keys HD_RM4, HD_RB2 //　ひょ +//#define JP_fya_keys HD_RM4, HD_RM1 // ふぁ unnecessary? +//#define JP_fyu_keys HD_RM4, HD_RB1 //　ふぃ +//#define JP_fye_keys HD_RM4, HD_RB1 //　ふぇ +//#define JP_fyo_keys HD_RM4, HD_RB2 //　ふぉ + +#define JP_bya_keys HD_LB4, HD_RM1 // びゃ +#define JP_byu_keys HD_LB4, HD_RB1 //　びゅ conflicts with diacritic? +#define JP_byo_keys HD_LB4, HD_RB2 //　びょ +#define JP_mya_keys HD_LT2, HD_RM1 // みゃ +#define JP_myu_keys HD_LT2, HD_RB1 //　みゅ +#define JP_myo_keys HD_LT2, HD_RB2 //　みょ +#define JP_rya_keys HD_LH1, HD_RM1 // りゃ +#define JP_ryu_keys HD_LH1, HD_RB1 //　りゅ +#define JP_ryo_keys HD_LH1, HD_RB2 //　りょ + +#endif // JP_YOUON_COMBOS_ALL // All Japanese contracted sounds +#endif // JP_YOUON_COMBOS // Major Japanese contracted sounds as combos +#endif // JP_MODE_ENABLE // All Japanese mode features + +#endif // COMBO_ENABLE diff --git a/handsdown/vb-config.h b/handsdown/vb-config.h index 61aa5cb..25f03ee 100644 --- a/handsdown/vb-config.h +++ b/handsdown/vb-config.h @@ -4,38 +4,9 @@ // #define HD_adaptive_code "handsdown/vb-adaptive.c" // -// -// Alpha Layer for a 34 key formfactor -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ -// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ -// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ -// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭──────────╯ -// ╰─────────╯ ╰──────────╯ -// Hands Down Vibranium b -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ X W M G J │ │ #$ .: /* "[ '] │ -// │ S C N T K | | ,; A E I H │ -// │ B P L D V │ │ -+ U O Y F │ -// ╰───────────╮ BSP R │ │ SPC RET ╭──────────╯ -// ╰─────────╯ ╰──────────╯ -// Q (LT3) & Z (LT4) are on the punc layer -// and on combos (defined below) -// -// for now... -// This will morph to being entirel properly abstracted -// similar to Miryoku, (maybe someone will make an HD Miryoku someday?) -// -// // -// We want to be able to define a combo -// by location for variation independent, spatial referencing, or -// by letter for mnemonic/phonetic referencing (variation dependent) -// -// BE CAREFUL to not double define a combo! -// -// First, let's add any hold-taps to the alpha keycodes +// First, let's define HD alpha keycodes with any hold-taps/custom keycodes // #define HD_A RSFT_T(KC_A) #define HD_B KC_B @@ -47,7 +18,7 @@ #define HD_H RCTL_T(KC_H) #define HD_I RALT_T(KC_I) #define HD_J KC_J -#define HD_K LT(L_NUMPAD,KC_K) +#define HD_K LT(L_NUM,KC_K) #define HD_L KC_L #define HD_M KC_M #define HD_N RGUI_T(KC_N) @@ -66,64 +37,112 @@ #define HD_MINS KC_MINS #define HD_HASH KC_HASH -#define HD_SPC LT(L_PUNCT,KC_SPC) -#define HD_BSPC LT(L_FN_NUM,KC_BSPC) +#define HD_SPC LT(L_SYM,KC_SPC) +#define HD_BSPC LT(L_FUN,KC_BSPC) #define HD_ENT LT(L_NAV,KC_ENT) #define HD_QUOT KC_QUOT #define HD_DQUO KC_DQUO #define HD_SLSH KC_SLSH #define HD_DOT KC_DOT -#define HD_COMM LT(L_FN_NUM, KC_COMM) +#define HD_COMM LT(L_FUN, KC_COMM) +// Now let's place these HD keycodes on the keymap +// for variation independent spatial referencing by key position +// +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 +// // -// Now let's place these keycodes on the map -// for variation independent spatial referencing +// Base (alpha) Layer Hands Down Vibranium-vb (HRMs /+ thumb mods) +// ╭─────────────────────╮ ╭─────────────────────╮ +// esc │ X W M G J │ L_CFG L_NUM │ #$ .: /* "[ '] │ LANG2/henk +// tab │ S C N T K | ( ) | ,; A E I H │ LANG1/mhen +// Z │ B P L D V │ [ copy pste ] │ -+ U O Y F │ Q +// ╰───────────╮ bsp R │ & | │ spc ret ╭──────────╯ +// left rght app ╰─────────╯ ╰──────────╯ tgLN up dn // -// (is there any way to combine these 2 steps?) +// For small boards, Q (LT3) & Z (LT4) are (also) on the sym layer +// and accessible combos (defined below) // + +#define HD_LT5 KC_ESC #define HD_LT4 HD_X #define HD_LT3 HD_W #define HD_LT2 HD_M #define HD_LT1 HD_G #define HD_LT0 HD_J +#define HD_LTA OSL(L_CFG) +#define HD_RTA TG(L_NUM) #define HD_RT0 HD_HASH #define HD_RT1 HD_DOT #define HD_RT2 HD_SLSH #define HD_RT3 HD_DQUO #define HD_RT4 HD_QUOT +#define HD_RT5 KC_LNG2 +#define HD_LM5 KC_TAB #define HD_LM4 HD_S #define HD_LM3 HD_C #define HD_LM2 HD_N #define HD_LM1 HD_T #define HD_LM0 HD_K +#define HD_LMA KC_LPRN +#define HD_RMA KC_RPRN #define HD_RM0 HD_COMM #define HD_RM1 HD_A #define HD_RM2 HD_E #define HD_RM3 HD_I #define HD_RM4 HD_H +#define HD_RM5 KC_LNG1 +#define HD_LB5 HD_Z #define HD_LB4 HD_B #define HD_LB3 HD_P #define HD_LB2 HD_L #define HD_LB1 HD_D #define HD_LB0 HD_V +#define HD_LBA LT(L_NUM, KC_LBRC) +#define HD_LBB LT(L_FUN,SK_COPY) +#define HD_RBB LT(L_FUN,SK_PSTE) +#define HD_RBA LT(L_NAV,KC_RBRC) #define HD_RB0 HD_MINS #define HD_RB1 HD_U #define HD_RB2 HD_O #define HD_RB3 HD_Y #define HD_RB4 HD_F +#define HD_RB5 HD_Q -//Primary Thumbs (others unique to the board) +//Primary Thumbs 1-3 (others are unique to the board) +#define HD_LH5 KC_LEFT +#define HD_LH4 LT(L_FUN,KC_MUTE) +#define HD_LH3 KC_APP #define HD_LH2 HD_BSPC #define HD_LH1 HD_R +#define HD_LH0 LT(L_CFG,KC_MUTE) +#define HD_LHA LT(L_NAV,KC_LNG2) +#define HD_RHA LT(L_SYM,KC_LNG1) +#define HD_RH0 LT(L_CFG,KC_MPLY) #define HD_RH1 HD_SPC #define HD_RH2 HD_ENT - - +#define HD_RH3 TG(L_NUM) +#define HD_RH4 LT(L_FUN,KC_MPLY) +#define HD_RH5 KC_DN #ifdef COMBO_ENABLE // +// We want to be able to define a combo by location +// for variation independent, spatial referencing, or +// by letter for mnemonic/phonetic referencing (variation dependent) +// put this sort of obscures the definitions…so… +// +// BE CAREFUL to not double define a combo! +// // Combo definitions that rely on phonetics/mnemonics for their locations. // // Combos that are spacially organized don't need to be redefined @@ -132,15 +151,17 @@ // These few spatial combos may move to accommodate some mnemonic combos, // notably the H-digraph combos that inhabit close areas. // -#define HD_tab_keys HD_LT4, HD_LT3 // tab +#define HD_tab_keys HD_LM3, HD_LM1 // tab +#define HD_stab_keys HD_LM3, HD_LM2, HD_LM1 // hard-ENTER/page break #define HD_spc_keys HD_LM1, HD_LM0 // SPACE #define HD_ent_keys HD_LB0, HD_LB1 // ENTER #define HD_ent2_keys HD_LB0, HD_LB1, HD_LB2 // hard-ENTER/page break +#define APPMENU_keys HD_LT1, HD_LT0 // APPMENU -// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3) +// TEXT ENTRY - off map standard alphas (also on Layer L_SYM @ Z=LT4 & Q=LT3) // #define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u) -#define HD_L1_keys HD_LM3, HD_LM1 // ex. TYPE "z" +#define HD_L1_keys HD_LT4, HD_LT3 // ex. TYPE "z" #define HD_L1 HD_Z //#define HD_L2_keys HD_LM3, HD_LM1 // ex. TYPE "x" //#define HD_L2 HD_X @@ -159,10 +180,12 @@ #define HD_Gh_keys HD_LT2, HD_LT1 // TYPE "gh" #define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch" +// Should we put all the diacritic keys here? +// or get keep them all in the common area (if they all share +// HD Neu vowel block)? #define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ #define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ - #ifdef EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans @@ -176,9 +199,9 @@ #ifdef EN_PRONOUN_COMBOS_ALL // Admittedly of questionable value #define HD_youd_keys HD_Y, HD_D // TYPE "you'd" + 've #define HD_youll_keys HD_Y, HD_L // TYPE "you'll" + 've -#define HD_youre_keys HD_Y, HD_R // TYPE "you're" +#define HD_youre_keys HD_Y, HD_F // TYPE "you're" #define HD_youve_keys HD_Y, HD_V // TYPE "you've" -#define HD_your_keys HD_Y, HD_P // TYPE "your" "P" for "possessive" case +#define HD_your_keys HD_Y, HD_R // TYPE "your" #define HD_their_keys HD_T, HD_B // TYPE "their" #6 (R on same finger in Neu) #define HD_theyre_keys HD_T, HD_X // "they're" (R on same finger in Neu) @@ -193,19 +216,22 @@ #ifdef EN_W_PRONOUNS #define HD_where_keys HD_X, HD_R // "where" + 's +#define HD_were_keys HD_X, HD_QUOT // TYPE "we're" #define HD_wed_keys HD_X, HD_G // TYPE "we'd" + 've #define HD_well_keys HD_X, HD_M // TYPE "we'll" + 've -#define HD_were_keys HD_X, HD_QUOT // TYPE "we're" #define HD_weve_keys HD_X, HD_J // TYPE "we've" #endif // EN_W_PRONOUNS -#endif // EN_PRONOUN_keysS_ALL -#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans +#endif // EN_PRONOUNS_ALL +#endif // EN_PRONOUNS // the entirely unnecessary pronoun combo shenanigans // SEMANTIC FUNCTIONS ** uses SemKeys ** // Spatially arranged on the QWERTY ZXCV locations +// independent of the HD Alphas, though since some of +// the above combos may compete for the same locations, +// we'll define them all here. // #define HD_new_keys HD_LM2, HD_LB2 // new #define HD_open_keys HD_LM1, HD_LB1 // open @@ -216,7 +242,6 @@ #define HD_swrd_keys HD_LB4, HD_LB0 // select word #define HD_undo_keys HD_LB4, HD_LB3 // undo #define HD_redo_keys HD_LB4, HD_LB3, HD_LB2 // redo -//#define HD_cut_keys HD_LB4, HD_LB2 // cut #define HD_copy_keys HD_LB3, HD_LB2 // copy (hold for cut) #define HD_pste_keys HD_LB2, HD_LB1 // paste (hold for paste-match) diff --git a/handsdown/vv-adaptive.c b/handsdown/vv-adaptive.c index 92fa998..882af19 100644 --- a/handsdown/vv-adaptive.c +++ b/handsdown/vv-adaptive.c @@ -19,7 +19,8 @@ bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) uint16_t keycode = *calling_keycode; // Are we in an adaptive context? (adaptive on is assumed). - if (timer_elapsed(prior_keydown) > ADAPTIVE_TERM) { // outside adaptive threshhold + if (timer_elapsed(prior_keydown) > ADAPTIVE_TERM + || ((keycode == KC_SLSH) && (timer_elapsed(prior_keydown) > ADAPTIVE_TERM * 16))) { prior_keycode = prior_keydown = 0; // turn off Adaptives. return true; // no adaptive conditions, so return. } @@ -174,6 +175,7 @@ bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) // right hand adaptives */ + case KC_SLSH: case KC_H: // H precedes a vowel much more often than it follows (thanks, Ancient Greek!) switch (prior_keycode) { // maybe OK? What about xxR? resulting in a SFB on thumb? case KC_A: // AE is a fraction less common, but I find the EAE trill harder than EAH. @@ -208,9 +210,8 @@ bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) break; } break; - case KC_J: + case KC_DQUO: switch (prior_keycode) { - case KC_QUOT: case KC_B: // tap_code(KC_Y); // BJ = BY (eliminate scissor on ring finger BY is 6x BJ) return_state = false; // done. @@ -228,7 +229,6 @@ bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) return_state = false; // done. break; case KC_QUOT: // - case KC_J: // case KC_B: // tap_code(KC_O); // (eliminate scissor) return_state = false; // done. @@ -238,7 +238,6 @@ bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) case KC_DOT: switch (prior_keycode) { case KC_QUOT: // This could be smarter (only after O rolled up) - case KC_J: // case KC_B: // tap_code(KC_U); // (eliminate scissor) return_state = false; // done. @@ -252,10 +251,6 @@ bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) send_string(".org"); return_state = false; // done. break; - case KC_J: - tap_code(KC_I); // (eliminate SFB) - return_state = false; // done. - break; } break; diff --git a/handsdown/vv-config.h b/handsdown/vv-config.h index 325af8e..4edcfd4 100644 --- a/handsdown/vv-config.h +++ b/handsdown/vv-config.h @@ -2,43 +2,11 @@ // // The Hands Down Variation dependent defs & files // -#define HD_adaptive_code "handsdown/vv-adaptive.c" -// -// -// KEY POSITION Names -//╭─────────────────────╮ ╭─────────────────────╮ -//│ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ -//│ LM4 LM3 LM2 LM1 LM0 │ │ RM0 RM1 RM2 RM3 RM4 │ -//│ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ -//╰───────────╮ LH2 LH1 | | RH1 RH2 ╭───────────╯ -// ╰─────────╯ ╰─────────╯ -// -// Base (alpha) Layer Hands Down Vibranium-vv -// Building for a 34 key board -// ╭─────────────────╮ ╭─────────────────╮ -// │ X W M G "[ │ │ #$ .: '] J B │ -// │ S C N T K | | ,; A E I H │ -// │ V F L D /* │ │ -+ U O Y F │ -// ╰───────╮ BSP R │ │ SPC RET ╭──────╯ -// ╰─────────╯ ╰──────────╯ -// -// Q (LT3) & Z (LT4) are on the punc layer -// and on combos (defined below) -// -// for now... -// This will morph to being entirel properly abstracted -// similar to Miryoku, (maybe someone will make an HD Miryoku someday?) -// +#define HD_adaptive_code "handsdown/vb-adaptive.c" // // -// We want to be able to define a combo -// by location for variation independent, spatial referencing, or -// by letter for mnemonic/phonetic referencing (variation dependent) -// -// BE CAREFUL to not double define a combo! -// -// First, let's add any hold-taps to the alpha keycodes +// First, let's define HD alpha keycodes with any hold-taps/custom keycodes // #define HD_A RSFT_T(KC_A) #define HD_B KC_B @@ -50,7 +18,7 @@ #define HD_H RCTL_T(KC_H) #define HD_I RALT_T(KC_I) #define HD_J KC_J -#define HD_K LT(L_NUMPAD,KC_K) +#define HD_K LT(L_NUM,KC_K) #define HD_L KC_L #define HD_M KC_M #define HD_N RGUI_T(KC_N) @@ -69,64 +37,112 @@ #define HD_MINS KC_MINS #define HD_HASH KC_HASH -#define HD_SPC LT(L_PUNCT,KC_SPC) -#define HD_BSPC LT(L_FN_NUM,KC_BSPC) +#define HD_SPC LT(L_SYM,KC_SPC) +#define HD_BSPC LT(L_FUN,KC_BSPC) #define HD_ENT LT(L_NAV,KC_ENT) #define HD_QUOT KC_QUOT #define HD_DQUO KC_DQUO #define HD_SLSH KC_SLSH #define HD_DOT KC_DOT -#define HD_COMM LT(L_FN_NUM, KC_COMM) +#define HD_COMM LT(L_FUN, KC_COMM) +// Now let's place these HD keycodes on the keymap +// for variation independent spatial referencing by key position +// +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 // -// Now let's place these keycodes on the map -// for variation independent spatial referencing // -// (is there any way to combine these 2 steps?) +// Base (alpha) Layer Hands Down Vibranium-vv (HRMs /+ thumb mods) +// ╭─────────────────────╮ ╭─────────────────────╮ +// esc │ X W M G J │ L_CFG L_NUM │ #$ .: '[ "] B │ LANG2/henk +// tab │ S C N T K | ( ) | ,; A E I H │ LANG1/mhen +// Z │ V F L D /* │ [ copy pste ] │ -+ U O Y P │ Q +// ╰───────────╮ bsp R │ & | │ spc ret ╭──────────╯ +// left rght app ╰─────────╯ ╰──────────╯ tgLN up dn // +// For small boards, Q (LT3) & Z (LT4) are (also) on the sym layer +// and accessible combos (defined below) +// + +#define HD_LT5 KC_ESC #define HD_LT4 HD_X #define HD_LT3 HD_W #define HD_LT2 HD_M #define HD_LT1 HD_G -#define HD_LT0 HD_DQUO +#define HD_LT0 HD_J +#define HD_LTA OSL(L_CFG) +#define HD_RTA TG(L_NUM) #define HD_RT0 HD_HASH #define HD_RT1 HD_DOT #define HD_RT2 HD_QUOT -#define HD_RT3 HD_J +#define HD_RT3 HD_DQUO #define HD_RT4 HD_B +#define HD_RT5 KC_LNG2 +#define HD_LM5 KC_TAB #define HD_LM4 HD_S #define HD_LM3 HD_C #define HD_LM2 HD_N #define HD_LM1 HD_T #define HD_LM0 HD_K +#define HD_LMA KC_LPRN +#define HD_RMA KC_RPRN #define HD_RM0 HD_COMM #define HD_RM1 HD_A #define HD_RM2 HD_E #define HD_RM3 HD_I #define HD_RM4 HD_H +#define HD_RM5 KC_LNG1 +#define HD_LB5 HD_Z #define HD_LB4 HD_V #define HD_LB3 HD_F #define HD_LB2 HD_L #define HD_LB1 HD_D #define HD_LB0 HD_SLSH +#define HD_LBA LT(L_NUM, KC_LBRC) +#define HD_LBB LT(L_FUN,SK_COPY) +#define HD_RBB LT(L_FUN,SK_PSTE) +#define HD_RBA LT(L_NAV,KC_RBRC) #define HD_RB0 HD_MINS #define HD_RB1 HD_U #define HD_RB2 HD_O #define HD_RB3 HD_Y #define HD_RB4 HD_P +#define HD_RB5 HD_Q -//Primary Thumbs (others unique to the board) +//Primary Thumbs 1-3 (others are unique to the board) +#define HD_LH5 KC_LEFT +#define HD_LH4 LT(L_FUN,KC_MUTE) +#define HD_LH3 KC_APP #define HD_LH2 HD_BSPC #define HD_LH1 HD_R +#define HD_LH0 LT(L_CFG,KC_MUTE) +#define HD_LHA LT(L_NAV,KC_LNG2) +#define HD_RHA LT(L_SYM,KC_LNG1) +#define HD_RH0 LT(L_CFG,KC_MPLY) #define HD_RH1 HD_SPC #define HD_RH2 HD_ENT - - +#define HD_RH3 TG(L_NUM) +#define HD_RH4 LT(L_FUN,KC_MPLY) +#define HD_RH5 KC_DN #ifdef COMBO_ENABLE // +// We want to be able to define a combo by location +// for variation independent, spatial referencing, or +// by letter for mnemonic/phonetic referencing (variation dependent) +// put this sort of obscures the definitions…so… +// +// BE CAREFUL to not double define a combo! +// // Combo definitions that rely on phonetics/mnemonics for their locations. // // Combos that are spacially organized don't need to be redefined @@ -135,15 +151,17 @@ // These few spatial combos may move to accommodate some mnemonic combos, // notably the H-digraph combos that inhabit close areas. // -#define HD_tab_keys HD_LT4, HD_LT3 // tab +#define HD_tab_keys HD_LM3, HD_LM1 // tab +#define HD_stab_keys HD_LM3, HD_LM2, HD_LM1 // hard-ENTER/page break #define HD_spc_keys HD_LM1, HD_LM0 // SPACE #define HD_ent_keys HD_LB0, HD_LB1 // ENTER #define HD_ent2_keys HD_LB0, HD_LB1, HD_LB2 // hard-ENTER/page break +//#define APPMENU_keys HD_LT1, HD_LT0 // APPMENU -// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3) +// TEXT ENTRY - off map standard alphas (also on Layer L_SYM @ Z=LT4 & Q=LT3) // #define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u) -#define HD_L1_keys HD_LM3, HD_LM1 // ex. TYPE "z" +#define HD_L1_keys HD_LT1, HD_LT0 // ex. TYPE "z" #define HD_L1 HD_Z //#define HD_L2_keys HD_LM3, HD_LM1 // ex. TYPE "x" //#define HD_L2 HD_X @@ -162,10 +180,12 @@ #define HD_Gh_keys HD_LT2, HD_LT1 // TYPE "gh" #define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch" +// Should we put all the diacritic keys here? +// or get keep them all in the common area (if they all share +// HD Neu vowel block)? #define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ #define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ - #ifdef EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans @@ -179,9 +199,9 @@ #ifdef EN_PRONOUN_COMBOS_ALL // Admittedly of questionable value #define HD_youd_keys HD_Y, HD_D // TYPE "you'd" + 've #define HD_youll_keys HD_Y, HD_L // TYPE "you'll" + 've -#define HD_youre_keys HD_Y, HD_QUOT // TYPE "you're" +#define HD_youre_keys HD_Y, HD_F // TYPE "you're" #define HD_youve_keys HD_Y, HD_V // TYPE "you've" -#define HD_your_keys HD_Y, HD_R // TYPE "your" "P" for "possessive" case +#define HD_your_keys HD_Y, HD_R // TYPE "your" #define HD_their_keys HD_T, HD_B // TYPE "their" #6 (R on same finger in Neu) #define HD_theyre_keys HD_T, HD_X // "they're" (R on same finger in Neu) @@ -193,22 +213,22 @@ #define HD_there_keys HD_T, HD_R // TYPE "there" #7 + 's #define HD_here_keys HD_H, HD_R // TYPE "here" #5 + 's - #ifdef EN_W_PRONOUNS #define HD_where_keys HD_X, HD_R // "where" + 's +#define HD_were_keys HD_X, HD_QUOT // TYPE "we're" #define HD_wed_keys HD_X, HD_G // TYPE "we'd" + 've #define HD_well_keys HD_X, HD_M // TYPE "we'll" + 've -#define HD_were_keys HD_X, HD_QUOT // TYPE "we're" #define HD_weve_keys HD_X, HD_J // TYPE "we've" #endif // EN_W_PRONOUNS -#endif // EN_PRONOUN_keysS_ALL -#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans - - +#endif // EN_PRONOUNS_ALL +#endif // EN_PRONOUNS // the entirely unnecessary pronoun combo shenanigans // SEMANTIC FUNCTIONS ** uses SemKeys ** // Spatially arranged on the QWERTY ZXCV locations +// independent of the HD Alphas, though since some of +// the above combos may compete for the same locations, +// we'll define them all here. // #define HD_new_keys HD_LM2, HD_LB2 // new #define HD_open_keys HD_LM1, HD_LB1 // open @@ -219,12 +239,9 @@ #define HD_swrd_keys HD_LB4, HD_LB0 // select word #define HD_undo_keys HD_LB4, HD_LB3 // undo #define HD_redo_keys HD_LB4, HD_LB3, HD_LB2 // redo -//#define HD_cut_keys HD_LB4, HD_LB2 // cut #define HD_copy_keys HD_LB3, HD_LB2 // copy (hold for cut) #define HD_pste_keys HD_LB2, HD_LB1 // paste (hold for paste-match) - - #ifdef JP_MODE_ENABLE #ifdef JP_YOUON_COMBOS // Major Japanese contracted consonants as combos @@ -297,5 +314,4 @@ #endif // JP_YOUON_COMBOS // Major Japanese contracted sounds as combos #endif // JP_MODE_ENABLE // All Japanese mode features - #endif // COMBO_ENABLE diff --git a/kyria/Kyria Hands Down.pdf b/kyria/Kyria Hands Down.pdf new file mode 100644 index 0000000..a2b5cb2 Binary files /dev/null and b/kyria/Kyria Hands Down.pdf differ diff --git a/kyria/config.h b/kyria/config.h new file mode 100644 index 0000000..461aa5c --- /dev/null +++ b/kyria/config.h @@ -0,0 +1,27 @@ + +#pragma once + +// Kyria hardware specific bits +// +// Allows to use either side as the master. Look at the documentation for info: +// https://docs.qmk.fm/#/config_options?id=setting-handedness +#define EE_HANDS + +//#ifdef PRODUCT +//#undef PRODUCT +//#define PRODUCT HD-Kyria +//#endif + +#ifdef OLED_DRIVER_ENABLE + #define OLED_DISPLAY_128X64 + #ifdef OLED_TIMEOUT + #undef OLED_TIMEOUT + #endif + #define OLED_TIMEOUT 9000 +#endif + +#ifdef ENCODER_ENABLE + #define ENCODER_RESOLUTION 2 // old encoders + #define ENCODER_DIRECTION_FLIP // old encoders +// #define ENCODER_RESOLUTION 4 // new encoders +#endif diff --git a/kyria/kyria_hd_keymap.c b/kyria/kyria_hd_keymap.c new file mode 100644 index 0000000..a800e24 --- /dev/null +++ b/kyria/kyria_hd_keymap.c @@ -0,0 +1,68 @@ + +#include QMK_KEYBOARD_H + +#ifdef COMBO_ENABLE +#include HD_combo_def // this has the combo definitions (needed here for the QMK keymap introspection) +#endif + +#define ______ KC_TRNS +#define __no__ KC_NO + +/* The Kyria Keymap Key positions + * ,-----------------------------------------------. ,-----------------------------------------------. + * | LT5 | LT4 | LT3 | LT2 | LT1 | LT0 | | RT0 | RT1 | RT2 | RT3 | RT4 | RT5 | + * |-------+-------+-------+-------+-------+-------+ +-------+-------+-------+-------+-------+-------| + * | LM5 | LM4 | LM3 | LM2 | LM1 | LM0 | | RM0 | RM1 | RM2 | RM3 | RM4 | RM5 | + * |-------+-------+-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------+-------+-------| + * | LB5 | LB4 | LB3 | LB2 | LB1 | LB0 | LBA | LBB | | RBB | RBA | RB0 | RB1 | RB2 | RB3 | RB4 | RB5 | + * `-------+-------+-------+-------+-------+-------+-------+-------' '-------+-------+-------+-------+-------+-------+-------+-------' + * | LH4 | LH3 | LH2 | LH1 | LH0 | | RH0 | RH1 | RH2 | RH3 | RH4 | + * `---------------------------------------' '---------------------------------------' + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + + [L_QWERTY] = LAYOUT( + SK_COPY, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LNG2, + SK_PSTE, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_LNG1, + KC_AMPR, KC_Z, KC_X, KC_C, KC_V, KC_B, HD_LBA, HD_LBB, HD_RBB, HD_RBA, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_EQL, + LT(L_FUN,KC_MUTE), KC_APP, LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), HD_LH0, HD_RH0, LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), LT(L_FUN,KC_TAB), LT(L_FUN,KC_MPLY)), + + [L_HD] = LAYOUT( + HD_LT5, HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, HD_RT5, + HD_LM5, HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, HD_RM5, + HD_LB5, HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_LBA, HD_LBB, HD_RBB, HD_RBA, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, HD_RB5, + HD_LH4, HD_LH3, HD_LH2, HD_LH1, HD_LH0, HD_RH0, HD_RH1, HD_RH2, HD_RH3, HD_RH4), + + [L_SYM] = LAYOUT( + LS_LT5, LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, LS_RT5, + LS_LM5, LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, LS_RM5, + LS_LB5, LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_LBA, LS_LBB, LS_RBB, LS_RBA, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, LS_RB5, + LS_LH4, LS_LH3, LS_LH2, LS_LH1, LS_LH0, LS_RH0, LS_RH1, LS_RH2, LS_RH3, LS_RH4), + + [L_FUN] = LAYOUT( + LF_LT5, LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, LF_RT5, + LF_LM5, LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, LF_RM5, + LF_LB5, LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_LBA, LF_LBB, LF_RBB, LF_RBA, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, LF_RB5, + LF_LH4, LF_LH3, LF_LH2, LF_LH1, LF_LH0, LF_RH0, LF_RH1, LF_RH2, LF_RH3, LF_RH4), + + [L_NUM] = LAYOUT( + LN_LT5, LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, LN_RT5, + LN_LM5, LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, LN_RM5, + LN_LB5, LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_LBA, LN_LBB, LN_RBB, LN_RBA, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, LN_RB5, + LN_LH4, LN_LH3, LN_LH2, LN_LH1, LN_LH0, LN_RH0, LN_RH1, LN_RH2, LN_RH3, LN_RH4), + + [L_NAV] = LAYOUT( + LV_LT5, LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, LV_RT5, + LV_LM5, LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, LV_RM5, + LV_LB5, LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_LBA, LV_LBB, LV_RBB, LV_RBA, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, LV_RB5, + LV_LH4, LV_LH3, LV_LH2, LV_LH1, LV_LH0, LV_RH0, LV_RH1, LV_RH2, LV_RH3, LV_RH4), + + [L_CFG] = LAYOUT( + LC_LT5, LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, LC_RT5, + LC_LM5, LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, LC_RM5, + LC_LB5, LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_LBA, LC_LBB, LC_RBB, LC_RBA, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, LC_RB5, + LC_LH4, LC_LH3, LC_LH2, LC_LH1, LC_LH0, LC_RH0, LC_RH1, LC_RH2, LC_RH3, LC_RH4), + +}; + diff --git a/moutis.c b/moutis.c index a6a8cb7..583e2d4 100644 --- a/moutis.c +++ b/moutis.c @@ -53,22 +53,22 @@ layer_state_t layer_state_set_user(layer_state_t layer_state) { switch (biton32(layer_state)) { - case L_HDALPHA: + case L_HD: #ifdef RGBLIGHT_ENABLE rgblight_sethsv_noeeprom(128, 128, 128); break; #endif - case L_PUNCT: + case L_SYM: #ifdef RGBLIGHT_ENABLE rgblight_sethsv_noeeprom(213, 255, 128); #endif break; - case L_FN_NUM: + case L_FUN: #ifdef RGBLIGHT_ENABLE rgblight_sethsv_noeeprom(64, 255, 128); #endif break; - case L_NUMPAD: + case L_NUM: #ifdef RGBLIGHT_ENABLE rgblight_sethsv_noeeprom(85, 255, 128); #endif @@ -78,7 +78,7 @@ layer_state_t layer_state_set_user(layer_state_t layer_state) { rgblight_sethsv_noeeprom(128, 255, 128); #endif break; - case L_MEDIA_KBD: + case L_CFG: #ifdef RGBLIGHT_ENABLE rgblight_sethsv_noeeprom(0, 255, 128); #endif diff --git a/moutis.h b/moutis.h index 489f0b4..1962d91 100644 --- a/moutis.h +++ b/moutis.h @@ -4,7 +4,10 @@ // which HD alpha variation are we using? // // defines all variation dependent constants/files/keycodes, etc. -#include "handsdown/vv-config.h" +// they will be used in the respective keymap for each keyboard + +#include "handsdown/vb-config.h" // definitions for the Alpha layer and mnemonic combos +#include "moutis_layers.h" // definitions for all the other layers #ifndef USERSPACE @@ -68,12 +71,12 @@ extern rgblight_config_t rgblight_config; // Perhaps simply redefining these in the xx-config.h // to override these defs would be the right approach? // -#define DQUO_S KC_RBRC // ] -#define DQUO_A A(S(KC_BSLS)) // » -#define DQUO_SA A(S(KC_4)) // › -#define SQUO_S KC_LBRC // [ -#define SQUO_A A(KC_BSLS) // « -#define SQUO_SA A(S(KC_3)) // ‹ +#define DQUO_S KC_RBRC // ] Double quote shifted +#define DQUO_A A(S(KC_BSLS)) // » Double quote alted +#define DQUO_SA A(S(KC_4)) // › Double quote shifted & alted +#define SQUO_S KC_LBRC // [ Single quote shifted +#define SQUO_A A(KC_BSLS) // « single quote alted +#define SQUO_SA A(S(KC_3)) // ‹ single quote shifted & alted #define JRQU KC_RBRC // keycode for "[" in Japanese mode #define JLQU KC_LBRC // keycode for "]" in Japanese mode @@ -87,16 +90,15 @@ typedef union { } user_config_t; -enum my_layers { // must be difined before semantickeys.h -// enum my_layers for layout layers for HD Neu family - L_QWERTY, // 0 - QWERTY compatibility layer - L_HDALPHA, // 1 - Hands Down Alpha layer - L_PUNCT, // 2 - symbols, punctuation, off-map alphas - L_FN_NUM, // 3 - number row & function row - L_NUMPAD, // 4 - numpad (right); navpad (left) - L_NAV, // 5 - nav pad (right); meta keys (left) -// L_SYMBOLS, // diacritics are better handled by combos and semantickeys? - L_MEDIA_KBD // 6 - Media/Consumer controls; Keyboard settings +// enum my_layers for layout layers +enum my_layers {// must be difined before semantickeys.h + L_QWERTY, // 0 - QWERTY compatibility layer + L_HD, // 1 - Hands Down Alpha layer + L_SYM, // 2 - symbols, punctuation, off-map alphas + L_FUN, // 3 - function & number rows + L_NUM, // 4 - numpad (right); navpad (left) + L_NAV, // 5 - nav pad (right); meta keys (left) + L_CFG // 6 - Media/Consumer controls; Keyboard settings }; enum OS_Platform { // Used for platform support via SemKeys diff --git a/moutis_ENCODER.c b/moutis_ENCODER.c index 81813ef..3f04af9 100644 --- a/moutis_ENCODER.c +++ b/moutis_ENCODER.c @@ -35,8 +35,8 @@ bool encoder_update_user(uint8_t index, bool clockwise) { if (!index) { /* First (left) encoder */ switch(get_highest_layer(layer_state)){ - case L_PUNCT: // puncuation layer - case L_FN_NUM: + case L_SYM: // puncuation layer + case L_FUN: volbright: /* for audio scrub bk/fwd. */ if ((held_mods & MOD_MASK_SHIFT)) { @@ -53,7 +53,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) { } } goto exit; - case L_NUMPAD: // numpad layer (for navigating in spreadsheets) + case L_NUM: // numpad layer (for navigating in spreadsheets) if (clockwise) { tap_code16(KC_RGHT); // } else { @@ -69,7 +69,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) { break; #ifdef RGBLIGHT_ENABLE - case L_MEDIA_KBD: // media/kbd settings layer + case L_CFG: // media/kbd settings layer if (clockwise) { rgblight_increase_val(); // val (brightness) + } else { @@ -95,9 +95,9 @@ bool encoder_update_user(uint8_t index, bool clockwise) { } } else { // Second (right) encoder switch(get_highest_layer(layer_state)){ - case L_PUNCT: // puncuation layer + case L_SYM: // puncuation layer goto volbright; - case L_FN_NUM: // function layer + case L_FUN: // function layer /* for audio scrub bk/fwd. */ if (clockwise) { tap_code(KC_MNXT); // media next track @@ -105,7 +105,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) { tap_code(KC_MPRV); // media prev track } break; - case L_NUMPAD: // numpad layer (for navigating in spreadsheets) + case L_NUM: // numpad layer (for navigating in spreadsheets) if (clockwise) { tap_code16(KC_DOWN); // } else { @@ -121,7 +121,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) { break; #ifdef RGBLIGHT_ENABLE - case L_MEDIA_KBD: // media/kbd settings layer + case L_CFG: // media/kbd settings layer if ((held_mods & MOD_MASK_SHIFT)) { if (clockwise) { rgblight_increase_sat(); // Sat + diff --git a/moutis_app_menu.c b/moutis_app_menu.c index 617ed57..380791d 100644 --- a/moutis_app_menu.c +++ b/moutis_app_menu.c @@ -34,6 +34,7 @@ void process_APP_MENU(keyrecord_t *record) { tap_code16(S(KC_TAB)); // switch app else */ + layer_on(L_NAV); tap_code(KC_TAB); // switch app state_reset_timer = timer_read(); // (re)start timing hold for keyup below return; // handled this record. @@ -51,6 +52,7 @@ void process_APP_MENU(keyrecord_t *record) { } else { unregister_code(KC_RGUI); // Mac } + layer_off(L_NAV); state_reset_timer = 0; // stop the timer } return; // handled this record. @@ -68,6 +70,7 @@ void matrix_APP_MENU(void) { } else { unregister_code(KC_RGUI); // Mac } + layer_off(L_NAV); state_reset_timer = mods_held = 0; // stop the timer appmenu_on = false; } diff --git a/moutis_combo.h b/moutis_combo.h index 1f07911..bf4a880 100644 --- a/moutis_combo.h +++ b/moutis_combo.h @@ -41,15 +41,16 @@ enum my_combos { FC_ESC, // ESCape SIMPLE COMBO must be first (used as FALSE for combo_on) - HC_KBD, + HC_CFG, // The keyboard and media config/settings layer HC_APP, + HC_APPNAV, // App menu on Nav layer HC_CAPW, // CAPS WORD for all others FC_CAPS, // CAPS LOCK (others) - FC_LANG2, // eisuu (others) - FC_LANG1, // kana (others) + FC_LANG2, // eisuu/mhen (others) + FC_LANG1, // kana/henk (others) HC_TAB, -// HC_PCT, // % percent (hold = for %) + HC_STAB, HC_DOLR, // $ HC_HASH, // # HC_QUES, // ? diff --git a/moutis_combo_def.c b/moutis_combo_def.c index 5132f9b..e6bdd70 100644 --- a/moutis_combo_def.c +++ b/moutis_combo_def.c @@ -1,26 +1,53 @@ // -// Alpha Layer for a 34 key form factor -// ╭─────────────────────╮ ╭─────────────────────╮ -// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ -// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ -// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ -// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭──────────╯ -// ╰─────────╯ ╰──────────╯ +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 // -// These definitions based on Hands Down Neu +// These definitions based on Hands Down Neu & variations' // combo keycodes defined in the variation config -// ex "HDvariations/nu/nu-config.h" +// ex "handsdonu-config.h" // // Combo definitions defined spatially // Other variation dependent combos have predetermined +// positions for 34 key boards + +const uint16_t PROGMEM HC_cfg_combo[] = {HD_RH1, HD_RH2, COMBO_END}; // keyboard settings/config layer +#ifdef APPMENU_keys +const uint16_t PROGMEM H_menu_combo[] = {APPMENU_keys, COMBO_END}; // AppMENU +#else +const uint16_t PROGMEM H_menu_combo[] = {HD_LB3, HD_LB1, COMBO_END}; // AppMENU // default Appmenu location +#endif +const uint16_t PROGMEM H_menu_nav_combo[] = {LN_LB3, LN_LB1, COMBO_END}; // AppMENU on Nav layer + +// Spatially arranged on the QWERTY ZXCV locations // +const uint16_t PROGMEM Htab_combo[] = {HD_tab_keys, COMBO_END}; // tab +const uint16_t PROGMEM Hstab_combo[] = {HD_stab_keys, COMBO_END}; // shift-tab +const uint16_t PROGMEM Hspc_combo[] = {HD_spc_keys, COMBO_END}; // SPACE +const uint16_t PROGMEM Hent_combo[] = {HD_ent_keys, COMBO_END}; // ENTER +const uint16_t PROGMEM Hent2_combo[] = {HD_ent2_keys, COMBO_END}; // hard-ENTER/page break + +// SEMANTIC FUNCTIONS ** usinp SemKeys ** +const uint16_t PROGMEM Hnew_combo[] = {HD_new_keys, COMBO_END}; // new +const uint16_t PROGMEM Hopen_combo[] = {HD_open_keys, COMBO_END}; // openi +const uint16_t PROGMEM Hclose_combo[] = {HD_close_keys, COMBO_END}; // close +const uint16_t PROGMEM Hquit_combo[] = {HD_quit_keys, COMBO_END}; // quit +const uint16_t PROGMEM Hfind_combo[] = {HD_find_keys, COMBO_END}; // find selection +const uint16_t PROGMEM Hsall_combo[] = {HD_sall_keys, COMBO_END}; // select all +const uint16_t PROGMEM Hswrd_combo[] = {HD_swrd_keys, COMBO_END}; // select word +const uint16_t PROGMEM Hundo_combo[] = {HD_undo_keys, COMBO_END}; // undo +const uint16_t PROGMEM Hredo_combo[] = {HD_redo_keys, COMBO_END}; // redo +const uint16_t PROGMEM Hcopy_combo[] = {HD_copy_keys, COMBO_END}; // copy (hold for cut) +const uint16_t PROGMEM Hpste_combo[] = {HD_pste_keys, COMBO_END}; // paste (hold for paste-match) -// for 34 key boards -const uint16_t PROGMEM HC_kbd_combo[] = {HD_RH1, HD_RH2, COMBO_END}; // keyboard settings/config layer -const uint16_t PROGMEM H_menu_combo[] = {HD_LT0, HD_LT1, COMBO_END}; // MENU /* examples of text entry combos */ const uint16_t PROGMEM H_Left_combo[] = {HD_LT3, HD_LT2, HD_LT1, COMBO_END}; // TYPE LeftComboTapE @@ -33,8 +60,8 @@ const uint16_t PROGMEM F_SCAP_combo[] = {HD_LT3, HD_LT2, HD_LT1, HD_LT0, COMBO_E const uint16_t PROGMEM F_CAPS_combo[] = {HD_LM3, HD_LM2, HD_RM2, HD_RM3, COMBO_END}; // CAPS LOCK (on until hit again) const uint16_t PROGMEM H_CAPW_combo[] = {HD_LM1, HD_LM2, HD_RM1, HD_RM2, COMBO_END}; // CAPS WORD (on until word delimiter) -const uint16_t PROGMEM H_EISUU_combo[] = {HD_LM3, HD_LM2, HD_LM1, COMBO_END}; // KC_MHEN -const uint16_t PROGMEM H_KANA_combo[] = {HD_RM3, HD_RM2, HD_RM1, COMBO_END}; // KC_HENK +const uint16_t PROGMEM H_EISUU_combo[] = {HD_LB3, HD_LB2, HD_LB1, COMBO_END}; // KC_MHEN +const uint16_t PROGMEM H_KANA_combo[] = {HD_RB3, HD_RB2, HD_RB1, COMBO_END}; // KC_HENK @@ -47,7 +74,7 @@ const uint16_t PROGMEM H_KANA_combo[] = {HD_RM3, HD_RM2, HD_RM1, COMBO_END}; // const uint16_t PROGMEM F_ESC_combo[] = {HD_LM4, HD_LM1, COMBO_END}; // ESCape const uint16_t PROGMEM Hndsh_combo[] = {HD_RB0, HD_RB1, COMBO_END}; // – n dash const uint16_t PROGMEM Hmdsh_combo[] = {HD_RB0, HD_RB2, COMBO_END}; // — m dash -const uint16_t PROGMEM Htild_combo[] = {HD_RB0, HD_RB4, COMBO_END}; // ~ tilde (not the deadkey for eñye) +const uint16_t PROGMEM Htild_combo[] = {HD_RB1, HD_RB4, COMBO_END}; // ~ tilde (not the deadkey for eñye) const uint16_t PROGMEM Hunds_combo[] = {HD_RB1, HD_RB3, COMBO_END}; // _ underscore const uint16_t PROGMEM Hequal_combo[] = {HD_RB2, HD_RB3, COMBO_END}; // = equal (hold for %) //const uint16_t PROGMEM Hpercent_combo[] = {HD_RB3, HD_RB4, COMBO_END}; // % percent @@ -77,7 +104,7 @@ const uint16_t PROGMEM Hring_combo[] = {HD_RM1, HD_RM4, COMBO_END}; // ˚ ring ( const uint16_t PROGMEM Hcedi_combo[] = {HD_LM4, HD_LM2, COMBO_END}; // ¸ cedille (dead key) //const uint16_t PROGMEM Hoslsh_combo[] = {HD_RB2, HD_LB0, COMBO_END}; // ø/Ø or Wh -// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ J & G respectively)byby= +// TEXT ENTRY - off map standard alphas (also on Layer L_SYM @ J & G respectively)byby= const uint16_t PROGMEM H_Q_combo[] = {HD_Qu_keys, COMBO_END}; // TYPE "q" (Qu & Linger deletes u) const uint16_t PROGMEM H_L1_combo[] = {HD_L1_keys, COMBO_END}; // ex. TYPE "z" //const uint16_t PROGMEM H_L2_combo[] = {HD_L2_keys, COMBO_END}; // ex. TYPE "x" @@ -95,7 +122,6 @@ const uint16_t PROGMEM H_Sch_combo[] = {HD_Sch_keys, COMBO_END}; // TYPE "Sch" // TEXT ENTRY - (ANY ROW/ MIXED ROWS) - const uint16_t PROGMEM HOE_lig_combo[] = {HD_OE_lig_keys, COMBO_END}; // Œ const uint16_t PROGMEM HAE_lig_combo[] = {HD_AE_lig_keys, COMBO_END}; // Æ @@ -128,9 +154,9 @@ const uint16_t PROGMEM H_here_combo[] = {HD_here_keys, COMBO_END}; // TYPE "here #ifdef EN_W_PRONOUNS const uint16_t PROGMEM H_where_combo[] = {HD_where_keys, COMBO_END}; // "where" + 's +const uint16_t PROGMEM H_were_combo[] = {HD_were_keys, COMBO_END}; // TYPE "we're" const uint16_t PROGMEM H_wed_combo[] = {HD_wed_keys, COMBO_END}; // TYPE "we'd" + 've const uint16_t PROGMEM H_well_combo[] = {HD_well_keys, COMBO_END}; // TYPE "we'll" + 've -const uint16_t PROGMEM H_were_combo[] = {HD_were_keys, COMBO_END}; // TYPE "we're" const uint16_t PROGMEM H_weve_combo[] = {HD_weve_keys, COMBO_END}; // TYPE "we've" #endif // EN_W_PRONOUNS @@ -138,33 +164,6 @@ const uint16_t PROGMEM H_weve_combo[] = {HD_weve_keys, COMBO_END}; // TYPE "we'v #endif // EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans -// UPPER ROW - -// FUNCTIONS/COMMANDS Spatially arranged -const uint16_t PROGMEM Htab_combo[] = {HD_tab_keys, COMBO_END}; // tab -const uint16_t PROGMEM Hspc_combo[] = {HD_spc_keys, COMBO_END}; // SPACE -const uint16_t PROGMEM Hent_combo[] = {HD_ent_keys, COMBO_END}; // ENTER -const uint16_t PROGMEM Hent2_combo[] = {HD_ent2_keys, COMBO_END}; // hard-ENTER/page break - -// LOWER ROW - -// SEMANTIC FUNCTIONS ** uses SemKeys ** -// Spatially arranged on the QWERTY ZXCV locations -// -const uint16_t PROGMEM Hnew_combo[] = {HD_new_keys, COMBO_END}; // new -const uint16_t PROGMEM Hopen_combo[] = {HD_open_keys, COMBO_END}; // open -const uint16_t PROGMEM Hclose_combo[] = {HD_close_keys, COMBO_END}; // close -const uint16_t PROGMEM Hquit_combo[] = {HD_quit_keys, COMBO_END}; // quit -const uint16_t PROGMEM Hfind_combo[] = {HD_find_keys, COMBO_END}; // find selection -const uint16_t PROGMEM Hsall_combo[] = {HD_sall_keys, COMBO_END}; // select all -const uint16_t PROGMEM Hswrd_combo[] = {HD_swrd_keys, COMBO_END}; // select word -const uint16_t PROGMEM Hundo_combo[] = {HD_undo_keys, COMBO_END}; // undo -const uint16_t PROGMEM Hredo_combo[] = {HD_redo_keys, COMBO_END}; // redo -//const uint16_t PROGMEM Hcut_combo[] = {HD_cut_keys, COMBO_END}; // cut (not using this anymore?) -const uint16_t PROGMEM Hcopy_combo[] = {HD_copy_keys, COMBO_END}; // copy (hold for cut) -const uint16_t PROGMEM Hpste_combo[] = {HD_pste_keys, COMBO_END}; // paste (hold for paste-match) - - // TWO HANDS // 53 Japanese contract consonant combos. @@ -270,10 +269,10 @@ const uint16_t PROGMEM PPLMN_combo[] = {RSFT_T(KC_P4), RCTL_T(KC_PPLS), COMBO_EN combo_t key_combos[] = { - // These simple combos trigger on press, repeat. HC_kbd_combo - [HC_KBD] = COMBO(HC_kbd_combo, MO(L_MEDIA_KBD)), // keyboard/media settings/config layer + // These simple combos trigger on press, repeat. HC_cfg_combo + [HC_CFG] = COMBO(HC_cfg_combo, MO(L_CFG)), // keyboard/media settings/config layer [HC_APP] = COMBO(H_menu_combo, KC_APP), // app menu -// [HC_PCT] = COMBO(Hpercent_combo, KC_PERC), // % (hold = for %) + [HC_APPNAV] = COMBO(H_menu_nav_combo, KC_APP), // app menu [HC_SCLN] = COMBO(Hscln_combo, KC_SCLN), // ; [HC_COLN] = COMBO_ACTION(Hcoln_combo), // : (hold for elipsis) [HC_UNDS] = COMBO_ACTION(Hunds_combo), // _ underscore @@ -285,6 +284,7 @@ combo_t key_combos[] = { [HC_HASH] = COMBO(Hhash_combo, SK_SECT), // # hijacked for § [HC_AT] = COMBO_ACTION(Hat_combo), // @ (hold for alanreiser.com) [HC_TAB] = COMBO(Htab_combo, KC_TAB), + [HC_STAB] = COMBO(Hstab_combo, S(KC_TAB)), [HC_Q] = COMBO_ACTION(H_Q_combo), [HC_L1] = COMBO(H_L1_combo, HD_L1), diff --git a/moutis_layers.h b/moutis_layers.h new file mode 100644 index 0000000..3594eff --- /dev/null +++ b/moutis_layers.h @@ -0,0 +1,372 @@ +// +// moutis_layers.h +// +// +// Created by Alan on 6/23/23. +// + +#ifndef moutis_layers_h +#define moutis_layers_h +#endif /* moutis_layers_h */ + + +// Key Position Names for a 34 (-54) key split form factor +// Should cover Ferris through Atreus-Kyria-Ergodox +// ╭─────────────────────╮ ╭─────────────────────╮ +// LT5 │ LT4 LT3 LT2 LT1 LT0 │ LTA RTB │ RT0 RT1 RT2 RT3 RT4 │ RT5 +// LM5 │ LM4 LM3 LM2 LM1 LM0 | LMA RMA | RT0 RM1 RM2 RM3 RM4 │ RM5 +// LB5 │ LB4 LB3 LB2 LB1 LB0 │ LBA LBB RBB RBA │ RB0 RB1 RB2 RB3 RB4 │ RB5 +// ╰───────────╮ LH2 LH1 │ LH0 LHA RHA RH0 │ RH1 RH2 ╭───────────╯ +// LH5 LH4 LH3 ╰─────────╯ ╰─────────╯ RH3 RH4 RH5 + + + +/* L_SYM Symbols and punctuation + ╭──────────────────────────────────────────╮ ╭───────────────────────────────────────────────╮ +__ │ QUIT CLOZ SCAP SCLP FAGN │ │ DOCBEG HOME UP PGUP PARAPRV │ __ +__ │ LCTL LALT LGUI LSFT FIND | | WORDPRV LEFT DOWN RGHT WORDNXT │ __ +__ │ UNDO CUT COPY PSTE PSTM │ TAB __ __ ESC │ DOCEND END DOWN PGDN PARANXT │ __ + ╰──────────────────╮ __ S(MENU) MENU │ __ __ │ HISTPRV HISTNXT __ ╭──────────────────╯ + HISTPRV HISTNXT ╰───────────────────────╯ ╰────────────────────────────╯ ZOOMRST ZOOMOUT +*/ + +/* L_SYM Symbols & punctuation (Much of this should be handled by SemKeys/unicode for platform independance + ______, KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), ______, + ______, KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), ______, + ______, KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ______, ______, ______, ______, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, ______, + ______, KC_VOLD, SK_DELWDL, SK_DELWDR, KC_VOLU, LALT(KC_9), LSA(KC_8), LSA(KC_9), ______, ______), + +*/ +#define LS_LT5 KC_TRNS +#define LS_LT4 KC_Z +#define LS_LT3 KC_Q +#define LS_LT2 RALT(KC_5) +#define LS_LT1 LALT(KC_7) +#define LS_LT0 LSA(KC_7) +#define LS_RT0 LALT(KC_4) +#define LS_RT1 KC_DLR +#define LS_RT2 A(S(KC_2)) +#define LS_RT3 RALT(KC_3) +#define LS_RT4 LALT(KC_Y) +#define LS_RT5 KC_TRNS + +#define LS_LM5 KC_TRNS +#define LS_LM4 KC_LT +#define LS_LM3 KC_LBRC +#define LS_LM2 KC_LPRN +#define LS_LM1 KC_LCBR +#define LS_LM0 RSA(KC_5) +#define LS_RM0 RALT(KC_1) +#define LS_RM1 RSFT_T(KC_PAST) +#define LS_RM2 RGUI_T(KC_PEQL) +#define LS_RM3 RALT_T(KC_PPLS) +#define LS_RM4 RCTL_T(KC_PSLS) +#define LS_RM5 KC_TRNS + +#define LS_LB5 KC_TRNS +#define LS_LB4 KC_GT +#define LS_LB3 KC_RBRC +#define LS_LB2 KC_RPRN +#define LS_LB1 KC_RCBR +#define LS_LB0 LALT(KC_8) +#define LS_LBA KC_TRNS +#define LS_LBB KC_TRNS +#define LS_RBB KC_TRNS +#define LS_RBA KC_TRNS +#define LS_RB0 KC_UNDS +#define LS_RB1 KC_PIPE +#define LS_RB2 KC_AMPR +#define LS_RB3 KC_CIRC +#define LS_RB4 KC_PERC +#define LS_RB5 KC_TRNS + +#define LS_LH5 KC_TRNS +#define LS_LH4 KC_TRNS +#define LS_LH3 KC_VOLD +#define LS_LH2 SK_DELWDL +#define LS_LH1 SK_DELWDR +#define LS_LH0 KC_VOLU +#define LS_RH0 LALT(KC_9) +#define LS_RH1 LSA(KC_8) +#define LS_RH2 LSA(KC_9) +#define LS_RH3 KC_TRNS +#define LS_RH4 KC_TRNS +#define LS_RH5 KC_TRNS + + +/* L_FUN LAYER K-key row (left) and Num row (right) + ╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ + RGB_TOG │ F9 F10 F11 F12 F13 │ │ / 7 8 9 - │ RGB_MOD + RGB_VAI │ C_T(F5) A_T(F6) G_T(F7) S_T(L8) F14 | | * S_T(1) G_T(2) A_T(3) C_T(+) │ RGB_HUI + RGB_VAD │ F1 F2 F3 F4 INS │ __ __ __ __ │ , 4 5 3 = │ RGB_HUD + ╰────────────────╮ __ __ __ │ __ __ │ 0 . TG(LN) ╭────────────────╯ + __ __ ╰─────────────────────────╯ ╰─────────────────────────╯ __ __ +*/ +/* + RGB_TOG, KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, RGB_MOD, + RGB_VAI, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), RGB_HUI, + RGB_VAD, KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, ______, ______, ______, ______, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, RGB_HUD, + ______, ______, KC_SCLN, TG(L_NUM), ______, ______, KC_0, KC_DOT, ______, SK_ZOOMRST), +*/ + +#define LF_LT5 RGB_TOG +#define LF_LT4 KC_F9 +#define LF_LT3 KC_F10 +#define LF_LT2 KC_F11 +#define LF_LT1 KC_F12 +#define LF_LT0 KC_F13 +#define LF_RT0 KC_SLSH +#define LF_RT1 KC_7 +#define LF_RT2 KC_8 +#define LF_RT3 KC_9 +#define LF_RT4 KC_MINS +#define LF_RT5 RGB_MOD + +#define LF_LM5 RGB_VAI +#define LF_LM4 LCTL_T(KC_F5) +#define LF_LM3 LALT_T(KC_F6) +#define LF_LM2 LGUI_T(KC_F7) +#define LF_LM1 LSFT_T(KC_F8) +#define LF_LM0 KC_F14 +#define LF_RM0 KC_COMM +#define LF_RM1 RSFT_T(KC_1) +#define LF_RM2 RGUI_T(KC_2) +#define LF_RM3 RALT_T(KC_3) +#define LF_RM4 RCTL_T(KC_PPLS) +#define LF_RM5 RGB_HUI + +#define LF_LB5 RGB_VAD +#define LF_LB4 KC_F1 +#define LF_LB3 KC_F2 +#define LF_LB2 KC_F3 +#define LF_LB1 KC_F4 +#define LF_LB0 KC_INS +#define LF_LBA KC_TRNS +#define LF_LBB KC_TRNS +#define LF_RBB KC_TRNS +#define LF_RBA KC_TRNS +#define LF_RB0 KC_COMM +#define LF_RB1 KC_4 +#define LF_RB2 KC_5 +#define LF_RB3 KC_6 +#define LF_RB4 KC_EQL +#define LF_RB5 RGB_HUD + +#define LF_LH5 KC_TRNS +#define LF_LH4 KC_TRNS +#define LF_LH3 KC_TRNS +#define LF_LH2 KC_SCLN +#define LF_LH1 TG(L_NUM) +#define LF_LH0 KC_TRNS +#define LF_RH0 KC_TRNS +#define LF_RH1 KC_0 +#define LF_RH2 KC_DOT +#define LF_RH3 KC_TRNS +#define LF_RH4 SK_ZOOMRST +#define LF_RH5 KC_TRNS + + +/* L_NUM Layer (LN) + ╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ +__ │ TAB PGUP UP PGDN TAB │ │ PSLS P7 P8 P9 PMNS │ __ +__ │ W_LEFT LEFT DOWN RGHT W_RGHT | | PAST P4 P5 P6 PPLS │ __ +__ │ UNDO CUT COPY PSTE SPC │ __ __ __ __ │ PCMM P1 P2 P3 PEQL │ __ + ╰────────────────╮ __ G_T(BSP) C_T(ENT)│ __ __ │ P0 PDOT __ ╭────────────────╯ + __ __ ╰─────────────────────────╯ ╰─────────────────────────╯ __ __ +*/ +/* + // L_NUM THE NUMPAD LAYER (right) with nav/editing on left (the 10-Key/Spreadsheet layer) + KC_NUM, KC_PGDN, KC_UP, KC_PGUP, KC_TAB, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, + SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), RCTL_T(KC_PPLS), + SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, KC_ESC, KC_ESC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, + KC_TRNS, KC_TRNS, KC_TRNS, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), KC_DEL, KC_C, KC_P0, KC_PDOT, KC_TRNS, KC_TRNS, KC_TRNS), +*/ +#define LN_LT5 KC_TRNS +#define LN_LT4 KC_NUM +#define LN_LT3 KC_PGDN +#define LN_LT2 KC_UP +#define LN_LT1 KC_PGUP +#define LN_LT0 KC_TAB +#define LN_RT0 KC_PSLS +#define LN_RT1 KC_P7 +#define LN_RT2 KC_P8 +#define LN_RT3 KC_P9 +#define LN_RT4 KC_PMNS +#define LN_RT5 KC_TRNS + +#define LN_LM5 KC_TRNS +#define LN_LM4 SK_WORDPRV +#define LN_LM3 KC_LEFT +#define LN_LM2 KC_DOWN +#define LN_LM1 KC_RGHT +#define LN_LM0 SK_WORDNXT +#define LN_RM0 KC_PAST +#define LN_RM1 RSFT_T(KC_P4) +#define LN_RM2 RGUI_T(KC_P5) +#define LN_RM3 RALT_T(KC_P6) +#define LN_RM4 RCTL_T(KC_PPLS) +#define LN_RM5 KC_TRNS + +#define LN_LB5 KC_TRNS +#define LN_LB4 SK_UNDO +#define LN_LB3 SK_CUT +#define LN_LB2 SK_COPY +#define LN_LB1 SK_PSTE +#define LN_LB0 KC_SPC +#define LN_LBA KC_ESC +#define LN_LBB KC_TRNS +#define LN_RBB KC_TRNS +#define LN_RBA KC_ESC +#define LN_RB0 KC_PCMM +#define LN_RB1 KC_P1 +#define LN_RB2 KC_P2 +#define LN_RB3 KC_P3 +#define LN_RB4 KC_PEQL +#define LN_RB5 KC_TRNS + +#define LN_LH5 KC_TRNS +#define LN_LH4 KC_TRNS +#define LN_LH3 KC_TRNS +#define LN_LH2 LGUI_T(KC_BSPC) +#define LN_LH1 LSFT_T(KC_ENT) +#define LN_LH0 KC_DEL +#define LN_LHA KC_TRNS +#define LN_RHA KC_TRNS +#define LN_RH0 KC_C +#define LN_RH1 KC_P0 +#define LN_RH2 KC_PDOT +#define LN_RH3 KC_TRNS +#define LN_RH4 KC_TRNS +#define LN_RH5 KC_TRNS + +/* L_NAV Layer (LV) + ╭──────────────────────────────────────────╮ ╭───────────────────────────────────────────────╮ +__ │ QUIT CLOZ SCAP SCLP FAGN │ │ DOCBEG HOME UP PGUP PARAPRV │ __ +__ │ LCTL LALT LGUI LSFT FIND | | WORDPRV LEFT DOWN RGHT WORDNXT │ __ +__ │ UNDO CUT COPY PSTE PSTM │ TAB __ __ ESC │ DOCEND END DOWN PGDN PARANXT │ __ + ╰──────────────────╮ __ S(MENU) MENU │ __ __ │ HISTPRV HISTNXT __ ╭──────────────────╯ + HISTPRV HISTNXT ╰───────────────────────╯ ╰────────────────────────────╯ ZOOMRST ZOOMOUT +*/ +/* + L_NAV THE NAVIGATION (right hand) LAYER w/ edit & mods on left + KC_TRNS, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_NUM, + KC_VOLU, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_TRNS, + KC_VOLD, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, KC_TRNS, + SK_ZOOMRST, KC_TRNS, S(KC_APP), KC_APP, KC_TRNS, SK_ZOOMOUT, SK_HISTPRV, SK_HISTNXT, SK_ZOOMIN, SK_ZOOMRST), +*/ +#define LV_LT5 KC_TRNS +#define LV_LT4 SK_QUIT +#define LV_LT3 SK_CLOZ +#define LV_LT2 SK_SCAP +#define LV_LT1 SK_SCLP +#define LV_LT0 SK_FAGN +#define LV_RT0 SK_DOCBEG +#define LV_RT1 KC_HOME +#define LV_RT2 KC_UP +#define LV_RT3 KC_PGUP +#define LV_RT4 SK_PARAPRV +#define LV_RT5 KC_NUM + +#define LV_LM5 KC_VOLU +#define LV_LM4 KC_LCTL +#define LV_LM3 KC_LALT +#define LV_LM2 KC_LGUI +#define LV_LM1 KC_LSFT +#define LV_LM0 SK_FIND +#define LV_RM0 SK_WORDPRV +#define LV_RM1 KC_LEFT +#define LV_RM2 KC_DOWN +#define LV_RM3 KC_RGHT +#define LV_RM4 SK_WORDNXT +#define LV_RM5 KC_TRNS + +#define LV_LB5 KC_VOLD +#define LV_LB4 SK_UNDO +#define LV_LB3 SK_CUT +#define LV_LB2 SK_COPY +#define LV_LB1 SK_PSTE +#define LV_LB0 SK_PSTM +#define LV_LBA KC_TRNS +#define LV_LBB KC_TRNS +#define LV_RBB KC_TRNS +#define LV_RBA KC_TRNS +#define LV_RB0 SK_DOCEND +#define LV_RB1 KC_END +#define LV_RB2 KC_DOWN +#define LV_RB3 KC_PGDN +#define LV_RB4 SK_PARANXT +#define LV_RB5 KC_TRNS + +#define LV_LH5 KC_TRNS +#define LV_LH4 SK_ZOOMRST +#define LV_LH3 KC_TRNS +#define LV_LH2 S(KC_APP) +#define LV_LH1 KC_APP +#define LV_LH0 KC_TRNS +#define LV_RH0 SK_ZOOMOUT +#define LV_RH1 SK_HISTPRV +#define LV_RH2 SK_HISTNXT +#define LV_RH3 SK_ZOOMIN +#define LV_RH4 SK_ZOOMRST +#define LV_RH5 KC_TRNS + +/* L_CFG Keyboard Configuration (left) and Media Settings (right) + __no__, QK_RBT, CG_SWAP, CG_NORM, EE_CLR, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, __no__, SK_ZOOMRST, RGB_MOD, + RGB_VAI, HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, __no__, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, RGB_SAI, + RGB_HUI, QK_BOOT, AG_SWAP, AG_NORM, KC_VOLD, KC_BRID, RGB_VAD, __no__, __no__, RGB_SAD, __no__, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, RGB_HUD, + __no__, __no__, __no__, TG(L_NUM), __no__, __no__, __no__, __no__, __no__, __no__) +*/ +#define LC_LT5 KC_NO +#define LC_LT4 QK_RBT +#define LC_LT3 CG_SWAP +#define LC_LT2 CG_NORM +#define LC_LT1 EE_CLR +#define LC_LT0 SK_KILL +#define LC_RT0 LCA(KC_DEL) +#define LC_RT1 KC_NUM +#define LC_RT2 KC_EJCT +#define LC_RT3 KC_NO +#define LC_RT4 SK_ZOOMRST +#define LC_RT5 RGB_MOD + +#define LC_LM5 RGB_VAI +#define LC_LM4 HD_AdaptKeyToggle +#define LC_LM3 HD_L_QWERTY +#define LC_LM2 HD_L_ALPHA +#define LC_LM1 KC_VOLU +#define LC_LM0 KC_BRIU +#define LC_RM0 KC_NO +#define LC_RM1 KC_MPRV +#define LC_RM2 KC_MUTE +#define LC_RM3 KC_MNXT +#define LC_RM4 SK_ZOOMOUT +#define LC_RM5 RGB_SAI + +#define LC_LB5 RGB_HUI +#define LC_LB4 QK_BOOT +#define LC_LB3 AG_SWAP +#define LC_LB2 AG_NORM +#define LC_LB1 KC_VOLD +#define LC_LB0 KC_BRID +#define LC_LBA RGB_VAD +#define LC_LBB KC_NO +#define LC_RBB KC_NO +#define LC_RBA RGB_SAD +#define LC_RB0 KC_NO +#define LC_RB1 KC_MRWD +#define LC_RB2 KC_MPLY +#define LC_RB3 KC_MFFD +#define LC_RB4 SK_ZOOMIN +#define LC_RB5 RGB_HUD + +#define LC_LH4 KC_NO +#define LC_LH3 KC_NO +#define LC_LH2 KC_NO +#define LC_LH1 TG(L_NUM) +#define LC_LH0 KC_NO +#define LC_RH0 KC_NO +#define LC_RH1 KC_NO +#define LC_RH2 KC_NO +#define LC_RH3 KC_NO +#define LC_RH4 KC_NO + diff --git a/moutis_process_record.c b/moutis_process_record.c index 4810428..0dc0f9b 100644 --- a/moutis_process_record.c +++ b/moutis_process_record.c @@ -276,13 +276,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { } break; - case KC_QUOT: // SHIFT = ], ALT=›, ALT+SHIFT=» + case KC_QUOT: // SHIFT = [ (linger=[|]), ALT=«, ALT+SHIFT=‹ clear_keyboard(); // clean record to tinker with. if (saved_mods & MOD_MASK_ALT) { // ALT (only) down? if (saved_mods & MOD_MASK_SHIFT) { // SHFT too? - tap_code16(DQUO_SA);// this should be semkey for ‹? + tap_code16(SQUO_SA);// this should be semkey for ‹? } else { // alt & shift? - tap_code16(DQUO_A);// this should be linger on semkey for «? + tap_code16(SQUO_A);// this should be linger on semkey for «? } return_state = false; // don't do more with this record. #ifndef JP_MODE_ENABLE @@ -292,7 +292,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { || (!saved_mods && !IS_ENGLISH_MODE)) { // or no mods & not in english #endif // register_linger_key(user_config.RBRC_key); // example of simple linger macro - register_linger_key(DQUO_S); // example of simple linger macro + register_linger_key(SQUO_S); // example of simple linger macro return_state = false; // don't do more with this record. } else //{ // no mods, so linger goto byteshave; // CAUTION: messing w/stack frame here!! @@ -300,13 +300,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // return_state = false; // don't do more with this record. // } break; - case KC_DQUO: // SHIFT = [ (linger=[|]), ALT=‹, ALT+SHIFT=« + case KC_DQUO: // SHIFT = ], ALT=», ALT+SHIFT=› + clear_keyboard(); // clean record to tinker with. if (saved_mods & MOD_MASK_ALT) { // ALT (only) down? if (saved_mods & MOD_MASK_SHIFT) { // SHFT too? - tap_code16(SQUO_SA);// this should be semkey for ›? + tap_code16(DQUO_SA);// this should be semkey for ›? } else { - tap_code16(SQUO_A);// this should be linger on semkey for »? + tap_code16(DQUO_A);// this should be linger on semkey for »? } return_state = false; // don't do more with this record. #ifndef JP_MODE_ENABLE @@ -316,7 +317,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { || (!saved_mods && !IS_ENGLISH_MODE)) { // or no mods & not in english #endif // register_linger_key(user_config.RBRC_key); // example of simple linger macro - register_linger_key(SQUO_S); // example of simple linger macro + register_linger_key(DQUO_S); // example of simple linger macro return_state = false; // don't do more with this record. } else { // no mods, so byteshave: // CAUTION: messing w/stack frame here!! diff --git a/moutis_semantickeys.c b/moutis_semantickeys.c index 71d5a3d..269875d 100644 --- a/moutis_semantickeys.c +++ b/moutis_semantickeys.c @@ -64,9 +64,9 @@ void tap_SemKey(uint16_t semkeycode) { const uint16_t SemKeys_t[SemKeys_COUNT - SK_KILL][OS_count] = { // Mac, Win, (Phase 3, add others if necessary, expand to multi-key?) - [SK_KILL - SK_KILL] = {G(A(KC_ESC)),C(A(KC_DEL))}, // "KILL" OR Force quit / ctrl-alt-del - [SK_HENK - SK_KILL] = {KC_LNG1, KC_INT4}, // 変換 - [SK_MHEN - SK_KILL] = {KC_LNG2, KC_INT5}, // 無変換 + [SK_KILL - SK_KILL] = {G(A(KC_ESC)),C(A(KC_DEL))}, // Force quit / ctrl-alt-del + [SK_HENK - SK_KILL] = {KC_LNG1, C(S(KC_1))}, // 変換/かな + [SK_MHEN - SK_KILL] = {KC_LNG2, C(S(KC_0))}, // 無変換/英数 [SK_HENT - SK_KILL] = {G(KC_ENT),C(KC_ENT)}, // Hard ENTER [SK_UNDO - SK_KILL] = {G(KC_Z),C(KC_Z)}, // undo [SK_REDO - SK_KILL] = {G(S(KC_Z)),C(S(KC_Z))}, // Redo diff --git a/moutis_semantickeys.h b/moutis_semantickeys.h index 51afb98..de9cfc5 100644 --- a/moutis_semantickeys.h +++ b/moutis_semantickeys.h @@ -82,7 +82,7 @@ enum my_keycodes { HD_L_ALPHA, -/* Eventually…these should be handled as SemKeys with BCD Alt-gr? +/* Eventually…these should be handled as SemKeys with BCD & Alt-gr for Windows? HD_aumlt, HD_amacr, HD_aacut, diff --git a/mykeyboards/Atreus/atreus_hd_keymap.c b/mykeyboards/Atreus/atreus_hd_keymap.c index 388ebcb..784a2a2 100644 --- a/mykeyboards/Atreus/atreus_hd_keymap.c +++ b/mykeyboards/Atreus/atreus_hd_keymap.c @@ -5,42 +5,81 @@ #include HD_combo_def // this has the combo definitions #endif -#define ____ KC_TRNS -#define _no_ KC_NO +#define ______ KC_TRNS +#define __no__ KC_NO const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { [L_QWERTY] = LAYOUT( KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, - RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), - KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUMPAD), LT(L_FN_NUM,KC_MPLY), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, - KC_LEFT, KC_RGHT, KC_APP, LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_MEDIA_KBD,KC_MUTE), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_MEDIA_KBD,KC_MPLY), KC_UP, KC_DOWN), - [L_HDALPHA] = LAYOUT( + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUM), LT(L_FUN,KC_MPLY), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + KC_LEFT, KC_RGHT, KC_APP, LT(L_CFG,KC_MUTE), LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_CFG,KC_MUTE), LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), LT(L_CFG,KC_MPLY), KC_UP, KC_DOWN), + + [L_HD] = LAYOUT( HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, - HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, LT(L_NUMPAD, KC_LBRC), LT(L_NAV,KC_RBRC), HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, - ____, ____, KC_APP, HD_LH2, HD_LH1, LT(L_MEDIA_KBD,KC_Q), LT(L_MEDIA_KBD,KC_Z), HD_RH1, HD_RH2, ____, ____, ____), - [L_PUNCT] = LAYOUT( + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_LBA, HD_RBA, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + KC_LEFT, KC_RGHT, HD_LH3, HD_LH2, HD_LH1, HD_LH0, HD_RH0, HD_RH1, HD_RH2, HD_RH3, KC_UP, KC_DOWN), + +/* + [L_SYM] = LAYOUT( KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), - KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ____, ____, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, - ____, ____, ____, SK_DELWDL, SK_DELWDR, ____, LSA(KC_8), ____, ____, ____, ____, ____), - [L_FN_NUM] = LAYOUT( + KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ______, ______, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, + ______, ______, ______, SK_DELWDL, SK_DELWDR, ______, LSA(KC_8), ______, ______, ______, ______, ______), +*/ + [L_SYM] = LAYOUT( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_LBA, LS_RBA, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + ______, ______, LS_LH3, LS_LH2, LS_LH1, LS_LH0, LS_RH0, LS_RH1, LS_RH2, LS_RH3, ______, ______), + +/* [L_FUN] = LAYOUT( KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_BSLS, - LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_SCLN, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_SLSH), KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_PAUS, KC_TAB, KC_MINS, KC_4, KC_5, KC_6, KC_EQL, KC_PSCR, KC_LSCR, ____, KC_BSPC, KC_ENT, ____, KC_DEL, KC_0, KC_DOT, KC_COMM, ____, ____), - [L_NUMPAD] = LAYOUT( - KC_LNUM, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, - LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, - SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, TG(L_NUMPAD), ____, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, - ____, ____, ____, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), ____, KC_DEL, KC_P0, KC_PDOT, KC_C, ____, ____), - [L_NAV] = LAYOUT( + LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_SCLN, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_SLSH), KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_PAUS, KC_TAB, KC_MINS, KC_4, KC_5, KC_6, KC_EQL, KC_PSCR, KC_LSCR, ______, KC_BSPC, KC_ENT, ______, KC_DEL, KC_0, KC_DOT, KC_COMM, ______, ______), +*/ + [L_FUN] = LAYOUT( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_LBA, LF_RBA, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + ______, ______, LF_LH3, LF_LH2, LF_LH1, LF_LH0, LF_RH0, LF_RH1, LF_RH2, LF_RH3, ______, ______), + +/* + [L_NUM] = LAYOUT( + KC_NUM, KC_PGDN, KC_UP, KC_PGUP, KC_TAB, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, + SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), RCTL_T(KC_PPLS), + SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, KC_ESC, KC_ESC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, + ______, ______, ______, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), KC_DEL, KC_C, KC_P0, KC_PDOT, ______, ______, ______), +*/ + [L_NUM] = LAYOUT( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_LBA, LN_RBA, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + ______, ______, LN_LH3, LN_LH2, LN_LH1, LN_LH0, LN_RH0, LN_RH1, LN_RH2, LN_RH3, ______, ______), +/* + [L_NAV] = LAYOUT( SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_ESC, KC_TAB, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, - SK_HISTPRV, SK_HISTNXT, ____, ____, ____, ____, ____, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST, SK_ZOOMOUT, SK_ZOOMIN), - [L_MEDIA_KBD] = LAYOUT( - QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, _no_, SK_ZOOMRST, - HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, _no_, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, - QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, _no_, _no_, _no_, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, - _no_, _no_, TG(L_NUMPAD), _no_, _no_, _no_, _no_, _no_, _no_, _no_, _no_, _no_) + SK_HISTPRV, SK_HISTNXT, ______, ______, ______, ______, ______, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST, SK_ZOOMOUT, SK_ZOOMIN), +*/ + [L_NAV] = LAYOUT( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_LBA, LV_RBA, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, +SK_HISTPRV, SK_HISTNXT, LV_LH3, LV_LH2, LV_LH1, LV_LH0, LV_RH0, LV_RH1, LV_RH2, LV_RH3, SK_ZOOMOUT, SK_ZOOMIN), + +/* + [L_CFG] = LAYOUT( + QK_RBT, CG_SWAP, CG_NORM, EE_CLR, SK_KILL, LCA(KC_DEL), KC_NUM, KC_EJCT, __no__, SK_ZOOMRST, + HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, __no__, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, + QK_BOOT, AG_SWAP, AG_NORM, KC_VOLD, KC_BRID, __no__, __no__, __no__, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, + __no__, __no__, TG(L_NUM), __no__, __no__, __no__, __no__, __no__, __no__, __no__, __no__, __no__) +*/ + [L_CFG] = LAYOUT( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_LBA, LC_RBA, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + ______, ______, LC_LH3, LC_LH2, LC_LH1, LC_LH0, LC_RH0, LC_RH1, LC_RH2, LC_RH3, ______, ______), }; diff --git a/mykeyboards/ferris/ferris_hd_keymap.c b/mykeyboards/ferris/ferris_hd_keymap.c index 61749ed..0a05d83 100644 --- a/mykeyboards/ferris/ferris_hd_keymap.c +++ b/mykeyboards/ferris/ferris_hd_keymap.c @@ -7,44 +7,62 @@ #define ____ KC_TRNS #define _no_ KC_NO +// Alpha Layer for a 34 key (3x5+2) formfactor +// ╭─────────────────────╮ ╭─────────────────────╮ +// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ +// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ +// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ +// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭───────────╯ +// ╰─────────╯ ╰─────────╯ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - - [0] = LAYOUT_split_3x5_2( - KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, - RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), - KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + /* + [L_QWERTY] = LAYOUT_split_3x5_2( + KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT)), - [1] = LAYOUT_split_3x5_2( - HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, - HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, - HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, - HD_LH2, HD_LH1, HD_RH1, HD_RH2), - [2] = LAYOUT_split_3x5_2( - KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), - KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), - KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, - SK_DELWDL, SK_DELWDR, ____, LSA(KC_8)), - [3] = LAYOUT_split_3x5_2( - KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_MINS, - LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), - KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, - KC_SCLN, TG(L_NUMPAD), KC_0, KC_DOT), - [4] = LAYOUT_split_3x5_2( - KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, - SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6),RCTL_T(KC_PPLS), - KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, - LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT)), - [5] = LAYOUT_split_3x5_2( - SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, - KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, - SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_FAGN, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, - MO(L_MEDIA_KBD), KC_APP, SK_HISTPRV, SK_HISTNXT), - [6] = LAYOUT_split_3x5_2( - QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, _no_, SK_ZOOMRST, - HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, _no_, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, - QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, _no_, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, - _no_, TG(L_NUMPAD), _no_, _no_) +*/ + [L_QWERTY] = LAYOUT_split_3x5_2( // Actually MITHRIL + KC_W, KC_P, KC_G, KC_D, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_X, KC_QUOT, + RCTL_T(KC_C), RALT_T(KC_N), RGUI_T(KC_S), RSFT_T(KC_T), LT(L_NUM,KC_K), LT(L_NUM,KC_COMM), RSFT_T(KC_I), RGUI_T(KC_E), RALT_T(KC_L), RCTL_T(KC_A), + KC_Y, KC_B, KC_F, KC_M, KC_V, KC_MINS, KC_U, KC_O, KC_H, KC_DQUO, + HD_LH2, HD_LH1, HD_RH1, HD_RH2), -}; + [L_HD] = LAYOUT_split_3x5_2( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + HD_LH2, HD_LH1, HD_RH1, HD_RH2), + + [L_SYM] = LAYOUT_split_3x5_2( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + LS_LH2, LS_LH1, LS_RH1, LS_RH2), + + [L_FUN] = LAYOUT_split_3x5_2( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + LF_LH2, LF_LH1, LF_RH1, LF_RH2), + [L_NUM] = LAYOUT_split_3x5_2( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + LN_LH2, LN_LH1, LN_RH1, LN_RH2), + + [L_NAV] = LAYOUT_split_3x5_2( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, + LV_LH2, LV_LH1, LV_RH1, LV_RH2), + + [L_CFG] = LAYOUT_split_3x5_2( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + LC_LH2, LC_LH1, LC_RH1, LC_RH2), + +}; diff --git a/mykeyboards/kyria/kyria_hd_keymap.c b/mykeyboards/kyria/kyria_hd_keymap.c index bf2c205..a800e24 100644 --- a/mykeyboards/kyria/kyria_hd_keymap.c +++ b/mykeyboards/kyria/kyria_hd_keymap.c @@ -1,48 +1,68 @@ -#include QMK_KEYBOARD_H +#include QMK_KEYBOARD_H #ifdef COMBO_ENABLE -#include HD_combo_def // this has the combo definitions +#include HD_combo_def // this has the combo definitions (needed here for the QMK keymap introspection) #endif -#define ____ KC_TRNS -#define _no_ KC_NO +#define ______ KC_TRNS +#define __no__ KC_NO + +/* The Kyria Keymap Key positions + * ,-----------------------------------------------. ,-----------------------------------------------. + * | LT5 | LT4 | LT3 | LT2 | LT1 | LT0 | | RT0 | RT1 | RT2 | RT3 | RT4 | RT5 | + * |-------+-------+-------+-------+-------+-------+ +-------+-------+-------+-------+-------+-------| + * | LM5 | LM4 | LM3 | LM2 | LM1 | LM0 | | RM0 | RM1 | RM2 | RM3 | RM4 | RM5 | + * |-------+-------+-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------+-------+-------| + * | LB5 | LB4 | LB3 | LB2 | LB1 | LB0 | LBA | LBB | | RBB | RBA | RB0 | RB1 | RB2 | RB3 | RB4 | RB5 | + * `-------+-------+-------+-------+-------+-------+-------+-------' '-------+-------+-------+-------+-------+-------+-------+-------' + * | LH4 | LH3 | LH2 | LH1 | LH0 | | RH0 | RH1 | RH2 | RH3 | RH4 | + * `---------------------------------------' '---------------------------------------' + */ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [L_QWERTY] = LAYOUT( - SK_COPY, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LNG2, - SK_PSTE, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_LNG1, - KC_AMPR, KC_Z, KC_X, KC_C, KC_V, KC_B, LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_ESC), LT(L_FN_NUM,KC_ESC), LT(L_MEDIA_KBD,KC_MPLY), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_EQL, - LT(L_FN_NUM,KC_MUTE), KC_APP, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_NUMPAD,KC_LNG2), LT(L_NUMPAD,KC_LNG1), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_FN_NUM,KC_TAB), LT(L_FN_NUM,KC_MPLY)), - [L_HDALPHA] = LAYOUT( - ____, HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, ____, - ____, HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, ____, - ____, HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, LT(L_MEDIA_KBD,KC_MUTE), LT(L_NUMPAD,KC_ESC), LT(L_NUMPAD,KC_ESC), LT(L_MEDIA_KBD,KC_MPLY), HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, ____, - ____, ____, HD_LH2, HD_LH1, LT(L_NAV,KC_SPC), LT(L_PUNCT,KC_LNG1), HD_RH1, HD_RH2, ____, ____), - [L_PUNCT] = LAYOUT( - ____, KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), ____, - ____, KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), ____, - ____, KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ____, ____, ____, ____, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, ____, - ____, KC_VOLD, SK_DELWDL, SK_DELWDR, KC_VOLU, LALT(KC_9), LSA(KC_8), LSA(KC_9), ____, ____), - [L_FN_NUM] = LAYOUT( - RGB_TOG, KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, RGB_MOD, - RGB_VAI, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), RGB_HUI, - RGB_VAD, KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, ____, ____, ____, ____, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, RGB_HUD, - ____, ____, KC_SCLN, TG(L_NUMPAD), ____, ____, KC_0, KC_DOT, ____, SK_ZOOMRST), - [L_NUMPAD] = LAYOUT( - RGB_TOG, KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, RGB_MOD, - RGB_VAI, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), RCTL_T(KC_PPLS), RGB_HUI, - RGB_VAD, KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, TG(5), _no_, _no_, LALT(KC_MINS), KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, RGB_HUD, - ____, TG(L_NUMPAD), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), ____, KC_DEL, LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT), KC_C, SK_ZOOMRST), - [L_NAV] = LAYOUT( - ____, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_NUM, - KC_VOLU, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, ____, - KC_VOLD, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, ____, ____, ____, ____, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, ____, - SK_ZOOMRST, ____, S(KC_APP), KC_APP, ____, SK_ZOOMOUT, SK_HISTPRV, SK_HISTNXT, SK_ZOOMIN, SK_ZOOMRST), - [L_MEDIA_KBD] = LAYOUT( - _no_, QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, _no_, SK_ZOOMRST, RGB_MOD, - RGB_VAI, HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, _no_, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, RGB_SAI, - RGB_HUI, QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, RGB_VAD, _no_, _no_, RGB_SAD, _no_, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, RGB_HUD, - _no_, _no_, _no_, TG(L_NUMPAD), _no_, _no_, _no_, _no_, _no_, _no_) + SK_COPY, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LNG2, + SK_PSTE, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_LNG1, + KC_AMPR, KC_Z, KC_X, KC_C, KC_V, KC_B, HD_LBA, HD_LBB, HD_RBB, HD_RBA, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_EQL, + LT(L_FUN,KC_MUTE), KC_APP, LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), HD_LH0, HD_RH0, LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), LT(L_FUN,KC_TAB), LT(L_FUN,KC_MPLY)), + + [L_HD] = LAYOUT( + HD_LT5, HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, HD_RT5, + HD_LM5, HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, HD_RM5, + HD_LB5, HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_LBA, HD_LBB, HD_RBB, HD_RBA, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, HD_RB5, + HD_LH4, HD_LH3, HD_LH2, HD_LH1, HD_LH0, HD_RH0, HD_RH1, HD_RH2, HD_RH3, HD_RH4), + + [L_SYM] = LAYOUT( + LS_LT5, LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, LS_RT5, + LS_LM5, LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, LS_RM5, + LS_LB5, LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_LBA, LS_LBB, LS_RBB, LS_RBA, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, LS_RB5, + LS_LH4, LS_LH3, LS_LH2, LS_LH1, LS_LH0, LS_RH0, LS_RH1, LS_RH2, LS_RH3, LS_RH4), + + [L_FUN] = LAYOUT( + LF_LT5, LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, LF_RT5, + LF_LM5, LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, LF_RM5, + LF_LB5, LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_LBA, LF_LBB, LF_RBB, LF_RBA, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, LF_RB5, + LF_LH4, LF_LH3, LF_LH2, LF_LH1, LF_LH0, LF_RH0, LF_RH1, LF_RH2, LF_RH3, LF_RH4), + + [L_NUM] = LAYOUT( + LN_LT5, LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, LN_RT5, + LN_LM5, LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, LN_RM5, + LN_LB5, LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_LBA, LN_LBB, LN_RBB, LN_RBA, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, LN_RB5, + LN_LH4, LN_LH3, LN_LH2, LN_LH1, LN_LH0, LN_RH0, LN_RH1, LN_RH2, LN_RH3, LN_RH4), + + [L_NAV] = LAYOUT( + LV_LT5, LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, LV_RT5, + LV_LM5, LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, LV_RM5, + LV_LB5, LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_LBA, LV_LBB, LV_RBB, LV_RBA, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, LV_RB5, + LV_LH4, LV_LH3, LV_LH2, LV_LH1, LV_LH0, LV_RH0, LV_RH1, LV_RH2, LV_RH3, LV_RH4), + + [L_CFG] = LAYOUT( + LC_LT5, LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, LC_RT5, + LC_LM5, LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, LC_RM5, + LC_LB5, LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_LBA, LC_LBB, LC_RBB, LC_RBA, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, LC_RB5, + LC_LH4, LC_LH3, LC_LH2, LC_LH1, LC_LH0, LC_RH0, LC_RH1, LC_RH2, LC_RH3, LC_RH4), + }; diff --git a/mykeyboards/naked48/naked48_hd_keymap.c b/mykeyboards/naked48/naked48_hd_keymap.c index 1f1ed2b..10ad1b5 100644 --- a/mykeyboards/naked48/naked48_hd_keymap.c +++ b/mykeyboards/naked48/naked48_hd_keymap.c @@ -4,63 +4,108 @@ #include HD_combo_def // this has the combo definitions #endif -#define ____ KC_TRNS -#define _no_ KC_NO +#define ______ KC_TRNS +#define __no__ KC_NO -const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { -/* Qwerty Salicylic Acid's Naked 48 is logically a Planck layout - * ,-----------------------------------------. ,-----------------------------------------. - * | Q | W | E | R | T | mute | | play | Y | U | I | O | P | - * |------+------+------+------+------+------+ +------+------+------+------+------+------| - * | A | S | D | F | G | Tab | | ' | H | J | K | L | ; | - * |------+------+------+------+------+------+ +------+------+------+------+------+------| - * | Z | X | C | V | B | num | | nav | N | M | , | . | / | - * `------+------+------+------+------+------+------+------+------+------+------+------+------+------' - * | Down | Up | APP | Bksp | Del |LANG1 |LANG2 | spc | Ent | | Left |Right | - * `-----------------------------------------------------------------------------------' +/* Salicylic Acid's Naked 48 is logically a Planck 12x4 layout + * ,-----------------------------------------------. ,-----------------------------------------------. + * | LT4 | LT3 | LT2 | LT1 | LT0 | mute | | play | RT0 | RT1 | RT2 | RT3 | RT4 | + * |-------+-------+-------+-------+-------+-------+ +-------+-------+-------+-------+-------+-------| + * | LM4 | LM3 | LM2 | LM1 | LM0 | mute | | play | RM0 | RM1 | RM2 | RM3 | RM4 | + * |-------+-------+-------+-------+-------+-------+ +-------+-------+-------+-------+-------+-------| + * | LB4 | LB3 | LB2 | LB1 | LB0 | LBA | | RBA | RB0 | RB1 | RB2 | RB3 | RB4 | + * `-------+-------+-------+-------+-------+-------+------+-------+-------+-------+-------+-------+-------+-------' + * | Left | Right | LH2 | LH1 | LH0 | LHA | RHA | RH0 | RH1 | RH2 | Up | Down | + * `----------------------------------------------------------------------------------------------' */ -[L_QWERTY] = LAYOUT( - KC_Q, KC_W, KC_E, KC_R, KC_T, LT(L_MEDIA_KBD,KC_MUTE), LT(L_MEDIA_KBD,KC_MPLY), KC_Y, KC_U, KC_I, KC_O, KC_P, - RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_NUMPAD,KC_TAB), KC_QUOT, LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), - KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUMPAD), TT(L_NAV), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, - KC_DOWN, KC_UP, KC_APP, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_FN_NUM,SK_MHEN), LT(L_FN_NUM,SK_HENK), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_NUMPAD,KC_TAB), KC_LEFT, KC_RGHT), +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +/*[L_QWERTY] = LAYOUT( + KC_Q, KC_W, KC_E, KC_R, KC_T, LT(L_CFG,KC_MUTE), LT(L_CFG,KC_MPLY), KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_NUM,KC_TAB), KC_QUOT, LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUM), TT(L_NAV), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + KC_LEFT, KC_RGHT, LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), KC_APP, LT(L_FUN,SK_MHEN), LT(L_FUN,SK_HENK), LT(L_NUM,KC_TAB), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), KC_UP, KC_DOWN), [L_HDALPHA] = LAYOUT( - HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, LT(L_MEDIA_KBD,KC_MUTE), LT(L_MEDIA_KBD,KC_MPLY), HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, - HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, TT(L_NUMPAD), TT(L_NAV), HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, - HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, LT(L_NUMPAD, KC_LBRC), LT(L_NAV,KC_RBRC), HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, - ____, ____, HD_LH2, HD_LH1, LT(L_MEDIA_KBD,KC_Q), KC_APP, LT(L_MEDIA_KBD,KC_MPLY), LT(L_MEDIA_KBD,KC_Z), HD_RH1, HD_RH2, ____, ____), - -[L_PUNCT] = LAYOUT( - KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), KC_ESC, ____, LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT_T(KC_Y), - KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), ____, ____, RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RALT_T(KC_R), - KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ____, ____, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, - ____, ____, SK_DELWDL, SK_DELWDR, ____, ____, ____, ____, LSA(KC_8), LSA(KC_9), LALT(KC_9), ____), - -[L_FN_NUM] = LAYOUT( - KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_F16, ____, KC_SLSH, KC_7, KC_8, KC_9, KC_BSLS, + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, KC_MUTE, KC_MPLY, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, TT(L_NUM), TT(L_NAV), HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, KC_LBRC, KC_RBRC, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + ______, ______, HD_LH2, HD_LH1, LT(L_CFG,KC_LPRN), KC_APP, MO(L_CFG), LT(L_CFG,KC_RPRN), HD_RH1, HD_RH2, ______, ______), + +[L_SYM] = LAYOUT( + KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), KC_ESC, ______, LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT_T(KC_Y), + KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), ______, ______, RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RALT_T(KC_R), + KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ______, ______, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, + ______, ______, SK_DELWDL, SK_DELWDR, ______, ______, ______, ______, LSA(KC_8), LSA(KC_9), LALT(KC_9), ______), + +[L_FUN] = LAYOUT( + KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_F16, ______, KC_SLSH, KC_7, KC_8, KC_9, KC_BSLS, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_F17, TG(L_NAV), KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_SLSH), KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_F18, KC_TAB, KC_MINS, KC_4, KC_5, KC_6, KC_EQL, - KC_PSCR, KC_SCRL, KC_BSPC, KC_ENT, ____, KC_PAUS, KC_INS, ____, KC_0, KC_DOT, KC_SCLN, KC_PENT), + KC_PSCR, KC_SCRL, KC_BSPC, KC_ENT, ______, KC_PAUS, KC_INS, ______, KC_0, KC_DOT, KC_SCLN, KC_PENT), -[L_NUMPAD] = LAYOUT( +[L_NUM] = LAYOUT( LALT(KC_RBRC), SK_QUIT, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_NUM, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, - LSA(KC_3), LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, ____, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, - LSA(KC_4), SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_ENT, TG(L_NUMPAD), KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, - ____, ____, ____, KC_BSPC, KC_ENT, ____, ____, KC_P0, KC_PDOT, KC_C, ____, ____), + LSA(KC_3), LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, ______, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, + LSA(KC_4), SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_ENT, TG(L_NUM), KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, + ______, ______, ______, KC_BSPC, KC_ENT, ______, ______, KC_P0, KC_PDOT, KC_C, ______, ______), [L_NAV] = LAYOUT( - SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, ____, ____, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, - KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, ____, TG(L_NAV), SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, - SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, TG(L_NAV), ____, SK_DOCEND, KC_END, KC_DOWN, KC_LALT, SK_PARANXT, - ____, ____, SK_DELWDL, SK_DELWDR, ____, ____, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, ____, SK_ZOOMOUT, SK_ZOOMIN), + SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, ______, ______, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, + KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, ______, TG(L_NAV), SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, + SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, TG(L_NAV), ______, SK_DOCEND, KC_END, KC_DOWN, KC_LALT, SK_PARANXT, + ______, ______, SK_DELWDL, SK_DELWDR, ______, ______, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, ______, SK_ZOOMOUT, SK_ZOOMIN), -[L_MEDIA_KBD] = LAYOUT( - QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), ____, RGB_TOG, SK_KILL, KC_NUM, KC_EJCT, _no_, SK_ZOOMRST, - HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, ____, ____, _no_, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, +[L_CFG] = LAYOUT( + QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), ______, RGB_TOG, SK_KILL, KC_NUM, KC_EJCT, __no__, SK_ZOOMRST, + HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, ______, ______, __no__, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, + + QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, AG_NORM, CG_NORM, __no__, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, + + ______, ______, ______, ______, TG(L_NUM), ______, ______, ______, ______, ______, ______, ______) +}; +*/ + + [L_QWERTY] = LAYOUT( + KC_Q, KC_W, KC_E, KC_R, KC_T, LT(L_CFG,KC_MUTE), LT(L_CFG,KC_MPLY), KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_NUM,KC_TAB), KC_QUOT, LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUM), TT(L_NAV), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + KC_LEFT, KC_RGHT, LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), KC_APP, LT(L_FUN,SK_MHEN), LT(L_FUN,SK_HENK), LT(L_NUM,KC_TAB), LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), KC_UP, KC_DOWN), + + [L_HD] = LAYOUT( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, KC_MUTE, KC_MPLY, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, LT(L_NUM,KC_TAB), KC_QUOT, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_LBA, HD_RBA, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + KC_LEFT, KC_RGHT, HD_LH2, HD_LH1, HD_LH3, HD_LH0, HD_RH0, HD_RH3, HD_RH1, HD_RH2, KC_UP, KC_DOWN), + + [L_SYM] = LAYOUT( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, ______, ______, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, ______, ______, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_LBA, LS_RBA, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + ______, ______, LS_LH2, LS_LH1, LS_LH3, LS_LH0, LS_RH0, LS_RH3, LS_RH1, LS_RH2, ______, ______), + + [L_FUN] = LAYOUT( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, ______, ______, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, ______, ______, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_LBA, LF_RBA, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + ______, ______, LF_LH2, LF_LH1, LF_LH3, LF_LH0, LF_RH0, LF_RH3, LF_RH1, LF_RH2, ______, ______), + + [L_NUM] = LAYOUT( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, ______, ______, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, ______, ______, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_LBA, LN_RBA, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + ______, ______, LN_LH2, LN_LH1, LN_LH3, LN_LH0, LN_RH0, LN_RH1, LN_RH2, LN_RH3, ______, ______), + + [L_NAV] = LAYOUT( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, ______, ______, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, ______, ______, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_LBA, LV_RBA, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, + ______, ______, LV_LH2, LV_LH1, LV_LH3, LV_LH0, LV_RH0, LV_RH3, LV_RH1, LV_RH2, ______, ______), - QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, AG_NORM, CG_NORM, _no_, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, + [L_CFG] = LAYOUT( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, ______, RGB_TOG, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, ______, ______, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_LBA, LC_RBA, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + ______, ______, LC_LH3, LC_LH2, LC_LH1, LC_LH0, LC_RH0, LC_RH1, LC_RH2, LC_RH3, ______, ______) - ____, ____, ____, ____, TG(L_NUMPAD), ____, ____, ____, ____, ____, ____, ____) }; diff --git a/mykeyboards/rollow/rollow_hd_keymap.c b/mykeyboards/rollow/rollow_hd_keymap.c index a4d44df..30ffbd6 100644 --- a/mykeyboards/rollow/rollow_hd_keymap.c +++ b/mykeyboards/rollow/rollow_hd_keymap.c @@ -7,57 +7,63 @@ #define ____ KC_TRNS #define _no_ KC_NO -// Alpha Layer for a 34 key formfactor +// Alpha Layer for a 36 key (3x5+3) formfactor // ╭─────────────────────╮ ╭─────────────────────╮ // │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ // │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ // │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ -// ╰───────────╮ LH2 LH1 │ │ RH1 RH2 ╭──────────╯ -// ╰─────────╯ ╰──────────╯ +// ╰───────╮ LH3 LH2 LH1 │ │ RH1 RH2 RH3 ╭───────╯ +// ╰─────────────╯ ╰─────────────╯ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - - [L_QWERTY] = LAYOUT_split_3x5_3( // Actually MITHRIL - KC_W, KC_P, KC_G, KC_D, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_X, KC_QUOT, - RCTL_T(KC_C), RALT_T(KC_N), RGUI_T(KC_S), RSFT_T(KC_T), LT(L_NUMPAD,KC_K), LT(L_FN_NUM,KC_COMM), RSFT_T(KC_I), RGUI_T(KC_E), RALT_T(KC_L), RCTL_T(KC_A), - KC_Y, KC_B, KC_F, KC_M, KC_V, KC_MINS, KC_U, KC_O, KC_H, KC_DQUO, - LT(L_MEDIA_KBD,KC_MUTE), HD_LH2, HD_LH1, HD_RH1, HD_RH2, LT(L_MEDIA_KBD,KC_MPLY)), /* [L_QWERTY] = LAYOUT_split_3x5_3( - KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, - RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), - KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, - LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_MEDIA_KBD,KC_MPLY)), + KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + LT(L_CFG,KC_MUTE), LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), LT(L_CFG,KC_MPLY)), */ - [L_HDALPHA] = LAYOUT_split_3x5_3( - HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, - HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, - HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, - LT(L_MEDIA_KBD,KC_MUTE), HD_LH2, HD_LH1, HD_RH1, HD_RH2, LT(L_MEDIA_KBD,KC_MPLY)), - [L_PUNCT] = LAYOUT_split_3x5_3( - KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), - KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), - KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, - ____, SK_DELWDL, SK_DELWDR, ____, LSA(KC_8), ____), - [L_FN_NUM] = LAYOUT_split_3x5_3( - KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, - LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), - KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, - ____, KC_SCLN, TG(L_NUMPAD), KC_0, KC_DOT, ____), - [L_NUMPAD] = LAYOUT_split_3x5_3( - KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, - SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6),RCTL_T(KC_PPLS), - KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, - TG(L_NUMPAD), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT), ____), - [L_NAV] = LAYOUT_split_3x5_3( - SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, - KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, - SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, - SK_ZOOMRST, S(KC_APP), KC_APP, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST), - [L_MEDIA_KBD] = LAYOUT_split_3x5_3( - QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, _no_, SK_ZOOMRST, - HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, _no_, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, - QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, _no_, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, - _no_, _no_, TG(L_NUMPAD), _no_, _no_, _no_) + [L_QWERTY] = LAYOUT_split_3x5_3( // Actually MITHRIL + KC_W, KC_P, KC_G, KC_D, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_X, KC_QUOT, + RCTL_T(KC_C), RALT_T(KC_N), RGUI_T(KC_S), RSFT_T(KC_T), LT(L_NUM,KC_K), LT(L_NUM,KC_COMM), RSFT_T(KC_I), RGUI_T(KC_E), RALT_T(KC_L), RCTL_T(KC_A), + KC_Y, KC_B, KC_F, KC_M, KC_V, KC_MINS, KC_U, KC_O, KC_H, KC_DQUO, + LT(L_CFG,KC_MUTE), HD_LH2, HD_LH1, HD_RH1, HD_RH2, LT(L_CFG,KC_MPLY)), + + [L_HD] = LAYOUT_split_3x5_3( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + HD_LH3, HD_LH2, HD_LH1, HD_RH1, HD_RH2, HD_RH3), + + [L_SYM] = LAYOUT_split_3x5_3( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + LS_LH3, LS_LH2, LS_LH1, LS_RH1, LS_RH2, LS_RH3), + + [L_FUN] = LAYOUT_split_3x5_3( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + LF_LH3, LF_LH2, LF_LH1, LF_RH1, LF_RH2, LF_RH3), + + [L_NUM] = LAYOUT_split_3x5_3( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + LN_LH3, LN_LH2, LN_LH1, LN_RH1, LN_RH2, LN_RH3), + + [L_NAV] = LAYOUT_split_3x5_3( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, + LV_LH3, LV_LH2, LV_LH1, LV_RH1, LV_RH2, LV_RH3), + + [L_CFG] = LAYOUT_split_3x5_3( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + LC_LH3, LC_LH2, LC_LH1, LC_RH1, LC_RH2, LC_RH3), + }; diff --git a/naked48/config.h b/naked48/config.h new file mode 100644 index 0000000..0288669 --- /dev/null +++ b/naked48/config.h @@ -0,0 +1,19 @@ + +/* Copyright 2018 Salicylic_acid3 + * + * 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 . + */ + +#pragma once + diff --git a/naked48/naked48_hd_keymap.c b/naked48/naked48_hd_keymap.c new file mode 100644 index 0000000..10ad1b5 --- /dev/null +++ b/naked48/naked48_hd_keymap.c @@ -0,0 +1,111 @@ +#include QMK_KEYBOARD_H + +#ifdef COMBO_ENABLE +#include HD_combo_def // this has the combo definitions +#endif + +#define ______ KC_TRNS +#define __no__ KC_NO + +/* Salicylic Acid's Naked 48 is logically a Planck 12x4 layout + * ,-----------------------------------------------. ,-----------------------------------------------. + * | LT4 | LT3 | LT2 | LT1 | LT0 | mute | | play | RT0 | RT1 | RT2 | RT3 | RT4 | + * |-------+-------+-------+-------+-------+-------+ +-------+-------+-------+-------+-------+-------| + * | LM4 | LM3 | LM2 | LM1 | LM0 | mute | | play | RM0 | RM1 | RM2 | RM3 | RM4 | + * |-------+-------+-------+-------+-------+-------+ +-------+-------+-------+-------+-------+-------| + * | LB4 | LB3 | LB2 | LB1 | LB0 | LBA | | RBA | RB0 | RB1 | RB2 | RB3 | RB4 | + * `-------+-------+-------+-------+-------+-------+------+-------+-------+-------+-------+-------+-------+-------' + * | Left | Right | LH2 | LH1 | LH0 | LHA | RHA | RH0 | RH1 | RH2 | Up | Down | + * `----------------------------------------------------------------------------------------------' + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +/*[L_QWERTY] = LAYOUT( + KC_Q, KC_W, KC_E, KC_R, KC_T, LT(L_CFG,KC_MUTE), LT(L_CFG,KC_MPLY), KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_NUM,KC_TAB), KC_QUOT, LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUM), TT(L_NAV), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + KC_LEFT, KC_RGHT, LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), KC_APP, LT(L_FUN,SK_MHEN), LT(L_FUN,SK_HENK), LT(L_NUM,KC_TAB), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), KC_UP, KC_DOWN), +[L_HDALPHA] = LAYOUT( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, KC_MUTE, KC_MPLY, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, TT(L_NUM), TT(L_NAV), HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, KC_LBRC, KC_RBRC, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + ______, ______, HD_LH2, HD_LH1, LT(L_CFG,KC_LPRN), KC_APP, MO(L_CFG), LT(L_CFG,KC_RPRN), HD_RH1, HD_RH2, ______, ______), + +[L_SYM] = LAYOUT( + KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), KC_ESC, ______, LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT_T(KC_Y), + KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), ______, ______, RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RALT_T(KC_R), + KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), ______, ______, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, + ______, ______, SK_DELWDL, SK_DELWDR, ______, ______, ______, ______, LSA(KC_8), LSA(KC_9), LALT(KC_9), ______), + +[L_FUN] = LAYOUT( + KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_F16, ______, KC_SLSH, KC_7, KC_8, KC_9, KC_BSLS, + LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_F17, TG(L_NAV), KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_SLSH), + KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_F18, KC_TAB, KC_MINS, KC_4, KC_5, KC_6, KC_EQL, + KC_PSCR, KC_SCRL, KC_BSPC, KC_ENT, ______, KC_PAUS, KC_INS, ______, KC_0, KC_DOT, KC_SCLN, KC_PENT), + +[L_NUM] = LAYOUT( + LALT(KC_RBRC), SK_QUIT, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_NUM, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, + LSA(KC_3), LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, ______, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, + LSA(KC_4), SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_ENT, TG(L_NUM), KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, + ______, ______, ______, KC_BSPC, KC_ENT, ______, ______, KC_P0, KC_PDOT, KC_C, ______, ______), + +[L_NAV] = LAYOUT( + SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, ______, ______, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, + KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, ______, TG(L_NAV), SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, + SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, TG(L_NAV), ______, SK_DOCEND, KC_END, KC_DOWN, KC_LALT, SK_PARANXT, + ______, ______, SK_DELWDL, SK_DELWDR, ______, ______, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, ______, SK_ZOOMOUT, SK_ZOOMIN), + + +[L_CFG] = LAYOUT( + QK_RBT, AG_SWAP, CG_SWAP, EE_CLR, LCA(KC_DEL), ______, RGB_TOG, SK_KILL, KC_NUM, KC_EJCT, __no__, SK_ZOOMRST, + HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, ______, ______, __no__, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, + + QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, AG_NORM, CG_NORM, __no__, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, + + ______, ______, ______, ______, TG(L_NUM), ______, ______, ______, ______, ______, ______, ______) +}; +*/ + + [L_QWERTY] = LAYOUT( + KC_Q, KC_W, KC_E, KC_R, KC_T, LT(L_CFG,KC_MUTE), LT(L_CFG,KC_MPLY), KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_NUM,KC_TAB), KC_QUOT, LT(L_FUN,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, TT(L_NUM), TT(L_NAV), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + KC_LEFT, KC_RGHT, LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), KC_APP, LT(L_FUN,SK_MHEN), LT(L_FUN,SK_HENK), LT(L_NUM,KC_TAB), LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), KC_UP, KC_DOWN), + + [L_HD] = LAYOUT( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, KC_MUTE, KC_MPLY, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, LT(L_NUM,KC_TAB), KC_QUOT, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_LBA, HD_RBA, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + KC_LEFT, KC_RGHT, HD_LH2, HD_LH1, HD_LH3, HD_LH0, HD_RH0, HD_RH3, HD_RH1, HD_RH2, KC_UP, KC_DOWN), + + [L_SYM] = LAYOUT( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, ______, ______, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, ______, ______, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_LBA, LS_RBA, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + ______, ______, LS_LH2, LS_LH1, LS_LH3, LS_LH0, LS_RH0, LS_RH3, LS_RH1, LS_RH2, ______, ______), + + [L_FUN] = LAYOUT( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, ______, ______, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, ______, ______, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_LBA, LF_RBA, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + ______, ______, LF_LH2, LF_LH1, LF_LH3, LF_LH0, LF_RH0, LF_RH3, LF_RH1, LF_RH2, ______, ______), + + [L_NUM] = LAYOUT( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, ______, ______, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, ______, ______, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_LBA, LN_RBA, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + ______, ______, LN_LH2, LN_LH1, LN_LH3, LN_LH0, LN_RH0, LN_RH1, LN_RH2, LN_RH3, ______, ______), + + [L_NAV] = LAYOUT( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, ______, ______, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, ______, ______, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_LBA, LV_RBA, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, + ______, ______, LV_LH2, LV_LH1, LV_LH3, LV_LH0, LV_RH0, LV_RH3, LV_RH1, LV_RH2, ______, ______), + + [L_CFG] = LAYOUT( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, ______, RGB_TOG, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, ______, ______, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_LBA, LC_RBA, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + ______, ______, LC_LH3, LC_LH2, LC_LH1, LC_LH0, LC_RH0, LC_RH1, LC_RH2, LC_RH3, ______, ______) + +}; diff --git a/rollow/config.h b/rollow/config.h new file mode 100644 index 0000000..98a4bcf --- /dev/null +++ b/rollow/config.h @@ -0,0 +1,17 @@ + +#pragma once + +// Rollow hardware specific bits +// +// Allows to use either side as the master. Look at the documentation for info: +// https://docs.qmk.fm/#/config_options?id=setting-handedness +#define EE_HANDS + + +#ifdef ENCODER_ENABLE + #ifdef ENCODER_RESOLUTION + #undef ENCODER_RESOLUTION + #endif + #define ENCODER_DIRECTION_FLIP // old encoders/barrel encoders + #define ENCODER_RESOLUTION 4 // new encoders +#endif diff --git a/rollow/rollow_hd_keymap.c b/rollow/rollow_hd_keymap.c new file mode 100644 index 0000000..30ffbd6 --- /dev/null +++ b/rollow/rollow_hd_keymap.c @@ -0,0 +1,69 @@ +#include QMK_KEYBOARD_H + +#ifdef COMBO_ENABLE +#include HD_combo_def // this has the combo definitions +#endif + +#define ____ KC_TRNS +#define _no_ KC_NO + +// Alpha Layer for a 36 key (3x5+3) formfactor +// ╭─────────────────────╮ ╭─────────────────────╮ +// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │ +// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │ +// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │ +// ╰───────╮ LH3 LH2 LH1 │ │ RH1 RH2 RH3 ╭───────╯ +// ╰─────────────╯ ╰─────────────╯ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +/* + [L_QWERTY] = LAYOUT_split_3x5_3( + KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, + RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUM,KC_G), LT(L_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), + KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, + LT(L_CFG,KC_MUTE), LT(L_FUN,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_SYM,KC_SPC), LT(L_NAV,KC_ENT), LT(L_CFG,KC_MPLY)), +*/ + [L_QWERTY] = LAYOUT_split_3x5_3( // Actually MITHRIL + KC_W, KC_P, KC_G, KC_D, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_X, KC_QUOT, + RCTL_T(KC_C), RALT_T(KC_N), RGUI_T(KC_S), RSFT_T(KC_T), LT(L_NUM,KC_K), LT(L_NUM,KC_COMM), RSFT_T(KC_I), RGUI_T(KC_E), RALT_T(KC_L), RCTL_T(KC_A), + KC_Y, KC_B, KC_F, KC_M, KC_V, KC_MINS, KC_U, KC_O, KC_H, KC_DQUO, + LT(L_CFG,KC_MUTE), HD_LH2, HD_LH1, HD_RH1, HD_RH2, LT(L_CFG,KC_MPLY)), + + [L_HD] = LAYOUT_split_3x5_3( + HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, + HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, + HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, + HD_LH3, HD_LH2, HD_LH1, HD_RH1, HD_RH2, HD_RH3), + + [L_SYM] = LAYOUT_split_3x5_3( + LS_LT4, LS_LT3, LS_LT2, LS_LT1, LS_LT0, LS_RT0, LS_RT1, LS_RT2, LS_RT3, LS_RT4, + LS_LM4, LS_LM3, LS_LM2, LS_LM1, LS_LM0, LS_RM0, LS_RM1, LS_RM2, LS_RM3, LS_RM4, + LS_LB4, LS_LB3, LS_LB2, LS_LB1, LS_LB0, LS_RB0, LS_RB1, LS_RB2, LS_RB3, LS_RB4, + LS_LH3, LS_LH2, LS_LH1, LS_RH1, LS_RH2, LS_RH3), + + [L_FUN] = LAYOUT_split_3x5_3( + LF_LT4, LF_LT3, LF_LT2, LF_LT1, LF_LT0, LF_RT0, LF_RT1, LF_RT2, LF_RT3, LF_RT4, + LF_LM4, LF_LM3, LF_LM2, LF_LM1, LF_LM0, LF_RM0, LF_RM1, LF_RM2, LF_RM3, LF_RM4, + LF_LB4, LF_LB3, LF_LB2, LF_LB1, LF_LB0, LF_RB0, LF_RB1, LF_RB2, LF_RB3, LF_RB4, + LF_LH3, LF_LH2, LF_LH1, LF_RH1, LF_RH2, LF_RH3), + + [L_NUM] = LAYOUT_split_3x5_3( + LN_LT4, LN_LT3, LN_LT2, LN_LT1, LN_LT0, LN_RT0, LN_RT1, LN_RT2, LN_RT3, LN_RT4, + LN_LM4, LN_LM3, LN_LM2, LN_LM1, LN_LM0, LN_RM0, LN_RM1, LN_RM2, LN_RM3, LN_RM4, + LN_LB4, LN_LB3, LN_LB2, LN_LB1, LN_LB0, LN_RB0, LN_RB1, LN_RB2, LN_RB3, LN_RB4, + LN_LH3, LN_LH2, LN_LH1, LN_RH1, LN_RH2, LN_RH3), + + [L_NAV] = LAYOUT_split_3x5_3( + LV_LT4, LV_LT3, LV_LT2, LV_LT1, LV_LT0, LV_RT0, LV_RT1, LV_RT2, LV_RT3, LV_RT4, + LV_LM4, LV_LM3, LV_LM2, LV_LM1, LV_LM0, LV_RM0, LV_RM1, LV_RM2, LV_RM3, LV_RM4, + LV_LB4, LV_LB3, LV_LB2, LV_LB1, LV_LB0, LV_RB0, LV_RB1, LV_RB2, LV_RB3, LV_RB4, + LV_LH3, LV_LH2, LV_LH1, LV_RH1, LV_RH2, LV_RH3), + + [L_CFG] = LAYOUT_split_3x5_3( + LC_LT4, LC_LT3, LC_LT2, LC_LT1, LC_LT0, LC_RT0, LC_RT1, LC_RT2, LC_RT3, LC_RT4, + LC_LM4, LC_LM3, LC_LM2, LC_LM1, LC_LM0, LC_RM0, LC_RM1, LC_RM2, LC_RM3, LC_RM4, + LC_LB4, LC_LB3, LC_LB2, LC_LB1, LC_LB0, LC_RB0, LC_RB1, LC_RB2, LC_RB3, LC_RB4, + LC_LH3, LC_LH2, LC_LH1, LC_RH1, LC_RH2, LC_RH3), + +}; +