diff options
10 files changed, 1835 insertions, 0 deletions
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h new file mode 100644 index 0000000000..c147d5e67f --- /dev/null +++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h @@ -0,0 +1,75 @@ +/* Copyright 2023 Florent Linguenheld (@FLinguenheld) + * + * 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 + +/* 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. + +/* OLED */ +#undef OLED_FONT_H +#define OLED_FONT_H "./oled/glcdfont.c" + +#define OLED_TIMEOUT 25000 +#define OLED_BRIGHTNESS 60 // 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 + +/* Unicode */ +// #define UNICODE_SELECTED_MODES UC_LNX +#define UNICODE_SELECTED_MODES UNICODE_MODE_LINUX + +/* leader */ +#define LEADER_PER_KEY_TIMING +#define LEADER_TIMEOUT 280 +#define LEADER_NO_TIMEOUT + +/* Mouse */ +#define MK_3_SPEED +#define MK_MOMENTARY_ACCEL + +#define MK_C_OFFSET_0 1 +#define MK_C_INTERVAL_0 12 + +#define MK_C_OFFSET_1 4 +#define MK_C_INTERVAL_1 18 + +#define MK_C_OFFSET_UNMOD 13 +#define MK_C_INTERVAL_UNMOD 15 + +#define MK_C_OFFSET_2 25 +#define MK_C_INTERVAL_2 10 + + +#define MK_W_OFFSET_0 1 +#define MK_W_INTERVAL_0 160 + +#define MK_W_OFFSET_1 2 +#define MK_W_INTERVAL_1 120 + +#define MK_W_OFFSET_UNMOD 4 +#define MK_W_INTERVAL_UNMOD 70 + +#define MK_W_OFFSET_2 10 +#define MK_W_INTERVAL_2 30 diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c new file mode 100644 index 0000000000..d6bd3818b4 --- /dev/null +++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c @@ -0,0 +1,199 @@ +// Copyright 2023 Florent Linguenheld (@FLinguenheld) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include QMK_KEYBOARD_H +#include "keycodes.h" + +/* 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: + + // -- + 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) { + + case KC_BSPC: + case KC_LABK: // Easy indent with vim + case KC_RABK: + + /* French */ + case CS_E_ACUTE: + + case CS_A_GRAVE: + case CS_E_GRAVE: + case CS_I_GRAVE: + case CS_O_GRAVE: + case CS_U_GRAVE: + + case CS_A_CIRCUMFLEX: + case CS_E_CIRCUMFLEX: + case CS_I_CIRCUMFLEX: + case CS_O_CIRCUMFLEX: + case CS_U_CIRCUMFLEX: + + 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_C_CEDILLA: + case CS_AE: + case CS_OE: + + return true; + + 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); + } +} + +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 new file mode 100644 index 0000000000..e5b897dc62 --- /dev/null +++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c @@ -0,0 +1,275 @@ +// Copyright 2023 Florent Linguenheld (@FLinguenheld) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include QMK_KEYBOARD_H +#include "keycodes.h" + +/* How to : + - Add an entry in the enum + - Create a new sequence of keys + - Link the enum to this sequence in the key_combos table + + For macros : + - Same steps + - And add the macro in the process_combo_event() function +*/ + +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, + + /* 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_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_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_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_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}; + +/* 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}; + + +/* Sequences fo keys */ +combo_t key_combos[] = { + [LEADER] = COMBO(combo_leader, KC_LEAD), + [BOOTLOADER] = COMBO(combo_bootloader, QK_BOOTLOADER), + + [LAYER_ADJUST] = COMBO(combo_adjust, OSL(_ADJUST)), + [LAYER_FN] = COMBO(combo_fn, OSL(_FN)), + [LAYER_LEFT_HAND] = COMBO(combo_left_hand, OSL(_LEFT_HAND)), + + /* -- */ + // [ENTER_SHIFTED] = COMBO(combo_enter_shifted, S(KC_ENT)), + [ALT_SHIFT] = COMBO(combo_alt_shift, A(S(XXXXXXX))), + [CONTROL_SHIFT] = COMBO(combo_control_shift, C(S(XXXXXXX))), + [CONTROL_ALT] = COMBO(combo_control_alt, C(A(XXXXXXX))), + [CONTROL_SHIFT_ALT] = COMBO(combo_control_shift_alt, C(S(A(XXXXXXX)))), + [RIGHT_ALT] = COMBO(combo_right_alt, KC_RALT), + + /* French */ + [E_ACUTE] = COMBO(combo_e_acute, CS_E_ACUTE), + [C_CEDILLA] = COMBO(combo_c_cedilla, CS_C_CEDILLA), + [E_A] = COMBO(combo_ea, CS_AE), + [E_O] = COMBO(combo_eo, CS_OE), + + [A_GRAVE] = COMBO(combo_a_grave, CS_A_GRAVE), + [E_GRAVE] = COMBO(combo_e_grave, CS_E_GRAVE), + [I_GRAVE] = COMBO(combo_i_grave, CS_I_GRAVE), + [O_GRAVE] = COMBO(combo_o_grave, CS_O_GRAVE), + [U_GRAVE] = COMBO(combo_u_grave, CS_U_GRAVE), + + [A_CIRCUMFLEX] = COMBO(combo_a_circumflex, CS_A_CIRCUMFLEX), + [E_CIRCUMFLEX] = COMBO(combo_e_circumflex, CS_E_CIRCUMFLEX), + [I_CIRCUMFLEX] = COMBO(combo_i_circumflex, CS_I_CIRCUMFLEX), + [O_CIRCUMFLEX] = COMBO(combo_o_circumflex, CS_O_CIRCUMFLEX), + [U_CIRCUMFLEX] = COMBO(combo_u_circumflex, CS_U_CIRCUMFLEX), + + [A_DIAERESIS] = COMBO(combo_a_diaeresis, CS_A_DIAERESIS), + [E_DIAERESIS] = COMBO(combo_e_diaeresis, CS_E_DIAERESIS), + [I_DIAERESIS] = COMBO(combo_i_diaeresis, CS_I_DIAERESIS), + [O_DIAERESIS] = COMBO(combo_o_diaeresis, CS_O_DIAERESIS), + [U_DIAERESIS] = COMBO(combo_u_diaeresis, CS_U_DIAERESIS), + [Y_DIAERESIS] = COMBO(combo_y_diaeresis, CS_Y_DIAERESIS), + + /* -- */ + [AMPERSAND] = COMBO(combo_ampersand, KC_AMPR), + [AT_SIGN] = COMBO(combo_at_sign, KC_AT), + [BACKSLASH] = COMBO(combo_backslash, KC_BSLS), + [CIRCUMFLEX] = COMBO(combo_circumflex, KC_CIRC), + [COLON] = COMBO(combo_colon, KC_COLON), + [DOLLAR] = COMBO(combo_dollar, KC_DLR), + [EQUAL] = COMBO(combo_equal, KC_EQL), + [EXCLAMATION_MARK] = COMBO(combo_exclamation_mark, KC_EXCLAIM), + [GRAVE] = COMBO(combo_grave, KC_GRV), + [HASH] = COMBO(combo_hash, KC_HASH), + [MINUS] = COMBO(combo_minus, KC_MINS), + [PERCENT] = COMBO(combo_percent, KC_PERC), + [PIPE] = COMBO(combo_pipe, KC_PIPE), + [PLUS] = COMBO(combo_plus, KC_PLUS), + [QUESTION_MARK] = COMBO(combo_question_mark, KC_QUESTION), + [QUOTE] = COMBO(combo_quote, KC_QUOTE), + [QUOTE_DOUBLE] = COMBO(combo_quote_double, KC_DOUBLE_QUOTE), + [SEMICOLON] = COMBO(combo_semicolon, KC_SEMICOLON), + [SLASH] = COMBO(combo_slash, KC_SLSH), + [STAR] = COMBO(combo_star, KC_ASTR), + [TILDE] = COMBO(combo_tilde, KC_TILD), + [UNDERSCORE] = COMBO(combo_underscore, KC_UNDS), + + [ANGLE_BRACKET_LEFT] = COMBO(combo_angle_bracket_left, KC_LABK), + [ANGLE_BRACKET_RIGHT] = COMBO(combo_angle_bracket_right, KC_RABK), + + [BRACKET_LEFT] = COMBO(combo_bracket_left, KC_LEFT_BRACKET), + [BRACKET_RIGHT] = COMBO(combo_bracket_right, KC_RIGHT_BRACKET), + [CURLY_BRACKET_LEFT] = COMBO(combo_curly_bracket_left, KC_LEFT_CURLY_BRACE), + [CURLY_BRACKET_RIGHT] = COMBO(combo_curly_bracket_right, KC_RIGHT_CURLY_BRACE), + [PARENTHESIS_LEFT] = COMBO(combo_parenthesis_left, KC_LEFT_PAREN), + [PARENTHESIS_RIGHT] COMBO(combo_parenthesis_right, KC_RIGHT_PAREN), + + /* One hand special */ + [CONTROL_RIGHT] = COMBO(combo_control_right, KC_RCTL), + [CONTROL_SHIFT_RIGHT] = COMBO(combo_control_shift_right, C(S(XXXXXXX))), + + [SHIFT_LEFT] = COMBO(combo_shift_left, KC_LSFT), + // [ALTGR_LEFT] = COMBO(combo_altgr_left, KC_ALGR), + [CONTROL_SHIFT_LEFT] = COMBO(combo_control_shift_left, C(S(XXXXXXX))), + // [DEL_LEFT] = COMBO(combo_del_left, KC_BSPC), +}; diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/leader.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/leader.c new file mode 100644 index 0000000000..7cfd30af6d --- /dev/null +++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/leader.c @@ -0,0 +1,268 @@ +// Copyright 2023 Florent Linguenheld (@FLinguenheld) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include QMK_KEYBOARD_H + +LEADER_EXTERNS(); + +void matrix_scan_user(void) { + LEADER_DICTIONARY() { + leading = false; + leader_end(); + + // SEQ_ONE_KEY(KC_F) { + // // Anything you can do in a macro. + // SEND_STRING("QMK is awesome."); } + + + SEQ_TWO_KEYS(KC_M, KC_S) { + SEND_STRING("f@linguenheld.fr"); } + SEQ_TWO_KEYS(KC_M, KC_L) { + SEND_STRING("florent@linguenheld.fr"); } + SEQ_TWO_KEYS(KC_F, KC_L) { + SEND_STRING("FLinguenheld"); } + + SEQ_THREE_KEYS(KC_T, KC_E, KC_S) { + SEND_STRING("test01234"); } + SEQ_THREE_KEYS(KC_A, KC_D, KC_M) { + SEND_STRING("admin01234"); } + + SEQ_ONE_KEY(KC_C) { + SEND_STRING(" | xclip -r -selection clipboard"); } + + /* Degree */ + SEQ_THREE_KEYS(KC_D, KC_E, KC_G) { + send_unicode_string("°"); } + + /* Copyright / Register */ + SEQ_THREE_KEYS(KC_C, KC_O, KC_P) { + send_unicode_string("©"); } + SEQ_THREE_KEYS(KC_R, KC_E, KC_G) { + send_unicode_string("®"); } + + /* Diameter */ + SEQ_THREE_KEYS(KC_D, KC_I, KC_A) { + send_unicode_string("ø"); } + SEQ_FOUR_KEYS(KC_D, KC_I, KC_A, KC_M) { + send_unicode_string("Ø"); } + + /* Currency */ + SEQ_THREE_KEYS(KC_E, KC_U, KC_R) { + send_unicode_string("€"); } + SEQ_THREE_KEYS(KC_P, KC_O, KC_U) { + send_unicode_string("£"); } + SEQ_THREE_KEYS(KC_Y, KC_E, KC_N) { + send_unicode_string("¥"); } + SEQ_THREE_KEYS(KC_C, KC_E, KC_N) { + send_unicode_string("¢"); } + + /* Fractions */ + SEQ_THREE_KEYS(KC_F, KC_C, KC_T) { + send_unicode_string("¼"); } + SEQ_THREE_KEYS(KC_F, KC_C, KC_G) { + send_unicode_string("½"); } + SEQ_THREE_KEYS(KC_F, KC_H, KC_T) { + send_unicode_string("¾"); } + + /* Maths */ + SEQ_THREE_KEYS(KC_M, KC_U, KC_L) { + send_unicode_string("×"); } + SEQ_THREE_KEYS(KC_D, KC_I, KC_V) { + send_unicode_string("÷"); } + SEQ_TWO_KEYS(KC_P, KC_M) { + send_unicode_string("±"); } + SEQ_THREE_KEYS(KC_I, KC_N, KC_E) { + send_unicode_string("≠"); } + SEQ_THREE_KEYS(KC_A, KC_L, KC_M) { + send_unicode_string("≈"); } + SEQ_THREE_KEYS(KC_S, KC_Q, KC_U) { + send_unicode_string("√"); } + SEQ_THREE_KEYS(KC_I, KC_N, KC_F) { + send_unicode_string("∞"); } + SEQ_TWO_KEYS(KC_LABK, KC_LABK) { + send_unicode_string("≤"); } + SEQ_TWO_KEYS(KC_RABK, KC_RABK) { + send_unicode_string("≥"); } + + /* Greek */ + SEQ_TWO_KEYS(KC_P, KC_I) { + send_unicode_string("π"); } + SEQ_THREE_KEYS(KC_P, KC_I, KC_I) { + send_unicode_string("Π"); } + + SEQ_THREE_KEYS(KC_O, KC_M, KC_E) { + send_unicode_string("ω"); } + SEQ_FOUR_KEYS(KC_O, KC_M, KC_E, KC_G) { + send_unicode_string("Ω"); } + + /* Icons */ + SEQ_THREE_KEYS(KC_F, KC_L, KC_A) { + send_unicode_string("⚡"); } + SEQ_THREE_KEYS(KC_S, KC_T, KC_A) { + send_unicode_string("⭐"); } + SEQ_THREE_KEYS(KC_S, KC_P, KC_A) { + send_unicode_string("✨"); } + SEQ_THREE_KEYS(KC_P, KC_O, KC_P) { + send_unicode_string("🎉"); } + SEQ_THREE_KEYS(KC_R, KC_E, KC_C) { + send_unicode_string("♻️"); } + SEQ_THREE_KEYS(KC_L, KC_O, KC_V) { + send_unicode_string("❤️"); } + SEQ_THREE_KEYS(KC_F, KC_I, KC_R) { + send_unicode_string("🔥"); } + SEQ_THREE_KEYS(KC_B, KC_O, KC_M) { + send_unicode_string("💣"); } + SEQ_FOUR_KEYS(KC_B, KC_O, KC_U, KC_M) { + send_unicode_string("💥"); } + SEQ_THREE_KEYS(KC_R, KC_O, KC_C) { + send_unicode_string("🚀"); } + SEQ_THREE_KEYS(KC_T, KC_E, KC_L) { + send_unicode_string("🔭"); } + SEQ_THREE_KEYS(KC_M, KC_A, KC_G) { + send_unicode_string("🔎"); } + SEQ_THREE_KEYS(KC_W, KC_A, KC_R) { + send_unicode_string("⚠️"); } + + SEQ_THREE_KEYS(KC_B, KC_U, KC_L) { + send_unicode_string("💡"); } + SEQ_FOUR_KEYS(KC_I, KC_N, KC_F, KC_O) { + send_unicode_string("ℹ️"); } + SEQ_THREE_KEYS(KC_G, KC_E, KC_A) { + send_unicode_string("⚙️"); } + SEQ_THREE_KEYS(KC_L, KC_I, KC_N) { + send_unicode_string("🔗"); } + SEQ_THREE_KEYS(KC_P, KC_I, KC_N) { + send_unicode_string("📌"); } + SEQ_FOUR_KEYS(KC_F, KC_L, KC_A, KC_G) { + send_unicode_string("🚩"); } + SEQ_THREE_KEYS(KC_B, KC_A, KC_L) { + send_unicode_string("🎈"); } + SEQ_THREE_KEYS(KC_G, KC_I, KC_F) { + send_unicode_string("🎁"); } + + SEQ_THREE_KEYS(KC_P, KC_E, KC_N) { + send_unicode_string("✏️"); } + SEQ_THREE_KEYS(KC_K, KC_E, KC_Y) { + send_unicode_string("🔑"); } + SEQ_THREE_KEYS(KC_B, KC_O, KC_X) { + send_unicode_string("🧰"); } + + SEQ_TWO_KEYS(KC_O, KC_K) { + send_unicode_string("👌"); } + SEQ_THREE_KEYS(KC_O, KC_W, KC_D) { + send_unicode_string("⛔"); } + + SEQ_ONE_KEY(KC_V) { + send_unicode_string("✓"); } + SEQ_TWO_KEYS(KC_V, KC_B) { + send_unicode_string("☑"); } + SEQ_TWO_KEYS(KC_V, KC_G) { + send_unicode_string("✅"); } + + SEQ_ONE_KEY(KC_X) { + send_unicode_string("✗"); } + SEQ_TWO_KEYS(KC_X, KC_B) { + send_unicode_string("☒"); } + SEQ_TWO_KEYS(KC_X, KC_G) { + send_unicode_string("❎"); } + SEQ_TWO_KEYS(KC_X, KC_R) { + send_unicode_string("❌"); } + + SEQ_ONE_KEY(KC_QUESTION) { + send_unicode_string("❔"); } + SEQ_ONE_KEY(KC_EXCLAIM) { + send_unicode_string("❕"); } + SEQ_TWO_KEYS(KC_QUESTION, KC_QUESTION) { + send_unicode_string("❓"); } + SEQ_TWO_KEYS(KC_EXCLAIM, KC_EXCLAIM) { + send_unicode_string("❗"); } + + SEQ_THREE_KEYS(KC_C, KC_O, KC_F) { + send_unicode_string("☕"); } + SEQ_THREE_KEYS(KC_U, KC_M, KC_B) { + send_unicode_string("☔"); } + + SEQ_THREE_KEYS(KC_L, KC_O, KC_L) { + send_unicode_string("😀"); } + SEQ_THREE_KEYS(KC_M, KC_D, KC_R) { + send_unicode_string("🤣"); } + SEQ_THREE_KEYS(KC_K, KC_I, KC_S) { + send_unicode_string("😙"); } + SEQ_THREE_KEYS(KC_A, KC_N, KC_G) { + send_unicode_string("😇"); } + SEQ_THREE_KEYS(KC_G, KC_L, KC_A) { + send_unicode_string("😎"); } + SEQ_THREE_KEYS(KC_A, KC_N, KC_G) { + send_unicode_string("🤬"); } + SEQ_THREE_KEYS(KC_F, KC_E, KC_A) { + send_unicode_string("😱"); } + SEQ_THREE_KEYS(KC_N, KC_E, KC_U) { + send_unicode_string("😐"); } + SEQ_THREE_KEYS(KC_T, KC_H, KC_I) { + send_unicode_string("🤔"); } + SEQ_THREE_KEYS(KC_Z, KC_I, KC_P) { + send_unicode_string("🤐"); } + SEQ_THREE_KEYS(KC_S, KC_U, KC_R) { + send_unicode_string("😯"); } + SEQ_THREE_KEYS(KC_R, KC_O, KC_L) { + send_unicode_string("🙄"); } + SEQ_THREE_KEYS(KC_M, KC_O, KC_O) { + send_unicode_string("🌝"); } + SEQ_THREE_KEYS(KC_H, KC_U, KC_G) { + send_unicode_string("🫂"); } + + SEQ_THREE_KEYS(KC_H, KC_E, KC_N) { + send_unicode_string("🐔"); } + SEQ_THREE_KEYS(KC_R, KC_O, KC_O) { + send_unicode_string("🐓"); } + SEQ_THREE_KEYS(KC_D, KC_U, KC_C) { + send_unicode_string("🦆"); } + SEQ_THREE_KEYS(KC_P, KC_E, KC_A) { + send_unicode_string("🦚"); } + SEQ_THREE_KEYS(KC_B, KC_I, KC_R) { + send_unicode_string("🐦"); } + + /* Subscript / superscript */ + SEQ_THREE_KEYS(KC_U, KC_P, KC_F) { + send_unicode_string("⁰"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_F) { + send_unicode_string("₀"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_C) { + send_unicode_string("¹"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_C) { + send_unicode_string("₁"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_G) { + send_unicode_string("²"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_G) { + send_unicode_string("₂"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_H) { + send_unicode_string("³"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_H) { + send_unicode_string("₃"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_T) { + send_unicode_string("⁴"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_T) { + send_unicode_string("₄"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_S) { + send_unicode_string("⁵"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_S) { + send_unicode_string("₅"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_R) { + send_unicode_string("⁶"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_R) { + send_unicode_string("₆"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_P) { + send_unicode_string("⁷"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_P) { + send_unicode_string("₇"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_D) { + send_unicode_string("⁸"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_D) { + send_unicode_string("₈"); } + SEQ_THREE_KEYS(KC_U, KC_P, KC_L) { + send_unicode_string("⁹"); } + SEQ_THREE_KEYS(KC_D, KC_N, KC_L) { + send_unicode_string("₉"); } + + }; +} diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keycodes.h b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keycodes.h new file mode 100644 index 0000000000..b90b28fda4 --- /dev/null +++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keycodes.h @@ -0,0 +1,44 @@ +// Copyright 2023 Florent Linguenheld (@FLinguenheld) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +enum layers { + _BASE, + _NUMERIC, + _ARROWS, + _MOUSE, + _ADJUST, + _FN, + _LEFT_HAND, +}; + +enum custom_keys { + UNICODE = SAFE_RANGE, // Shortcut to write unicodes, see numeric layer + + /* See auto-shift */ + CS_E_ACUTE, + + CS_A_GRAVE, + CS_E_GRAVE, + CS_I_GRAVE, + CS_O_GRAVE, + CS_U_GRAVE, + + CS_C_CEDILLA, + CS_AE, + CS_OE, + + CS_A_CIRCUMFLEX, + CS_E_CIRCUMFLEX, + CS_I_CIRCUMFLEX, + CS_O_CIRCUMFLEX, + CS_U_CIRCUMFLEX, + + CS_A_DIAERESIS, + CS_E_DIAERESIS, + CS_I_DIAERESIS, + CS_O_DIAERESIS, + CS_U_DIAERESIS, + CS_Y_DIAERESIS, +}; diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keymap.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keymap.c new file mode 100644 index 0000000000..50fb7909f3 --- /dev/null +++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keymap.c @@ -0,0 +1,133 @@ +/* Copyright 2023 Florent Linguenheld (@FLinguenheld) + * + * 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 QMK_KEYBOARD_H +#include "keycodes.h" + + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + + /* Macros */ + switch (keycode) { + + case UNICODE: + if (record->event.pressed) { + register_code(KC_LCTL); + register_code(KC_LSFT); + tap_code16(KC_U); + } else { + unregister_code(KC_LCTL); + unregister_code(KC_LSFT); + } + break; + } + + return true; +} + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + + [_BASE] = LAYOUT( + //|---------------+---------------+---------------+---------------+---------------| |---------------+---------------+---------------+---------------+---------------| + GUI_T(KC_ESC) , KC_B , KC_O , KC_W , KC_BSPC , KC_J , KC_P , KC_D , KC_L , KC_F , + //|---------------+---------------+---------------+---------------+---------------| |---------------+---------------+---------------+---------------+---------------| + KC_A , KC_I , KC_E , KC_U , KC_TAB , KC_V , KC_T , KC_S , KC_R , KC_N , + //|---------------+---------------+---------------+---------------+---------------| |---------------+---------------+---------------+---------------+---------------| + KC_LALT , KC_X , KC_Q , KC_Y , KC_K , KC_Z , KC_C , KC_G |