9 files changed, 205 insertions, 205 deletions

diff --git a/users/konstantin/config.h b/users/konstantin/config.h
index f18c4a70e..4ca19f824 100644
--- a/users/konstantin/config.h
+++ b/users/konstantin/config.h
@@ -19,4 +19,4 @@
 
 #define UNICODE_CYCLE_PERSIST  false
 #define UNICODE_SELECTED_MODES UC_WINC, UC_WIN, UC_LNX
-#define UNICODE_WINC_KEY       KC_RGUI
+#define UNICODE_KEY_WINC       KC_RGUI
diff --git a/users/konstantin/konstantin.c b/users/konstantin/konstantin.c
index 753742fa7..9e3caca41 100644
--- a/users/konstantin/konstantin.c
+++ b/users/konstantin/konstantin.c
@@ -4,107 +4,99 @@ __attribute__((weak))
 void keyboard_pre_init_keymap(void) {}
 
 void keyboard_pre_init_user(void) {
-  keyboard_pre_init_keymap();
+    keyboard_pre_init_keymap();
 }
 
 __attribute__((weak))
 void eeconfig_init_keymap(void) {}
 
 void eeconfig_init_user(void) {
-  eeconfig_init_keymap();
+    eeconfig_init_keymap();
 }
 
 __attribute__((weak))
 void keyboard_post_init_keymap(void) {}
 
 void keyboard_post_init_user(void) {
-  keyboard_post_init_keymap();
+    keyboard_post_init_keymap();
 }
 
 __attribute__((weak))
 bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
-  return true;
+    return true;
 }
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  if (!process_record_keymap(keycode, record)) {
-    return false;
-  }
-
-#ifdef LAYER_NUMPAD
-  void toggle_numpad(void) {
-    layer_invert(L_NUMPAD);
-    bool numpad = IS_LAYER_ON(L_NUMPAD), num_lock = IS_HOST_LED_ON(USB_LED_NUM_LOCK);
-    if (num_lock != numpad) {
-      tap_code(KC_NLCK);  // Toggle Num Lock to match layer state
+    if (!process_record_keymap(keycode, record)) {
+        return false;
     }
-  }
-#endif
 
-  switch (keycode) {
-  case CLEAR:
-    if (record->event.pressed) {
-      SEND_STRING(SS_LCTRL("a") SS_TAP(X_DELETE));
-    }
-    return false;
+    switch (keycode) {
+    case CLEAR:
+        if (record->event.pressed) {
+            SEND_STRING(SS_LCTRL("a") SS_TAP(X_DELETE));
+        }
+        return false;
 
-  case DST_P_R:
-    (record->event.pressed ? register_code16 : unregister_code16)(
-      (get_mods() & DST_MOD_MASK) ? DST_REM : DST_PRV
-    );
-    return false;
+    case DST_P_R:
+        (record->event.pressed ? register_code16 : unregister_code16)(
+            (get_mods() & DST_MOD_MASK) ? DST_REM : DST_PRV
+        );
+        return false;
 
-  case DST_N_A:
-    (record->event.pressed ? register_code16 : unregister_code16)(
-      (get_mods() & DST_MOD_MASK) ? DST_ADD : DST_NXT
-    );
-    return false;
+    case DST_N_A:
+        (record->event.pressed ? register_code16 : unregister_code16)(
+            (get_mods() & DST_MOD_MASK) ? DST_ADD : DST_NXT
+        );
+        return false;
 
 #ifdef LAYER_FN
-    static bool fn_lock;
-
-  case FN_FNLK:
-    if (record->event.pressed && record->tap.count == TAPPING_TOGGLE) {
-      fn_lock = !IS_LAYER_ON(L_FN);  // Fn layer will be toggled after this
-    }
-    return true;
-#endif
+        static bool fn_lock;
 
-#ifdef LAYER_NUMPAD
-  case NUMPAD:
-    if (record->event.pressed) {
-      toggle_numpad();
-    }
-    return false;
+    case FN_FNLK:
+        if (record->event.pressed && record->tap.count == TAPPING_TOGGLE) {
+            fn_lock = !IS_LAYER_ON(L_FN);  // Fn layer will be toggled after this
+        }
+        return true;
 #endif
 
-  case KC_ESC:
-    if (record->event.pressed) {
-#ifdef LAYER_NUMPAD
-      if (IS_LAYER_ON(L_NUMPAD)) {
-        toggle_numpad();
-        return false;
-      }
+    case KC_ESC:
+        if (record->event.pressed) {
+#ifdef LAYER_NUMPAD  // Disable Numpad layer before Fn layer
+            if (IS_LAYER_ON(L_NUMPAD)) {
+                layer_off(L_NUMPAD);
+                return false;
+            }
 #endif
 #ifdef LAYER_FN
-      if (IS_LAYER_ON(L_FN) && fn_lock) {
-        layer_off(L_FN);
-        return fn_lock = false;
-      }
+            if (IS_LAYER_ON(L_FN) && fn_lock) {
+                layer_off(L_FN);
+                return fn_lock = false;
+            }
 #endif
-    }
-    return true;
+        }
+        return true;
 
-  default:
-    return true;
-  }
+    default:
+        return true;
+    }
 }
 
 __attribute__((weak))
 uint32_t layer_state_set_keymap(uint32_t state) {
-  return state;
+    return state;
 }
 
 uint32_t layer_state_set_user(uint32_t state) {
-  return layer_state_set_keymap(state);
+    state = layer_state_set_keymap(state);
+
+#ifdef LAYER_NUMPAD
+    bool numpad = state & 1UL<<L_NUMPAD;
+    bool num_lock = IS_HOST_LED_ON(USB_LED_NUM_LOCK);
+    if (numpad != num_lock) {
+        tap_code(KC_NLCK);  // Toggle Num Lock to match Numpad layer state
+    }
+#endif
+
+    return state;
 }
