[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

keyboards/crkbd/keymaps/curry/config.h

@@ -6,23 +6,7 @@
 #define OLED_DISABLE_TIMEOUT
 #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_HUE_STEP 8
 #    define RGB_MATRIX_SAT_STEP 8

keyboards/crkbd/keymaps/curry/keymap.c

@@ -6,10 +6,10 @@
         K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A  \
     ) \
     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, \
-                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__)
 
@@ -32,6 +32,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         _________________DVORAK_L3_________________, _________________DVORAK_R3_________________
     ),
 
+    [_WORKMAN] = LAYOUT_crkbd_base_wrapper(
+        _________________WORKMAN_L1________________, _________________WORKMAN_R1________________,
+        _________________WORKMAN_L2________________, _________________WORKMAN_R2________________,
+        _________________WORKMAN_L3________________, _________________WORKMAN_R3________________
+    ),
+
     [_MODS] = LAYOUT_wrapper(
         _______, ___________________BLANK___________________,       ___________________BLANK___________________, _______,
         _______, ___________________BLANK___________________,       ___________________BLANK___________________, _______,
@@ -40,8 +46,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     ),
 
     [_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__________________, _______,
                                    _______, _______, _______,       _______, _______, _______
     ),
@@ -54,7 +60,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     ),
 
     [_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,
         MG_NKRO, _________________ADJUST_L3_________________,       _________________ADJUST_R3_________________, RGB_IDL,
                                    _______, _______, _______,       _______, TG_MODS, _______

keyboards/crkbd/keymaps/curry/rules.mk

@@ -2,22 +2,15 @@
 #   change to "no" to disable the options, or define them in the Makefile in
 #   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
-MIDI_ENABLE                 = no  # MIDI controls
-AUDIO_ENABLE                = no  # Audio output on port C6
-UNICODE_ENABLE              = no  # Unicode
-BLUETOOTH_ENABLE            = no  # Enable Bluetooth with the Adafruit EZ-Key HID
-RGBLIGHT_ENABLE             = no  # Enable WS2812 RGB underlight.
-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

keyboards/lily58/keymaps/curry/config.h

@@ -5,3 +5,13 @@
 
 #define OLED_DISABLE_TIMEOUT
 #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

keyboards/lily58/keymaps/curry/keymap.c

@@ -11,7 +11,7 @@
         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, \
         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__)
 
