diff --git a/.gitignore b/.gitignore index ec5cfa2b..800a4e2c 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,8 @@ *.hex *.bin *.uf2 + +# clangd +compile_commands.json +.clangd/ +.cache/ 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/config.h b/keyboards/moonlander/keymaps/ikcelaks/config.h new file mode 100644 index 00000000..814bbccf --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/config.h @@ -0,0 +1,25 @@ +/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> + * Copyright 2020 Jack Humbert + * Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) + * + * 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 . + */ + +#pragma once + +#define ORYX_CONFIGURATOR + +// User Added +#define COMBO_COUNT 10 +#define TAPPING_TOGGLE 2 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..1eb787e7 --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h @@ -0,0 +1,11 @@ +#pragma once +#include "../__init__.h" + +enum custom_keycodes { + US_MAG1 = SAFE_RANGE, + US_MAG2, + US_MAG3, + US_MAG4, + US_D_UND, + US_QUOT_S, +}; diff --git a/keyboards/moonlander/keymaps/ikcelaks/keymap.c b/keyboards/moonlander/keymaps/ikcelaks/keymap.c new file mode 100644 index 00000000..51712358 --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/keymap.c @@ -0,0 +1,135 @@ +/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> + * Copyright 2020 Jack Humbert + * Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) + * + * 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 . + */ + + + +#include "__init__.h" + +#define KC_MAC_UNDO LGUI(KC_Z) +#define KC_MAC_CUT LGUI(KC_X) +#define KC_MAC_COPY LGUI(KC_C) +#define KC_MAC_PASTE LGUI(KC_V) +#define KC_PC_UNDO LCTL(KC_Z) +#define KC_PC_CUT LCTL(KC_X) +#define KC_PC_COPY LCTL(KC_C) +#define KC_PC_PASTE LCTL(KC_V) +#define ES_LESS_MAC KC_GRV +#define ES_GRTR_MAC LSFT(KC_GRV) +#define ES_BSLS_MAC ALGR(KC_6) +#define NO_PIPE_ALT KC_GRV +#define NO_BSLS_ALT KC_EQUAL +#define LSA_T(kc) MT(MOD_LSFT | MOD_LALT, kc) +#define BP_NDSH_MAC ALGR(KC_8) +#define SE_SECT_MAC ALGR(KC_6) +#define MOON_LED_LEVEL LED_LEVEL + +#define C_GUI_ESC LGUI_T(KC_ESC) +#define C_RSFT_ENT RSFT_T(KC_ENT) +#define C_LALT_ENT LALT_T(KC_ENT) +#define C_RCTL_MINS RCTL_T(KC_MINS) +#define C_LCTL_BSPC LCTL(KC_BSPC) + +enum layers { + BASE, // default layer + SYMB, // symbols + MDIA, // media keys + NAVI, // navigation +}; + +// 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, 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), 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, + _______, KC_HASH, KC_AMPR, KC_LCBR, KC_RCBR, KC_PIPE, _______, _______, KC_INS, KC_7, KC_8, KC_9, KC_PMNS, KC_F12, + _______, KC_AT, KC_EXLM, KC_LPRN, KC_RPRN, KC_TILD, _______, US_D_UND, KC_PPLS, KC_4, KC_5, KC_6, KC_PAST, _______, + _______, KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_GRV, KC_PSLS, KC_1, KC_2, KC_3, KC_PEQL, _______, + _______, _______, _______, _______, _______, _______, _______, KC_0, KC_PCMM, KC_PDOT, KC_PENT, _______, + _______, _______, _______, _______, _______, _______ + ), + [MDIA] = LAYOUT_moonlander( + _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, QK_BOOT, + _______, _______, _______, KC_MS_U, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, + _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPLY, + _______, _______, _______, _______, _______, _______, _______, _______, KC_MPRV, KC_MNXT, _______, _______, + XXXXXXX, _______, _______, KC_BTN1, KC_BTN2, _______, _______, KC_VOLU, KC_VOLD, KC_MUTE, _______, XXXXXXX, + _______, _______, _______, _______, _______, _______ + ), + [NAVI] = LAYOUT_moonlander( + XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, + XXXXXXX, KC_WH_L, KC_WH_R, LCTL(KC_F), LCTL(KC_R), KC_WH_U, XXXXXXX, XXXXXXX, KC_PGUP, KC_HOME, KC_UP, KC_END, KC_CAPS, XXXXXXX, + XXXXXXX, KC_LALT, KC_LGUI, KC_LSFT, KC_LCTL, KC_WH_D, XXXXXXX, XXXXXXX, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, LCTL(KC_DEL), XXXXXXX, + XXXXXXX, LCTL(KC_Z), LCTL(KC_X), LCTL(KC_C), LCTL(KC_V), LCTL(KC_A), KC_INS, KC_BSPC, XXXXXXX, KC_DEL, XXXXXXX, XXXXXXX, + XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, + _______, _______, _______, KC_ENT, KC_TAB, KC_SPC + ) +}; + +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}; +const uint16_t PROGMEM combo_LB_IR[] = { KC_K, KC_G, COMBO_END}; +const uint16_t PROGMEM combo_RB_IM[] = { KC_H, KC_QUOT, COMBO_END}; +const uint16_t PROGMEM combo_RB_MR[] = { KC_QUOT, KC_QUES, COMBO_END}; +const uint16_t PROGMEM combo_RB_RP[] = { KC_QUES, KC_DOT, COMBO_END}; +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, US_MAG3), + COMBO(combo_LB_RP, US_MAG4), + COMBO(combo_LB_IR, US_QUOT_S), + COMBO(combo_RB_IM, KC_SCLN), + COMBO(combo_RB_MR, US_MAG3), + COMBO(combo_RB_RP, US_MAG4), + COMBO(combo_RB_IR, US_QUOT_S), +}; + +extern rgb_config_t rgb_matrix_config; + +void keyboard_post_init_user(void) { + rgb_matrix_enable(); +} + +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) { + switch (keycode) { + case US_D_UND: + SEND_STRING(SS_LSFT(SS_TAP(X_4)) SS_DELAY(100) SS_LSFT(SS_TAP(X_MINUS))); + return false; + case US_QUOT_S: + SEND_STRING("'s"); + 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..f245b42f --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h @@ -0,0 +1,55 @@ +// 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 quadruple_magic_switch(trigger, body) \ + magic_switch_core(trigger, body, -3) + +#define quintuple_magic_switch(trigger, body) \ + magic_switch_core(trigger, body, -4) + +#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..f9d78c2c --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c @@ -0,0 +1,251 @@ + +#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_switch(KC_B, + quadruple_magic_case(KC_A, KC_L, KC_L, KC_I, "st"); + quadruple_magic_case(KC_L, KC_I, KC_V, KC_I, "on"); + ); + } + + switch (queue(-4)) { + quadruple_magic_case(KC_A, KC_B, KC_E, KC_T, "ment"); + quadruple_magic_case(KC_V, KC_I, KC_L, KC_I, "on"); + } + + 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_D, KC_A, "y"); + double_magic_case(KC_W, KC_A, "y"); + double_magic_case(KC_B, KC_E, "en"); + double_magic_case(KC_L, KC_I, "st"); + double_magic_case(KC_V, KC_I, "sion"); + } + + 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, get_last_mods() & MOD_MASK_SHIFT ? "=" : " but"); + magic_case(KC_I, "on"); + magic_case(KC_DOT, get_last_mods() & MOD_MASK_SHIFT ? "=" : "\\"); + magic_case(KC_MINS, ">"); + } +} + +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"); + double_magic_case(KC_O, KC_U, "ght"); + } + + 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"); + magic_case(KC_COMMA, " and"); + 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 new file mode 100644 index 00000000..224b341f --- /dev/null +++ b/keyboards/moonlander/keymaps/ikcelaks/rules.mk @@ -0,0 +1,11 @@ +# Set any rules.mk overrides for your specific keymap here. +# See rules at https://docs.qmk.fm/#/config_options?id=the-rulesmk-file +CONSOLE_ENABLE = no +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/qmk.json b/qmk.json index 3afc389f..ddd3a308 100644 --- a/qmk.json +++ b/qmk.json @@ -1,4 +1,6 @@ { "userspace_version": "1.0", - "build_targets": [] -} \ No newline at end of file + "build_targets": [ + ["moonlander", "ikcelaks"] + ] +} 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