diff --git a/users/konstantin/konstantin.h b/users/konstantin/konstantin.h
index 0639b93a6..d43712b96 100644
--- a/users/konstantin/konstantin.h
+++ b/users/konstantin/konstantin.h
@@ -1,20 +1,25 @@
 #pragma once
 
 #include "quantum.h"
-#if defined(RGBLIGHT_ENABLE) || defined(RGBMATRIX_ENABLE)
-  #include "rgb.h"
+#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
+    #include "rgb.h"
 #endif
 #ifdef TAP_DANCE_ENABLE
-  #include "tap_dance.h"
+    #include "tap_dance.h"
 #endif
 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE)
-  #include "unicode.h"
+    #include "unicode.h"
 #endif
 
 #ifdef LAYER_FN
-  #define FN      MO(L_FN)
-  #define FN_CAPS LT(L_FN, KC_CAPS)
-  #define FN_FNLK TT(L_FN)
+    #define FN      MO(L_FN)
+    #define FN_CAPS LT(L_FN, KC_CAPS)
+    #define FN_ESC  LT(L_FN, KC_ESC)
+    #define FN_FNLK TT(L_FN)
+#endif
+
+#ifdef LAYER_NUMPAD
+    #define NUMPAD TG(L_NUMPAD)
 #endif
 
 #define KC_SYSR LALT(KC_PSCR)
@@ -27,50 +32,49 @@
 #define MV_RGHT LCTL(KC_RGHT)
 #define TOP     LCTL(KC_HOME)
 #define BOTTOM  LCTL(KC_END)
-#define PRV_TAB LCTL(KC_PGUP)
-#define NXT_TAB LCTL(KC_PGDN)
+#define TAB_PRV LCTL(KC_PGUP)
+#define TAB_NXT LCTL(KC_PGDN)
+#define DEL_PRV LCTL(KC_BSPC)
+#define DEL_NXT LCTL(KC_DEL)
 
 #define DST_ADD LCTL(LGUI(KC_D))
 #define DST_REM LCTL(LGUI(KC_F4))
 #define DST_PRV LCTL(LGUI(KC_LEFT))
 #define DST_NXT LCTL(LGUI(KC_RGHT))
 #ifndef DST_MOD_MASK
