masq
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Keymap] Userspace refactor, adding leader key functionality (#7790) 

* Userspace refactor

* Fixed missed ifdef

* tapcode16, adjust layout

* glcdfont changes from #7745

* Modify Keymaps, add workman

* RGB & OLED update
This commit is contained in:
Akaash Suresh 2020-01-09 13:57:54 -06:00 committed by Drashna Jaelre
parent 71de09d751
commit caa70df816
25 changed files with 458 additions and 483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
keyboards/crkbd/keymaps/curry/config.h
View File

@ -6,23 +6,7 @@
#define OLED_DISABLE_TIMEOUT #define OLED_DISABLE_TIMEOUT
#define TAPPING_TERM_PER_KEY #define TAPPING_TERM_PER_KEY
#ifdef RGBLIGHT_ENABLE #if defined(RGB_MATRIX_ENABLE)
# undef RGBLED_NUM
# define RGBLED_NUM 27
# define RGBLIGHT_HUE_STEP 8
# define RGBLIGHT_SAT_STEP 8
# define RGBLIGHT_VAL_STEP 5
# define RGBLIGHT_LIMIT_VAL 120
#endif
#ifdef RGB_MATRIX_ENABLE
# define RGB_MATRIX_KEYPRESSES // reacts to keypresses
// # define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
// # define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
# define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
// # define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
// # define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
# define RGB_MATRIX_MAXIMUM_BRIGHTNESS 120 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255 # define RGB_MATRIX_MAXIMUM_BRIGHTNESS 120 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
# define RGB_MATRIX_HUE_STEP 8 # define RGB_MATRIX_HUE_STEP 8
# define RGB_MATRIX_SAT_STEP 8 # define RGB_MATRIX_SAT_STEP 8

18
keyboards/crkbd/keymaps/curry/keymap.c
View File

@ -6,10 +6,10 @@
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \ K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \
) \ ) \
LAYOUT_wrapper( \ LAYOUT_wrapper( \
KC_GESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \ KC_TAB, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \
M_LCTL, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, M_RALT, \ MT_ESC, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, KC_QUOT, \
OS_LSFT, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, OS_RSFT, \ OS_LSFT, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, OS_RSFT, \
KC_GRV, OS_LALT, SP_LWER, ET_RAIS, KC_BSPC, OS_RGUI \ KC_LEAD,OS_LALT, SP_LWER, ET_RAIS, KC_BSPC, KC_RGUI \
) )
#define LAYOUT_crkbd_base_wrapper(...) LAYOUT_crkbd_base(__VA_ARGS__) #define LAYOUT_crkbd_base_wrapper(...) LAYOUT_crkbd_base(__VA_ARGS__)
@ -32,6 +32,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_________________DVORAK_L3_________________, _________________DVORAK_R3_________________ _________________DVORAK_L3_________________, _________________DVORAK_R3_________________
), ),
[_WORKMAN] = LAYOUT_crkbd_base_wrapper(
_________________WORKMAN_L1________________, _________________WORKMAN_R1________________,
_________________WORKMAN_L2________________, _________________WORKMAN_R2________________,
_________________WORKMAN_L3________________, _________________WORKMAN_R3________________
),
[_MODS] = LAYOUT_wrapper( [_MODS] = LAYOUT_wrapper(
_______, ___________________BLANK___________________, ___________________BLANK___________________, _______, _______, ___________________BLANK___________________, ___________________BLANK___________________, _______,
_______, ___________________BLANK___________________, ___________________BLANK___________________, _______, _______, ___________________BLANK___________________, ___________________BLANK___________________, _______,
@ -40,8 +46,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
), ),
[_LOWER] = LAYOUT_wrapper( [_LOWER] = LAYOUT_wrapper(
_______, _________________LOWER_L1__________________, _________________LOWER_R1__________________, KC_PIPE, KC_F11, _________________LOWER_L1__________________, _________________LOWER_R1__________________, KC_F12,
KC_F11, _________________LOWER_L2__________________, _________________LOWER_R2__________________, KC_F12, KC_GRV, _________________LOWER_L2__________________, _________________LOWER_R2__________________, KC_PIPE,
_______, _________________LOWER_L3__________________, _________________LOWER_R3__________________, _______, _______, _________________LOWER_L3__________________, _________________LOWER_R3__________________, _______,
_______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______
), ),
@ -54,7 +60,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
), ),
[_ADJUST] = LAYOUT_wrapper( \ [_ADJUST] = LAYOUT_wrapper( \
KC_MAKE, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RESET, KC_MAKE, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RST,
VRSN, _________________ADJUST_L2_________________, _________________ADJUST_R2_________________, EEP_RST, VRSN, _________________ADJUST_L2_________________, _________________ADJUST_R2_________________, EEP_RST,
MG_NKRO, _________________ADJUST_L3_________________, _________________ADJUST_R3_________________, RGB_IDL, MG_NKRO, _________________ADJUST_L3_________________, _________________ADJUST_R3_________________, RGB_IDL,
_______, _______, _______, _______, TG_MODS, _______ _______, _______, _______, _______, TG_MODS, _______

31
keyboards/crkbd/keymaps/curry/rules.mk
View File

@ -2,22 +2,15 @@
# change to "no" to disable the options, or define them in the Makefile in # change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically # the appropriate keymap folder that will get included automatically
# #
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) BOOTMAGIC_ENABLE = no
MOUSEKEY_ENABLE = no # Mouse keys(+4700) MOUSEKEY_ENABLE = no
EXTRAKEY_ENABLE = yes # Audio control and System control(+450) CONSOLE_ENABLE = no
CONSOLE_ENABLE = no # Console for debug(+400) COMMAND_ENABLE = no
COMMAND_ENABLE = no # Commands for debug and configuration
NKRO_ENABLE = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work RGBLIGHT_ENABLE = no
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality RGB_MATRIX_ENABLE = WS2812
MIDI_ENABLE = no # MIDI controls
AUDIO_ENABLE = no # Audio output on port C6 OLED_DRIVER_ENABLE = yes
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID BOOTLOADER = atmel-dfu
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. SPLIT_TRANSPORT = mirror
SWAP_HANDS_ENABLE = no # Enable one-hand typing
RGB_MATRIX_ENABLE = WS2812
TAP_DANCE_ENABLE = yes # Enable Tap Dance.
OLED_DRIVER_ENABLE = yes
BOOTLOADER = atmel-dfu
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
SPLIT_TRANSPORT = mirror

10
keyboards/lily58/keymaps/curry/config.h
View File

@ -5,3 +5,13 @@
#define OLED_DISABLE_TIMEOUT #define OLED_DISABLE_TIMEOUT
#define TAPPING_TERM_PER_KEY #define TAPPING_TERM_PER_KEY
#if defined(RGBLIGHT_ENABLE)
# undef RGBLED_NUM
# define RGBLED_NUM 27
# define RGBLIGHT_HUE_STEP 8
# define RGBLIGHT_SAT_STEP 8
# define RGBLIGHT_VAL_STEP 5
# define RGBLIGHT_LIMIT_VAL 120
#endif

8
keyboards/lily58/keymaps/curry/keymap.c
View File

@ -7,11 +7,11 @@
K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A \ K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A \
) \ ) \
LAYOUT_wrapper( \ LAYOUT_wrapper( \
KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_GRV, \ KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_GRV, \
KC_TAB, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, KC_BSLS, \ KC_TAB, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, KC_BSLS, \
KC_LCTL, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, KC_QUOT, \ KC_LCTL, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, KC_QUOT, \
OS_LSFT, K31, K32, K33, K34, K35, KC_LBRC, KC_RBRC, K36, K37, K38, K39, K3A, OS_RSFT, \ OS_LSFT, K31, K32, K33, K34, K35, KC_LBRC, KC_RBRC, K36, K37, K38, K39, K3A, OS_RSFT, \
OS_LGUI, OS_LALT, LOWER, KC_SPC, KC_ENT, RAISE, KC_BSPC, OS_RGUI \ KC_LEAD, OS_LALT, LOWER, KC_SPC, KC_ENT, RAISE, KC_BSPC, OS_RGUI \
) )
#define LAYOUT_lily58_base_wrapper(...) LAYOUT_lily58_base(__VA_ARGS__) #define LAYOUT_lily58_base_wrapper(...) LAYOUT_lily58_base(__VA_ARGS__)
@ -63,7 +63,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_ADJUST] = LAYOUT_wrapper( \ [_ADJUST] = LAYOUT_wrapper( \
_______, ___________________BLANK___________________, ___________________BLANK___________________, _______, _______, ___________________BLANK___________________, ___________________BLANK___________________, _______,
KC_MAKE, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RESET, KC_MAKE, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RST,
VRSN, _________________ADJUST_L2_________________, _________________ADJUST_R2_________________, EEP_RST, VRSN, _________________ADJUST_L2_________________, _________________ADJUST_R2_________________, EEP_RST,
MG_NKRO, _________________ADJUST_L3_________________, _______, _______, _________________ADJUST_R3_________________, RGB_IDL, MG_NKRO, _________________ADJUST_L3_________________, _______, _______, _________________ADJUST_R3_________________, RGB_IDL,
_______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______

29
keyboards/lily58/keymaps/curry/rules.mk
View File

@ -2,20 +2,15 @@
# change to "no" to disable the options, or define them in the Makefile in # change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically # the appropriate keymap folder that will get included automatically
# #
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) BOOTMAGIC_ENABLE = no
MOUSEKEY_ENABLE = no # Mouse keys(+4700) MOUSEKEY_ENABLE = no
EXTRAKEY_ENABLE = yes # Audio control and System control(+450) CONSOLE_ENABLE = no
CONSOLE_ENABLE = no # Console for debug(+400) COMMAND_ENABLE = no
COMMAND_ENABLE = no # Commands for debug and configuration
NKRO_ENABLE = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work RGBLIGHT_ENABLE = no
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality RGB_MATRIX_ENABLE = no
MIDI_ENABLE = no # MIDI controls
AUDIO_ENABLE = no # Audio output on port C6 OLED_DRIVER_ENABLE = yes
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID BOOTLOADER = atmel-dfu
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. SPLIT_TRANSPORT = mirror
SWAP_HANDS_ENABLE = no # Enable one-hand typing
TAP_DANCE_ENABLE = yes # Enable Tap Dance.
OLED_DRIVER_ENABLE = yes
BOOTLOADER = atmel-dfu
SPLIT_TRANSPORT = mirror

0
users/curry/LICENSE.md → users/curry/LICENSE
View File

125
users/curry/config.h
View File

@ -6,97 +6,82 @@
/* Set Polling rate to 1000Hz */ /* Set Polling rate to 1000Hz */
#define USB_POLLING_INTERVAL_MS 1 #define USB_POLLING_INTERVAL_MS 1
#ifdef RGBLIGHT_ENABLE #if defined(RGBLIGHT_ENABLE)
# undef RGBLIGHT_ANIMATIONS # undef RGBLIGHT_ANIMATIONS
# if defined(__AVR__) && !defined(__AVR_AT90USB1286__) # define RGBLIGHT_SLEEP
# define RGBLIGHT_SLEEP # define RGBLIGHT_EFFECT_BREATHING
# define RGBLIGHT_EFFECT_BREATHING # define RGBLIGHT_EFFECT_SNAKE
# define RGBLIGHT_EFFECT_SNAKE # define RGBLIGHT_EFFECT_KNIGHT
# define RGBLIGHT_EFFECT_KNIGHT
# else
# define RGBLIGHT_ANIMATIONS
# endif
#endif // RGBLIGHT_ENABLE #endif // RGBLIGHT_ENABLE
#ifdef RGB_MATRIX_ENABLE #if defined(RGB_MATRIX_ENABLE)
# define RGB_MATRIX_KEYPRESSES // reacts to keypresses (will slow down matrix scan by a lot) # define RGB_MATRIX_KEYPRESSES
// # define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
# define RGB_MATRIX_FRAMEBUFFER_EFFECTS # define RGB_MATRIX_FRAMEBUFFER_EFFECTS
// # define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects # define RGB_DISABLE_WHEN_USB_SUSPENDED true
# define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
// # define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
// # define EECONFIG_RGB_MATRIX (uint32_t *)16
# if defined(__AVR__) && !defined(__AVR_AT90USB1286__) # define DISABLE_RGB_MATRIX_ALPHAS_MODS
# define DISABLE_RGB_MATRIX_ALPHAS_MODS # define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
# define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN # define DISABLE_RGB_MATRIX_BREATHING
# define DISABLE_RGB_MATRIX_BREATHING # define DISABLE_RGB_MATRIX_BAND_SAT
# define DISABLE_RGB_MATRIX_BAND_SAT # define DISABLE_RGB_MATRIX_BAND_VAL
# define DISABLE_RGB_MATRIX_BAND_VAL # define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT
# define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT # define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL
# define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL # define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT
# define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT # define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL
# define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL # define DISABLE_RGB_MATRIX_CYCLE_ALL
# define DISABLE_RGB_MATRIX_CYCLE_ALL # define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
# define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT # define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
# define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN # define DISABLE_RGB_MATRIX_CYCLE_OUT_IN
# define DISABLE_RGB_MATRIX_CYCLE_OUT_IN
// # define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL // # define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
# define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON # define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
# define DISABLE_RGB_MATRIX_DUAL_BEACON # define DISABLE_RGB_MATRIX_DUAL_BEACON
# define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL # define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL
# define DISABLE_RGB_MATRIX_CYCLE_SPIRAL # define DISABLE_RGB_MATRIX_CYCLE_SPIRAL
# define DISABLE_RGB_MATRIX_RAINBOW_BEACON # define DISABLE_RGB_MATRIX_RAINBOW_BEACON
# define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS # define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
# define DISABLE_RGB_MATRIX_RAINDROPS # define DISABLE_RGB_MATRIX_RAINDROPS
# define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS # define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
// # define DISABLE_RGB_MATRIX_TYPING_HEATMAP // # define DISABLE_RGB_MATRIX_TYPING_HEATMAP
# define DISABLE_RGB_MATRIX_DIGITAL_RAIN # define DISABLE_RGB_MATRIX_DIGITAL_RAIN
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE # define DISABLE_RGB_MATRIX_SOLID_REACTIVE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS # define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
# define DISABLE_RGB_MATRIX_SPLASH # define DISABLE_RGB_MATRIX_SPLASH
# define DISABLE_RGB_MATRIX_MULTISPLASH # define DISABLE_RGB_MATRIX_MULTISPLASH
# define DISABLE_RGB_MATRIX_SOLID_SPLASH # define DISABLE_RGB_MATRIX_SOLID_SPLASH
# define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH # define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH
# endif // AVR #endif // RGB_MATRIX_ENABLE
#endif // RGB_MATRIX_ENABLE
#ifndef ONESHOT_TAP_TOGGLE #if !defined(ONESHOT_TAP_TOGGLE)
# define ONESHOT_TAP_TOGGLE 2 # define ONESHOT_TAP_TOGGLE 2
#endif // !ONESHOT_TAP_TOGGLE #endif // !ONESHOT_TAP_TOGGLE
#ifndef ONESHOT_TIMEOUT #if !defined(ONESHOT_TIMEOUT)
# define ONESHOT_TIMEOUT 3000 # define ONESHOT_TIMEOUT 3000
#endif // !ONESHOT_TIMEOUT #endif // !ONESHOT_TIMEOUT
#ifndef QMK_KEYS_PER_SCAN #if !defined(QMK_KEYS_PER_SCAN)
# define QMK_KEYS_PER_SCAN 4 # define QMK_KEYS_PER_SCAN 4
#endif // !QMK_KEYS_PER_SCAN #endif // !QMK_KEYS_PER_SCAN
// this makes it possible to do rolling combos (zx) with keys that
// convert to other keys on hold (z becomes ctrl when you hold it,
// and when this option isn't enabled, z rapidly followed by x
// actually sends Ctrl-x. That's bad.)
#define IGNORE_MOD_TAP_INTERRUPT #define IGNORE_MOD_TAP_INTERRUPT
#undef PERMISSIVE_HOLD #undef PERMISSIVE_HOLD
//#define TAPPING_FORCE_HOLD
//#define RETRO_TAPPING
#define FORCE_NKRO #define FORCE_NKRO
#ifndef TAPPING_TOGGLE #if !defined(TAPPING_TOGGLE)
# define TAPPING_TOGGLE 1 # define TAPPING_TOGGLE 1
#endif #endif
#ifdef TAPPING_TERM #if defined(TAPPING_TERM)
# undef TAPPING_TERM # undef TAPPING_TERM
#endif // TAPPING_TERM #endif // TAPPING_TERM
#if defined(KEYBOARD_ergodox_ez) #if defined(KEYBOARD_ergodox_ez)
# define TAPPING_TERM 185 # define TAPPING_TERM 185
#elif defined(KEYBOARD_crkbd) #elif defined(KEYBOARD_crkbd)
@ -107,12 +92,20 @@
#define TAP_CODE_DELAY 5 #define TAP_CODE_DELAY 5
#define LEADER_TIMEOUT 250
#define LEADER_PER_KEY_TIMING
/* Disable unused and unneeded features to reduce on firmware size */ /* Disable unused and unneeded features to reduce on firmware size */
#ifdef LOCKING_SUPPORT_ENABLE #if defined(LOCKING_SUPPORT_ENABLE)
# undef LOCKING_SUPPORT_ENABLE # undef LOCKING_SUPPORT_ENABLE
#endif #endif
#ifdef LOCKING_RESYNC_ENABLE
#if defined(LOCKING_RESYNC_ENABLE)
# undef LOCKING_RESYNC_ENABLE # undef LOCKING_RESYNC_ENABLE
#endif #endif
#if defined(OLED_FONT_H)
# undef OLED_FONT_H
#endif
#define OLED_FONT_H "users/curry/glcdfont.c" #define OLED_FONT_H "users/curry/glcdfont.c"

19
users/curry/curry.c
View File

@ -53,15 +53,16 @@ void rgb_matrix_update_pwm_buffers(void);
// On RESET, set all RGB to red, shutdown the keymap. // On RESET, set all RGB to red, shutdown the keymap.
void shutdown_user(void) { void shutdown_user(void) {
#ifdef RGBLIGHT_ENABLE #if defined(RGBLIGHT_ENABLE)
rgblight_enable_noeeprom(); rgblight_enable_noeeprom();
rgblight_mode_noeeprom(1); rgblight_mode_noeeprom(1);
rgblight_setrgb_red(); rgblight_setrgb_red();
#endif // RGBLIGHT_ENABLE #endif
#ifdef RGB_MATRIX_ENABLE
#if defined(RGB_MATRIX_ENABLE)
rgb_matrix_set_color_all(0xFF, 0x00, 0x00); rgb_matrix_set_color_all(0xFF, 0x00, 0x00);
rgb_matrix_update_pwm_buffers(); rgb_matrix_update_pwm_buffers();
#endif // RGB_MATRIX_ENABLE #endif
shutdown_keymap(); shutdown_keymap();
} }
@ -77,7 +78,7 @@ __attribute__((weak)) void matrix_scan_keymap(void) {}
// No global matrix scan code, so just run keymap's matrix // No global matrix scan code, so just run keymap's matrix
// scan function // scan function
void matrix_scan_user(void) { __attribute__((weak)) void matrix_scan_user(void) {
static bool has_ran_yet; static bool has_ran_yet;
if (!has_ran_yet) { if (!has_ran_yet) {
has_ran_yet = true; has_ran_yet = true;
@ -96,18 +97,16 @@ __attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state)
// On Layer change, run keymap's layer change check // On Layer change, run keymap's layer change check
layer_state_t layer_state_set_user(layer_state_t state) { layer_state_t layer_state_set_user(layer_state_t state) {
state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) #if defined(RGBLIGHT_ENABLE)
state = layer_state_set_rgb(state); state = layer_state_set_rgb(state);
#endif // RGBLIGHT_ENABLE #endif
return layer_state_set_keymap(state); return layer_state_set_keymap(state);
} }
__attribute__((weak)) layer_state_t default_layer_state_set_keymap(layer_state_t state) { return 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 // Runs state check and changes underglow color and animation
layer_state_t default_layer_state_set_user(layer_state_t state) { layer_state_t default_layer_state_set_user(layer_state_t state) { return default_layer_state_set_keymap(state); }
return default_layer_state_set_keymap(state);
}
__attribute__((weak)) void led_set_keymap(uint8_t usb_led) {} __attribute__((weak)) void led_set_keymap(uint8_t usb_led) {}

14
users/curry/curry.h
View File

@ -1,18 +1,23 @@
#pragma once #pragma once
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "version.h" #include "version.h"
#include "eeprom.h" #include "eeprom.h"
#include "wrappers.h" #include "wrappers.h"
#include "process_records.h" #include "process_records.h"
#ifdef TAP_DANCE_ENABLE #if defined(TAP_DANCE_ENABLE)
# include "tap_dances.h" # include "tap_dances.h"
#endif // TAP_DANCE_ENABLE #endif // TAP_DANCE_ENABLE
#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
# include "rgb_stuff.h" #if defined(RGB_MATRIX_ENABLE)
# include "rgb_matrix_user.h"
#endif #endif
#if defined(RGBLIGHT_ENABLE)
# include "rgb_lighting_user.h"
#endif
#if defined(KEYBOARD_lily58_rev1) & defined(PROTOCOL_LUFA) #if defined(KEYBOARD_lily58_rev1) & defined(PROTOCOL_LUFA)
# include "lufa.h" # include "lufa.h"
# include "split_util.h" # include "split_util.h"
@ -23,6 +28,7 @@ enum userspace_layers {
_QWERTY = 0, _QWERTY = 0,
_COLEMAK, _COLEMAK,
_DVORAK, _DVORAK,
_WORKMAN,
_MODS, _MODS,
_LOWER, _LOWER,
_RAISE, _RAISE,

11
users/curry/glcdfont.c
View File

@ -1,13 +1,4 @@
#pragma once #include "progmem.h"
#ifdef __AVR__
# include <avr/io.h>
# include <avr/pgmspace.h>
#elif defined(ESP8266)
# include <pgmspace.h>
#else
# define PROGMEM
#endif
// Corne 8x6 font with QMK Firmware Logo // Corne 8x6 font with QMK Firmware Logo
// Online editor: https://helixfonteditor.netlify.com/ // Online editor: https://helixfonteditor.netlify.com/

24
users/curry/leader.c Normal file
View File

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

3
users/curry/leader.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
void matrix_scan_user(void);

13
users/curry/oled.c
View File

@ -1,6 +1,5 @@
#include "curry.h" #include "curry.h"
#ifdef OLED_DRIVER_ENABLE
#define KEYLOGGER_LENGTH 5 #define KEYLOGGER_LENGTH 5
static uint32_t oled_timer = 0; static uint32_t oled_timer = 0;
static char keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"}; static char keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"};
@ -26,6 +25,7 @@ static const char PROGMEM code_to_name[0xFF] = {
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' // Fx ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' // Fx
}; };
// clang-format on
void add_keylog(uint16_t keycode); void add_keylog(uint16_t keycode);
oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; } oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; }
@ -49,7 +49,7 @@ void add_keylog(uint16_t keycode) {
} }
void render_keylogger_status(void) { void render_keylogger_status(void) {
oled_write_P(PSTR("Keys"), false); oled_write_P(PSTR("Keys:"), false);
oled_write(keylog_str, false); oled_write(keylog_str, false);
} }
@ -65,6 +65,9 @@ void render_default_layer_state(void) {
case _DVORAK: case _DVORAK:
oled_write_P(PSTR(" DVRK"), false); oled_write_P(PSTR(" DVRK"), false);
break; break;
case _WORKMAN:
oled_write_P(PSTR(" WRKM"), false);
break;
} }
} }
@ -139,11 +142,11 @@ void oled_task_user(void) {
oled_off(); oled_off();
return; return;
} }
# ifndef SPLIT_KEYBOARD #if !defined(SPLIT_KEYBOARD)
else { else {
oled_on(); oled_on();
} }
# endif #endif
if (is_keyboard_master()) { if (is_keyboard_master()) {
render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc) render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
} else { } else {
@ -158,5 +161,3 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
} }
return true; return true;
} }
#endif

