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) {
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

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) {
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);

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) {
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.

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

@ -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;
}

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:
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:

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
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;
}

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;
}
/* 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 ?

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 {
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);

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_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);

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) {
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), _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______
),

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/>.
*/
#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, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______
),

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

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 │ ' │ . │ = │ + │     │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐    │
* │      │ 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)) // ≠ */

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/oneshot.c
SRC += features_conf.c
SRC += features/typo_layer.c
INTROSPECTION_KEYMAP_C = features/combos.c