-  #define DST_MOD_MASK MOD_MASK_CTRL
+    #define DST_MOD_MASK MOD_MASK_SHIFT
 #endif
 
 #define LCT_CPS LCTL_T(KC_CAPS)
 
 #ifdef SEND_STRING_CLEAN
-  #undef  SEND_STRING
-  #define SEND_STRING(string) {     \
-      uint8_t ss_mods = get_mods(); \
-      clear_mods();                 \
-      send_string_P(PSTR(string));  \
-      set_mods(ss_mods);            \
-    }
+    #undef  SEND_STRING
+    #define SEND_STRING(string) {         \
+            uint8_t ss_mods = get_mods(); \
+            clear_mods();                 \
+            send_string_P(PSTR(string));  \
+            set_mods(ss_mods);            \
+        }
 #endif
 
 enum keycodes_user {
-  CLEAR = SAFE_RANGE,
-  DST_P_R,
-  DST_N_A,
-#ifdef LAYER_NUMPAD
-  NUMPAD,
-#endif
+    CLEAR = SAFE_RANGE,
+    DST_P_R,
+    DST_N_A,
 
-  RANGE_KEYMAP,
+    RANGE_KEYMAP,
 };
 
 enum layers_user {
-  L_BASE,
+    L_BASE,
 #ifdef LAYER_FN
-  L_FN,
+    L_FN,
 #endif
 #ifdef LAYER_NUMPAD
-  L_NUMPAD,
+    L_NUMPAD,
 #endif
 
-  L_RANGE_KEYMAP,
+    L_RANGE_KEYMAP,
 };
 
 void keyboard_pre_init_keymap(void);
diff --git a/users/konstantin/rgb.h b/users/konstantin/rgb.h
index 53b5821b0..aed855aa0 100644
--- a/users/konstantin/rgb.h
+++ b/users/konstantin/rgb.h
@@ -3,15 +3,15 @@
 #include "quantum.h"
 
 typedef struct {
-  uint16_t h;  // 0–360
-  uint8_t  s;  // 0–255
-  uint8_t  v;  // 0–255
+    uint16_t h;  // 0–360
+    uint8_t  s;  // 0–255
+    uint8_t  v;  // 0–255
 } hsv_t;
 
 typedef struct {
-  uint8_t r;  // 0–255
-  uint8_t g;  // 0–255
-  uint8_t b;  // 0–255
+    uint8_t r;  // 0–255
+    uint8_t g;  // 0–255
+    uint8_t b;  // 0–255
 } rgb_t;
 
 extern const hsv_t GODSPEED_BLUE;
diff --git a/users/konstantin/rules.mk b/users/konstantin/rules.mk
index 6bda030fb..bf0ab979f 100644
--- a/users/konstantin/rules.mk
+++ b/users/konstantin/rules.mk
@@ -1,12 +1,16 @@
 SRC += konstantin.c
-ifneq (,$(filter yes,$(RGBLIGHT_ENABLE) $(RGB_MATRIX_ENABLE)))  # if either is yes
-  SRC += rgb.c
+ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
+    SRC += rgb.c
+endif
+RGB_MATRIX_ENABLE ?= no
+ifneq ($(strip $(RGB_MATRIX_ENABLE)), no)
+    SRC += rgb.c
 endif
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
-  SRC += tap_dance.c
+    SRC += tap_dance.c
 endif
-ifneq (,$(filter yes,$(UNICODE_ENABLE) $(UNICODEMAP_ENABLE)))  # if either is yes
-  SRC += unicode.c
+ifneq (,$(filter yes,$(UNICODE_ENABLE) $(UNICODEMAP_ENABLE)))
+    SRC += unicode.c
 endif
 
 EXTRAFLAGS += -flto
diff --git a/users/konstantin/tap_dance.c b/users/konstantin/tap_dance.c
index 0b405939b..fa43288ce 100644
--- a/users/konstantin/tap_dance.c
+++ b/users/konstantin/tap_dance.c
@@ -1,117 +1,117 @@
 #include "tap_dance.h"
 #include "konstantin.h"
 
