Up keymap (#20769)

flinguenheld keymap aurora sweep

11 files changed, 1505 insertions, 1473 deletions

diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/.clang-format b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/.clang-format
new file mode 100644
index 0000000000..f87f20d8b6
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/.clang-format
@@ -0,0 +1 @@
+ColumnLimit: 110
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h
index c147d5e67f..f14e2b17e1 100644
--- a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h
@@ -18,23 +18,21 @@
 
 /* Flash */
 #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET              // Activates the double-tap behavior
-#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 200U // Timeout window in ms in which the double tap can occur.
+#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 200U // In ms in which the double tap can occur
 
 /* OLED */
 #undef OLED_FONT_H
 #define OLED_FONT_H "./oled/glcdfont.c"
 
-#define  OLED_TIMEOUT 25000
-#define OLED_BRIGHTNESS 60 // Protect my eyesss
+#define OLED_TIMEOUT 25000
+#define OLED_BRIGHTNESS 50 // Protect my eyesss
 #define SPLIT_LAYER_STATE_ENABLE
 #define SPLIT_MODS_ENABLE
 #define SPLIT_OLED_ENABLE
 
 /* Auto shift ♥ */
 #define AUTO_SHIFT_TIMEOUT 115
-
-/* Redefine CTRL + space (See space cadet shift) */
-#define LCPO_KEYS KC_LCTL, KC_TRNS, KC_SPC
+#define TAPPING_TERM 155
 
 /* Unicode */
 // #define UNICODE_SELECTED_MODES UC_LNX
@@ -61,7 +59,6 @@
 #define MK_C_OFFSET_2 25
 #define MK_C_INTERVAL_2 10
 
-
 #define MK_W_OFFSET_0 1
 #define MK_W_INTERVAL_0 160
 
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c
index d6bd3818b4..d5bf9f0223 100644
--- a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c
@@ -7,193 +7,498 @@
 /* Only for basis letters
    Exceptions like Tab or Enter */
 bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+  case KC_TAB:
+    // case KC_ENT:
 
-    switch (keycode) {
-
-        case KC_TAB:
-        case KC_ENT:
-
-        // --
-        case KC_A:
-        case KC_B:
-        case KC_C:
-        case KC_D:
-        case KC_E:
-        case KC_F:
-        case KC_G:
-        case KC_H:
-        case KC_I:
-        case KC_J:
-        case KC_K:
-        case KC_L:
-        case KC_M:
-        case KC_N:
-        case KC_O:
-        case KC_P:
-        case KC_Q:
-        case KC_R:
-        case KC_S:
-        case KC_T:
-        case KC_U:
-        case KC_V:
-        case KC_W:
-        case KC_X:
-        case KC_Y:
-        case KC_Z:
-
-            return true;
-    }
-
-    return get_custom_auto_shifted_key(keycode, record);
-}
+  case US_EACU:
+  case US_CCED:
+  case US_AE:
+  case US_OE:
+
+  // --
+  case KC_A:
+  case KC_B:
+  case KC_C:
+  case KC_D:
+  case KC_E:
+  case KC_F:
+  case KC_G:
+  case KC_H:
+  case KC_I:
+  case KC_J:
+  case KC_K:
+  case KC_L:
+  case KC_M:
+  case KC_N:
+  case KC_O:
+  case KC_P:
+  case KC_Q:
+  case KC_R:
+  case KC_S:
+  case KC_T:
+  case KC_U:
+  case KC_V:
+  case KC_W:
+  case KC_X:
+  case KC_Y:
+  case KC_Z:
 
+    return true;
+  }
+
+  return get_custom_auto_shifted_key(keycode, record);
+}
 
 /* Custom auto shift
    I use this instead of tap dance because double tap is horrible
    Add here the letter or the custom enum, then add in press_user and press_release the actions */
 bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