27
users/curry/process_records.c
View File

@ -9,6 +9,11 @@ __attribute__((weak)) bool process_record_secrets(uint16_t keycode, keyrecord_t
bool process_record_user(uint16_t keycode, keyrecord_t *record) { 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); 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) { switch (keycode) {
case KC_QWERTY ... KC_WORKMAN:
if (record->event.pressed) {
set_single_persistent_default_layer(keycode - KC_QWERTY);
}
break;
case KC_MAKE: case KC_MAKE:
if (!record->event.pressed) { if (!record->event.pressed) {
uint8_t temp_mod = mod_config(get_mods()); uint8_t temp_mod = mod_config(get_mods());
@ -19,18 +24,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) { if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) {
send_string_with_delay_P(PSTR(":flash"), TAP_CODE_DELAY); send_string_with_delay_P(PSTR(":flash"), TAP_CODE_DELAY);
} }
if ((temp_mod | temp_osm) & MOD_MASK_CTRL) { send_string_with_delay_P(PSTR(" -j8 --output-sync\n"), TAP_CODE_DELAY);
send_string_with_delay_P(PSTR(" -j8 --output-sync"), TAP_CODE_DELAY);
}
#ifdef RGB_MATRIX_SPLIT_RIGHT
send_string_with_delay_P(PSTR(" RGB_MATRIX_SPLIT_RIGHT=yes"), TAP_CODE_DELAY);
# ifndef OLED_DRIVER_ENABLE
send_string_with_delay_P(PSTR(" OLED_DRIVER_ENABLE=no"), TAP_CODE_DELAY);
# endif
#endif
send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), TAP_CODE_DELAY);
} }
break; break;
case VRSN: // Prints firmware version case VRSN: // Prints firmware version
@ -44,17 +39,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
copy_paste_timer = timer_read(); copy_paste_timer = timer_read();
} else { } else {
if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy
register_code(KC_LCTL); tap_code16(LCTL(KC_C));
tap_code(KC_C);
unregister_code(KC_LCTL);
} else { // Tap, paste } else { // Tap, paste
register_code(KC_LCTL); tap_code16(LCTL(KC_V));
tap_code(KC_V);
unregister_code(KC_LCTL);
} }
} }
break; break;
#ifdef UNICODE_ENABLE #if defined(UNICODE_ENABLE)
case UC_FLIP: // (ノಠ痊ಠ)ノ彡┻━┻ case UC_FLIP: // (ノಠ痊ಠ)ノ彡┻━┻
if (record->event.pressed) { if (record->event.pressed) {
send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B"); send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B");

62
users/curry/process_records.h
View File

@ -1,36 +1,29 @@
#pragma once #pragma once
#include "curry.h"
#if defined(KEYMAP_SAFE_RANGE)
# define PLACEHOLDER_SAFE_RANGE KEYMAP_SAFE_RANGE
#else
# define PLACEHOLDER_SAFE_RANGE SAFE_RANGE
#endif
enum userspace_custom_keycodes { enum userspace_custom_keycodes {
VRSN = PLACEHOLDER_SAFE_RANGE, // Prints QMK Firmware and board info VRSN = SAFE_RANGE, // Prints QMK Firmware and board info
KC_QWERTY, // Sets default layer to QWERTY KC_QWERTY, // Sets default layer to QWERTY
KC_COLEMAK, // Sets default layer to COLEMAK KC_COLEMAK, // Sets default layer to COLEMAK
KC_DVORAK, // Sets default layer to DVORAK KC_DVORAK, // Sets default layer to DVORAK
KC_MAKE, // Run keyboard's customized make command KC_WORKMAN, // Sets default layer to WORKMAN
KC_RGB_T, // Toggles RGB Layer Indication mode KC_MAKE, // Run keyboard's customized make command
RGB_IDL, // RGB Idling animations KC_RGB_T, // Toggles RGB Layer Indication mode
KC_SECRET_1, // test1 RGB_IDL, // RGB Idling animations
KC_SECRET_2, // test2 KC_SECRET_1, // test1
KC_SECRET_3, // test3 KC_SECRET_2, // test2
KC_SECRET_4, // test4 KC_SECRET_3, // test3
KC_SECRET_5, // test5 KC_SECRET_4, // test4
KC_CCCV, // Hold to copy, tap to paste KC_SECRET_5, // test5
KC_NUKE, // NUCLEAR LAUNCH DETECTED!!! KC_CCCV, // Hold to copy, tap to paste
UC_FLIP, // (ಠ痊ಠ)┻━┻ UC_FLIP, // (ಠ痊ಠ)┻━┻
UC_TABL, // ┬─┬ノ( º _ ºノ) UC_TABL, // ┬─┬ノ( º _ ºノ)
UC_SHRG, // ¯\_(ツ)_/¯ UC_SHRG, // ¯\_(ツ)_/¯
UC_DISA, // ಠ_ಠ UC_DISA, // ಠ_ಠ
KC_DT1, KC_DT1,
KC_DT2, KC_DT2,
KC_DT3, KC_DT3,
KC_DT4, KC_DT4,
NEW_SAFE_RANGE // use "NEWPLACEHOLDER for keymap specific codes NEW_SAFE_RANGE // use "NEWPLACEHOLDER for keymap specific codes
}; };
bool process_record_secrets(uint16_t keycode, keyrecord_t *record); bool process_record_secrets(uint16_t keycode, keyrecord_t *record);
@ -52,25 +45,20 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
#define QWERTY KC_QWERTY #define QWERTY KC_QWERTY
#define DVORAK KC_DVORAK #define DVORAK KC_DVORAK
#define COLEMAK KC_COLEMAK #define COLEMAK KC_COLEMAK
#define WORKMAN KC_WORKMAN
#define KC_RESET RESET #define KC_RST RESET
#define KC_RST KC_RESET
#ifdef SWAP_HANDS_ENABLE #if defined(SWAP_HANDS_ENABLE)
# define KC_C1R3 SH_T(KC_TAB) # define KC_C1R3 SH_T(KC_TAB)
#else // SWAP_HANDS_ENABLE #else // SWAP_HANDS_ENABLE
# define KC_C1R3 KC_TAB # define KC_C1R3 KC_TAB
#endif // SWAP_HANDS_ENABLE #endif // SWAP_HANDS_ENABLE
#define BK_LWER LT(_LOWER, KC_BSPC)
#define SP_LWER LT(_LOWER, KC_SPC) #define SP_LWER LT(_LOWER, KC_SPC)
#define DL_RAIS LT(_RAISE, KC_DEL)
#define ET_RAIS LT(_RAISE, KC_ENTER) #define ET_RAIS LT(_RAISE, KC_ENTER)
/* OSM keycodes, to keep things clean and easy to change */ /* OSM keycodes, to keep things clean and easy to change */
#define KC_MLSF OSM(MOD_LSFT)
#define KC_MRSF OSM(MOD_RSFT)
#define OS_LGUI OSM(MOD_LGUI) #define OS_LGUI OSM(MOD_LGUI)
#define OS_RGUI OSM(MOD_RGUI) #define OS_RGUI OSM(MOD_RGUI)
#define OS_LSFT OSM(MOD_LSFT) #define OS_LSFT OSM(MOD_LSFT)
@ -82,12 +70,6 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
#define OS_MEH OSM(MOD_MEH) #define OS_MEH OSM(MOD_MEH)
#define OS_HYPR OSM(MOD_HYPR) #define OS_HYPR OSM(MOD_HYPR)
#define M_LALT ALT_T(KC_TAB)
#define M_RALT RALT_T(KC_QUOT)
#define M_LCTL CTL_T(KC_TAB)
#define M_RCTL RCTL_T(KC_QUOT)
#define MT_ESC MT(MOD_LCTL, KC_ESC) #define MT_ESC MT(MOD_LCTL, KC_ESC)
#define ALT_APP ALT_T(KC_APP) #define ALT_APP ALT_T(KC_APP)

274
users/curry/rgb_stuff.c → users/curry/rgb_lighting_user.c
View File

@ -1,138 +1,77 @@
#include "curry.h" #include "curry.h"
#include "rgb_stuff.h" #include "rgb_lighting_user.h"
#include "eeprom.h"
#if defined(RGBLIGHT_ENABLE)
extern rgblight_config_t rgblight_config; extern rgblight_config_t rgblight_config;
bool has_initialized; bool has_initialized;
void rgblight_sethsv_default_helper(uint8_t index) { rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, index); } void rgblight_sethsv_default_helper(uint8_t index) { rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, index); }
#endif // RGBLIGHT_ENABLE
#if defined(RGB_MATRIX_ENABLE)
static uint32_t hypno_timer;
# if defined(SPLIT_KEYBOARD) || defined(KEYBOARD_ergodox_ez) || defined(KEYBOARD_crkbd)
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN_DUAL
# else
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN
# endif
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;
}
}
void rgb_matrix_indicators_user(void) {
if (userspace_config.rgb_layer_change &&
# ifdef RGB_DISABLE_WHEN_USB_SUSPENDED
!g_suspend_state &&
# endif
# if defined(RGBLIGHT_ENABLE)
(!rgblight_config.enable && rgb_matrix_config.enable)
# else
rgb_matrix_config.enable
# endif
) {
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);
}
}
#endif
/* Custom indicators for modifiers. /* Custom indicators for modifiers.
* This allows for certain lights to be lit up, based on what mods are active, giving some visual feedback. * 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. * This is especially useful for One Shot Mods, since it's not always obvious if they're still lit up.
*/ */
#ifdef RGBLIGHT_ENABLE #if defined(INDICATOR_LIGHTS)
# ifdef INDICATOR_LIGHTS
void set_rgb_indicators(uint8_t this_mod, uint8_t this_led, uint8_t this_osm) { 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 (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)) { if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) {
# ifdef SHFT_LED1 # ifdef SHFT_LED1
rgblight_sethsv_at(120, 255, 255, SHFT_LED1); rgblight_sethsv_at(120, 255, 255, SHFT_LED1);
# endif // SHFT_LED1 # endif // SHFT_LED1
# ifdef SHFT_LED2 # ifdef SHFT_LED2
rgblight_sethsv_at(120, 255, 255, SHFT_LED2); rgblight_sethsv_at(120, 255, 255, SHFT_LED2);
# endif // SHFT_LED2 # endif // SHFT_LED2
} else { } else {
# ifdef SHFT_LED1 # ifdef SHFT_LED1
rgblight_sethsv_default_helper(SHFT_LED1); rgblight_sethsv_default_helper(SHFT_LED1);
# endif // SHFT_LED1 # endif // SHFT_LED1
# ifdef SHFT_LED2 # ifdef SHFT_LED2
rgblight_sethsv_default_helper(SHFT_LED2); rgblight_sethsv_default_helper(SHFT_LED2);
# endif // SHFT_LED2 # endif // SHFT_LED2
} }
if ((this_mod | this_osm) & MOD_MASK_CTRL) { if ((this_mod | this_osm) & MOD_MASK_CTRL) {
# ifdef CTRL_LED1 # ifdef CTRL_LED1
rgblight_sethsv_at(0, 255, 255, CTRL_LED1); rgblight_sethsv_at(0, 255, 255, CTRL_LED1);
# endif // CTRL_LED1 # endif // CTRL_LED1
# ifdef CTRL_LED2 # ifdef CTRL_LED2
rgblight_sethsv_at(0, 255, 255, CTRL_LED2); rgblight_sethsv_at(0, 255, 255, CTRL_LED2);
# endif // CTRL_LED2 # endif // CTRL_LED2
} else { } else {
# ifdef CTRL_LED1 # ifdef CTRL_LED1
rgblight_sethsv_default_helper(CTRL_LED1); rgblight_sethsv_default_helper(CTRL_LED1);
# endif // CTRL_LED1 # endif // CTRL_LED1
# ifdef CTRL_LED2 # ifdef CTRL_LED2
rgblight_sethsv_default_helper(CTRL_LED2); rgblight_sethsv_default_helper(CTRL_LED2);
# endif // CTRL_LED2 # endif // CTRL_LED2
} }
if ((this_mod | this_osm) & MOD_MASK_GUI) { if ((this_mod | this_osm) & MOD_MASK_GUI) {
# ifdef GUI_LED1 # ifdef GUI_LED1
rgblight_sethsv_at(51, 255, 255, GUI_LED1); rgblight_sethsv_at(51, 255, 255, GUI_LED1);
# endif // GUI_LED1 # endif // GUI_LED1
# ifdef GUI_LED2 # ifdef GUI_LED2
rgblight_sethsv_at(51, 255, 255, GUI_LED2); rgblight_sethsv_at(51, 255, 255, GUI_LED2);
# endif // GUI_LED2 # endif // GUI_LED2
} else { } else {
# ifdef GUI_LED1 # ifdef GUI_LED1
rgblight_sethsv_default_helper(GUI_LED1); rgblight_sethsv_default_helper(GUI_LED1);
# endif // GUI_LED1 # endif // GUI_LED1
# ifdef GUI_LED2 # ifdef GUI_LED2
rgblight_sethsv_default_helper(GUI_LED2); rgblight_sethsv_default_helper(GUI_LED2);
# endif // GUI_LED2 # endif // GUI_LED2
} }
if ((this_mod | this_osm) & MOD_MASK_ALT) { if ((this_mod | this_osm) & MOD_MASK_ALT) {
# ifdef ALT_LED1 # ifdef ALT_LED1
rgblight_sethsv_at(240, 255, 255, ALT_LED1); rgblight_sethsv_at(240, 255, 255, ALT_LED1);
# endif // ALT_LED1 # endif // ALT_LED1
# ifdef GUI_LED2 # ifdef GUI_LED2
rgblight_sethsv_at(240, 255, 255, ALT_LED2); rgblight_sethsv_at(240, 255, 255, ALT_LED2);
# endif // GUI_LED2 # endif // GUI_LED2
} else { } else {
# ifdef GUI_LED1 # ifdef GUI_LED1
rgblight_sethsv_default_helper(ALT_LED1); rgblight_sethsv_default_helper(ALT_LED1);
# endif // GUI_LED1 # endif // GUI_LED1
# ifdef GUI_LED2 # ifdef GUI_LED2
rgblight_sethsv_default_helper(ALT_LED2); rgblight_sethsv_default_helper(ALT_LED2);
# endif // GUI_LED2 # endif // GUI_LED2
} }
} }
} }
@ -143,9 +82,9 @@ void matrix_scan_indicator(void) {
set_rgb_indicators(get_mods(), host_keyboard_leds(), get_oneshot_mods()); set_rgb_indicators(get_mods(), host_keyboard_leds(), get_oneshot_mods());
} }
} }
# endif // INDICATOR_LIGHTS #endif // INDICATOR_LIGHTS
# ifdef RGBLIGHT_TWINKLE #if defined(RGBLIGHT_TWINKLE)
static rgblight_fadeout lights[RGBLED_NUM]; static rgblight_fadeout lights[RGBLED_NUM];
__attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; } __attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; }
@ -153,40 +92,40 @@ __attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) {
/* This function checks for used LEDs. This way, collisions don't occur and cause weird rendering */ /* 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) { bool rgblight_twinkle_is_led_used(uint8_t index) {
switch (index) { switch (index) {
# ifdef INDICATOR_LIGHTS # ifdef INDICATOR_LIGHTS
# ifdef SHFT_LED1 # ifdef SHFT_LED1
case SHFT_LED1: case SHFT_LED1:
return true; return true;
# endif // SHFT_LED1 # endif // SHFT_LED1
# ifdef SHFT_LED2 # ifdef SHFT_LED2
case SHFT_LED2: case SHFT_LED2:
return true; return true;
# endif // SHFT_LED2 # endif // SHFT_LED2
# ifdef CTRL_LED1 # ifdef CTRL_LED1
case CTRL_LED1: case CTRL_LED1:
return true; return true;
# endif // CTRL_LED1 # endif // CTRL_LED1
# ifdef CTRL_LED2 # ifdef CTRL_LED2
case CTRL_LED2: case CTRL_LED2:
return true; return true;
# endif // CTRL_LED2 # endif // CTRL_LED2
# ifdef GUI_LED1 # ifdef GUI_LED1
case GUI_LED1: case GUI_LED1:
return true; return true;
# endif // GUI_LED1 # endif // GUI_LED1
# ifdef GUI_LED2 # ifdef GUI_LED2
case GUI_LED2: case GUI_LED2:
return true; return true;
# endif // GUI_LED2 # endif // GUI_LED2
# ifdef ALT_LED1 # ifdef ALT_LED1
case ALT_LED1: case ALT_LED1:
return true; return true;
# endif // ALT_LED1 # endif // ALT_LED1
# ifdef ALT_LED2 # ifdef ALT_LED2
case ALT_LED2: case ALT_LED2:
return true; return true;
# endif // ALT_LED2 # endif // ALT_LED2
# endif // INDICATOR_LIGHTS # endif // INDICATOR_LIGHTS
default: default:
return rgblight_twinkle_is_led_used_keymap(index); return rgblight_twinkle_is_led_used_keymap(index);
} }
@ -259,8 +198,7 @@ void start_rgb_light(void) {
rgblight_sethsv_at(light->hue, 255, light->life, light_index); rgblight_sethsv_at(light->hue, 255, light->life, light_index);
} }
# endif #endif
#endif // RGBLIGHT_ENABLE
bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
uint16_t temp_keycode = keycode; uint16_t temp_keycode = keycode;
@ -269,15 +207,8 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
temp_keycode &= 0xFF; temp_keycode &= 0xFF;
} }
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
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);
}
#endif
switch (temp_keycode) { switch (temp_keycode) {
#ifdef RGBLIGHT_TWINKLE #if defined(RGBLIGHT_TWINKLE)
case KC_A ... KC_SLASH: case KC_A ... KC_SLASH:
case KC_F1 ... KC_F12: case KC_F1 ... KC_F12:
case KC_INSERT ... KC_UP: case KC_INSERT ... KC_UP:
@ -290,7 +221,6 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
break; break;
#endif // RGBLIGHT_TWINKLE #endif // RGBLIGHT_TWINKLE
case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal
#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
if (record->event.pressed) { if (record->event.pressed) {
userspace_config.rgb_layer_change ^= 1; userspace_config.rgb_layer_change ^= 1;
dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
@ -299,38 +229,16 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better) layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better)
} }
} }
#endif // RGBLIGHT_ENABLE
break;
case RGB_IDL: // This allows me to use underglow as layer indication, or as normal
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
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);
}
}
#endif
break; break;
case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions
if (record->event.pressed) { if (record->event.pressed) {
bool is_eeprom_updated = false; bool is_eeprom_updated = false;
#ifdef RGBLIGHT_ENABLE
// This disables layer indication, as it's assumed that if you're changing this ... you want that disabled // This disables layer indication, as it's assumed that if you're changing this ... you want that disabled
if (userspace_config.rgb_layer_change) { if (userspace_config.rgb_layer_change) {
userspace_config.rgb_layer_change = false; userspace_config.rgb_layer_change = false;
dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
is_eeprom_updated = true; is_eeprom_updated = true;
} }
#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
if (is_eeprom_updated) { if (is_eeprom_updated) {
eeconfig_update_user(userspace_config.raw); eeconfig_update_user(userspace_config.raw);
} }
@ -341,8 +249,7 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
} }
void keyboard_post_init_rgb(void) { void keyboard_post_init_rgb(void) {
#if defined(RGBLIGHT_ENABLE) #if defined(RGBLIGHT_STARTUP_ANIMATION)
# if defined(RGBLIGHT_STARTUP_ANIMATION)
bool is_enabled = rgblight_config.enable; bool is_enabled = rgblight_config.enable;
if (userspace_config.rgb_layer_change) { if (userspace_config.rgb_layer_change) {
rgblight_enable_noeeprom(); rgblight_enable_noeeprom();
@ -361,44 +268,27 @@ void keyboard_post_init_rgb(void) {
rgblight_disable_noeeprom(); rgblight_disable_noeeprom();
} }
# endif #endif
layer_state_set_user(layer_state); layer_state_set_user(layer_state);
#endif
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
if (userspace_config.rgb_matrix_idle_anim) {
rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
}
#endif
} }
void matrix_scan_rgb(void) { void matrix_scan_rgb(void) {
#ifdef RGBLIGHT_ENABLE #if defined(RGBLIGHT_TWINKLE)
# ifdef RGBLIGHT_TWINKLE
scan_rgblight_fadeout(); scan_rgblight_fadeout();
# endif // RGBLIGHT_ENABLE #endif // RGBLIGHT_ENABLE
# ifdef INDICATOR_LIGHTS #if defined(INDICATOR_LIGHTS)
matrix_scan_indicator(); matrix_scan_indicator();
# endif
#endif
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
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);
}
#endif #endif
} }
#ifdef RGBLIGHT_ENABLE
void rgblight_set_hsv_and_mode(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode) { void rgblight_set_hsv_and_mode(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode) {
rgblight_sethsv_noeeprom(hue, sat, val); rgblight_sethsv_noeeprom(hue, sat, val);
wait_us(175); // Add a slight delay between color and mode to ensure it's processed correctly wait_us(175); // Add a slight delay between color and mode to ensure it's processed correctly
rgblight_mode_noeeprom(mode); rgblight_mode_noeeprom(mode);
} }
#endif
layer_state_t layer_state_set_rgb(layer_state_t state) { layer_state_t layer_state_set_rgb(layer_state_t state) {
#ifdef RGBLIGHT_ENABLE
if (userspace_config.rgb_layer_change) { if (userspace_config.rgb_layer_change) {
switch (get_highest_layer(state)) { switch (get_highest_layer(state)) {
case _RAISE: case _RAISE:
@ -420,6 +310,9 @@ layer_state_t layer_state_set_rgb(layer_state_t state) {
case _DVORAK: case _DVORAK:
rgblight_set_hsv_and_mode(HSV_SPRINGGREEN, mode); rgblight_set_hsv_and_mode(HSV_SPRINGGREEN, mode);
break; break;
case _WORKMAN:
rgblight_set_hsv_and_mode(HSV_GOLDENROD, mode);
break;
default: default:
rgblight_set_hsv_and_mode(HSV_CYAN, mode); rgblight_set_hsv_and_mode(HSV_CYAN, mode);
break; break;
@ -428,44 +321,5 @@ layer_state_t layer_state_set_rgb(layer_state_t state) {
} }
} }
} }
#endif // RGBLIGHT_ENABLE
return state; return state;
} }
#ifdef RGB_MATRIX_ENABLE
# include "lib/lib8tion/lib8tion.h"
extern led_config_t g_led_config;
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;
}
}
}
#endif

19
users/curry/rgb_lighting_user.h Normal file
View File

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

144
users/curry/rgb_matrix_user.c Normal file
View File

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

7
users/curry/rgb_matrix_user.h Normal file
View File

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

32
users/curry/rgb_stuff.h
View File

@ -1,32 +0,0 @@
#pragma once
#include "quantum.h"
#ifdef RGB_MATRIX_ENABLE
# include "rgb_matrix.h"
#endif
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_TWINKLE)
typedef struct {
bool enabled;
uint8_t hue;
uint16_t timer;
uint8_t life;
} rgblight_fadeout;
#endif
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);
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_TWINKLE)
void scan_rgblight_fadeout(void);
#endif
#if defined(RGBLIGHT_ENABLE)
void rgblight_sethsv_default_helper(uint8_t index);
#endif
#ifdef RGB_MATRIX_ENABLE
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);
#endif

20
users/curry/rules.mk
View File

@ -1,8 +1,15 @@
SRC += curry.c \ SRC += curry.c \
process_records.c process_records.c
LTO_ENABLE = yes # Common flags
SPACE_CADET_ENABLE = no 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 ($(strip $(NO_SECRETS)), yes)
ifneq ("$(wildcard $(USER_PATH)/secrets.c)","") ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
@ -21,8 +28,12 @@ ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
SRC += oled.c SRC += oled.c
endif endif
ifeq ($(strip $(LEADER_ENABLE)), yes)
SRC += leader.c
endif
ifeq ($(strip $(RGBLIGHT_ENABLE)), yes) ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
SRC += rgb_stuff.c SRC += rgb_lighting_user.c
ifeq ($(strip $(INDICATOR_LIGHTS)), yes) ifeq ($(strip $(INDICATOR_LIGHTS)), yes)
OPT_DEFS += -DINDICATOR_LIGHTS OPT_DEFS += -DINDICATOR_LIGHTS
endif endif
@ -39,10 +50,9 @@ endif
RGB_MATRIX_ENABLE ?= no RGB_MATRIX_ENABLE ?= no
ifneq ($(strip $(RGB_MATRIX_ENABLE)), no) ifneq ($(strip $(RGB_MATRIX_ENABLE)), no)
SRC += rgb_stuff.c SRC += rgb_matrix_user.c
endif endif
ifdef CONSOLE_ENABLE ifdef CONSOLE_ENABLE
ifeq ($(strip $(KEYLOGGER_ENABLE)), yes) ifeq ($(strip $(KEYLOGGER_ENABLE)), yes)
OPT_DEFS += -DKEYLOGGER_ENABLE OPT_DEFS += -DKEYLOGGER_ENABLE

1
users/curry/tap_dances.c
View File

@ -1,3 +1,4 @@
#include "tap_dances.h"
#include "curry.h" #include "curry.h"
qk_tap_dance_action_t tap_dance_actions[] = {}; qk_tap_dance_action_t tap_dance_actions[] = {};

2
users/curry/tap_dances.h
View File

@ -1,3 +1 @@
#pragma once #pragma once
#include "curry.h"

30
users/curry/wrappers.h
View File

@ -15,18 +15,6 @@ expanded before being used as arguments to the LAYOUT_xxx macro.
#define LAYOUT_ortho_4x12_wrapper(...) LAYOUT_ortho_4x12(__VA_ARGS__) #define LAYOUT_ortho_4x12_wrapper(...) LAYOUT_ortho_4x12(__VA_ARGS__)
#define LAYOUT_ortho_5x12_wrapper(...) LAYOUT_ortho_5x12(__VA_ARGS__) #define LAYOUT_ortho_5x12_wrapper(...) LAYOUT_ortho_5x12(__VA_ARGS__)
/*
Blocks for each of the four major keyboard layouts
Organized so we can quickly adapt and modify all of them
at once, rather than for each keyboard, one at a time.
And this allows for much cleaner blocks in the keymaps.
For instance Tap/Hold for Control on all of the layouts
NOTE: These are all the same length. If you do a search/replace
then you need to add/remove underscores to keep the
lengths consistent.
*/
#define _________________QWERTY_L1_________________ KC_Q, KC_W, KC_E, KC_R, KC_T #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_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_L3_________________ KC_Z, KC_X, KC_C, KC_V, KC_B
@ -51,6 +39,14 @@ NOTE: These are all the same length. If you do a search/replace
#define _________________DVORAK_R2_________________ KC_D, KC_H, KC_T, KC_N, KC_S #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 _________________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_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 ________________NUMBER_RIGHT_______________ KC_6, KC_7, KC_8, KC_9, KC_0
@ -67,26 +63,26 @@ NOTE: These are all the same length. If you do a search/replace
#define _________________LOWER_L1__________________ _________________FUNC_LEFT_________________ #define _________________LOWER_L1__________________ _________________FUNC_LEFT_________________
#define _________________LOWER_L2__________________ _________________SYM_LEFT__________________ #define _________________LOWER_L2__________________ _________________SYM_LEFT__________________
#define _________________LOWER_L3__________________ KC_DT1, KC_DT2, KC_DT3, KC_DT4, _______ #define _________________LOWER_L3__________________ KC_DT1, KC_DT2, KC_DT3, KC_DT4, KC_CCCV
#define _________________LOWER_R1__________________ _________________FUNC_RIGHT________________ #define _________________LOWER_R1__________________ _________________FUNC_RIGHT________________
#define _________________LOWER_R2__________________ _________________SYM_RIGHT_________________ #define _________________LOWER_R2__________________ _________________SYM_RIGHT_________________
#define _________________LOWER_R3__________________ _______, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR #define _________________LOWER_R3__________________ KC_DQUO, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR
#define _________________RAISE_L1__________________ ________________NUMBER_LEFT________________ #define _________________RAISE_L1__________________ ________________NUMBER_LEFT________________
#define _________________RAISE_L2__________________ KC_PGUP, KC_PGDN, KC_HOME, KC_END, _______ #define _________________RAISE_L2__________________ KC_PGUP, KC_PGDN, KC_HOME, KC_END, _______
#define _________________RAISE_L3__________________ _______, _______, _______, _______, _______ #define _________________RAISE_L3__________________ UC_FLIP, UC_TABL, UC_SHRG, UC_DISA, _______
#define _________________RAISE_R1__________________ ________________NUMBER_RIGHT_______________ #define _________________RAISE_R1__________________ ________________NUMBER_RIGHT_______________
#define _________________RAISE_R2__________________ KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______ #define _________________RAISE_R2__________________ KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______
#define _________________RAISE_R3__________________ _______, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC #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_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_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_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_R1_________________ KC_SEC1, KC_SEC2, KC_SEC3, KC_SEC4, KC_SEC5
#define _________________ADJUST_R2_________________ CG_SWAP, QWERTY, COLEMAK, DVORAK, XXXXXXX #define _________________ADJUST_R2_________________ CG_SWAP, QWERTY, COLEMAK, DVORAK, WORKMAN
#define _________________ADJUST_R3_________________ MG_NKRO, KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT #define _________________ADJUST_R3_________________ MG_NKRO, KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT
// clang-format on // clang-format on