-#define ACTION_TAP_DANCE_DOUBLE_MOD(mod1, mod2) {                   \
-    .fn        = { td_double_mod_each, NULL, td_double_mod_reset }, \
-    .user_data = &(qk_tap_dance_pair_t){ mod1, mod2 },              \
-  }
+#define ACTION_TAP_DANCE_DOUBLE_MOD(mod1, mod2) {                       \
+        .fn        = { td_double_mod_each, NULL, td_double_mod_reset }, \
+        .user_data = &(qk_tap_dance_pair_t){ mod1, mod2 },              \
+    }
 
 void td_double_mod_each(qk_tap_dance_state_t *state, void *user_data) {
-  qk_tap_dance_pair_t *data = (qk_tap_dance_pair_t *)user_data;
-
-  // Single tap → mod1, double tap → mod2, triple tap etc. → mod1+mod2
-  if (state->count == 1 || state->count == 3) {
-    register_code(data->kc1);
-  } else if (state->count == 2) {
-    unregister_code(data->kc1);
-    register_code(data->kc2);
-  }
-  // Prevent tap dance from sending the mods as weak mods
-  state->weak_mods &= ~(MOD_BIT(data->kc1) | MOD_BIT(data->kc2));
+    qk_tap_dance_pair_t *data = (qk_tap_dance_pair_t *)user_data;
+
+    // Single tap → mod1, double tap → mod2, triple tap etc. → mod1+mod2
+    if (state->count == 1 || state->count == 3) {
+        register_code(data->kc1);
+    } else if (state->count == 2) {
+        unregister_code(data->kc1);
+        register_code(data->kc2);
+    }
+    // Prevent tap dance from sending the mods as weak mods
+    state->weak_mods &= ~(MOD_BIT(data->kc1) | MOD_BIT(data->kc2));
 }
 
 void td_double_mod_reset(qk_tap_dance_state_t *state, void *user_data) {
-  qk_tap_dance_pair_t *data = (qk_tap_dance_pair_t *)user_data;
-
-  if (state->count == 1 || state->count >= 3) {
-    unregister_code(data->kc1);
-  }
-  if (state->count >= 2) {
-    unregister_code(data->kc2);
-  }
+    qk_tap_dance_pair_t *data = (qk_tap_dance_pair_t *)user_data;
+
+    if (state->count == 1 || state->count >= 3) {
+        unregister_code(data->kc1);
+    }
+    if (state->count >= 2) {
+        unregister_code(data->kc2);
+    }
 }
 
-#define ACTION_TAP_DANCE_MOD_LAYER(mod, layer) {                  \
-    .fn        = { td_mod_layer_each, NULL, td_mod_layer_reset }, \
-    .user_data = &(qk_tap_dance_dual_role_t){ mod, layer },       \
-  }
+#define ACTION_TAP_DANCE_MOD_LAYER(mod, layer) {                      \
+        .fn        = { td_mod_layer_each, NULL, td_mod_layer_reset }, \
+        .user_data = &(qk_tap_dance_dual_role_t){ mod, layer },       \
+    }
 
 void td_mod_layer_each(qk_tap_dance_state_t *state, void *user_data) {
-  qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data;
-
-  // Single tap → mod, double tap → layer, triple tap etc. → mod+layer
-  if (state->count == 1 || state->count == 3) {
-    register_code(data->kc);
-  } else if (state->count == 2) {
-    unregister_code(data->kc);
-    // Prevent tap dance from sending the mod as a weak mod
-    state->weak_mods &= ~MOD_BIT(data->kc);
-    layer_on(data->layer);
-  }
+    qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data;
+
+    // Single tap → mod, double tap → layer, triple tap etc. → mod+layer
+    if (state->count == 1 || state->count == 3) {
+        register_code(data->kc);
+    } else if (state->count == 2) {
+        unregister_code(data->kc);
+        // Prevent tap dance from sending the mod as a weak mod
+        state->weak_mods &= ~MOD_BIT(data->kc);
+        layer_on(data->layer);
+    }
 }
 
 void td_mod_layer_reset(qk_tap_dance_state_t *state, void *user_data) {
-  qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data;
-
-  if (state->count == 1 || state->count >= 3) {
-    unregister_code(data->kc);
-  }
-  if (state->count >= 2) {
-    layer_off(data->layer);
-  }
+    qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data;
+
+    if (state->count == 1 || state->count >= 3) {
+        unregister_code(data->kc);
+    }
+    if (state->count >= 2) {
+        layer_off(data->layer);
+    }
 }
 
