mirrors/qmk_userspace
1
0
Fork 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2026-03-10 10:20:23 -04:00
Code Issues Projects Releases Packages Wiki Activity

Changement de préfixe

Browse source 
FR -> FG
This commit is contained in:
Kawamashi 2025-03-23 11:39:49 +01:00
commit 71f7675cc8
16 changed files with 616 additions and 510 deletions
Download patch file Download diff file Expand all files Collapse all files

214
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/clever_keys.c
View file

@ -27,19 +27,19 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
if (isLetter(next_keycode) || next_keycode == E_CIRC) { if (isLetter(next_keycode) || next_keycode == E_CIRC) {
switch (prev_keycode) { switch (prev_keycode) {
case FR_EXLM: case FG_EXLM:
case FR_QUES: case FG_QUES:
//case FR_3PTS: //case FG_3PTS:
case FR_2PTS: case FG_2PTS:
// Add space between punctuation and letters. // Add space between punctuation and letters.
invoke_key(KC_SPC, record); invoke_key(KC_SPC, record);
case KC_SPC: case KC_SPC:
switch (recent[RECENT_SIZE - 2]) { switch (recent[RECENT_SIZE - 2]) {
case FR_EXLM: case FG_EXLM:
case FR_QUES: case FG_QUES:
//case FR_3PTS: //case FG_3PTS:
case FR_POIN: case FG_POIN:
// Add OS shift at the beginning of sentences. // Add OS shift at the beginning of sentences.
if (!is_caps_lock_on()) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } if (!is_caps_lock_on()) { set_oneshot_mods(MOD_BIT(KC_LSFT)); }
break; break;
@ -50,62 +50,67 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
switch (prev_keycode) { switch (prev_keycode) {
case FR_Q: case FG_Q:
switch (next_keycode) { switch (next_keycode) {
// Ajout automatique du "u" après le "q" // Ajout automatique du "u" après le "q"
case FR_E: case FG_E:
case FR_I: case FG_I:
case FR_A: case FG_A:
case FR_O: case FG_O:
case FR_EACU: case FG_EACU:
case E_CIRC: case E_CIRC:
case FR_APOS: case FG_APOS:
invoke_key(FR_U, record); invoke_key(FG_U, record);
break; break;
// Raccourci pour "quelq" // Raccourci pour "quelq"
case FR_Q: case FG_Q:
clear_recent_keys(); // To prevent infinite loop 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; break;
// Raccourci pour "quoi", ça évite un aller-retour sur la main gauche. // Raccourci pour "quoi", ça évite un aller-retour sur la main gauche.
case FR_Z: case FG_Z:
return finish_word((uint16_t[]) {FR_U, FR_O, FR_I}, 3, record); return finish_word((uint16_t[]) {FG_U, FG_O, FG_I}, 3, record);
// Raccourci pour "quand" // Raccourci pour "quand"
case FR_D: case FG_D:
process_word((uint16_t[]) {FR_U, FR_A, FR_N}, 3, record); process_word((uint16_t[]) {FG_U, FG_A, FG_N}, 3, record);
break; break;
} }
break; break;
case FR_P: case FG_P:
switch (next_keycode) { switch (next_keycode) {
case FR_M: case FG_M:
// "pas" // "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" // "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])) { if (!isLetter(recent[RECENT_SIZE - 2])) {
// "pour" // "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) { switch (next_keycode) {
case FR_QUES: case FG_QUES:
case FR_EXLM: case FG_EXLM:
// On ajoute un espace insécable s'il n'a pas été entré avant le point d'exclamation. // 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. // Il ne faut pas tester cette fonctionnalité avec Word, qui ajoute cet espace automatiquement.
if (isLetter(recent[RECENT_SIZE - 1])) { 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); del_oneshot_mods(MOD_MASK_SHIFT);
unregister_mods(MOD_MASK_SHIFT); unregister_mods(MOD_MASK_SHIFT);
} */ } */
invoke_key(S(KC_SPC), record); invoke_key(KC_SPC, record);
//set_mods(mods); //set_mods(mods);
return replace_next_key(next_keycode, record); return replace_next_key(next_keycode, record);
} }
@ -124,161 +129,134 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
case MAGIC: case MAGIC:
switch (prev_keycode) { switch (prev_keycode) {
case FR_T: case FG_T:
invoke_key(FR_I, record); invoke_key(FG_I, record);
case FR_I: case FG_I:
return finish_magic((uint16_t[]) {FR_O, FR_N}, 2, record); return finish_magic((uint16_t[]) {FG_O, FG_N}, 2, record);
case FR_C: case FG_C:
return finish_magic((uint16_t[]) {FR_APOS, FR_E, FR_S, FR_T}, 4, record); return finish_magic((uint16_t[]) {FG_APOS, FG_E, FG_S, FG_T}, 4, record);
case FR_D: case FG_D:
return finish_magic((uint16_t[]) {FR_A, FR_N, FR_S}, 3, record); return finish_magic((uint16_t[]) {FG_A, FG_N, FG_S}, 3, record);
case FR_P: case FG_P:
return finish_magic((uint16_t[]) {FR_L, FR_U, FR_S}, 3, record); return finish_magic((uint16_t[]) {FG_L, FG_U, FG_S}, 3, record);
case FR_O: case FG_O:
return finish_magic((uint16_t[]) {FR_N, FR_T}, 2, record); return finish_magic((uint16_t[]) {FG_N, FG_T}, 2, record);
case FR_A: case FG_A:
if (isLetter(recent[RECENT_SIZE - 2])) { if (isLetter(recent[RECENT_SIZE - 2])) {
// "ant" // "ant"
return finish_magic((uint16_t[]) {FR_N, FR_T}, 2, record); return finish_magic((uint16_t[]) {FG_N, FG_T}, 2, record);
} else { } else {
// "avec" // "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: case FG_S:
return finish_magic((uint16_t[]) {FR_U, FR_R}, 2, record); return finish_magic((uint16_t[]) {FG_U, FG_R}, 2, record);
case FR_B: case FG_B:
process_word((uint16_t[]) {FR_O, FR_N, FR_J}, 3, record); process_word((uint16_t[]) {FG_O, FG_N, FG_J}, 3, record);
case FR_J: case FG_J:
return finish_magic((uint16_t[]) {FR_O, FR_U, FR_R}, 3, record); 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])) { if (isLetter(recent[RECENT_SIZE - 2])) {
// "ment" // "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 { } else {
// "même" // "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: default:
return false; return false;
} }
case FR_AROB: case FG_AROB:
if (!isLetter(recent[RECENT_SIZE - 2])) { if (!isLetter(recent[RECENT_SIZE - 2])) {
switch (prev_keycode) { switch (prev_keycode) {
case FR_T: case FG_T:
// "t@" -> "toujours" // "t@" -> "toujours"
layer_off(_TYPO); 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" // "p@" -> "peut-être"
layer_off(_TYPO); 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" // "a@" -> "aujourd'hui"
layer_off(_TYPO); 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" // "b@" -> "beaucoup"
layer_off(_TYPO); 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" // "e@" -> "est-ce qu"
layer_off(_TYPO); 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à" // "d@" -> "déjà"
layer_off(_TYPO); 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; break;
case FR_Q: case FG_Q:
if (prev_keycode == FR_J) { if (prev_keycode == FG_J) {
// "jq" -> "jusqu" // "jq" -> "jusqu"
process_word((uint16_t[]) {FR_U, FR_S}, 2, record); process_word((uint16_t[]) {FG_U, FG_S}, 2, record);
} }
break; break;
case FR_A: case FG_A:
//if (prev_keycode == FR_O && !isCaps) { //if (prev_keycode == FG_O && !isCaps) {
if (prev_keycode == FR_O) { if (prev_keycode == FG_O) {
// "oa" -> "oi" // "oa" -> "oi"
clear_recent_keys(); // To prevent infinite loop clear_recent_keys(); // To prevent infinite loop
return replace_next_key(FR_I, record); return replace_next_key(FG_I, record);
} }
break; break;
case FR_I: case FG_I:
//if (prev_keycode == FR_O && !isCaps && recent[RECENT_SIZE - 3] != FR_Q) { //if (prev_keycode == FG_O && !isCaps && recent[RECENT_SIZE - 3] != FG_Q) {
if (prev_keycode == FR_O && recent[RECENT_SIZE - 3] != FR_Q) { if (prev_keycode == FG_O && recent[RECENT_SIZE - 3] != FG_Q) {
// "oi" -> "oa", for "keyboard" // "oi" -> "oa", for "keyboard"
clear_recent_keys(); // To prevent infinite loop clear_recent_keys(); // To prevent infinite loop
return replace_next_key(FR_A, record); return replace_next_key(FG_A, record);
} }
break; break;
case FR_O: case FG_O:
if (prev_keycode == FR_U && recent[RECENT_SIZE - 2] != FR_Q) { if (prev_keycode == FG_U && recent[RECENT_SIZE - 2] != FG_Q) {
// "uo" -> "un" // "uo" -> "un"
return replace_next_key(FR_N, record); return replace_next_key(FG_N, record);
} }
break; break;
case CA_CED: /* case CA_CED:
layer_off(_TYPO); //layer_off(_TYPO);
return finish_word((uint16_t[]) {FR_CCED, FR_A}, 2, record); return finish_word((uint16_t[]) {FG_C, FG_A}, 2, record); */
case OU_GRV: case OU_GRV:
layer_off(_TYPO); 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: case AGRV_SPC:
layer_off(_TYPO); //layer_off(_TYPO);
return finish_word((uint16_t[]) {FR_AGRV, KC_SPC}, 2, record); return finish_word((uint16_t[]) {FG_A, 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);*/
} }
return false; // Process next keycode normally return false; // Process next keycode normally

160
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_old.c
View file

@ -15,19 +15,19 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) {
if (isLetter(next_keycode) || next_keycode == E_CIRC) { if (isLetter(next_keycode) || next_keycode == E_CIRC) {
switch (prev_keycode) { switch (prev_keycode) {
case FR_EXLM: case FG_EXLM:
case FR_QUES: case FG_QUES:
case FR_3PTS: case FG_3PTS:
case FR_2PTS: case FG_2PTS:
// Add space between punctuation and letters. // Add space between punctuation and letters.
process_next_key(KC_SPC, record); process_next_key(KC_SPC, record);
case KC_SPC: case KC_SPC:
switch (recent[RECENT_SIZE - 2]) { switch (recent[RECENT_SIZE - 2]) {
case FR_EXLM: case FG_EXLM:
case FR_QUES: case FG_QUES:
case FR_3PTS: case FG_3PTS:
case FR_POIN: case FG_POIN:
// Add OS shift at the beginning of a sentence. // Add OS shift at the beginning of a sentence.
if (!is_caps_lock_on()) { set_oneshot_mods(MOD_BIT(KC_LSFT)); } if (!is_caps_lock_on()) { set_oneshot_mods(MOD_BIT(KC_LSFT)); }
break; break;
@ -36,97 +36,97 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) {
} }
// Ajout automatique du "u" après le "q" // Ajout automatique du "u" après le "q"
if (prev_keycode == FR_Q) { if (prev_keycode == FG_Q) {
switch (next_keycode) { switch (next_keycode) {
case FR_E: case FG_E:
case FR_I: case FG_I:
case FR_A: case FG_A:
case FR_O: case FG_O:
case FR_EACU: case FG_EACU:
case E_CIRC: case E_CIRC:
case FR_APOS: case FG_APOS:
process_next_key(FR_U, record); process_next_key(FG_U, record);
break; break;
// Raccourci pour "quelq" // Raccourci pour "quelq"
case FR_Q: case FG_Q:
clear_recent_keys(); // To prevent infinite loop 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; break;
// Raccourci pour "quoi", ça évite un aller-retour sur la main gauche. // Raccourci pour "quoi", ça évite un aller-retour sur la main gauche.
case FR_Z: case FG_Z:
return finish_word((uint16_t[]) {FR_U, FR_O, FR_I}, 3, record); return finish_word((uint16_t[]) {FG_U, FG_O, FG_I}, 3, record);
// Raccourci pour "quand" // Raccourci pour "quand"
case FR_D: case FG_D:
process_word((uint16_t[]) {FR_U, FR_A, FR_N}, 3, record); process_word((uint16_t[]) {FG_U, FG_A, FG_N}, 3, record);
break; 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) { switch (prev_keycode) {
case FR_T: case FG_T:
// "t@" -> "toujours" // "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" // "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" // "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" // "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" // "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à" // "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) { switch (next_keycode) {
case FR_M: case FG_M:
// "pas" // "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" // "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])) { if (!isLetter(recent[RECENT_SIZE - 2])) {
// "pour" // "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" // "oa" -> "oi"
process_next_key(FR_I, record); process_next_key(FG_I, record);
return false; 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" // "uo" -> "un"
process_next_key(FR_N, record); process_next_key(FG_N, record);
return false; return false;
} }
switch (next_keycode) { switch (next_keycode) {
case FR_QUES: case FG_QUES:
case FR_EXLM: case FG_EXLM:
// On ajoute un espace insécable s'il n'a pas été entré avant le point d'exclamation. // 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. // Il ne faut pas tester cette fonctionnalité avec Word, qui ajoute cet espace automatiquement.
if (isLetter(recent[RECENT_SIZE - 1])) { if (isLetter(recent[RECENT_SIZE - 1])) {
@ -146,73 +146,73 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) {
case MAGIC: case MAGIC:
switch (prev_keycode) { switch (prev_keycode) {
case FR_T: case FG_T:
process_next_key(FR_I, record); process_next_key(FG_I, record);
case FR_I: case FG_I:
return finish_word((uint16_t[]) {FR_O, FR_N}, 2, record); return finish_word((uint16_t[]) {FG_O, FG_N}, 2, record);
case FR_C: case FG_C:
return finish_word((uint16_t[]) {FR_APOS, FR_E, FR_S, FR_T}, 4, record); return finish_word((uint16_t[]) {FG_APOS, FG_E, FG_S, FG_T}, 4, record);
case FR_D: case FG_D:
return finish_word((uint16_t[]) {FR_A, FR_N, FR_S}, 3, record); return finish_word((uint16_t[]) {FG_A, FG_N, FG_S}, 3, record);
case FR_P: case FG_P:
return finish_word((uint16_t[]) {FR_L, FR_U, FR_S}, 3, record); return finish_word((uint16_t[]) {FG_L, FG_U, FG_S}, 3, record);
case FR_A: case FG_A:
return finish_word((uint16_t[]) {FR_V, FR_E, FR_C}, 3, record); return finish_word((uint16_t[]) {FG_V, FG_E, FG_C}, 3, record);
case FR_S: case FG_S:
return finish_word((uint16_t[]) {FR_U, FR_R}, 2, record); return finish_word((uint16_t[]) {FG_U, FG_R}, 2, record);
case FR_B: case FG_B:
process_word((uint16_t[]) {FR_O, FR_N, FR_J}, 3, record); process_word((uint16_t[]) {FG_O, FG_N, FG_J}, 3, record);
case FR_J: case FG_J:
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);
case FR_M: case FG_M:
// "même" // "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: default:
return false; return false;
} }
case FR_Q: case FG_Q:
if (prev_keycode == FR_J) { if (prev_keycode == FG_J) {
// "jq" -> "jusqu" // "jq" -> "jusqu"
process_word((uint16_t[]) {FR_U, FR_S}, 2, record); process_word((uint16_t[]) {FG_U, FG_S}, 2, record);
} }
break; break;
case CA_CED: 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: 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: 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: case E_CIRC:
return process_accent(FR_ACIR, FR_E, record); return process_accent(FG_ACIR, FG_E, record);
case I_CIRC: case I_CIRC:
return process_accent(FR_ACIR, FR_I, record); return process_accent(FG_ACIR, FG_I, record);
case A_CIRC: case A_CIRC:
return process_accent(FR_ACIR, FR_A, record); return process_accent(FG_ACIR, FG_A, record);
case O_CIRC: case O_CIRC:
return process_accent(FR_ACIR, FR_O, record); return process_accent(FG_ACIR, FG_O, record);
case U_CIRC: case U_CIRC:
return process_accent(FR_ACIR, FR_U, record); return process_accent(FG_ACIR, FG_U, record);
case I_TREM: case I_TREM:
return process_accent(FR_TREM, FR_I, record); return process_accent(FG_TREM, FG_I, record);
} }
store_keycode(next_keycode, record); store_keycode(next_keycode, record);

2
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_utilities.c
View file

@ -80,7 +80,7 @@ uint16_t get_next_keycode(uint16_t keycode, keyrecord_t* record) {
switch (basic_keycode) { switch (basic_keycode) {
case KC_A ... KC_SLASH: // These keys type letters, digits, symbols. 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))) { if (isLetter(basic_keycode) && (mods & ~MOD_BIT(KC_ALGR))) {
// Shift doesn't matter for letters. // Shift doesn't matter for letters.

36
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/combos.c
View file

@ -36,21 +36,21 @@ enum combos {
CTRLALT CTRLALT
}; };
const uint16_t PROGMEM del_combo_d[] = {FR_S, FR_N, COMBO_END}; const uint16_t PROGMEM del_combo_d[] = {FG_S, FG_N, COMBO_END};
const uint16_t PROGMEM bkspc_combo_d[] = {FR_N, FR_R, COMBO_END}; const uint16_t PROGMEM bkspc_combo_d[] = {FG_N, FG_R, COMBO_END};
const uint16_t PROGMEM del_word_combo[] = {FR_M, FR_L, COMBO_END}; const uint16_t PROGMEM del_word_combo[] = {FG_M, FG_L, COMBO_END};
const uint16_t PROGMEM bk_word_combo[] = {FR_L, FR_APOS, COMBO_END}; const uint16_t PROGMEM bk_word_combo[] = {FG_L, FG_APOS, COMBO_END};
const uint16_t PROGMEM enter_combo[] = {FR_P, FR_EACU, COMBO_END}; const uint16_t PROGMEM enter_combo[] = {FG_P, FG_EACU, COMBO_END};
const uint16_t PROGMEM tab_combo[] = {FR_T, FR_I, COMBO_END}; const uint16_t PROGMEM tab_combo[] = {FG_T, FG_I, COMBO_END};
const uint16_t PROGMEM esc_combo[] = {FR_T, FR_A, COMBO_END}; const uint16_t PROGMEM esc_combo[] = {FG_T, FG_A, COMBO_END};
const uint16_t PROGMEM bkspc_combo_g[] = {FR_A, FR_I, COMBO_END}; const uint16_t PROGMEM bkspc_combo_g[] = {FG_A, FG_I, COMBO_END};
const uint16_t PROGMEM home_combo[] = {FR_Z, FR_Y, COMBO_END}; const uint16_t PROGMEM home_combo[] = {FG_Z, FG_Y, COMBO_END};
const uint16_t PROGMEM end_combo[] = {FR_EACU, FR_VIRG, COMBO_END}; const uint16_t PROGMEM end_combo[] = {FG_EACU, FG_VIRG, COMBO_END};
const uint16_t PROGMEM help_combo[] = {FR_VIRG, FR_APOS, COMBO_END}; const uint16_t PROGMEM help_combo[] = {FG_VIRG, FG_APOS, COMBO_END};
const uint16_t PROGMEM panic_combo[] = {FR_EACU, FR_L, COMBO_END}; const uint16_t PROGMEM panic_combo[] = {FG_EACU, FG_L, COMBO_END};
const uint16_t PROGMEM numword_combo[] = {FR_S, FR_R, COMBO_END}; const uint16_t PROGMEM numword_combo[] = {FG_S, FG_R, COMBO_END};
const uint16_t PROGMEM alttab_combo[] = {FR_D, FR_Y, COMBO_END}; const uint16_t PROGMEM alttab_combo[] = {FG_D, FG_Y, COMBO_END};
const uint16_t PROGMEM ctrlaFR_Combo[] = {FR_A, FR_I, FR_T, COMBO_END}; const uint16_t PROGMEM ctrlaFG_Combo[] = {FG_A, FG_I, FG_T, COMBO_END};
combo_t key_combos[] = { combo_t key_combos[] = {
[R_BKSPC] = COMBO(bkspc_combo_d, KC_BSPC), [R_BKSPC] = COMBO(bkspc_combo_d, KC_BSPC),
@ -67,7 +67,7 @@ combo_t key_combos[] = {
[PANIC] = COMBO(panic_combo, RAZ), [PANIC] = COMBO(panic_combo, RAZ),
[NUMWRD] = COMBO(numword_combo, NUMWORD), [NUMWRD] = COMBO(numword_combo, NUMWORD),
[ALTTAB] = COMBO(alttab_combo, KC_NO), [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) { /* 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) { switch (combo_index) {
case ALTTAB: case ALTTAB:
switch (keycode) { switch (keycode) {
case FR_Y: case FG_Y:
tap_code16(S(KC_TAB)); tap_code16(S(KC_TAB));
return true; return true;
case FR_D: case FG_D:
tap_code(KC_TAB); tap_code(KC_TAB);
return true; return true;
} }

8
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/macros.c
View file

@ -29,9 +29,15 @@ bool process_macros(uint16_t keycode, keyrecord_t *record) {
case OS_TYPO: case OS_TYPO:
if ((get_mods() | get_weak_mods() | get_oneshot_mods()) & MOD_BIT(KC_ALGR)) { 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; 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; return true;
case AIDE_MEM: case AIDE_MEM:

27
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/numword.c
View file

@ -55,33 +55,24 @@ bool should_terminate_num_word(uint16_t keycode, const keyrecord_t *record) {
// Numpad keycodes // Numpad keycodes
case KC_1 ... KC_0: case KC_1 ... KC_0:
case KC_PDOT: case KC_PDOT:
case FR_VIRG: case FG_VIRG:
case FR_MOIN: case FG_MOIN:
case FR_ASTX: case FG_ASTX:
case FR_PLUS: case FG_PLUS:
case FR_SLSH: case FG_SLSH:
case FR_ACIR: case FG_ACIR:
case FR_CARN: case FG_CARN:
// Misc // Misc
case KC_BSPC: case KC_BSPC:
case NUMWORD: // For the combo NUMWORD to work case NUMWORD: // For the combo NUMWORD to work
/* /*
case FR_EGAL: case FG_EGAL:
case FR_BSLS: case FG_BSLS:*/
// Misc
//case KC_BSPC:
case FR_UNDS: */
return false; return false;
/* default:
if (record->event.pressed) { return true; }
return false; */
} }
//if (!on_left_hand(record->event.key)) { return false; }
return true; return true;
} }

5
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/os4a.c
View file

@ -58,11 +58,6 @@ bool process_os4a_keys(uint16_t keycode, keyrecord_t *record) {
return true; 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) { bool process_os4a_layers(uint16_t keycode, keyrecord_t *record) {
// Should keycode exit the OS4A layer ? // Should keycode exit the OS4A layer ?

9
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/tap_hold_utilities.c
View file

@ -26,7 +26,8 @@ void tap_converter(uint16_t keycode, keyrecord_t *record) {
} else { } else {
if (IS_QK_MOD_TAP(keycode) || IS_QK_LAYER_TAP(keycode)) { if (IS_QK_MOD_TAP(keycode) || IS_QK_LAYER_TAP(keycode)) {
// Tranform the record to send the tap event // 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); 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). if (record->tap.count) { // Handling of special tap-hold keys (on tap).
switch (keycode) { switch (keycode) {
/* case ALGR_T(FR_LACL): /* case ALGR_T(FG_LACL):
return process_tap_hold(FR_LACL, record); */ return process_tap_hold(FG_LACL, record); */
case RCTL_T(FEN_B): case RCTL_T(FEN_B):
return process_tap_hold(LWIN(KC_DOWN), record); return process_tap_hold(LWIN(KC_DOWN), record);
case SFT_T(COPY): case SFT_T(COPY):
return process_tap_hold(C(FR_C), record); return process_tap_hold(C(FG_C), record);
case LT_REPT: case LT_REPT:
repeat_key_invoke(&record->event); repeat_key_invoke(&record->event);

127
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.c Normal file
View file

@ -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 <http://www.gnu.org/licenses/>.
*/
#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;
} */

35
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/typo_layer.h Normal file
View file

@ -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 <http://www.gnu.org/licenses/>.
*/
#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

53
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features_conf.c
View file

@ -23,8 +23,9 @@ bool isLetter(uint16_t keycode) {
case KC_A ... KC_N: case KC_A ... KC_N:
case KC_Q ... KC_V: case KC_Q ... KC_V:
case KC_X ... KC_Z: case KC_X ... KC_Z:
case FR_E: case FG_U:
case KC_NUHS ... KC_DOT: case FG_E:
case KC_GRV ... KC_DOT:
return true; return true;
default: 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) { uint16_t tap_hold_extractor(uint16_t keycode) {
switch (keycode) { switch (keycode) {
default: default:
@ -46,7 +49,7 @@ bool caps_word_press_user(uint16_t keycode) {
// Managing underscore on alt gr + E. // Managing underscore on alt gr + E.
// Underscore must continue Caps Word, without shifting. // 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. // Keycodes that continue Caps Word, with shift applied.
if (isLetter(keycode)) { if (isLetter(keycode)) {
@ -56,17 +59,17 @@ bool caps_word_press_user(uint16_t keycode) {
switch (keycode) { switch (keycode) {
// Keycodes that continue Caps Word, without shifting. // Keycodes that continue Caps Word, without shifting.
case FR_TYPO: case FG_TYPO:
//case FR_GRV: //case FG_GRV:
case FR_MOIN: case FG_MOIN:
case FR_UNDS: case FG_UNDS:
case FR_SLSH: case FG_SLSH:
case KC_KP_1 ... KC_KP_0: case KC_KP_1 ... KC_KP_0:
case KC_LEFT: case KC_LEFT:
case KC_RIGHT: case KC_RIGHT:
case KC_BSPC: case KC_BSPC:
case KC_DEL: case KC_DEL:
case FR_APOS: case FG_APOS:
return true; return true;
default: 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 // One-shot 4 all configuration
uint8_t get_os4a_layer(uint16_t keycode) { uint8_t get_os4a_layer(uint16_t keycode) {
@ -108,6 +92,7 @@ bool os4a_layer_changer(uint16_t keycode) {
case OS_FA: case OS_FA:
case NUMWORD: case NUMWORD:
case TT_FA: case TT_FA:
case TG_APOD:
return true; return true;
default: default:
return false; 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;} //if (keycode == OS_TYPO && (mods & ~MOD_BIT(KC_ALGR))) { return true;}
switch (keycode) { 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 L_OS4A:
case R_OS4A: case R_OS4A:
case OS_SHFT: case OS_SHFT:
@ -160,7 +145,7 @@ bool is_oneshot_ignored_key(uint16_t keycode) {
case OS_FA: case OS_FA:
case NUMWORD: case NUMWORD:
case TT_FA: case TT_FA:
case FR_TYPO: case FG_TYPO:
return true; return true;
default: default:
return false; 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) { uint16_t get_alt_repeat_key_keycode_user(uint16_t keycode, uint8_t mods) {
switch (keycode) { switch (keycode) {
case C(FR_Z): case C(FG_Z):
return C(FR_Y); return C(FG_Y);
case C(FR_Y): case C(FG_Y):
return C(FR_Z); return C(FG_Z);
} }
keycode = tap_hold_extractor(keycode); keycode = tap_hold_extractor(keycode);

80
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap - Copie.c
View file

@ -23,12 +23,12 @@ bool is_caps_lock_on(void) { return host_keyboard_led_state().caps_lock; }
bool isLetter(uint16_t keycode) { bool isLetter(uint16_t keycode) {
switch (keycode) { switch (keycode) {
case KC_A ... KC_L: case KC_A ... KC_L:
case FR_M: case FG_M:
case KC_N ... KC_Z: case KC_N ... KC_Z:
case FR_AGRV: case FG_AGRV:
case FR_EACU: case FG_EACU:
case FR_EGRV: case FG_EGRV:
case FR_CCED: case FG_CCED:
return true; return true;
default: default:
@ -64,13 +64,13 @@ bool caps_word_press_user(uint16_t keycode) {
} else { } else {
switch (keycode) { switch (keycode) {
// Keycodes that continue Caps Word, without shifting. // Keycodes that continue Caps Word, without shifting.
case FR_MOIN: case FG_MOIN:
case KC_KP_1 ... KC_KP_0: case KC_KP_1 ... KC_KP_0:
case KC_LEFT: case KC_LEFT:
case KC_RIGHT: case KC_RIGHT:
case KC_BSPC: case KC_BSPC:
case KC_DEL: case KC_DEL:
case FR_APOS: case FG_APOS:
return true; return true;
default: default:
@ -87,24 +87,24 @@ uint16_t COMBO_LEN = 0;
// Custom altGr keys // Custom altGr keys
const custom_altgr_key_t custom_altgr_keys[] = { const custom_altgr_key_t custom_altgr_keys[] = {
{FR_AGRV, FR_AE}, {FG_AGRV, FG_AE},
{FR_B, FR_SS}, {FG_B, FG_SS},
{FR_A, FR_LDAQ}, {FG_A, FG_LDAQ},
{FR_I, FR_RDAQ}, {FG_I, FG_RDAQ},
{FR_T, FR_ESPR}, {FG_T, FG_ESPR},
{FR_S, FR_AROB}, {FG_S, FG_AROB},
{ALGR_T(FR_A), FR_LDAQ}, {ALGR_T(FG_A), FG_LDAQ},
{LCTL_T(FR_I), FR_RDAQ}, {LCTL_T(FG_I), FG_RDAQ},
{RCTL_T(FR_T), FR_ESPR}, {RCTL_T(FG_T), FG_ESPR},
{ALGR_T(FR_S), FR_AROB}, {ALGR_T(FG_S), FG_AROB},
{FR_X, FR_TM}, {FG_X, FG_TM},
{KC_KP_8, FR_INFN}, {KC_KP_8, FG_INFN},
{FR_H, FR_HASH}, {FG_H, FG_HASH},
{FR_V, FR_DEG}, {FG_V, FG_DEG},
{FR_CCED, FR_CEDL}, {FG_CCED, FG_CEDL},
{FR_Q, FR_SECT}, {FG_Q, FG_SECT},
{FR_POIN, FR_PVIR}, {FG_POIN, FG_PVIR},
{FR_C, FR_COPY}, {FG_C, FG_COPY},
}; };
uint8_t NUM_CUSTOM_ALTGR_KEYS = 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) { bool first_of_chorded_mods(uint16_t keycode) {
switch (keycode) { switch (keycode) {
case LT_TAB: // Pour pouvoir faire OSM shift + LT_TAB (win + shift + flèche). 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 FG_CCED: // Pour pouvoir faire Alt + F4, Alt + F11.
case LCTL_T(FR_I): case LCTL_T(FG_I):
case RCTL_T(FR_T): case RCTL_T(FG_T):
case OSM(MOD_LSFT): // Pour pouvoir faire OSM shift + LT_TAB (win + shift + flèche). case OSM(MOD_LSFT): // Pour pouvoir faire OSM shift + LT_TAB (win + shift + flèche).
return true; return true;
@ -234,10 +234,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_BASE] = LAYOUT( [_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_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(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, 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, 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, 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,FR_E), LT_VIRG, LT_APOS, LT(_SYMBOLS,KC_SPC), OSM(MOD_RSFT), KC_RGUI, KC_MUTE 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( [_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, KC_ESC, FG_EXLM, FG_QUES, FG_ESPR, FG_PVIR, FG_PIPE, FG_MOIN, KC_P7, KC_P8, KC_P9, FG_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, _______, 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,
_______, FR_LBKT, FR_RBKT, FR_INF, FR_SUP, FR_CARN, _______, _______, _______, _______, FR_ACIR, KC_P1, KC_P2, KC_P3, FR_PLUS, FR_PERC, _______, FG_LBKT, FG_RBKT, FG_INF, FG_SUP, FG_CARN, _______, _______, _______, _______, FG_ACIR, KC_P1, KC_P2, KC_P3, FG_PLUS, FG_PERC,
_______, _______, _______, KC_SPC, FR_VIRG, NUMWORD, KC_P0, KC_PDOT, _______ , _______ _______, _______, _______, KC_SPC, FG_VIRG, NUMWORD, KC_P0, KC_PDOT, _______ , _______
), ),
/* /*
* Layer 2 : Symbols + function keys * Layer 2 : Symbols + function keys
@ -276,9 +276,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_SHORTNAV] = LAYOUT( [_SHORTNAV] = LAYOUT(
KC_ESC, A(KC_F4), ALT_TAB, LWIN(FR_V), _______, _______, _______, C(KC_LEFT), KC_UP, C(KC_RIGHT), _______, _______, KC_ESC, A(KC_F4), ALT_TAB, LWIN(FG_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, _______, 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(FR_Z), C(FR_Y), _______, _______, _______, _______, 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, _______, _______, _______ _______, _______, _______, QUES_PT, QUES_PT, EXCL_PT, EXCL_PT, _______, _______, _______
), ),
@ -299,7 +299,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_FUNCAPPS] = LAYOUT( [_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, 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), _______, _______, _______, 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), _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),

126
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.c
View file

@ -14,7 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "keymap.h" #include "keymap.h"
@ -97,15 +97,17 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// Custom tap-hold keys // Custom tap-hold keys
if (!process_custom_tap_hold(keycode, record)) { return false; } if (!process_custom_tap_hold(keycode, record)) { return false; }
if (!process_typo(keycode, record)) { return false; }
if (IS_LAYER_ON(_TYPO) && record->event.pressed) { if (IS_LAYER_ON(_TYPO) && record->event.pressed) {
switch (keycode) { switch (keycode) {
case FR_AROB: case FG_AROB:
case FR_K: case FG_K:
case FR_J: case FG_J:
case CA_CED:
case AGRV_SPC:
case OU_GRV: case OU_GRV:
case FG_CCED:
case AGRV_SPC:
break; break;
default: default:
@ -115,17 +117,17 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
del_oneshot_mods(MOD_MASK_SHIFT); del_oneshot_mods(MOD_MASK_SHIFT);
unregister_mods(MOD_MASK_SHIFT); unregister_mods(MOD_MASK_SHIFT);
} }
tap_code(FR_TYPO); tap_code(FG_TYPO);
//set_mods(mods); //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 // Macros
if (!process_macros(keycode, record)) { return false; } if (!process_macros(keycode, record)) { return false; }
// Custom alt gr
//if (!process_custom_altgr_keys(keycode, record)) { return false; }
// Clever keys // Clever keys
if (!process_clever_keys(keycode, record)) { return false; } 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) { void post_process_record_user(uint16_t keycode, keyrecord_t* record) {
// //
if (os4a_layer != 0 && exit_os4a_layer) { if (os4a_layer != 0 && exit_os4a_layer) { os4a_layer_off(os4a_layer); }
os4a_layer_off(os4a_layer); if (exit_num_word) { disable_num_word(); }
} //if (exit_typo && keycode != FG_TYPO) { typo_layer_off(); }
if (exit_num_word) {
disable_num_word();
}
} }
@ -163,12 +162,32 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_BASE] = LAYOUT( [_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, FG_X, FG_VIRG, FG_EACU, FG_P, FG_B, FG_F, FG_M, FG_L, FG_APOS, FG_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, FG_O, FG_A, FG_I, FG_T, FG_G, FG_V, FG_S, FG_N, FG_R, FG_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_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 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 * Layer 1 : Mods gauche
* *
@ -205,32 +224,13 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_R_MODS] = LAYOUT( [_R_MODS] = LAYOUT(
_______, _______, _______, _______, _______, _______, KC_NO, KC_RGUI, OS_WIN, KC_NO, KC_NO, KC_NO, _______, _______, _______, _______, _______, _______, KC_NO, KC_RGUI, OS_WIN, TG_APOD, KC_NO, KC_NO,
_______, _______, _______, _______, _______, _______, TT_FA, OS_SHFT, OS_CTRL, NUMWORD, FR_TYPO, 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, KC_NO, KC_NO, KC_NO, OS_FA, OS_LALT, KC_NO,
_______, _______, _______, _______, _______, _______, _______, _______, KC_NO, 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 * Layer 1 : Numpad
@ -247,32 +247,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_NUMBERS] = LAYOUT( [_NUMBERS] = LAYOUT(
_______, _______, FR_ASTX, FR_EGAL, _______, S(FR_ACIR), KC_6, _______, FR_PLUS, FR_MOIN, _______, _______, _______, _______, FG_ASTX, FG_EGAL, _______, FG_PERC, KC_6, _______, FG_PLUS, FG_MOIN, _______, _______,
_______, KC_8, KC_6, KC_4, KC_2, FR_CARN, _______, KC_1, KC_3, KC_5, KC_7, _______, _______, KC_6, KC_4, KC_2, FG_SLSH, FG_CARN, S(FG_ACIR), KC_1, KC_3, KC_5, KC_7, _______,
_______, _______, _______, _______, FR_SLSH, _______, _______, _______, _______, _______, _______, KC_9, _______, _______, _______, _______, _______, _______, _______, _______, KC_8, _______, _______, _______, _______, _______, _______, KC_9, _______, _______, _______, _______,
_______, _______, FR_VIRG, KC_0 , NUMWORD, LT_REPT, KC_SPC, KC_PDOT, _______, _______ _______, _______, 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 * Layer 2 : Symbols
@ -289,10 +269,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_TYPO] = LAYOUT( [_TYPO] = LAYOUT(
_______, _______, _______, _______, _______, FR_J, FR_K, FR_F, FR_D, _______, _______, _______, _______, _______, _______, _______, _______, FG_D, _______, S(FG_M), S(FG_L), _______, _______, _______,
_______, OU_GRV, _______, _______, _______, _______, FR_M, FR_J, FR_L, FR_AROB, _______, _______, _______, OU_GRV, _______, _______, FG_B, _______, _______, FG_J, FG_T, FG_AROB, _______, _______,
_______, _______, _______, _______, CA_CED, _______, _______, _______, _______, _______, _______, _______, _______, FR_K, TG_TYPO, _______, _______, _______, _______, _______, FG_DQUO, _______, _______, _______, _______, _______, _______, FG_CCED, _______, FG_K, TG_TYPO, _______,
_______, _______, _______, _______, FR_O, _______, AGRV_SPC, _______, _______, _______ _______, _______, _______, _______, FG_O, _______, AGRV_SPC, _______, _______, _______
), ),
@ -311,9 +291,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* `----------------------------------' `----------------------------------' * `----------------------------------' `----------------------------------'
*/ */
[_SHORTNAV] = LAYOUT( [_SHORTNAV] = LAYOUT(
_______, KC_BSPC, LWIN(KC_TAB), LWIN(FR_V), RCS(FR_V), _______, KC_PGUP, C(KC_LEFT), KC_UP, C(KC_RGHT), _______, _______, _______, KC_BSPC, LWIN(KC_TAB), LWIN(FG_V), RCS(FG_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 , _______, _______, 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(FR_Z), C(FR_Y), _______, _______, _______, _______, _______, KC_VOLD, KC_VOLU, KC_MUTE, _______, _______, _______, KC_SPC, KC_SPC, KC_SPC, C(FG_Z), C(FG_Y), _______, _______, _______, _______, _______, KC_VOLD, KC_VOLU, KC_MUTE, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),

21
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap.h
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#pragma once #pragma once
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
@ -21,17 +21,18 @@
#include "keymap_french_frgo.h" #include "keymap_french_frgo.h"
#include "features_conf.h" #include "features_conf.h"
#include "clever_keys.h" #include "clever_keys.h"
#include "features/custom_altgr_keys.h"
#include "features/tap_hold_utilities.h" #include "features/tap_hold_utilities.h"
#include "features/clever_keys_utilities.h" #include "features/clever_keys_utilities.h"
#include "features/numword.h" #include "features/numword.h"
#include "features/macros.h" #include "features/macros.h"
#include "features/os4a.h" #include "features/os4a.h"
#include "features/oneshot.h" #include "features/oneshot.h"
#include "features/typo_layer.h"
enum layers { enum layers {
_BASE = 0, _BASE = 0,
_APOS_DR,
// OS4A layers should be as closed as base layer as possible // OS4A layers should be as closed as base layer as possible
_L_MODS, _L_MODS,
_R_MODS, _R_MODS,
@ -51,33 +52,35 @@ enum custom_keycodes {
CAPSWORD, CAPSWORD,
AGRV_SPC, AGRV_SPC,
OU_GRV, OU_GRV,
E_CIRC, E_CIRC,
I_CIRC, /* I_CIRC,
A_CIRC, A_CIRC,
O_CIRC, O_CIRC,
U_CIRC, U_CIRC,
I_TREM, I_TREM, */
CA_CED, CA_CED,
CIRC, /* CIRC,
TILDE, TILDE,
GRAVE, GRAVE, */
MAGIC, MAGIC,
OS_SHFT, OS_SHFT,
OS_CTRL, OS_CTRL,
OS_RALT, OS_RALT,
OS_LALT, OS_LALT,
OS_WIN OS_WIN,
//OS_TYPO
}; };
// Layer taps // Layer taps
#define LT_SPC ALGR_T(KC_SPC) #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_REPT LT(_NUMBERS, KC_0)
#define LT_MGC LT(_SHORTNAV, KC_0) #define LT_MGC LT(_SHORTNAV, KC_0)
#define OS_TYPO OSL(_TYPO) #define OS_TYPO OSL(_TYPO)
#define OS_FA OSL(_FUNCAPPS) #define OS_FA OSL(_FUNCAPPS)
#define TT_FA TT(_FUNCAPPS) #define TT_FA TT(_FUNCAPPS)
#define TG_TYPO TG(_TYPO) #define TG_TYPO TG(_TYPO)
#define TG_APOD TG(_APOS_DR)
// One shot mods // One shot mods
#define L_OS4A LSFT_T(OS4A) #define L_OS4A LSFT_T(OS4A)

222
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/keymap_french_frgo.h
View file

@ -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 │ ' │ . │ = │ + │     │ * │     │ 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 │ **│          │ * │    │ E │ Q │ Z │ Y │ D │ J │ K │ C │ H │ W │ **│          │
* ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤
@ -37,60 +37,60 @@
*/ */
// Row 1 // Row 1
#define FR_AGRV KC_GRV // à #define FG_CCED KC_GRV // ç
#define FR_1 KC_1 // 1 #define FG_1 KC_1 // 1
#define FR_2 KC_2 // 2 #define FG_2 KC_2 // 2
#define FR_3 KC_3 // 3 #define FG_3 KC_3 // 3
#define FR_4 KC_4 // 4 #define FG_4 KC_4 // 4
#define FR_5 KC_5 // 5 #define FG_5 KC_5 // 5
#define FR_6 KC_6 // 6 #define FG_6 KC_6 // 6
#define FR_7 KC_7 // 7 #define FG_7 KC_7 // 7
#define FR_8 KC_8 // 8 #define FG_8 KC_8 // 8
#define FR_9 KC_9 // 9 #define FG_9 KC_9 // 9
#define FR_0 KC_0 // 0 #define FG_0 KC_0 // 0
#define FR_SLSH KC_MINS // / #define FG_SLSH KC_MINS // /
#define FR_ASTX KC_EQL // * #define FG_ASTX KC_EQL // *
// Row 2 // Row 2
#define FR_X KC_Q // X #define FG_X KC_Q // X
#define FR_VIRG KC_W // , #define FG_VIRG KC_W // ,
#define FR_EACU KC_E // É #define FG_EACU KC_E // É
#define FR_P KC_R // P #define FG_P KC_R // P
#define FR_B KC_T // B #define FG_B KC_T // B
#define FR_F KC_Y // F #define FG_F KC_Y // F
#define FR_M KC_U // M #define FG_M KC_U // M
#define FR_L KC_I // L #define FG_L KC_I // L
#define FR_APOS KC_O // ' #define FG_APOS KC_O // ’
#define FR_POIN KC_P // . #define FG_POIN KC_P // .
#define FR_EGAL KC_LBRC // = #define FG_EGAL KC_LBRC // =
#define FR_PLUS KC_RBRC // + #define FG_PLUS KC_RBRC // +
// Row 3 // Row 3
#define FR_O KC_A // O #define FG_O KC_A // O
#define FR_A KC_S // A #define FG_A KC_S // A
#define FR_I KC_D // I #define FG_I KC_D // I
#define FR_T KC_F // T #define FG_T KC_F // T
#define FR_G KC_G // G #define FG_G KC_G // G
#define FR_V KC_H // V #define FG_V KC_H // V
#define FR_S KC_J // S #define FG_S KC_J // S
#define FR_N KC_K // N #define FG_N KC_K // N
#define FR_R KC_L // R #define FG_R KC_L // R
#define FR_U KC_SCLN // U #define FG_U KC_SCLN // U
#define FR_UGRV KC_QUOT // Ù #define FG_MOIN KC_QUOT // -
#define FR_CCED KC_NUHS // Ç #define FG_APOD KC_NUHS // '
// Row 4 // Row 4
#define FR_E KC_NUBS // E #define FG_E KC_NUBS // E
#define FR_Q KC_Z // Q #define FG_Q KC_Z // Q
#define FR_Z KC_X // Z #define FG_Z KC_X // Z
#define FR_Y KC_C // Y #define FG_Y KC_C // Y
#define FR_D KC_V // D #define FG_D KC_V // D
#define FR_J KC_B // J #define FG_J KC_B // J
#define FR_K KC_N // K #define FG_K KC_N // K
#define FR_C KC_M // C #define FG_C KC_M // C
#define FR_H KC_COMM // H #define FG_H KC_COMM // H
#define FR_W KC_DOT // W #define FG_W KC_DOT // W
#define FR_TYPO KC_SLSH // ** #define FG_TYPO KC_SLSH // **
/* Shifted symbols /* Shifted symbols
@ -99,21 +99,24 @@
* ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤
* │     │   │ ! │   │   │   │   │   │   │ ? │ : │ ≠ │   │     │ * │     │   │ ! │   │   │   │   │   │   │ ? │ : │ ≠ │   │     │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │ * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │
* │      │   │   │   │   │   │   │   │   │   │   │   │   │    │ * │      │   │   │   │   │   │   │   │   │   │   │   │ ? │    │
* ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤
* │    │   │   │   │   │   │   │   │   │   │   │   │          │ * │    │   │   │   │   │   │   │   │   │   │   │ ; │          │
* ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤
* │    │    │    │                        │    │    │    │    │ * │    │    │    │                        │    │    │    │    │
* └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘
*/ */
// Row 2 // Row 2
#define FR_EXLM S(FR_VIRG) // ! #define FG_EXLM S(FG_VIRG) // !
#define FR_QUES S(FR_APOS) // ? #define FG_QUES S(FG_APOS) // ?
#define FR_2PTS S(FR_POIN) // : #define FG_2PTS S(FG_POIN) // :
#define FR_DIFF S(FR_EGAL) // ≠ #define FG_DIFF S(FG_EGAL) // ≠
// Row 4
//#define FG_PVIR S(FG_TYPO)
// Row 5 // Row 5
#define FR_NBSP S(KC_SPC) // Espace insecable #define FG_NBSP S(KC_SPC) // Espace insecable
@ -121,50 +124,51 @@
* ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐
* │   │ ₁ │ ₂ │ ₃ │ ₄ │ ₅ │ ₆ │ ₇ │ ₈ │ ₉ │ ₀ │   │   │       │ * │   │ ₁ │ ₂ │ ₃ │ ₄ │ ₅ │ ₆ │ ₇ │ ₈ │ ₉ │ ₀ │   │   │       │
* ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤
* │     │ ^ │ ! │ = │ $ │ @ │ # │ < │ > │ ? │ : │   │   │     │ * │     │ ^ │ ! │ = │ $ │ % │ # │ ; │ ' │ ? │ : │   │   │     │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │ * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │
* │      │ * │ + │ - │ / │ \ │ ` │ ( │ ) │ ; │ " │   │   │    │ * │      │ * │ + │ - │ / │ \ │ ` │ ( │ ) │ < │ > │   │   │    │
* ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤
* │    │ _ │ % │ ~ │ | │ & │   │   │ { │ } │ [ │ ] │          │ * │    │ _ │ ~ │ | │ & │ " │ @ │   │ { │ } │ [ │ ] │          │
* ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤
* │    │    │    │                        │    │    │    │    │ * │    │    │    │                        │    │    │    │    │
* └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘
*/ */
// Row 2 // Row 2
#define FR_ACIR ALGR(FR_X) // ^ #define FG_ACIR ALGR(FG_X) // ^
//#define FR_EXLM ALGR(FR_VIRG) // ! //#define FG_EXLM ALGR(FG_VIRG) // !
//#define FR_EGAL ALGR(FR_EACU) // = //#define FG_EGAL ALGR(FG_EACU) // =
#define FR_DLR ALGR(FR_P) // $ #define FG_DLR ALGR(FG_P) // $
#define FR_AROB ALGR(FR_B) // @ #define FG_PERC ALGR(FG_B) // %
#define FR_HASH ALGR(FR_F) // # #define FG_HASH ALGR(FG_F) // #
#define FR_INF ALGR(FR_M) // < #define FG_PVIR ALGR(FG_M) // ;
#define FR_SUP ALGR(FR_L) // > //#define FG_QUES ALGR(FG_APOS) // ?
//#define FR_QUES ALGR(FR_APOS) // ? //#define FG_2PTS ALGR(FG_POIN) // :
//#define FR_2PTS ALGR(FR_POIN) // :
// Row 3 // Row 3
/* #define FR_ASTX ALGR(FR_O) // * /* #define FG_ASTX ALGR(FG_O) // *
#define FR_PLUS ALGR(FR_A) // + #define FG_PLUS ALGR(FG_A) // +
#define FR_SLSH ALGR(FR_T) // / */ #define FG_SLSH ALGR(FG_T) // /
#define FR_MOIN ALGR(FR_I) // - #define FG_MOIN ALGR(FG_I) // - */
#define FR_BSLS ALGR(FR_G) // '\' #define FG_BSLS ALGR(FG_G) // '\'
#define FR_GRV ALGR(FR_V) // ` #define FG_GRV ALGR(FG_V) // `
#define FR_LPRN ALGR(FR_S) // ( #define FG_LPRN ALGR(FG_S) // (
#define FR_RPRN ALGR(FR_N) // ) #define FG_RPRN ALGR(FG_N) // )
#define FR_PVIR ALGR(FR_R) // ; #define FG_INF ALGR(FG_R) // <
#define FR_DQUO ALGR(FR_U) // " #define FG_SUP ALGR(FG_U) // >
//#define FG_DQUO ALGR(FG_U) // "
#define FG_AROB ALGR(FG_J)
// Row 4 // Row 4
#define FR_UNDS ALGR(FR_E) // _ #define FG_UNDS ALGR(FG_E) // _
#define FR_PERC ALGR(FR_Q) // % #define FG_TILD ALGR(FG_Q) // ~
#define FR_TILD ALGR(FR_Z) // ~ #define FG_PIPE ALGR(FG_Z) // |
#define FR_PIPE ALGR(FR_Y) // | #define FG_ESPR ALGR(FG_Y) // &
#define FR_ESPR ALGR(FR_D) // & #define FG_DQUO ALGR(FG_D) // "
#define FR_LCBR ALGR(FR_C) // { #define FG_LCBR ALGR(FG_C) // {
#define FR_RCBR ALGR(FR_H) // } #define FG_RCBR ALGR(FG_H) // }
#define FR_LSBR ALGR(FR_W) // [ #define FG_LSBR ALGR(FG_W) // [
#define FR_RSBR ALGR(FR_TYPO) // ] #define FG_RSBR ALGR(FG_TYPO) // ]
/* Shift+AltGr symbols /* 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 /* // Row 1
#define FR_IBRV S(ALGR(FR_AROB)) //  ̑ (dead) #define FG_IBRV S(ALGR(FG_AROB)) //  ̑ (dead)
#define FR_DACU S(ALGR(FR_LPRN)) // ˝ (dead) #define FG_DACU S(ALGR(FG_LPRN)) // ˝ (dead)
#define FR_DGRV S(ALGR(FR_RPRN)) //  ̏ (dead) #define FG_DGRV S(ALGR(FG_RPRN)) //  ̏ (dead)
#define FR_MDSH S(ALGR(FR_RSQU)) // — #define FG_MDSH S(ALGR(FG_RSQU)) // —
#define FR_LSAQ S(ALGR(FR_LDAQ)) // ‹ #define FG_LSAQ S(ALGR(FG_LDAQ)) // ‹
#define FR_RSAQ S(ALGR(FR_RDAQ)) // › #define FG_RSAQ S(ALGR(FG_RDAQ)) // ›
#define FR_IQUE S(ALGR(FR_APOS)) // ¿ #define FG_IQUE S(ALGR(FG_APOS)) // ¿
// Row 2 // Row 2
#define FR_TM S(ALGR(FR_T)) // ™ #define FG_TM S(ALGR(FG_T)) // ™
#define FR_DOTB S(ALGR(FR_I)) //  ̣ (dead) #define FG_DOTB S(ALGR(FG_I)) //  ̣ (dead)
#define FR_PERM S(ALGR(FR_P)) // ‰ #define FG_PERM S(ALGR(FG_P)) // ‰
#define FR_NBHY S(ALGR(FR_MOIN)) // ‑ (non-breaking hyphen) #define FG_NBHY S(ALGR(FG_MOIN)) // ‑ (non-breaking hyphen)
#define FR_DDAG S(ALGR(FR_PLUS)) // ‡ #define FG_DDAG S(ALGR(FG_PLUS)) // ‡
// Row 3 // Row 3
#define FR_MACB S(ALGR(FR_H)) // ˍ (dead) #define FG_MACB S(ALGR(FG_H)) // ˍ (dead)
#define FR_SQRT S(ALGR(FR_SLSH)) // √ #define FG_SQRT S(ALGR(FG_SLSH)) // √
#define FR_QRTR S(ALGR(FR_ASTX)) // ¼ #define FG_QRTR S(ALGR(FG_ASTX)) // ¼
// Row 4 // Row 4
#define FR_GEQL S(ALGR(FR_INF)) // ≥ #define FG_GEQL S(ALGR(FG_INF)) // ≥
#define FR_OGON S(ALGR(FR_V)) // ˛ (dead) #define FG_OGON S(ALGR(FG_V)) // ˛ (dead)
#define FR_IEXL S(ALGR(FR_VIRG)) //  ̦ (dead) #define FG_IEXL S(ALGR(FG_VIRG)) //  ̦ (dead)
//#define FR_NEQL S(ALGR(FR_EGAL)) // ≠ */ //#define FG_NEQL S(ALGR(FG_EGAL)) // ≠ */

1
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/rules.mk
View file

@ -34,6 +34,7 @@ SRC += features/numword.c
SRC += features/macros.c SRC += features/macros.c
SRC += features/oneshot.c SRC += features/oneshot.c
SRC += features_conf.c SRC += features_conf.c
SRC += features/typo_layer.c
INTROSPECTION_KEYMAP_C = features/combos.c INTROSPECTION_KEYMAP_C = features/combos.c