mirrors/qmk_userspace
1
0
Fork 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2025-11-08 04:29:58 -05:00
Code Issues Projects Releases Packages Wiki Activity

C’est bon !

Browse source
This commit is contained in:
Kawamashi 2025-04-08 19:22:12 +02:00
commit de82c3d321
4 changed files with 57 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -19,11 +19,11 @@
#include "clever_keys.h" #include "clever_keys.h"
bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) { void get_clever_keycode(uint16_t* next_keycode, keyrecord_t* record) {
uint16_t prev_keycode = recent[RECENT_SIZE - 1]; uint16_t prev_keycode = recent[RECENT_SIZE - 1];
/* if (isLetter(next_keycode) || isSendStringMacro(next_keycode)) { if (isLetter(*next_keycode) || isSendStringMacro(*next_keycode)) {
switch (prev_keycode) { switch (prev_keycode) {
case FG_EXLM: case FG_EXLM:
case FG_QUES: case FG_QUES:
@ -31,7 +31,7 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
case FG_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);
set_last_keycode(next_keycode); set_last_keycode(*next_keycode);
case KC_SPC: case KC_SPC:
switch (recent[RECENT_SIZE - 2]) { switch (recent[RECENT_SIZE - 2]) {
@ -50,7 +50,7 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
switch (prev_keycode) { switch (prev_keycode) {
case FG_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 FG_E: case FG_E:
@ -60,54 +60,57 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
case FG_EACU: case FG_EACU:
case FG_APOS: case FG_APOS:
invoke_key(FG_U, record); invoke_key(FG_U, record);
set_last_keycode(*next_keycode);
break; break;
// Raccourci pour "quelq" // Raccourci pour "quelq"
case FG_Q: case FG_Q:
clear_recent_keys(); // To prevent infinite loop
process_word((uint16_t[]) {FG_U, FG_E, FG_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 FG_Z: case FG_Z:
return finish_word((uint16_t[]) {FG_U, FG_O, FG_I}, 3, record); finish_word((uint16_t[]) {FG_U, FG_O, FG_I}, 3, next_keycode, record);
break;
// Raccourci pour "quand" // Raccourci pour "quand"
case FG_D: case FG_D:
process_word((uint16_t[]) {FG_U, FG_A, FG_N}, 3, record); process_word((uint16_t[]) {FG_U, FG_A, FG_N}, 3, record);
set_last_keycode(*next_keycode);
break; break;
} }
break; break;
case FG_P: case FG_P:
switch (next_keycode) { switch (*next_keycode) {
case FG_M: case FG_M:
// "pas" // "pas"
return finish_word((uint16_t[]) {FG_A, FG_S}, 2, record); return finish_word((uint16_t[]) {FG_A, FG_S}, 2, next_keycode, record);
case FG_APOS: case FG_APOS:
// "par" // "par"
return finish_word((uint16_t[]) {FG_A, FG_R}, 2, record); return finish_word((uint16_t[]) {FG_A, FG_R}, 2, next_keycode, record);
case FG_POIN: case FG_POIN:
if (!isLetter(recent[RECENT_SIZE - 2])) { if (!isLetter(recent[RECENT_SIZE - 2])) {
// "pour" // "pour"
return finish_word((uint16_t[]) {FG_O, FG_U, FG_R}, 3, record); return finish_word((uint16_t[]) {FG_O, FG_U, FG_R}, 3, next_keycode, record);
} }
break; break;
} }
break; break;
case FG_CCED: case FG_CCED:
if (!isLetter(next_keycode)) { if (!isLetter(*next_keycode)) {
invoke_key(FG_A, record); invoke_key(FG_A, record);
set_last_keycode(*next_keycode);
} }
break; break;
} }
switch (next_keycode) { switch (*next_keycode) {
case FG_QUES: case FG_QUES:
case FG_EXLM: case FG_EXLM:
@ -115,7 +118,7 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
// 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])) {
invoke_key(KC_SPC, record); invoke_key(KC_SPC, record);
return replace_next_key(next_keycode, record); return replace_next_key(*next_keycode, next_keycode, record);
} }
break; break;
@ -125,49 +128,49 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
case FG_T: case FG_T:
invoke_key(FG_I, record); invoke_key(FG_I, record);
case FG_I: case FG_I:
return finish_magic((uint16_t[]) {FG_O, FG_N}, 2, record); return finish_word((uint16_t[]) {FG_O, FG_N}, 2, next_keycode, record);
case FG_C: case FG_C:
return finish_magic((uint16_t[]) {FG_APOS, FG_E, FG_S, FG_T}, 4, record); return finish_word((uint16_t[]) {FG_APOS, FG_E, FG_S, FG_T}, 4, next_keycode, record);
case FG_D: case FG_D:
return finish_magic((uint16_t[]) {FG_A, FG_N, FG_S}, 3, record); return finish_word((uint16_t[]) {FG_A, FG_N, FG_S}, 3, next_keycode, record);
case FG_P: case FG_P:
return finish_magic((uint16_t[]) {FG_L, FG_U, FG_S}, 3, record); return finish_word((uint16_t[]) {FG_L, FG_U, FG_S}, 3, next_keycode, record);
case FG_O: case FG_O:
return finish_magic((uint16_t[]) {FG_N, FG_T}, 2, record); return finish_word((uint16_t[]) {FG_N, FG_T}, 2, next_keycode, record);
case FG_A: case FG_A:
if (isLetter(recent[RECENT_SIZE - 2])) { if (isLetter(recent[RECENT_SIZE - 2])) {
// "ant" // "ant"
return finish_magic((uint16_t[]) {FG_N, FG_T}, 2, record); return finish_word((uint16_t[]) {FG_N, FG_T}, 2, next_keycode, record);
} else { } else {
// "avec" // "avec"
return finish_magic((uint16_t[]) {FG_V, FG_E, FG_C}, 3, record); return finish_word((uint16_t[]) {FG_V, FG_E, FG_C}, 3, next_keycode, record);
} }
case FG_S: case FG_S:
return finish_magic((uint16_t[]) {FG_U, FG_R}, 2, record); return finish_word((uint16_t[]) {FG_U, FG_R}, 2, next_keycode, record);
case FG_B: case FG_B:
process_word((uint16_t[]) {FG_O, FG_N, FG_J}, 3, record); process_word((uint16_t[]) {FG_O, FG_N, FG_J}, 3, record);
case FG_J: case FG_J:
return finish_magic((uint16_t[]) {FG_O, FG_U, FG_R}, 3, record); return finish_word((uint16_t[]) {FG_O, FG_U, FG_R}, 3, next_keycode, record);
case FG_M: case FG_M:
if (isLetter(recent[RECENT_SIZE - 2])) { if (isLetter(recent[RECENT_SIZE - 2])) {
// "ment" // "ment"
return finish_magic((uint16_t[]) {FG_E, FG_N, FG_T}, 3, record); return finish_word((uint16_t[]) {FG_E, FG_N, FG_T}, 3, next_keycode, record);
} else { } else {
// "même" // "même"
return finish_magic((uint16_t[]) {FG_ODK, FG_O, FG_M, FG_E}, 4, record); return finish_word((uint16_t[]) {FG_ODK, FG_O, FG_M, FG_E}, 4, next_keycode, record);
} }
default: default:
return false; return;
} }
case FG_AROB: case FG_AROB:
@ -177,32 +180,32 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
case FG_T: case FG_T:
// "t@" -> "toujours" // "t@" -> "toujours"
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_O, FG_U, FG_J, FG_O, FG_U, FG_R, FG_S}, 7, record); return finish_word((uint16_t[]) {FG_O, FG_U, FG_J, FG_O, FG_U, FG_R, FG_S}, 7, next_keycode, record);
case FG_P: case FG_P:
// "p@" -> "peut-être" // "p@" -> "peut-être"
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_E, FG_U, FG_T, FG_MOIN, FG_ODK, FG_O, FG_T, FG_R, FG_E}, 9, record); return finish_word((uint16_t[]) {FG_E, FG_U, FG_T, FG_MOIN, FG_ODK, FG_O, FG_T, FG_R, FG_E}, 9, next_keycode, record);
case FG_A: case FG_A:
// "a@" -> "aujourd'hui" // "a@" -> "aujourd'hui"
layer_off(_ODK); layer_off(_ODK);
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); 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, next_keycode, record);
case FG_B: case FG_B:
// "b@" -> "beaucoup" // "b@" -> "beaucoup"
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_E, FG_A, FG_U, FG_C, FG_O, FG_U, FG_P}, 7, record); return finish_word((uint16_t[]) {FG_E, FG_A, FG_U, FG_C, FG_O, FG_U, FG_P}, 7, next_keycode, record);
case FG_E: case FG_E:
// "e@" -> "est-ce qu" // "e@" -> "est-ce qu"
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_S, FG_T, FG_MOIN, FG_C, FG_E, KC_SPC, FG_Q}, 7, record); return finish_word((uint16_t[]) {FG_S, FG_T, FG_MOIN, FG_C, FG_E, KC_SPC, FG_Q}, 7, next_keycode, record);
case FG_D: case FG_D:
// "d@" -> "déjà" // "d@" -> "déjà"
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_EACU, FG_J, FG_ODK, FG_A}, 4, record); return finish_word((uint16_t[]) {FG_EACU, FG_J, FG_ODK, FG_A}, 4, next_keycode, record);
} }
} }
break; break;
@ -211,6 +214,8 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
if (prev_keycode == FG_J) { if (prev_keycode == FG_J) {
// "jq" -> "jusqu" // "jq" -> "jusqu"
process_word((uint16_t[]) {FG_U, FG_S}, 2, record); process_word((uint16_t[]) {FG_U, FG_S}, 2, record);
set_last_keycode(*next_keycode);
return;
} }
break; break;
@ -218,8 +223,7 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
//if (prev_keycode == FG_O && !isCaps) { //if (prev_keycode == FG_O && !isCaps) {
if (prev_keycode == FG_O) { if (prev_keycode == FG_O) {
// "oa" -> "oi" // "oa" -> "oi"
clear_recent_keys(); // To prevent infinite loop return replace_next_key(FG_I, next_keycode, record);
return replace_next_key(FG_I, record);
} }
break; break;
@ -227,34 +231,25 @@ bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record) {
//if (prev_keycode == FG_O && !isCaps && recent[RECENT_SIZE - 3] != FG_Q) { //if (prev_keycode == FG_O && !isCaps && recent[RECENT_SIZE - 3] != FG_Q) {
if (prev_keycode == FG_O && recent[RECENT_SIZE - 3] != FG_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 return replace_next_key(FG_A, next_keycode, record);
return replace_next_key(FG_A, record);
} }
break; break;
case FG_O: case FG_O:
if (prev_keycode == FG_U && recent[RECENT_SIZE - 2] != FG_Q) { if (prev_keycode == FG_U && recent[RECENT_SIZE - 2] != FG_Q) {
// "uo" -> "un" // "uo" -> "un"
return replace_next_key(FG_N, record); return replace_next_key(FG_N, next_keycode, record);
} }
break; break;
case OU_GRV: case OU_GRV:
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_O, FG_ODK, FG_T}, 3, record); return finish_word((uint16_t[]) {FG_O, FG_ODK, FG_T}, 3, next_keycode, record);
case AGRV_SPC: case AGRV_SPC:
layer_off(_ODK); layer_off(_ODK);
return finish_word((uint16_t[]) {FG_AGR, KC_SPC}, 2, record); return finish_word((uint16_t[]) {FG_AGR, KC_SPC}, 2, next_keycode, record);
} */
switch (next_keycode) {
case FG_O:
if (prev_keycode == FG_U && recent[RECENT_SIZE - 2] != FG_Q) {
// "uo" -> "un"
return replace_next_key(FG_N, record);
}
break;
} }
return false; // Process next keycode normally //return KC_NO; // Process next keycode normally
} }