-#define ACTION_TAP_DANCE_LAYER_MOD(layer, mod) {                  \
-    .fn        = { td_layer_mod_each, NULL, td_layer_mod_reset }, \
-    .user_data = &(qk_tap_dance_layer_mod_t){ layer, mod, 0, 0 }, \
-  }
+#define ACTION_TAP_DANCE_LAYER_MOD(layer, mod) {                      \
+        .fn        = { td_layer_mod_each, NULL, td_layer_mod_reset }, \
+        .user_data = &(qk_tap_dance_layer_mod_t){ layer, mod, 0, 0 }, \
+    }
 
 typedef struct {
-  uint8_t  layer;
-  uint16_t kc;
-  bool     layer_on;  // Layer state when tap dance started
-  bool     started;
+    uint8_t  layer;
+    uint16_t kc;
+    bool     layer_on;  // Layer state when tap dance started
+    bool     started;
 } qk_tap_dance_layer_mod_t;
 
 void td_layer_mod_each(qk_tap_dance_state_t *state, void *user_data) {
-  qk_tap_dance_layer_mod_t *data = (qk_tap_dance_layer_mod_t *)user_data;
-  if (!data->started) {
-    data->layer_on = IS_LAYER_ON(data->layer);
-    data->started = true;
-  }
-
-  // Single tap → layer, double tap → mod, triple tap etc. → layer+mod
-  if (state->count == 1 || state->count == 3) {
-    layer_on(data->layer);
-  } else if (state->count == 2) {
-    if (!data->layer_on) {
-      layer_off(data->layer);
+    qk_tap_dance_layer_mod_t *data = (qk_tap_dance_layer_mod_t *)user_data;
+    if (!data->started) {
+        data->layer_on = IS_LAYER_ON(data->layer);
+        data->started = true;
+    }
+
+    // Single tap → layer, double tap → mod, triple tap etc. → layer+mod
+    if (state->count == 1 || state->count == 3) {
+        layer_on(data->layer);
+    } else if (state->count == 2) {
+        if (!data->layer_on) {
+            layer_off(data->layer);
+        }
+        register_code(data->kc);
     }
-    register_code(data->kc);
-  }
 }
 
 void td_layer_mod_reset(qk_tap_dance_state_t *state, void *user_data) {
-  qk_tap_dance_layer_mod_t *data = (qk_tap_dance_layer_mod_t *)user_data;
+    qk_tap_dance_layer_mod_t *data = (qk_tap_dance_layer_mod_t *)user_data;
 
-  if ((state->count == 1 || state->count >= 3) && !data->layer_on) {
-    layer_off(data->layer);
-  }
-  if (state->count >= 2) {
-    unregister_code(data->kc);
-  }
+    if ((state->count == 1 || state->count >= 3) && !data->layer_on) {
+        layer_off(data->layer);
+    }
+    if (state->count >= 2) {
+        unregister_code(data->kc);
+    }
 
-  data->started = false;
+    data->started = false;
 }
 
 qk_tap_dance_action_t tap_dance_actions[] = {
-  [TD_DST_A_R] = ACTION_TAP_DANCE_DOUBLE(DST_ADD, DST_REM),
+    [TD_DST_A_R] = ACTION_TAP_DANCE_DOUBLE(DST_ADD, DST_REM),
 
-  [TD_RAL_LAL] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RALT, KC_LALT),
-  [TD_RAL_RGU] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RALT, KC_RGUI),
-  [TD_RCT_RSF] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RCTL, KC_RSFT),
+    [TD_RAL_LAL] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RALT, KC_LALT),
+    [TD_RAL_RGU] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RALT, KC_RGUI),
+    [TD_RCT_RSF] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RCTL, KC_RSFT),
 