@@ -63,7 +63,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
     [_ADJUST] = LAYOUT_wrapper( \
         _______, ___________________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,
         MG_NKRO, _________________ADJUST_L3_________________, _______,  _______, _________________ADJUST_R3_________________, RGB_IDL,
                                    _______, _______, _______, _______,  _______, _______, _______, _______

keyboards/lily58/keymaps/curry/rules.mk

@@ -2,20 +2,15 @@
 #   change to "no" to disable the options, or define them in the Makefile in
 #   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
-UNICODE_ENABLE              = no  # Unicode
-BLUETOOTH_ENABLE            = no  # Enable Bluetooth with the Adafruit EZ-Key HID
-RGBLIGHT_ENABLE             = no  # Enable WS2812 RGB underlight.
-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

users/curry/config.h

@@ -6,28 +6,19 @@
 /* Set Polling rate to 1000Hz */
 #define USB_POLLING_INTERVAL_MS 1
 
-#ifdef RGBLIGHT_ENABLE
+#if defined(RGBLIGHT_ENABLE)
 #    undef RGBLIGHT_ANIMATIONS
-#    if defined(__AVR__) && !defined(__AVR_AT90USB1286__)
 #    define RGBLIGHT_SLEEP
 #    define RGBLIGHT_EFFECT_BREATHING
 #    define RGBLIGHT_EFFECT_SNAKE
 #    define RGBLIGHT_EFFECT_KNIGHT
-#    else
-#        define RGBLIGHT_ANIMATIONS
-#    endif
 #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_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_GRADIENT_UP_DOWN
 #    define DISABLE_RGB_MATRIX_BREATHING
@@ -64,39 +55,33 @@
 #    define DISABLE_RGB_MATRIX_MULTISPLASH
 #    define DISABLE_RGB_MATRIX_SOLID_SPLASH
 #    define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH
-#    endif  // AVR
 #endif  // RGB_MATRIX_ENABLE
 
-#ifndef ONESHOT_TAP_TOGGLE
+#if !defined(ONESHOT_TAP_TOGGLE)
 #    define ONESHOT_TAP_TOGGLE 2
 #endif  // !ONESHOT_TAP_TOGGLE
 
-#ifndef ONESHOT_TIMEOUT
+#if !defined(ONESHOT_TIMEOUT)
 #    define ONESHOT_TIMEOUT 3000
 #endif  // !ONESHOT_TIMEOUT
 
-#ifndef QMK_KEYS_PER_SCAN
+#if !defined(QMK_KEYS_PER_SCAN)
 #    define QMK_KEYS_PER_SCAN 4
 #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
 #undef PERMISSIVE_HOLD
-//#define TAPPING_FORCE_HOLD
-//#define RETRO_TAPPING
 
 #define FORCE_NKRO
 
-#ifndef TAPPING_TOGGLE
+#if !defined(TAPPING_TOGGLE)
 #    define TAPPING_TOGGLE 1
 #endif
 
-#ifdef TAPPING_TERM
+#if defined(TAPPING_TERM)
 #    undef TAPPING_TERM
 #endif  // TAPPING_TERM
+
 #if defined(KEYBOARD_ergodox_ez)
 #    define TAPPING_TERM 185
 #elif defined(KEYBOARD_crkbd)
@@ -107,12 +92,20 @@
 
 #define TAP_CODE_DELAY 5
 
+#define LEADER_TIMEOUT 250
+#define LEADER_PER_KEY_TIMING
+
 /* Disable unused and unneeded features to reduce on firmware size */
-#ifdef LOCKING_SUPPORT_ENABLE
+#if defined(LOCKING_SUPPORT_ENABLE)
 #    undef LOCKING_SUPPORT_ENABLE
 #endif
-#ifdef LOCKING_RESYNC_ENABLE
+
+#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"

users/curry/curry.c

@@ -53,15 +53,16 @@ void rgb_matrix_update_pwm_buffers(void);
 
 // On RESET, set all RGB to red, shutdown the keymap.
 void shutdown_user(void) {
-#ifdef RGBLIGHT_ENABLE
+#if defined(RGBLIGHT_ENABLE)
     rgblight_enable_noeeprom();
     rgblight_mode_noeeprom(1);
     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_update_pwm_buffers();
-#endif  // RGB_MATRIX_ENABLE
+#endif
     shutdown_keymap();
 }
 
@@ -77,7 +78,7 @@ __attribute__((weak)) void matrix_scan_keymap(void) {}
 
 // No global matrix scan code, so just run keymap's matrix
 // scan function
-void matrix_scan_user(void) {
+__attribute__((weak)) void matrix_scan_user(void) {
     static bool has_ran_yet;
     if (!has_ran_yet) {
         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
 layer_state_t layer_state_set_user(layer_state_t state) {
     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);
-#endif  // RGBLIGHT_ENABLE
+#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) {
+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) {}
 

users/curry/curry.h

@@ -1,18 +1,23 @@
 #pragma once
 
 #include QMK_KEYBOARD_H
-
 #include "version.h"
 #include "eeprom.h"
 #include "wrappers.h"
 #include "process_records.h"
 
-#ifdef TAP_DANCE_ENABLE
+#if defined(TAP_DANCE_ENABLE)
 #    include "tap_dances.h"
 #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
+
+#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"
@@ -23,6 +28,7 @@ enum userspace_layers {
     _QWERTY  = 0,
     _COLEMAK,
     _DVORAK,
+    _WORKMAN,
     _MODS,
     _LOWER,
     _RAISE,

users/curry/glcdfont.c

@@ -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
 // Online editor: https://helixfonteditor.netlify.com/

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

users/curry/leader.h

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

users/curry/oled.c

@@ -1,6 +1,5 @@
 #include "curry.h"
 
-#ifdef OLED_DRIVER_ENABLE
 #define KEYLOGGER_LENGTH 5
 static uint32_t oled_timer                       = 0;
 static char     keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"};
@@ -26,6 +25,7 @@ static const char PROGMEM code_to_name[0xFF] = {
     ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '        // Fx
 };
 
+// clang-format on
 void add_keylog(uint16_t keycode);
 
 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) {
-    oled_write_P(PSTR("Keys"), false);
+    oled_write_P(PSTR("Keys:"), false);
     oled_write(keylog_str, false);
 }
 
@@ -65,6 +65,9 @@ void render_default_layer_state(void) {
         case _DVORAK:
             oled_write_P(PSTR(" DVRK"), false);
             break;
+        case _WORKMAN:
+            oled_write_P(PSTR(" WRKM"), false);
+            break;
     }
 }
 
@@ -139,7 +142,7 @@ void oled_task_user(void) {
         oled_off();
         return;
     }
-#    ifndef SPLIT_KEYBOARD
+#if !defined(SPLIT_KEYBOARD)
     else {
         oled_on();
     }
@@ -158,5 +161,3 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
     }
     return true;
 }
