diff options
Diffstat (limited to 'users')
71 files changed, 4075 insertions, 76 deletions
diff --git a/users/bcat/config.h b/users/bcat/config.h index f6be07bf6..6b132a429 100644 --- a/users/bcat/config.h +++ b/users/bcat/config.h @@ -22,6 +22,26 @@ */ #define TAPPING_FORCE_HOLD +#if defined(RGB_MATRIX_ENABLE) + /* Turn off per-key RGB when the host goes to sleep. */ + #define RGB_DISABLE_WHEN_USB_SUSPENDED true + + /* Keep per-key RGB increments consistent across keyboards. */ + #undef RGB_MATRIX_HUE_STEP + #undef RGB_MATRIX_SAT_STEP + #undef RGB_MATRIX_VAL_STEP + #undef RGB_MATRIX_SPD_STEP + + #define RGB_MATRIX_HUE_STEP 8 + #define RGB_MATRIX_SAT_STEP 17 + #define RGB_MATRIX_VAL_STEP 17 + #define RGB_MATRIX_SPD_STEP 17 + + /* Turn on additional RGB animations. */ + #define RGB_MATRIX_FRAMEBUFFER_EFFECTS + #define RGB_MATRIX_KEYPRESSES +#endif + #if defined(RGBLIGHT_ENABLE) /* Turn off RGB underglow when the host goes to sleep. */ #define RGBLIGHT_SLEEP diff --git a/users/csc027/csc027.c b/users/csc027/csc027.c new file mode 100644 index 000000000..de1bad6f2 --- /dev/null +++ b/users/csc027/csc027.c @@ -0,0 +1,53 @@ +#include "csc027.h" + +// Declare the strings in PROGMEM using the convenience macro +CUSTOM_MACROS(CUSTOM_DEF, CUSTOM_MACRO_STRING, SEMI_DELIM); + +static const char* const custom_macros[] PROGMEM = { + // Declare the pointer to the strings in PROGMEM + CUSTOM_MACROS(CUSTOM_VAR, DROP, COMMA_DELIM) +}; + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + switch(keycode) { + case LOWER: + if(record->event.pressed) { + layer_on(_LW); + } else { + layer_off(_LW); + } + update_tri_layer(_LW, _RS, _MS); + return false; + case RAISE: + if(record->event.pressed) { + layer_on(_RS); + } else { + layer_off(_RS); + } + update_tri_layer(_LW, _RS, _MS); + return false; + case (MC_first + 1)...(MC_last - 1): + if(record->event.pressed) { + send_string_P( +#if defined(__AVR__) + // The accessor here first reads from the pointer array that is located + // in PROGMEM. The pointer is taken and passed to the send_string_P + // function, which is aware of the difference between RAM and PROGMEM + // pointers. + (char*)pgm_read_word(&custom_macros[keycode - MC_first - 1]) +#else + // For non-AVR MCUs, the PROGMEM macro is defined as nothing. So, the strings are + // declared in RAM instead of flash. The send_string_P function, when compiled for + // non-AVR targets, uses a different definition of pgm_read_byte internally. This + // definition uses RAM pointers instead. This is why the raw pointer is passed for + // non-AVR MCUs. + custom_macros[keycode - MC_first - 1] +#endif + ); + return true; + } + return false; + default: + return true; + } +} diff --git a/users/csc027/csc027.h b/users/csc027/csc027.h new file mode 100644 index 000000000..96bf7dc0e --- /dev/null +++ b/users/csc027/csc027.h @@ -0,0 +1,29 @@ +#pragma once + +#include "quantum.h" +#include "defines.h" + +enum custom_keycodes { + // Layer Keycodes + LOWER = SAFE_RANGE, + RAISE, + + + MC_first, + + // Macro Keycodes + CUSTOM_MACROS(CUSTOM_ENUM, DROP, COMMA_DELIM), + + MC_last +}; + +enum custom_layers { + _QW = 0, // Qwerty + _RS, // Raise + _LW, // Lower + _MS, // Mouse + _GT, // Git + _CN, // Convenience + _GW, // Guild Wars 2 + _CS // Counter-Strike: Global Offensive +}; diff --git a/users/csc027/custom_audio.c b/users/csc027/custom_audio.c new file mode 100644 index 000000000..96e0e6602 --- /dev/null +++ b/users/csc027/custom_audio.c @@ -0,0 +1,17 @@ +#include "csc027.h" +#include "custom_audio.h" + +#if defined(AUDIO_ENABLE) + +float tone_on[][2] = SONG(E__NOTE(_G6)); +float tone_off[][2] = SONG(E__NOTE(_D5)); + +void on_usb_led_off(void) { + PLAY_SONG(tone_off); +} + +void on_usb_led_on(void) { + PLAY_SONG(tone_on); +} + +#endif diff --git a/users/csc027/custom_audio.h b/users/csc027/custom_audio.h new file mode 100644 index 000000000..daea1e652 --- /dev/null +++ b/users/csc027/custom_audio.h @@ -0,0 +1,8 @@ +#pragma once + +#if defined(AUDIO_ENABLE) + +void on_usb_led_off(void); +void on_usb_led_on(void); + +#endif diff --git a/users/csc027/custom_rgb.c b/users/csc027/custom_rgb.c new file mode 100644 index 000000000..000483b2a --- /dev/null +++ b/users/csc027/custom_rgb.c @@ -0,0 +1,25 @@ +#include "csc027.h" +#include "custom_rgb.h" + +#if defined(RGBLIGHT_ENABLE) + +void keyboard_post_init_user(void) { + rgblight_enable_noeeprom(); + rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT); + uint16_t user_hue = rgblight_get_hue(); + for (uint16_t i = 0; i < 256; ++i) { + rgblight_sethsv_noeeprom((i + user_hue) % 256, 255, 255); + wait_ms(5); + } + rgblight_sethsv_noeeprom(0, 0, 0); +} + +void on_usb_led_off(void) { + rgblight_sethsv_noeeprom(0, 0, rgblight_get_val() - 85); +} + +void on_usb_led_on(void) { + rgblight_sethsv_noeeprom(0, 0, rgblight_get_val() + 85); +} + +#endif diff --git a/users/csc027/custom_rgb.h b/users/csc027/custom_rgb.h new file mode 100644 index 000000000..47fdeb7b2 --- /dev/null +++ b/users/csc027/custom_rgb.h @@ -0,0 +1,9 @@ +#pragma once + +#if defined(RGBLIGHT_ENABLE) + +void keyboard_post_init_user(void); +void on_usb_led_off(void); +void on_usb_led_on(void); + +#endif diff --git a/users/csc027/defines.h b/users/csc027/defines.h new file mode 100644 index 000000000..4f52938f1 --- /dev/null +++ b/users/csc027/defines.h @@ -0,0 +1,270 @@ +#pragma once +#include "csc027.h" + +#define MC_RSFE RSFT_T(KC_ENT) // Right Shift on hold, Enter on tap +#define MC_LSEC LSFT_T(KC_ESC) // Left Shift on hold, Escape on tap + +#define ________________ KC_TRNS + +/* QWERTY Layer + * + * The basic layer of this keymap is a QWERTY layer. + * + * - Modifier keys more closely resemble a standard keyboard's layout. + * - There is a "Nxt L" function that cycles through the QWERTY and + * game layers. This has been implemented by hard coding the jump to the + * next layer in each of the layers using the TO() macro. Currently, the + * "Nxt L" function skips over the momentary layers (i.e., Mouse, Git, + * Lower, Raise, and Convenience layers). + * - There is a "Rst L" function that resets the current layer to the + * QWERTY layer. + * - The "Git" one shot function goes to the macro layer which has Git + * commands implemented. + * - The "Convc" momentary function goes to the Convenience layer which has a + * tenkey. Note: The tenkey will operate using the secondary functions if + * the Number Lock is not enabled (e.g., Left and Right instead of 4 and + * 6). + * - The Right Shift key also doubles as an Enter key if it is tapped rather + * than held. + * + * ,-----------------------------------. ,-----------------------------------. + * | Tab | Q | W | E | R | T | | Y | U | I | O | P |BkSpc| + * |-----------------------------------| |-----------------------------------| + * | Esc | A | S | D | F | G | | H | J | K | L | ; | ' | + * |-----------------------------------| |-----------------------------------| + * |Shift| Z | X | C | V | B | | N | M | , | . | / |Sf/En| + * |-----------------------------------| |-----------------------------------| + * |Cntrl|Super| Alt |Convc|Lower|Space| |Space|Raise| \ | Git |Nxt L|Rst L| + * `-----------------------------------' `-----------------------------------' + */ + +#define _____________________QWERTY_L1_____________________ KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T +#define _____________________QWERTY_L2_____________________ KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G +#define _____________________QWERTY_L3_____________________ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B +#define _____________________QWERTY_L4_____________________ KC_LCTL, KC_LGUI, KC_LALT, MO(_CN), LOWER, KC_SPC + +#define _____________________QWERTY_R1_____________________ KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC +#define _____________________QWERTY_R2_____________________ KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT +#define _____________________QWERTY_R3_____________________ KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, MC_RSFE +#define _____________________QWERTY_R4_____________________ KC_SPC, RAISE, KC_BSLS, OSL(_GT), TO(_GW), XXXXXXX + +/* Raise Layer + * + * The Raise layer accommodates the Home, End, Page Up, and Page Down keys + * in what would be the Vim arrow keys positions. This is done as opposed + * to using C-D, C-U, 0, $, and ^, because it would require a separate layer. + * + * - The top row has the shifted versions of the number row, rather than the + * numbers themselves. This is a change to have a mnemonic where shifted + * elements are on the Raise layer. This also makes it easy to use some of + * Vim style movement controls (e.g. $, %), but makes it harder for others + * (e.g. ^, (, )). Consider swapping the number row with the shifted number + * row if you do not care about the mnemonic. + * - The Left Brace, Right Brace, Underscore, and Plus keys have been moved + * from the right side to the left side. This will take some getting used + * to, as these keys are normally on the right side of the keyboard. An + * alternative would be to keep the keys on the right hand side just under + * the Parentheses. This would prevent the use of Vim arrow keys however. + * - The F keys have been laid across the bottom in the Raise layer, rather + * than the Lower layer to allow easy access to the Alt-F4 chord for + * Windows. When the F keys were put in the Lower layer, it made it hard + * to use this chord, as the Lower key, the Alt key, and the F4 key were + * all right next to each other. + * - A Delete key has been added in this layer to allow easy access to the + * Control-Alt-Delete login chord for Windows. + * + * ,-----------------------------------. ,-----------------------------------. + * | ~ | ! | @ | # | $ | % | | ^ | & | * | ( | ) | Del | + * |-----------------------------------| |-----------------------------------| + * | | _ | + | { | } | Caps| | Home| PgDn| PgUp| End | | | + * |-----------------------------------| |-----------------------------------| + * | | F1 | F2 | F3 | F4 | F5 | | F6 | F7 | F8 | F9 | F10 | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * `-----------------------------------' `-----------------------------------' + */ + +#define ______________________RAISE_L1_____________________ KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC +#define ______________________RAISE_L2_____________________ _______, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_CAPS +#define ______________________RAISE_L3_____________________ _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5 +#define ______________________RAISE_L4_____________________ _______, _______, _______, _______, _______, _______ + +#define ______________________RAISE_R1_____________________ KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_DELT +#define ______________________RAISE_R2_____________________ KC_HOME, KC_PGDN, KC_PGUP, KC_END, XXXXXXX, XXXXXXX +#define ______________________RAISE_R3_____________________ KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, _______ +#define ______________________RAISE_R4_____________________ _______, _______, _______, _______, XXXXXXX, XXXXXXX + +/* Lower Layer + * + * The lower layout scheme accommodates the Vim style arrow keys. + * + * - The arrow keys are in the normal Vim positions. + * - The Left Square Bracket, Right Square Bracket, Minus, and Equal keys + * have been moved from the right side to the left side. This will take + * some getting used to, as it is on the left rather than the right. + * - A Delete key has been added in this layer to allow easy access to the + * Control-Alt-Delete login chord for Windows. + * - The remaining F keys are in this layer. + * + * ,-----------------------------------. ,-----------------------------------. + * | ` | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | Del | + * |-----------------------------------| |-----------------------------------| + * | | - | = | [ | ] | | | Left| Down| Up |Right| | | + * |-----------------------------------| |-----------------------------------| + * | | F11 | F12 | | | | | | | | | | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * `-----------------------------------' `-----------------------------------' + */ + +#define ______________________LOWER_L1_____________________ KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5 +#define ______________________LOWER_L2_____________________ _______, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, XXXXXXX +#define ______________________LOWER_L3_____________________ _______, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX +#define ______________________LOWER_L4_____________________ _______, _______, _______, _______, _______, _______ + +#define ______________________LOWER_R1_____________________ KC_6, KC_7, KC_8, KC_9, KC_0, KC_DELT +#define ______________________LOWER_R2_____________________ KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, XXXXXXX, XXXXXXX +#define ______________________LOWER_R3_____________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______ +#define ______________________LOWER_R4_____________________ _______, _______, _______, _______, XXXXXXX, XXXXXXX + + +/* MIT Layout (Mouse) + * + * The mouse layer adds keys to use the keyboard like a mouse. + * + * ,-----------------------------------. ,-----------------------------------. + * | | | | | | | | | | | | | | + * |-----------------------------------| |-----------------------------------| + * | | | |Ms-Lc|Ms-Rc| | | Ms-L| Ms-D| Ms-U| Ms-R| | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * `-----------------------------------' `-----------------------------------' + */ + +#define ______________________MOUSE_L1_____________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX +#define ______________________MOUSE_L2_____________________ _______, XXXXXXX, XXXXXXX, KC_BTN1, KC_BTN2, XXXXXXX +#define ______________________MOUSE_L3_____________________ _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX +#define ______________________MOUSE_L4_____________________ _______, _______, _______, _______, _______, _______ + +#define ______________________MOUSE_R1_____________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX +#define ______________________MOUSE_R2_____________________ KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, XXXXXXX, XXXXXXX +#define ______________________MOUSE_R3_____________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______ +#define ______________________MOUSE_R4_____________________ _______, _______, _______, _______, XXXXXXX, XXXXXXX + +/* MIT Layout (Git) + * + * The macro layer that has common git commands. + * + * ,-----------------------------------. ,-----------------------------------. + * | |Chery| Show|Rebas|Reset| Tag | | | Pull| Init|Rmote| Push| | + * |-----------------------------------| |-----------------------------------| + * | | Add |Sttus| Diff|Fetch| Grep| |Stash| |ChkOt| Log | | | + * |-----------------------------------| |-----------------------------------| + * | | | |Comit| Move|Brnch| | |Merge| | | | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * `-----------------------------------' `-----------------------------------' + */ + +#define _______________________GIT_L1______________________ XXXXXXX, MC_cherrypick, MC_show, MC_rebase, MC_reset, MC_tag +#define _______________________GIT_L2______________________ _______, MC_add, MC_status, MC_diff, MC_fetch, MC_grep +#define _______________________GIT_L3______________________ _______, XXXXXXX, XXXXXXX, MC_commit, MC_mv, MC_branch +#define _______________________GIT_L4______________________ _______, _______, _______, _______, _______, _______ + +#define _______________________GIT_R1______________________ XXXXXXX, MC_pull, MC_init, MC_remote, MC_push, XXXXXXX +#define _______________________GIT_R2______________________ MC_stash, XXXXXXX, MC_checkout, MC_log, XXXXXXX, XXXXXXX +#define _______________________GIT_R3______________________ XXXXXXX, MC_merge, XXXXXXX, XXXXXXX, XXXXXXX, _______ +#define _______________________GIT_R4______________________ _______, _______, _______, _______, XXXXXXX, XXXXXXX + + +/* MIT Layout (Convenience) + * + * The Convenience layer adds miscellaneous chords to the keyboard. + * + * - The Number Lock key is physically in the same spot as the Caps Lock key + * in the raise layer. + * - There is also a Backspace Key for convenience. + * - There is a convenience macro to type the Control-Alt-Delete login chord for Windows. + * - There is a convenience macro to switch context from the Remote Desktop to the local + * machine in Windows. + * - There are convenience macros to switch between virtual desktops in Windows. + * - There are convenience macros to create and delete virtual desktops in Windows. + * + * ,-----------------------------------. ,-----------------------------------. + * | | |Insrt|ScrLk|PrtSc| | | | | | | |BkSpc| + * |-----------------------------------| |-----------------------------------| + * | | | App | LCAD|MRDCC|NmLck| |MVTDL|MVTDC|MVTDN|MVTDR| | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * |-----------------------------------| |-----------------------------------| + * | | | | | | | | | | | | | | + * `-----------------------------------' `-----------------------------------' + */ + +#define ___________________CONVENIENCE_L1__________________ XXXXXXX, XXXXXXX, KC_INS, KC_SLCK, KC_PSCR, XXXXXXX +#define ___________________CONVENIENCE_L2__________________ _______, XXXXXXX, KC_APP, MC_lcad, MC_rdcc, KC_NLCK +#define ___________________CONVENIENCE_L3__________________ _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX +#define ___________________CONVENIENCE_L4__________________ _______, _______, _______, _______, _______, _______ + +#define ___________________CONVENIENCE_R1__________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_BSPC +#define ___________________CONVENIENCE_R2__________________ MC_vtdl, MC_vtdc, MC_vtdn, MC_vtdr, XXXXXXX, XXXXXXX +#define ___________________CONVENIENCE_R3__________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______ +#define ___________________CONVENIENCE_R4__________________ _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX + +/* Convenience macros + * + * These are accelerator macros for simplifying declaration of PROGMEM strings + */ + +// Declare variable name +#define CUSTOM_VAR(VAR) mc_##VAR + +// Declare PROGMEM string using the variable name +#define CUSTOM_DEF(VAR) const char CUSTOM_VAR(VAR)[] PROGMEM = + +// Declare enum name +#define CUSTOM_ENUM(VAR) MC_##VAR + +#define CUSTOM_MACRO_STRING(X) X + +#define COMMA_DELIM(...) , +#define SEMI_DELIM(...) ; + +#define DROP(...) + +/* Keycode synchronization macros + * + * These macros help synchronize the keycodes between the string declaration, string pointer declaration, and enum order. + */ + + +#define CUSTOM_MACROS(CUSTOM_NAME, CUSTOM_STRING, CUSTOM_DELIM) \ + CUSTOM_NAME(add) CUSTOM_STRING("git add ") CUSTOM_DELIM() \ + CUSTOM_NAME(branch) CUSTOM_STRING("git branch ") CUSTOM_DELIM() \ + CUSTOM_NAME(checkout) CUSTOM_STRING("git checkout ") CUSTOM_DELIM() \ + CUSTOM_NAME(cherrypick) CUSTOM_STRING("git cherry-pick ") CUSTOM_DELIM() \ + CUSTOM_NAME(commit) CUSTOM_STRING("git commit -m \"\""SS_TAP(X_LEFT)) CUSTOM_DELIM() \ + CUSTOM_NAME(diff) CUSTOM_STRING("git diff ") CUSTOM_DELIM() \ + CUSTOM_NAME(fetch) CUSTOM_STRING("git fetch ") CUSTOM_DELIM() \ + CUSTOM_NAME(grep) CUSTOM_STRING("git grep ") CUSTOM_DELIM() \ + CUSTOM_NAME(log) CUSTOM_STRING("git log --decorate --oneline --graph ") CUSTOM_DELIM() \ + CUSTOM_NAME(init) CUSTOM_STRING("git init ") CUSTOM_DELIM() \ + CUSTOM_NAME(mv) CUSTOM_STRING("git mv ") CUSTOM_DELIM() \ + CUSTOM_NAME(merge) CUSTOM_STRING("git merge ") CUSTOM_DELIM() \ + CUSTOM_NAME(push) CUSTOM_STRING("git push ") CUSTOM_DELIM() \ + CUSTOM_NAME(pull) CUSTOM_STRING("git pull ") CUSTOM_DELIM() \ + CUSTOM_NAME(rebase) CUSTOM_STRING("git rebase ") CUSTOM_DELIM() \ + CUSTOM_NAME(remote) CUSTOM_STRING("git remote ") CUSTOM_DELIM() \ + CUSTOM_NAME(reset) CUSTOM_STRING("git reset ") CUSTOM_DELIM() \ + CUSTOM_NAME(show) CUSTOM_STRING("git show ") CUSTOM_DELIM() \ + CUSTOM_NAME(stash) CUSTOM_STRING("git stash ") CUSTOM_DELIM() \ + CUSTOM_NAME(status) CUSTOM_STRING("git status ") CUSTOM_DELIM() \ + CUSTOM_NAME(tag) CUSTOM_STRING("git tag ") CUSTOM_DELIM() \ + CUSTOM_NAME(rdcc) CUSTOM_STRING(SS_LCTL(SS_LALT(SS_TAP(X_HOME)))) CUSTOM_DELIM() \ + CUSTOM_NAME(lcad) CUSTOM_STRING(SS_LCTL(SS_LALT(SS_TAP(X_DELETE)))) CUSTOM_DELIM() \ + CUSTOM_NAME(vtdl) CUSTOM_STRING(SS_LCTL(SS_LGUI(SS_TAP(X_LEFT)))) CUSTOM_DELIM() \ + CUSTOM_NAME(vtdc) CUSTOM_STRING(SS_LCTL(SS_LGUI(SS_TAP(X_F4)))) CUSTOM_DELIM() \ + CUSTOM_NAME(vtdn) CUSTOM_STRING(SS_LCTL(SS_LGUI("d"))) CUSTOM_DELIM() \ + CUSTOM_NAME(vtdr) CUSTOM_STRING(SS_LCTL(SS_LGUI(SS_TAP(X_RIGHT)))) diff --git a/users/csc027/rules.mk b/users/csc027/rules.mk new file mode 100644 index 000000000..7e5d44e1c --- /dev/null +++ b/users/csc027/rules.mk @@ -0,0 +1,11 @@ +SRC += csc027.c + +ifeq ($(strip $(RGBLIGHT_ENABLE)), yes) + SRC += custom_rgb.c + SRC += usb_led.c +endif + +ifeq ($(strip $(AUDIO_ENABLE)), yes) + SRC += custom_audio.c + SRC += usb_led.c +endif diff --git a/users/csc027/usb_led.c b/users/csc027/usb_led.c new file mode 100644 index 000000000..1418e32ca --- /dev/null +++ b/users/csc027/usb_led.c @@ -0,0 +1,32 @@ +#include "csc027.h" +#include "usb_led.h" +#include "led.h" + +#if defined(RGBLIGHT_ENABLE) +# include "custom_rgb.h" +#elif defined(AUDIO_ENABLE) +# include "custom_audio.h" +#endif + +#if defined(AUDIO_ENABLE) || defined(RGBLIGHT_ENABLE) + +bool led_update_user(led_t usb_led) { + static led_t old_usb_led = { + .num_lock = false, + .caps_lock = false, + .scroll_lock = false + }; + + if(old_usb_led.caps_lock != usb_led.caps_lock) { + usb_led.caps_lock ? on_usb_led_on() : on_usb_led_off(); + } else if(old_usb_led.num_lock != usb_led.num_lock) { + usb_led.num_lock ? on_usb_led_on() : on_usb_led_off(); + } else if(old_usb_led.scroll_lock != usb_led.scroll_lock) { + usb_led.scroll_lock ? on_usb_led_on() : on_usb_led_off(); + } + old_usb_led = usb_led; + + return true; +} + +#endif diff --git a/users/csc027/usb_led.h b/users/csc027/usb_led.h new file mode 100644 index 000000000..7451b4695 --- /dev/null +++ b/users/csc027/usb_led.h @@ -0,0 +1,3 @@ +#pragma once + +bool led_update_user(led_t usb_led); diff --git a/users/curry/.gitignore b/users/curry/.gitignore new file mode 100644 index 000000000..c6df8c013 --- /dev/null +++ b/users/curry/.gitignore @@ -0,0 +1 @@ +secrets.c diff --git a/users/curry/LICENSE b/users/curry/LICENSE new file mode 100644 index 000000000..198ae45b2 --- /dev/null +++ b/users/curry/LICENSE @@ -0,0 +1,14 @@ +Copyright 2020 Akaash Suresh casa.akaash@gmail.com @CurryFurious + +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/>. diff --git a/users/curry/README.md b/users/curry/README.md new file mode 100644 index 000000000..70d6262d7 --- /dev/null +++ b/users/curry/README.md @@ -0,0 +1,30 @@ +# Information + +These is my userspace files, heavily influenced by @drashna's userspace structure. + +# Keyboards + +Main uses are for corne & lily58, supporting dfu bootloader (elite-c) + +## Split Common +Is compatible with split_common when the previous two keyboards update to them. + +If you want to use these keymaps with split common code, they are on my personal github fork: [CurryFurious/qmk_firmware](https://github.com/CurryFurious/qmk_firmware) + +Referenced PRs: #6260, #5998, #6001 + +## Keymaps +Keymap layout is similar between the two keyboards. Lily58 has a lot of open keys for custom keys as well. Keymap formatting is set up in the physical layout of the keyboard, so mapping keys should be easier. + +## Tap Dances + +Tap dances are enabled but none are defined, you can add them to [tapdances.c](tapdances.c). If not using tapdances, you can disable them in the keymaps. + +## RGB +RGB is implemented pretty much the same as @drashna. Only change is that I added the RGB code from the drashna's corne [keymap.c](../../keyboards/crkbd/keymaps/drashna/keymap.c), lines 313-383 into rgb_stuff.c. + +## OLED +Similarly to RGB, I moved all OLED code into [oled.c](oled.c) to better clear up the keymap.c file. I haven't experimented with the kyria's 128x64 pixel screen so it probably won't work as well with it yet. + +## Wrappers +Have implemented QWERTY, COLEMAK Mod DH, and DVORAK. Other macros are defined, some modified from drashna's. Drashna's [wrappers.h](../drashna/wrappers.h) has other layouts that you can copy in as you see fit, make sure to add them to the userspace_layers enum in [curry.h](curry.h) diff --git a/users/curry/config.h b/users/curry/config.h new file mode 100644 index 000000000..b982dab03 --- /dev/null +++ b/users/curry/config.h @@ -0,0 +1,111 @@ +#pragma once + +// Use custom magic number so that when switching branches, EEPROM always gets reset +#define EECONFIG_MAGIC_NUMBER (uint16_t)0x420 + +/* Set Polling rate to 1000Hz */ +#define USB_POLLING_INTERVAL_MS 1 + +#if defined(RGBLIGHT_ENABLE) +# undef RGBLIGHT_ANIMATIONS +# define RGBLIGHT_SLEEP +# define RGBLIGHT_EFFECT_BREATHING +# define RGBLIGHT_EFFECT_SNAKE +# define RGBLIGHT_EFFECT_KNIGHT +#endif // RGBLIGHT_ENABLE + +#if defined(RGB_MATRIX_ENABLE) +# define RGB_MATRIX_KEYPRESSES +# define RGB_MATRIX_FRAMEBUFFER_EFFECTS +# define RGB_DISABLE_WHEN_USB_SUSPENDED true + +# define DISABLE_RGB_MATRIX_ALPHAS_MODS +# define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN +# define DISABLE_RGB_MATRIX_BREATHING +# define DISABLE_RGB_MATRIX_BAND_SAT +# define DISABLE_RGB_MATRIX_BAND_VAL +# define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT +# define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL +# define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT +# define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL +# define DISABLE_RGB_MATRIX_CYCLE_ALL +# define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT +# define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN +# define DISABLE_RGB_MATRIX_CYCLE_OUT_IN +// # define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL +# define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON +# define DISABLE_RGB_MATRIX_DUAL_BEACON +# define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL +# define DISABLE_RGB_MATRIX_CYCLE_SPIRAL +# define DISABLE_RGB_MATRIX_RAINBOW_BEACON +# define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS +# define DISABLE_RGB_MATRIX_RAINDROPS +# define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS +// # define DISABLE_RGB_MATRIX_TYPING_HEATMAP +# define DISABLE_RGB_MATRIX_DIGITAL_RAIN +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS +# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS +# define DISABLE_RGB_MATRIX_SPLASH +# define DISABLE_RGB_MATRIX_MULTISPLASH +# define DISABLE_RGB_MATRIX_SOLID_SPLASH +# define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH +#endif // RGB_MATRIX_ENABLE + +#if !defined(ONESHOT_TAP_TOGGLE) +# define ONESHOT_TAP_TOGGLE 2 +#endif // !ONESHOT_TAP_TOGGLE + +#if !defined(ONESHOT_TIMEOUT) +# define ONESHOT_TIMEOUT 3000 +#endif // !ONESHOT_TIMEOUT + +#if !defined(QMK_KEYS_PER_SCAN) +# define QMK_KEYS_PER_SCAN 4 +#endif // !QMK_KEYS_PER_SCAN + +#define IGNORE_MOD_TAP_INTERRUPT +#undef PERMISSIVE_HOLD + +#define FORCE_NKRO + +#if !defined(TAPPING_TOGGLE) +# define TAPPING_TOGGLE 1 +#endif + +#if defined(TAPPING_TERM) +# undef TAPPING_TERM +#endif // TAPPING_TERM + +#if defined(KEYBOARD_ergodox_ez) +# define TAPPING_TERM 185 +#elif defined(KEYBOARD_crkbd) +# define TAPPING_TERM 200 +#else +# define TAPPING_TERM 175 +#endif + +#define TAP_CODE_DELAY 5 + +#define LEADER_TIMEOUT 250 +#define LEADER_PER_KEY_TIMING + +/* Disable unused and unneeded features to reduce on firmware size */ +#if defined(LOCKING_SUPPORT_ENABLE) +# undef LOCKING_SUPPORT_ENABLE +#endif + +#if defined(LOCKING_RESYNC_ENABLE) +# undef LOCKING_RESYNC_ENABLE +#endif + +#if defined(OLED_FONT_H) +# undef OLED_FONT_H +#endif + +#define OLED_FONT_H "users/curry/glcdfont.c" diff --git a/users/curry/curry.c b/users/curry/curry.c new file mode 100644 index 000000000..035355359 --- /dev/null +++ b/users/curry/curry.c @@ -0,0 +1,130 @@ +#include "curry.h" + +userspace_config_t userspace_config; + +#define CURRY_UNICODE_MODE 1 + +void bootmagic_lite(void) { + matrix_scan(); +#if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0 + wait_ms(DEBOUNCING_DELAY * 2); +#elif defined(DEBOUNCE) && DEBOUNCE > 0 + wait_ms(DEBOUNCE * 2); +#else + wait_ms(30); +#endif + matrix_scan(); + if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) { + bootloader_jump(); + } +} + +__attribute__((weak)) void keyboard_pre_init_keymap(void) {} + +void keyboard_pre_init_user(void) { + userspace_config.raw = eeconfig_read_user(); + keyboard_pre_init_keymap(); +} + +__attribute__((weak)) void matrix_init_keymap(void) {} + +// Call user matrix init, set default RGB colors and then +// call the keymap's init function +void matrix_init_user(void) { +#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)) + set_unicode_input_mode(CURRY_UNICODE_MODE); + get_unicode_input_mode(); +#endif // UNICODE_ENABLE + matrix_init_keymap(); +} + +__attribute__((weak)) void keyboard_post_init_keymap(void) {} + +void keyboard_post_init_user(void) { +#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + keyboard_post_init_rgb(); +#endif + keyboard_post_init_keymap(); +} + +__attribute__((weak)) void shutdown_keymap(void) {} + +void rgb_matrix_update_pwm_buffers(void); + +// On RESET, set all RGB to red, shutdown the keymap. +void shutdown_user(void) { +#if defined(RGBLIGHT_ENABLE) + rgblight_enable_noeeprom(); + rgblight_mode_noeeprom(1); + rgblight_setrgb_red(); +#endif + +#if defined(RGB_MATRIX_ENABLE) + rgb_matrix_set_color_all(0xFF, 0x00, 0x00); + rgb_matrix_update_pwm_buffers(); +#endif + shutdown_keymap(); +} + +__attribute__((weak)) void suspend_power_down_keymap(void) {} + +void suspend_power_down_user(void) { suspend_power_down_keymap(); } + +__attribute__((weak)) void suspend_wakeup_init_keymap(void) {} + +void suspend_wakeup_init_user(void) { suspend_wakeup_init_keymap(); } + +__attribute__((weak)) void matrix_scan_keymap(void) {} + +// No global matrix scan code, so just run keymap's matrix +// scan function +__attribute__((weak)) void matrix_scan_user(void) { + static bool has_ran_yet; + if (!has_ran_yet) { + has_ran_yet = true; + startup_user(); + } + +#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + matrix_scan_rgb(); +#endif // RGBLIGHT_ENABLE + + matrix_scan_keymap(); +} + +__attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state) { return state; } + +// On Layer change, run keymap's layer change check +layer_state_t layer_state_set_user(layer_state_t state) { + state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); +#if defined(RGBLIGHT_ENABLE) + state = layer_state_set_rgb(state); +#endif + return layer_state_set_keymap(state); +} + +__attribute__((weak)) layer_state_t default_layer_state_set_keymap(layer_state_t state) { return state; } + +// Runs state check and changes underglow color and animation +layer_state_t default_layer_state_set_user(layer_state_t state) { return default_layer_state_set_keymap(state); } + +__attribute__((weak)) void led_set_keymap(uint8_t usb_led) {} + +// Any custom LED code goes here. +void led_set_user(uint8_t usb_led) { led_set_keymap(usb_led); } + +__attribute__((weak)) void eeconfig_init_keymap(void) {} + +void eeconfig_init_user(void) { + userspace_config.raw = 0; + userspace_config.rgb_layer_change = true; + eeconfig_update_user(userspace_config.raw); +#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)) + set_unicode_input_mode(CURRY_UNICODE_MODE); + get_unicode_input_mode(); +#else + eeprom_update_byte(EECONFIG_UNICODEMODE, CURRY_UNICODE_MODE); +#endif + eeconfig_init_keymap(); + keyboard_init(); +} diff --git a/users/curry/curry.h b/users/curry/curry.h new file mode 100644 index 000000000..ee4a73683 --- /dev/null +++ b/users/curry/curry.h @@ -0,0 +1,59 @@ +#pragma once + +#include QMK_KEYBOARD_H +#include "version.h" +#include "eeprom.h" +#include "wrappers.h" +#include "process_records.h" + +#if defined(TAP_DANCE_ENABLE) +# include "tap_dances.h" +#endif // TAP_DANCE_ENABLE + +#if defined(RGB_MATRIX_ENABLE) +# include "rgb_matrix_user.h" +#endif + +#if defined(RGBLIGHT_ENABLE) +# include "rgb_lighting_user.h" +#endif + +#if defined(KEYBOARD_lily58_rev1) & defined(PROTOCOL_LUFA) +# include "lufa.h" +# include "split_util.h" +#endif + +/* Define layer names */ +enum userspace_layers { + _QWERTY = 0, + _COLEMAK, + _DVORAK, + _WORKMAN, + _MODS, + _LOWER, + _RAISE, + _ADJUST, +}; + +void matrix_init_keymap(void); +void shutdown_keymap(void); +void suspend_power_down_keymap(void); +void suspend_wakeup_init_keymap(void); +void matrix_scan_keymap(void); +layer_state_t layer_state_set_keymap(layer_state_t state); +layer_state_t default_layer_state_set_keymap(layer_state_t state); +void led_set_keymap(uint8_t usb_led); +void eeconfig_init_keymap(void); + +// clang-format off +typedef union { + uint32_t raw; + struct { + bool rgb_layer_change :1; + bool nuke_switch :1; + bool rgb_matrix_idle_anim :1; + }; +} userspace_config_t; +// clang-format on + +extern userspace_config_t userspace_config; diff --git a/users/curry/glcdfont.c b/users/curry/glcdfont.c new file mode 100644 index 000000000..10ce3b345 --- /dev/null +++ b/users/curry/glcdfont.c @@ -0,0 +1,232 @@ +#include "progmem.h" + +// Corne 8x6 font with QMK Firmware Logo +// Online editor: https://helixfonteditor.netlify.com/ + +// clang-format off +const unsigned char font[] PROGMEM = { +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00, +0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00, +0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00, +0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00, +0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00, +0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00, +0x00, 0x18, 0x3C, 0x18, 0x00, 0x00, +0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00, +0x00, 0x18, 0x24, 0x18, 0x00, 0x00, +0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00, +0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00, +0x26, 0x29, 0x79, 0x29, 0x26, 0x00, +0x40, 0x7F, 0x05, 0x05, 0x07, 0x00, +0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00, +0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00, +0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00, +0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00, +0x14, 0x22, 0x7F, 0x22, 0x14, 0x00, +0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00, +0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00, +0x00, 0x66, 0x89, 0x95, 0x6A, 0x00, +0x60, 0x60, 0x60, 0x60, 0x60, 0x00, +0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00, +0x08, 0x04, 0x7E, 0x04, 0x08, 0x00, +0x10, 0x20, 0x7E, 0x20, 0x10, 0x00, +0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00, +0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00, +0x1E, 0x10, 0x10, 0x10, 0x10, 0x00, +0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00, +0x30, 0x38, 0x3E, 0x38, 0x30, 0x00, +0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, +0x00, 0x07, 0x00, 0x07, 0x00, 0x00, +0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, +0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00, +0x23, 0x13, 0x08, 0x64, 0x62, 0x00, +0x36, 0x49, 0x56, 0x20, 0x50, 0x00, +0x00, 0x08, 0x07, 0x03, 0x00, 0x00, +0x00, 0x1C, 0x22, 0x41, 0x00, 0x00, +0x00, 0x41, 0x22, 0x1C, 0x00, 0x00, +0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00, +0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, +0x00, 0x80, 0x70, 0x30, 0x00, 0x00, +0x08, 0x08, 0x08, 0x08, 0x08, 0x00, +0x00, 0x00, 0x60, 0x60, 0x00, 0x00, +0x20, 0x10, 0x08, 0x04, 0x02, 0x00, +0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, +0x00, 0x42, 0x7F, 0x40, 0x00, 0x00, +0x72, 0x49, 0x49, 0x49, 0x46, 0x00, +0x21, 0x41, 0x49, 0x4D, 0x33, 0x00, +0x18, 0x14, 0x12, 0x7F, 0x10, 0x00, +0x27, 0x45, 0x45, 0x45, 0x39, 0x00, +0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00, +0x41, 0x21, 0x11, 0x09, 0x07, 0x00, +0x36, 0x49, 0x49, 0x49, 0x36, 0x00, +0x46, 0x49, 0x49, 0x29, 0x1E, 0x00, +0x00, 0x00, 0x14, 0x00, 0x00, 0x00, +0x00, 0x40, 0x34, 0x00, 0x00, 0x00, +0x00, 0x08, 0x14, 0x22, 0x41, 0x00, +0x14, 0x14, 0x14, 0x14, 0x14, 0x00, +0x00, 0x41, 0x22, 0x14, 0x08, 0x00, +0x02, 0x01, 0x59, 0x09, 0x06, 0x00, +0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00, +0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00, +0x7F, 0x49, 0x49, 0x49, 0x36, 0x00, +0x3E, 0x41, 0x41, 0x41, 0x22, 0x00, +0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00, +0x7F, 0x49, 0x49, 0x49, 0x41, 0x00, +0x7F, 0x09, 0x09, 0x09, 0x01, 0x00, +0x3E, 0x41, 0x41, 0x51, 0x73, 0x00, +0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, +0x00, 0x41, 0x7F, 0x41, 0x00, 0x00, +0x20, 0x40, 0x41, 0x3F, 0x01, 0x00, +0x7F, 0x08, 0x14, 0x22, 0x41, 0x00, +0x7F, 0x40, 0x40, 0x40, 0x40, 0x00, +0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00, +0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00, +0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, +0x7F, 0x09, 0x09, 0x09, 0x06, 0x00, +0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00, +0x7F, 0x09, 0x19, 0x29, 0x46, 0x00, +0x26, 0x49, 0x49, 0x49, 0x32, 0x00, +0x03, 0x01, 0x7F, 0x01, 0x03, 0x00, +0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00, +0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00, +0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00, +0x63, 0x14, 0x08, 0x14, 0x63, 0x00, +0x03, 0x04, 0x78, 0x04, 0x03, 0x00, +0x61, 0x59, 0x49, 0x4D, 0x43, 0x00, +0x00, 0x7F, 0x41, 0x41, 0x41, 0x00, +0x02, 0x04, 0x08, 0x10, 0x20, 0x00, +0x00, 0x41, 0x41, 0x41, 0x7F, 0x00, +0x04, 0x02, 0x01, 0x02, 0x04, 0x00, +0x40, 0x40, 0x40, 0x40, 0x40, 0x00, +0x00, 0x03, 0x07, 0x08, 0x00, 0x00, +0x20, 0x54, 0x54, 0x78, 0x40, 0x00, +0x7F, 0x28, 0x44, 0x44, 0x38, 0x00, +0x38, 0x44, 0x44, 0x44, 0x28, 0x00, +0x38, 0x44, 0x44, 0x28, 0x7F, 0x00, +0x38, 0x54, 0x54, 0x54, 0x18, 0x00, +0x00, 0x08, 0x7E, 0x09, 0x02, 0x00, +0x18, 0x24, 0x24, 0x1C, 0x78, 0x00, +0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, +0x00, 0x44, 0x7D, 0x40, 0x00, 0x00, +0x20, 0x40, 0x40, 0x3D, 0x00, 0x00, +0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, +0x00, 0x41, 0x7F, 0x40, 0x00, 0x00, +0x7C, 0x04, 0x78, 0x04, 0x78, 0x00, +0x7C, 0x08, 0x04, 0x04, 0x78, 0x00, +0x38, 0x44, 0x44, 0x44, 0x38, 0x00, +0x7C, 0x18, 0x24, 0x24, 0x18, 0x00, +0x18, 0x24, 0x24, 0x18, 0x7C, 0x00, +0x7C, 0x08, 0x04, 0x04, 0x08, 0x00, +0x48, 0x54, 0x54, 0x54, 0x24, 0x00, +0x04, 0x04, 0x3F, 0x44, 0x24, 0x00, +0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00, +0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00, +0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00, +0x44, 0x28, 0x10, 0x28, 0x44, 0x00, +0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00, +0x44, 0x64, 0x54, 0x4C, 0x44, 0x00, +0x00, 0x08, 0x36, 0x41, 0x00, 0x00, +0x00, 0x00, 0x77, 0x00, 0x00, 0x00, +0x00, 0x41, 0x36, 0x08, 0x00, 0x00, +0x02, 0x01, 0x02, 0x04, 0x02, 0x00, +0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, +0xF0, 0xF8, 0xF8, 0x18, 0x00, 0xC0, +0xF0, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF, +0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x80, 0xC0, 0xE0, 0xE0, +0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, +0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, +0x80, 0xC0, 0xE0, 0xE0, 0xE0, 0xE0, +0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0x80, +0x00, 0x00, 0x00, 0xE0, 0xE0, 0xC0, +0xC0, 0xE0, 0xE0, 0xE0, 0xE0, 0x00, +0x00, 0xE0, 0xE0, 0xC0, 0xC0, 0xE0, +0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0x80, +0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, +0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, +0xE0, 0xE0, 0xC0, 0x80, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC, +0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00, +0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E, +0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00, +0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B, +0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00, +0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE, +0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0xF8, 0xFC, 0xFE, +0xFF, 0xE0, 0x00, 0xFF, 0xFF, 0xFF, +0xFF, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, +0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +0xFF, 0x1F, 0x07, 0x01, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0xFF, 0xFF, 0xFF, 0x81, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x81, +0xC3, 0xC3, 0xC3, 0x00, 0x00, 0xFF, +0xFF, 0xFF, 0x81, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x81, 0xFF, 0xFF, +0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, +0x01, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0xFF, 0xFF, 0xFF, 0x01, 0x00, +0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, +0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, +0x9D, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, +0x1C, 0x9D, 0xDF, 0xDF, 0xDF, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F, +0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00, +0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F, +0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00, +0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20, +0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00, +0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F, +0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x03, 0x0F, 0x1F, +0x3F, 0x3F, 0x3F, 0x3F, 0x1F, 0x1F, +0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x3F, +0x3F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F, +0x7F, 0x7C, 0x78, 0x78, 0x38, 0x1C, +0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x01, 0x03, 0x07, 0x07, +0x07, 0x07, 0x07, 0x07, 0x07, 0x07, +0x03, 0x01, 0x00, 0x00, 0x00, 0x00, +0x01, 0x03, 0x07, 0x07, 0x07, 0x07, +0x07, 0x07, 0x07, 0x07, 0x03, 0x01, +0x00, 0x00, 0x00, 0x07, 0x07, 0x07, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x07, 0x07, 0x07, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x07, 0x07, +0x07, 0x00, 0x00, 0x00, 0x01, 0x03, +0x07, 0x07, 0x07, 0x07, 0x07, 0x07, +0x07, 0x07, 0x03, 0x01, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; diff --git a/users/curry/leader.c b/users/curry/leader.c new file mode 100644 index 000000000..3fca6a2ec --- /dev/null +++ b/users/curry/leader.c @@ -0,0 +1,24 @@ +#include "curry.h" +#include "leader.h" + +LEADER_EXTERNS(); + +void matrix_scan_user(void) { + static bool has_ran_yet; + if (!has_ran_yet) { + has_ran_yet = true; + startup_user(); + } + +#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + matrix_scan_rgb(); +#endif // RGBLIGHT_ENABLE + LEADER_DICTIONARY() { + leading = false; + leader_end(); + SEQ_ONE_KEY(KC_F) { SEND_STRING(SS_LCTL("akf")); } // Select all and format + SEQ_ONE_KEY(KC_P) { SEND_STRING(SS_LCTL(SS_LSFT("4"))); } // Screenshot region + SEQ_TWO_KEYS(KC_D, KC_D) { SEND_STRING(SS_LCTL("ac")); } // Copy all + } + matrix_scan_keymap(); +} diff --git a/users/curry/leader.h b/users/curry/leader.h new file mode 100644 index 000000000..f215893b9 --- /dev/null +++ b/users/curry/leader.h @@ -0,0 +1,3 @@ +#pragma once + +void matrix_scan_user(void); diff --git a/users/curry/oled.c b/users/curry/oled.c new file mode 100644 index 000000000..fc87a46e5 --- /dev/null +++ b/users/curry/oled.c @@ -0,0 +1,163 @@ +#include "curry.h" + +#define KEYLOGGER_LENGTH 5 +static uint32_t oled_timer = 0; +static char keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"}; +static uint16_t log_timer = 0; +// clang-format off +static const char PROGMEM code_to_name[0xFF] = { +// 0 1 2 3 4 5 6 7 8 9 A B c D E F + ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', // 0x + 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', // 1x + '3', '4', '5', '6', '7', '8', '9', '0', 20, 19, 27, 26, 22, '-', '=', '[', // 2x + ']','\\', '#', ';','\'', '`', ',', '.', '/', 128, ' ', ' ', ' ', ' ', ' ', ' ', // 3x + ' ', ' ', ' ', ' ', ' ', ' ', 'P', 'S', ' ', ' ', ' ', ' ', 16, ' ', ' ', ' ', // 4x + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 5x + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 6x + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 7x + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 8x + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 9x + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ax + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Bx + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Cx + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Dx + 'C', 'S', 'A', 'C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ex + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' // Fx +}; + +// clang-format on +void add_keylog(uint16_t keycode); + +oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; } + +void add_keylog(uint16_t keycode) { + if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) || (keycode >= QK_MODS && keycode <= QK_MODS_MAX)) { + keycode = keycode & 0xFF; + } else if (keycode > 0xFF) { + keycode = 0; + } + + for (uint8_t i = (KEYLOGGER_LENGTH - 1); i > 0; --i) { + keylog_str[i] = keylog_str[i - 1]; + } + + if (keycode < (sizeof(code_to_name) / sizeof(char))) { + keylog_str[0] = pgm_read_byte(&code_to_name[keycode]); + } + + log_timer = timer_read(); +} + +void render_keylogger_status(void) { + oled_write_P(PSTR("Keys:"), false); + oled_write(keylog_str, false); +} + +void render_default_layer_state(void) { + oled_write_P(PSTR("Lyout"), false); + switch (get_highest_layer(default_layer_state)) { + case _QWERTY: + oled_write_P(PSTR(" QRTY"), false); + break; + case _COLEMAK: + oled_write_P(PSTR(" COLE"), false); + break; + case _DVORAK: + oled_write_P(PSTR(" DVRK"), false); + break; + case _WORKMAN: + oled_write_P(PSTR(" WRKM"), false); + break; + } +} + +void render_layer_state(void) { + oled_write_P(PSTR("LAYER"), false); + oled_write_P(PSTR("Lower"), layer_state_is(_LOWER)); + oled_write_P(PSTR("Raise"), layer_state_is(_RAISE)); + oled_write_P(PSTR(" Mods"), layer_state_is(_MODS)); +} + +void render_keylock_status(uint8_t led_usb_state) { + oled_write_P(PSTR("Lock:"), false); + oled_write_P(PSTR(" "), false); + oled_write_P(PSTR("N"), led_usb_state & (1 << USB_LED_NUM_LOCK)); + oled_write_P(PSTR("C"), led_usb_state & (1 << USB_LED_CAPS_LOCK)); + oled_write_ln_P(PSTR("S"), led_usb_state & (1 << USB_LED_SCROLL_LOCK)); +} + +void render_mod_status(uint8_t modifiers) { + oled_write_P(PSTR("Mods:"), false); + oled_write_P(PSTR(" "), false); + oled_write_P(PSTR("S"), (modifiers & MOD_MASK_SHIFT)); + oled_write_P(PSTR("C"), (modifiers & MOD_MASK_CTRL)); + oled_write_P(PSTR("A"), (modifiers & MOD_MASK_ALT)); + oled_write_P(PSTR("G"), (modifiers & MOD_MASK_GUI)); +} + +void render_bootmagic_status(void) { + /* Show Ctrl-Gui Swap options */ + static const char PROGMEM logo[][2][3] = { + {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}}, + {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}}, + }; + oled_write_P(PSTR("BTMGK"), false); + oled_write_P(PSTR(" "), false); + oled_write_P(logo[0][0], !keymap_config.swap_lctl_lgui); + oled_write_P(logo[1][0], keymap_config.swap_lctl_lgui); + oled_write_P(PSTR(" "), false); + oled_write_P(logo[0][1], !keymap_config.swap_lctl_lgui); + oled_write_P(logo[1][1], keymap_config.swap_lctl_lgui); + oled_write_P(PSTR(" NKRO"), keymap_config.nkro); +} + +void render_user_status(void) { + oled_write_P(PSTR("USER:"), false); + oled_write_P(PSTR(" Anim"), userspace_config.rgb_matrix_idle_anim); + oled_write_P(PSTR(" Layr"), userspace_config.rgb_layer_change); + oled_write_P(PSTR(" Nuke"), userspace_config.nuke_switch); +} + +void render_status_main(void) { + /* Show Keyboard Layout */ + render_default_layer_state(); + render_keylock_status(host_keyboard_leds()); + render_bootmagic_status(); + render_user_status(); + + render_keylogger_status(); +} + +void render_status_secondary(void) { + /* Show Keyboard Layout */ + render_default_layer_state(); + render_layer_state(); + render_mod_status(get_mods() | get_oneshot_mods()); + + render_keylogger_status(); +} + +void oled_task_user(void) { + if (timer_elapsed32(oled_timer) > 30000) { + oled_off(); + return; + } +#if !defined(SPLIT_KEYBOARD) + else { + oled_on(); + } +#endif + if (is_keyboard_master()) { + render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc) + } else { + render_status_secondary(); + } +} + +bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { + if (record->event.pressed) { + oled_timer = timer_read32(); + add_keylog(keycode); + } + return true; +} diff --git a/users/curry/process_records.c b/users/curry/process_records.c new file mode 100644 index 000000000..fd58ea181 --- /dev/null +++ b/users/curry/process_records.c @@ -0,0 +1,76 @@ +#include "curry.h" + +uint16_t copy_paste_timer; + +__attribute__((weak)) bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { return true; } + +__attribute__((weak)) bool process_record_secrets(uint16_t keycode, keyrecord_t *record) { return true; } + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + xprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed); + switch (keycode) { + case KC_QWERTY ... KC_WORKMAN: + if (record->event.pressed) { + set_single_persistent_default_layer(keycode - KC_QWERTY); + } + break; + case KC_MAKE: + if (!record->event.pressed) { + uint8_t temp_mod = mod_config(get_mods()); + uint8_t temp_osm = mod_config(get_oneshot_mods()); + clear_mods(); + clear_oneshot_mods(); + send_string_with_delay_P(PSTR("make " QMK_KEYBOARD ":" QMK_KEYMAP), TAP_CODE_DELAY); + if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) { + send_string_with_delay_P(PSTR(":flash"), TAP_CODE_DELAY); + } + send_string_with_delay_P(PSTR(" -j8 --output-sync\n"), TAP_CODE_DELAY); + } + break; + + case VRSN: // Prints firmware version + if (record->event.pressed) { + send_string_with_delay_P(PSTR(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE), TAP_CODE_DELAY); + } + break; + + case KC_CCCV: // One key copy/paste + if (record->event.pressed) { + copy_paste_timer = timer_read(); + } else { + if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy + tap_code16(LCTL(KC_C)); + } else { // Tap, paste + tap_code16(LCTL(KC_V)); + } + } + break; +#if defined(UNICODE_ENABLE) + case UC_FLIP: // (ノಠ痊ಠ)ノ彡┻━┻ + if (record->event.pressed) { + send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B"); + } + break; + case UC_TABL: // ┬─┬ノ( º _ ºノ) + if (record->event.pressed) { + send_unicode_hex_string("252C 2500 252C 30CE 0028 0020 00BA 0020 005F 0020 00BA 30CE 0029"); + } + break; + case UC_SHRG: // ¯\_(ツ)_/¯ + if (record->event.pressed) { + send_unicode_hex_string("00AF 005C 005F 0028 30C4 0029 005F 002F 00AF"); + } + break; + case UC_DISA: // ಠ_ಠ + if (record->event.pressed) { + send_unicode_hex_string("0CA0 005F 0CA0"); + } + break; +#endif + } + return process_record_keymap(keycode, record) && +#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + process_record_user_rgb(keycode, record) && +#endif // RGBLIGHT_ENABLE + process_record_secrets(keycode, record); +} diff --git a/users/curry/process_records.h b/users/curry/process_records.h new file mode 100644 index 000000000..49e7240c6 --- /dev/null +++ b/users/curry/process_records.h @@ -0,0 +1,86 @@ +#pragma once + +enum userspace_custom_keycodes { + VRSN = SAFE_RANGE, // Prints QMK Firmware and board info + KC_QWERTY, // Sets default layer to QWERTY + KC_COLEMAK, // Sets default layer to COLEMAK + KC_DVORAK, // Sets default layer to DVORAK + KC_WORKMAN, // Sets default layer to WORKMAN + KC_MAKE, // Run keyboard's customized make command + KC_RGB_T, // Toggles RGB Layer Indication mode + RGB_IDL, // RGB Idling animations + KC_SECRET_1, // test1 + KC_SECRET_2, // test2 + KC_SECRET_3, // test3 + KC_SECRET_4, // test4 + KC_SECRET_5, // test5 + KC_CCCV, // Hold to copy, tap to paste + UC_FLIP, // (ಠ痊ಠ)┻━┻ + UC_TABL, // ┬─┬ノ( º _ ºノ) + UC_SHRG, // ¯\_(ツ)_/¯ + UC_DISA, // ಠ_ಠ + KC_DT1, + KC_DT2, + KC_DT3, + KC_DT4, + NEW_SAFE_RANGE // use "NEWPLACEHOLDER for keymap specific codes +}; + +bool process_record_secrets(uint16_t keycode, keyrecord_t *record); +bool process_record_keymap(uint16_t keycode, keyrecord_t *record); + +#define LOWER MO(_LOWER) +#define RAISE MO(_RAISE) +#define ADJUST MO(_ADJUST) +#define TG_MODS TG(_MODS) +#define OS_LWR OSL(_LOWER) +#define OS_RSE OSL(_RAISE) + +#define KC_SEC1 KC_SECRET_1 +#define KC_SEC2 KC_SECRET_2 +#define KC_SEC3 KC_SECRET_3 +#define KC_SEC4 KC_SECRET_4 +#define KC_SEC5 KC_SECRET_5 + +#define QWERTY KC_QWERTY +#define DVORAK KC_DVORAK +#define COLEMAK KC_COLEMAK +#define WORKMAN KC_WORKMAN + +#define KC_RST RESET + +#if defined(SWAP_HANDS_ENABLE) +# define KC_C1R3 SH_T(KC_TAB) +#else // SWAP_HANDS_ENABLE +# define KC_C1R3 KC_TAB +#endif // SWAP_HANDS_ENABLE + +#define SP_LWER LT(_LOWER, KC_SPC) +#define ET_RAIS LT(_RAISE, KC_ENTER) + +/* OSM keycodes, to keep things clean and easy to change */ +#define OS_LGUI OSM(MOD_LGUI) +#define OS_RGUI OSM(MOD_RGUI) +#define OS_LSFT OSM(MOD_LSFT) +#define OS_RSFT OSM(MOD_RSFT) +#define OS_LCTL OSM(MOD_LCTL) +#define OS_RCTL OSM(MOD_RCTL) +#define OS_LALT OSM(MOD_LALT) +#define OS_RALT OSM(MOD_RALT) +#define OS_MEH OSM(MOD_MEH) +#define OS_HYPR OSM(MOD_HYPR) + +#define MT_ESC MT(MOD_LCTL, KC_ESC) + +#define ALT_APP ALT_T(KC_APP) + +#define MG_NKRO MAGIC_TOGGLE_NKRO + +#define UC_IRNY UC(0x2E2E) +#define UC_CLUE UC(0x203D) + +// KWin Window Switching +#define KC_DT1 LCTL(KC_F1) +#define KC_DT2 LCTL(KC_F2) +#define KC_DT3 LCTL(KC_F3) +#define KC_DT4 LCTL(KC_F4) diff --git a/users/curry/rgb_lighting_user.c b/users/curry/rgb_lighting_user.c new file mode 100644 index 000000000..25e1ce010 --- /dev/null +++ b/users/curry/rgb_lighting_user.c @@ -0,0 +1,325 @@ +#include "curry.h" +#include "rgb_lighting_user.h" + +extern rgblight_config_t rgblight_config; +bool has_initialized; + +void rgblight_sethsv_default_helper(uint8_t index) { rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, index); } + +/* Custom indicators for modifiers. + * This allows for certain lights to be lit up, based on what mods are active, giving some visual feedback. + * This is especially useful for One Shot Mods, since it's not always obvious if they're still lit up. + */ +#if defined(INDICATOR_LIGHTS) +void set_rgb_indicators(uint8_t this_mod, uint8_t this_led, uint8_t this_osm) { + if (userspace_config.rgb_layer_change && get_highest_layer(layer_state) == 0) { + if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) { +# ifdef SHFT_LED1 + rgblight_sethsv_at(120, 255, 255, SHFT_LED1); +# endif // SHFT_LED1 +# ifdef SHFT_LED2 + rgblight_sethsv_at(120, 255, 255, SHFT_LED2); +# endif // SHFT_LED2 + } else { +# ifdef SHFT_LED1 + rgblight_sethsv_default_helper(SHFT_LED1); +# endif // SHFT_LED1 +# ifdef SHFT_LED2 + rgblight_sethsv_default_helper(SHFT_LED2); +# endif // SHFT_LED2 + } + if ((this_mod | this_osm) & MOD_MASK_CTRL) { +# ifdef CTRL_LED1 + rgblight_sethsv_at(0, 255, 255, CTRL_LED1); +# endif // CTRL_LED1 +# ifdef CTRL_LED2 + rgblight_sethsv_at(0, 255, 255, CTRL_LED2); +# endif // CTRL_LED2 + } else { +# ifdef CTRL_LED1 + rgblight_sethsv_default_helper(CTRL_LED1); +# endif // CTRL_LED1 +# ifdef CTRL_LED2 + rgblight_sethsv_default_helper(CTRL_LED2); +# endif // CTRL_LED2 + } + if ((this_mod | this_osm) & MOD_MASK_GUI) { +# ifdef GUI_LED1 + rgblight_sethsv_at(51, 255, 255, GUI_LED1); +# endif // GUI_LED1 +# ifdef GUI_LED2 + rgblight_sethsv_at(51, 255, 255, GUI_LED2); +# endif // GUI_LED2 + } else { +# ifdef GUI_LED1 + rgblight_sethsv_default_helper(GUI_LED1); +# endif // GUI_LED1 +# ifdef GUI_LED2 + rgblight_sethsv_default_helper(GUI_LED2); +# endif // GUI_LED2 + } + if ((this_mod | this_osm) & MOD_MASK_ALT) { +# ifdef ALT_LED1 + rgblight_sethsv_at(240, 255, 255, ALT_LED1); +# endif // ALT_LED1 +# ifdef GUI_LED2 + rgblight_sethsv_at(240, 255, 255, ALT_LED2); +# endif // GUI_LED2 + } else { +# ifdef GUI_LED1 + rgblight_sethsv_default_helper(ALT_LED1); +# endif // GUI_LED1 +# ifdef GUI_LED2 + rgblight_sethsv_default_helper(ALT_LED2); +# endif // GUI_LED2 + } + } +} + +/* Function for the indicators */ +void matrix_scan_indicator(void) { + if (has_initialized) { + set_rgb_indicators(get_mods(), host_keyboard_leds(), get_oneshot_mods()); + } +} +#endif // INDICATOR_LIGHTS + +#if defined(RGBLIGHT_TWINKLE) +static rgblight_fadeout lights[RGBLED_NUM]; + +__attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; } + +/* This function checks for used LEDs. This way, collisions don't occur and cause weird rendering */ +bool rgblight_twinkle_is_led_used(uint8_t index) { + switch (index) { +# ifdef INDICATOR_LIGHTS +# ifdef SHFT_LED1 + case SHFT_LED1: + return true; +# endif // SHFT_LED1 +# ifdef SHFT_LED2 + case SHFT_LED2: + return true; +# endif // SHFT_LED2 +# ifdef CTRL_LED1 + case CTRL_LED1: + return true; +# endif // CTRL_LED1 +# ifdef CTRL_LED2 + case CTRL_LED2: + return true; +# endif // CTRL_LED2 +# ifdef GUI_LED1 + case GUI_LED1: + return true; +# endif // GUI_LED1 +# ifdef GUI_LED2 + case GUI_LED2: + return true; +# endif // GUI_LED2 +# ifdef ALT_LED1 + case ALT_LED1: + return true; +# endif // ALT_LED1 +# ifdef ALT_LED2 + case ALT_LED2: + return true; +# endif // ALT_LED2 +# endif // INDICATOR_LIGHTS + default: + return rgblight_twinkle_is_led_used_keymap(index); + } +} + +/* Handler for fading/twinkling effect */ +void scan_rgblight_fadeout(void) { // Don't effing change this function .... rgblight_sethsv is supppppper intensive + bool litup = false; + for (uint8_t light_index = 0; light_index < RGBLED_NUM; ++light_index) { + if (lights[light_index].enabled && timer_elapsed(lights[light_index].timer) > 10) { + rgblight_fadeout *light = &lights[light_index]; + litup = true; + + if (light->life) { + light->life -= 1; + if (get_highest_layer(layer_state) == 0) { + sethsv(light->hue + rand() % 0xF, 255, light->life, (LED_TYPE *)&led[light_index]); + } + light->timer = timer_read(); + } else { + if (light->enabled && get_highest_layer(layer_state) == 0) { + rgblight_sethsv_default_helper(light_index); + } + litup = light->enabled = false; + } + } + } + if (litup && get_highest_layer(layer_state) == 0) { + rgblight_set(); + } +} + +/* Triggers a LED to fade/twinkle. + * This function handles the selection of the LED and prepres for it to be used. + */ +void start_rgb_light(void) { + uint8_t indices[RGBLED_NUM]; + uint8_t indices_count = 0; + uint8_t min_life = 0xFF; + uint8_t min_life_index = -1; + for (uint8_t index = 0; index < RGBLED_NUM; ++index) { + if (rgblight_twinkle_is_led_used(index)) { + continue; + } + if (lights[index].enabled) { + if (min_life_index == -1 || lights[index].life < min_life) { + min_life = lights[index].life; + min_life_index = index; + } + continue; + } + + indices[indices_count] = index; + ++indices_count; + } + + uint8_t light_index; + if (!indices_count) { + light_index = min_life_index; + } else { + light_index = indices[rand() % indices_count]; + } + + rgblight_fadeout *light = &lights[light_index]; + light->enabled = true; + light->timer = timer_read(); + light->life = 0xC0 + rand() % 0x40; + + light->hue = rgblight_config.hue + (rand() % 0xB4) - 0x54; + + rgblight_sethsv_at(light->hue, 255, light->life, light_index); +} +#endif + +bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { + uint16_t temp_keycode = keycode; + // Filter out the actual keycode from MT and LT keys. + if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) { + temp_keycode &= 0xFF; + } + + switch (temp_keycode) { +#if defined(RGBLIGHT_TWINKLE) + case KC_A ... KC_SLASH: + case KC_F1 ... KC_F12: + case KC_INSERT ... KC_UP: + case KC_KP_SLASH ... KC_KP_DOT: + case KC_F13 ... KC_F24: + case KC_AUDIO_MUTE ... KC_MEDIA_REWIND: + if (record->event.pressed) { + start_rgb_light(); + } + break; +#endif // RGBLIGHT_TWINKLE + case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal + if (record->event.pressed) { + userspace_config.rgb_layer_change ^= 1; + dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); + eeconfig_update_user(userspace_config.raw); + if (userspace_config.rgb_layer_change) { + layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better) + } + } + break; + case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions + if (record->event.pressed) { + bool is_eeprom_updated = false; + // This disables layer indication, as it's assumed that if you're changing this ... you want that disabled + if (userspace_config.rgb_layer_change) { + userspace_config.rgb_layer_change = false; + dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); + is_eeprom_updated = true; + } + if (is_eeprom_updated) { + eeconfig_update_user(userspace_config.raw); + } + } + break; + } + return true; +} + +void keyboard_post_init_rgb(void) { +#if defined(RGBLIGHT_STARTUP_ANIMATION) + bool is_enabled = rgblight_config.enable; + if (userspace_config.rgb_layer_change) { + rgblight_enable_noeeprom(); + } + if (rgblight_config.enable) { + layer_state_set_user(layer_state); + uint16_t old_hue = rgblight_config.hue; + rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT); + for (uint16_t i = 255; i > 0; i--) { + rgblight_sethsv_noeeprom((i + old_hue) % 255, 255, 255); + matrix_scan(); + wait_ms(10); + } + } + if (!is_enabled) { + rgblight_disable_noeeprom(); + } + +#endif + layer_state_set_user(layer_state); +} + +void matrix_scan_rgb(void) { +#if defined(RGBLIGHT_TWINKLE) + scan_rgblight_fadeout(); +#endif // RGBLIGHT_ENABLE + +#if defined(INDICATOR_LIGHTS) + matrix_scan_indicator(); +#endif +} + +void rgblight_set_hsv_and_mode(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode) { + rgblight_sethsv_noeeprom(hue, sat, val); + wait_us(175); // Add a slight delay between color and mode to ensure it's processed correctly + rgblight_mode_noeeprom(mode); +} + +layer_state_t layer_state_set_rgb(layer_state_t state) { + if (userspace_config.rgb_layer_change) { + switch (get_highest_layer(state)) { + case _RAISE: + rgblight_set_hsv_and_mode(HSV_YELLOW, RGBLIGHT_MODE_BREATHING + 3); + break; + case _LOWER: + rgblight_set_hsv_and_mode(HSV_GREEN, RGBLIGHT_MODE_BREATHING + 3); + break; + case _ADJUST: + rgblight_set_hsv_and_mode(HSV_RED, RGBLIGHT_MODE_KNIGHT + 2); + break; + default: // for any other layers, or the default layer + { + uint8_t mode = get_highest_layer(state) == _MODS ? RGBLIGHT_MODE_BREATHING : RGBLIGHT_MODE_STATIC_LIGHT; + switch (get_highest_layer(default_layer_state)) { + case _COLEMAK: + rgblight_set_hsv_and_mode(HSV_MAGENTA, mode); + break; + case _DVORAK: + rgblight_set_hsv_and_mode(HSV_SPRINGGREEN, mode); + break; + case _WORKMAN: + rgblight_set_hsv_and_mode(HSV_GOLDENROD, mode); + break; + default: + rgblight_set_hsv_and_mode(HSV_CYAN, mode); + break; + } + break; + } + } + } + return state; +} diff --git a/users/curry/rgb_lighting_user.h b/users/curry/rgb_lighting_user.h new file mode 100644 index 000000000..91d7a7061 --- /dev/null +++ b/users/curry/rgb_lighting_user.h @@ -0,0 +1,19 @@ +#pragma once + +typedef struct { + bool enabled; + uint8_t hue; + uint16_t timer; + uint8_t life; +} rgblight_fadeout; + +bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record); +void keyboard_post_init_rgb(void); +void matrix_scan_rgb(void); +layer_state_t layer_state_set_rgb(layer_state_t state); +layer_state_t default_layer_state_set_rgb(layer_state_t state); +void rgblight_sethsv_default_helper(uint8_t index); + +#if defined(RGBLIGHT_TWINKLE) +void scan_rgblight_fadeout(void); +#endif diff --git a/users/curry/rgb_matrix_user.c b/users/curry/rgb_matrix_user.c new file mode 100644 index 000000000..d1698b087 --- /dev/null +++ b/users/curry/rgb_matrix_user.c @@ -0,0 +1,144 @@ +#include "curry.h" +#include "rgb_matrix_user.h" +#include "lib/lib8tion/lib8tion.h" + +static uint32_t hypno_timer; +extern led_config_t g_led_config; + +#define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN_DUAL + +void suspend_power_down_keymap(void) { rgb_matrix_set_suspend_state(true); } + +void suspend_wakeup_init_keymap(void) { rgb_matrix_set_suspend_state(false); } + +void check_default_layer(uint8_t mode, uint8_t type) { + switch (get_highest_layer(default_layer_state)) { + case _QWERTY: + rgb_matrix_layer_helper(HSV_CYAN, mode, rgb_matrix_config.speed, type); + break; + case _COLEMAK: + rgb_matrix_layer_helper(HSV_MAGENTA, mode, rgb_matrix_config.speed, type); + break; + case _DVORAK: + rgb_matrix_layer_helper(HSV_SPRINGGREEN, mode, rgb_matrix_config.speed, type); + break; + case _WORKMAN: + rgb_matrix_layer_helper(HSV_GOLDENROD, mode, rgb_matrix_config.speed, type); + break; + } +} + +void rgb_matrix_indicators_user(void) { + if (userspace_config.rgb_layer_change && !g_suspend_state && rgb_matrix_config.enable) { + switch (get_highest_layer(layer_state)) { + case _RAISE: + rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); + break; + case _LOWER: + rgb_matrix_layer_helper(HSV_GREEN, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); + break; + case _ADJUST: + rgb_matrix_layer_helper(HSV_RED, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); + break; + default: { + check_default_layer(IS_LAYER_ON(_MODS), LED_FLAG_UNDERGLOW); + break; + } + } + check_default_layer(0, LED_FLAG_MODIFIER); + } +} + +bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { + uint16_t temp_keycode = keycode; + // Filter out the actual keycode from MT and LT keys. + if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) { + temp_keycode &= 0xFF; + } + + hypno_timer = timer_read32(); + if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_REST_MODE) { + rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP); + } + + switch (temp_keycode) { + case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal + if (record->event.pressed) { + userspace_config.rgb_layer_change ^= 1; + dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); + eeconfig_update_user(userspace_config.raw); + if (userspace_config.rgb_layer_change) { + layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better) + } + } + break; + case RGB_IDL: // This allows me to use underglow as layer indication, or as normal + if (record->event.pressed) { + userspace_config.rgb_matrix_idle_anim ^= 1; + dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim); + eeconfig_update_user(userspace_config.raw); + if (userspace_config.rgb_matrix_idle_anim) { + rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP); + } + } + break; + case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions + if (record->event.pressed) { + bool is_eeprom_updated = false; + if (userspace_config.rgb_matrix_idle_anim) { + userspace_config.rgb_matrix_idle_anim = false; + dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim); + is_eeprom_updated = true; + } + if (is_eeprom_updated) { + eeconfig_update_user(userspace_config.raw); + } + } + break; + } + return true; +} + +void keyboard_post_init_rgb(void) { + if (userspace_config.rgb_matrix_idle_anim) { + rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE); + } +} + +void matrix_scan_rgb(void) { + if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_TYPING_HEATMAP && timer_elapsed32(hypno_timer) > 15000) { + rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE); + } +} + +void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type) { + HSV hsv = {hue, sat, val}; + if (hsv.v > rgb_matrix_config.hsv.v) { + hsv.v = rgb_matrix_config.hsv.v; + } + + switch (mode) { + case 1: // breathing + { + uint16_t time = scale16by8(g_rgb_counters.tick, speed / 8); + hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); + RGB rgb = hsv_to_rgb(hsv); + for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) { + if (HAS_FLAGS(g_led_config.flags[i], led_type)) { + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + } + break; + } + default: // Solid Color + { + RGB rgb = hsv_to_rgb(hsv); + for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) { + if (HAS_FLAGS(g_led_config.flags[i], led_type)) { + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + } + break; + } + } +} diff --git a/users/curry/rgb_matrix_user.h b/users/curry/rgb_matrix_user.h new file mode 100644 index 000000000..d7db29bff --- /dev/null +++ b/users/curry/rgb_matrix_user.h @@ -0,0 +1,7 @@ +#pragma once + +bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record); +void keyboard_post_init_rgb(void); +void matrix_scan_rgb(void); +void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue); +void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type); diff --git a/users/curry/rgblight_breathe_table.h b/users/curry/rgblight_breathe_table.h new file mode 100644 index 000000000..4c6ae38fa --- /dev/null +++ b/users/curry/rgblight_breathe_table.h @@ -0,0 +1,118 @@ +#ifndef RGBLIGHT_EFFECT_BREATHE_TABLE +#define RGBLIGHT_EFFECT_BREATHE_TABLE + +// clang-format off +const uint8_t rgblight_effect_breathe_table[] PROGMEM = { +/* #define RGBLIGHT_EFFECT_BREATHE_CENTER 0.00 */ +/* #define RGBLIGHT_EFFECT_BREATHE_MAX 255 */ + + #if RGBLIGHT_BREATHE_TABLE_SIZE == 256 + 0x44, 0x45, 0x47, 0x48, 0x4a, 0x4b, 0x4c, 0x4e, + 0x4f, 0x51, 0x52, 0x54, 0x55, 0x57, 0x58, 0x5a, + 0x5c, 0x5d, 0x5f, 0x60, 0x62, 0x64, 0x65, 0x67, + 0x69, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x73, 0x75, + 0x77, 0x79, 0x7b, 0x7c, 0x7e, 0x80, 0x82, 0x84, + 0x86, 0x88, 0x8a, 0x8b, 0x8d, 0x8f, 0x91, 0x93, + 0x95, 0x97, 0x99, 0x9b, 0x9d, 0x9f, 0xa1, 0xa3, + 0xa5, 0xa7, 0xa9, 0xaa, 0xac, 0xae, 0xb0, 0xb2, + 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xbf, 0xc1, + 0xc3, 0xc5, 0xc7, 0xc9, 0xca, 0xcc, 0xce, 0xd0, + 0xd1, 0xd3, 0xd5, 0xd6, 0xd8, 0xda, 0xdb, 0xdd, + 0xde, 0xe0, 0xe1, 0xe3, 0xe4, 0xe5, 0xe7, 0xe8, + 0xe9, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, + 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf8, + 0xf9, 0xfa, 0xfa, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, + 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, + 0xfd, 0xfc, 0xfc, 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, + 0xf8, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, + 0xf1, 0xf0, 0xef, 0xee, 0xed, 0xec, 0xeb, 0xe9, + 0xe8, 0xe7, 0xe5, 0xe4, 0xe3, 0xe1, 0xe0, 0xde, + 0xdd, 0xdb, 0xda, 0xd8, 0xd6, 0xd5, 0xd3, 0xd1, + 0xd0, 0xce, 0xcc, 0xca, 0xc9, 0xc7, 0xc5, 0xc3, + 0xc1, 0xbf, 0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, + 0xb2, 0xb0, 0xae, 0xac, 0xaa, 0xa9, 0xa7, 0xa5, + 0xa3, 0xa1, 0x9f, 0x9d, 0x9b, 0x99, 0x97, 0x95, + 0x93, 0x91, 0x8f, 0x8d, 0x8b, 0x8a, 0x88, 0x86, + 0x84, 0x82, 0x80, 0x7e, 0x7c, 0x7b, 0x79, 0x77, + 0x75, 0x73, 0x72, 0x70, 0x6e, 0x6c, 0x6a, 0x69, + 0x67, 0x65, 0x64, 0x62, 0x60, 0x5f, 0x5d, 0x5c, + 0x5a, 0x58, 0x57, 0x55, 0x54, 0x52, 0x51, 0x4f, + 0x4e, 0x4c, 0x4b, 0x4a, 0x48, 0x47, 0x45, 0x44 + #endif /* 256 bytes table */ + + #if RGBLIGHT_BREATHE_TABLE_SIZE == 128 + 0x44, 0x47, 0x4a, 0x4c, + 0x4f, 0x52, 0x55, 0x58, + 0x5c, 0x5f, 0x62, 0x65, + 0x69, 0x6c, 0x70, 0x73, + 0x77, 0x7b, 0x7e, 0x82, + 0x86, 0x8a, 0x8d, 0x91, + 0x95, 0x99, 0x9d, 0xa1, + 0xa5, 0xa9, 0xac, 0xb0, + 0xb4, 0xb8, 0xbc, 0xbf, + 0xc3, 0xc7, 0xca, 0xce, + 0xd1, 0xd5, 0xd8, 0xdb, + 0xde, 0xe1, 0xe4, 0xe7, + 0xe9, 0xec, 0xee, 0xf0, + 0xf2, 0xf4, 0xf6, 0xf8, + 0xf9, 0xfa, 0xfc, 0xfc, + 0xfd, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, + 0xfd, 0xfc, 0xfb, 0xfa, + 0xf8, 0xf7, 0xf5, 0xf3, + 0xf1, 0xef, 0xed, 0xeb, + 0xe8, 0xe5, 0xe3, 0xe0, + 0xdd, 0xda, 0xd6, 0xd3, + 0xd0, 0xcc, 0xc9, 0xc5, + 0xc1, 0xbe, 0xba, 0xb6, + 0xb2, 0xae, 0xaa, 0xa7, + 0xa3, 0x9f, 0x9b, 0x97, + 0x93, 0x8f, 0x8b, 0x88, + 0x84, 0x80, 0x7c, 0x79, + 0x75, 0x72, 0x6e, 0x6a, + 0x67, 0x64, 0x60, 0x5d, + 0x5a, 0x57, 0x54, 0x51, + 0x4e, 0x4b, 0x48, 0x45 + #endif /* 128 bytes table */ + + #if RGBLIGHT_BREATHE_TABLE_SIZE == 64 + 0x44, 0x4a, + 0x4f, 0x55, + 0x5c, 0x62, + 0x69, 0x70, + 0x77, 0x7e, + 0x86, 0x8d, + 0x95, 0x9d, + 0xa5, 0xac, + 0xb4, 0xbc, + 0xc3, 0xca, + 0xd1, 0xd8, + 0xde, 0xe4, + 0xe9, 0xee, + 0xf2, 0xf6, + 0xf9, 0xfc, + 0xfd, 0xfe, + 0xfe, 0xfe, + 0xfd, 0xfb, + 0xf8, 0xf5, + 0xf1, 0xed, + 0xe8, 0xe3, + 0xdd, 0xd6, + 0xd0, 0xc9, + 0xc1, 0xba, + 0xb2, 0xaa, + 0xa3, 0x9b, + 0x93, 0x8b, + 0x84, 0x7c, + 0x75, 0x6e, + 0x67, 0x60, + 0x5a, 0x54, + 0x4e, 0x48 + #endif /* 64 bytes table */ +}; +// clang-format on + +static const int table_scale = 256 / sizeof(rgblight_effect_breathe_table); + +#endif /* RGBLIGHT_EFFECT_BREATHE_TABLE */ diff --git a/users/curry/rules.mk b/users/curry/rules.mk new file mode 100644 index 000000000..87d3b38ea --- /dev/null +++ b/users/curry/rules.mk @@ -0,0 +1,71 @@ +SRC += curry.c \ + process_records.c + +# Common flags +SPACE_CADET_ENABLE = no +LTO_ENABLE = yes +EXTRAKEY_ENABLE = yes +UNICODE_ENABLE = yes +NKRO_ENABLE = yes +EXTRAKEY_ENABLE = yes +LEADER_ENABLE = yes +TAP_DANCE_ENABLE = no + +ifneq ($(strip $(NO_SECRETS)), yes) + ifneq ("$(wildcard $(USER_PATH)/secrets.c)","") + SRC += secrets.c + endif + ifeq ($(strip $(NO_SECRETS)), lite) + OPT_DEFS += -DNO_SECRETS + endif +endif + +ifeq ($(strip $(TAP_DANCE_ENABLE)), yes) + SRC += tap_dances.c +endif + +ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes) + SRC += oled.c +endif + +ifeq ($(strip $(LEADER_ENABLE)), yes) + SRC += leader.c +endif + +ifeq ($(strip $(RGBLIGHT_ENABLE)), yes) + SRC += rgb_lighting_user.c + ifeq ($(strip $(INDICATOR_LIGHTS)), yes) + OPT_DEFS += -DINDICATOR_LIGHTS + endif + ifeq ($(strip $(RGBLIGHT_TWINKLE)), yes) + OPT_DEFS += -DRGBLIGHT_TWINKLE + endif + ifeq ($(strip $(RGBLIGHT_NOEEPROM)), yes) + OPT_DEFS += -DRGBLIGHT_NOEEPROM + endif + ifeq ($(strip $(RGBLIGHT_STARTUP_ANIMATION)), yes) + OPT_DEFS += -DRGBLIGHT_STARTUP_ANIMATION + endif +endif + +RGB_MATRIX_ENABLE ?= no +ifneq ($(strip $(RGB_MATRIX_ENABLE)), no) + SRC += rgb_matrix_user.c +endif + +ifdef CONSOLE_ENABLE + ifeq ($(strip $(KEYLOGGER_ENABLE)), yes) + OPT_DEFS += -DKEYLOGGER_ENABLE + endif +endif + +ifeq ($(strip $(MAKE_BOOTLOADER)), yes) + OPT_DEFS += -DMAKE_BOOTLOADER +endif + +# At least until build.mk or the like drops, this is here to prevent +# VUSB boards from enabling NKRO, as they do not support it. Ideally +# this should be handled per keyboard, but until that happens ... +ifeq ($(strip $(PROTOCOL)), VUSB) + NKRO_ENABLE = no +endif diff --git a/users/curry/tap_dances.c b/users/curry/tap_dances.c new file mode 100644 index 000000000..166ea2c68 --- /dev/null +++ b/users/curry/tap_dances.c @@ -0,0 +1,4 @@ +#include "tap_dances.h" +#include "curry.h" + +qk_tap_dance_action_t tap_dance_actions[] = {}; diff --git a/users/curry/tap_dances.h b/users/curry/tap_dances.h new file mode 100644 index 000000000..6f70f09be --- /dev/null +++ b/users/curry/tap_dances.h @@ -0,0 +1 @@ +#pragma once diff --git a/users/curry/wrappers.h b/users/curry/wrappers.h new file mode 100644 index 000000000..62e89a717 --- /dev/null +++ b/users/curry/wrappers.h @@ -0,0 +1,88 @@ +#pragma once +#include "curry.h" +/* +Since our quirky block definitions are basically a list of comma separated +arguments, we need a wrapper in order for these definitions to be +expanded before being used as arguments to the LAYOUT_xxx macro. +*/ +#if (!defined(LAYOUT) && defined(KEYMAP)) +# define LAYOUT KEYMAP +#endif + +// clang-format off +#define KEYMAP_wrapper(...) LAYOUT(__VA_ARGS__) +#define LAYOUT_wrapper(...) LAYOUT(__VA_ARGS__) +#define LAYOUT_ortho_4x12_wrapper(...) LAYOUT_ortho_4x12(__VA_ARGS__) +#define LAYOUT_ortho_5x12_wrapper(...) LAYOUT_ortho_5x12(__VA_ARGS__) + +#define _________________QWERTY_L1_________________ KC_Q, KC_W, KC_E, KC_R, KC_T +#define _________________QWERTY_L2_________________ KC_A, KC_S, KC_D, KC_F, KC_G +#define _________________QWERTY_L3_________________ KC_Z, KC_X, KC_C, KC_V, KC_B + +#define _________________QWERTY_R1_________________ KC_Y, KC_U, KC_I, KC_O, KC_P +#define _________________QWERTY_R2_________________ KC_H, KC_J, KC_K, KC_L, KC_SCLN +#define _________________QWERTY_R3_________________ KC_N, KC_M, KC_COMM, KC_DOT, KC_SLASH + +#define _________________COLEMAK_L1________________ KC_Q, KC_W, KC_F, KC_P, KC_B +#define _________________COLEMAK_L2________________ KC_A, KC_R, KC_S, KC_T, KC_G +#define _________________COLEMAK_L3________________ KC_Z, KC_X, KC_C, KC_D, KC_V + +#define _________________COLEMAK_R1________________ KC_J, KC_L, KC_U, KC_Y, KC_SCLN +#define _________________COLEMAK_R2________________ KC_M, KC_N, KC_E, KC_I, KC_O +#define _________________COLEMAK_R3________________ KC_K, KC_H, KC_COMM, KC_DOT, KC_SLASH + +#define _________________DVORAK_L1_________________ KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y +#define _________________DVORAK_L2_________________ KC_A, KC_O, KC_E, KC_U, KC_I +#define _________________DVORAK_L3_________________ KC_SCLN, KC_Q, KC_J, KC_K, KC_X + +#define _________________DVORAK_R1_________________ KC_F, KC_G, KC_C, KC_R, KC_L +#define _________________DVORAK_R2_________________ KC_D, KC_H, KC_T, KC_N, KC_S +#define _________________DVORAK_R3_________________ KC_B, KC_M, KC_W, KC_V, KC_Z + +#define _________________WORKMAN_L1________________ KC_Q, KC_D, KC_R, KC_W, KC_B +#define _________________WORKMAN_L2________________ KC_A, KC_S, KC_H, KC_T, KC_G +#define _________________WORKMAN_L3________________ KC_Z, KC_X, KC_M, KC_C, KC_V + +#define _________________WORKMAN_R1________________ KC_J, KC_F, KC_U, KC_P, KC_SCLN +#define _________________WORKMAN_R2________________ KC_Y, KC_N, KC_E, KC_O, KC_I +#define _________________WORKMAN_R3________________ KC_K, KC_L, KC_COMM, KC_DOT, KC_SLASH + + +#define ________________NUMBER_LEFT________________ KC_1, KC_2, KC_3, KC_4, KC_5 +#define ________________NUMBER_RIGHT_______________ KC_6, KC_7, KC_8, KC_9, KC_0 + +#define _________________FUNC_LEFT_________________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5 +#define _________________FUNC_RIGHT________________ KC_F6, KC_F7, KC_F8, KC_F9, KC_F10 + +#define _________________SYM_LEFT__________________ KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC +#define _________________SYM_RIGHT_________________ KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN + + +#define ___________________BLANK___________________ _______, _______, _______, _______, _______ + + +#define _________________LOWER_L1__________________ _________________FUNC_LEFT_________________ +#define _________________LOWER_L2__________________ _________________SYM_LEFT__________________ +#define _________________LOWER_L3__________________ KC_DT1, KC_DT2, KC_DT3, KC_DT4, KC_CCCV + +#define _________________LOWER_R1__________________ _________________FUNC_RIGHT________________ +#define _________________LOWER_R2__________________ _________________SYM_RIGHT_________________ +#define _________________LOWER_R3__________________ KC_DQUO, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR + +#define _________________RAISE_L1__________________ ________________NUMBER_LEFT________________ +#define _________________RAISE_L2__________________ KC_PGUP, KC_PGDN, KC_HOME, KC_END, _______ +#define _________________RAISE_L3__________________ UC_FLIP, UC_TABL, UC_SHRG, UC_DISA, _______ + +#define _________________RAISE_R1__________________ ________________NUMBER_RIGHT_______________ +#define _________________RAISE_R2__________________ KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______ +#define _________________RAISE_R3__________________ KC_QUOT, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC + +#define _________________ADJUST_L1_________________ RGB_MOD, RGB_HUI, RGB_SAI, RGB_VAI, RGB_TOG +#define _________________ADJUST_L2_________________ MU_TOG , CK_TOGG, AU_ON, AU_OFF, CG_NORM +#define _________________ADJUST_L3_________________ RGB_RMOD,RGB_HUD,RGB_SAD, RGB_VAD, KC_RGB_T + +#define _________________ADJUST_R1_________________ KC_SEC1, KC_SEC2, KC_SEC3, KC_SEC4, KC_SEC5 +#define _________________ADJUST_R2_________________ CG_SWAP, QWERTY, COLEMAK, DVORAK, WORKMAN +#define _________________ADJUST_R3_________________ MG_NKRO, KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT + +// clang-format on diff --git a/users/d4mation/config.h b/users/d4mation/config.h new file mode 100644 index 000000000..3140a036f --- /dev/null +++ b/users/d4mation/config.h @@ -0,0 +1 @@ +#define FORCE_NKRO
\ No newline at end of file diff --git a/users/d4mation/d4mation.c b/users/d4mation/d4mation.c new file mode 100644 index 000000000..5aa58a9f0 --- /dev/null +++ b/users/d4mation/d4mation.c @@ -0,0 +1,37 @@ +#include "d4mation.h" + +__attribute__ ((weak)) +bool process_record_keymap( uint16_t keycode, keyrecord_t *record ) { + /* If you want macros specific to your keymap, you need to define this function in your keymap */ + return true; +} + +__attribute__ ((weak)) +void matrix_init_keymap() { + /* If you want a matrix init specific to your keymap, you need to define this function in your keymap */ +} + +__attribute__ ((weak)) +void matrix_scan_keymap() { + /* If you want a matrix scan specific to your keymap, you need to define this function in your keymap */ +} + +__attribute__((weak)) +void eeconfig_init_keymap( void ) {} + +/* process_record_user() is called in macros.c */ + +void matrix_init_user( void ) { + matrix_init_keymap(); +} + +void matrix_scan_user( void ) { + matrix_scan_keymap(); +} + +void eeconfig_init_user( void ) { + + eeconfig_init_keymap(); + keyboard_init(); + +}
\ No newline at end of file diff --git a/users/d4mation/d4mation.h b/users/d4mation/d4mation.h new file mode 100644 index 000000000..94c63526d --- /dev/null +++ b/users/d4mation/d4mation.h @@ -0,0 +1,17 @@ +#pragma once + +#include "quantum.h" + +#ifdef UNICODE_ENABLE +#include "macros.h" +#endif + +#ifdef TAP_DANCE_ENABLE +#include "tap-dance.h" +#endif + +bool process_record_keymap( uint16_t keycode, keyrecord_t *record ); + +void matrix_init_keymap( void ); + +void matrix_scan_keymap( void );
\ No newline at end of file diff --git a/users/d4mation/macros.c b/users/d4mation/macros.c new file mode 100644 index 000000000..3c115d7ea --- /dev/null +++ b/users/d4mation/macros.c @@ -0,0 +1,160 @@ +#include "d4mation.h" +#include "tap-hold.h" +#include "zalgo.h" +#include "macros.h" + +bool zalgo_enabled = false; + +bool process_record_user( uint16_t keycode, keyrecord_t *record ) { + + switch ( keycode ) { + + case _GRAVE_ESC: + + /* Send ` on Tap, Esc on Hold */ + tap_or_hold( record, KC_GRAVE, KC_ESC ); + + return false; + break; + + case PHPOPEN: + + if ( record->event.pressed ) { + + tap_code16( S( KC_COMMA ) ); + tap_code16( S( KC_SLASH ) ); + + tap_code( KC_P ); + tap_code( KC_H ); + tap_code( KC_P ); + + } + + return false; + break; + + case PHPCLSE: + + if ( record->event.pressed ) { + tap_code16( S( KC_SLASH ) ); + tap_code16( S( KC_DOT ) ); + } + + return false; + break; + + #ifdef UNICODE_ENABLE + + case AMENO: /* ༼ つ ◕_◕ ༽つ */ + + if ( record->event.pressed ) { + + send_unicode_hex_string( "0F3C 0020 3064 0020 25D5 005F 25D5 0020 0F3D 3064" ); + + } + + return false; + break; + + case MAGIC: /* (∩ ͡° ͜ʖ ͡°)⊃━☆ﾟ. * */ + + if ( record->event.pressed ) { + + send_unicode_hex_string( "0028 2229 0020 0361 00B0 0020 035C 0296 0020 0361 00B0 0029 2283 2501 2606 FF9F 002E 0020 002A" ); + + } + + return false; + break; + + case LENNY: /* ( ͡° ͜ʖ ͡°) */ + + if ( record->event.pressed ) { + + send_unicode_hex_string( "0028 0020 0361 00B0 0020 035C 0296 0020 0361 00b0 0029" ); + + } + + return false; + break; + + case DISFACE: /* ಠ_ಠ */ + + if ( record->event.pressed ) { + send_unicode_hex_string( "0CA0 005F 0CA0" ); + } + + return false; + break; + + case TFLIP: /* (╯°□°)╯ ︵ ┻━┻ */ + + if ( record->event.pressed ) { + + send_unicode_hex_string( "0028 256F 00b0 25A1 00B0 0029 256F FE35 253B 2501 253B" ); + + } + + return false; + break; + + case TPUT: /* ┬──┬ ノ( ゜-゜ノ) */ + + if ( record->event.pressed ) { + + send_unicode_hex_string( "252C 2500 2500 252C 0020 30CE 0028 0020 309C 002D 309C 30CE 0029" ); + + } + + return false; + break; + + case SHRUG: /* ¯\_(ツ)_/¯ */ + + if ( record->event.pressed ) { + + send_unicode_hex_string( "00AF 005C 005F 0028 30C4 0029 005F 002F 00AF" ); + + } + + return false; + break; + + case ZALGO: /* Toggles Zalgo Text mode */ + + if ( record->event.pressed ) { + zalgo_enabled = ! zalgo_enabled; + } + + return false; + break; + + #endif + + default: + + #ifdef UNICODE_ENABLE + + if ( zalgo_enabled ) { + + if ( keycode < KC_A || ( keycode > KC_0 && keycode < KC_MINUS ) || keycode > KC_SLASH ) { + process_record_keymap( keycode, record ); + return true; + } + + if ( record->event.pressed ) { + zalgo_text( keycode ); + } + + return false; + } + + #endif + + break; + } + + process_record_keymap( keycode, record ); + return true; + +};
\ No newline at end of file diff --git a/users/d4mation/macros.h b/users/d4mation/macros.h new file mode 100644 index 000000000..e69d30dec --- /dev/null +++ b/users/d4mation/macros.h @@ -0,0 +1,23 @@ +#pragma once + +#include "quantum.h" +#include "tap-hold.h" +#include "zalgo.h" + +#define SCRGB LCTL( LSFT( LGUI( KC_4 ) ) ) /* Mac Screen Area Grab shortcut (Puts into Clipboard) */ +#define SLEEP LALT( LGUI( KC_SYSTEM_POWER ) ) /* Instant sleep on Mac, rather than having to hold down the button */ + +enum custom_keycodes { + _GRAVE_ESC = SAFE_RANGE, /* Prefixed with underscore to prevent conflicts */ + PHPOPEN, /* <?php */ + PHPCLSE, /* ?> */ + AMENO, + MAGIC, + LENNY, + DISFACE, + TFLIP, + TPUT, + SHRUG, + ZALGO, + NEW_SAFE_RANGE +};
\ No newline at end of file diff --git a/users/d4mation/rules.mk b/users/d4mation/rules.mk new file mode 100644 index 000000000..3d65a2242 --- /dev/null +++ b/users/d4mation/rules.mk @@ -0,0 +1,15 @@ +SRC += d4mation.c \ + tap-hold.c \ + macros.c + +BOOTMAGIC_ENABLE = no +LTO_ENABLE = yes +MOUSEKEY_ENABLE = no + +ifeq ($(strip $(UNICODE_ENABLE)), yes) + SRC += zalgo.c +endif + +ifeq ($(strip $(TAP_DANCE_ENABLE)), yes) + SRC += tap-dance.c +endif
\ No newline at end of file diff --git a/users/d4mation/tap-dance.c b/users/d4mation/tap-dance.c new file mode 100644 index 000000000..46f2274f5 --- /dev/null +++ b/users/d4mation/tap-dance.c @@ -0,0 +1,6 @@ +#include "tap-dance.h" + +qk_tap_dance_action_t tap_dance_actions[] = { + /* Tap once/hold for Shift, tap twice for Caps Lock */ + [SHIFT_CAPS] = ACTION_TAP_DANCE_DOUBLE( KC_LSHIFT, KC_CAPS ) +};
\ No newline at end of file diff --git a/users/d4mation/tap-dance.h b/users/d4mation/tap-dance.h new file mode 100644 index 000000000..0087c4a6e --- /dev/null +++ b/users/d4mation/tap-dance.h @@ -0,0 +1,7 @@ +#pragma once + +#include "quantum.h" + +enum tap_dance { + SHIFT_CAPS = 0 +};
\ No newline at end of file diff --git a/users/d4mation/tap-hold.c b/users/d4mation/tap-hold.c new file mode 100644 index 000000000..0c5119f99 --- /dev/null +++ b/users/d4mation/tap-hold.c @@ -0,0 +1,28 @@ +#include "tap-hold.h" + +#ifndef TAP_HOLD_TIME +#define TAP_HOLD_TIME 200 +#endif + +uint16_t tap_hold_timer; + +void tap_or_hold( keyrecord_t *record, uint16_t tap, uint16_t hold ) { + + if ( record->event.pressed ) { + tap_hold_timer = timer_read(); + } else { + + if ( tap_hold_timer && + timer_elapsed( tap_hold_timer ) > TAP_HOLD_TIME ) { + /* Held down then released */ + tap_code( hold ); + } else { + /* Quickly Tapped */ + tap_code( tap ); + } + + tap_hold_timer = 0; + + } + +}
\ No newline at end of file diff --git a/users/d4mation/tap-hold.h b/users/d4mation/tap-hold.h new file mode 100644 index 000000000..52dc0830f --- /dev/null +++ b/users/d4mation/tap-hold.h @@ -0,0 +1,5 @@ +#pragma once + +#include "quantum.h" + +void tap_or_hold( keyrecord_t *record, uint16_t tap, uint16_t hold );
\ No newline at end of file diff --git a/users/d4mation/zalgo.c b/users/d4mation/zalgo.c new file mode 100644 index 000000000..3a1688e05 --- /dev/null +++ b/users/d4mation/zalgo.c @@ -0,0 +1,21 @@ +#include "zalgo.h" + +void zalgo_text( uint16_t keycode ) { + + tap_code( keycode ); + + int number = ( rand() % ( 8 + 1 - 2 ) ) + 2; + unsigned int index; + + unicode_input_start(); + + for ( index = 0; index < number; index++ ) { + + uint16_t hex = ( rand() % ( 0x036F + 1 - 0x0300 ) ) + 0x0300; + register_hex( hex ); + + } + + unicode_input_finish(); + +}
\ No newline at end of file diff --git a/users/d4mation/zalgo.h b/users/d4mation/zalgo.h new file mode 100644 index 000000000..f59fc035b --- /dev/null +++ b/users/d4mation/zalgo.h @@ -0,0 +1,5 @@ +#pragma once + +#include "quantum.h" + +void zalgo_text( uint16_t keycode );
\ No newline at end of file diff --git a/users/drashna/drashna.c b/users/drashna/drashna.c index 71779a621..1a4ee9b41 100644 --- a/users/drashna/drashna.c +++ b/users/drashna/drashna.c @@ -121,9 +121,13 @@ void shutdown_user(void) { rgblight_setrgb_red(); #endif // RGBLIGHT_ENABLE #ifdef RGB_MATRIX_ENABLE +# ifdef __AVR__ rgb_matrix_set_color_all(0xFF, 0x00, 0x00); rgb_matrix_update_pwm_buffers(); - +# else + rgb_matrix_sethsv_noeeprom(0, 255, 255); + rgb_matrix_mode_noeeprom(1); +# endif #endif // RGB_MATRIX_ENABLE shutdown_keymap(); } diff --git a/users/drashna/process_records.c b/users/drashna/process_records.c index 2f79ad11c..af3ee9cf0 100644 --- a/users/drashna/process_records.c +++ b/users/drashna/process_records.c @@ -80,13 +80,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { copy_paste_timer = timer_read(); } else { if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy - register_code(KC_LCTL); - tap_code(KC_C); - unregister_code(KC_LCTL); + tap_code16(LCTL(KC_C)); } else { // Tap, paste - register_code(KC_LCTL); - tap_code(KC_V); - unregister_code(KC_LCTL); + tap_code16(LCTL(KC_V)); } } break; diff --git a/users/drashna/rgb_stuff.c b/users/drashna/rgb_stuff.c index 52ec61c22..e7247f754 100644 --- a/users/drashna/rgb_stuff.c +++ b/users/drashna/rgb_stuff.c @@ -147,6 +147,7 @@ bool rgblight_twinkle_is_led_used(uint8_t index) { /* Handler for fading/twinkling effect */ void scan_rgblight_fadeout(void) { // Don't effing change this function .... rgblight_sethsv is supppppper intensive bool litup = false; + for (uint8_t light_index = 0; light_index < RGBLED_NUM; ++light_index) { if (lights[light_index].enabled && timer_elapsed(lights[light_index].timer) > 10) { rgblight_fadeout *light = &lights[light_index]; @@ -179,6 +180,7 @@ void start_rgb_light(void) { uint8_t indices_count = 0; uint8_t min_life = 0xFF; uint8_t min_life_index = -1; + for (uint8_t index = 0; index < RGBLED_NUM; ++index) { if (rgblight_twinkle_is_led_used(index)) { continue; @@ -248,7 +250,14 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); eeconfig_update_user(userspace_config.raw); if (userspace_config.rgb_layer_change) { +# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE) + rgblight_enable_noeeprom(); +# endif layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better) +# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE) + } else { + rgblight_disable_noeeprom(); +# endif } } #endif // RGBLIGHT_ENABLE @@ -265,28 +274,182 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { } #endif break; +#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + case RGB_TOG: + // Split keyboards need to trigger on key-up for edge-case issue +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_toggle(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_toggle(); +# endif + } + return false; + break; case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions if (record->event.pressed) { - bool is_eeprom_updated = false; -#ifdef RGBLIGHT_ENABLE + bool is_eeprom_updated; +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) // This disables layer indication, as it's assumed that if you're changing this ... you want that disabled if (userspace_config.rgb_layer_change) { userspace_config.rgb_layer_change = false; dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); is_eeprom_updated = true; } -#endif -#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) +# endif +# if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) if (userspace_config.rgb_matrix_idle_anim) { userspace_config.rgb_matrix_idle_anim = false; dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim); is_eeprom_updated = true; } -#endif +# endif if (is_eeprom_updated) { eeconfig_update_user(userspace_config.raw); } } + +# if defined(RGBLIGHT_DISABLE_KEYCODES) || defined(RGB_MATRIX_DISABLE_KEYCODES) + if (keycode == RGB_MODE_FORWARD && record->event.pressed) { + uint8_t shifted = get_mods() & (MOD_MASK_SHIFT); + if (shifted) { +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_step_reverse(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_step_reverse(); +# endif + } else { +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_step(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_step(); +# endif + } + } else if (keycode == RGB_MODE_REVERSE && record->event.pressed) { + uint8_t shifted = get_mods() & (MOD_MASK_SHIFT); + if (shifted) { +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_step(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_step(); +# endif + } else { +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_step_reverse(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_step_reverse(); +# endif + } + } else if (keycode == RGB_HUI) { +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_increase_hue(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_increase_hue(); +# endif + } + } else if (keycode == RGB_HUD) { +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_decrease_hue(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_decrease_hue(); +# endif + } + } else if (keycode == RGB_SAI) { +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_increase_sat(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_increase_sat(); +# endif + } + } else if (keycode == RGB_SAD) { +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_decrease_sat(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_decrease_sat(); +# endif + } + } else if (keycode == RGB_VAI) { +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_increase_val(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_increase_val(); +# endif + } + } else if (keycode == RGB_VAD) { +# ifndef SPLIT_KEYBOARD + if (record->event.pressed) { +# else + if (!record->event.pressed) { +# endif +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_decrease_val(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_decrease_val(); +# endif + } + } else if (keycode == RGB_SPI) { + if (record->event.pressed) { +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_increase_speed(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_increase_speed(); +# endif + } + } else if (keycode == RGB_SPD) { + if (record->event.pressed) { +# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES) + rgblight_decrease_speed(); +# endif +# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES) + rgb_matrix_decrease_speed(); +# endif + } + } + return false; +# endif +#endif + break; } return true; diff --git a/users/drashna/rules.mk b/users/drashna/rules.mk index 882857fc8..4d55da803 100644 --- a/users/drashna/rules.mk +++ b/users/drashna/rules.mk @@ -1,7 +1,9 @@ SRC += drashna.c \ process_records.c -LTO_ENABLE = yes +ifneq ($(PLATFORM),CHIBIOS) + LTO_ENABLE = yes +endif SPACE_CADET_ENABLE = no ifneq ($(strip $(NO_SECRETS)), yes) @@ -58,4 +60,4 @@ endif # this should be handled per keyboard, but until that happens ... ifeq ($(strip $(PROTOCOL)), VUSB) NKRO_ENABLE = no -endif
\ No newline at end of file +endif diff --git a/users/hvp/hvp.h b/users/hvp/hvp.h index 2b2210f87..99da258aa 100644 --- a/users/hvp/hvp.h +++ b/users/hvp/hvp.h @@ -4,3 +4,9 @@ # include "tap_dances.h" #endif #include "quantum.h" + +#define TAPPING_TERM 150 + +// Keys + +#define D_NAVI MT(MOD_LCTL | MOD_LSFT, KC_D)
\ No newline at end of file diff --git a/users/hvp/tap_dances.c b/users/hvp/tap_dances.c index bb102b30a..1269d5f27 100644 --- a/users/hvp/tap_dances.c +++ b/users/hvp/tap_dances.c @@ -6,10 +6,7 @@ void dance_1_finished(qk_tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code(KC_SCLN); } else { - register_code(KC_RALT); - register_code(KC_O); - unregister_code(KC_RALT); - unregister_code(KC_O); + tap_code16(ALGR(KC_A)); } } @@ -17,8 +14,7 @@ void dance_1_reset(qk_tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_SCLN); } else { - unregister_code(KC_RALT); - unregister_code(KC_O); + unregister_code16(ALGR(KC_A)); } } @@ -27,10 +23,7 @@ void dance_2_finished(qk_tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code(KC_QUOT); } else { - register_code(KC_RALT); - register_code(KC_A); - unregister_code(KC_RALT); - unregister_code(KC_A); + tap_code16(ALGR(KC_W)); } } @@ -38,8 +31,7 @@ void dance_2_reset(qk_tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_QUOT); } else { - unregister_code(KC_RALT); - unregister_code(KC_A); + unregister_code16(ALGR(KC_W)); } } @@ -49,10 +41,7 @@ void dance_3_finished(qk_tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code(KC_SLSH); } else { - register_code(KC_RALT); - register_code(KC_W); - unregister_code(KC_RALT); - unregister_code(KC_W); + tap_code16(ALGR(KC_O)); } } @@ -60,8 +49,43 @@ void dance_3_reset(qk_tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_SLSH); } else { - unregister_code(KC_RALT); - unregister_code(KC_W); + unregister_code16(ALGR(KC_O)); + } +} + +// Tap dance 4 +void dance_4_finished(qk_tap_dance_state_t *state, void *user_data) { + // if (state->count == 2) + if (state->count == 2) { + tap_code(KC_DOT); + } else { + tap_code16(ALGR(KC_W)); + } +} + +void dance_4_reset(qk_tap_dance_state_t *state, void *user_data) { + if (state->count == 2) { + unregister_code(KC_DOT); + } else { + unregister_code16(ALGR(KC_W)); + } +} + +// Tap dance 5 +void dance_5_finished(qk_tap_dance_state_t *state, void *user_data) { + // if (state->count == 2) + if (state->count == 2) { + tap_code(KC_DOT); + } else { + tap_code16(ALGR(KC_O)); + } +} + +void dance_5_reset(qk_tap_dance_state_t *state, void *user_data) { + if (state->count == 2) { + unregister_code(KC_DOT); + } else { + unregister_code16(ALGR(KC_O)); } } @@ -72,4 +96,8 @@ qk_tap_dance_action_t tap_dance_actions[] = { [TD2] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_2_finished, dance_2_reset), - [TD3] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_3_finished, dance_3_reset)};
\ No newline at end of file + [TD3] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_3_finished, dance_3_reset), + + [TD4] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_4_finished, dance_4_reset), + + [TD5] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_5_finished, dance_5_reset)};
\ No newline at end of file diff --git a/users/hvp/tap_dances.h b/users/hvp/tap_dances.h index 705985faa..cad9bd90e 100644 --- a/users/hvp/tap_dances.h +++ b/users/hvp/tap_dances.h @@ -6,5 +6,7 @@ enum tapdance_id { TD1 = 0, TD2, - TD3 + TD3, + TD4, + TD5 }; diff --git a/users/manna-harbour_miryoku/config.h b/users/manna-harbour_miryoku/config.h index c3c513d06..5ac3208c9 100644 --- a/users/manna-harbour_miryoku/config.h +++ b/users/manna-harbour_miryoku/config.h @@ -1,5 +1,4 @@ - -// generated from users/manna-harbour_miryoku/miryoku.org +// generated from users/manna-harbour_miryoku/miryoku.org -*- buffer-read-only: t -*- #pragma once diff --git a/users/manna-harbour_miryoku/manna-harbour_miryoku.c b/users/manna-harbour_miryoku/manna-harbour_miryoku.c index a50677008..8ae38c25c 100644 --- a/users/manna-harbour_miryoku/manna-harbour_miryoku.c +++ b/users/manna-harbour_miryoku/manna-harbour_miryoku.c @@ -1,12 +1,18 @@ - -// generated from users/manna-harbour_miryoku/miryoku.org +// generated from users/manna-harbour_miryoku/miryoku.org -*- buffer-read-only: t -*- #include QMK_KEYBOARD_H #define KC_NP KC_NO // key is not present #define KC_NA KC_NO // present but not available for use #define KC_NU KC_NO // available but not used + +// non-KC_ keycodes #define KC_RST RESET +#define KC_TOG RGB_TOG +#define KC_MOD RGB_MOD +#define KC_HUI RGB_HUI +#define KC_SAI RGB_SAI +#define KC_VAI RGB_VAI enum layers { BASE, MEDR, NAVR, MOUR, NSSL, NSL, FUNL }; @@ -30,7 +36,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KC_NP, KC_NP, KC_NA, KC_NA, KC_NA, KC_BTN3, KC_BTN1, KC_BTN2, KC_NP, KC_NP ), [MEDR] = LAYOUT_miryoku( - KC_RST, KC_NA, KC_NA, KC_NA, KC_NA, KC_NU, KC_NU, KC_NU, KC_NU, KC_NU, + KC_RST, KC_NA, KC_NA, KC_NA, KC_NA, KC_TOG, KC_MOD, KC_HUI, KC_SAI, KC_VAI, KC_LGUI, KC_LALT, KC_LCTL, KC_LSFT, KC_NA, KC_NU, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_NA, KC_ALGR, KC_NA, KC_NA, KC_NA, KC_NU, KC_NU, KC_NU, KC_NU, KC_NU, KC_NP, KC_NP, KC_NA, KC_NA, KC_NA, KC_MSTP, KC_MPLY, KC_MUTE, KC_NP, KC_NP diff --git a/users/manna-harbour_miryoku/miryoku.org b/users/manna-harbour_miryoku/miryoku.org index c352df8fd..692321d01 100644 --- a/users/manna-harbour_miryoku/miryoku.org +++ b/users/manna-harbour_miryoku/miryoku.org @@ -134,11 +134,12 @@ the home position. Unused keys are available for other related functions. *** Media (MEDR) Tertiary RH layer is media control, with volume up / down and next / prev -mirroring the navigation keys. Pause, stop and mute are on thumbs. Unused keys -are available for other related functions. +mirroring the navigation keys. Pause, stop and mute are on thumbs. RGB control +is on the top row (combine with shift to invert). Unused keys are available for +other related functions. #+NAME: medr -| | | | | | +| TOG | MOD | HUI | SAI | VAI | | | MPRV | VOLD | VOLU | MNXT | | | | | | | | MSTP | MPLY | MUTE | NP | NP | @@ -383,7 +384,7 @@ Header for tangled src files. #+NAME: header #+BEGIN_SRC C :tangle no -generated from users/manna-harbour_miryoku/miryoku.org +generated from users/manna-harbour_miryoku/miryoku.org -*- buffer-read-only: t -*- #+END_SRC @@ -404,8 +405,7 @@ bottom row unused and the rest of the bottom row are the thumb keys. Contains the keymap. Included from keymap.c [[./manna-harbour_miryoku.c][users/manna-harbour_miryoku/manna-harbour_miryoku.c]] -#+BEGIN_SRC C :noweb yes :tangle manna-harbour_miryoku.c - +#+BEGIN_SRC C :noweb yes :padline no :tangle manna-harbour_miryoku.c // <<header>> #include QMK_KEYBOARD_H @@ -413,7 +413,14 @@ Contains the keymap. Included from keymap.c #define KC_NP KC_NO // key is not present #define KC_NA KC_NO // present but not available for use #define KC_NU KC_NO // available but not used + +// non-KC_ keycodes #define KC_RST RESET +#define KC_TOG RGB_TOG +#define KC_MOD RGB_MOD +#define KC_HUI RGB_HUI +#define KC_SAI RGB_SAI +#define KC_VAI RGB_VAI <<table-enums()>> @@ -434,8 +441,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { Config options. Automatically included. [[./config.h][users/manna-harbour_miryoku/config.h]] -#+BEGIN_SRC C :noweb yes :tangle config.h - +#+BEGIN_SRC C :noweb yes :padline no :tangle config.h // <<header>> #pragma once @@ -457,12 +463,12 @@ Config options. Automatically included. Build options. Automatically included. [[./rules.mk][users/manna-harbour_miryoku/rules.mk]] -#+BEGIN_SRC makefile :noweb yes :tangle rules.mk - +#+BEGIN_SRC makefile :noweb yes :padline no :tangle rules.mk # <<header>> MOUSEKEY_ENABLE = yes # Mouse keys(+4700) EXTRAKEY_ENABLE = yes # Audio control and System control(+450) +EXTRAFLAGS += -flto # Link Time Optimization to reduce code size, 31358->28034/28672 #+END_SRC @@ -481,8 +487,7 @@ thumb key is the innermost key of the partial bottom row. The remaining keys are unused. [[../../layouts/community/ergodox/manna-harbour_miryoku/keymap.c][layouts/community/ergodox/manna-harbour_miryoku/keymap.c]] -#+BEGIN_SRC C :noweb yes :tangle ../../layouts/community/ergodox/manna-harbour_miryoku/keymap.c - +#+BEGIN_SRC C :noweb yes :padline no :tangle ../../layouts/community/ergodox/manna-harbour_miryoku/keymap.c // <<header>> #define LAYOUT_miryoku(\ @@ -524,8 +529,7 @@ provide some column stagger on ortho keyboards. The bottom row left 3 columns are the thumb keys. The remaining keys are unused. [[../../layouts/community/ortho_4x12/manna-harbour_miryoku/keymap.c][layouts/community/ortho_4x12/manna-harbour_miryoku/keymap.c]] -#+BEGIN_SRC C :noweb yes :tangle ../../layouts/community/ortho_4x12/manna-harbour_miryoku/keymap.c - +#+BEGIN_SRC C :noweb yes :padline no :tangle ../../layouts/community/ortho_4x12/manna-harbour_miryoku/keymap.c // <<header>> #define LAYOUT_miryoku(\ @@ -561,14 +565,14 @@ To use the keymap on a keyboard which does not support the layouts feature, LAYOUT_miryoku is defined as a macro mapping onto the keyboard's own LAYOUT macro, leaving the unused keys as KC_NO. The userspace keymap is then included. - *** crkbd The outer columns are unused. -[[../../keyboards/crkbd/keymaps/manna-harbour_miryoku/keymap.c][keyboards/crkbd/keymaps/manna-harbour_miryoku/keymap.c]] -#+BEGIN_SRC C :noweb yes :tangle ../../keyboards/crkbd/keymaps/manna-harbour_miryoku/keymap.c +**** keymap.c +[[../../keyboards/crkbd/keymaps/manna-harbour_miryoku/keymap.c][keyboards/crkbd/keymaps/manna-harbour_miryoku/keymap.c]] +#+BEGIN_SRC C :noweb yes :padline no :tangle ../../keyboards/crkbd/keymaps/manna-harbour_miryoku/keymap.c // <<header>> #define LAYOUT_miryoku( \ @@ -586,12 +590,92 @@ KC_NO, K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, KC_ #include "manna-harbour_miryoku.c" + +#ifdef SSD1306OLED + +#include "ssd1306.h" + +void matrix_init_user(void) { + iota_gfx_init(!has_usb()); // turns on the display +} + +// When add source files to SRC in rules.mk, you can use functions. +const char *read_logo(void); + +void matrix_scan_user(void) { + iota_gfx_task(); +} + +void matrix_render_user(struct CharacterMatrix *matrix) { + if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) { + matrix_write(matrix, read_logo()); + } +} + +void matrix_update(struct CharacterMatrix *dest, const struct CharacterMatrix *source) { + if (memcmp(dest->display, source->display, sizeof(dest->display))) { + memcpy(dest->display, source->display, sizeof(dest->display)); + dest->dirty = true; + } +} + +void iota_gfx_task_user(void) { + struct CharacterMatrix matrix; + matrix_clear(&matrix); + matrix_render_user(&matrix); + matrix_update(&display, &matrix); +} + +#endif //SSD1306OLED + #+END_SRC + +**** config.h + +[[../../keyboards/crkbd/keymaps/manna-harbour_miryoku/config.h][keyboards/crkbd/keymaps/manna-harbour_miryoku/config.h]] +#+BEGIN_SRC C :noweb yes :padline no :tangle ../../keyboards/crkbd/keymaps/manna-harbour_miryoku/config.h +// <<header>> + +#pragma once + +#define EE_HANDS + +#ifdef RGB_MATRIX_ENABLE +#define RGB_MATRIX_KEYPRESSES // reacts to keypresses +#define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended +#define RGB_MATRIX_FRAMEBUFFER_EFFECTS +#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash. +#define RGB_MATRIX_HUE_STEP 8 +#define RGB_MATRIX_SAT_STEP 8 +#define RGB_MATRIX_VAL_STEP 8 +#define RGB_MATRIX_SPD_STEP 10 +#endif + +#define SSD1306OLED // old oled driver + +#+END_SRC + + +**** rules.mk + +[[../../keyboards/crkbd/keymaps/manna-harbour_miryoku/rules.mk][keyboards/crkbd/keymaps/manna-harbour_miryoku/rules.mk]] +#+BEGIN_SRC C :noweb yes :padline no :tangle ../../keyboards/crkbd/keymaps/manna-harbour_miryoku/rules.mk +# <<header>> + +RGB_MATRIX_ENABLE = WS2812 + +# old oled driver +SRC += ./lib/glcdfont.c \ + ./lib/logo_reader.c + +#+END_SRC + + To build for this keyboard, #+BEGIN_SRC sh :tangle no -cd ../.. && make crkbd:manna-harbour_miryoku:avrdude +cd ../.. && make crkbd:manna-harbour_miryoku:flash #+END_SRC diff --git a/users/manna-harbour_miryoku/rules.mk b/users/manna-harbour_miryoku/rules.mk index baff1431f..a54616b47 100644 --- a/users/manna-harbour_miryoku/rules.mk +++ b/users/manna-harbour_miryoku/rules.mk @@ -1,5 +1,5 @@ - -# generated from users/manna-harbour_miryoku/miryoku.org +# generated from users/manna-harbour_miryoku/miryoku.org -*- buffer-read-only: t -*- MOUSEKEY_ENABLE = yes # Mouse keys(+4700) EXTRAKEY_ENABLE = yes # Audio control and System control(+450) +LTO_ENABLE = yes diff --git a/users/mverteuil/.gitignore b/users/mverteuil/.gitignore new file mode 100644 index 000000000..785f649dc --- /dev/null +++ b/users/mverteuil/.gitignore @@ -0,0 +1 @@ +copyright.h diff --git a/users/mverteuil/mverteuil.c b/users/mverteuil/mverteuil.c new file mode 100644 index 000000000..a3afc417f --- /dev/null +++ b/users/mverteuil/mverteuil.c @@ -0,0 +1,2 @@ +#include QMK_KEYBOARD_H +#include "mverteuil.h" diff --git a/users/mverteuil/mverteuil.h b/users/mverteuil/mverteuil.h new file mode 100644 index 000000000..1119b75ad --- /dev/null +++ b/users/mverteuil/mverteuil.h @@ -0,0 +1,21 @@ +#if AUDIO_ENABLE +# if __has_include("copyright.h") +# include "copyright.h" +# endif + +# define LOWER_SOUND S__NOTE(_EF5), W__NOTE(_REST), Q__NOTE(_E4) +# define NUMPAD_SOUND S__NOTE(_DF5), S__NOTE(_REST), S__NOTE(_C6) +# define RAISE_SOUND S__NOTE(_E4), W__NOTE(_REST), Q__NOTE(_EF5) + +# define AUDIO_ON_SONG SONG(ZELDA_PUZZLE) +# define LAYER_FUNCROW_ON_SONG SONG(COLEMAK_SOUND) +# define LAYER_FUNCROW_OFF_SONG SONG(QWERTY_SOUND) +# define LAYER_NMPAD_SONG SONG(NUMPAD_SOUND) +# define LAYER_LOWER_SONG SONG(LOWER_SOUND) +# define LAYER_RAISE_SONG SONG(RAISE_SOUND) +#else +// No-op version of PLAY_SONG instead of many checks for AUDIO_ENABLED +# ifndef PLAY_SONG +# define PLAY_SONG(ARG) // ARG +# endif +#endif diff --git a/users/mverteuil/rules.mk b/users/mverteuil/rules.mk new file mode 100644 index 000000000..bfc4b1ed1 --- /dev/null +++ b/users/mverteuil/rules.mk @@ -0,0 +1 @@ +SRC += mverteuil.c diff --git a/users/rossman360/readme.md b/users/rossman360/readme.md new file mode 100644 index 000000000..ebb17d16c --- /dev/null +++ b/users/rossman360/readme.md @@ -0,0 +1,14 @@ +Copyright 2020 Ross Montsinger rmontsinger@gmail.com @Rossman360 + +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/>.
\ No newline at end of file diff --git a/users/rossman360/rossman360.c b/users/rossman360/rossman360.c new file mode 100644 index 000000000..a1c4ad8f9 --- /dev/null +++ b/users/rossman360/rossman360.c @@ -0,0 +1,80 @@ +#include "rossman360.h" + +void my_custom_function(void) { + +} + +__attribute__ ((weak)) +bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { + return true; +} + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { +switch (keycode) { + case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader + if (!record->event.pressed) { + uint8_t temp_mod = get_mods(); + uint8_t temp_osm = get_oneshot_mods(); + clear_mods(); clear_oneshot_mods(); + SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP); + #ifndef FLASH_BOOTLOADER + if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) + #endif + { + SEND_STRING(":flash"); + } + if ((temp_mod | temp_osm) & MOD_MASK_CTRL) { + SEND_STRING(" -j8 --output-sync"); + } + tap_code(KC_ENT); + set_mods(temp_mod); + } + break; + case CSPEAK: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_PGDOWN) SS_TAP(X_ENTER) SS_TAP(X_ENTER) SS_TAP(X_PGDOWN)); + } + break; + case SPEAK1: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_PGDOWN) SS_TAP(X_ENTER) SS_TAP(X_ENTER) SS_TAP(X_PGDOWN) SS_LCTRL(SS_TAP(X_1))); + } + break; + case SPEAK2: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_PGDOWN) SS_TAP(X_ENTER) SS_TAP(X_ENTER) SS_TAP(X_PGDOWN) SS_LCTRL(SS_TAP(X_2))); + } + break; + case SPEAK3: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_PGDOWN) SS_TAP(X_ENTER) SS_TAP(X_ENTER) SS_TAP(X_PGDOWN) SS_LCTRL(SS_TAP(X_3))); + } + break; + case SPEAK4: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_PGDOWN) SS_TAP(X_ENTER) SS_TAP(X_ENTER) SS_TAP(X_PGDOWN) SS_LCTRL(SS_TAP(X_4))); + } + break; + case PARADOWN: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_PGDOWN) SS_TAP(X_ENTER) SS_TAP(X_PGDOWN)); + } + break; + case PMERGE: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_HOME) SS_TAP(X_BSPACE) SS_TAP(X_SPACE) SS_LCTRL(SS_TAP(X_BSPACE)) SS_TAP(X_SPACE)); + } + break; + case WREFRESH: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_SPACE) SS_TAP(X_BSPACE)); + } + break; + case REMCAPS: + if (record->event.pressed) { + SEND_STRING(SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_LCTRL(SS_TAP(X_LEFT)) SS_TAP(X_DELETE)); + } + break; +}; +return true; +}; diff --git a/users/rossman360/rossman360.h b/users/rossman360/rossman360.h new file mode 100644 index 000000000..9d6ee5981 --- /dev/null +++ b/users/rossman360/rossman360.h @@ -0,0 +1,28 @@ +#pragma once +#include "quantum.h" + +#define BWORD LCTL(KC_BSPC) +#define LWORD LCTL(KC_LEFT) +#define RWORD LCTL(KC_RIGHT) +#define JUMPBACK LSFT(KC_TAB) +#define UNDO LCTL(KC_Z) +#define XPANDR LCTL(LSFT(KC_X)) +#define NTAB LCTL(KC_T) +#define CTAB LCTL(KC_W) +#define XPANDR LCTL(LSFT(KC_X)) +#define CMDBSP MT(MOD_LGUI, KC_BSPC) +#define ALTDEL MT(MOD_LALT, KC_DEL) + +// Define all of +enum custom_keycodes { + KC_MAKE = SAFE_RANGE, + CSPEAK, + SPEAK1, + SPEAK2, + SPEAK3, + SPEAK4, + PARADOWN, + WREFRESH, + PMERGE, + REMCAPS, +}; diff --git a/users/rossman360/rules.mk b/users/rossman360/rules.mk new file mode 100644 index 000000000..8aaa74316 --- /dev/null +++ b/users/rossman360/rules.mk @@ -0,0 +1,5 @@ +SRC += rossman360.c + +ifeq ($(strip $(MACROS_ENABLED)), yes) + OPT_DEFS += -DMACROS_ENABLED +endif
\ No newline at end of file diff --git a/users/stanrc85/stanrc85.c b/users/stanrc85/stanrc85.c index e3da6d646..6ea0e33bc 100644 --- a/users/stanrc85/stanrc85.c +++ b/users/stanrc85/stanrc85.c @@ -56,26 +56,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { if (!record->event.pressed) { uint8_t mods = get_mods(); clear_mods(); - send_string_with_delay_P(PSTR("make " QMK_KEYBOARD ":" QMK_KEYMAP), 10); + send_string_with_delay_P(PSTR("qmk compile -kb " QMK_KEYBOARD " -km " QMK_KEYMAP "\n"), 10); //New way if (mods & MOD_MASK_SHIFT) { - //RESET board for flashing if SHIFT held or tapped with KC_MAKE - #if defined(__arm__) - send_string_with_delay_P(PSTR(":dfu-util"), 10); - #elif defined(BOOTLOADER_DFU) - send_string_with_delay_P(PSTR(":dfu"), 10); - #elif defined(BOOTLOADER_HALFKAY) - send_string_with_delay_P(PSTR(":teensy"), 10); - #elif defined(BOOTLOADER_CATERINA) - send_string_with_delay_P(PSTR(":avrdude"), 10); - #endif // bootloader options - send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), 10); + send_string(SS_LGUI()); + send_string("qmk toolbox\n"); reset_keyboard(); } - if (mods & MOD_MASK_CTRL) { - send_string_with_delay_P(PSTR(" -j8 --output-sync"), 10); - } - send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), 10); - set_mods(mods); + set_mods(mods); } break; case KC_RDP: //Opens Windows RDP diff --git a/users/twschum/config.h b/users/twschum/config.h new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/users/twschum/config.h diff --git a/users/twschum/readme.md b/users/twschum/readme.md new file mode 100644 index 000000000..b354e4b79 --- /dev/null +++ b/users/twschum/readme.md @@ -0,0 +1,14 @@ +Copyright 2019 Tim Schumacher <twschum@gmail.com> @twschum + +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/>. diff --git a/users/twschum/rules.mk b/users/twschum/rules.mk new file mode 100644 index 000000000..9878e6f69 --- /dev/null +++ b/users/twschum/rules.mk @@ -0,0 +1,5 @@ +SRC += twschum.c +SRC += xtonhasvim.c +ifeq ($(strip $(FLASH_BOOTLOADER)), yes) + OPT_DEFS += -DFLASH_BOOTLOADER +endif diff --git a/users/twschum/twschum.c b/users/twschum/twschum.c new file mode 100644 index 000000000..2d34f9571 --- /dev/null +++ b/users/twschum/twschum.c @@ -0,0 +1,257 @@ +#include "twschum.h" + +#ifdef TWSCHUM_TAPPING_CTRL_PREFIX +// state for the great state machine of custom actions! +#define TIMEOUT_DELAY 200 // ms +static uint16_t idle_timer; +static bool timeout_is_active = false; + +static bool ctrl_shortcuts_enabled_g = false; +//static bool B_down = 0; // TODO just use top bit from count +//static int8_t B_count = 0; + +#define N_TAPPING_CTRL_KEYS 2 +static struct Tapping_ctrl_key_t special_keys_g[N_TAPPING_CTRL_KEYS] = { + {false, 0, KC_B}, {false, 0, KC_A} +}; + +static inline void start_idle_timer(void) { + idle_timer = timer_read(); + timeout_is_active = true; +} +static inline void clear_state_after_idle_timeout(void) { + idle_timer = 0; + timeout_is_active = false; + + // send timed out plain keys from tapping ctrl mod + for (int i = 0; i < N_TAPPING_CTRL_KEYS; ++i) { + struct Tapping_ctrl_key_t* key = special_keys_g + i; + repeat_send_keys(key->count, key->keycode); + key->count = 0; + } +} + +inline void matrix_scan_user(void) { + if (timeout_is_active && timer_elapsed(idle_timer) > TIMEOUT_DELAY) { + clear_state_after_idle_timeout(); + } +} + +static inline bool tap_ctrl_event(struct Tapping_ctrl_key_t* key, keyrecord_t* record) { + if (!ctrl_shortcuts_enabled_g) { + // normal operation, just send the plain keycode + if (record->event.pressed) { + register_code(key->keycode); + } + else { + unregister_code(key->keycode); + } + return false; + } + key->down = record->event.pressed; + // increment count and reset timer when key pressed + // start the timeout when released + if (key->down) { + ++(key->count); + timeout_is_active = false; + idle_timer = 0; + } + else { + if (key->count) { + start_idle_timer(); + } + } + return false; +} + +static inline bool tap_ctrl_other_pressed(void) { + for (int i = 0; i < N_TAPPING_CTRL_KEYS; ++i) { + struct Tapping_ctrl_key_t* key = special_keys_g + i; + if (key->count) { + if (key->down) { + // another key has been pressed while the leader key is down, + // so send number of ctrl-KEY combos before the other key + repeat_send_keys(key->count, KC_LCTL, key->keycode); + key->count = 0; + } + else { + // another key pressed after leader key released, + // need to send the plain keycode plus potential mods + if (get_mods() & MOD_MASK_CTRL) { + // make sure to send a shift if prssed + repeat_send_keys(key->count, KC_RSHIFT, key->keycode); + } + else { + repeat_send_keys(key->count, key->keycode); + } + key->count = 0; + } + return true; // will send the other keycode + } + } + return true; // safe default +} +#endif /* TWSCHUM_TAPPING_CTRL_PREFIX */ + + +/* Use RGB underglow to indicate layer + * https://docs.qmk.fm/reference/customizing-functionality + */ +// add to quantum/rgblight_list.h +#ifdef RGBLIGHT_ENABLE +static bool rgb_layers_enabled = true; +static bool rgb_L0_enabled = false; + +layer_state_t layer_state_set_user(layer_state_t state) { + if (!rgb_layers_enabled) { + return state; + } + switch (get_highest_layer(state)) { + case _Base: + if (rgb_L0_enabled) { + rgblight_sethsv_noeeprom(_Base_HSV_ON); + } + else { + rgblight_sethsv_noeeprom(_Base_HSV_OFF); + } + break; + case _Vim: + rgblight_sethsv_noeeprom(_Vim_HSV); + break; + case _Fn: + rgblight_sethsv_noeeprom(_Fn_HSV); + break; + case _Nav: + rgblight_sethsv_noeeprom(_Nav_HSV); + break; + case _Num: + rgblight_sethsv_noeeprom(_Num_HSV); + break; + case _Cfg: + rgblight_sethsv_noeeprom(_Cfg_HSV); + break; + case _None: + rgblight_sethsv_noeeprom(_None_HSV); + break; + } + return state; +} +#endif /* RGBLIGHT_ENABLE */ + +/* process_record_vimlayer: handles the VIM_ keycodes from xtonhasvim's vim + * emulation layer + * add process_record_keymap to allow specific keymap to still add keys + * Makes the callstack look like: + * process_record_ + * _quantum + * _kb + * _user + * _keymap + * _vimlayer + */ +__attribute__ ((weak)) +bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { + return true; +} + +/* Return True to continue processing keycode, false to stop further processing + * process_record_keymap to be call by process_record_user in the vim addon */ +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + + /* keymap gets first whack, then vimlayer */ + if(!process_record_keymap(keycode, record)) return false; + if(!process_record_vimlayer(keycode, record)) return false; + + switch (keycode) { + /* KC_MAKE is a keycode to be used with any keymap + * Outputs `make <keyboard>:<keymap>` + * Holding shift will add the appropriate flashing command (:dfu, + * :teensy, :avrdude, :dfu-util) for a majority of keyboards. + * Holding control will add some commands that will speed up compiling + * time by processing multiple files at once + * For the boards that lack a shift key, or that you want to always + * attempt the flashing part, you can add FLASH_BOOTLOADER = yes to the + * rules.mk of that keymap. + */ + case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader + if (!record->event.pressed) { + uint8_t temp_mod = get_mods(); + uint8_t temp_osm = get_oneshot_mods(); + clear_mods(); clear_oneshot_mods(); + SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP); + #ifndef FLASH_BOOTLOADER + if ( (temp_mod | temp_osm) & MOD_MASK_SHIFT ) { + SEND_STRING(":flash"); + } + #endif + if ( (temp_mod | temp_osm) & MOD_MASK_CTRL) { + SEND_STRING(" -j8 --output-sync"); + } + SEND_STRING(SS_TAP(X_ENTER)); + set_mods(temp_mod); + } + break; + + #ifdef RGBLIGHT_ENABLE + case TG_LAYER_RGB: + if (record->event.pressed) { + rgb_layers_enabled = !rgb_layers_enabled; + } + return false; + case TG_L0_RGB: + if (record->event.pressed) { + rgb_L0_enabled = !rgb_L0_enabled; + } + return false; + #endif + + case SALT_CMD: + if (!record->event.pressed) { + SEND_STRING(SALT_CMD_MACRO); + } + return false; + case LESS_PD: + if (!record->event.pressed) { + SEND_STRING(LESS_PD_MACRO); + } + return false; + case CODE_PASTE: + if (!record->event.pressed) { + SEND_STRING(CODE_PASTE_MACRO); + } + return false; + + #ifdef TWSCHUM_TAPPING_CTRL_PREFIX + case EN_CTRL_SHORTCUTS: + if (record->event.pressed) { + ctrl_shortcuts_enabled_g = !ctrl_shortcuts_enabled_g; + start_idle_timer(); // need to clear out state in some cases + } + return false; + case CTRL_A: + return tap_ctrl_event(&special_keys_g[1], record); + case CTRL_B: + return tap_ctrl_event(&special_keys_g[0], record); + default: + if (record->event.pressed) { + return tap_ctrl_other_pressed(); + } + #endif + } + return true; +} + +#ifdef RGBLIGHT_ENABLE +void matrix_init_user(void) { + // called once on board init + rgblight_enable(); +} +#endif + +void suspend_power_down_user(void) { + // TODO shut off backlighting +} + +void suspend_wakeup_init_user(void) { + // TODO turn on backlighting +} diff --git a/users/twschum/twschum.h b/users/twschum/twschum.h new file mode 100644 index 000000000..e8c9aeffc --- /dev/null +++ b/users/twschum/twschum.h @@ -0,0 +1,131 @@ +#pragma once +#include <stdarg.h> +#include "quantum.h" +#include "xtonhasvim.h" + +/************************** + * QMK Features Used + ************************** + * RGBLIGHT_ENABLE + * - Adds layer indication via RGB underglow + * - see the `layer_definitions` enum and following _*_HSV #defines + * + * + * + ************************** + * Custom Feature Flags + ************************** + * + * TWSCHUM_TAPPING_CTRL_PREFIX + * - Adds feature that makes sending nested sequences of C-a, C-b[, C-b, ...] + * as simple as C-a b [b ...] + * - Not necessarily super useful outside specialized nested tmux sessions, + * but it was a fun state-machine to build + * + * TWSCHUM_VIM_LAYER + * - Fork of xtonhasvim, adding vim-emulation + * + * TWSCHUM_IS_MAC + * - Flag for handling media keys and other settings between OSX and Win/Unix + * without having to include bootmagic + * + ************************** + * Features Wishlist + ************************** + * use VIM_Q as macro recorder! + * Dynamic macros + * Leader functions + * Uniicode leader commands??? (symbolic unicode) + * Mac mode vs not: -probably bootmagic or use default with dynamic swap out here + * KC_MFFD(KC_MEDIA_FAST_FORWARD) and KC_MRWD(KC_MEDIA_REWIND) instead of KC_MNXT and KC_MPRV + */ + +/* Each layer gets a color, overwritable per keyboard */ +enum layers_definitions { + _Base, + _Vim, + _Fn, + _Nav, + _Num, + _Cfg, + _None, +}; +#ifdef RGBLIGHT_ENABLE +#define _Base_HSV_ON HSV_WHITE +#define _Base_HSV_OFF 0, 0, 0 +#define _Vim_HSV HSV_ORANGE +#define _Fn_HSV HSV_GREEN +#define _Nav_HSV HSV_AZURE +#define _Num_HSV HSV_GOLD +#define _Cfg_HSV HSV_RED +#define _None_HSV HSV_WHITE +#endif + +enum extra_keycodes { + TWSCHUM_START = VIM_SAFE_RANGE, + KC_MAKE, // types the make command for this keyboard +#ifdef TWSCHUM_TAPPING_CTRL_PREFIX + CTRL_A, + CTRL_B, + EN_CTRL_SHORTCUTS, +#endif +#ifdef RGBLIGHT_ENABLE + TG_LAYER_RGB, // Toggle between standard RGB underglow, and RGB underglow to do layer indication + TG_L0_RGB, // Toggle color on or off of layer0 +#endif + SALT_CMD, // macro + LESS_PD, // macro + CODE_PASTE, // macro + KEYMAP_SAFE_RANGE, // range to start for the keymap +}; +#define SALT_CMD_MACRO "sudo salt \\* cmd.run ''"SS_TAP(X_LEFT) +#define LESS_PD_MACRO "sudo less /pipedream/cache/" +// TODO mac vs linux +#define CODE_PASTE_MACRO SS_LSFT("\n")"```"SS_LSFT("\n")SS_LALT("v")SS_LSFT("\n")"```" + + +/* PP_NARG macro returns the number of arguments passed to it. + * https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s + */ +#define PP_NARG(...) PP_NARG_(__VA_ARGS__,PP_RSEQ_N()) +#define PP_NARG_(...) PP_ARG_N(__VA_ARGS__) +#define PP_MAX_ARGS 64 +#define PP_ARG_N( \ + _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \ + _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ + _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ + _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ + _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ + _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ + _61,_62,_63,N,...) N +#define PP_RSEQ_N() 63,62,61,60, \ + 59,58,57,56,55,54,53,52,51,50, \ + 49,48,47,46,45,44,43,42,41,40, \ + 39,38,37,36,35,34,33,32,31,30, \ + 29,28,27,26,25,24,23,22,21,20, \ + 19,18,17,16,15,14,13,12,11,10, \ + 9,8,7,6,5,4,3,2,1,0 + +#define send_keys(...) send_n_keys(PP_NARG(__VA_ARGS__), __VA_ARGS__) +static inline void send_n_keys(int n, ...) { + uint8_t i = 0; + uint16_t keycodes[PP_MAX_ARGS]; + va_list keys; + va_start(keys, n); + for (; i < n; ++i) { + keycodes[i] = (uint16_t)va_arg(keys, int); // cast suppresses warning + register_code(keycodes[i]); + } + for (; n > 0; --n) { + unregister_code(keycodes[n-1]); + } + va_end(keys); +} +#define repeat_send_keys(n, ...) {for (int i=0; i < n; ++i) {send_keys(__VA_ARGS__);}} + +/* State functions for nested c-a & c-b leader keystrokes */ +struct Tapping_ctrl_key_t { + bool down; + int8_t count; + const uint16_t keycode; +}; diff --git a/users/twschum/xtonhasvim.c b/users/twschum/xtonhasvim.c new file mode 100644 index 000000000..a1adf39f0 --- /dev/null +++ b/users/twschum/xtonhasvim.c @@ -0,0 +1,593 @@ + /* Copyright 2015-2017 Christon DeWan * + * 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 "xtonhasvim.h" + + +uint16_t vstate = VIM_START; +static bool yank_was_lines = false; +static bool SHIFTED = false; +static uint32_t mod_override_layer_state = 0; +static uint16_t mod_override_triggering_key = 0; + +static void edit(void) { vstate = VIM_START; layer_clear(); } +#define EDIT edit() + + +static void simple_movement(uint16_t keycode) { + switch(keycode) { + case VIM_B: + register_code(KC_LALT); + tap_code16(LSFT(KC_LEFT)); // select to start of this word + unregister_code(KC_LALT); + break; + case VIM_E: + register_code(KC_LALT); + tap_code16(LSFT(KC_RIGHT)); // select to end of this word + unregister_code(KC_LALT); + break; + case VIM_H: + tap_code16(LSFT(KC_LEFT)); + break; + case VIM_J: + tap_code16(LGUI(KC_LEFT)); + tap_code16(LSFT(KC_DOWN)); + tap_code16(LSFT(KC_DOWN)); + break; + case VIM_K: + tap_code16(LGUI(KC_LEFT)); + tap_code(KC_DOWN); + tap_code16(LSFT(KC_UP)); + tap_code16(LSFT(KC_UP)); + break; + case VIM_L: + tap_code16(LSFT(KC_RIGHT)); + break; + case VIM_W: + register_code(KC_LALT); + tap_code16(LSFT(KC_RIGHT)); // select to end of this word + tap_code16(LSFT(KC_RIGHT)); // select to end of next word + tap_code16(LSFT(KC_LEFT)); // select to start of next word + unregister_code(KC_LALT); + break; + } +} + +static void comma_period(uint16_t keycode) { + switch (keycode) { + case VIM_COMMA: + if (SHIFTED) { + // indent + tap_code16(LGUI(KC_LBRACKET)); + } else { + // toggle comment + tap_code16(LGUI(KC_SLASH)); + } + break; + case VIM_PERIOD: + if (SHIFTED) { + // outdent + tap_code16(LGUI(KC_RBRACKET)); + } + break; + } +} + + +bool process_record_vimlayer(uint16_t keycode, keyrecord_t *record) { + + /****** mod passthru *****/ + if(record->event.pressed && layer_state_is(vim_cmd_layer()) && (IS_MOD(keycode) || keycode == LSFT(KC_LALT))) { + mod_override_layer_state = layer_state; + mod_override_triggering_key = keycode; + // TODO: change this to track key location instead + layer_clear(); + return true; // let the event fall through... + } + if(mod_override_layer_state && !record->event.pressed && keycode == mod_override_triggering_key) { + layer_state_set(mod_override_layer_state); + mod_override_layer_state = 0; + mod_override_triggering_key = 0; + return true; + } + + if (VIM_START <= keycode && keycode <= VIM_ESC) { + if(keycode == VIM_SHIFT) { + SHIFTED = record->event.pressed; + return false; + } + + if (record->event.pressed) { + if(keycode == VIM_START) { + // entry from anywhere + layer_on(vim_cmd_layer()); + vstate = VIM_START; + + // reset state + yank_was_lines = false; + SHIFTED = false; + mod_override_layer_state = 0; + mod_override_triggering_key = 0; + + return false; + } + switch(vstate) { + case VIM_START: + switch(keycode){ + /***************************** + * ground state + *****************************/ + case VIM_A: + if(SHIFTED) { + // tap_code16(LGUI(KC_RIGHT)); + tap_code16(LCTL(KC_E)); + } else { + tap_code(KC_RIGHT); + } + EDIT; + break; + case VIM_B: + register_code(KC_LALT); + register_code(KC_LEFT); + break; + case VIM_C: + if(SHIFTED) { + register_code(KC_LSHIFT); + tap_code16(LGUI(KC_RIGHT)); + unregister_code(KC_LSHIFT); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + EDIT; + } else { + vstate = VIM_C; + } + break; + case VIM_D: + if(SHIFTED) { + tap_code16(LCTL(KC_K)); + } else { + vstate = VIM_D; + } + break; + case VIM_E: + register_code(KC_LALT); + register_code(KC_RIGHT); + break; + case VIM_G: + if(SHIFTED) { + tap_code(KC_END); + } else { + vstate = VIM_G; + } + break; + case VIM_H: + register_code(KC_LEFT); + break; + case VIM_I: + if(SHIFTED){ + tap_code16(LCTL(KC_A)); + } + EDIT; + break; + case VIM_J: + if(SHIFTED) { + tap_code16(LGUI(KC_RIGHT)); + tap_code(KC_DEL); + } else { + register_code(KC_DOWN); + } + break; + case VIM_K: + register_code(KC_UP); + break; + case VIM_L: + register_code(KC_RIGHT); + break; + case VIM_O: + if(SHIFTED) { + tap_code16(LGUI(KC_LEFT)); + tap_code(KC_ENTER); + tap_code(KC_UP); + EDIT; + } else { + tap_code16(LGUI(KC_RIGHT)); + tap_code(KC_ENTER); + EDIT; + } + break; + case VIM_P: + if(SHIFTED) { + tap_code16(LGUI(KC_LEFT)); + tap_code16(LGUI(KC_V)); + } else { + if(yank_was_lines) { + tap_code16(LGUI(KC_RIGHT)); + tap_code(KC_RIGHT); + tap_code16(LGUI(KC_V)); + } else { + tap_code16(LGUI(KC_V)); + } + } + break; + case VIM_S: + // s for substitute? + if(SHIFTED) { + tap_code16(LGUI(KC_LEFT)); + register_code(KC_LSHIFT); + tap_code16(LGUI(KC_RIGHT)); + unregister_code(KC_LSHIFT); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + EDIT; + } else { + tap_code16(LSFT(KC_RIGHT)); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + EDIT; + } + break; + case VIM_U: + if(SHIFTED) { + register_code(KC_LSFT); + tap_code16(LGUI(KC_Z)); + unregister_code(KC_LSHIFT); + } else { + tap_code16(LGUI(KC_Z)); + } + break; + case VIM_V: + if(SHIFTED) { + tap_code16(LGUI(KC_LEFT)); + tap_code16(LSFT(KC_DOWN)); + vstate = VIM_VS; + } else { + vstate = VIM_V; + } + break; + case VIM_W: + register_code(KC_LALT); + tap_code(KC_RIGHT); + tap_code(KC_RIGHT); + tap_code(KC_LEFT); + unregister_code(KC_LALT); + break; + case VIM_X: + // tap_code16(LSFT(KC_RIGHT)); + // tap_code16(LGUI(KC_X)); + register_code(KC_DEL); + break; + case VIM_Y: + if(SHIFTED) { + tap_code16(LGUI(KC_LEFT)); + tap_code16(LSFT(KC_DOWN)); + tap_code16(LGUI(KC_C)); + tap_code(KC_RIGHT); + yank_was_lines = true; + } else { + vstate = VIM_Y; + } + break; + case VIM_COMMA: + case VIM_PERIOD: + comma_period(keycode); + break; + } + break; + case VIM_C: + /***************************** + * c- ...for change. I never use this... + *****************************/ + switch(keycode) { + case VIM_B: + case VIM_E: + case VIM_H: + case VIM_J: + case VIM_K: + case VIM_L: + case VIM_W: + simple_movement(keycode); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + EDIT; + break; + + case VIM_C: + tap_code16(LGUI(KC_LEFT)); + register_code(KC_LSHIFT); + tap_code16(LGUI(KC_RIGHT)); + unregister_code(KC_LSHIFT); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + EDIT; + break; + case VIM_I: + vstate = VIM_CI; + break; + default: + vstate = VIM_START; + break; + } + break; + case VIM_CI: + /***************************** + * ci- ...change inner word + *****************************/ + switch(keycode) { + case VIM_W: + tap_code16(LALT(KC_LEFT)); + register_code(KC_LSHIFT); + tap_code16(LALT(KC_RIGHT)); + unregister_code(KC_LSHIFT); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + EDIT; + default: + vstate = VIM_START; + break; + } + break; + case VIM_D: + /***************************** + * d- ...delete stuff + *****************************/ + switch(keycode) { + case VIM_B: + case VIM_E: + case VIM_H: + case VIM_J: + case VIM_K: + case VIM_L: + case VIM_W: + simple_movement(keycode); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + vstate = VIM_START; + break; + case VIM_D: + tap_code16(LGUI(KC_LEFT)); + tap_code16(LSFT(KC_DOWN)); + tap_code16(LGUI(KC_X)); + yank_was_lines = true; + vstate = VIM_START; + break; + case VIM_I: + vstate = VIM_DI; + break; + default: + vstate = VIM_START; + break; + } + break; + case VIM_DI: + /***************************** + * ci- ...delete a word... FROM THE INSIDE! + *****************************/ + switch(keycode) { + case VIM_W: + tap_code16(LALT(KC_LEFT)); + register_code(KC_LSHIFT); + tap_code16(LALT(KC_RIGHT)); + unregister_code(KC_LSHIFT); + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + vstate = VIM_START; + default: + vstate = VIM_START; + break; + } + break; + case VIM_V: + /***************************** + * visual! + *****************************/ + switch(keycode) { + case VIM_D: + case VIM_X: + tap_code16(LGUI(KC_X)); + yank_was_lines = false; + vstate = VIM_START; + break; + case VIM_B: + register_code(KC_LALT); + register_code(KC_LSHIFT); + register_code(KC_LEFT); + // leave open for key repeat + break; + case VIM_E: + register_code(KC_LALT); + register_code(KC_LSHIFT); + register_code(KC_RIGHT); + // leave open for key repeat + break; + case VIM_H: + register_code(KC_LSHIFT); + register_code(KC_LEFT); + break; + case VIM_I: + vstate = VIM_VI; + break; + case VIM_J: + register_code(KC_LSHIFT); + register_code(KC_DOWN); + break; + case VIM_K: + register_code(KC_LSHIFT); + register_code(KC_UP); + break; + case VIM_L: + register_code(KC_LSHIFT); + register_code(KC_RIGHT); + break; + case VIM_W: + register_code(KC_LALT); + tap_code16(LSFT(KC_RIGHT)); // select to end of this word + tap_code16(LSFT(KC_RIGHT)); // select to end of next word + tap_code16(LSFT(KC_LEFT)); // select to start of next word + unregister_code(KC_LALT); + break; + case VIM_P: + tap_code16(LGUI(KC_V)); + vstate = VIM_START; + break; + case VIM_Y: + tap_code16(LGUI(KC_C)); + tap_code(KC_RIGHT); + yank_was_lines = false; + vstate = VIM_START; + break; + case VIM_V: + case VIM_ESC: + tap_code(KC_RIGHT); + vstate = VIM_START; + break; + case VIM_COMMA: + case VIM_PERIOD: + comma_period(keycode); + break; + default: + // do nothing + break; + } + break; + case VIM_VI: + /***************************** + * vi- ...select a word... FROM THE INSIDE! + *****************************/ + switch(keycode) { + case VIM_W: + tap_code16(LALT(KC_LEFT)); + register_code(KC_LSHIFT); + tap_code16(LALT(KC_RIGHT)); + unregister_code(KC_LSHIFT); + vstate = VIM_V; + default: + // ignore + vstate = VIM_V; + break; + } + break; + case VIM_VS: + /***************************** + * visual line + *****************************/ + switch(keycode) { + case VIM_D: + case VIM_X: + tap_code16(LGUI(KC_X)); + yank_was_lines = true; + vstate = VIM_START; + break; + case VIM_J: + register_code(KC_LSHIFT); + register_code(KC_DOWN); + break; + case VIM_K: + register_code(KC_LSHIFT); + register_code(KC_UP); + break; + case VIM_Y: + tap_code16(LGUI(KC_C)); + yank_was_lines = true; + tap_code(KC_RIGHT); + vstate = VIM_START; + break; + case VIM_P: + tap_code16(LGUI(KC_V)); + vstate = VIM_START; + break; + case VIM_V: + case VIM_ESC: + tap_code(KC_RIGHT); + vstate = VIM_START; + break; + case VIM_COMMA: + case VIM_PERIOD: + comma_period(keycode); + break; + default: + // do nothing + break; + } + break; + case VIM_G: + /***************************** + * gg, and a grab-bag of other macros i find useful + *****************************/ + switch(keycode) { + case VIM_G: + tap_code(KC_HOME); + break; + // codes b + case VIM_H: + tap_code16(LCTL(KC_A)); + break; + case VIM_J: + register_code(KC_PGDN); + break; + case VIM_K: + register_code(KC_PGUP); + break; + case VIM_L: + tap_code16(LCTL(KC_E)); + break; + default: + // do nothing + break; + } + vstate = VIM_START; + break; + case VIM_Y: + /***************************** + * yoink! + *****************************/ + switch(keycode) { + case VIM_B: + case VIM_E: + case VIM_H: + case VIM_J: + case VIM_K: + case VIM_L: + case VIM_W: + simple_movement(keycode); + tap_code16(LGUI(KC_C)); + tap_code(KC_RIGHT); + yank_was_lines = false; + break; + case VIM_Y: + tap_code16(LGUI(KC_LEFT)); + tap_code16(LSFT(KC_DOWN)); + tap_code16(LGUI(KC_C)); + tap_code(KC_RIGHT); + yank_was_lines = true; + break; + default: + // NOTHING + break; + } + vstate = VIM_START; + break; + } + } else { + /************************ + * key unregister_code events + ************************/ + clear_keyboard(); + } + return false; + } else { + return true; + } +} + diff --git a/users/twschum/xtonhasvim.h b/users/twschum/xtonhasvim.h new file mode 100644 index 000000000..fd9ebd4f0 --- /dev/null +++ b/users/twschum/xtonhasvim.h @@ -0,0 +1,62 @@ + /* Copyright 2015-2017 Christon DeWan + * + * 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/>. + */ + +#ifndef USERSPACE +#define USERSPACE + +#include QMK_KEYBOARD_H + +enum xtonhasvim_keycodes { + VIM_START = SAFE_RANGE, // bookend for vim states + VIM_A, + VIM_B, + VIM_C, + VIM_CI, + VIM_D, + VIM_DI, + VIM_E, + VIM_H, + VIM_G, + VIM_I, + VIM_J, + VIM_K, + VIM_L, + VIM_O, + VIM_P, + VIM_S, + VIM_U, + VIM_V, + VIM_VS, // visual-line + VIM_VI, + VIM_W, + VIM_X, + VIM_Y, + VIM_PERIOD, // to support indent/outdent + VIM_COMMA, // and toggle comments + VIM_SHIFT, // avoid side-effect of supporting real shift. + VIM_ESC, // bookend + VIM_SAFE_RANGE // start other keycodes here. +}; + +bool process_record_vimlayer(uint16_t keycode, keyrecord_t *record); + +// NOTE: Define this in keymap.c to return vim layer +extern uint8_t vim_cmd_layer(void); + +extern uint16_t vstate; + + +#endif |