From 4dbb782522c4bd5bf4bdef4d596cf525f8c60a58 Mon Sep 17 00:00:00 2001 From: Matt Skalecki Date: Fri, 9 Feb 2024 12:03:24 -0500 Subject: [PATCH] Migrated to QKekos's macros --- .../moonlander/keymaps/ikcelaks/__init__.h | 6 + .../keymaps/ikcelaks/general/custom_keys.h | 13 + .../moonlander/keymaps/ikcelaks/keymap.c | 357 +----------------- .../keymaps/ikcelaks/magic_sturdy/__init__.h | 49 +++ .../keymaps/ikcelaks/magic_sturdy/general.c | 177 +++++++++ .../keymaps/ikcelaks/magic_sturdy/general.h | 32 ++ .../ikcelaks/magic_sturdy/magic_keys.c | 250 ++++++++++++ .../ikcelaks/magic_sturdy/magic_keys.h | 7 + .../moonlander/keymaps/ikcelaks/rules.mk | 4 + users/ikcelaks/ikcelaks.c | 5 + users/ikcelaks/ikcelaks.h | 8 + users/ikcelaks/readme.md | 14 + users/ikcelaks/rules.mk | 1 + 13 files changed, 579 insertions(+), 344 deletions(-) create mode 100644 keyboards/moonlander/keymaps/ikcelaks/__init__.h create mode 100644 keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h create mode 100644 keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h create mode 100644 keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.c create mode 100644 keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.h create mode 100644 keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c create mode 100644 keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.h create mode 100644 users/ikcelaks/ikcelaks.c create mode 100644 users/ikcelaks/ikcelaks.h create mode 100644 users/ikcelaks/readme.md create mode 100644 users/ikcelaks/rules.mk diff --git a/keyboards/moonlander/keymaps/ikcelaks/__init__.h b/keyboards/moonlander/keymaps/ikcelaks/__init__.h new file mode 100644 index 00000000..abbb81ad --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/__init__.h @@ -0,0 +1,6 @@ +#pragma once + +#include QMK_KEYBOARD_H + +#include "general/custom_keys.h" +#include "magic_sturdy/__init__.h" diff --git a/keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h b/keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h new file mode 100644 index 00000000..b5c9a807 --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h @@ -0,0 +1,13 @@ +#pragma once +#include "../__init__.h" + +enum custom_keycodes { + US_MAG1 = SAFE_RANGE, + US_MAG2, + US_MAG3, + US_MAG4, + // C_MAG_2, + // C_MAG_3, + MK_DUND, + MG_QUOT_S, +}; diff --git a/keyboards/moonlander/keymaps/ikcelaks/keymap.c b/keyboards/moonlander/keymaps/ikcelaks/keymap.c index 01e694da..9ad06344 100644 --- a/keyboards/moonlander/keymaps/ikcelaks/keymap.c +++ b/keyboards/moonlander/keymaps/ikcelaks/keymap.c @@ -18,7 +18,7 @@ -#include QMK_KEYBOARD_H +#include "__init__.h" #define KC_MAC_UNDO LGUI(KC_Z) #define KC_MAC_CUT LGUI(KC_X) @@ -38,7 +38,6 @@ #define SE_SECT_MAC ALGR(KC_6) #define MOON_LED_LEVEL LED_LEVEL -#define C_MAGIC QK_AREP #define C_GUI_ESC LGUI_T(KC_ESC) #define C_RSFT_ENT RSFT_T(KC_ENT) #define C_LALT_ENT LALT_T(KC_ENT) @@ -52,35 +51,15 @@ enum layers { NAVI, // navigation }; -enum custom_keycodes { - C_MAG_2 = SAFE_RANGE, - C_MAG_3, - MK_DUND, - MG_ENT, - MG_MENT, - MG_ER, - MG_ES, - MG_UST, - MG_ON, - MG_ION, - MG_OA, - MG_SP_BUT, - MG_THE, - MG_EFORE, - MG_HICH, - MG_MLATIV, - MG_QUOT_S, -}; - // clang-format off const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { [BASE] = LAYOUT_moonlander( KC_DOT, KC_1, KC_2, KC_3, KC_4, KC_5, KC_EQL, KC_ASTR, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, - KC_TAB, KC_V, KC_M, KC_L, KC_C, KC_P, KC_DQUO, KC_PIPE, KC_B, C_MAGIC, KC_U, KC_O, KC_COMM, KC_BSLS, + KC_TAB, KC_V, KC_M, KC_L, KC_C, KC_P, KC_DQUO, KC_PIPE, KC_B, US_MAG1, KC_U, KC_O, KC_COMM, KC_BSLS, LCTL(KC_BSPC), KC_S, KC_T, KC_R, KC_D, KC_Y, KC_Q, KC_DLR, KC_F, KC_N, KC_E, KC_A, KC_I, C_RCTL_MINS, KC_LSFT, KC_X, KC_K, KC_J, KC_G, KC_W, KC_Z, KC_H, KC_QUOT, KC_QUES, KC_DOT, C_RSFT_ENT, KC_GRV, KC_LCTL, KC_LGUI, KC_ESC, TT(NAVI), C_LALT_ENT, C_GUI_ESC, C_S_T(KC_SLSH), KC_LALT, KC_LBRC, TT(MDIA), TT(SYMB), - KC_SPC, KC_BSPC, KC_DEL, OSL(SYMB), OSM(MOD_LSFT), QK_REP + KC_SPC, KC_BSPC, KC_DEL, OSL(SYMB), OSM(MOD_LSFT), US_MAG2 ), [SYMB] = LAYOUT_moonlander( _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, _______, _______, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, @@ -108,7 +87,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -const uint16_t PROGMEM combo_RT_12[] = { QK_REP, OSM(MOD_LSFT), COMBO_END}; +const uint16_t PROGMEM combo_RT_12[] = { US_MAG2, OSM(MOD_LSFT), COMBO_END}; const uint16_t PROGMEM combo_LB_IM[] = { KC_J, KC_G, COMBO_END}; const uint16_t PROGMEM combo_LB_MR[] = { KC_K, KC_J, COMBO_END}; const uint16_t PROGMEM combo_LB_RP[] = { KC_X, KC_K, COMBO_END}; @@ -121,12 +100,12 @@ const uint16_t PROGMEM combo_RB_IR[] = { KC_H, KC_QUES, COMBO_END}; combo_t key_combos[COMBO_COUNT] = { COMBO(combo_RT_12, OSL(SYMB)), COMBO(combo_LB_IM, KC_COLN), - COMBO(combo_LB_MR, C_MAG_2), - COMBO(combo_LB_RP, C_MAG_3), + COMBO(combo_LB_MR, US_MAG3), + COMBO(combo_LB_RP, US_MAG4), COMBO(combo_LB_IR, MG_QUOT_S), COMBO(combo_RB_IM, KC_SCLN), - COMBO(combo_RB_MR, C_MAG_2), - COMBO(combo_RB_RP, C_MAG_3), + COMBO(combo_RB_MR, US_MAG3), + COMBO(combo_RB_RP, US_MAG4), COMBO(combo_RB_IR, MG_QUOT_S), }; @@ -136,327 +115,17 @@ void keyboard_post_init_user(void) { rgb_matrix_enable(); } -bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* remembered_mods) { - switch (keycode) { - // Ignore Custom Magic Keys - case C_MAG_2: - case C_MAG_3: - return false; - case KC_A ... KC_Z: - if ((*remembered_mods & ~(MOD_MASK_SHIFT)) == 0) { - *remembered_mods &= ~MOD_MASK_SHIFT; - } - break; - } - - return true; -} - -uint16_t get_alt_repeat_key_keycode_user(uint16_t keycode, uint8_t mods) { - switch (keycode) { - case KC_C: - case KC_P: - case KC_D: - case KC_G: - case KC_Z: return KC_Y; - case KC_Y: return KC_P; - case KC_R: return KC_L; - case KC_K: return KC_S; - case KC_L: - case KC_S: return KC_K; - case KC_U: return KC_E; - case KC_E: return KC_U; - case KC_O: return KC_A; - case KC_A: return KC_O; - case KC_DOT: - if (mods & MOD_MASK_SHIFT) { - return KC_EQL; - } else { - return KC_BSLS; - } - case KC_COMM: - if (mods & MOD_MASK_SHIFT) { - return KC_EQL; - } else { - return MG_SP_BUT; - } - case KC_EQL: - case C_RCTL_MINS: - case KC_MINS: return KC_RABK; - case KC_Q: return MG_MLATIV; - case KC_H: return MG_OA; - case KC_I: return MG_ON; - case KC_N: return MG_ION; - case KC_V: return MG_ER; - case KC_X: return MG_ES; - case KC_M: return MG_ENT; - case KC_T: return MG_MENT; - case KC_J: return MG_UST; - case KC_B: return MG_EFORE; - case KC_W: return MG_HICH; - case KC_1 ... KC_0: return KC_DOT; - } - - return MG_THE; -} - -bool process_magic_key_2(uint16_t prev_keycode, uint8_t prev_mods) { - switch (prev_keycode) { - case KC_B: - SEND_STRING("ecome"); - return false; - case KC_F: - SEND_STRING("ollow"); - return false; - case KC_N: - SEND_STRING("eighbor"); - return false; - case KC_H: - SEND_STRING("owever"); - return false; - case KC_U: - SEND_STRING("pgrade"); - return false; - case KC_O: - SEND_STRING("ther"); - return false; - case KC_A: - SEND_STRING("lready"); - return false; - case KC_P: - SEND_STRING("sych"); - return false; - case KC_I: - SEND_STRING("'ll"); - return false; - case KC_K: - SEND_STRING("now"); - return false; - case KC_T: - SEND_STRING("hough"); - return false; - case KC_L: - SEND_STRING("ittle"); - return false; - case KC_M: - case KC_R: - SEND_STRING("ight"); - return false; - case KC_J: - SEND_STRING("udge"); - return false; - case KC_C: - SEND_STRING("ould"); - return false; - case KC_D: - SEND_STRING("evelop"); - return false; - case KC_G: - SEND_STRING("eneral"); - return false; - case KC_W: - SEND_STRING("here"); - return false; - case KC_S: - SEND_STRING("hould"); - return false; - case KC_DOT: - SEND_STRING("org"); - return false; - case KC_COMM: - SEND_STRING(" however"); - return false; - default: - SEND_STRING("'ll"); - return false; - } -} - -bool process_magic_key_3(uint16_t prev_keycode, uint8_t prev_mods) { - switch (prev_keycode) { - case KC_B: - SEND_STRING("etween"); - return false; - case KC_N: - SEND_STRING("umber"); - return false; - case KC_U: - SEND_STRING("pdate"); - return false; - case KC_A: - SEND_STRING("bout"); - return false; - case KC_W: - SEND_STRING("orld"); - return false; - case KC_G: - SEND_STRING("overn"); - return false; - case KC_P: - SEND_STRING("rogram"); - return false; - case KC_Q: - SEND_STRING("uestion"); - return false; - case KC_C: - SEND_STRING("rowd"); - return false; - case KC_S: - SEND_STRING("chool"); - return false; - case KC_T: - SEND_STRING("hrough"); - return false; - case KC_M: - SEND_STRING("anage"); - return false; - case KC_O: - SEND_STRING("xygen"); - return false; - case KC_I: - SEND_STRING("'m"); - return false; - case KC_E: - SEND_STRING("'re"); - return false; - case KC_DOT: - SEND_STRING("com"); - return false; - case KC_COMM: - SEND_STRING(" since"); - return false; - default: - return false; - } -} - bool process_record_user(uint16_t keycode, keyrecord_t *record) { + bool return_value; + + if (sturdy_pr(keycode, record, &return_value)) + return return_value; + if (record->event.pressed) { - int rep_count = get_repeat_key_count(); - if (rep_count < -1 && keycode != MG_UST) { - send_char('n'); - return false; - } switch (keycode) { - case C_MAG_2: - return process_magic_key_2(get_last_keycode(), get_last_mods()); - case C_MAG_3: - return process_magic_key_3(get_last_keycode(), get_last_mods()); case MK_DUND: SEND_STRING(SS_LSFT(SS_TAP(X_4)) SS_DELAY(100) SS_LSFT(SS_TAP(X_MINUS))); return false; - case MG_ENT: - SEND_STRING("ent"); - return false; - case MG_MENT: - SEND_STRING("ment"); - return false; - case MG_ER: - SEND_STRING("er"); - return false; - case MG_ES: - SEND_STRING("es"); - return false; - case MG_UST: - if (rep_count < -1) { - SEND_STRING("ment"); - } else { - SEND_STRING("ust"); - } - return false; - case MG_OA: - SEND_STRING("oa"); - return false; - case MG_ON: - SEND_STRING("on"); - return false; - case MG_ION: - SEND_STRING("ion"); - return false; - case MG_SP_BUT: - SEND_STRING(" but"); - return false; - case MG_THE: - SEND_STRING("the"); - return false; - case MG_EFORE: - SEND_STRING("efore"); - return false; - case MG_HICH: - SEND_STRING("hich"); - return false; - case MG_MLATIV: - SEND_STRING("mlativ"); - return false; - case MG_QUOT_S: - SEND_STRING("'s"); - return false; - } - - if (rep_count > 0) { - switch (keycode) { - case KC_BSPC: - case C_LCTL_BSPC: - case KC_DQUO: - case KC_LPRN: - case KC_SPC: - case KC_ENT: - case C_LALT_ENT: - case C_RSFT_ENT: - unregister_weak_mods(MOD_MASK_CSAG); - SEND_STRING("for"); - return false; - case KC_I: - unregister_weak_mods(MOD_MASK_CSAG); - SEND_STRING("ng"); - return false; - case KC_DOT: - case KC_QUES: - case KC_EXLM: - case KC_COLN: - case KC_SCLN: - unregister_weak_mods(MOD_MASK_CSAG); - send_char(' '); - add_oneshot_mods(MOD_MASK_SHIFT); - set_last_keycode(KC_SPC); - return false; - case KC_COMM: - unregister_weak_mods(MOD_MASK_CSAG); - SEND_STRING(" and"); - return false; - case KC_C: - unregister_weak_mods(MOD_MASK_CSAG); - send_char('k'); - return false; - case KC_A: - unregister_weak_mods(MOD_MASK_CSAG); - SEND_STRING("nd"); - return false; - case KC_N: - unregister_weak_mods(MOD_MASK_CSAG); - send_char('f'); - return false; - case KC_B: - unregister_weak_mods(MOD_MASK_CSAG); - SEND_STRING("ecause"); - return false; - case KC_W: - unregister_weak_mods(MOD_MASK_CSAG); - SEND_STRING("ould"); - return false; - case KC_Y: - unregister_weak_mods(MOD_MASK_CSAG); - if (rep_count > 2) { - SEND_STRING("ll"); - return false; - } - if (rep_count > 1) { - send_char('\''); - return false; - } - SEND_STRING("ou"); - return false; - } } } return true; diff --git a/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h new file mode 100644 index 00000000..72a2e804 --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h @@ -0,0 +1,49 @@ +// Originally from QKekos +#pragma once +#include "../__init__.h" + +#include "general.h" +#include "magic_keys.h" + +#define single_queue_check(p_key) queue(-1) == p_key +#define double_queue_check(pp_key, p_key) queue(-2) == pp_key && single_queue_check(p_key) +#define triple_queue_check(ppp_key, pp_key, p_key) queue(-3) == ppp_key && double_queue_check(pp_key, p_key) +#define quadruple_queue_check(pppp_key, ppp_key, pp_key, p_key) queue(-4) == pppp_key && triple_queue_check(ppp_key, pp_key, p_key) + +#define magic_case_core(trigger, condition, supplement) \ + case trigger: \ + if (condition) { \ + record_send_string(supplement); \ + return; \ + } \ + break + +#define magic_switch_core(trigger, body, index) \ + case trigger: \ + switch (queue(index)) { \ + body \ + } \ + break + +#define magic_case(trigger, supplement) \ + case trigger: \ + record_send_string(supplement); \ + return + +#define double_magic_switch(trigger, body) \ + magic_switch_core(trigger, body, -1) + +#define triple_magic_switch(trigger, body) \ + magic_switch_core(trigger, body, -2) + +#define double_magic_case(trigger, p_key, supplement) \ + magic_case_core(trigger, single_queue_check(p_key), supplement) + +#define triple_magic_case(trigger, pp_key, p_key, supplement) \ + magic_case_core(trigger, double_queue_check(pp_key, p_key), supplement) + +#define quadruple_magic_case(trigger, ppp_key, pp_key, p_key, supplement) \ + magic_case_core(trigger, triple_queue_check(ppp_key, pp_key, p_key), supplement) + +#define quintuple_magic_case(trigger, pppp_key, ppp_key, pp_key, p_key, supplement) \ + magic_case_core(trigger, quadruple_queue_check(pppp_key, ppp_key, pp_key, p_key), supplement) diff --git a/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.c b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.c new file mode 100644 index 00000000..c6a9f15b --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.c @@ -0,0 +1,177 @@ + +#include "../__init__.h" + +int mag1_key_count = 0; +int mag2_key_count = 0; +int mag3_key_count = 0; +int mag4_key_count = 0; +int last_key_pressed_time = 0; +int prev_key_time; + +int prev_keys_queue[PREV_KEYS_QUEUE_SIZE] = {KC_NO}; +deferred_token magic_timeout_token = INVALID_DEFERRED_TOKEN; + +uint32_t enqueue_space(uint32_t trigger_time, void *cb_arg) { + enqueue(KC_SPC); + return 0; +} + +void refresh_token(void) { + if (magic_timeout_token != INVALID_DEFERRED_TOKEN) + cancel_deferred_exec(magic_timeout_token); + + magic_timeout_token = defer_exec(MAGIC_KEY_TIMEOUT, enqueue_space, NULL); +} + +void record_send_string(const char *str) { + for (int i = 0; str[i] != '\0'; i++) { + if (65 <= str[i] && str[i] <= 90) enqueue(str[i] - 61); + else if (97 <= str[i] && str[i] <= 122) enqueue(str[i] - 93); + } + + SEND_STRING(str); +} + +void enqueue(int keycode) { + for (int i = 0; i < PREV_KEYS_QUEUE_SIZE - 1; i += 1) + prev_keys_queue[i] = prev_keys_queue[i + 1]; + + prev_keys_queue[PREV_KEYS_QUEUE_SIZE - 1] = keycode; +} + +void dequeue(void) { + set_last_keycode(prev_keys_queue[PREV_KEYS_QUEUE_SIZE - 1]); + + for (int i = PREV_KEYS_QUEUE_SIZE - 1; i > 0; i -= 1) + prev_keys_queue[i] = prev_keys_queue[i - 1]; + + prev_keys_queue[0] = KC_NO; +} + +void print_queue(void) { + uprintf("queue: "); + + for (int i = 0; i < PREV_KEYS_QUEUE_SIZE - 1; i += 1) + uprintf("%d, ", prev_keys_queue[i]); + + uprintf("\n"); +} + +uint16_t normalize_keycode(uint16_t keycode) { + if (IS_QK_MOD_TAP(keycode)) return QK_MOD_TAP_GET_TAP_KEYCODE(keycode); + if (IS_QK_LAYER_TAP(keycode)) return QK_LAYER_TAP_GET_TAP_KEYCODE(keycode); + + return keycode; +} + +bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* mods) { + keycode = normalize_keycode(keycode); + + switch (keycode) { + case KC_BSPC: + case KC_LEFT: + dequeue(); + return false; + } + + if ( + (*mods & MOD_MASK_CTRL) && + ((keycode == KC_BSPC && record->tap.count) || (keycode == KC_BSPC)) + ) keycode = KC_SPC; + + switch (keycode) { + case KC_ENT: + case KC_TAB: + case KC_BSPC: + case KC_DQUO: + case KC_LPRN: + case KC_SPC: + keycode = KC_SPC; + break; + + case KC_A ... KC_Z: + if ((*mods & ~(MOD_MASK_SHIFT)) == 0) { + *mods &= ~MOD_MASK_SHIFT; + } + break; + + case US_MAG1: + case US_MAG2: + case US_MAG3: + case US_MAG4: + return false; + } + + enqueue(keycode); + print_queue(); + return true; +} + +bool sturdy_pr(uint16_t keycode, keyrecord_t *record, bool *return_value) { + *return_value = false; + prev_key_time = last_key_pressed_time; + + if (record->event.pressed) { + last_key_pressed_time = timer_read(); + refresh_token(); + + if (keycode != US_MAG1) mag1_key_count = 0; + else mag1_key_count += 1; + + if (keycode != US_MAG2) mag2_key_count = 0; + else mag2_key_count += 1; + + if (keycode != US_MAG4) mag3_key_count = 0; + else mag3_key_count += 1; + + if (keycode != US_MAG4) mag4_key_count = 0; + else mag4_key_count += 1; + } + + switch (keycode) { + case US_MAG1: + if (record->event.pressed) + process_magic_key_1(); + + return true; + + case US_MAG2: + if (record->event.pressed) + process_magic_key_2(); + + return true; + + case US_MAG3: + if (record->event.pressed) + process_magic_key_3(); + + return true; + + case US_MAG4: + if (record->event.pressed) + process_magic_key_4(); + + return true; + + // case KC_B: + // case KC_Z: + // case KC_F: + // return process_double_tap(keycode, record); + } + + return false; +} + +// bool process_double_tap(uint16_t keycode, keyrecord_t *record) { +// if ( +// !record->event.pressed || +// highest_layer != STURDY || +// queue(-2) != keycode || +// timer_elapsed(prev_key_time) > (get_tapping_term(keycode, NULL) + 50) +// ) return false; + +// dequeue(); +// process_magic_key(); + +// return true; +// } diff --git a/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.h b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.h new file mode 100644 index 00000000..4173b285 --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.h @@ -0,0 +1,32 @@ +// Originally from QKekos + +#pragma once +#include "../__init__.h" + +#define PREV_KEYS_QUEUE_SIZE 10 +#define MAGIC_KEY_TIMEOUT 1500 + +bool sturdy_pr(uint16_t keycode, keyrecord_t *record, bool *return_value); +bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* mods); +bool process_double_tap(uint16_t keycode, keyrecord_t *record); +void record_send_string(const char *str); +void enqueue(int keycode); +void dequeue(void); +void print_queue(void); + +uint32_t enqueue_space(uint32_t trigger_time, void *cb_arg); +void refresh_token(void); + +extern int prev_keys_queue[]; +extern int mag1_key_count; +extern int mag2_key_count; +extern int mag3_key_count; +extern int mag4_key_count; +extern int last_key_pressed_time; + +#define queue(i) prev_keys_queue[PREV_KEYS_QUEUE_SIZE + i] + +#define record_case(symbol, keycode) \ + case symbol: \ + enqueue(keycode); \ + continue diff --git a/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c new file mode 100644 index 00000000..44f46289 --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c @@ -0,0 +1,250 @@ + +#include "../__init__.h" + +void process_magic_key_1(void) { + if (mag1_key_count >= 2) { + switch (queue(-4)) { + quadruple_magic_case(KC_SPC, KC_A, KC_L, KC_R, "eady"); + quadruple_magic_case(KC_J, KC_U, KC_D, KC_G, "ment"); + } + + switch (queue(-3)) { + default: record_send_string("n"); return; + } + } + + switch (queue(-5)) { + quintuple_magic_case(KC_B, KC_A, KC_L, KC_L, KC_I, "st"); + } + + switch (queue(-4)) { + quadruple_magic_case(KC_A, KC_B, KC_E, KC_T, "ment"); + } + + switch (queue(-3)) { + triple_magic_switch(KC_SPC, + double_magic_switch(KC_A, + magic_case(KC_L, "r"); + magic_case(KC_N, "other"); + ); + + double_magic_switch(KC_E, + magic_case(KC_D, "ge"); + magic_case(KC_X, "ample"); + ); + + double_magic_case(KC_U, KC_S, "e"); + double_magic_case(KC_T, KC_I, "me"); + double_magic_case(KC_I, KC_N, "form"); + ); + + triple_magic_switch(KC_B, + double_magic_switch(KC_E, + magic_case(KC_T, "ween"); + magic_case(KC_L, "ieve"); + ); + + double_magic_case(KC_U, KC_D, "ge"); + ); + + triple_magic_switch(KC_V, + double_magic_switch(KC_A, + magic_case(KC_R, "ious"); + ); + + double_magic_case(KC_I, KC_D, "eo"); + ); + + triple_magic_switch(KC_R, + double_magic_case(KC_I, KC_D, "ge"); + double_magic_case(KC_E, KC_D, "ge"); + ); + + triple_magic_switch(KC_S, + double_magic_case(KC_Y, KC_S, "tem"); + ); + + triple_magic_switch(KC_G, + double_magic_case(KC_E, KC_N, "ious"); + ); + + triple_magic_switch(KC_D, + double_magic_case(KC_I, KC_F, "feren"); + double_magic_case(KC_E, KC_F, "inite"); + ); + + triple_magic_switch(KC_L, + double_magic_case(KC_E, KC_D, "ge"); + double_magic_case(KC_L, KC_I, "on"); + ); + + triple_magic_case(KC_J, KC_U, KC_D, "g"); + triple_magic_case(KC_O, KC_B, KC_V, "ious"); + triple_magic_case(KC_H, KC_I, KC_L, "arious"); + } + + switch (queue(-2)) { + double_magic_switch(KC_SPC, + magic_case(KC_T, "han"); + magic_case(KC_L, "ittle"); + ); + + double_magic_switch(KC_P, + magic_case(KC_L, "y"); + magic_case(KC_A, "ge"); + magic_case(KC_E, "ople"); + magic_case(KC_R, "evious"); + ); + + double_magic_case(KC_I, KC_C, "k"); + double_magic_case(KC_C, KC_Y, "c"); + double_magic_case(KC_A, KC_C, "k"); + double_magic_case(KC_E, KC_C, "k"); + double_magic_case(KC_D, KC_A, "y"); + double_magic_case(KC_B, KC_E, "en"); + double_magic_case(KC_S, KC_O, "me"); + double_magic_case(KC_L, KC_I, "st"); + } + + switch (queue(-1)) { + magic_case(KC_SPC, "the"); + + magic_case(KC_V, "er"); + magic_case(KC_S, "k"); + magic_case(KC_X, "es"); + + magic_case(KC_M, "ent"); + magic_case(KC_T, "ment"); + magic_case(KC_K, "s"); + + magic_case(KC_L, "k"); + magic_case(KC_R, "l"); + magic_case(KC_J, "ust"); + + magic_case(KC_C, "y"); + magic_case(KC_D, "y"); + magic_case(KC_G, "y"); + magic_case(KC_P, "y"); + magic_case(KC_Y, "p"); + magic_case(KC_W, "hich"); + magic_case(KC_Q, "uestion"); + + magic_case(KC_B, "efore"); + magic_case(KC_F, "irst"); + magic_case(KC_Z, "one"); + // US_MAG1 + magic_case(KC_N, "ion"); + magic_case(KC_H, "owever"); + + magic_case(KC_U, "e"); + magic_case(KC_E, "u"); + // KC_QUOT + + magic_case(KC_O, "a"); + magic_case(KC_A, "b"); + // KC_QUES + + magic_case(KC_COMM, " but"); + magic_case(KC_I, "on"); + magic_case(KC_DOT, "\\"); + } +} + +void process_magic_key_2(void) { + switch (queue(-3)) { + triple_magic_switch(KC_SPC, + double_magic_case(KC_A, KC_B, "out"); + double_magic_case(KC_O, KC_X, "ygen"); + ); + + triple_magic_case(KC_A, KC_N, KC_Y, "way"); + // triple_magic_case(KC_C, KC_A, KC_P, "able"); + // triple_magic_case(KC_U, KC_N, KC_I, "versity"); + } + + switch (queue(-2)) { + double_magic_switch(KC_SPC, + magic_case(KC_I, "ncrease"); + magic_case(KC_B, "ecause"); + ); + + double_magic_case(KC_F, KC_R, "om"); + } + + switch (queue(-1)) { + magic_case(KC_SPC, "for"); + magic_case(KC_A, "nd"); + magic_case(KC_X, "er"); + magic_case(KC_I, "ng"); + magic_case(KC_Y, "ou"); + magic_case(KC_Q, "ui"); + magic_case(KC_J, "oin"); + magic_case(KC_W, "ould"); + magic_case(KC_C, "k"); + magic_case(KC_N, "f"); + case KC_COMMA: + record_send_string(" and"); + return; + case KC_DOT: + case KC_QUES: + case KC_EXLM: + case KC_COLN: + case KC_SCLN: + unregister_weak_mods(MOD_MASK_CSAG); + send_char(' '); + add_oneshot_mods(MOD_MASK_SHIFT); + enqueue(KC_SPC); + return; + default: tap_code16(queue(-1)); enqueue(queue(-1)); + } +} + +void process_magic_key_3(void) { + switch (queue(-1)) { + magic_case(KC_B, "ecome"); + magic_case(KC_F, "ollow"); + magic_case(KC_N, "eighbor"); + magic_case(KC_H, "owever"); + magic_case(KC_U, "pgrade"); + magic_case(KC_O, "ther"); + magic_case(KC_A, "lready"); + magic_case(KC_P, "sych"); + magic_case(KC_I, "'ll"); + magic_case(KC_K, "now"); + magic_case(KC_T, "hough"); + magic_case(KC_L, "ight"); + magic_case(KC_M, "ight"); + magic_case(KC_R, "ight"); + magic_case(KC_J, "udge"); + magic_case(KC_C, "ould"); + magic_case(KC_D, "evelop"); + magic_case(KC_G, "eneral"); + magic_case(KC_W, "here"); + magic_case(KC_S, "hould"); + magic_case(KC_DOT, "org"); + magic_case(KC_COMM, " however"); + default: return; + } +} + +void process_magic_key_4(void) { + switch (queue(-1)) { + magic_case(KC_B, "etween"); + magic_case(KC_N, "umber"); + magic_case(KC_U, "pdate"); + magic_case(KC_O, "ught"); + magic_case(KC_A, "bout"); + magic_case(KC_P, "rogram"); + magic_case(KC_I, "'m"); + magic_case(KC_T, "hrough"); + magic_case(KC_M, "anage"); + magic_case(KC_C, "rowd"); + magic_case(KC_G, "overn"); + magic_case(KC_W, "orld"); + magic_case(KC_S, "chool"); + magic_case(KC_E, "'re"); + magic_case(KC_DOT, "com"); + magic_case(KC_COMM, " since"); + default: return; + } +} diff --git a/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.h b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.h new file mode 100644 index 00000000..5edd796e --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.h @@ -0,0 +1,7 @@ +#pragma once +#include "../__init__.h" + +void process_magic_key_1(void); +void process_magic_key_2(void); +void process_magic_key_3(void); +void process_magic_key_4(void); diff --git a/keyboards/moonlander/keymaps/ikcelaks/rules.mk b/keyboards/moonlander/keymaps/ikcelaks/rules.mk index 304edbc5..224b341f 100644 --- a/keyboards/moonlander/keymaps/ikcelaks/rules.mk +++ b/keyboards/moonlander/keymaps/ikcelaks/rules.mk @@ -5,3 +5,7 @@ COMMAND_ENABLE = no SPACE_CADET_ENABLE = no COMBO_ENABLE = yes REPEAT_KEY_ENABLE = yes +DEFERRED_EXEC_ENABLE = yes + +SRC += magic_sturdy/general.c +SRC += magic_sturdy/magic_keys.c diff --git a/users/ikcelaks/ikcelaks.c b/users/ikcelaks/ikcelaks.c new file mode 100644 index 00000000..31277157 --- /dev/null +++ b/users/ikcelaks/ikcelaks.c @@ -0,0 +1,5 @@ +#include "ikcelaks.h" + +void my_custom_function(void) { + +} diff --git a/users/ikcelaks/ikcelaks.h b/users/ikcelaks/ikcelaks.h new file mode 100644 index 00000000..f7c79902 --- /dev/null +++ b/users/ikcelaks/ikcelaks.h @@ -0,0 +1,8 @@ +#ifndef USERSPACE +#define USERSPACE + +#include "quantum.h" + +void my_custom_function(void); + +#endif \ No newline at end of file diff --git a/users/ikcelaks/readme.md b/users/ikcelaks/readme.md new file mode 100644 index 00000000..fdea33b6 --- /dev/null +++ b/users/ikcelaks/readme.md @@ -0,0 +1,14 @@ +Copyright @ + +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 . \ No newline at end of file diff --git a/users/ikcelaks/rules.mk b/users/ikcelaks/rules.mk new file mode 100644 index 00000000..9ffd9520 --- /dev/null +++ b/users/ikcelaks/rules.mk @@ -0,0 +1 @@ +SRC += ikcelaks.c