-
-#endif

users/curry/process_records.c

@@ -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) {
     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());
@@ -19,18 +24,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
                 if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) {
                     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;
 
         case VRSN:  // Prints firmware version
@@ -44,17 +39,13 @@ 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_code16(LCTL(KC_C));
-                    tap_code(KC_C);
-                    unregister_code(KC_LCTL);
                 } else {  // Tap, paste
-                    register_code(KC_LCTL);
+                    tap_code16(LCTL(KC_V));
-                    tap_code(KC_V);
-                    unregister_code(KC_LCTL);
                 }
             }
             break;
-#ifdef UNICODE_ENABLE
+#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");

users/curry/process_records.h

@@ -1,17 +1,11 @@
 #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 {
-    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_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
@@ -21,7 +15,6 @@ enum userspace_custom_keycodes {
     KC_SECRET_4,        // test4
     KC_SECRET_5,        // test5
     KC_CCCV,            // Hold to copy, tap to paste
-    KC_NUKE,                        // NUCLEAR LAUNCH DETECTED!!!
     UC_FLIP,            // (ಠ痊ಠ)┻━┻
     UC_TABL,            // ┬─┬ノ( º _ ºノ)
     UC_SHRG,            // ¯\_(ツ)_/¯
@@ -52,25 +45,20 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
 #define QWERTY KC_QWERTY
 #define DVORAK KC_DVORAK
 #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)
 #else  // SWAP_HANDS_ENABLE
 #    define KC_C1R3 KC_TAB
 #endif  // SWAP_HANDS_ENABLE
 
-#define BK_LWER LT(_LOWER, KC_BSPC)
 #define SP_LWER LT(_LOWER, KC_SPC)
-#define DL_RAIS LT(_RAISE, KC_DEL)
 #define ET_RAIS LT(_RAISE, KC_ENTER)
 
 /* 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_RGUI OSM(MOD_RGUI)
 #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_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 ALT_APP ALT_T(KC_APP)

users/curry/rgb_lighting_user.c

@@ -1,77 +1,16 @@
 #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;
 bool                     has_initialized;
 
 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.
  * 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.
  */
-#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) {
     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)) {
@@ -145,7 +84,7 @@ void matrix_scan_indicator(void) {
 }
 #endif  // INDICATOR_LIGHTS
 
-#    ifdef RGBLIGHT_TWINKLE
+#if defined(RGBLIGHT_TWINKLE)
 static rgblight_fadeout lights[RGBLED_NUM];
 
 __attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; }