-    switch(keycode) {
+  switch (keycode) {
+  case KC_BSPC:
 
-        case KC_BSPC:
-        case KC_LABK:  // Easy indent with vim
-        case KC_RABK:
+  // Double them !!!
+  case KC_AMPERSAND:
+  case KC_AT:
+  case KC_BACKSLASH:
+  case KC_CIRCUMFLEX:
+  case KC_COLON:
+  case KC_DOLLAR:
+  case KC_EQUAL:
+  case KC_EXCLAIM:
+  case KC_GRAVE:
+  case KC_HASH:
+  case KC_MINUS:
+  case KC_PERC:
+  case KC_PIPE:
+  case KC_PLUS:
+  case KC_QUESTION:
+  case KC_QUOTE:
+  case KC_DOUBLE_QUOTE:
+  case KC_SEMICOLON:
+  case KC_SLASH:
+  case KC_ASTERISK:
+  case KC_TILDE:
+  case KC_UNDERSCORE:
 
-        /* French */
-        case CS_E_ACUTE:
+  case KC_LEFT_ANGLE_BRACKET: // Easy indent with vim
+  case KC_RIGHT_ANGLE_BRACKET:
 
-        case CS_A_GRAVE:
-        case CS_E_GRAVE:
-        case CS_I_GRAVE:
-        case CS_O_GRAVE:
-        case CS_U_GRAVE:
+  case KC_LEFT_BRACKET:
+  case KC_RIGHT_BRACKET:
+  case KC_LEFT_CURLY_BRACE:
+  case KC_RIGHT_CURLY_BRACE:
+  case KC_LEFT_PAREN:
+  case KC_RIGHT_PAREN:
 
-        case CS_A_CIRCUMFLEX:
-        case CS_E_CIRCUMFLEX:
-        case CS_I_CIRCUMFLEX:
-        case CS_O_CIRCUMFLEX:
-        case CS_U_CIRCUMFLEX:
+  /* French */
+  case CS_A_GRAVE:
+  case CS_E_GRAVE:
+  case CS_U_GRAVE:
 
-        case CS_A_DIAERESIS:
-        case CS_E_DIAERESIS:
-        case CS_I_DIAERESIS:
-        case CS_O_DIAERESIS:
-        case CS_U_DIAERESIS:
-        case CS_Y_DIAERESIS:
+  case CS_A_CIRCUMFLEX:
+  case CS_E_CIRCUMFLEX:
+  case CS_I_CIRCUMFLEX:
+  case CS_O_CIRCUMFLEX:
+  case CS_U_CIRCUMFLEX:
 
-        case CS_C_CEDILLA:
-        case CS_AE:
-        case CS_OE:
+  case CS_E_DIAERESIS:
+  case CS_I_DIAERESIS:
+  case CS_U_DIAERESIS:
+  case CS_Y_DIAERESIS:
+    return true;
 
-            return true;
-
-        default:
-            return false;
-    }
+  default:
+    return false;
+  }
 }
 
 void autoshift_press_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
