mirrors/qmk_userspace
1
0
Fork 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2026-03-11 02:30:22 -04:00
Code Issues Projects Releases Packages Wiki Activity

Migrated to QKekos's macros

Browse source
This commit is contained in:
Matt Skalecki 2024-02-09 12:03:24 -05:00
commit 4dbb782522
13 changed files with 578 additions and 343 deletions
Download patch file Download diff file Expand all files Collapse all files

6
keyboards/moonlander/keymaps/ikcelaks/__init__.h Normal file
View file

@ -0,0 +1,6 @@
#pragma once
#include QMK_KEYBOARD_H
#include "general/custom_keys.h"
#include "magic_sturdy/__init__.h"

13
keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h Normal file
View file

@ -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,
};

357
keyboards/moonlander/keymaps/ikcelaks/keymap.c
View file

@ -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;

49
keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h Normal file
View file

@ -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)

177
keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.c Normal file
View file

@ -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;
// }

32
keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.h Normal file
View file

@ -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

250
keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c Normal file
View file

@ -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;
}
}

7
keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.h Normal file
View file

@ -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);

4
keyboards/moonlander/keymaps/ikcelaks/rules.mk
View file

@ -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

5
users/ikcelaks/ikcelaks.c Normal file
View file

@ -0,0 +1,5 @@
#include "ikcelaks.h"
void my_custom_function(void) {
}

8
users/ikcelaks/ikcelaks.h Normal file
View file

@ -0,0 +1,8 @@
#ifndef USERSPACE
#define USERSPACE
#include "quantum.h"
void my_custom_function(void);
#endif

14
users/ikcelaks/readme.md Normal file
View file

@ -0,0 +1,14 @@
Copyright <year> <name> <email> @<github_username>
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/>.

1
users/ikcelaks/rules.mk Normal file
View file

@ -0,0 +1 @@
SRC += ikcelaks.c