@@ -260,7 +199,6 @@ void start_rgb_light(void) {
     rgblight_sethsv_at(light->hue, 255, light->life, light_index);
 }
 #endif
-#endif  // RGBLIGHT_ENABLE
 
 bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
     uint16_t temp_keycode = keycode;
@@ -269,15 +207,8 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
         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) {
-#ifdef RGBLIGHT_TWINKLE
+#if defined(RGBLIGHT_TWINKLE)
         case KC_A ... KC_SLASH:
         case KC_F1 ... KC_F12:
         case KC_INSERT ... KC_UP:
@@ -290,7 +221,6 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
             break;
 #endif                  // RGBLIGHT_TWINKLE
         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) {
                 userspace_config.rgb_layer_change ^= 1;
                 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)
                 }
             }
-#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;
         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
                 // 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)
-                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) {
                     eeconfig_update_user(userspace_config.raw);
                 }
@@ -341,7 +249,6 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
 }
 
 void keyboard_post_init_rgb(void) {
-#if defined(RGBLIGHT_ENABLE)
 #if defined(RGBLIGHT_STARTUP_ANIMATION)
     bool is_enabled = rgblight_config.enable;
     if (userspace_config.rgb_layer_change) {
@@ -363,42 +270,25 @@ void keyboard_post_init_rgb(void) {
 
 #endif
     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) {
-#ifdef RGBLIGHT_ENABLE
+#if defined(RGBLIGHT_TWINKLE)
-#    ifdef RGBLIGHT_TWINKLE
     scan_rgblight_fadeout();
 #endif  // RGBLIGHT_ENABLE
 
-#    ifdef INDICATOR_LIGHTS
+#if defined(INDICATOR_LIGHTS)
     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
 }
 
-#ifdef RGBLIGHT_ENABLE
 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);
 }
-#endif
 
 layer_state_t layer_state_set_rgb(layer_state_t state) {
-#ifdef RGBLIGHT_ENABLE
     if (userspace_config.rgb_layer_change) {
         switch (get_highest_layer(state)) {
             case _RAISE:
@@ -420,6 +310,9 @@ layer_state_t layer_state_set_rgb(layer_state_t state) {
                     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;
@@ -428,44 +321,5 @@ layer_state_t layer_state_set_rgb(layer_state_t state) {
             }
         }
     }
-#endif  // RGBLIGHT_ENABLE
-
     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

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

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

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

users/curry/rgb_stuff.h

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

users/curry/rules.mk

@@ -1,8 +1,15 @@
 SRC += curry.c \
        process_records.c
 
-LTO_ENABLE            = yes
+# 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)","")
@@ -21,8 +28,12 @@ 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_stuff.c
+    SRC += rgb_lighting_user.c
     ifeq ($(strip $(INDICATOR_LIGHTS)), yes)
         OPT_DEFS += -DINDICATOR_LIGHTS
     endif
@@ -39,10 +50,9 @@ endif
 
 RGB_MATRIX_ENABLE ?= no
 ifneq ($(strip $(RGB_MATRIX_ENABLE)), no)
-    SRC += rgb_stuff.c
+    SRC += rgb_matrix_user.c
 endif
 
-
 ifdef CONSOLE_ENABLE
     ifeq ($(strip $(KEYLOGGER_ENABLE)), yes)
         OPT_DEFS += -DKEYLOGGER_ENABLE

users/curry/tap_dances.c

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

users/curry/tap_dances.h

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

users/curry/wrappers.h

@@ -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_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_L2_________________         KC_A,    KC_S,    KC_D,    KC_F,    KC_G
 #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_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
@@ -67,26 +63,26 @@ NOTE: These are all the same length.  If you do a search/replace
 
 #define _________________LOWER_L1__________________         _________________FUNC_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_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_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_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_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,  XXXXXXX
+#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