-    switch(keycode) {
-
-        case KC_BSPC:
-            register_code16((!shifted) ? KC_BSPC : KC_DEL);
-            break;
-
-        case KC_LABK:
-            if (shifted) { send_unicode_string("<<"); }
-            else         { send_unicode_string("<"); } break;
-
-        case KC_RABK:
-            if (shifted) { send_unicode_string(">>"); }
-            else         { send_unicode_string(">"); } break;
-
-        /* French
-           Release is not necessary with 'send_unicode_string()' */
-        case CS_E_ACUTE:
-            if (shifted) { send_unicode_string("É"); }
-            else         { send_unicode_string("é"); } break;
-
-        case CS_A_GRAVE:
-            if (shifted) { send_unicode_string("À"); }
-            else         { send_unicode_string("à"); } break;
-        case CS_E_GRAVE:
-            if (shifted) { send_unicode_string("È"); }
-            else         { send_unicode_string("è"); } break;
-        case CS_I_GRAVE:
-            if (shifted) { send_unicode_string("Ì"); }
-            else         { send_unicode_string("ì"); } break;
-        case CS_O_GRAVE:
-            if (shifted) { send_unicode_string("Ò"); }
-            else         { send_unicode_string("ò"); } break;
-        case CS_U_GRAVE:
-            if (shifted) { send_unicode_string("Ù"); }
-            else         { send_unicode_string("ù"); } break;
-
-        case CS_A_CIRCUMFLEX:
-            if (shifted) { send_unicode_string("Â"); }
-            else         { send_unicode_string("â"); }  break;
-        case CS_E_CIRCUMFLEX:
-            if (shifted) { send_unicode_string("Ê"); }
-            else         { send_unicode_string("ê"); }  break;
-        case CS_I_CIRCUMFLEX:
-            if (shifted) { send_unicode_string("Î"); }
-            else         { send_unicode_string("î"); }  break;
-        case CS_O_CIRCUMFLEX:
-            if (shifted) { send_unicode_string("Ô"); }
-            else         { send_unicode_string("ô"); }  break;
-        case CS_U_CIRCUMFLEX:
-            if (shifted) { send_unicode_string("Û"); }
-            else         { send_unicode_string("û"); }  break;
-
-        case CS_A_DIAERESIS:
-            if (shifted) { send_unicode_string("Ä"); }
-            else         { send_unicode_string("ä"); }  break;
-        case CS_E_DIAERESIS:
-            if (shifted) { send_unicode_string("Ë"); }
-            else         { send_unicode_string("ë"); }  break;
-        case CS_I_DIAERESIS:
-            if (shifted) { send_unicode_string("Ï"); }
-            else         { send_unicode_string("ï"); }  break;
-        case CS_O_DIAERESIS:
-            if (shifted) { send_unicode_string("Ö"); }
-            else         { send_unicode_string("ö"); }  break;
-        case CS_U_DIAERESIS:
-            if (shifted) { send_unicode_string("Ü"); }
-            else         { send_unicode_string("ü"); }  break;
-        case CS_Y_DIAERESIS:
-            if (shifted) { send_unicode_string("Ÿ"); }
-            else         { send_unicode_string("ÿ"); }  break;
-
-        case CS_C_CEDILLA:
-            if (shifted) { send_unicode_string("Ç"); }
-            else         { send_unicode_string("ç"); } break;
-        case CS_AE:
-            if (shifted) { send_unicode_string("Æ"); }
-            else         { send_unicode_string("æ"); } break;
-        case CS_OE:
-            if (shifted) { send_unicode_string("Œ"); }
-            else         { send_unicode_string("œ"); } break;
-
-
-        default:
-            if (shifted) {
-                add_weak_mods(MOD_BIT(KC_LSFT));
-            }
-            /* & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift */
-            register_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+  switch (keycode) {
+  case KC_BSPC:
+    if (shifted) {
+      tap_code16(KC_DEL);
+    } else {
+      tap_code16(KC_BSPC);
     }
-}
+    break;
+    break;
 
-void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
-    switch(keycode) {
+  case KC_AMPERSAND:
+    if (shifted) {
+      tap_code16(KC_AMPERSAND);
+      tap_code16(KC_AMPERSAND);
+    } else {
+      tap_code16(KC_AMPERSAND);
+    }
+    break;
+  case KC_AT:
+    if (shifted) {
+      tap_code16(KC_AT);
+      tap_code16(KC_AT);
+    } else {
+      tap_code16(KC_AT);
+    }
+    break;
+  case KC_BACKSLASH:
+    if (shifted) {
+      tap_code16(KC_BACKSLASH);
+      tap_code16(KC_BACKSLASH);
+    } else {
+      tap_code16(KC_BACKSLASH);
+    }
+    break;
+  case KC_CIRCUMFLEX:
+    if (shifted) {
+      tap_code16(KC_CIRCUMFLEX);
+      tap_code16(KC_CIRCUMFLEX);
+    } else {
+      tap_code16(KC_CIRCUMFLEX);
+    }
+    break;
+  case KC_COLON:
+    if (shifted) {
+      tap_code16(KC_COLON);
+      tap_code16(KC_COLON);
+    } else {
+      tap_code16(KC_COLON);
+    }
+    break;
+  case KC_DOLLAR:
+    if (shifted) {
+      tap_code16(KC_DOLLAR);
+      tap_code16(KC_DOLLAR);
+    } else {
+      tap_code16(KC_DOLLAR);
+    }
+    break;
+  case KC_EQUAL:
+    if (shifted) {
+      tap_code16(KC_EQUAL);
+      tap_code16(KC_EQUAL);
+    } else {
+      tap_code16(KC_EQUAL);
+    }
+    break;
+  case KC_EXCLAIM:
+    if (shifted) {
+      tap_code16(KC_EXCLAIM);
+      tap_code16(KC_EXCLAIM);
+    } else {
+      tap_code16(KC_EXCLAIM);
+    }
+    break;
+  case KC_GRAVE:
+    if (shifted) {
+      tap_code16(KC_GRAVE);
+      tap_code16(KC_GRAVE);
+    } else {
+      tap_code16(KC_GRAVE);
+    }
+    break;
+  case KC_HASH:
+    if (shifted) {
+      tap_code16(KC_HASH);
+      tap_code16(KC_HASH);
+    } else {
+      tap_code16(KC_HASH);
+    }
+    break;
+  case KC_MINUS:
+    if (shifted) {
+      tap_code16(KC_MINUS);
+      tap_code16(KC_MINUS);
+    } else {
+      tap_code16(KC_MINUS);
+    }
+    break;
+  case KC_PERCENT:
+    if (shifted) {
+      tap_code16(KC_PERCENT);
+      tap_code16(KC_PERCENT);
+    } else {
+      tap_code16(KC_PERCENT);
+    }
+    break;
+  case KC_PIPE:
+    if (shifted) {
+      tap_code16(KC_PIPE);
+      tap_code16(KC_PIPE);
+    } else {
+      tap_code16(KC_PIPE);
+    }
+    break;
+  case KC_PLUS:
+    if (shifted) {
+      tap_code16(KC_PLUS);
+      tap_code16(KC_PLUS);
+    } else {
+      tap_code16(KC_PLUS);
+    }
+    break;
+  case KC_QUESTION:
+    if (shifted) {
+      tap_code16(KC_QUESTION);
+      tap_code16(KC_QUESTION);
+    } else {
+      tap_code16(KC_QUESTION);
+    }
+    break;
+  case KC_QUOTE:
+    if (shifted) {
+      tap_code16(KC_QUOTE);
+      tap_code16(KC_QUOTE);
+    } else {
+      tap_code16(KC_QUOTE);
+    }
+    break;
+  case KC_DOUBLE_QUOTE:
+    if (shifted) {
+      tap_code16(KC_DOUBLE_QUOTE);
+      tap_code16(KC_DOUBLE_QUOTE);
+    } else {
+      tap_code16(KC_DOUBLE_QUOTE);
+    }
+    break;
+  case KC_SEMICOLON:
+    if (shifted) {
+      tap_code16(KC_SEMICOLON);
+      tap_code16(KC_SEMICOLON);
+    } else {
+      tap_code16(KC_SEMICOLON);
+    }
+    break;
+  case KC_SLASH:
+    if (shifted) {
+      tap_code16(KC_SLASH);
+      tap_code16(KC_SLASH);
+    } else {
+      tap_code16(KC_SLASH);
+    }
+    break;
+  case KC_ASTERISK:
+    if (shifted) {
+      tap_code16(KC_ASTERISK);
+      tap_code16(KC_ASTERISK);
+    } else {
+      tap_code16(KC_ASTERISK);
+    }
+    break;
+  case KC_TILDE:
+    if (shifted) {
+      tap_code16(KC_TILDE);
+      tap_code16(KC_TILDE);
+    } else {
+      tap_code16(KC_TILDE);
+    }
+    break;
+  case KC_UNDERSCORE:
+    if (shifted) {
+      tap_code16(KC_UNDERSCORE);
+      tap_code16(KC_UNDERSCORE);
+    } else {
+      tap_code16(KC_UNDERSCORE);
+    }
+    break;
 
-        case KC_BSPC:
-            unregister_code16((!shifted) ? KC_BSPC : KC_DEL);
-            break;
+  case KC_LEFT_ANGLE_BRACKET:
+    if (shifted) {
+      tap_code16(KC_LEFT_ANGLE_BRACKET);
+      tap_code16(KC_LEFT_ANGLE_BRACKET);
+    } else {
+      tap_code16(KC_LEFT_ANGLE_BRACKET);
+    }
+    break;
+  case KC_RIGHT_ANGLE_BRACKET:
+    if (shifted) {
+      tap_code16(KC_RIGHT_ANGLE_BRACKET);
+      tap_code16(KC_RIGHT_ANGLE_BRACKET);
+    } else {
+      tap_code16(KC_RIGHT_ANGLE_BRACKET);
+    }
+    break;
 
-        default:
-            /* & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift
-               The IS_RETRO check isn't really necessary here, always using
-               keycode & 0xFF would be fine. */
-            unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+  case KC_LEFT_BRACKET:
+    if (shifted) {
+      tap_code16(KC_LEFT_BRACKET);
+      tap_code16(KC_LEFT_BRACKET);
+    } else {
+      tap_code16(KC_LEFT_BRACKET);
+    }
+    break;
+  case KC_RIGHT_BRACKET:
+    if (shifted) {
+      tap_code16(KC_RIGHT_BRACKET);
+      tap_code16(KC_RIGHT_BRACKET);
+    } else {
+      tap_code16(KC_RIGHT_BRACKET);
+    }
+    break;
+  case KC_LEFT_CURLY_BRACE:
+    if (shifted) {
+      tap_code16(KC_LEFT_CURLY_BRACE);
+      tap_code16(KC_LEFT_CURLY_BRACE);
+    } else {
+      tap_code16(KC_LEFT_CURLY_BRACE);
+    }
+    break;
+  case KC_RIGHT_CURLY_BRACE:
+    if (shifted) {
+      tap_code16(KC_RIGHT_CURLY_BRACE);
+      tap_code16(KC_RIGHT_CURLY_BRACE);
+    } else {
+      tap_code16(KC_RIGHT_CURLY_BRACE);
+    }
+    break;
+  case KC_LEFT_PAREN:
+    if (shifted) {
+      tap_code16(KC_LEFT_PAREN);
+      tap_code16(KC_LEFT_PAREN);
+    } else {
+      tap_code16(KC_LEFT_PAREN);
+    }
+    break;
+  case KC_RIGHT_PAREN:
+    if (shifted) {
+      tap_code16(KC_RIGHT_PAREN);
+      tap_code16(KC_RIGHT_PAREN);
+    } else {
+      tap_code16(KC_RIGHT_PAREN);
+    }
+    break;
+
+  /* French
+     Release is not necessary with 'send_unicode_string()' */
+  case CS_A_GRAVE:
+    if (shifted) {
+      tap_code16(US_DGRV);
+      tap_code16(S(KC_A));
+    } else {
+      tap_code16(US_DGRV);
+      tap_code16(KC_A);
+    }
+    break;
+  case CS_E_GRAVE:
+    if (shifted) {
+      tap_code16(US_DGRV);
+      tap_code16(S(KC_E));
+    } else {
+      tap_code16(US_DGRV);
+      tap_code16(KC_E);
+    }
+    break;
+  case CS_U_GRAVE:
+    if (shifted) {
+      tap_code16(US_DGRV);
+      tap_code16(S(KC_U));
+    } else {
+      tap_code16(US_DGRV);
+      tap_code16(KC_U);
+    }
+    break;
+
+  case CS_A_CIRCUMFLEX:
+    if (shifted) {
+      tap_code16(US_DCIR);
+      tap_code16(S(KC_A));
+    } else {
+      tap_code16(US_DCIR);
+      tap_code16(KC_A);
+    }
+    break;
+  case CS_E_CIRCUMFLEX:
+    if (shifted) {
+      tap_code16(US_DCIR);
+      tap_code16(S(KC_E));
+    } else {
+      tap_code16(US_DCIR);
+      tap_code16(KC_E);
     }
+    break;
+  case CS_I_CIRCUMFLEX:
+    if (shifted) {
+      tap_code16(US_DCIR);
+      tap_code16(S(KC_I));
+    } else {
+      tap_code16(US_DCIR);
+      tap_code16(KC_I);
+    }
+    break;
+  case CS_O_CIRCUMFLEX:
+    if (shifted) {
+      tap_code16(US_DCIR);
+      tap_code16(S(KC_O));
+    } else {
+      tap_code16(US_DCIR);
+      tap_code16(KC_O);
+    }
+    break;
+  case CS_U_CIRCUMFLEX:
+    if (shifted) {
+      tap_code16(US_DCIR);
+      tap_code16(S(KC_U));
+    } else {
+      tap_code16(US_DCIR);
+      tap_code16(KC_U);
+    }
+    break;
+
+  case CS_E_DIAERESIS:
+    if (shifted) {
+      tap_code16(US_DIAE);
+      tap_code16(S(KC_E));
+    } else {
+      tap_code16(US_DIAE);
+      tap_code16(KC_E);
+    }
+    break;
+  case CS_I_DIAERESIS:
+    if (shifted) {
+      tap_code16(US_DIAE);
+      tap_code16(S(KC_I));
+    } else {
+      tap_code16(US_DIAE);
+      tap_code16(KC_I);
+    }
+    break;
+  case CS_U_DIAERESIS:
+    if (shifted) {
+      tap_code16(US_DIAE);
+      tap_code16(S(KC_U));
+    } else {
+      tap_code16(US_DIAE);
+      tap_code16(KC_U);
+    }
+    break;
+  case CS_Y_DIAERESIS:
+    if (shifted) {
+      tap_code16(US_DIAE);
+      tap_code16(S(KC_Y));
+    } else {
+      tap_code16(US_DIAE);
+      tap_code16(KC_Y);
+    }
+    break;
+
+  default:
+    if (shifted) {
+      add_weak_mods(MOD_BIT(KC_LSFT));
+    }
+    /* & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift */
+    register_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+  }
+}
+
+void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
+  switch (keycode) {
+  case KC_BSPC:
+    unregister_code16((!shifted) ? KC_BSPC : KC_DEL);
+    break;
+
+  default:
+    /* & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift
+       The IS_RETRO check isn't really necessary here, always using
+       keycode & 0xFF would be fine. */
+    unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+  }
 }
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c
index c382eedddc..de0436b361 100644
--- a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c
@@ -15,256 +15,231 @@
 */
 
 enum combos {
-    LEADER,
-    BOOTLOADER,
-
-    LAYER_ADJUST,
-    LAYER_FN,
-    LAYER_LEFT_HAND,
-
-    /* French */
-    E_ACUTE,
-    C_CEDILLA,
-    E_A,
-    E_O,
-
-    A_GRAVE,
-    E_GRAVE,
-    I_GRAVE,
-    O_GRAVE,
-    U_GRAVE,
-
-    A_CIRCUMFLEX,
-    E_CIRCUMFLEX,
-    I_CIRCUMFLEX,
-    O_CIRCUMFLEX,
-    U_CIRCUMFLEX,
-
-    A_DIAERESIS,
-    E_DIAERESIS,
-    I_DIAERESIS,
-    O_DIAERESIS,
-    U_DIAERESIS,
-    Y_DIAERESIS,
-
-    /* -- */
-    AMPERSAND,
-    AT_SIGN,
-    BACKSLASH,
-    CIRCUMFLEX,
-    COLON,
-    DOLLAR,
-    EQUAL,
-    EXCLAMATION_MARK,
-    GRAVE,
-    HASH,
-    MINUS,
-    PERCENT,
-    PIPE,
-    PLUS,
-    QUESTION_MARK,
-    QUOTE,
-    QUOTE_DOUBLE,
-    SEMICOLON,
-    SLASH,
-    STAR,
-    TILDE,
-    UNDERSCORE,
-
-    ANGLE_BRACKET_LEFT,
-    ANGLE_BRACKET_RIGHT,
-
-    BRACKET_LEFT,
-    BRACKET_RIGHT,
-    CURLY_BRACKET_LEFT,
-    CURLY_BRACKET_RIGHT,
-    PARENTHESIS_LEFT,
-    PARENTHESIS_RIGHT,
-
-    /* -- */
-    ALT_SHIFT,
-    CONTROL_SHIFT,
-    CONTROL_ALT,
-    CONTROL_SHIFT_ALT,
-    RIGHT_ALT,
-
-    /* One hand special */
-    CONTROL_RIGHT,
-    CONTROL_SHIFT_RIGHT,
-
-    // DEL_LEFT,
-    SHIFT_LEFT,
-    ALTGR_LEFT,
-    CONTROL_SHIFT_LEFT,
+  LEADER,
+  BOOTLOADER,
+
+  LAYER_ADJ,
+  LAYER_FN,
+  LAYER_LEFT_HAND,
+  LAYER_MOUSE,
+  LAYER_MOUSE_BACK,
+
+  /* French */
+  C_CEDILLA,
+  E_A,
+  E_O,
+
+  A_GRAVE,
+  E_GRAVE,
+  U_GRAVE,
+
+  A_CIRCUMFLEX,
+  E_CIRCUMFLEX,
+  I_CIRCUMFLEX,
+  O_CIRCUMFLEX,
+  U_CIRCUMFLEX,
+
+  E_DIAERESIS,
+  I_DIAERESIS,
+  U_DIAERESIS,
+  Y_DIAERESIS,
+
+  /* -- */
+  AMPERSAND,
+  AT_SIGN,
+  BACKSLASH,
+  CIRCUMFLEX,
+  COLON,
+  DOLLAR,
+  EQUAL,
+  EXCLAMATION_MARK,
+  GRAVE,
+  HASH,
+  MINUS,
+  PERCENT,
+  PIPE,
+  PLUS,
+  QUESTION_MARK,
+  QUOTE,
+  QUOTE_DOUBLE,
+  SEMICOLON,
+  SLASH,
+  STAR,
+  TILDE,
+  UNDERSCORE,
+
+  ANGLE_BRACKET_LEFT,
+  ANGLE_BRACKET_RIGHT,
+
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  CURLY_BRACKET_LEFT,
+  CURLY_BRACKET_RIGHT,
+  PARENTHESIS_LEFT,
+  PARENTHESIS_RIGHT,
+
+  /* Non qwerty */
+  EURO,
+
+  /* One hand special */
+  CONTROL_RIGHT,
+  CONTROL_SHIFT_RIGHT,
+
+  ALT_LEFT,
+  SHIFT_LEFT,
+  CONTROL_SHIFT_LEFT,
+
+  /* Just to replace the define in config.h */
+  COMBO_LENGTH,
 };