2
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/clever_keys.h
View file

@ -25,7 +25,7 @@
extern "C" { extern "C" {
#endif #endif
bool clever_key_finder(uint16_t next_keycode, keyrecord_t* record); void get_clever_keycode(uint16_t* next_keycode, keyrecord_t* record);
#ifdef __cplusplus #ifdef __cplusplus

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

@ -18,6 +18,7 @@
uint16_t recent[RECENT_SIZE] = {KC_NO}; uint16_t recent[RECENT_SIZE] = {KC_NO};
uint16_t deadline = 0; uint16_t deadline = 0;
//static unsigned short int bkspc_countdown = RECENT_SIZE + 1;
unsigned short int bkspc_countdown = RECENT_SIZE + 1; unsigned short int bkspc_countdown = RECENT_SIZE + 1;
// Copy of the record argument for the clever key. // Copy of the record argument for the clever key.
@ -37,7 +38,6 @@ void recent_keys_task(void) {
// Handles one event. Returns false if the key was appended to `recent`. // Handles one event. Returns false if the key was appended to `recent`.
uint16_t get_next_keycode(uint16_t keycode, keyrecord_t* record) { uint16_t get_next_keycode(uint16_t keycode, keyrecord_t* record) {
//if (!record->event.pressed) { return KC_NO; }
uint8_t mods = get_mods() | get_oneshot_mods(); uint8_t mods = get_mods() | get_oneshot_mods();
@ -151,33 +151,25 @@ void invoke_key(uint16_t keycode, keyrecord_t* record) {
bkspc_countdown = 1; bkspc_countdown = 1;
} }
bool replace_next_key(uint16_t new_keycode, keyrecord_t* record) { void replace_next_key(uint16_t clever_keycode, uint16_t* next_keycode, keyrecord_t* record) {
//store_keycode(new_keycode, record); //store_keycode(new_keycode, record);
record->keycode = new_keycode; record->keycode = clever_keycode;
return true; *next_keycode = clever_keycode;
set_last_keycode(clever_keycode);
//set_last_keycode(*next_keycode);
processingCK = true;
} }
/* bool replace_next_key(uint16_t keycode, keyrecord_t* record) {
invoke_key(keycode, record);
return true;
} */
void process_word(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record) { void process_word(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record) {
for (int i = 0; i < num_keycodes; ++i) { for (int i = 0; i < num_keycodes; ++i) {
invoke_key(keycodes[i], record); process_key(keycodes[i], record);
} }
bkspc_countdown = num_keycodes; bkspc_countdown = num_keycodes;
} }
bool finish_word(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record) { void finish_word(uint16_t keycodes[], uint8_t num_keycodes, uint16_t* next_keycode, keyrecord_t* record) {
process_word(keycodes, num_keycodes, record); process_word(keycodes, num_keycodes - 1, record);
return true; replace_next_key(keycodes[num_keycodes - 1], next_keycode, record);
}
bool finish_magic(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record) {
// Set the keycode to be repeated to match the key buffer.
set_last_keycode(keycodes[num_keycodes - 1]);
return finish_word(keycodes, num_keycodes, record);
} }
@ -188,10 +180,7 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) {
uint16_t next_keycode = get_next_keycode(keycode, record); uint16_t next_keycode = get_next_keycode(keycode, record);
if (next_keycode != KC_NO) { if (next_keycode != KC_NO) {
if (clever_key_finder(next_keycode, record)) { get_clever_keycode(&next_keycode, record);
processingCK = true;
//return false;
}
store_keycode(next_keycode, record); store_keycode(next_keycode, record);
} }
//return true; // If no clever key was found, process keycode normally. //return true; // If no clever key was found, process keycode normally.
@ -199,21 +188,6 @@ bool process_clever_keys(uint16_t keycode, keyrecord_t* record) {
return true; return true;
} }
/* bool process_clever_keys(uint16_t keycode, keyrecord_t* record) {
if (record->event.pressed) {
uint16_t next_keycode = get_next_keycode(keycode, record);
if (next_keycode != KC_NO) {
if (clever_key_finder(next_keycode, record)) { return false; }
store_keycode(next_keycode, record);
}
}
return true; // If no clever key was found, process keycode normally.
} */
void end_CK(keyrecord_t* record) { void end_CK(keyrecord_t* record) {
if (processingCK) { if (processingCK) {
processingCK = false; processingCK = false;

5
keyboards/splitkb/kyria/rev1/base/keymaps/Kawamashi/features/clever_keys_utilities.h
View file

@ -37,10 +37,9 @@ uint16_t get_next_keycode(uint16_t keycode, keyrecord_t* record);
void store_keycode(uint16_t keycode, keyrecord_t* record); void store_keycode(uint16_t keycode, keyrecord_t* record);
void process_key(uint16_t keycode, keyrecord_t* record); void process_key(uint16_t keycode, keyrecord_t* record);
void invoke_key(uint16_t keycode, keyrecord_t* record); void invoke_key(uint16_t keycode, keyrecord_t* record);
bool replace_next_key(uint16_t keycode, keyrecord_t* record); void replace_next_key(uint16_t clever_keycode, uint16_t* next_keycode, keyrecord_t* record);
void process_word(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record); void process_word(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record);
bool finish_word(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record); void finish_word(uint16_t keycodes[], uint8_t num_keycodes, uint16_t* next_keycode, keyrecord_t* record);
bool finish_magic(uint16_t keycodes[], uint8_t num_keycodes, keyrecord_t* record);
bool process_clever_keys(uint16_t keycode, keyrecord_t* record); bool process_clever_keys(uint16_t keycode, keyrecord_t* record);
void end_CK(keyrecord_t* record); void end_CK(keyrecord_t* record);