-  [TD_LSFT_FN] = ACTION_TAP_DANCE_MOD_LAYER(KC_LSFT, L_FN),
-  [TD_RCTL_FN] = ACTION_TAP_DANCE_MOD_LAYER(KC_RCTL, L_FN),
-  [TD_FN_RCTL] = ACTION_TAP_DANCE_LAYER_MOD(L_FN, KC_RCTL),
+    [TD_LSFT_FN] = ACTION_TAP_DANCE_MOD_LAYER(KC_LSFT, L_FN),
+    [TD_RCTL_FN] = ACTION_TAP_DANCE_MOD_LAYER(KC_RCTL, L_FN),
+    [TD_FN_RCTL] = ACTION_TAP_DANCE_LAYER_MOD(L_FN, KC_RCTL),
 };
diff --git a/users/konstantin/tap_dance.h b/users/konstantin/tap_dance.h
index ad7c04cb7..13d682a60 100644
--- a/users/konstantin/tap_dance.h
+++ b/users/konstantin/tap_dance.h
@@ -13,13 +13,13 @@
 #define FN_RCTL TD(TD_FN_RCTL)
 
 enum tap_dance {
-  TD_DST_A_R,
+    TD_DST_A_R,
 
-  TD_RAL_LAL,
-  TD_RAL_RGU,
-  TD_RCT_RSF,
+    TD_RAL_LAL,
+    TD_RAL_RGU,
+    TD_RCT_RSF,
 
-  TD_LSFT_FN,
-  TD_RCTL_FN,
-  TD_FN_RCTL,
+    TD_LSFT_FN,
+    TD_RCTL_FN,
+    TD_FN_RCTL,
 };
diff --git a/users/konstantin/unicode.c b/users/konstantin/unicode.c
index 144c0aaf7..8ef5aaa1e 100644
--- a/users/konstantin/unicode.c
+++ b/users/konstantin/unicode.c
@@ -2,6 +2,6 @@
 
 #ifdef UNICODEMAP_ENABLE
 const uint32_t PROGMEM unicode_map[] = {
-  FOREACH_UNICODE(UCM_ENTRY)
+    FOREACH_UNICODE(UCM_ENTRY)
 };
 #endif
diff --git a/users/konstantin/unicode.h b/users/konstantin/unicode.h
index c8eddabb7..b2616d120 100644
--- a/users/konstantin/unicode.h
+++ b/users/konstantin/unicode.h
@@ -3,13 +3,13 @@
 #include "quantum.h"
 
 #define FOREACH_UNICODE(M) \
-  M(COMMA,   0x002C)       \
-  M(L_PAREN, 0x0028)       \
-  M(R_PAREN, 0x0029)       \
-  M(EQUALS,  0x003D)       \
-  M(TIMES,   0x00D7)       \
-  M(DIVIDE,  0x00F7)       \
-  M(MINUS,   0x2212)
+    M(COMMA,   0x002C)     \
+    M(L_PAREN, 0x0028)     \
+    M(R_PAREN, 0x0029)     \
+    M(EQUALS,  0x003D)     \
+    M(TIMES,   0x00D7)     \
+    M(DIVIDE,  0x00F7)     \
+    M(MINUS,   0x2212)
 
 #define UC_KEYCODE(name, code)  name = UC(code),
 
@@ -19,16 +19,16 @@
 
 #if defined(UNICODE_ENABLE)
 enum unicode_keycodes {
-  FOREACH_UNICODE(UC_KEYCODE)
+    FOREACH_UNICODE(UC_KEYCODE)
 };
 #elif defined(UNICODEMAP_ENABLE)
 enum unicode_names {
-  FOREACH_UNICODE(UCM_NAME)
+    FOREACH_UNICODE(UCM_NAME)
 };
 
 extern const uint32_t PROGMEM unicode_map[];
 
 enum unicode_keycodes {
-  FOREACH_UNICODE(UCM_KEYCODE)
+    FOREACH_UNICODE(UCM_KEYCODE)
 };
 #endif