+uint16_t COMBO_LEN = COMBO_LENGTH;
 
 /* Sequences fo keys */
-const uint16_t PROGMEM combo_leader[] =                 {LT(_MOUSE, KC_COMM), LT(_ARROWS, KC_DOT), COMBO_END};
-const uint16_t PROGMEM combo_bootloader[] =             {KC_K, KC_TAB, KC_Z, KC_BSPC, KC_V, KC_J, COMBO_END};
+const uint16_t PROGMEM combo_leader[] = {LT(_MOUSE, KC_COMM), LT(_ARROWS, KC_DOT), COMBO_END};
+const uint16_t PROGMEM combo_bootloader[] = {KC_K, KC_TAB, KC_Z, KC_BSPC, KC_V, KC_J, COMBO_END};
+
+const uint16_t PROGMEM combo_ADJ[] = {CTL_T(KC_SPACE), LT(_NUMERIC, KC_ENT), COMBO_END};
+const uint16_t PROGMEM combo_fn[] = {LT(_NUMERIC, KC_ENT), KC_N, COMBO_END};
+const uint16_t PROGMEM combo_left_hand[] = {LT(_MOUSE, KC_COMM), GUI_T(KC_ESC), COMBO_END};
+const uint16_t PROGMEM combo_mouse[] = {KC_A, KC_I, KC_E, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_mouse_back[] = {KC_MS_LEFT, KC_MS_UP, KC_MS_DOWN, KC_MS_RIGHT, COMBO_END};
+/* -- */
+const uint16_t PROGMEM combo_c_cedilla[] = {LT(_ARROWS, KC_DOT), KC_C, COMBO_END};
+const uint16_t PROGMEM combo_ea[] = {US_EACU, KC_A, COMBO_END};
+const uint16_t PROGMEM combo_eo[] = {US_EACU, KC_O, COMBO_END};
 
-const uint16_t PROGMEM combo_adjust[] =                 {KC_LCPO, LT(_NUMERIC, KC_ENT), COMBO_END};
-const uint16_t PROGMEM combo_fn[] =                     {LT(_NUMERIC, KC_ENT), KC_N, COMBO_END};
-const uint16_t PROGMEM combo_left_hand[] =              {KC_LCPO, GUI_T(KC_ESC), COMBO_END};
+const uint16_t PROGMEM combo_a_grave[] = {CTL_T(KC_SPACE), KC_A, COMBO_END};
+const uint16_t PROGMEM combo_e_grave[] = {CTL_T(KC_SPACE), KC_E, COMBO_END};
+const uint16_t PROGMEM combo_u_grave[] = {CTL_T(KC_SPACE), KC_U, COMBO_END};
 
-/* -- */
-// const uint16_t PROGMEM combo_enter_shifted[] =          {LT(_NUMERIC, KC_ENT), KC_S, COMBO_END};
-const uint16_t PROGMEM combo_control_shift[] =          {KC_LCPO, KC_S, COMBO_END};
-const uint16_t PROGMEM combo_control_alt[] =            {KC_LCPO, KC_LALT, COMBO_END};
-const uint16_t PROGMEM combo_control_shift_alt[] =      {KC_LCPO, KC_S, KC_A, COMBO_END};
-const uint16_t PROGMEM combo_right_alt[] =              {KC_LAPO, KC_G, COMBO_END};
-const uint16_t PROGMEM combo_alt_shift[] =              {KC_LALT, KC_S, COMBO_END};
+const uint16_t PROGMEM combo_a_circumflex[] = {LT(_MOUSE, KC_COMM), KC_A, COMBO_END};
+const uint16_t PROGMEM combo_e_circumflex[] = {LT(_MOUSE, KC_COMM), KC_E, COMBO_END};
+const uint16_t PROGMEM combo_i_circumflex[] = {LT(_MOUSE, KC_COMM), KC_I, COMBO_END};
+const uint16_t PROGMEM combo_o_circumflex[] = {LT(_MOUSE, KC_COMM), KC_O, COMBO_END};
+const uint16_t PROGMEM combo_u_circumflex[] = {LT(_MOUSE, KC_COMM), KC_U, COMBO_END};
 
-/* -- */
-const uint16_t PROGMEM combo_e_acute[] =                {KC_LCPO, KC_E, COMBO_END};
-const uint16_t PROGMEM combo_c_cedilla[] =              {KC_LCPO, KC_I, COMBO_END};
-const uint16_t PROGMEM combo_ea[] =                     {KC_LCPO, KC_A, COMBO_END};
-const uint16_t PROGMEM combo_eo[] =                     {KC_LCPO, KC_O, COMBO_END};
-
-const uint16_t PROGMEM combo_a_grave[] =                {LT(_MOUSE, KC_COMM), KC_A, COMBO_END};
-const uint16_t PROGMEM combo_e_grave[] =                {LT(_MOUSE, KC_COMM), KC_E, COMBO_END};
-const uint16_t PROGMEM combo_i_grave[] =                {LT(_MOUSE, KC_COMM), KC_I, COMBO_END};
-const uint16_t PROGMEM combo_o_grave[] =                {LT(_MOUSE, KC_COMM), KC_O, COMBO_END};
-const uint16_t PROGMEM combo_u_grave[] =                {LT(_MOUSE, KC_COMM), KC_U, COMBO_END};
-
-const uint16_t PROGMEM combo_a_circumflex[] =           {KC_C, KC_A, COMBO_END};
-const uint16_t PROGMEM combo_e_circumflex[] =           {KC_C, KC_E, COMBO_END};
-const uint16_t PROGMEM combo_i_circumflex[] =           {KC_C, KC_I, COMBO_END};
-const uint16_t PROGMEM combo_o_circumflex[] =           {KC_C, KC_O, COMBO_END};
-const uint16_t PROGMEM combo_u_circumflex[] =           {KC_C, KC_U, COMBO_END};
-
-const uint16_t PROGMEM combo_a_diaeresis[] =            {KC_T, KC_A, COMBO_END};
-const uint16_t PROGMEM combo_e_diaeresis[] =            {KC_T, KC_E, COMBO_END};
-const uint16_t PROGMEM combo_i_diaeresis[] =            {KC_T, KC_I, COMBO_END};
-const uint16_t PROGMEM combo_o_diaeresis[] =            {KC_T, KC_O, COMBO_END};
-const uint16_t PROGMEM combo_u_diaeresis[] =            {KC_T, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_y_diaeresis[] =            {KC_T, KC_Y, COMBO_END};
+const uint16_t PROGMEM combo_e_diaeresis[] = {US_EACU, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_i_diaeresis[] = {US_EACU, KC_I, COMBO_END};
+const uint16_t PROGMEM combo_u_diaeresis[] = {US_EACU, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_y_diaeresis[] = {US_EACU, KC_Y, COMBO_END};
 
 /* -- */
-const uint16_t PROGMEM combo_ampersand[] =              {KC_I, KC_E, COMBO_END};
-const uint16_t PROGMEM combo_at_sign[] =                {KC_Q, KC_Y, COMBO_END};
-const uint16_t PROGMEM combo_backslash[] =              {KC_D, KC_R, COMBO_END};
-const uint16_t PROGMEM combo_circumflex[] =             {KC_T, KC_D, COMBO_END};
-const uint16_t PROGMEM combo_colon[] =                  {KC_C, KC_G, COMBO_END};
-const uint16_t PROGMEM combo_dollar[] =                 {KC_D, KC_L, COMBO_END};
-const uint16_t PROGMEM combo_equal[] =                  {KC_T, KC_H, COMBO_END};
-const uint16_t PROGMEM combo_exclamation_mark[] =       {KC_O, KC_W, COMBO_END};
-const uint16_t PROGMEM combo_grave[] =                  {KC_T, KC_G, COMBO_END};
-const uint16_t PROGMEM combo_hash[] =                   {KC_I, KC_O, COMBO_END};
-const uint16_t PROGMEM combo_minus[] =                  {KC_T, KC_R, COMBO_END};
-const uint16_t PROGMEM combo_percent[] =                {KC_O, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_pipe[] =                   {KC_E, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_plus[] =                   {KC_T, KC_L, COMBO_END};
-const uint16_t PROGMEM combo_question_mark[] =          {KC_B, KC_O, COMBO_END};
-const uint16_t PROGMEM combo_quote[] =                  {KC_T, KC_N, COMBO_END};
-const uint16_t PROGMEM combo_quote_double[] =           {KC_A, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_semicolon[] =              {KC_G, KC_H, COMBO_END};
-const uint16_t PROGMEM combo_slash[] =                  {KC_S, KC_L, COMBO_END};
-const uint16_t PROGMEM combo_star[] =                   {KC_S, KC_T, COMBO_END};
-const uint16_t PROGMEM combo_tilde[] =                  {KC_I, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_underscore[] =             {KC_S, KC_R, COMBO_END};
-
-const uint16_t PROGMEM combo_angle_bracket_left[] =     {KC_C, KC_S, COMBO_END};
-const uint16_t PROGMEM combo_angle_bracket_right[] =    {KC_S, KC_H, COMBO_END};
-
-const uint16_t PROGMEM combo_bracket_left[] =           {KC_Q, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_bracket_right[] =          {KC_E, KC_Y, COMBO_END};
-const uint16_t PROGMEM combo_curly_bracket_left[] =     {KC_X, KC_E, COMBO_END};
-const uint16_t PROGMEM combo_curly_bracket_right[] =    {KC_I, KC_Q, COMBO_END};
-const uint16_t PROGMEM combo_parenthesis_left[] =       {KC_X, KC_U, COMBO_END};
-const uint16_t PROGMEM combo_parenthesis_right[] =      {KC_I, KC_Y, COMBO_END};
+const uint16_t PROGMEM combo_ampersand[] = {KC_E, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_at_sign[] = {KC_D, KC_L, COMBO_END};
+const uint16_t PROGMEM combo_backslash[] = {KC_B, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_circumflex[] = {KC_B, KC_O, COMBO_END};
+const uint16_t PROGMEM combo_colon[] = {KC_C, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_dollar[] = {KC_O, KC_W, COMBO_END};
+const uint16_t PROGMEM combo_equal[] = {KC_T, KC_H, COMBO_END};
+const uint16_t PROGMEM combo_exclamation_mark[] = {KC_Q, KC_Y, COMBO_END};
+const uint16_t PROGMEM combo_grave[] = {KC_T, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_hash[] = {KC_X, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_minus[] = {KC_T, KC_R, COMBO_END};
+const uint16_t PROGMEM combo_percent[] = {KC_B, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_pipe[] = {KC_I, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_plus[] = {KC_T, KC_L, COMBO_END};
+const uint16_t PROGMEM combo_question_mark[] = {KC_P, KC_D, COMBO_END};
+const uint16_t PROGMEM combo_quote[] = {KC_T, KC_N, COMBO_END};
+const uint16_t PROGMEM combo_quote_double[] = {KC_A, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_semicolon[] = {KC_G, KC_H, COMBO_END};
+const uint16_t PROGMEM combo_slash[] = {KC_S, KC_L, COMBO_END};
+const uint16_t PROGMEM combo_star[] = {KC_S, KC_T, COMBO_END};
+const uint16_t PROGMEM combo_tilde[] = {KC_I, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_underscore[] = {KC_S, KC_R, COMBO_END};
+
+const uint16_t PROGMEM combo_angle_bracket_left[] = {KC_C, KC_S, COMBO_END};
+const uint16_t PROGMEM combo_angle_bracket_right[] = {KC_S, KC_H, COMBO_END};
+const uint16_t PROGMEM combo_bracket_left[] = {KC_I, KC_O, COMBO_END};
+const uint16_t PROGMEM combo_bracket_right[] = {KC_O, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_curly_bracket_left[] = {KC_X, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_curly_bracket_right[] = {KC_E, KC_Y, COMBO_END};
+const uint16_t PROGMEM combo_parenthesis_left[] = {KC_T, KC_D, COMBO_END};
+const uint16_t PROGMEM combo_parenthesis_right[] = {KC_D, KC_R, COMBO_END};
+
+/* Non qwerty */
+const uint16_t PROGMEM combo_euro[] = {KC_X, KC_Q, COMBO_END};
 
 /* One hand special */
-const uint16_t PROGMEM combo_control_right[] =          {LT(_NUMERIC, KC_ENT), KC_R, COMBO_END};
-const uint16_t PROGMEM combo_control_shift_right[] =    {LT(_NUMERIC, KC_ENT), KC_S, COMBO_END};
-
-const uint16_t PROGMEM combo_shift_left[] =             {KC_LCPO, KC_LALT, COMBO_END};
-// const uint16_t PROGMEM combo_altgr_left[] =             {LT(_MOUSE, KC_COMM), KC_LALT, COMBO_END};
-// const uint16_t PROGMEM combo_del_left[] =               {GUI_T(KC_ESC), KC_K, COMBO_END};
-const uint16_t PROGMEM combo_control_shift_left[] =     {LT(_MOUSE, KC_COMM), KC_LALT, COMBO_END};
+const uint16_t PROGMEM combo_control_right[] = {LT(_NUMERIC, KC_ENT), KC_R, COMBO_END};
+const uint16_t PROGMEM combo_c