From 71f7675cc8ccc04d3baf664731920b369513ab67 Mon Sep 17 00:00:00 2001 From: Kawamashi Date: Sun, 23 Mar 2025 11:39:49 +0100 Subject: [PATCH] =?UTF-8?q?Changement=20de=20pr=C3=A9fixe?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit FR -> FG --- .../rev1/base/keymaps/Kawamashi/clever_keys.c | 214 ++++++++--------- .../Kawamashi/features/clever_keys_old.c | 160 ++++++------- .../features/clever_keys_utilities.c | 2 +- .../base/keymaps/Kawamashi/features/combos.c | 36 +-- .../base/keymaps/Kawamashi/features/macros.c | 8 +- .../base/keymaps/Kawamashi/features/numword.c | 27 +-- .../base/keymaps/Kawamashi/features/os4a.c | 5 - .../Kawamashi/features/tap_hold_utilities.c | 9 +- .../keymaps/Kawamashi/features/typo_layer.c | 127 ++++++++++ .../keymaps/Kawamashi/features/typo_layer.h | 35 +++ .../base/keymaps/Kawamashi/features_conf.c | 53 ++--- .../base/keymaps/Kawamashi/keymap - Copie.c | 80 +++---- .../rev1/base/keymaps/Kawamashi/keymap.c | 126 +++++----- .../rev1/base/keymaps/Kawamashi/keymap.h | 21 +- .../keymaps/Kawamashi/keymap_french_frgo.h | 222 +++++++++--------- .../rev1/base/keymaps/Kawamashi/rules.mk | 1 + 16 files changed, 616 insertions(+), 510 deletions(-) create mode 100644 keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.c create mode 100644 keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.h diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/clever_keys.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/clever_keys.c index 7303817a..a7e535e2 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/clever_keys.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/clever_keys.c @@ -27,19 +27,19 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) { if (isLetter(next_keycode) || next_keycode == E_CIRC) { switch (prev_keycode) { - case FR_EXLM: - case FR_QUES: - //case FR_3PTS: - case FR_2PTS: + case FG_EXLM: + case FG_QUES: + //case FG_3PTS: + case FG_2PTS: // Add space between punctuation and letters. invoke_key(KC_SPC, record); case KC_SPC: switch (recent[RECENT_SIZE - 2]) { - case FR_EXLM: - case FR_QUES: - //case FR_3PTS: - case FR_POIN: + case FG_EXLM: + case FG_QUES: + //case FG_3PTS: + case FG_POIN: // Add OS shift at the beginning of sentences. if (!is_caps_lock_on()) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } break; @@ -50,62 +50,67 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) { switch (prev_keycode) { - case FR_Q: + case FG_Q: switch (next_keycode) { // Ajout automatique du "u" après le "q" - case FR_E: - case FR_I: - case FR_A: - case FR_O: - case FR_EACU: + case FG_E: + case FG_I: + case FG_A: + case FG_O: + case FG_EACU: case E_CIRC: - case FR_APOS: - invoke_key(FR_U, record); + case FG_APOS: + invoke_key(FG_U, record); break; // Raccourci pour "quelq" - case FR_Q: + case FG_Q: clear_recent_keys(); // To prevent infinite loop - process_word((uint16_t[]) {FR_U, FR_E, FR_L}, 3, record); + process_word((uint16_t[]) {FG_U, FG_E, FG_L}, 3, record); break; // Raccourci pour "quoi", ça évite un aller-retour sur la main gauche. - case FR_Z: - return finish_word((uint16_t[]) {FR_U, FR_O, FR_I}, 3, record); + case FG_Z: + return finish_word((uint16_t[]) {FG_U, FG_O, FG_I}, 3, record); // Raccourci pour "quand" - case FR_D: - process_word((uint16_t[]) {FR_U, FR_A, FR_N}, 3, record); + case FG_D: + process_word((uint16_t[]) {FG_U, FG_A, FG_N}, 3, record); break; } break; - case FR_P: + case FG_P: switch (next_keycode) { - case FR_M: + case FG_M: // "pas" - return finish_word((uint16_t[]) {FR_A, FR_S}, 2, record); + return finish_word((uint16_t[]) {FG_A, FG_S}, 2, record); - case FR_APOS: + case FG_APOS: // "par" - return finish_word((uint16_t[]) {FR_A, FR_R}, 2, record); + return finish_word((uint16_t[]) {FG_A, FG_R}, 2, record); - case FR_POIN: + case FG_POIN: if (!isLetter(recent[RECENT_SIZE - 2])) { // "pour" - return finish_word((uint16_t[]) {FR_O, FR_U, FR_R}, 3, record); + return finish_word((uint16_t[]) {FG_O, FG_U, FG_R}, 3, record); } - break; - } + break; + } + + case FG_CCED: + if (!isLetter(next_keycode)) { + invoke_key(FG_A, record); + } } switch (next_keycode) { - case FR_QUES: - case FR_EXLM: + case FG_QUES: + case FG_EXLM: // On ajoute un espace insécable s'il n'a pas été entré avant le point d'exclamation. // Il ne faut pas tester cette fonctionnalité avec Word, qui ajoute cet espace automatiquement. if (isLetter(recent[RECENT_SIZE - 1])) { @@ -115,7 +120,7 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) { del_oneshot_mods(MOD_MASK_SHIFT); unregister_mods(MOD_MASK_SHIFT); } */ - invoke_key(S(KC_SPC), record); + invoke_key(KC_SPC, record); //set_mods(mods); return replace_next_key(next_keycode, record); } @@ -124,161 +129,134 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) { case MAGIC: switch (prev_keycode) { - case FR_T: - invoke_key(FR_I, record); - case FR_I: - return finish_magic((uint16_t[]) {FR_O, FR_N}, 2, record); + case FG_T: + invoke_key(FG_I, record); + case FG_I: + return finish_magic((uint16_t[]) {FG_O, FG_N}, 2, record); - case FR_C: - return finish_magic((uint16_t[]) {FR_APOS, FR_E, FR_S, FR_T}, 4, record); + case FG_C: + return finish_magic((uint16_t[]) {FG_APOS, FG_E, FG_S, FG_T}, 4, record); - case FR_D: - return finish_magic((uint16_t[]) {FR_A, FR_N, FR_S}, 3, record); + case FG_D: + return finish_magic((uint16_t[]) {FG_A, FG_N, FG_S}, 3, record); - case FR_P: - return finish_magic((uint16_t[]) {FR_L, FR_U, FR_S}, 3, record); + case FG_P: + return finish_magic((uint16_t[]) {FG_L, FG_U, FG_S}, 3, record); - case FR_O: - return finish_magic((uint16_t[]) {FR_N, FR_T}, 2, record); + case FG_O: + return finish_magic((uint16_t[]) {FG_N, FG_T}, 2, record); - case FR_A: + case FG_A: if (isLetter(recent[RECENT_SIZE - 2])) { // "ant" - return finish_magic((uint16_t[]) {FR_N, FR_T}, 2, record); + return finish_magic((uint16_t[]) {FG_N, FG_T}, 2, record); } else { // "avec" - return finish_magic((uint16_t[]) {FR_V, FR_E, FR_C}, 3, record); + return finish_magic((uint16_t[]) {FG_V, FG_E, FG_C}, 3, record); } - case FR_S: - return finish_magic((uint16_t[]) {FR_U, FR_R}, 2, record); + case FG_S: + return finish_magic((uint16_t[]) {FG_U, FG_R}, 2, record); - case FR_B: - process_word((uint16_t[]) {FR_O, FR_N, FR_J}, 3, record); + case FG_B: + process_word((uint16_t[]) {FG_O, FG_N, FG_J}, 3, record); - case FR_J: - return finish_magic((uint16_t[]) {FR_O, FR_U, FR_R}, 3, record); + case FG_J: + return finish_magic((uint16_t[]) {FG_O, FG_U, FG_R}, 3, record); - case FR_M: + case FG_M: if (isLetter(recent[RECENT_SIZE - 2])) { // "ment" - return finish_magic((uint16_t[]) {FR_E, FR_N, FR_T}, 3, record); + return finish_magic((uint16_t[]) {FG_E, FG_N, FG_T}, 3, record); } else { // "même" - return finish_magic((uint16_t[]) {FR_TYPO, FR_O, FR_M, FR_E}, 4, record); + return finish_magic((uint16_t[]) {FG_TYPO, FG_O, FG_M, FG_E}, 4, record); } default: return false; } - case FR_AROB: + case FG_AROB: if (!isLetter(recent[RECENT_SIZE - 2])) { switch (prev_keycode) { - case FR_T: + case FG_T: // "t@" -> "toujours" layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_O, FR_U, FR_J, FR_O, FR_U, FR_R, FR_S}, 7, record); + return finish_word((uint16_t[]) {FG_O, FG_U, FG_J, FG_O, FG_U, FG_R, FG_S}, 7, record); - case FR_P: + case FG_P: // "p@" -> "peut-être" layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_E, FR_U, FR_T, FR_MOIN, FR_TYPO, FR_O, FR_T, FR_R, FR_E}, 9, record); + return finish_word((uint16_t[]) {FG_E, FG_U, FG_T, FG_MOIN, FG_TYPO, FG_O, FG_T, FG_R, FG_E}, 9, record); - case FR_A: + case FG_A: // "a@" -> "aujourd'hui" layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_U, FR_J, FR_O, FR_U, FR_R, FR_D, FR_APOS, FR_H, FR_U, FR_I}, 10, record); + return finish_word((uint16_t[]) {FG_U, FG_J, FG_O, FG_U, FG_R, FG_D, FG_APOS, FG_H, FG_U, FG_I}, 10, record); - case FR_B: + case FG_B: // "b@" -> "beaucoup" layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_E, FR_A, FR_U, FR_C, FR_O, FR_U, FR_P}, 7, record); + return finish_word((uint16_t[]) {FG_E, FG_A, FG_U, FG_C, FG_O, FG_U, FG_P}, 7, record); - case FR_E: + case FG_E: // "e@" -> "est-ce qu" layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_S, FR_T, FR_MOIN, FR_C, FR_E, KC_SPC, FR_Q}, 7, record); + return finish_word((uint16_t[]) {FG_S, FG_T, FG_MOIN, FG_C, FG_E, KC_SPC, FG_Q}, 7, record); - case FR_D: + case FG_D: // "d@" -> "déjà" layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_EACU, FR_J, FR_AGRV}, 3, record); + return finish_word((uint16_t[]) {FG_EACU, FG_J, FG_A}, 3, record); } } break; - case FR_Q: - if (prev_keycode == FR_J) { + case FG_Q: + if (prev_keycode == FG_J) { // "jq" -> "jusqu" - process_word((uint16_t[]) {FR_U, FR_S}, 2, record); + process_word((uint16_t[]) {FG_U, FG_S}, 2, record); } break; - case FR_A: - //if (prev_keycode == FR_O && !isCaps) { - if (prev_keycode == FR_O) { + case FG_A: + //if (prev_keycode == FG_O && !isCaps) { + if (prev_keycode == FG_O) { // "oa" -> "oi" clear_recent_keys(); // To prevent infinite loop - return replace_next_key(FR_I, record); + return replace_next_key(FG_I, record); } break; - case FR_I: - //if (prev_keycode == FR_O && !isCaps && recent[RECENT_SIZE - 3] != FR_Q) { - if (prev_keycode == FR_O && recent[RECENT_SIZE - 3] != FR_Q) { + case FG_I: + //if (prev_keycode == FG_O && !isCaps && recent[RECENT_SIZE - 3] != FG_Q) { + if (prev_keycode == FG_O && recent[RECENT_SIZE - 3] != FG_Q) { // "oi" -> "oa", for "keyboard" clear_recent_keys(); // To prevent infinite loop - return replace_next_key(FR_A, record); + return replace_next_key(FG_A, record); } break; - case FR_O: - if (prev_keycode == FR_U && recent[RECENT_SIZE - 2] != FR_Q) { + case FG_O: + if (prev_keycode == FG_U && recent[RECENT_SIZE - 2] != FG_Q) { // "uo" -> "un" - return replace_next_key(FR_N, record); + return replace_next_key(FG_N, record); } break; - case CA_CED: - layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_CCED, FR_A}, 2, record); +/* case CA_CED: + //layer_off(_TYPO); + return finish_word((uint16_t[]) {FG_C, FG_A}, 2, record); */ case OU_GRV: layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_O, FR_UGRV}, 2, record); + return finish_word((uint16_t[]) {FG_O, FG_TYPO, FG_U}, 3, record); case AGRV_SPC: - layer_off(_TYPO); - return finish_word((uint16_t[]) {FR_AGRV, KC_SPC}, 2, record); - -/* case E_CIRC: - return process_accent(FR_ACIR, FR_E, record); - - case I_CIRC: - return process_accent(FR_ACIR, FR_I, record); - - case A_CIRC: - return process_accent(FR_ACIR, FR_A, record); - - case O_CIRC: - return process_accent(FR_ACIR, FR_O, record); - - case U_CIRC: - return process_accent(FR_ACIR, FR_U, record); - - case I_TREM: - return process_accent(FR_TREM, FR_I, record); - - case CIRC: - return process_accent(FR_ACIR, KC_SPC, record); - - case TILDE: - return process_accent(FR_TILD, KC_SPC, record); - - case GRAVE: - return process_accent(FR_GRV, KC_SPC, record);*/ + //layer_off(_TYPO); + return finish_word((uint16_t[]) {FG_A, KC_SPC}, 2, record); } return false; // Process next keycode normally diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_old.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_old.c index 6d88506d..dd4ab32f 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_old.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_old.c @@ -15,19 +15,19 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) { if (isLetter(next_keycode) || next_keycode == E_CIRC) { switch (prev_keycode) { - case FR_EXLM: - case FR_QUES: - case FR_3PTS: - case FR_2PTS: + case FG_EXLM: + case FG_QUES: + case FG_3PTS: + case FG_2PTS: // Add space between punctuation and letters. process_next_key(KC_SPC, record); case KC_SPC: switch (recent[RECENT_SIZE - 2]) { - case FR_EXLM: - case FR_QUES: - case FR_3PTS: - case FR_POIN: + case FG_EXLM: + case FG_QUES: + case FG_3PTS: + case FG_POIN: // Add OS shift at the beginning of a sentence. if (!is_caps_lock_on()) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } break; @@ -36,97 +36,97 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) { } // Ajout automatique du "u" après le "q" - if (prev_keycode == FR_Q) { + if (prev_keycode == FG_Q) { switch (next_keycode) { - case FR_E: - case FR_I: - case FR_A: - case FR_O: - case FR_EACU: + case FG_E: + case FG_I: + case FG_A: + case FG_O: + case FG_EACU: case E_CIRC: - case FR_APOS: - process_next_key(FR_U, record); + case FG_APOS: + process_next_key(FG_U, record); break; // Raccourci pour "quelq" - case FR_Q: + case FG_Q: clear_recent_keys(); // To prevent infinite loop - process_word((uint16_t[]) {FR_U, FR_E, FR_L}, 3, record); + process_word((uint16_t[]) {FG_U, FG_E, FG_L}, 3, record); break; // Raccourci pour "quoi", ça évite un aller-retour sur la main gauche. - case FR_Z: - return finish_word((uint16_t[]) {FR_U, FR_O, FR_I}, 3, record); + case FG_Z: + return finish_word((uint16_t[]) {FG_U, FG_O, FG_I}, 3, record); // Raccourci pour "quand" - case FR_D: - process_word((uint16_t[]) {FR_U, FR_A, FR_N}, 3, record); + case FG_D: + process_word((uint16_t[]) {FG_U, FG_A, FG_N}, 3, record); break; } - } else if (next_keycode == FR_AROB && !isLetter(recent[RECENT_SIZE - 2])) { + } else if (next_keycode == FG_AROB && !isLetter(recent[RECENT_SIZE - 2])) { switch (prev_keycode) { - case FR_T: + case FG_T: // "t@" -> "toujours" - return finish_word((uint16_t[]) {FR_O, FR_U, FR_J, FR_O, FR_U, FR_R, FR_S}, 7, record); + return finish_word((uint16_t[]) {FG_O, FG_U, FG_J, FG_O, FG_U, FG_R, FG_S}, 7, record); - case FR_P: + case FG_P: // "p@" -> "peut-être" - return finish_word((uint16_t[]) {FR_E, FR_U, FR_T, FR_MOIN, FR_ACIR, FR_E, FR_T, FR_R, FR_E}, 9, record); + return finish_word((uint16_t[]) {FG_E, FG_U, FG_T, FG_MOIN, FG_ACIR, FG_E, FG_T, FG_R, FG_E}, 9, record); - case FR_A: + case FG_A: // "a@" -> "aujourd'hui" - return finish_word((uint16_t[]) {FR_U, FR_J, FR_O, FR_U, FR_R, FR_D, FR_APOS, FR_H, FR_U, FR_I}, 10, record); + return finish_word((uint16_t[]) {FG_U, FG_J, FG_O, FG_U, FG_R, FG_D, FG_APOS, FG_H, FG_U, FG_I}, 10, record); - case FR_B: + case FG_B: // "b@" -> "beaucoup" - return finish_word((uint16_t[]) {FR_E, FR_A, FR_U, FR_C, FR_O, FR_U, FR_P}, 7, record); + return finish_word((uint16_t[]) {FG_E, FG_A, FG_U, FG_C, FG_O, FG_U, FG_P}, 7, record); - case FR_E: + case FG_E: // "e@" -> "est-ce qu" - return finish_word((uint16_t[]) {FR_S, FR_T, FR_MOIN, FR_C, FR_E, KC_SPC, FR_Q}, 7, record); + return finish_word((uint16_t[]) {FG_S, FG_T, FG_MOIN, FG_C, FG_E, KC_SPC, FG_Q}, 7, record); - case FR_D: + case FG_D: // "d@" -> "déjà" - return finish_word((uint16_t[]) {FR_EACU, FR_J, FR_AGRV}, 3, record); + return finish_word((uint16_t[]) {FG_EACU, FG_J, FG_AGRV}, 3, record); } - } else if (prev_keycode == FR_P) { + } else if (prev_keycode == FG_P) { switch (next_keycode) { - case FR_M: + case FG_M: // "pas" - return finish_word((uint16_t[]) {FR_A, FR_S}, 2, record); + return finish_word((uint16_t[]) {FG_A, FG_S}, 2, record); - case FR_APOS: + case FG_APOS: // "par" - return finish_word((uint16_t[]) {FR_A, FR_R}, 2, record); + return finish_word((uint16_t[]) {FG_A, FG_R}, 2, record); - case FR_POIN: + case FG_POIN: if (!isLetter(recent[RECENT_SIZE - 2])) { // "pour" - return finish_word((uint16_t[]) {FR_O, FR_U, FR_R}, 3, record); + return finish_word((uint16_t[]) {FG_O, FG_U, FG_R}, 3, record); } } - } else if (next_keycode == FR_A && prev_keycode == FR_O) { + } else if (next_keycode == FG_A && prev_keycode == FG_O) { // "oa" -> "oi" - process_next_key(FR_I, record); + process_next_key(FG_I, record); return false; - } else if (next_keycode == FR_O && prev_keycode == FR_U && recent[RECENT_SIZE - 2] != FR_Q) { + } else if (next_keycode == FG_O && prev_keycode == FG_U && recent[RECENT_SIZE - 2] != FG_Q) { // "uo" -> "un" - process_next_key(FR_N, record); + process_next_key(FG_N, record); return false; } switch (next_keycode) { - case FR_QUES: - case FR_EXLM: + case FG_QUES: + case FG_EXLM: // On ajoute un espace insécable s'il n'a pas été entré avant le point d'exclamation. // Il ne faut pas tester cette fonctionnalité avec Word, qui ajoute cet espace automatiquement. if (isLetter(recent[RECENT_SIZE - 1])) { @@ -146,73 +146,73 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) { case MAGIC: switch (prev_keycode) { - case FR_T: - process_next_key(FR_I, record); - case FR_I: - return finish_word((uint16_t[]) {FR_O, FR_N}, 2, record); + case FG_T: + process_next_key(FG_I, record); + case FG_I: + return finish_word((uint16_t[]) {FG_O, FG_N}, 2, record); - case FR_C: - return finish_word((uint16_t[]) {FR_APOS, FR_E, FR_S, FR_T}, 4, record); + case FG_C: + return finish_word((uint16_t[]) {FG_APOS, FG_E, FG_S, FG_T}, 4, record); - case FR_D: - return finish_word((uint16_t[]) {FR_A, FR_N, FR_S}, 3, record); + case FG_D: + return finish_word((uint16_t[]) {FG_A, FG_N, FG_S}, 3, record); - case FR_P: - return finish_word((uint16_t[]) {FR_L, FR_U, FR_S}, 3, record); + case FG_P: + return finish_word((uint16_t[]) {FG_L, FG_U, FG_S}, 3, record); - case FR_A: - return finish_word((uint16_t[]) {FR_V, FR_E, FR_C}, 3, record); + case FG_A: + return finish_word((uint16_t[]) {FG_V, FG_E, FG_C}, 3, record); - case FR_S: - return finish_word((uint16_t[]) {FR_U, FR_R}, 2, record); + case FG_S: + return finish_word((uint16_t[]) {FG_U, FG_R}, 2, record); - case FR_B: - process_word((uint16_t[]) {FR_O, FR_N, FR_J}, 3, record); + case FG_B: + process_word((uint16_t[]) {FG_O, FG_N, FG_J}, 3, record); - case FR_J: - return finish_word((uint16_t[]) {FR_O, FR_U, FR_R}, 3, record); + case FG_J: + return finish_word((uint16_t[]) {FG_O, FG_U, FG_R}, 3, record); - case FR_M: + case FG_M: // "même" - return finish_word((uint16_t[]) {FR_ACIR, FR_E, FR_M, FR_E}, 4, record); + return finish_word((uint16_t[]) {FG_ACIR, FG_E, FG_M, FG_E}, 4, record); default: return false; } - case FR_Q: - if (prev_keycode == FR_J) { + case FG_Q: + if (prev_keycode == FG_J) { // "jq" -> "jusqu" - process_word((uint16_t[]) {FR_U, FR_S}, 2, record); + process_word((uint16_t[]) {FG_U, FG_S}, 2, record); } break; case CA_CED: - return finish_word((uint16_t[]) {FR_CCED, FR_A}, 2, record); + return finish_word((uint16_t[]) {FG_CCED, FG_A}, 2, record); case OU_GRV: - return finish_word((uint16_t[]) {FR_O, ALGR(FR_U)}, 2, record); + return finish_word((uint16_t[]) {FG_O, ALGR(FG_U)}, 2, record); case AGRV_SPC: - return finish_word((uint16_t[]) {FR_AGRV, KC_SPC}, 2, record); + return finish_word((uint16_t[]) {FG_AGRV, KC_SPC}, 2, record); case E_CIRC: - return process_accent(FR_ACIR, FR_E, record); + return process_accent(FG_ACIR, FG_E, record); case I_CIRC: - return process_accent(FR_ACIR, FR_I, record); + return process_accent(FG_ACIR, FG_I, record); case A_CIRC: - return process_accent(FR_ACIR, FR_A, record); + return process_accent(FG_ACIR, FG_A, record); case O_CIRC: - return process_accent(FR_ACIR, FR_O, record); + return process_accent(FG_ACIR, FG_O, record); case U_CIRC: - return process_accent(FR_ACIR, FR_U, record); + return process_accent(FG_ACIR, FG_U, record); case I_TREM: - return process_accent(FR_TREM, FR_I, record); + return process_accent(FG_TREM, FG_I, record); } store_keycode(next_keycode, record); diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_utilities.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_utilities.c index 5d1e97b4..5a48f6a2 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_utilities.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_utilities.c @@ -80,7 +80,7 @@ uint16_t get_next_keycode(uint16_t keycode, keyrecord_t* record) { switch (basic_keycode) { case KC_A ... KC_SLASH: // These keys type letters, digits, symbols. - case FR_E: + case FG_E: if (isLetter(basic_keycode) && (mods & ~MOD_BIT(KC_ALGR))) { // Shift doesn't matter for letters. diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/combos.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/combos.c index 05568538..34b7ab35 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/combos.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/combos.c @@ -36,21 +36,21 @@ enum combos { CTRLALT }; -const uint16_t PROGMEM del_combo_d[] = {FR_S, FR_N, COMBO_END}; -const uint16_t PROGMEM bkspc_combo_d[] = {FR_N, FR_R, COMBO_END}; -const uint16_t PROGMEM del_word_combo[] = {FR_M, FR_L, COMBO_END}; -const uint16_t PROGMEM bk_word_combo[] = {FR_L, FR_APOS, COMBO_END}; -const uint16_t PROGMEM enter_combo[] = {FR_P, FR_EACU, COMBO_END}; -const uint16_t PROGMEM tab_combo[] = {FR_T, FR_I, COMBO_END}; -const uint16_t PROGMEM esc_combo[] = {FR_T, FR_A, COMBO_END}; -const uint16_t PROGMEM bkspc_combo_g[] = {FR_A, FR_I, COMBO_END}; -const uint16_t PROGMEM home_combo[] = {FR_Z, FR_Y, COMBO_END}; -const uint16_t PROGMEM end_combo[] = {FR_EACU, FR_VIRG, COMBO_END}; -const uint16_t PROGMEM help_combo[] = {FR_VIRG, FR_APOS, COMBO_END}; -const uint16_t PROGMEM panic_combo[] = {FR_EACU, FR_L, COMBO_END}; -const uint16_t PROGMEM numword_combo[] = {FR_S, FR_R, COMBO_END}; -const uint16_t PROGMEM alttab_combo[] = {FR_D, FR_Y, COMBO_END}; -const uint16_t PROGMEM ctrlaFR_Combo[] = {FR_A, FR_I, FR_T, COMBO_END}; +const uint16_t PROGMEM del_combo_d[] = {FG_S, FG_N, COMBO_END}; +const uint16_t PROGMEM bkspc_combo_d[] = {FG_N, FG_R, COMBO_END}; +const uint16_t PROGMEM del_word_combo[] = {FG_M, FG_L, COMBO_END}; +const uint16_t PROGMEM bk_word_combo[] = {FG_L, FG_APOS, COMBO_END}; +const uint16_t PROGMEM enter_combo[] = {FG_P, FG_EACU, COMBO_END}; +const uint16_t PROGMEM tab_combo[] = {FG_T, FG_I, COMBO_END}; +const uint16_t PROGMEM esc_combo[] = {FG_T, FG_A, COMBO_END}; +const uint16_t PROGMEM bkspc_combo_g[] = {FG_A, FG_I, COMBO_END}; +const uint16_t PROGMEM home_combo[] = {FG_Z, FG_Y, COMBO_END}; +const uint16_t PROGMEM end_combo[] = {FG_EACU, FG_VIRG, COMBO_END}; +const uint16_t PROGMEM help_combo[] = {FG_VIRG, FG_APOS, COMBO_END}; +const uint16_t PROGMEM panic_combo[] = {FG_EACU, FG_L, COMBO_END}; +const uint16_t PROGMEM numword_combo[] = {FG_S, FG_R, COMBO_END}; +const uint16_t PROGMEM alttab_combo[] = {FG_D, FG_Y, COMBO_END}; +const uint16_t PROGMEM ctrlaFG_Combo[] = {FG_A, FG_I, FG_T, COMBO_END}; combo_t key_combos[] = { [R_BKSPC] = COMBO(bkspc_combo_d, KC_BSPC), @@ -67,7 +67,7 @@ combo_t key_combos[] = { [PANIC] = COMBO(panic_combo, RAZ), [NUMWRD] = COMBO(numword_combo, NUMWORD), [ALTTAB] = COMBO(alttab_combo, KC_NO), - [CTRLALT] = COMBO(ctrlaFR_Combo, RCTL(RALT(KC_DEL))) + [CTRLALT] = COMBO(ctrlaFG_Combo, RCTL(RALT(KC_DEL))) }; /* uint16_t get_combo_term(uint16_t combo_index, combo_t *combo) { @@ -118,10 +118,10 @@ bool process_combo_key_repress(uint16_t combo_index, combo_t *combo, uint8_t key switch (combo_index) { case ALTTAB: switch (keycode) { - case FR_Y: + case FG_Y: tap_code16(S(KC_TAB)); return true; - case FR_D: + case FG_D: tap_code(KC_TAB); return true; } diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/macros.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/macros.c index 2dd9505c..8e5750e2 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/macros.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/macros.c @@ -29,9 +29,15 @@ bool process_macros(uint16_t keycode, keyrecord_t *record) { case OS_TYPO: if ((get_mods() | get_weak_mods() | get_oneshot_mods()) & MOD_BIT(KC_ALGR)) { - tap_code16(ALGR(FR_TYPO)); + tap_code16(ALGR(FG_TYPO)); return false; } + const bool is_shifted = get_mods() & MOD_MASK_SHIFT; + if (is_shifted) { + del_weak_mods(MOD_MASK_SHIFT); + unregister_mods(MOD_MASK_SHIFT); + set_oneshot_mods(MOD_BIT(KC_LSFT)); + } return true; case AIDE_MEM: diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/numword.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/numword.c index f1390f15..ac53613e 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/numword.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/numword.c @@ -55,33 +55,24 @@ bool should_terminate_num_word(uint16_t keycode, const keyrecord_t *record) { // Numpad keycodes case KC_1 ... KC_0: case KC_PDOT: - case FR_VIRG: - case FR_MOIN: - case FR_ASTX: - case FR_PLUS: - case FR_SLSH: - case FR_ACIR: - case FR_CARN: + case FG_VIRG: + case FG_MOIN: + case FG_ASTX: + case FG_PLUS: + case FG_SLSH: + case FG_ACIR: + case FG_CARN: // Misc case KC_BSPC: case NUMWORD: // For the combo NUMWORD to work /* - case FR_EGAL: - case FR_BSLS: - - // Misc - //case KC_BSPC: - case FR_UNDS: */ + case FG_EGAL: + case FG_BSLS:*/ return false; - -/* default: - if (record->event.pressed) { return true; } - return false; */ } - //if (!on_left_hand(record->event.key)) { return false; } return true; } diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/os4a.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/os4a.c index 6d44b0c2..4833c8e3 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/os4a.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/os4a.c @@ -58,11 +58,6 @@ bool process_os4a_keys(uint16_t keycode, keyrecord_t *record) { return true; } -/* void update_osl(uint16_t keycode) { - //if (os4a_layer_changer(keycode)) { pending_OSL = true; } - pending_OSL = os4a_layer_changer(keycode); -} */ - bool process_os4a_layers(uint16_t keycode, keyrecord_t *record) { // Should keycode exit the OS4A layer ? diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/tap_hold_utilities.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/tap_hold_utilities.c index 4d3dabf1..7987baab 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/tap_hold_utilities.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/tap_hold_utilities.c @@ -26,7 +26,8 @@ void tap_converter(uint16_t keycode, keyrecord_t *record) { } else { if (IS_QK_MOD_TAP(keycode) || IS_QK_LAYER_TAP(keycode)) { // Tranform the record to send the tap event - record->keycode = tap_hold_extractor(keycode); + //record->keycode = tap_hold_extractor(keycode); + record->keycode = (keycode &= 0xff); } process_record(record); } @@ -71,14 +72,14 @@ bool process_custom_tap_hold(uint16_t keycode, keyrecord_t *record) { if (record->tap.count) { // Handling of special tap-hold keys (on tap). switch (keycode) { -/* case ALGR_T(FR_LACL): - return process_tap_hold(FR_LACL, record); */ +/* case ALGR_T(FG_LACL): + return process_tap_hold(FG_LACL, record); */ case RCTL_T(FEN_B): return process_tap_hold(LWIN(KC_DOWN), record); case SFT_T(COPY): - return process_tap_hold(C(FR_C), record); + return process_tap_hold(C(FG_C), record); case LT_REPT: repeat_key_invoke(&record->event); diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.c new file mode 100644 index 00000000..fc2d23b6 --- /dev/null +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.c @@ -0,0 +1,127 @@ +/* Copyright 2025 @Kawamashi + * + * 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 . + */ + + #include "typo_layer.h" + + +//bool is_typo = false; +bool exit_typo = false; + +void typo_layer_off() { + layer_off(_TYPO); + exit_typo = false; +} + +bool process_typo(uint16_t keycode, keyrecord_t *record) { + + + return true; +} + +/* bool process_typo(uint16_t keycode, keyrecord_t *record) { + + if (record->event.pressed) { + switch (keycode) { + case OS_TYPO: + // Handle the custom OSL that go with this feature + // It's timerless, to avoid problems when rolling with an other key, when shift is on. + //is_typo = true; + if ((get_mods() | get_weak_mods() | get_oneshot_mods()) & MOD_BIT(KC_ALGR)) { + tap_code16(ALGR(FG_TYPO)); + } else { + layer_on(_TYPO); + } + return false; + + case FG_TYPO: + const bool is_shifted = (get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT; + if (is_shifted) { + del_weak_mods(MOD_MASK_SHIFT); + del_oneshot_mods(MOD_MASK_SHIFT); + unregister_mods(MOD_MASK_SHIFT); + } + tap_code(FG_TYPO); + //set_mods(mods); + if (is_shifted) { + set_oneshot_mods(MOD_BIT(KC_LSFT)); + //is_shifted = false; + } + } + + if (IS_LAYER_ON(_TYPO)) { + switch (keycode) { + case TG_TYPO: + case FG_AROB: + case FG_K: + case FG_J: + case OU_GRV: + break; + + default: + //tap_code(FG_TYPO); + const bool is_shifted = (get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT; + if (is_shifted) { + del_weak_mods(MOD_MASK_SHIFT); + del_oneshot_mods(MOD_MASK_SHIFT); + unregister_mods(MOD_MASK_SHIFT); + } + tap_code(FG_TYPO); + if (is_shifted) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } + } + exit_typo = true; + } + } + return true; +} */ + + + +/* bool process_typo(uint16_t keycode, const keyrecord_t *record) { + // Handle the custom keycodes that go with this feature + if (keycode == OS_TYPO) { + if (record->event.pressed) { + is_typo = true; + layer_on(_TYPO); + return false; + } + } + + // Other than the custom keycode, nothing else in this feature will activate + // if the behavior is not on, so allow QMK to handle the event as usual. + if (!is_typo) { return true; } + + switch (keycode) { + case TG_TYPO : + case FG_AROB: + case FG_K: + case FG_J: + case OU_GRV: + break; + + default: + const bool is_shifted = (get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT; + if (is_shifted) { + del_weak_mods(MOD_MASK_SHIFT); + del_oneshot_mods(MOD_MASK_SHIFT); + unregister_mods(MOD_MASK_SHIFT); + } + tap_code(FG_TYPO); + if (is_shifted) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } + } + + exit_typo = true; + return true; +} */ \ No newline at end of file diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.h b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.h new file mode 100644 index 00000000..5c3b7dfb --- /dev/null +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.h @@ -0,0 +1,35 @@ +/* Copyright 2025 @Kawamashi + * + * 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 + +#include "quantum.h" +#include "keymap.h" + +#ifdef __cplusplus +extern "C" { +#endif + +extern bool exit_typo; + +void typo_layer_off(void); + +bool process_typo(uint16_t keycode, keyrecord_t *record); + +#ifdef __cplusplus +} +#endif diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features_conf.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features_conf.c index a1b9b9c8..b4e6a198 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features_conf.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features_conf.c @@ -23,8 +23,9 @@ bool isLetter(uint16_t keycode) { case KC_A ... KC_N: case KC_Q ... KC_V: case KC_X ... KC_Z: - case FR_E: - case KC_NUHS ... KC_DOT: + case FG_U: + case FG_E: + case KC_GRV ... KC_DOT: return true; default: @@ -32,6 +33,8 @@ bool isLetter(uint16_t keycode) { } } +// This function extracts the base keycode of MT and LT, +// even if the tap/hold key is a custom one, with non-basic tap keycode. uint16_t tap_hold_extractor(uint16_t keycode) { switch (keycode) { default: @@ -46,7 +49,7 @@ bool caps_word_press_user(uint16_t keycode) { // Managing underscore on alt gr + E. // Underscore must continue Caps Word, without shifting. - if ((get_mods() & MOD_BIT(KC_ALGR)) && keycode == FR_E) { return true; } + if ((get_mods() & MOD_BIT(KC_ALGR)) && keycode == FG_E) { return true; } // Keycodes that continue Caps Word, with shift applied. if (isLetter(keycode)) { @@ -56,17 +59,17 @@ bool caps_word_press_user(uint16_t keycode) { switch (keycode) { // Keycodes that continue Caps Word, without shifting. - case FR_TYPO: - //case FR_GRV: - case FR_MOIN: - case FR_UNDS: - case FR_SLSH: + case FG_TYPO: + //case FG_GRV: + case FG_MOIN: + case FG_UNDS: + case FG_SLSH: case KC_KP_1 ... KC_KP_0: case KC_LEFT: case KC_RIGHT: case KC_BSPC: case KC_DEL: - case FR_APOS: + case FG_APOS: return true; default: @@ -74,25 +77,6 @@ bool caps_word_press_user(uint16_t keycode) { } } - -// Custom AltGr keys - -/* const custom_altgr_key_t custom_altgr_keys[] = { - {FR_C, FR_COPY}, - {FR_Y, FR_TM}, - //{FR_I, FR_LDAQ}, - //{FR_T, FR_RDAQ}, - {FR_J, FR_CURR}, - //{FR_H, FR_HASH}, - {FR_Q, FR_SECT}, - {KC_KP_8, FR_INFN}, - {FR_F, FR_DEG} -}; - -uint8_t NUM_CUSTOM_ALTGR_KEYS = - sizeof(custom_altgr_keys) / sizeof(custom_altgr_key_t);*/ - - // One-shot 4 all configuration uint8_t get_os4a_layer(uint16_t keycode) { @@ -108,6 +92,7 @@ bool os4a_layer_changer(uint16_t keycode) { case OS_FA: case NUMWORD: case TT_FA: + case TG_APOD: return true; default: return false; @@ -149,7 +134,7 @@ bool is_oneshot_ignored_key(uint16_t keycode) { //if (keycode == OS_TYPO && (mods & ~MOD_BIT(KC_ALGR))) { return true;} switch (keycode) { - case OS_TYPO: + //case OS_TYPO: /!\ A ne pas remettre, sous peine de ne pas pouvoir faire shift + typo + touche de l'autre côté case L_OS4A: case R_OS4A: case OS_SHFT: @@ -160,7 +145,7 @@ bool is_oneshot_ignored_key(uint16_t keycode) { case OS_FA: case NUMWORD: case TT_FA: - case FR_TYPO: + case FG_TYPO: return true; default: return false; @@ -183,10 +168,10 @@ bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* reme uint16_t get_alt_repeat_key_keycode_user(uint16_t keycode, uint8_t mods) { switch (keycode) { - case C(FR_Z): - return C(FR_Y); - case C(FR_Y): - return C(FR_Z); + case C(FG_Z): + return C(FG_Y); + case C(FG_Y): + return C(FG_Z); } keycode = tap_hold_extractor(keycode); diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap - Copie.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap - Copie.c index 50683dda..94ab6654 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap - Copie.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap - Copie.c @@ -23,12 +23,12 @@ bool is_caps_lock_on(void) { return host_keyboard_led_state().caps_lock; } bool isLetter(uint16_t keycode) { switch (keycode) { case KC_A ... KC_L: - case FR_M: + case FG_M: case KC_N ... KC_Z: - case FR_AGRV: - case FR_EACU: - case FR_EGRV: - case FR_CCED: + case FG_AGRV: + case FG_EACU: + case FG_EGRV: + case FG_CCED: return true; default: @@ -64,13 +64,13 @@ bool caps_word_press_user(uint16_t keycode) { } else { switch (keycode) { // Keycodes that continue Caps Word, without shifting. - case FR_MOIN: + case FG_MOIN: case KC_KP_1 ... KC_KP_0: case KC_LEFT: case KC_RIGHT: case KC_BSPC: case KC_DEL: - case FR_APOS: + case FG_APOS: return true; default: @@ -87,24 +87,24 @@ uint16_t COMBO_LEN = 0; // Custom altGr keys const custom_altgr_key_t custom_altgr_keys[] = { - {FR_AGRV, FR_AE}, - {FR_B, FR_SS}, - {FR_A, FR_LDAQ}, - {FR_I, FR_RDAQ}, - {FR_T, FR_ESPR}, - {FR_S, FR_AROB}, - {ALGR_T(FR_A), FR_LDAQ}, - {LCTL_T(FR_I), FR_RDAQ}, - {RCTL_T(FR_T), FR_ESPR}, - {ALGR_T(FR_S), FR_AROB}, - {FR_X, FR_TM}, - {KC_KP_8, FR_INFN}, - {FR_H, FR_HASH}, - {FR_V, FR_DEG}, - {FR_CCED, FR_CEDL}, - {FR_Q, FR_SECT}, - {FR_POIN, FR_PVIR}, - {FR_C, FR_COPY}, + {FG_AGRV, FG_AE}, + {FG_B, FG_SS}, + {FG_A, FG_LDAQ}, + {FG_I, FG_RDAQ}, + {FG_T, FG_ESPR}, + {FG_S, FG_AROB}, + {ALGR_T(FG_A), FG_LDAQ}, + {LCTL_T(FG_I), FG_RDAQ}, + {RCTL_T(FG_T), FG_ESPR}, + {ALGR_T(FG_S), FG_AROB}, + {FG_X, FG_TM}, + {KC_KP_8, FG_INFN}, + {FG_H, FG_HASH}, + {FG_V, FG_DEG}, + {FG_CCED, FG_CEDL}, + {FG_Q, FG_SECT}, + {FG_POIN, FG_PVIR}, + {FG_C, FG_COPY}, }; uint8_t NUM_CUSTOM_ALTGR_KEYS = @@ -156,9 +156,9 @@ bool forbidden_chord(uint16_t tap_hold_keycode, keyrecord_t* tap_hold_record, ui bool first_of_chorded_mods(uint16_t keycode) { switch (keycode) { case LT_TAB: // Pour pouvoir faire OSM shift + LT_TAB (win + shift + flèche). - case FR_CCED: // Pour pouvoir faire Alt + F4, Alt + F11. - case LCTL_T(FR_I): - case RCTL_T(FR_T): + case FG_CCED: // Pour pouvoir faire Alt + F4, Alt + F11. + case LCTL_T(FG_I): + case RCTL_T(FG_T): case OSM(MOD_LSFT): // Pour pouvoir faire OSM shift + LT_TAB (win + shift + flèche). return true; @@ -234,10 +234,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_BASE] = LAYOUT( - KC_ESC, FR_AGRV, FR_B, FR_EACU, FR_POIN, FR_MOIN, FR_ACIR, FR_V, FR_L, FR_M, FR_X, FR_W, - KC_ENT, ALT_T(FR_O), SFT_T(FR_U), ALGR_T(FR_A), LCTL_T(FR_I), FR_J, FR_G, RCTL_T(FR_T), ALGR_T(FR_S), RSFT_T(FR_N), ALT_T(FR_R), FR_F, - LT_TAB, FR_Q, FR_Y, FR_EGRV, LWIN_T(FR_P), FR_DQUO, KC_BSPC, KC_END, KC_HOME, KC_DEL, FR_K, RWIN_T(FR_D), FR_Z, FR_H, FR_C, FR_CCED, - TG(_SYMBOLS), KC_SPC, OSM(MOD_LSFT), LT(_SYMBOLS,FR_E), LT_VIRG, LT_APOS, LT(_SYMBOLS,KC_SPC), OSM(MOD_RSFT), KC_RGUI, KC_MUTE + KC_ESC, FG_AGRV, FG_B, FG_EACU, FG_POIN, FG_MOIN, FG_ACIR, FG_V, FG_L, FG_M, FG_X, FG_W, + KC_ENT, ALT_T(FG_O), SFT_T(FG_U), ALGR_T(FG_A), LCTL_T(FG_I), FG_J, FG_G, RCTL_T(FG_T), ALGR_T(FG_S), RSFT_T(FG_N), ALT_T(FG_R), FG_F, + LT_TAB, FG_Q, FG_Y, FG_EGRV, LWIN_T(FG_P), FG_DQUO, KC_BSPC, KC_END, KC_HOME, KC_DEL, FG_K, RWIN_T(FG_D), FG_Z, FG_H, FG_C, FG_CCED, + TG(_SYMBOLS), KC_SPC, OSM(MOD_LSFT), LT(_SYMBOLS,FG_E), LT_VIRG, LT_APOS, LT(_SYMBOLS,KC_SPC), OSM(MOD_RSFT), KC_RGUI, KC_MUTE ), @@ -256,10 +256,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_SYMBOLS] = LAYOUT( - KC_ESC, FR_EXLM, FR_QUES, FR_ESPR, FR_PVIR, FR_PIPE, FR_MOIN, KC_P7, KC_P8, KC_P9, FR_ASTX, KC_NUM, - _______, FR_LACL, SFT_T(FR_RACL), ALGR_T(FR_LPRN), FR_RPRN, LAYER_LCK, FR_EGAL, RCTL_T(KC_P4), ALGR_T(KC_P5), KC_P6, FR_SLSH, FR_BSLS, - _______, FR_LBKT, FR_RBKT, FR_INF, FR_SUP, FR_CARN, _______, _______, _______, _______, FR_ACIR, KC_P1, KC_P2, KC_P3, FR_PLUS, FR_PERC, - _______, _______, _______, KC_SPC, FR_VIRG, NUMWORD, KC_P0, KC_PDOT, _______ , _______ + KC_ESC, FG_EXLM, FG_QUES, FG_ESPR, FG_PVIR, FG_PIPE, FG_MOIN, KC_P7, KC_P8, KC_P9, FG_ASTX, KC_NUM, + _______, FG_LACL, SFT_T(FG_RACL), ALGR_T(FG_LPRN), FG_RPRN, LAYER_LCK, FG_EGAL, RCTL_T(KC_P4), ALGR_T(KC_P5), KC_P6, FG_SLSH, FG_BSLS, + _______, FG_LBKT, FG_RBKT, FG_INF, FG_SUP, FG_CARN, _______, _______, _______, _______, FG_ACIR, KC_P1, KC_P2, KC_P3, FG_PLUS, FG_PERC, + _______, _______, _______, KC_SPC, FG_VIRG, NUMWORD, KC_P0, KC_PDOT, _______ , _______ ), /* * Layer 2 : Symbols + function keys @@ -276,9 +276,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_SHORTNAV] = LAYOUT( - KC_ESC, A(KC_F4), ALT_TAB, LWIN(FR_V), _______, _______, _______, C(KC_LEFT), KC_UP, C(KC_RIGHT), _______, _______, - _______, C(FR_A), C(FR_X), C(FR_V), C(FR_C), LAYER_LCK, KC_MUTE, RCTL_T(KC_LEFT), KC_DOWN, KC_RIGHT, KC_F2 , KC_MUTE, - _______, SELWORD, LWIN(KC_TAB), REV_TAB, ALT_TAB, _______, _______, S(KC_END), S(KC_HOME), _______, _______, C(FR_Z), C(FR_Y), _______, _______, _______, + KC_ESC, A(KC_F4), ALT_TAB, LWIN(FG_V), _______, _______, _______, C(KC_LEFT), KC_UP, C(KC_RIGHT), _______, _______, + _______, C(FG_A), C(FG_X), C(FG_V), C(FG_C), LAYER_LCK, KC_MUTE, RCTL_T(KC_LEFT), KC_DOWN, KC_RIGHT, KC_F2 , KC_MUTE, + _______, SELWORD, LWIN(KC_TAB), REV_TAB, ALT_TAB, _______, _______, S(KC_END), S(KC_HOME), _______, _______, C(FG_Z), C(FG_Y), _______, _______, _______, _______, _______, _______, QUES_PT, QUES_PT, EXCL_PT, EXCL_PT, _______, _______, _______ ), @@ -299,7 +299,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { [_FUNCAPPS] = LAYOUT( KC_ESC, KC_F12, KC_F9, KC_F8, KC_F7, C(KC_PAUS), _______, SWIN(KC_LEFT), LWIN(KC_UP), SWIN(KC_RIGHT), _______, QK_BOOT, _______, ALT_T(KC_F11), SFT_T(KC_F6), KC_F5, KC_F4, LAYER_LCK, _______, RCTL_T(FEN_G), LWIN(KC_DOWN), LWIN(KC_RIGHT), _______, _______, - _______, KC_F10, KC_F3, KC_F2, KC_F1, _______, _______, _______, _______, _______, _______, LWIN(FR_D), LWIN(KC_HOME), _______, _______, _______, + _______, KC_F10, KC_F3, KC_F2, KC_F1, _______, _______, _______, _______, _______, _______, LWIN(FG_D), LWIN(KC_HOME), _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ ), diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.c b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.c index 4ebd8dff..386ff5d9 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.c +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.c @@ -14,7 +14,7 @@ * along with this program. If not, see . */ - + #include QMK_KEYBOARD_H #include "keymap.h" @@ -97,15 +97,17 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // Custom tap-hold keys if (!process_custom_tap_hold(keycode, record)) { return false; } + if (!process_typo(keycode, record)) { return false; } + if (IS_LAYER_ON(_TYPO) && record->event.pressed) { switch (keycode) { - case FR_AROB: - case FR_K: - case FR_J: - case CA_CED: - case AGRV_SPC: + case FG_AROB: + case FG_K: + case FG_J: case OU_GRV: + case FG_CCED: + case AGRV_SPC: break; default: @@ -115,17 +117,17 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { del_oneshot_mods(MOD_MASK_SHIFT); unregister_mods(MOD_MASK_SHIFT); } - tap_code(FR_TYPO); + tap_code(FG_TYPO); //set_mods(mods); - if (is_shifted) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } + if (is_shifted) { + set_oneshot_mods(MOD_BIT(KC_LSFT)); + //is_shifted = false; + } } } // Macros if (!process_macros(keycode, record)) { return false; } - - // Custom alt gr - //if (!process_custom_altgr_keys(keycode, record)) { return false; } // Clever keys if (!process_clever_keys(keycode, record)) { return false; } @@ -136,12 +138,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { void post_process_record_user(uint16_t keycode, keyrecord_t* record) { // - if (os4a_layer != 0 && exit_os4a_layer) { - os4a_layer_off(os4a_layer); - } - if (exit_num_word) { - disable_num_word(); - } + if (os4a_layer != 0 && exit_os4a_layer) { os4a_layer_off(os4a_layer); } + if (exit_num_word) { disable_num_word(); } + //if (exit_typo && keycode != FG_TYPO) { typo_layer_off(); } } @@ -163,12 +162,32 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_BASE] = LAYOUT( - KC_NO, FR_X, FR_VIRG, FR_EACU, FR_P, FR_B, FR_F, FR_M, FR_L, FR_APOS, FR_POIN, KC_NO, - KC_NO, FR_O, FR_A, FR_I, FR_T, FR_G, FR_V, FR_S, FR_N, FR_R, FR_U, KC_NO, - KC_NO, FR_Q, FR_Z, FR_Y, FR_D, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, FR_C, FR_H, FR_W, OS_TYPO, KC_NO, + KC_NO, FG_X, FG_VIRG, FG_EACU, FG_P, FG_B, FG_F, FG_M, FG_L, FG_APOS, FG_POIN, KC_NO, + KC_NO, FG_O, FG_A, FG_I, FG_T, FG_G, FG_V, FG_S, FG_N, FG_R, FG_U, KC_NO, + KC_NO, FG_Q, FG_Z, FG_Y, FG_D, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, FG_C, FG_H, FG_W, OS_TYPO, KC_NO, KC_NO, KC_SPC, L_OS4A, LT_E, LT_MGC, LT_REPT, LT_SPC, R_OS4A, KC_RGUI, KC_NO ), +// * Layer template +// * +// * ,-------------------------------------------. ,-------------------------------------------. +// * | | | | | | | | | | | | | | +// * |--------+------+------+------+------+------| |------+------+------+------+------+--------| +// * | | | | | | | | | | | | | | +// * |--------+------+------+------+------+------+-------------. ,-------------+------+------+------+------+------+--------| +// * | | | | | | | | | | | | | | | | | | +// * `----------------------+------+------+------+------+------| |------+------+------+------+------+----------------------' +// * | | | | | | | | | | | | +// * | | | | | | | | | | | | +// * `----------------------------------' `----------------------------------' +// */ + [_APOS_DR] = LAYOUT( + _______, _______, _______, _______, _______, _______, _______, _______, _______, FG_APOD, _______, _______, + _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, + _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, + _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ + ), + /* * Layer 1 : Mods gauche * @@ -205,32 +224,13 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_R_MODS] = LAYOUT( - _______, _______, _______, _______, _______, _______, KC_NO, KC_RGUI, OS_WIN, KC_NO, KC_NO, KC_NO, - _______, _______, _______, _______, _______, _______, TT_FA, OS_SHFT, OS_CTRL, NUMWORD, FR_TYPO, KC_NO, + _______, _______, _______, _______, _______, _______, KC_NO, KC_RGUI, OS_WIN, TG_APOD, KC_NO, KC_NO, + _______, _______, _______, _______, _______, _______, TT_FA, OS_SHFT, OS_CTRL, NUMWORD, FG_TYPO, KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, OS_FA, OS_LALT, KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, KC_NO, KC_NO ), -/* - * Layer 3 : Numpad + symbols - * - * ,-------------------------------------------. ,-------------------------------------------. - * | | | & | ; | | | ^ | | ⁻ | 7 | 8 | 9 | * |NumLock | - * |--------+------+------+------+------+------| |------+------+------+------+------+--------| - * | | { | } | ( | ) | ˇ | | = | 4 | 5 | 6 | / | \ | - * |--------+------+------+------+------+------+-------------. ,-------------+------+------+------+------+------+--------| - * | | [ | ] | < | > | | | | | | | | 1 | 2 | 3 | + | % | - * `----------------------+------+------+------+------+------| |------+------+------+------+------+----------------------' - * | | | | | | | | 0 | . | | | - * | | | | | | | , | | | | | - * `----------------------------------' `----------------------------------' - */ -/* [_SYMBOLS] = LAYOUT( - _______, CIRC, FR_EXLM, FR_EGAL, FR_DLR, FR_AROB, FR_HASH, FR_INF, FR_SUP, FR_QUES, FR_2PTS, _______, - _______, FR_ASTX, FR_PLUS, FR_MOIN, FR_SLSH, FR_BSLS, GRAVE, FR_LPRN, FR_RPRN, FR_PVIR, FR_DQUO, _______, - _______, FR_PERC, TILDE, FR_PIPE, FR_ESPR, KC_NO, _______, _______, _______, _______, KC_NO, FR_LACL, FR_RACL, FR_LBKT, FR_RBKT, _______, - _______, _______, _______, FR_UNDS, _______, _______, FR_UNDS, KC_PDOT, _______, _______ - ), */ + /* * Layer 1 : Numpad @@ -247,32 +247,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_NUMBERS] = LAYOUT( - _______, _______, FR_ASTX, FR_EGAL, _______, S(FR_ACIR), KC_6, _______, FR_PLUS, FR_MOIN, _______, _______, - _______, KC_8, KC_6, KC_4, KC_2, FR_CARN, _______, KC_1, KC_3, KC_5, KC_7, _______, - _______, _______, _______, _______, FR_SLSH, _______, _______, _______, _______, _______, _______, KC_9, _______, _______, _______, _______, - _______, _______, FR_VIRG, KC_0 , NUMWORD, LT_REPT, KC_SPC, KC_PDOT, _______, _______ + _______, _______, FG_ASTX, FG_EGAL, _______, FG_PERC, KC_6, _______, FG_PLUS, FG_MOIN, _______, _______, + _______, KC_6, KC_4, KC_2, FG_SLSH, FG_CARN, S(FG_ACIR), KC_1, KC_3, KC_5, KC_7, _______, + _______, _______, _______, _______, KC_8, _______, _______, _______, _______, _______, _______, KC_9, _______, _______, _______, _______, + _______, _______, FG_VIRG, KC_0 , NUMWORD, LT_REPT, KC_SPC, _______, _______, _______ ), -/* - * Layer 2 : Symbols - * - * ,-------------------------------------------. ,-------------------------------------------. - * | | ! | ? | & | ; | | | | ⁻ | 7 | 8 | 9 | * |NumLock | - * |--------+------+------+------+------+------| |------+------+------+------+------+--------| - * | | { | } | ( | ) |Expos.| | = | 4 | 5 | 6 | / | \ | - * |--------+------+------+------+------+------+-------------. ,-------------+------+------+------+------+------+--------| - * | | [ | ] | < | > |Indice| | | | | | | 1 | 2 | 3 | + | % | - * `----------------------+------+------+------+------+------| |------+------+------+------+------+----------------------' - * | | | | | | | | 0 | . | | | - * | | | | | | | , | | | | | - * `----------------------------------' `----------------------------------' - */ -/* [_SYMBOLS] = LAYOUT( - _______, _______, _______, FR_DQUO, FR_PVIR, FR_ACIR, _______, KC_HOME, KC_UP, KC_END, _______, _______, - _______, FR_LACL, FR_RACL, FR_LPRN, FR_RPRN, FR_CARN, _______, KC_LEFT, KC_DOWN, ALGR_T(KC_RIGHT), KC_F2 , KC_MUTE, - _______, FR_LBKT, FR_RBKT, FR_INF, FR_SUP, KC_NO, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - _______, _______, _______, KC_SPC, FR_VIRG, NUMWORD, KC_P0, KC_PDOT, _______, _______ - ), */ /* * Layer 2 : Symbols @@ -289,10 +269,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_TYPO] = LAYOUT( - _______, _______, _______, _______, _______, FR_J, FR_K, FR_F, FR_D, _______, _______, _______, - _______, OU_GRV, _______, _______, _______, _______, FR_M, FR_J, FR_L, FR_AROB, _______, _______, - _______, _______, _______, _______, CA_CED, _______, _______, _______, _______, _______, _______, _______, _______, FR_K, TG_TYPO, _______, - _______, _______, _______, _______, FR_O, _______, AGRV_SPC, _______, _______, _______ + _______, _______, _______, _______, _______, FG_D, _______, S(FG_M), S(FG_L), _______, _______, _______, + _______, OU_GRV, _______, _______, FG_B, _______, _______, FG_J, FG_T, FG_AROB, _______, _______, + _______, _______, _______, _______, FG_DQUO, _______, _______, _______, _______, _______, _______, FG_CCED, _______, FG_K, TG_TYPO, _______, + _______, _______, _______, _______, FG_O, _______, AGRV_SPC, _______, _______, _______ ), @@ -311,9 +291,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * `----------------------------------' `----------------------------------' */ [_SHORTNAV] = LAYOUT( - _______, KC_BSPC, LWIN(KC_TAB), LWIN(FR_V), RCS(FR_V), _______, KC_PGUP, C(KC_LEFT), KC_UP, C(KC_RGHT), _______, _______, - _______, C(FR_A), C(FR_X), C(FR_V), SFT_T(COPY), _______, KC_PGDN, KC_LEFT, KC_DOWN, KC_RIGHT, KC_F2 , _______, - _______, KC_SPC, KC_SPC, KC_SPC, C(FR_Z), C(FR_Y), _______, _______, _______, _______, _______, KC_VOLD, KC_VOLU, KC_MUTE, _______, _______, + _______, KC_BSPC, LWIN(KC_TAB), LWIN(FG_V), RCS(FG_V), _______, KC_PGUP, C(KC_LEFT), KC_UP, C(KC_RGHT), _______, _______, + _______, C(FG_A), C(FG_X), C(FG_V), SFT_T(COPY), _______, KC_PGDN, KC_LEFT, KC_DOWN, KC_RIGHT, KC_F2 , _______, + _______, KC_SPC, KC_SPC, KC_SPC, C(FG_Z), C(FG_Y), _______, _______, _______, _______, _______, KC_VOLD, KC_VOLU, KC_MUTE, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ ), diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.h b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.h index 87ef2a7f..29c390ee 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.h +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.h @@ -13,7 +13,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #pragma once #include QMK_KEYBOARD_H @@ -21,17 +21,18 @@ #include "keymap_french_frgo.h" #include "features_conf.h" #include "clever_keys.h" -#include "features/custom_altgr_keys.h" #include "features/tap_hold_utilities.h" #include "features/clever_keys_utilities.h" #include "features/numword.h" #include "features/macros.h" #include "features/os4a.h" #include "features/oneshot.h" +#include "features/typo_layer.h" enum layers { _BASE = 0, + _APOS_DR, // OS4A layers should be as closed as base layer as possible _L_MODS, _R_MODS, @@ -51,33 +52,35 @@ enum custom_keycodes { CAPSWORD, AGRV_SPC, OU_GRV, - E_CIRC, - I_CIRC, + E_CIRC, +/* I_CIRC, A_CIRC, O_CIRC, U_CIRC, - I_TREM, + I_TREM, */ CA_CED, - CIRC, +/* CIRC, TILDE, - GRAVE, + GRAVE, */ MAGIC, OS_SHFT, OS_CTRL, OS_RALT, OS_LALT, - OS_WIN + OS_WIN, + //OS_TYPO }; // Layer taps #define LT_SPC ALGR_T(KC_SPC) -#define LT_E ALGR_T(FR_E) +#define LT_E ALGR_T(FG_E) #define LT_REPT LT(_NUMBERS, KC_0) #define LT_MGC LT(_SHORTNAV, KC_0) #define OS_TYPO OSL(_TYPO) #define OS_FA OSL(_FUNCAPPS) #define TT_FA TT(_FUNCAPPS) #define TG_TYPO TG(_TYPO) +#define TG_APOD TG(_APOS_DR) // One shot mods #define L_OS4A LSFT_T(OS4A) diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap_french_frgo.h b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap_french_frgo.h index 772572db..5e475314 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap_french_frgo.h +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap_french_frgo.h @@ -24,11 +24,11 @@ /* * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ - * │ À │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ / │ * │       │ + * │ Ç │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ / │ * │       │ * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ * │     │ X │ , │ É │ P │ B │ F │ M │ L │ ' │ . │ = │ + │     │ * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │ - * │      │ O │ A │ I │ T │ G │ V │ S │ N │ R │ U │ Ù │ Ç │    │ + * │      │ O │ A │ I │ T │ G │ V │ S │ N │ R │ U │ - │ ’ │    │ * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ * │    │ E │ Q │ Z │ Y │ D │ J │ K │ C │ H │ W │ **│          │ * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ @@ -37,60 +37,60 @@ */ // Row 1 -#define FR_AGRV KC_GRV // à -#define FR_1 KC_1 // 1 -#define FR_2 KC_2 // 2 -#define FR_3 KC_3 // 3 -#define FR_4 KC_4 // 4 -#define FR_5 KC_5 // 5 -#define FR_6 KC_6 // 6 -#define FR_7 KC_7 // 7 -#define FR_8 KC_8 // 8 -#define FR_9 KC_9 // 9 -#define FR_0 KC_0 // 0 -#define FR_SLSH KC_MINS // / -#define FR_ASTX KC_EQL // * +#define FG_CCED KC_GRV // ç +#define FG_1 KC_1 // 1 +#define FG_2 KC_2 // 2 +#define FG_3 KC_3 // 3 +#define FG_4 KC_4 // 4 +#define FG_5 KC_5 // 5 +#define FG_6 KC_6 // 6 +#define FG_7 KC_7 // 7 +#define FG_8 KC_8 // 8 +#define FG_9 KC_9 // 9 +#define FG_0 KC_0 // 0 +#define FG_SLSH KC_MINS // / +#define FG_ASTX KC_EQL // * // Row 2 -#define FR_X KC_Q // X -#define FR_VIRG KC_W // , -#define FR_EACU KC_E // É -#define FR_P KC_R // P -#define FR_B KC_T // B -#define FR_F KC_Y // F -#define FR_M KC_U // M -#define FR_L KC_I // L -#define FR_APOS KC_O // ' -#define FR_POIN KC_P // . -#define FR_EGAL KC_LBRC // = -#define FR_PLUS KC_RBRC // + +#define FG_X KC_Q // X +#define FG_VIRG KC_W // , +#define FG_EACU KC_E // É +#define FG_P KC_R // P +#define FG_B KC_T // B +#define FG_F KC_Y // F +#define FG_M KC_U // M +#define FG_L KC_I // L +#define FG_APOS KC_O // ’ +#define FG_POIN KC_P // . +#define FG_EGAL KC_LBRC // = +#define FG_PLUS KC_RBRC // + // Row 3 -#define FR_O KC_A // O -#define FR_A KC_S // A -#define FR_I KC_D // I -#define FR_T KC_F // T -#define FR_G KC_G // G -#define FR_V KC_H // V -#define FR_S KC_J // S -#define FR_N KC_K // N -#define FR_R KC_L // R -#define FR_U KC_SCLN // U -#define FR_UGRV KC_QUOT // Ù -#define FR_CCED KC_NUHS // Ç +#define FG_O KC_A // O +#define FG_A KC_S // A +#define FG_I KC_D // I +#define FG_T KC_F // T +#define FG_G KC_G // G +#define FG_V KC_H // V +#define FG_S KC_J // S +#define FG_N KC_K // N +#define FG_R KC_L // R +#define FG_U KC_SCLN // U +#define FG_MOIN KC_QUOT // - +#define FG_APOD KC_NUHS // ' // Row 4 -#define FR_E KC_NUBS // E -#define FR_Q KC_Z // Q -#define FR_Z KC_X // Z -#define FR_Y KC_C // Y -#define FR_D KC_V // D -#define FR_J KC_B // J -#define FR_K KC_N // K -#define FR_C KC_M // C -#define FR_H KC_COMM // H -#define FR_W KC_DOT // W -#define FR_TYPO KC_SLSH // ** +#define FG_E KC_NUBS // E +#define FG_Q KC_Z // Q +#define FG_Z KC_X // Z +#define FG_Y KC_C // Y +#define FG_D KC_V // D +#define FG_J KC_B // J +#define FG_K KC_N // K +#define FG_C KC_M // C +#define FG_H KC_COMM // H +#define FG_W KC_DOT // W +#define FG_TYPO KC_SLSH // ** /* Shifted symbols @@ -99,21 +99,24 @@ * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ * │     │   │ ! │   │   │   │   │   │   │ ? │ : │ ≠ │   │     │ * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │ - * │      │   │   │   │   │   │   │   │   │   │   │   │   │    │ + * │      │   │   │   │   │   │   │   │   │   │   │   │ ? │    │ * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │    │   │   │   │   │   │   │   │   │   │   │   │          │ + * │    │   │   │   │   │   │   │   │   │   │   │ ; │          │ * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ * │    │    │    │                        │    │    │    │    │ * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ */ // Row 2 -#define FR_EXLM S(FR_VIRG) // ! -#define FR_QUES S(FR_APOS) // ? -#define FR_2PTS S(FR_POIN) // : -#define FR_DIFF S(FR_EGAL) // ≠ +#define FG_EXLM S(FG_VIRG) // ! +#define FG_QUES S(FG_APOS) // ? +#define FG_2PTS S(FG_POIN) // : +#define FG_DIFF S(FG_EGAL) // ≠ + +// Row 4 +//#define FG_PVIR S(FG_TYPO) // Row 5 -#define FR_NBSP S(KC_SPC) // Espace insecable +#define FG_NBSP S(KC_SPC) // Espace insecable @@ -121,50 +124,51 @@ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ * │   │ ₁ │ ₂ │ ₃ │ ₄ │ ₅ │ ₆ │ ₇ │ ₈ │ ₉ │ ₀ │   │   │       │ * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │     │ ^ │ ! │ = │ $ │ @ │ # │ < │ > │ ? │ : │   │   │     │ + * │     │ ^ │ ! │ = │ $ │ % │ # │ ; │ ' │ ? │ : │   │   │     │ * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │ - * │      │ * │ + │ - │ / │ \ │ ` │ ( │ ) │ ; │ " │   │   │    │ + * │      │ * │ + │ - │ / │ \ │ ` │ ( │ ) │ < │ > │   │   │    │ * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │    │ _ │ % │ ~ │ | │ & │   │   │ { │ } │ [ │ ] │          │ + * │    │ _ │ ~ │ | │ & │ " │ @ │   │ { │ } │ [ │ ] │          │ * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ * │    │    │    │                        │    │    │    │    │ * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ */ // Row 2 -#define FR_ACIR ALGR(FR_X) // ^ -//#define FR_EXLM ALGR(FR_VIRG) // ! -//#define FR_EGAL ALGR(FR_EACU) // = -#define FR_DLR ALGR(FR_P) // $ -#define FR_AROB ALGR(FR_B) // @ -#define FR_HASH ALGR(FR_F) // # -#define FR_INF ALGR(FR_M) // < -#define FR_SUP ALGR(FR_L) // > -//#define FR_QUES ALGR(FR_APOS) // ? -//#define FR_2PTS ALGR(FR_POIN) // : +#define FG_ACIR ALGR(FG_X) // ^ +//#define FG_EXLM ALGR(FG_VIRG) // ! +//#define FG_EGAL ALGR(FG_EACU) // = +#define FG_DLR ALGR(FG_P) // $ +#define FG_PERC ALGR(FG_B) // % +#define FG_HASH ALGR(FG_F) // # +#define FG_PVIR ALGR(FG_M) // ; +//#define FG_QUES ALGR(FG_APOS) // ? +//#define FG_2PTS ALGR(FG_POIN) // : // Row 3 -/* #define FR_ASTX ALGR(FR_O) // * -#define FR_PLUS ALGR(FR_A) // + -#define FR_SLSH ALGR(FR_T) // / */ -#define FR_MOIN ALGR(FR_I) // - -#define FR_BSLS ALGR(FR_G) // '\' -#define FR_GRV ALGR(FR_V) // ` -#define FR_LPRN ALGR(FR_S) // ( -#define FR_RPRN ALGR(FR_N) // ) -#define FR_PVIR ALGR(FR_R) // ; -#define FR_DQUO ALGR(FR_U) // " +/* #define FG_ASTX ALGR(FG_O) // * +#define FG_PLUS ALGR(FG_A) // + +#define FG_SLSH ALGR(FG_T) // / +#define FG_MOIN ALGR(FG_I) // - */ +#define FG_BSLS ALGR(FG_G) // '\' +#define FG_GRV ALGR(FG_V) // ` +#define FG_LPRN ALGR(FG_S) // ( +#define FG_RPRN ALGR(FG_N) // ) +#define FG_INF ALGR(FG_R) // < +#define FG_SUP ALGR(FG_U) // > +//#define FG_DQUO ALGR(FG_U) // " +#define FG_AROB ALGR(FG_J) // Row 4 -#define FR_UNDS ALGR(FR_E) // _ -#define FR_PERC ALGR(FR_Q) // % -#define FR_TILD ALGR(FR_Z) // ~ -#define FR_PIPE ALGR(FR_Y) // | -#define FR_ESPR ALGR(FR_D) // & -#define FR_LCBR ALGR(FR_C) // { -#define FR_RCBR ALGR(FR_H) // } -#define FR_LSBR ALGR(FR_W) // [ -#define FR_RSBR ALGR(FR_TYPO) // ] +#define FG_UNDS ALGR(FG_E) // _ +#define FG_TILD ALGR(FG_Q) // ~ +#define FG_PIPE ALGR(FG_Z) // | +#define FG_ESPR ALGR(FG_Y) // & +#define FG_DQUO ALGR(FG_D) // " +#define FG_LCBR ALGR(FG_C) // { +#define FG_RCBR ALGR(FG_H) // } +#define FG_LSBR ALGR(FG_W) // [ +#define FG_RSBR ALGR(FG_TYPO) // ] /* Shift+AltGr symbols @@ -181,27 +185,27 @@ * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ */ - #define FR_CARN S(ALGR(FR_POIN)) // ˇ (dead) + #define FG_CARN S(ALGR(FG_POIN)) // ˇ (dead) /* // Row 1 -#define FR_IBRV S(ALGR(FR_AROB)) //  ̑ (dead) -#define FR_DACU S(ALGR(FR_LPRN)) // ˝ (dead) -#define FR_DGRV S(ALGR(FR_RPRN)) //  ̏ (dead) -#define FR_MDSH S(ALGR(FR_RSQU)) // — -#define FR_LSAQ S(ALGR(FR_LDAQ)) // ‹ -#define FR_RSAQ S(ALGR(FR_RDAQ)) // › -#define FR_IQUE S(ALGR(FR_APOS)) // ¿ +#define FG_IBRV S(ALGR(FG_AROB)) //  ̑ (dead) +#define FG_DACU S(ALGR(FG_LPRN)) // ˝ (dead) +#define FG_DGRV S(ALGR(FG_RPRN)) //  ̏ (dead) +#define FG_MDSH S(ALGR(FG_RSQU)) // — +#define FG_LSAQ S(ALGR(FG_LDAQ)) // ‹ +#define FG_RSAQ S(ALGR(FG_RDAQ)) // › +#define FG_IQUE S(ALGR(FG_APOS)) // ¿ // Row 2 -#define FR_TM S(ALGR(FR_T)) // ™ -#define FR_DOTB S(ALGR(FR_I)) //  ̣ (dead) -#define FR_PERM S(ALGR(FR_P)) // ‰ -#define FR_NBHY S(ALGR(FR_MOIN)) // ‑ (non-breaking hyphen) -#define FR_DDAG S(ALGR(FR_PLUS)) // ‡ +#define FG_TM S(ALGR(FG_T)) // ™ +#define FG_DOTB S(ALGR(FG_I)) //  ̣ (dead) +#define FG_PERM S(ALGR(FG_P)) // ‰ +#define FG_NBHY S(ALGR(FG_MOIN)) // ‑ (non-breaking hyphen) +#define FG_DDAG S(ALGR(FG_PLUS)) // ‡ // Row 3 -#define FR_MACB S(ALGR(FR_H)) // ˍ (dead) -#define FR_SQRT S(ALGR(FR_SLSH)) // √ -#define FR_QRTR S(ALGR(FR_ASTX)) // ¼ +#define FG_MACB S(ALGR(FG_H)) // ˍ (dead) +#define FG_SQRT S(ALGR(FG_SLSH)) // √ +#define FG_QRTR S(ALGR(FG_ASTX)) // ¼ // Row 4 -#define FR_GEQL S(ALGR(FR_INF)) // ≥ -#define FR_OGON S(ALGR(FR_V)) // ˛ (dead) -#define FR_IEXL S(ALGR(FR_VIRG)) //  ̦ (dead) -//#define FR_NEQL S(ALGR(FR_EGAL)) // ≠ */ +#define FG_GEQL S(ALGR(FG_INF)) // ≥ +#define FG_OGON S(ALGR(FG_V)) // ˛ (dead) +#define FG_IEXL S(ALGR(FG_VIRG)) //  ̦ (dead) +//#define FG_NEQL S(ALGR(FG_EGAL)) // ≠ */ diff --git a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/rules.mk b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/rules.mk index d07c29c0..ea0b060a 100644 --- a/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/rules.mk +++ b/keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/rules.mk @@ -34,6 +34,7 @@ SRC += features/numword.c SRC += features/macros.c SRC += features/oneshot.c SRC += features_conf.c +SRC += features/typo_layer.c INTROSPECTION_KEYMAP_C = features/combos.c