preferences.cpp

#include "pch.h"
#include "preferences.h"
#include "core/control_panel_core.h"
#include <uxtheme.h>
#include <commdlg.h>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>
#pragma comment(lib, "uxtheme.lib")
#pragma comment(lib, "comdlg32.lib")


// External declaration from component.cpp
extern HINSTANCE g_hInstance;

// Configuration variables - stored in foobar2000's config system
static cfg_int cfg_nowbar_theme_mode(
    GUID{0xABCDEF01, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89}}, 
    0  // Default: Auto
);

static cfg_int cfg_nowbar_cover_margin(
    GUID{0xABCDEF05, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8D}},
    1  // Default: Yes (margin enabled)
);

static cfg_int cfg_nowbar_cover_style(
    GUID{0xABCDEF54, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE4}},
    1  // Default: Rounded (0=Square, 1=Rounded)
);

static cfg_int cfg_nowbar_cover_artwork_visible(
    GUID{0xABCDEF53, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE3}},
    1  // Default: Yes (show artwork)
);

static cfg_int cfg_nowbar_online_artwork(
    GUID{0xABCDEF90, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF0}},
    0  // Default: Disabled
);

static cfg_int cfg_nowbar_bar_style(
    GUID{0xABCDEF06, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8E}},
    0  // Default: Pill-shaped
);

static cfg_int cfg_nowbar_seekbar_visible(
    GUID{0xABCDEF06, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x03}},
    1  // Default: On
);

static cfg_int cfg_nowbar_seekbar_length(
    GUID{0xABCDEF06, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x01}},
    0  // Default: Fixed
);

static cfg_int cfg_nowbar_seekbar_position(
    GUID{0xABCDEF06, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x02}},
    0  // Default: centered (no offset)
);

static cfg_int cfg_nowbar_button_scaling_enabled(
    GUID{0xABCDEFD1, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD1}},
    0  // Default: 0 (dynamic scaling)
);

static cfg_int cfg_nowbar_button_scaling_percent(
    GUID{0xABCDEFD2, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD2}},
    80 // Default: 80% of max button size
);

static cfg_int cfg_nowbar_mood_icon_visible(
    GUID{0xABCDEF07, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8F}},
    1  // Default: Show (visible)
);

static cfg_int cfg_nowbar_shuffle_icon_visible(
    GUID{0xABCDEF6B, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xFB}},
    1  // Default: Show (visible)
);

static cfg_int cfg_nowbar_repeat_icon_visible(
    GUID{0xABCDEF6C, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xFC}},
    1  // Default: Show (visible)
);

static cfg_int cfg_nowbar_rating_visible(
    GUID{0xABCDEFA2, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA2}},
    0  // Default: Hidden
);

static cfg_int cfg_nowbar_mood_tag_mode(
    GUID{0xABCDEF57, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE7}},
    0  // Default: 0=FEEDBACK, 1=2003_LOVED, 2=LFM_LOVED, 3=SMP_LOVED, 4=MOOD
);

static cfg_int cfg_nowbar_stop_icon_visible(
    GUID{0xABCDEF51, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE1}},
    0  // Default: Hidden
);

static cfg_int cfg_nowbar_stop_after_current_icon_visible(
    GUID{0xABCDEF5D, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xED}},
    0  // Default: Hidden
);

static cfg_int cfg_nowbar_super_icon_visible(
    GUID{0xABCDEF52, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE2}},
    1  // Default: Show
);

static cfg_int cfg_nowbar_miniplayer_icon_visible(
    GUID{0xABCDEF08, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x90}},
    0  // Default: Hidden
);

static cfg_int cfg_nowbar_custom_button_visible(
    GUID{0xABCDEF09, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x91}},
    1  // Default: Show (visible)
);

static cfg_int cfg_nowbar_hover_circles(
    GUID{0xABCDEF1C, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xAC}},
    1  // Default: Yes (show hover circles)
);

static cfg_int cfg_nowbar_alternate_icons(
    GUID{0xABCDEF1D, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xAD}},
    0  // Default: Disabled
);

static cfg_int cfg_nowbar_play_icon_style(
    GUID{0xABCDEFBA, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xBA}},
    0  // Default: Normal (0=Normal, 1=Inverted)
);

static cfg_int cfg_nowbar_cbutton_autohide(
    GUID{0xABCDEF1E, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xAE}},
    0  // Default: No (don't auto-hide)
);

static cfg_int cfg_nowbar_volume_icon_visible(
    GUID{0xABCDEF69, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF9}},
    1  // Default: Show (visible)
);

static cfg_int cfg_nowbar_volume_bar_visible(
    GUID{0xABCDEF6A, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xFA}},
    1  // Default: Show (visible)
);


static cfg_int cfg_nowbar_background_style(
    GUID{0xABCDEF50, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE0}},
    0  // Default: Solid (0=Solid, 1=Artwork Colors, 2=Blurred Artwork)
);

static cfg_int cfg_nowbar_smooth_animations(
    GUID{0xABCDEF80, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x80}},
    0  // Default: Disabled
);

static cfg_int cfg_nowbar_button_accent_color(
    GUID{0xABCDEFC0, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC0}},
    RGB(100, 180, 255)  // Default: Light blue (matches current m_accent_color)
);

static cfg_int cfg_nowbar_progress_accent_color(
    GUID{0xABCDEF55, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE5}},
    RGB(140, 140, 140)  // Default: Gray (matches current progress bar color)
);

static cfg_int cfg_nowbar_volume_accent_color(
    GUID{0xABCDEF56, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE6}},
    RGB(140, 140, 140)  // Default: Gray (matches current volume bar color)
);

// Play/Pause button accent color
static cfg_int cfg_nowbar_play_accent_color(
    GUID{0xABCDEFA0, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA0}},
    RGB(100, 180, 255)  // Default: same as button accent
);

// Button hover color
static cfg_int cfg_nowbar_hover_color(
    GUID{0xABCDEFA1, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA1}},
    RGB(255, 255, 255)  // Default: white (40 alpha applied at render time)
);

// Custom color enable flags (0=use theme, 1=use custom)
static cfg_int cfg_custom_button_accent_enabled(
    GUID{0xABCDEFB0, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB0}},
    0  // Default: use theme color
);
static cfg_int cfg_custom_play_accent_enabled(
    GUID{0xABCDEFB1, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB1}},
    0  // Default: use theme color
);
static cfg_int cfg_custom_progress_accent_enabled(
    GUID{0xABCDEFB2, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB2}},
    0  // Default: use theme color
);
static cfg_int cfg_custom_volume_accent_enabled(
    GUID{0xABCDEFB3, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB3}},
    0  // Default: use theme color
);
static cfg_int cfg_custom_hover_color_enabled(
    GUID{0xABCDEFB4, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB4}},
    0  // Default: use theme color (Selection)
);
static cfg_int cfg_custom_spectrum_color_enabled(
    GUID{0xABCDEFB5, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB5}},
    0  // Default: use theme color
);
static cfg_int cfg_custom_waveform_color_enabled(
    GUID{0xABCDEFB6, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB6}},
    0  // Default: use theme color
);
static cfg_int cfg_custom_waveform_unplayed_enabled(
    GUID{0xABCDEFB7, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB7}},
    0  // Default: use theme color (Text)
);
static cfg_int cfg_custom_progress_track_enabled(
    GUID{0xABCDEFB8, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB8}},
    0  // Default: use theme color (Text)
);
static cfg_int cfg_custom_volume_track_enabled(
    GUID{0xABCDEFB9, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB9}},
    0  // Default: use theme color (Text)
);

static cfg_int cfg_nowbar_infinite_playback(
    GUID{0xABCDEF58, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE8}},
    0  // Default: Disabled
);

static cfg_int cfg_nowbar_preview_mode(
    GUID{0xABCDEF59, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xE9}},
    0  // Default: Off (0=Off, 1=35%, 2=50%, 3=60sec)
);

static cfg_int cfg_nowbar_skip_low_rating_enabled(
    GUID{0xABCDEF5A, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xEA}},
    0  // Default: Disabled
);

static cfg_int cfg_nowbar_skip_low_rating_threshold(
    GUID{0xABCDEF5B, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xEB}},
    1  // Default: 1 (skip if rating <= 1)
);

static cfg_int cfg_nowbar_selection_mode(
    GUID{0xABCDEF5F, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xEF}},
    0  // Default: 0=Prioritize Now Playing Mode, 1=Follow Selection
);

static cfg_int cfg_nowbar_visualization_mode(
    GUID{0xABCDEF5C, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xEC}},
    0  // Default: Disabled (0=Disabled, 1=Spectrum, 2=Waveform)
);

// Remembers spectrum vs waveform selection independently of the enable checkbox,
// so the user's choice persists even when visualization is disabled.
static cfg_int cfg_nowbar_vis_type(
    GUID{0xABCDEF5E, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xEE}},
    1  // Default: Spectrum (1=Spectrum, 2=Waveform)
);

static cfg_int cfg_nowbar_spectrum_color(
    GUID{0xABCDEF81, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x81}},
    RGB(100, 180, 255)  // Default: light blue
);

static cfg_int cfg_nowbar_spectrum_width(
    GUID{0xABCDEF82, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x82}},
    1  // Default: Normal (0=Thin, 1=Normal, 2=Wide)
);

static cfg_int cfg_nowbar_spectrum_style(
    GUID{0xABCDEF8A, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8A}},
    1  // Default: Curve (0=Mono, 1=Curve, 2=Dominoes)
);

static cfg_int cfg_nowbar_spectrum_height(
    GUID{0xABCDEF8B, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8B}},
    2  // Default: High (0=Low, 1=Normal, 2=High)
);

static cfg_int cfg_nowbar_spectrum_opacity(
    GUID{0xABCDEF87, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x87}},
    75  // Default: 75% opacity
);

static cfg_int cfg_nowbar_spectrum_gradient_mode(
    GUID{0xABCDEF88, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x88}},
    0  // Default: Adaptive (0=Adaptive, 1=Solid, 2=Gradient, 3=Frequency)
);

static cfg_int cfg_nowbar_spectrum_color2(
    GUID{0xABCDEF89, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89}},
    RGB(30, 80, 160)  // Default: darker blue (gradient bottom)
);

static cfg_int cfg_nowbar_vis_60fps(
    GUID{0xABCDEF84, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x84}},
    0  // Default: Disabled (0=30fps spectrum, 1=60fps spectrum)
);

static cfg_int cfg_nowbar_waveform_color(
    GUID{0xABCDEF86, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x86}},
    RGB(255, 85, 0)  // Default: SoundCloud orange
);

static cfg_int cfg_nowbar_waveform_width(
    GUID{0xABCDEF85, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x85}},
    0  // Default: Thin (0=Thin, 1=Wide, 2=Wide (4K))
);

static cfg_int cfg_nowbar_waveform_style(
    GUID{0xABCDEF8C, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8C}},
    0  // Default: Waveform 1 (0=Waveform 1 / Bottom bars, 1=Waveform 2 / Centered envelope)
);

static cfg_int cfg_nowbar_waveform_unplayed_color(
    GUID{0xABCDEF66, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF6}},
    RGB(60, 60, 60)  // Default: dim gray (fully opaque)
);

static cfg_int cfg_nowbar_progress_track_color(
    GUID{0xABCDEF67, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF7}},
    RGB(60, 60, 60)  // Default: dark grey
);

static cfg_int cfg_nowbar_volume_track_color(
    GUID{0xABCDEF68, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF8}},
    RGB(60, 60, 60)  // Default: dark grey
);

static cfg_int cfg_nowbar_custom_button_action(
    GUID{0xABCDEF0A, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x92}},
    0  // Default: None (0=None, 1=Open URL, 2=Run Executable, 3=Foobar2k Action, 4=Open Folder)
);

static cfg_string cfg_nowbar_custom_button_url(
    GUID{0xABCDEF0B, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x93}},
    ""  // Default: empty
);

static cfg_string cfg_nowbar_custom_button_executable(
    GUID{0xABCDEF0C, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x94}},
    ""  // Default: empty
);

static cfg_string cfg_nowbar_custom_button_fb2k_action(
    GUID{0xABCDEF0D, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x95}},
    ""  // Default: empty (e.g., "Playback/Matrix Now Playing/Announce current track to Matrix")
);

// Display format configuration
static cfg_string cfg_nowbar_line1_format(
    GUID{0xABCDEF30, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC0}},
    "%title%"  // Default: title only
);

static cfg_string cfg_nowbar_line2_format(
    GUID{0xABCDEF31, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC1}},
    "%artist%"  // Default: artist only
);

static cfg_string cfg_nowbar_line3_format(
    GUID{0xABCDEF32, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC2}},
    ""  // Default: empty (disabled)
);

// Font configuration
static cfg_struct_t<LOGFONT> cfg_nowbar_artist_font(
    GUID{0xABCDEF02, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8A}},
    []() {
        LOGFONT lf = {};
        lf.lfHeight = -17;  // ~12.6pt at 96 DPI (40% larger than 9pt)
        lf.lfWeight = FW_NORMAL;
        lf.lfCharSet = DEFAULT_CHARSET;
        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
        lf.lfQuality = CLEARTYPE_QUALITY;
        lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
        wcscpy_s(lf.lfFaceName, L"Microsoft YaHei UI");
        return lf;
    }()
);

static cfg_struct_t<LOGFONT> cfg_nowbar_track_font(
    GUID{0xABCDEF03, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8B}},
    []() {
        LOGFONT lf = {};
        lf.lfHeight = -21;  // ~15.4pt at 96 DPI (40% larger than 11pt)
        lf.lfWeight = FW_BOLD;
        lf.lfCharSet = DEFAULT_CHARSET;
        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
        lf.lfQuality = CLEARTYPE_QUALITY;
        lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
        wcscpy_s(lf.lfFaceName, L"Microsoft YaHei UI");
        return lf;
    }()
);

static cfg_struct_t<LOGFONT> cfg_nowbar_line3_font(
    GUID{0xABCDEF0F, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x97}},
    []() {
        LOGFONT lf = {};
        lf.lfHeight = -17;  // Same as artist font default
        lf.lfWeight = FW_NORMAL;
        lf.lfCharSet = DEFAULT_CHARSET;
        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
        lf.lfQuality = CLEARTYPE_QUALITY;
        lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
        wcscpy_s(lf.lfFaceName, L"Microsoft YaHei UI");
        return lf;
    }()
);

static cfg_struct_t<LOGFONT> cfg_nowbar_time_font(
    GUID{0xABCDEF0E, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x96}},
    []() {
        LOGFONT lf = {};
        lf.lfHeight = -12;  // ~9pt at 96 DPI
        lf.lfWeight = FW_NORMAL;
        lf.lfCharSet = DEFAULT_CHARSET;
        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
        lf.lfQuality = CLEARTYPE_QUALITY;
        lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
        wcscpy_s(lf.lfFaceName, L"Microsoft YaHei UI");
        return lf;
    }()
);

static cfg_int cfg_nowbar_use_custom_fonts(
    GUID{0xABCDEF04, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x8C}},
    0  // Default: use built-in fonts
);

// Font color configuration (-1 = use theme color)
static cfg_int cfg_nowbar_track_font_color(
    GUID{0xABCDEF04, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC0}},
    -1  // Default: use theme color
);

static cfg_int cfg_nowbar_artist_font_color(
    GUID{0xABCDEF04, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC1}},
    -1  // Default: use theme color
);

static cfg_int cfg_nowbar_line3_font_color(
    GUID{0xABCDEF04, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC3}},
    -1  // Default: use theme color
);

static cfg_int cfg_nowbar_time_font_color(
    GUID{0xABCDEF04, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC2}},
    -1  // Default: use theme color
);

// Custom Button tab configuration (4 buttons)
static cfg_int cfg_cbutton1_enabled(
    GUID{0xABCDEF10, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA0}},
    0  // Default: disabled
);
static cfg_int cfg_cbutton1_action(
    GUID{0xABCDEF11, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA1}},
    0  // Default: None
);
static cfg_int cfg_cbutton2_enabled(
    GUID{0xABCDEF12, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA2}},
    0  // Default: disabled
);
static cfg_int cfg_cbutton2_action(
    GUID{0xABCDEF13, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA3}},
    0  // Default: None
);
static cfg_int cfg_cbutton3_enabled(
    GUID{0xABCDEF14, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA4}},
    0  // Default: disabled
);
static cfg_int cfg_cbutton3_action(
    GUID{0xABCDEF15, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA5}},
    0  // Default: None
);
static cfg_int cfg_cbutton4_enabled(
    GUID{0xABCDEF16, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA6}},
    0  // Default: disabled
);
static cfg_int cfg_cbutton4_action(
    GUID{0xABCDEF17, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA7}},
    0  // Default: None
);

static cfg_string cfg_cbutton1_path(
    GUID{0xABCDEF18, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA8}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton2_path(
    GUID{0xABCDEF19, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xA9}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton3_path(
    GUID{0xABCDEF1A, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xAA}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton4_path(
    GUID{0xABCDEF1B, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xAB}},
    ""  // Default: empty
);

// Custom Button 5 and 6 config
static cfg_int cfg_cbutton5_enabled(
    GUID{0xABCDEF20, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB0}},
    0  // Default: disabled
);
static cfg_int cfg_cbutton5_action(
    GUID{0xABCDEF21, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB1}},
    0  // Default: None
);
static cfg_string cfg_cbutton5_path(
    GUID{0xABCDEF22, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB2}},
    ""  // Default: empty
);
static cfg_int cfg_cbutton6_enabled(
    GUID{0xABCDEF23, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB3}},
    0  // Default: disabled
);
static cfg_int cfg_cbutton6_action(
    GUID{0xABCDEF24, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB4}},
    0  // Default: None
);
static cfg_string cfg_cbutton6_path(
    GUID{0xABCDEF25, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xB5}},
    ""  // Default: empty
);

// Custom Button Icon paths (PNG/ICO files for custom icons)
static cfg_string cfg_cbutton1_icon(
    GUID{0xABCDEF40, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD0}},
    ""  // Default: empty (use default numbered icon)
);
static cfg_string cfg_cbutton2_icon(
    GUID{0xABCDEF41, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD1}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton3_icon(
    GUID{0xABCDEF42, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD2}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton4_icon(
    GUID{0xABCDEF43, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD3}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton5_icon(
    GUID{0xABCDEF44, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD4}},
    ""  // Default: empty
);
static cfg_string cfg_cbutton6_icon(
    GUID{0xABCDEF45, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xD5}},
    ""  // Default: empty
);

// Custom Button Glyph sizes (percentage of icon area, default 80%)
static cfg_int cfg_cbutton1_glyph_size(
    GUID{0xABCDEF70, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x01}},
    80
);
static cfg_int cfg_cbutton2_glyph_size(
    GUID{0xABCDEF71, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x02}},
    80
);
static cfg_int cfg_cbutton3_glyph_size(
    GUID{0xABCDEF72, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x03}},
    80
);
static cfg_int cfg_cbutton4_glyph_size(
    GUID{0xABCDEF73, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x04}},
    80
);
static cfg_int cfg_cbutton5_glyph_size(
    GUID{0xABCDEF74, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x05}},
    80
);
static cfg_int cfg_cbutton6_glyph_size(
    GUID{0xABCDEF75, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x06}},
    80
);

// Custom Button Tooltip labels (user-friendly names for tooltips)
static cfg_string cfg_cbutton1_label(
    GUID{0xABCDEF60, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF0}},
    ""  // Default: empty (will show "Button #1")
);
static cfg_string cfg_cbutton2_label(
    GUID{0xABCDEF61, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF1}},
    ""  // Default: empty (will show "Button #2")
);
static cfg_string cfg_cbutton3_label(
    GUID{0xABCDEF62, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF2}},
    ""  // Default: empty (will show "Button #3")
);
static cfg_string cfg_cbutton4_label(
    GUID{0xABCDEF63, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF3}},
    ""  // Default: empty (will show "Button #4")
);
static cfg_string cfg_cbutton5_label(
    GUID{0xABCDEF64, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF4}},
    ""  // Default: empty (will show "Button #5")
);
static cfg_string cfg_cbutton6_label(
    GUID{0xABCDEF65, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF5}},
    ""  // Default: empty (will show "Button #6")
);

// Custom Button Font names (per-button font for glyph rendering)
static cfg_string cfg_cbutton1_font(
    GUID{0xABCDEF80, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x01}},
    "Segoe UI"
);
static cfg_string cfg_cbutton2_font(
    GUID{0xABCDEF81, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x02}},
    "Segoe UI"
);
static cfg_string cfg_cbutton3_font(
    GUID{0xABCDEF82, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x03}},
    "Segoe UI"
);
static cfg_string cfg_cbutton4_font(
    GUID{0xABCDEF83, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x04}},
    "Segoe UI"
);
static cfg_string cfg_cbutton5_font(
    GUID{0xABCDEF84, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x05}},
    "Segoe UI"
);
static cfg_string cfg_cbutton6_font(
    GUID{0xABCDEF85, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x06}},
    "Segoe UI"
);

// Color picker custom colors (16 user-defined slots in ChooseColor dialog)
static cfg_string cfg_color_picker_custom(
    GUID{0xABCDEF90, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x68, 0x90}},
    ""
);

// Profile configuration storage
static cfg_string cfg_cbutton_profiles(
    GUID{0xABCDEF70, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF6}},
    ""  // Default: empty (will create "Default" profile on first use)
);
static cfg_string cfg_cbutton_current_profile(
    GUID{0xABCDEF71, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xF7}},
    "Default"  // Default profile name
);

static cfg_int cfg_nowbar_3d_buttons(
    GUID{0xABCDEFC1, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC1}},
    1  // Default: Enabled (3D style)
);

static cfg_int cfg_nowbar_volume_number(
    GUID{0xABCDEFC2, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC2}},
    0  // Default: Disabled
);

static cfg_int cfg_nowbar_playback_time_visible(
    GUID{0xABCDEFC3, 0x1234, 0x5678, {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0xC3}},
    1  // Default: Show (1)
);

//=============================================================================
// Config File for All 12 Custom Buttons
// Buttons 1-6: Visible on panel, have enabled/icon fields
// Buttons 7-12: Hidden, keyboard shortcuts only
//=============================================================================

// Cached config for all 12 buttons (loaded from config file)
struct ConfigFileButtonConfig {
    bool enabled = false;      // Only used for buttons 1-6
    int action = 0;            // 0=none, 1=url, 2=executable, 3=foobar2k
    pfc::string8 path;         // URL, exe path, or fb2k command
    pfc::string8 icon;         // Glyph character (only used for buttons 1-6)
    pfc::string8 font;         // Font name (default "Segoe UI")
    int glyph_size = 80;       // Glyph size percentage (default 80%)
    pfc::string8 label;        // Tooltip/description
};

static ConfigFileButtonConfig g_config_buttons[12];
static bool g_config_loaded = false;
static pfc::string8 g_config_file_path;

// Get the config file directory path
pfc::string8 get_config_dir_path() {
    pfc::string8 profile_path = core_api::get_profile_path();
    // Remove "file://" prefix if present
    if (profile_path.has_prefix("file://")) {
        profile_path = profile_path.subString(7);
    }
    // Ensure trailing backslash
    if (!profile_path.is_empty() && profile_path[profile_path.length() - 1] != '\\' && profile_path[profile_path.length() - 1] != '/') {
        profile_path << "\\";
    }
    pfc::string8 dir_path;
    dir_path << profile_path << "foo_nowbar_data";
    return dir_path;
}

// Get the full config file path
static pfc::string8 get_config_file_path() {
    if (g_config_file_path.is_empty()) {
        g_config_file_path = get_config_dir_path();
        g_config_file_path << "\\custom_buttons.conf";
    }
    return g_config_file_path;
}

// Helper to trim whitespace from a string
static pfc::string8 trim_string(const char* str) {
    pfc::string8 result;
    const char* start = str;
    while (*start && (*start == ' ' || *start == '\t')) start++;
    const char* end = start + strlen(start);
    while (end > start && (*(end-1) == ' ' || *(end-1) == '\t' || *(end-1) == '\r' || *(end-1) == '\n')) end--;
    result.set_string(start, end - start);
    return result;
}

// Parse action string to int
static int parse_action_string(const char* str) {
    pfc::string8 action = trim_string(str);
    if (stricmp_utf8(action, "url") == 0) return 1;
    if (stricmp_utf8(action, "executable") == 0) return 2;
    if (stricmp_utf8(action, "foobar2k") == 0) return 3;
    if (stricmp_utf8(action, "open_folder") == 0) return 4;
    if (stricmp_utf8(action, "output_device") == 0 ||
        stricmp_utf8(action, "output_devices") == 0 ||
        stricmp_utf8(action, "output_device_menu") == 0 ||
        stricmp_utf8(action, "device") == 0) return 5;
    return 0;  // none
}

// Convert action int to string
static const char* action_to_string(int action) {
    switch (action) {
        case 1: return "url";
        case 2: return "executable";
        case 3: return "foobar2k";
        case 4: return "open_folder";
        case 5: return "output_device";
        default: return "none";
    }
}

// Create the foo_nowbar_data directory if it doesn't exist
void ensure_config_dir_exists() {
    pfc::string8 dir_path = get_config_dir_path();
    pfc::stringcvt::string_wide_from_utf8 wide_path(dir_path);
    CreateDirectoryW(wide_path, NULL);  // Ignore error if already exists
}

// Create default config file with template
static void create_default_config_file() {
    ensure_config_dir_exists();
    
    pfc::string8 file_path = get_config_file_path();
    pfc::stringcvt::string_wide_from_utf8 wide_path(file_path);
    
    std::ofstream file(wide_path.get_ptr(), std::ios::out | std::ios::binary);
    if (!file.is_open()) return;
    
    // Write UTF-8 BOM for proper encoding detection
    file.write("\xEF\xBB\xBF", 3);
    
    file << "# Now Bar Custom Buttons Configuration\n";
    file << "# Buttons 1-6: Visible on panel + keyboard shortcuts\n";
    file << "# Buttons 7-12: Hidden (keyboard shortcuts only)\n";
    file << "#\n";
    file << "# Action values: none, url, executable, foobar2k, open_folder, output_device\n";
    file << "# Path: URL for 'url', executable path for 'executable',\n";
    file << "#       menu path like 'Library/Search' for 'foobar2k',\n";
    file << "#       or leave empty for 'open_folder' or 'output_device'\n";
    file << "#\n";
    file << "# Title formatting is supported in URLs and paths (e.g., %artist%, %title%)\n";
    file << "\n";
    
    // Buttons 1-6 (visible)
    for (int i = 1; i <= 6; i++) {
        file << "[button:" << i << "]\n";
        file << "enabled = " << (get_nowbar_cbutton_enabled(i-1) ? "true" : "false") << "\n";
        file << "action = " << action_to_string(get_nowbar_cbutton_action(i-1)) << "\n";
        file << "path = " << get_nowbar_cbutton_path(i-1).c_str() << "\n";
        file << "icon = " << get_nowbar_cbutton_icon_path(i-1).c_str() << "\n";
        file << "font = " << get_nowbar_cbutton_font(i-1).c_str() << "\n";
        file << "glyph_size = " << get_nowbar_cbutton_glyph_size(i-1) << "\n";
        file << "label = " << get_nowbar_cbutton_label(i-1).c_str() << "\n";
        file << "\n";
    }

    // Buttons 7-12 (hidden)
    for (int i = 7; i <= 12; i++) {
        file << "[button:" << i << "]\n";
        file << "action = none\n";
        file << "path = \n";
        file << "label = Custom Button " << i << "\n";
        file << "\n";
    }

    file.close();
}

// Load config from file
static void load_config_file() {
    if (g_config_loaded) return;
    
    // Initialize with defaults
    for (int i = 0; i < 12; i++) {
        g_config_buttons[i] = ConfigFileButtonConfig();
        pfc::string8 label;
        label << "Custom Button " << (i + 1);
        g_config_buttons[i].label = label;
    }
    
    pfc::string8 file_path = get_config_file_path();
    pfc::stringcvt::string_wide_from_utf8 wide_path(file_path);
    
    std::ifstream file(wide_path.get_ptr());
    if (!file.is_open()) {
        // Config file doesn't exist - create it with current settings
        create_default_config_file();
        // Reload after creation
        file.open(wide_path.get_ptr());
        if (!file.is_open()) {
            g_config_loaded = true;
            return;
        }
    }
    
    std::string line;
    int current_button = -1;  // 0-based index
    
    while (std::getline(file, line)) {
        // Trim line
        size_t start = line.find_first_not_of(" \t");
        if (start == std::string::npos) continue;
        line = line.substr(start);
        
        // Skip comments and empty lines
        if (line.empty() || line[0] == '#' || line[0] == ';') continue;
        
        // Check for section header [button:N]
        if (line[0] == '[') {
            size_t end = line.find(']');
            if (end != std::string::npos) {
                std::string section = line.substr(1, end - 1);
                if (section.find("button:") == 0) {
                    int btn_num = std::atoi(section.substr(7).c_str());
                    if (btn_num >= 1 && btn_num <= 12) {
                        current_button = btn_num - 1;  // Convert to 0-based
                    }
                }
            }
            continue;
        }
        
        // Parse key=value
        size_t eq_pos = line.find('=');
        if (eq_pos == std::string::npos || current_button < 0) continue;
        
        std::string key = line.substr(0, eq_pos);
        std::string value = line.substr(eq_pos + 1);
        
        // Trim key and value
        while (!key.empty() && (key.back() == ' ' || key.back() == '\t')) key.pop_back();
        while (!value.empty() && (value[0] == ' ' || value[0] == '\t')) value = value.substr(1);
        while (!value.empty() && (value.back() == '\r' || value.back() == '\n')) value.pop_back();
        
        if (key == "enabled") {
            g_config_buttons[current_button].enabled = 
                (value == "true" || value == "1" || value == "yes");
        } else if (key == "action") {
            g_config_buttons[current_button].action = parse_action_string(value.c_str());
        } else if (key == "path") {
            g_config_buttons[current_button].path = value.c_str();
        } else if (key == "icon") {
            g_config_buttons[current_button].icon = value.c_str();
        } else if (key == "font") {
            g_config_buttons[current_button].font = value.c_str();
        } else if (key == "glyph_size") {
            g_config_buttons[current_button].glyph_size = atoi(std::string(value).c_str());
        } else if (key == "label") {
            g_config_buttons[current_button].label = value.c_str();
        }
    }
    
    file.close();
    g_config_loaded = true;
}

// Reload config from file (call when settings may have changed)
static void reload_config_file() {
    g_config_loaded = false;
    load_config_file();
}

// Save config file to disk (syncs buttons 1-6 from preferences, preserves 7-12 from cache)
static void save_config_file() {
    // Make sure config is loaded first so we have buttons 7-12
    if (!g_config_loaded) load_config_file();
    
    ensure_config_dir_exists();
    
    pfc::string8 file_path = get_config_file_path();
    pfc::stringcvt::string_wide_from_utf8 wide_path(file_path);
    
    std::ofstream file(wide_path.get_ptr(), std::ios::out | std::ios::binary);
    if (!file.is_open()) return;
    
    // Write UTF-8 BOM for proper encoding detection
    file.write("\xEF\xBB\xBF", 3);
    
    file << "# Now Bar Custom Buttons Configuration\n";
    file << "# Buttons 1-6: Visible on panel + keyboard shortcuts\n";
    file << "# Buttons 7-12: Hidden (keyboard shortcuts only)\n";
    file << "#\n";
    file << "# Action values: none, url, executable, foobar2k, open_folder, output_device\n";
    file << "# Path: URL for 'url', executable path for 'executable',\n";
    file << "#       menu path like 'Library/Search' for 'foobar2k',\n";
    file << "#       or leave empty for 'open_folder' or 'output_device'\n";
    file << "#\n";
    file << "# Title formatting is supported in URLs and paths (e.g., %artist%, %title%)\n";
    file << "\n";
    
    // Buttons 1-6 (visible) - read from preferences (cfg_* variables)
    for (int i = 1; i <= 6; i++) {
        file << "[button:" << i << "]\n";
        file << "enabled = " << (get_nowbar_cbutton_enabled(i-1) ? "true" : "false") << "\n";
        file << "action = " << action_to_string(get_nowbar_cbutton_action(i-1)) << "\n";
        file << "path = " << get_nowbar_cbutton_path(i-1).c_str() << "\n";
        file << "icon = " << get_nowbar_cbutton_icon_path(i-1).c_str() << "\n";
        file << "font = " << get_nowbar_cbutton_font(i-1).c_str() << "\n";
        file << "glyph_size = " << get_nowbar_cbutton_glyph_size(i-1) << "\n";
        file << "label = " << get_nowbar_cbutton_label(i-1).c_str() << "\n";
        file << "\n";
    }

    // Buttons 7-12 (hidden) - read from cached config
    for (int i = 7; i <= 12; i++) {
        file << "[button:" << i << "]\n";
        file << "action = " << action_to_string(g_config_buttons[i-1].action) << "\n";
        file << "path = " << g_config_buttons[i-1].path.c_str() << "\n";
        file << "label = " << g_config_buttons[i-1].label.c_str() << "\n";
        file << "\n";
    }
    
    file.close();
    
    // Update cache for buttons 1-6 to match preferences
    for (int i = 0; i < 6; i++) {
        g_config_buttons[i].enabled = get_nowbar_cbutton_enabled(i);
        g_config_buttons[i].action = get_nowbar_cbutton_action(i);
        g_config_buttons[i].path = get_nowbar_cbutton_path(i);
        g_config_buttons[i].icon = get_nowbar_cbutton_icon_path(i);
        g_config_buttons[i].font = get_nowbar_cbutton_font(i);
        g_config_buttons[i].glyph_size = get_nowbar_cbutton_glyph_size(i);
        g_config_buttons[i].label = get_nowbar_cbutton_label(i);
    }
}

// Get button config from config file (for buttons 7-12, always; for 1-6, optional)
static const ConfigFileButtonConfig& get_config_button(int index) {
    if (!g_config_loaded) load_config_file();
    if (index < 0 || index >= 12) {
        static ConfigFileButtonConfig empty;
        return empty;
    }
    return g_config_buttons[index];
}

//=============================================================================
// Profile Management - Simple JSON-like serialization
//=============================================================================

// Escape a string for JSON-like storage
static pfc::string8 escape_json_string(const char* str) {
    pfc::string8 result;
    while (*str) {
        if (*str == '"') result << "\\\"";
        else if (*str == '\\') result << "\\\\";
        else if (*str == '\n') result << "\\n";
        else if (*str == '\r') result << "\\r";
        else if (*str == '\t') result << "\\t";
        else result.add_byte(*str);
        str++;
    }
    return result;
}

// Unescape a JSON-like string
static pfc::string8 unescape_json_string(const char* str) {
    pfc::string8 result;
    while (*str) {
        if (*str == '\\' && *(str + 1)) {
            str++;
            if (*str == '"') result.add_byte('"');
            else if (*str == '\\') result.add_byte('\\');
            else if (*str == 'n') result.add_byte('\n');
            else if (*str == 'r') result.add_byte('\r');
            else if (*str == 't') result.add_byte('\t');
            else result.add_byte(*str);
        } else {
            result.add_byte(*str);
        }
        str++;
    }
    return result;
}

// Button configuration for a single button
struct ButtonConfig {
    bool enabled = false;
    int action = 0;
    pfc::string8 path;
    pfc::string8 icon;   // Glyph character
    pfc::string8 font;   // Font name (default "Segoe UI")
    int glyph_size = 80;  // Glyph size percentage
    pfc::string8 label;
};

// Full profile with 6 buttons
struct CButtonProfile {
    pfc::string8 name;
    ButtonConfig buttons[6];
};

// Serialize a single profile to JSON format
static pfc::string8 serialize_profile(const CButtonProfile& profile) {
    pfc::string8 json;
    json << "{\"name\":\"" << escape_json_string(profile.name.c_str()) << "\",\"buttons\":[";
    for (int i = 0; i < 6; i++) {
        if (i > 0) json << ",";
        json << "{\"enabled\":" << (profile.buttons[i].enabled ? "true" : "false");
        json << ",\"action\":" << profile.buttons[i].action;
        json << ",\"path\":\"" << escape_json_string(profile.buttons[i].path.c_str()) << "\"";
        json << ",\"icon\":\"" << escape_json_string(profile.buttons[i].icon.c_str()) << "\"";
        json << ",\"font\":\"" << escape_json_string(profile.buttons[i].font.c_str()) << "\"";
        json << ",\"glyph_size\":" << profile.buttons[i].glyph_size;
        json << ",\"label\":\"" << escape_json_string(profile.buttons[i].label.c_str()) << "\"}";
    }
    json << "]}";
    return json;
}

// Helper to skip whitespace
static const char* skip_ws(const char* p) {
    while (*p && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++;
    return p;
}

// Helper to parse a JSON string value (assumes p points to opening quote)
static const char* parse_json_string(const char* p, pfc::string8& out) {
    out.reset();
    if (*p != '"') return p;
    p++;
    while (*p && *p != '"') {
        if (*p == '\\' && *(p + 1)) {
            p++;
            if (*p == '"') out.add_byte('"');
            else if (*p == '\\') out.add_byte('\\');
            else if (*p == 'n') out.add_byte('\n');
            else if (*p == 'r') out.add_byte('\r');
            else if (*p == 't') out.add_byte('\t');
            else out.add_byte(*p);
        } else {
            out.add_byte(*p);
        }
        p++;
    }
    if (*p == '"') p++;
    return p;
}

// Skip any JSON value (string, number, boolean, null, object, array)
static const char* skip_json_value(const char* p) {
    p = skip_ws(p);
    if (*p == '"') {
        // String - skip to closing quote
        p++;
        while (*p && *p != '"') {
            if (*p == '\\' && *(p + 1)) p++;  // Skip escaped char
            p++;
        }
        if (*p == '"') p++;
    } else if (*p == '{') {
        // Object - skip to matching }
        int depth = 1;
        p++;
        while (*p && depth > 0) {
            if (*p == '{') depth++;
            else if (*p == '}') depth--;
            else if (*p == '"') {
                p++;
                while (*p && *p != '"') {
                    if (*p == '\\' && *(p + 1)) p++;
                    p++;
                }
            }
            if (*p) p++;
        }
    } else if (*p == '[') {
        // Array - skip to matching ]
        int depth = 1;
        p++;
        while (*p && depth > 0) {
            if (*p == '[') depth++;
            else if (*p == ']') depth--;
            else if (*p == '"') {
                p++;
                while (*p && *p != '"') {
                    if (*p == '\\' && *(p + 1)) p++;
                    p++;
                }
            }
            if (*p) p++;
        }
    } else {
        // Number, boolean, or null - skip until delimiter
        while (*p && *p != ',' && *p != '}' && *p != ']' && *p != ' ' && *p != '\t' && *p != '\n' && *p != '\r') {
            p++;
        }
    }
    return p;
}

// Parse a single profile from JSON
static const char* parse_profile(const char* p, CButtonProfile& profile) {
    p = skip_ws(p);
    if (*p != '{') return p;
    p++;
    
    while (*p && *p != '}') {
        p = skip_ws(p);
        if (*p == '"') {
            pfc::string8 key;
            p = parse_json_string(p, key);
            p = skip_ws(p);
            if (*p == ':') p++;
            p = skip_ws(p);
            
            if (key == "name") {
                p = parse_json_string(p, profile.name);
            } else if (key == "buttons") {
                if (*p == '[') {
                    p++;
                    int btn_idx = 0;
                    while (*p && *p != ']' && btn_idx < 6) {
                        p = skip_ws(p);
                        if (*p == '{') {
                            p++;
                            while (*p && *p != '}') {
                                p = skip_ws(p);
                                if (*p == '"') {
                                    pfc::string8 btn_key;
                                    p = parse_json_string(p, btn_key);
                                    p = skip_ws(p);
                                    if (*p == ':') p++;
                                    p = skip_ws(p);
                                    
                                    if (btn_key == "enabled") {
                                        if (strncmp(p, "true", 4) == 0) {
                                            profile.buttons[btn_idx].enabled = true;
                                            p += 4;
                                        } else if (strncmp(p, "false", 5) == 0) {
                                            profile.buttons[btn_idx].enabled = false;
                                            p += 5;
                                        } else {
                                            p = skip_json_value(p);  // Skip unexpected value
                                        }
                                    } else if (btn_key == "action") {
                                        profile.buttons[btn_idx].action = atoi(p);
                                        while (*p && ((*p >= '0' && *p <= '9') || *p == '-')) p++;
                                    } else if (btn_key == "path") {
                                        p = parse_json_string(p, profile.buttons[btn_idx].path);
                                    } else if (btn_key == "icon") {
                                        p = parse_json_string(p, profile.buttons[btn_idx].icon);
                                    } else if (btn_key == "font") {
                                        p = parse_json_string(p, profile.buttons[btn_idx].font);
                                    } else if (btn_key == "glyph_size") {
                                        profile.buttons[btn_idx].glyph_size = atoi(p);
                                        while (*p && ((*p >= '0' && *p <= '9') || *p == '-')) p++;
                                    } else if (btn_key == "label") {
                                        p = parse_json_string(p, profile.buttons[btn_idx].label);
                                    } else {
                                        // Unknown key - skip its value
                                        p = skip_json_value(p);
                                    }
                                } else if (*p && *p != '}') {
                                    // Unexpected character, skip it
                                    p++;
                                }
                                p = skip_ws(p);
                                if (*p == ',') p++;
                            }
                            if (*p == '}') p++;
                            btn_idx++;
                        } else if (*p && *p != ']') {
                            // Skip non-object elements in array
                            p = skip_json_value(p);
                        }
                        p = skip_ws(p);
                        if (*p == ',') p++;
                    }
                    // Skip any remaining buttons beyond 6
                    while (*p && *p != ']') {
                        p = skip_ws(p);
                        if (*p == '{' || *p == '[' || *p == '"') {
                            p = skip_json_value(p);
                        } else if (*p && *p != ']') {
                            p++;
                        }
                        p = skip_ws(p);
                        if (*p == ',') p++;
                    }
                    if (*p == ']') p++;
                } else {
                    p = skip_json_value(p);  // Skip non-array buttons value
                }
            } else {
                // Unknown key - skip its value
                p = skip_json_value(p);
            }
        } else if (*p && *p != '}') {
            // Unexpected character at top level, skip it
            p++;
        }
        p = skip_ws(p);
        if (*p == ',') p++;
    }
    if (*p == '}') p++;
    return p;
}


// Get all profiles from storage
static std::vector<CButtonProfile> get_all_profiles() {
    std::vector<CButtonProfile> profiles;
    pfc::string8 data = cfg_cbutton_profiles.get();
    
    if (data.is_empty()) {
        // Create default profile with current settings
        CButtonProfile def;
        def.name = "Default";
        for (int i = 0; i < 6; i++) {
            def.buttons[i].enabled = get_nowbar_cbutton_enabled(i);
            def.buttons[i].action = get_nowbar_cbutton_action(i);
            def.buttons[i].path = get_nowbar_cbutton_path(i);
            def.buttons[i].icon = get_nowbar_cbutton_icon_path(i);
            def.buttons[i].glyph_size = get_nowbar_cbutton_glyph_size(i);
            def.buttons[i].font = get_nowbar_cbutton_font(i);
            def.buttons[i].label = cfg_cbutton1_label.get();  // Will fix below
        }
        // Fix labels
        def.buttons[0].label = cfg_cbutton1_label.get();
        def.buttons[1].label = cfg_cbutton2_label.get();
        def.buttons[2].label = cfg_cbutton3_label.get();
        def.buttons[3].label = cfg_cbutton4_label.get();
        def.buttons[4].label = cfg_cbutton5_label.get();
        def.buttons[5].label = cfg_cbutton6_label.get();
        profiles.push_back(def);
        return profiles;
    }
    
    // Parse profiles array
    const char* p = data.c_str();
    p = skip_ws(p);
    if (*p == '[') {
        p++;
        while (*p && *p != ']') {
            p = skip_ws(p);
            if (*p == '{') {
                CButtonProfile profile;
                p = parse_profile(p, profile);
                if (!profile.name.is_empty()) {
                    profiles.push_back(profile);
                }
            }
            p = skip_ws(p);
            if (*p == ',') p++;
        }
    }
    
    if (profiles.empty()) {
        CButtonProfile def;
        def.name = "Default";
        profiles.push_back(def);
    }
    
    return profiles;
}

// Save all profiles to storage
static void save_all_profiles(const std::vector<CButtonProfile>& profiles) {
    pfc::string8 data;
    data << "[";
    for (size_t i = 0; i < profiles.size(); i++) {
        if (i > 0) data << ",";
        data << serialize_profile(profiles[i]);
    }
    data << "]";
    cfg_cbutton_profiles = data;
}

// Find a profile by name
static CButtonProfile* find_profile(std::vector<CButtonProfile>& profiles, const char* name) {
    for (auto& p : profiles) {
        if (stricmp_utf8(p.name.c_str(), name) == 0) {
            return &p;
        }
    }
    return nullptr;
}

// Get current profile name
static pfc::string8 get_current_profile_name() {
    return cfg_cbutton_current_profile.get();
}

// Set current profile name
static void set_current_profile_name(const char* name) {
    cfg_cbutton_current_profile = name;
}

// Static buffer for input dialog (shared across invocations)

static wchar_t s_input_dialog_buffer[256];
static POINT s_input_dialog_pos;

// Dialog proc for input dialog with positioning
static INT_PTR CALLBACK InputDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_INITDIALOG: {
        SetDlgItemTextW(hDlg, 101, s_input_dialog_buffer);
        SendDlgItemMessage(hDlg, 101, EM_SETSEL, 0, -1);  // Select all
        
        // Position at cursor
        RECT dlgRect;
        GetWindowRect(hDlg, &dlgRect);
        int dlgWidth = dlgRect.right - dlgRect.left;
        int dlgHeight = dlgRect.bottom - dlgRect.top;
        int screenWidth = GetSystemMetrics(SM_CXSCREEN);
        int screenHeight = GetSystemMetrics(SM_CYSCREEN);
        int x = s_input_dialog_pos.x;
        int y = s_input_dialog_pos.y;
        if (x + dlgWidth > screenWidth) x = screenWidth - dlgWidth;
        if (y + dlgHeight > screenHeight) y = screenHeight - dlgHeight;
        if (x < 0) x = 0;
        if (y < 0) y = 0;
        SetWindowPos(hDlg, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
        
        SetFocus(GetDlgItem(hDlg, 101));
        return FALSE;  // Don't set default focus
    }
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK) {
            GetDlgItemTextW(hDlg, 101, s_input_dialog_buffer, 256);
            EndDialog(hDlg, IDOK);
            return TRUE;
        } else if (LOWORD(wParam) == IDCANCEL) {
            EndDialog(hDlg, IDCANCEL);
            return TRUE;
        }
        break;
    case WM_CLOSE:
        EndDialog(hDlg, IDCANCEL);
        return TRUE;
    }
    return FALSE;
}

// Show input dialog at cursor position
// Returns true if OK was pressed, false if cancelled
// Result is stored in out_result
static bool show_input_dialog(HWND hwndParent, const wchar_t* title, const wchar_t* prompt,
                              const wchar_t* initial_value, pfc::string8& out_result) {
    // Copy initial value to buffer and get cursor position
    wcsncpy_s(s_input_dialog_buffer, initial_value, 255);
    GetCursorPos(&s_input_dialog_pos);

    // Calculate required buffer size for the dialog template to avoid overflow.
    // Each string is stored as wchar_t (2 bytes per character) including null terminator.
    const wchar_t* ok_text = L"OK";
    const wchar_t* cancel_text = L"Cancel";
    const wchar_t* font = L"MS Shell Dlg";
    size_t title_len = wcslen(title) + 1;
    size_t font_len = wcslen(font) + 1;
    size_t prompt_len = wcslen(prompt) + 1;
    size_t ok_len = wcslen(ok_text) + 1;
    size_t cancel_len = wcslen(cancel_text) + 1;

    // Estimate total size: DLGTEMPLATE + menu/class + strings + 4 DLGITEMTEMPLATE + alignment padding
    size_t needed = sizeof(DLGTEMPLATE) + 4  // menu + class words
        + (title_len + font_len + prompt_len + ok_len + cancel_len) * sizeof(wchar_t)
        + 2  // font size word
        + 4 * (sizeof(DLGITEMTEMPLATE) + 6)  // 4 controls with class + creation data
        + 64;  // alignment padding headroom
    if (needed < 2048) needed = 2048;  // minimum safe size

    // Allocate on heap to handle any string length safely
    std::vector<BYTE> dlg_storage(needed, 0);
    BYTE* dlg_buffer = dlg_storage.data();

    DLGTEMPLATE* pTemplate = (DLGTEMPLATE*)dlg_buffer;
    pTemplate->style = DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU | DS_SETFONT;
    pTemplate->dwExtendedStyle = 0;
    pTemplate->cdit = 4;  // 4 controls: static, edit, OK, Cancel
    pTemplate->x = 0;
    pTemplate->y = 0;
    pTemplate->cx = 200;
    pTemplate->cy = 70;

    WORD* pWord = (WORD*)(pTemplate + 1);
    *pWord++ = 0;  // No menu
    *pWord++ = 0;  // Default window class

    // Title
    memcpy(pWord, title, title_len * sizeof(wchar_t));
    pWord += title_len;

    // Font (required with DS_SETFONT)
    *pWord++ = 8;  // Font size
    memcpy(pWord, font, font_len * sizeof(wchar_t));
    pWord += font_len;

    // Align to DWORD
    pWord = (WORD*)(((ULONG_PTR)pWord + 3) & ~3);

    // Static text control
    DLGITEMTEMPLATE* pItem = (DLGITEMTEMPLATE*)pWord;
    pItem->style = WS_VISIBLE | WS_CHILD | SS_LEFT;
    pItem->dwExtendedStyle = 0;
    pItem->x = 10; pItem->y = 10; pItem->cx = 180; pItem->cy = 10;
    pItem->id = 100;
    pWord = (WORD*)(pItem + 1);
    *pWord++ = 0xFFFF; *pWord++ = 0x0082;  // Static class
    memcpy(pWord, prompt, prompt_len * sizeof(wchar_t));
    pWord += prompt_len;
    *pWord++ = 0;  // No creation data
    pWord = (WORD*)(((ULONG_PTR)pWord + 3) & ~3);

    // Edit control
    pItem = (DLGITEMTEMPLATE*)pWord;
    pItem->style = WS_VISIBLE | WS_CHILD | WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL;
    pItem->dwExtendedStyle = 0;
    pItem->x = 10; pItem->y = 22; pItem->cx = 180; pItem->cy = 14;
    pItem->id = 101;
    pWord = (WORD*)(pItem + 1);
    *pWord++ = 0xFFFF; *pWord++ = 0x0081;  // Edit class
    *pWord++ = 0;  // No text
    *pWord++ = 0;  // No creation data
    pWord = (WORD*)(((ULONG_PTR)pWord + 3) & ~3);

    // OK button
    pItem = (DLGITEMTEMPLATE*)pWord;
    pItem->style = WS_VISIBLE | WS_CHILD | WS_TABSTOP | BS_DEFPUSHBUTTON;
    pItem->dwExtendedStyle = 0;
    pItem->x = 55; pItem->y = 45; pItem->cx = 40; pItem->cy = 14;
    pItem->id = IDOK;
    pWord = (WORD*)(pItem + 1);
    *pWord++ = 0xFFFF; *pWord++ = 0x0080;  // Button class
    memcpy(pWord, ok_text, ok_len * sizeof(wchar_t));
    pWord += ok_len;
    *pWord++ = 0;  // No creation data
    pWord = (WORD*)(((ULONG_PTR)pWord + 3) & ~3);

    // Cancel button
    pItem = (DLGITEMTEMPLATE*)pWord;
    pItem->style = WS_VISIBLE | WS_CHILD | WS_TABSTOP | BS_PUSHBUTTON;
    pItem->dwExtendedStyle = 0;
    pItem->x = 105; pItem->y = 45; pItem->cx = 40; pItem->cy = 14;
    pItem->id = IDCANCEL;
    pWord = (WORD*)(pItem + 1);
    *pWord++ = 0xFFFF; *pWord++ = 0x0080;  // Button class
    memcpy(pWord, cancel_text, cancel_len * sizeof(wchar_t));
    pWord += cancel_len;
    *pWord++ = 0;  // No creation data

    INT_PTR dlgResult = DialogBoxIndirectW(g_hInstance, pTemplate, hwndParent, InputDialogProc);

    if (dlgResult == IDOK && wcslen(s_input_dialog_buffer) > 0) {
        pfc::stringcvt::string_utf8_from_wide utf8_result(s_input_dialog_buffer);
        out_result = utf8_result.get_ptr();
        return true;
    }
    return false;
}


// Load profile settings into the cfg_ variables

static void load_profile_to_config(const CButtonProfile& profile) {
    cfg_cbutton1_enabled = profile.buttons[0].enabled ? 1 : 0;
    cfg_cbutton2_enabled = profile.buttons[1].enabled ? 1 : 0;
    cfg_cbutton3_enabled = profile.buttons[2].enabled ? 1 : 0;
    cfg_cbutton4_enabled = profile.buttons[3].enabled ? 1 : 0;
    cfg_cbutton5_enabled = profile.buttons[4].enabled ? 1 : 0;
    cfg_cbutton6_enabled = profile.buttons[5].enabled ? 1 : 0;
    
    cfg_cbutton1_action = profile.buttons[0].action;
    cfg_cbutton2_action = profile.buttons[1].action;
    cfg_cbutton3_action = profile.buttons[2].action;
    cfg_cbutton4_action = profile.buttons[3].action;
    cfg_cbutton5_action = profile.buttons[4].action;
    cfg_cbutton6_action = profile.buttons[5].action;
    
    cfg_cbutton1_path = profile.buttons[0].path;
    cfg_cbutton2_path = profile.buttons[1].path;
    cfg_cbutton3_path = profile.buttons[2].path;
    cfg_cbutton4_path = profile.buttons[3].path;
    cfg_cbutton5_path = profile.buttons[4].path;
    cfg_cbutton6_path = profile.buttons[5].path;
    
    cfg_cbutton1_icon = profile.buttons[0].icon;
    cfg_cbutton2_icon = profile.buttons[1].icon;
    cfg_cbutton3_icon = profile.buttons[2].icon;
    cfg_cbutton4_icon = profile.buttons[3].icon;
    cfg_cbutton5_icon = profile.buttons[4].icon;
    cfg_cbutton6_icon = profile.buttons[5].icon;

    cfg_cbutton1_font = profile.buttons[0].font.is_empty() ? pfc::string8("Segoe UI") : profile.buttons[0].font;
    cfg_cbutton2_font = profile.buttons[1].font.is_empty() ? pfc::string8("Segoe UI") : profile.buttons[1].font;
    cfg_cbutton3_font = profile.buttons[2].font.is_empty() ? pfc::string8("Segoe UI") : profile.buttons[2].font;
    cfg_cbutton4_font = profile.buttons[3].font.is_empty() ? pfc::string8("Segoe UI") : profile.buttons[3].font;
    cfg_cbutton5_font = profile.buttons[4].font.is_empty() ? pfc::string8("Segoe UI") : profile.buttons[4].font;
    cfg_cbutton6_font = profile.buttons[5].font.is_empty() ? pfc::string8("Segoe UI") : profile.buttons[5].font;

    cfg_cbutton1_glyph_size = profile.buttons[0].glyph_size > 0 ? profile.buttons[0].glyph_size : 80;
    cfg_cbutton2_glyph_size = profile.buttons[1].glyph_size > 0 ? profile.buttons[1].glyph_size : 80;
    cfg_cbutton3_glyph_size = profile.buttons[2].glyph_size > 0 ? profile.buttons[2].glyph_size : 80;
    cfg_cbutton4_glyph_size = profile.buttons[3].glyph_size > 0 ? profile.buttons[3].glyph_size : 80;
    cfg_cbutton5_glyph_size = profile.buttons[4].glyph_size > 0 ? profile.buttons[4].glyph_size : 80;
    cfg_cbutton6_glyph_size = profile.buttons[5].glyph_size > 0 ? profile.buttons[5].glyph_size : 80;

    cfg_cbutton1_label = profile.buttons[0].label;
    cfg_cbutton2_label = profile.buttons[1].label;
    cfg_cbutton3_label = profile.buttons[2].label;
    cfg_cbutton4_label = profile.buttons[3].label;
    cfg_cbutton5_label = profile.buttons[4].label;
    cfg_cbutton6_label = profile.buttons[5].label;
}

// Save current config to a profile
static void save_config_to_profile(CButtonProfile& profile) {
    profile.buttons[0].enabled = cfg_cbutton1_enabled != 0;
    profile.buttons[1].enabled = cfg_cbutton2_enabled != 0;
    profile.buttons[2].enabled = cfg_cbutton3_enabled != 0;
    profile.buttons[3].enabled = cfg_cbutton4_enabled != 0;
    profile.buttons[4].enabled = cfg_cbutton5_enabled != 0;
    profile.buttons[5].enabled = cfg_cbutton6_enabled != 0;
    
    profile.buttons[0].action = cfg_cbutton1_action;
    profile.buttons[1].action = cfg_cbutton2_action;
    profile.buttons[2].action = cfg_cbutton3_action;
    profile.buttons[3].action = cfg_cbutton4_action;
    profile.buttons[4].action = cfg_cbutton5_action;
    profile.buttons[5].action = cfg_cbutton6_action;
    
    profile.buttons[0].path = cfg_cbutton1_path.get();
    profile.buttons[1].path = cfg_cbutton2_path.get();
    profile.buttons[2].path = cfg_cbutton3_path.get();
    profile.buttons[3].path = cfg_cbutton4_path.get();
    profile.buttons[4].path = cfg_cbutton5_path.get();
    profile.buttons[5].path = cfg_cbutton6_path.get();
    
    profile.buttons[0].icon = cfg_cbutton1_icon.get();
    profile.buttons[1].icon = cfg_cbutton2_icon.get();
    profile.buttons[2].icon = cfg_cbutton3_icon.get();
    profile.buttons[3].icon = cfg_cbutton4_icon.get();
    profile.buttons[4].icon = cfg_cbutton5_icon.get();
    profile.buttons[5].icon = cfg_cbutton6_icon.get();

    profile.buttons[0].font = cfg_cbutton1_font.get();
    profile.buttons[1].font = cfg_cbutton2_font.get();
    profile.buttons[2].font = cfg_cbutton3_font.get();
    profile.buttons[3].font = cfg_cbutton4_font.get();
    profile.buttons[4].font = cfg_cbutton5_font.get();
    profile.buttons[5].font = cfg_cbutton6_font.get();

    profile.buttons[0].glyph_size = cfg_cbutton1_glyph_size;
    profile.buttons[1].glyph_size = cfg_cbutton2_glyph_size;
    profile.buttons[2].glyph_size = cfg_cbutton3_glyph_size;
    profile.buttons[3].glyph_size = cfg_cbutton4_glyph_size;
    profile.buttons[4].glyph_size = cfg_cbutton5_glyph_size;
    profile.buttons[5].glyph_size = cfg_cbutton6_glyph_size;

    profile.buttons[0].label = cfg_cbutton1_label.get();
    profile.buttons[1].label = cfg_cbutton2_label.get();
    profile.buttons[2].label = cfg_cbutton3_label.get();
    profile.buttons[3].label = cfg_cbutton4_label.get();
    profile.buttons[4].label = cfg_cbutton5_label.get();
    profile.buttons[5].label = cfg_cbutton6_label.get();
}

// Export a profile to a file
static bool export_profile_to_file(const CButtonProfile& profile, const wchar_t* filepath) {
    std::ofstream file(filepath, std::ios::out | std::ios::binary);
    if (!file.is_open()) return false;
    
    pfc::string8 json;
    json << "{\n  \"name\": \"" << escape_json_string(profile.name.c_str()) << "\",\n";
    json << "  \"version\": 1,\n";
    json << "  \"buttons\": [\n";
    for (int i = 0; i < 6; i++) {
        json << "    {\n";
        json << "      \"enabled\": " << (profile.buttons[i].enabled ? "true" : "false") << ",\n";
        json << "      \"action\": " << profile.buttons[i].action << ",\n";
        json << "      \"path\": \"" << escape_json_string(profile.buttons[i].path.c_str()) << "\",\n";
        json << "      \"icon\": \"" << escape_json_string(profile.buttons[i].icon.c_str()) << "\",\n";
        json << "      \"font\": \"" << escape_json_string(profile.buttons[i].font.c_str()) << "\",\n";
        json << "      \"glyph_size\": " << profile.buttons[i].glyph_size << ",\n";
        json << "      \"label\": \"" << escape_json_string(profile.buttons[i].label.c_str()) << "\"\n";
        json << "    }" << (i < 5 ? "," : "") << "\n";
    }
    json << "  ]\n}\n";
    
    file.write(json.c_str(), json.length());
    file.close();
    return true;
}

// Import a profile from a file
static bool import_profile_from_file(const wchar_t* filepath, CButtonProfile& profile) {
    std::ifstream file(filepath, std::ios::in | std::ios::binary);
    if (!file.is_open()) return false;
    
    std::stringstream buffer;
    buffer << file.rdbuf();
    file.close();
    
    std::string content = buffer.str();
    parse_profile(content.c_str(), profile);
    
    return !profile.name.is_empty();
}

// Configuration accessors

int get_nowbar_theme_mode() {
    int mode = cfg_nowbar_theme_mode;
    if (mode < 0) mode = 0;
    if (mode > 3) mode = 3;  // 0=Auto, 1=Dark, 2=Light, 3=Custom
    return mode;
}

bool get_nowbar_cover_margin() {
    return cfg_nowbar_cover_margin != 0;
}

int get_nowbar_cover_style() {
    int v = cfg_nowbar_cover_style;
    return (v >= 0 && v <= 1) ? v : 1;  // Clamp to valid range; default Rounded
}

bool get_nowbar_cover_artwork_visible() {
    return cfg_nowbar_cover_artwork_visible != 0;
}

bool get_nowbar_online_artwork() {
    return cfg_nowbar_online_artwork != 0;
}

int get_nowbar_bar_style() {
    int style = cfg_nowbar_bar_style;
    if (style < 0) style = 0;
    if (style > 1) style = 1;
    return style;
}

bool get_nowbar_seekbar_visible() {
    return cfg_nowbar_seekbar_visible != 0;
}

int get_nowbar_seekbar_length() {
    int len = cfg_nowbar_seekbar_length;
    if (len < 0) len = 0;
    if (len > 1) len = 1;
    return len;
}

int get_nowbar_seekbar_position() {
    int pos = cfg_nowbar_seekbar_position;
    if (pos < -100) pos = -100;
    if (pos > 100) pos = 100;
    return pos;
}

static int s_preview_button_scaling_enabled = -1;  // -1 = no preview
static int s_preview_button_scaling_percent = -1;  // -1 = no preview

bool get_nowbar_button_scaling_enabled() {
    if (s_preview_button_scaling_enabled >= 0) {
        return s_preview_button_scaling_enabled != 0;
    }
    return cfg_nowbar_button_scaling_enabled != 0;
}

int get_nowbar_button_scaling_percent() {
    int val = (s_preview_button_scaling_percent >= 0)
        ? s_preview_button_scaling_percent
        : static_cast<int>(cfg_nowbar_button_scaling_percent);
    if (val < 50) val = 50;
    if (val > 100) val = 100;
    return val;
}

void set_nowbar_button_scaling_enabled(bool enabled) {
    cfg_nowbar_button_scaling_enabled = enabled ? 1 : 0;
}

void set_nowbar_button_scaling_percent(int percent) {
    if (percent < 50) percent = 50;
    if (percent > 100) percent = 100;
    cfg_nowbar_button_scaling_percent = percent;
}

static void set_nowbar_button_scaling_preview(bool enabled, int percent) {
    s_preview_button_scaling_enabled = enabled ? 1 : 0;
    s_preview_button_scaling_percent = percent;
    nowbar::ControlPanelCore::notify_all_settings_changed();
}

static void clear_nowbar_button_scaling_preview() {
    s_preview_button_scaling_enabled = -1;
    s_preview_button_scaling_percent = -1;
}

bool get_nowbar_mood_icon_visible() {
    return cfg_nowbar_mood_icon_visible != 0;
}

bool get_nowbar_shuffle_icon_visible() {
    return cfg_nowbar_shuffle_icon_visible != 0;
}

bool get_nowbar_repeat_icon_visible() {
    return cfg_nowbar_repeat_icon_visible != 0;
}

bool get_nowbar_rating_visible() {
    return cfg_nowbar_rating_visible != 0;
}

int get_nowbar_rating_mode() {
    return cfg_nowbar_rating_visible;  // 0=Hidden, 1=Show, 2=Line 3
}

int get_nowbar_mood_tag_mode() {
    return cfg_nowbar_mood_tag_mode;
}

bool get_nowbar_stop_icon_visible() {
    return cfg_nowbar_stop_icon_visible != 0;
}

bool get_nowbar_stop_after_current_icon_visible() {
    return cfg_nowbar_stop_after_current_icon_visible != 0;
}

bool get_nowbar_super_icon_visible() {
    return cfg_nowbar_super_icon_visible != 0;
}

bool get_nowbar_miniplayer_icon_visible() {
    return cfg_nowbar_miniplayer_icon_visible != 0;
}

bool get_nowbar_hover_circles_enabled() {
    return cfg_nowbar_hover_circles != 0;
}

int get_nowbar_alternate_icons_style() {
    int style = cfg_nowbar_alternate_icons;
    if (style < 0) style = 0;
    if (style > 2) style = 2;
    return style;  // 0=Style 1, 1=Style 2, 2=Style 3
}

int get_nowbar_play_icon_style() {
    int style = cfg_nowbar_play_icon_style;
    if (style < 0) style = 0;
    if (style > 1) style = 1;
    return style;  // 0=Normal, 1=Inverted
}

bool get_nowbar_cbutton_autohide() {
    return cfg_nowbar_cbutton_autohide != 0;
}

bool get_nowbar_3d_buttons_enabled() {
    return cfg_nowbar_3d_buttons != 0;
}

bool get_nowbar_volume_icon_visible() {
    return cfg_nowbar_volume_icon_visible != 0;
}

bool get_nowbar_volume_bar_visible() {
    return cfg_nowbar_volume_bar_visible != 0;
}

bool get_nowbar_volume_number_enabled() {
    return cfg_nowbar_volume_number != 0;
}

bool get_nowbar_playback_time_visible() {
    return cfg_nowbar_playback_time_visible != 0;
}


bool get_nowbar_infinite_playback_enabled() {
    return cfg_nowbar_infinite_playback != 0;
}

void set_nowbar_infinite_playback_enabled(bool enabled) {
    cfg_nowbar_infinite_playback = enabled ? 1 : 0;
}

int get_nowbar_preview_mode() {
    int mode = cfg_nowbar_preview_mode;
    if (mode < 0) mode = 0;
    if (mode > 3) mode = 3;  // 0=Off, 1=35%, 2=50%, 3=60sec
    return mode;
}

void set_nowbar_preview_mode(int mode) {
    if (mode < 0) mode = 0;
    if (mode > 3) mode = 3;
    cfg_nowbar_preview_mode = mode;
}

bool get_nowbar_skip_low_rating_enabled() {
    return cfg_nowbar_skip_low_rating_enabled != 0;
}

void set_nowbar_skip_low_rating_enabled(bool enabled) {
    cfg_nowbar_skip_low_rating_enabled = enabled ? 1 : 0;
}

void set_nowbar_skip_low_rating_threshold(int threshold) {
    if (threshold < 1) threshold = 1;
    if (threshold > 3) threshold = 3;
    cfg_nowbar_skip_low_rating_threshold = threshold;
}

int get_nowbar_selection_mode() {
    int mode = cfg_nowbar_selection_mode;
    if (mode < 0) mode = 0;
    if (mode > 1) mode = 1;  // 0=Prioritize Now Playing Mode, 1=Follow Selection
    return mode;
}

void set_nowbar_selection_mode(int mode) {
    if (mode < 0) mode = 0;
    if (mode > 1) mode = 1;
    cfg_nowbar_selection_mode = mode;
}

int get_nowbar_visualization_mode() {
    int mode = cfg_nowbar_visualization_mode;
    if (mode < 0) mode = 0;
    if (mode > 2) mode = 2;
    return mode;
}

bool get_nowbar_spectrum_visible() {
    return get_nowbar_visualization_mode() == 1;
}

COLORREF get_nowbar_spectrum_color() {
    return static_cast<COLORREF>(cfg_nowbar_spectrum_color.get_value());
}

int get_nowbar_spectrum_width() {
    int w = cfg_nowbar_spectrum_width;
    if (w < 0) w = 0;
    if (w > 2) w = 2;
    return w;
}

int get_nowbar_spectrum_style() {
    int s = cfg_nowbar_spectrum_style;
    if (s < 0) s = 0;
    if (s > 2) s = 2;  // 0=Mono, 1=Curve, 2=Dominoes
    return s;
}

int get_nowbar_spectrum_height() {
    int h = cfg_nowbar_spectrum_height;
    if (h < 0) h = 0;
    if (h > 2) h = 2;  // 0=Low, 1=Normal, 2=High
    return h;
}

int get_nowbar_spectrum_opacity() {
    int o = cfg_nowbar_spectrum_opacity;
    if (o < 0) o = 0;
    if (o > 100) o = 100;
    return o;
}

int get_nowbar_spectrum_gradient_mode() {
    int m = cfg_nowbar_spectrum_gradient_mode;
    if (m < 0) m = 0;
    if (m > 3) m = 3;
    return m;
}

COLORREF get_nowbar_spectrum_color2() {
    return static_cast<COLORREF>(cfg_nowbar_spectrum_color2.get_value());
}

bool get_nowbar_vis_60fps() {
    return cfg_nowbar_vis_60fps != 0;
}

COLORREF get_nowbar_waveform_color() {
    return static_cast<COLORREF>(cfg_nowbar_waveform_color.get_value());
}

COLORREF get_nowbar_waveform_unplayed_color() {
    return static_cast<COLORREF>(cfg_nowbar_waveform_unplayed_color.get_value());
}

int get_nowbar_waveform_width() {
    int w = cfg_nowbar_waveform_width;
    if (w < 0) w = 0;
    if (w > 2) w = 2;
    return w;
}

int get_nowbar_waveform_style() {
    int s = cfg_nowbar_waveform_style;
    if (s < 0) s = 0;
    if (s > 1) s = 1;
    return s;
}

int get_nowbar_skip_low_rating_threshold() {
    int threshold = cfg_nowbar_skip_low_rating_threshold;
    if (threshold < 1) threshold = 1;
    if (threshold > 3) threshold = 3;  // 1, 2, or 3
    return threshold;
}

int get_nowbar_background_style() {
    int style = cfg_nowbar_background_style;
    if (style < 0) style = 0;
    if (style > 2) style = 2;  // 0=Solid, 1=Artwork Colors, 2=Blurred Artwork
    return style;
}

bool get_nowbar_smooth_animations_enabled() {
    return cfg_nowbar_smooth_animations != 0;
}

COLORREF get_nowbar_button_accent_color() {
    return static_cast<COLORREF>(cfg_nowbar_button_accent_color.get_value());
}

COLORREF get_nowbar_progress_accent_color() {
    return static_cast<COLORREF>(cfg_nowbar_progress_accent_color.get_value());
}

COLORREF get_nowbar_volume_accent_color() {
    return static_cast<COLORREF>(cfg_nowbar_volume_accent_color.get_value());
}

COLORREF get_nowbar_play_accent_color() {
    return static_cast<COLORREF>(cfg_nowbar_play_accent_color.get_value());
}

COLORREF get_nowbar_hover_color() {
    return static_cast<COLORREF>(cfg_nowbar_hover_color.get_value());
}

bool get_nowbar_custom_button_accent_enabled() {
    return cfg_custom_button_accent_enabled != 0;
}
bool get_nowbar_custom_play_accent_enabled() {
    return cfg_custom_play_accent_enabled != 0;
}
bool get_nowbar_custom_progress_accent_enabled() {
    return cfg_custom_progress_accent_enabled != 0;
}
bool get_nowbar_custom_volume_accent_enabled() {
    return cfg_custom_volume_accent_enabled != 0;
}
bool get_nowbar_custom_hover_color_enabled() {
    return cfg_custom_hover_color_enabled != 0;
}
bool get_nowbar_custom_spectrum_color_enabled() {
    return cfg_custom_spectrum_color_enabled != 0;
}
bool get_nowbar_custom_waveform_color_enabled() {
    return cfg_custom_waveform_color_enabled != 0;
}
bool get_nowbar_custom_waveform_unplayed_enabled() {
    return cfg_custom_waveform_unplayed_enabled != 0;
}
COLORREF get_nowbar_progress_track_color() {
    return static_cast<COLORREF>(cfg_nowbar_progress_track_color.get_value());
}
bool get_nowbar_custom_progress_track_enabled() {
    return cfg_custom_progress_track_enabled != 0;
}
COLORREF get_nowbar_volume_track_color() {
    return static_cast<COLORREF>(cfg_nowbar_volume_track_color.get_value());
}
bool get_nowbar_custom_volume_track_enabled() {
    return cfg_custom_volume_track_enabled != 0;
}

bool get_nowbar_custom_button_visible() {
    return cfg_nowbar_custom_button_visible != 0;
}

int get_nowbar_custom_button_action() {
    int action = cfg_nowbar_custom_button_action;
    if (action < 0) action = 0;
    if (action > 5) action = 5;  // 0=None, 1=Open URL, 2=Run Executable, 3=Foobar2k Action, 4=Open Folder, 5=Output Device
    return action;
}

pfc::string8 get_nowbar_custom_button_url() {
    return cfg_nowbar_custom_button_url.get();
}

pfc::string8 get_nowbar_custom_button_executable() {
    return cfg_nowbar_custom_button_executable.get();
}

pfc::string8 get_nowbar_custom_button_fb2k_action() {
    return cfg_nowbar_custom_button_fb2k_action.get();
}

bool get_nowbar_cbutton_enabled(int button_index) {
    switch (button_index) {
        case 0: return cfg_cbutton1_enabled != 0;
        case 1: return cfg_cbutton2_enabled != 0;
        case 2: return cfg_cbutton3_enabled != 0;
        case 3: return cfg_cbutton4_enabled != 0;
        case 4: return cfg_cbutton5_enabled != 0;
        case 5: return cfg_cbutton6_enabled != 0;
        default: return false;
    }
}

int get_nowbar_cbutton_action(int button_index) {
    int action = 0;
    switch (button_index) {
        case 0: action = cfg_cbutton1_action; break;
        case 1: action = cfg_cbutton2_action; break;
        case 2: action = cfg_cbutton3_action; break;
        case 3: action = cfg_cbutton4_action; break;
        case 4: action = cfg_cbutton5_action; break;
        case 5: action = cfg_cbutton6_action; break;
    }
    if (action < 0) action = 0;
    if (action > 5) action = 5;
    return action;
}

pfc::string8 get_nowbar_cbutton_path(int button_index) {
    switch (button_index) {
        case 0: return cfg_cbutton1_path.get();
        case 1: return cfg_cbutton2_path.get();
        case 2: return cfg_cbutton3_path.get();
        case 3: return cfg_cbutton4_path.get();
        case 4: return cfg_cbutton5_path.get();
        case 5: return cfg_cbutton6_path.get();
        default: return pfc::string8();
    }
}

pfc::string8 get_nowbar_cbutton_icon_path(int button_index) {
    switch (button_index) {
        case 0: return cfg_cbutton1_icon.get();
        case 1: return cfg_cbutton2_icon.get();
        case 2: return cfg_cbutton3_icon.get();
        case 3: return cfg_cbutton4_icon.get();
        case 4: return cfg_cbutton5_icon.get();
        case 5: return cfg_cbutton6_icon.get();
        default: return pfc::string8();
    }
}

int get_nowbar_cbutton_glyph_size(int button_index) {
    switch (button_index) {
        case 0: return cfg_cbutton1_glyph_size;
        case 1: return cfg_cbutton2_glyph_size;
        case 2: return cfg_cbutton3_glyph_size;
        case 3: return cfg_cbutton4_glyph_size;
        case 4: return cfg_cbutton5_glyph_size;
        case 5: return cfg_cbutton6_glyph_size;
        default: return 80;
    }
}

pfc::string8 get_nowbar_cbutton_font(int button_index) {
    switch (button_index) {
        case 0: return cfg_cbutton1_font.get();
        case 1: return cfg_cbutton2_font.get();
        case 2: return cfg_cbutton3_font.get();
        case 3: return cfg_cbutton4_font.get();
        case 4: return cfg_cbutton5_font.get();
        case 5: return cfg_cbutton6_font.get();
        default: return "Segoe UI";
    }
}

pfc::string8 get_nowbar_cbutton_label(int button_index) {
    pfc::string8 label;
    switch (button_index) {
        case 0: label = cfg_cbutton1_label.get(); break;
        case 1: label = cfg_cbutton2_label.get(); break;
        case 2: label = cfg_cbutton3_label.get(); break;
        case 3: label = cfg_cbutton4_label.get(); break;
        case 4: label = cfg_cbutton5_label.get(); break;
        case 5: label = cfg_cbutton6_label.get(); break;
    }
    // Return default "Button #N" if label is empty
    if (label.is_empty()) {
        label << "Button #" << (button_index + 1);
    }
    return label;
}

// Config file accessor functions for all 12 buttons
int get_config_button_action(int button_index) {
    const auto& cfg = get_config_button(button_index);
    return cfg.action;
}

pfc::string8 get_config_button_path(int button_index) {
    const auto& cfg = get_config_button(button_index);
    return cfg.path;
}

pfc::string8 get_config_button_label(int button_index) {
    const auto& cfg = get_config_button(button_index);
    if (cfg.label.is_empty()) {
        pfc::string8 default_label;
        default_label << "Custom Button " << (button_index + 1);
        return default_label;
    }
    return cfg.label;
}

void reload_custom_button_config() {
    reload_config_file();
}

pfc::string8 get_nowbar_line1_format() {
    return cfg_nowbar_line1_format.get();
}

pfc::string8 get_nowbar_line2_format() {
    return cfg_nowbar_line2_format.get();
}

pfc::string8 get_nowbar_line3_format() {
    return cfg_nowbar_line3_format.get();
}

// Execute a foobar2000 main menu command by path (e.g., "Playback/Matrix Now Playing/Announce current track to Matrix")
bool execute_fb2k_action_by_path(const char* path) {
    if (!path || !*path) return false;

    pfc::string8 target_path(path);

    // Enumerate all main menu commands and find one matching the path
    service_enum_t<mainmenu_commands> enumerator;
    service_ptr_t<mainmenu_commands> commands;

    while (enumerator.next(commands)) {
        service_ptr_t<mainmenu_commands_v2> commands_v2;
        commands->service_query_t(commands_v2);

        const auto command_count = commands->get_command_count();
        for (uint32_t command_index = 0; command_index < command_count; command_index++) {
            GUID command_id = commands->get_command(command_index);

            // Build the full path for this command
            pfc::string8 command_name;
            commands->get_name(command_index, command_name);

            // Get parent group names
            std::list<pfc::string8> name_parts;
            name_parts.push_back(command_name);

            GUID parent_id = commands->get_parent();
            while (parent_id != pfc::guid_null) {
                service_enum_t<mainmenu_group> group_enum;
                service_ptr_t<mainmenu_group> group;
                bool found = false;

                while (group_enum.next(group)) {
                    if (group->get_guid() == parent_id) {
                        service_ptr_t<mainmenu_group_popup> popup;
                        if (group->service_query_t(popup)) {
                            pfc::string8 group_name;
                            popup->get_display_string(group_name);
                            name_parts.push_front(group_name);
                        }
                        parent_id = group->get_parent();
                        found = true;
                        break;
                    }
                }
                if (!found) break;
            }

            // Build full path string
            pfc::string8 full_path;
            bool first = true;
            for (const auto& part : name_parts) {
                if (!first) full_path << "/";
                full_path << part;
                first = false;
            }

            // Check for match (case-insensitive)
            if (stricmp_utf8(full_path.c_str(), target_path.c_str()) == 0) {
                mainmenu_commands::g_execute(command_id);
                return true;
            }

            // For dynamic commands, check sub-items
            if (commands_v2.is_valid() && commands_v2->is_command_dynamic(command_index)) {
                mainmenu_node::ptr node = commands_v2->dynamic_instantiate(command_index);

                // Recursive lambda to search dynamic nodes
                std::function<bool(const mainmenu_node::ptr&, std::list<pfc::string8>)> search_node;
                search_node = [&](const mainmenu_node::ptr& n, std::list<pfc::string8> parts) -> bool {
                    if (!n.is_valid()) return false;

                    pfc::string8 display_name;
                    uint32_t flags;
                    n->get_display(display_name, flags);

                    switch (n->get_type()) {
                    case mainmenu_node::type_command: {
                        parts.push_back(display_name);

                        pfc::string8 node_path;
                        bool first_part = true;
                        for (const auto& p : parts) {
                            if (!first_part) node_path << "/";
                            node_path << p;
                            first_part = false;
                        }

                        if (stricmp_utf8(node_path.c_str(), target_path.c_str()) == 0) {
                            mainmenu_commands::g_execute_dynamic(command_id, n->get_guid());
                            return true;
                        }
                        return false;
                    }
                    case mainmenu_node::type_group: {
                        if (!display_name.is_empty()) {
                            parts.push_back(display_name);
                        }

                        for (size_t i = 0, count = n->get_children_count(); i < count; i++) {
                            if (search_node(n->get_child(i), parts)) {
                                return true;
                            }
                        }
                        return false;
                    }
                    default:
                        return false;
                    }
                };

                // Start search from root with parent path
                std::list<pfc::string8> base_parts;
                for (const auto& p : name_parts) {
                    if (&p != &name_parts.back()) {  // Exclude the command name itself
                        base_parts.push_back(p);
                    }
                }
                if (search_node(node, base_parts)) {
                    return true;
                }
            }
        }
    }

    // Main menu command not found - try context menu commands
    // Get selected tracks from the active playlist
    auto pm = playlist_manager::get();
    metadb_handle_list tracks;
    
    t_size active_playlist = pm->get_active_playlist();
    if (active_playlist != pfc_infinite) {
        // Get all selected items, or just the focused item if nothing selected
        bit_array_bittable selection(pm->playlist_get_item_count(active_playlist));
        pm->playlist_get_selection_mask(active_playlist, selection);
        
        bool has_selection = false;
        for (t_size i = 0; i < pm->playlist_get_item_count(active_playlist); i++) {
            if (selection.get(i)) {
                has_selection = true;
                break;
            }
        }
        
        if (has_selection) {
            pm->playlist_get_selected_items(active_playlist, tracks);
        } else {
            // No selection - use focused item
            t_size focus = pm->playlist_get_focus_item(active_playlist);
            if (focus != pfc_infinite) {
                metadb_handle_ptr track;
                if (pm->playlist_get_item_handle(track, active_playlist, focus)) {
                    tracks.add_item(track);
                }
            }
        }
    }
    
    if (tracks.get_count() == 0) {
        return false;  // No tracks to operate on
    }
    
    // Create context menu manager and search for the command
    contextmenu_manager::ptr cm;
    contextmenu_manager::g_create(cm);
    cm->init_context(tracks, 0);
    
    // Recursive function to search context menu nodes
    std::function<bool(contextmenu_node*, pfc::string8)> search_context_node;
    search_context_node = [&](contextmenu_node* node, pfc::string8 parent_path) -> bool {
        if (!node) return false;
        
        t_size child_count = node->get_num_children();
        for (t_size i = 0; i < child_count; i++) {
            contextmenu_node* child = node->get_child(i);
            if (!child) continue;
            
            // Get node name
            const char* child_name = child->get_name();
            if (!child_name) continue;
            
            // Skip separators
            if (child->get_type() == contextmenu_item_node::type_separator) continue;
            
            // Build full path for this node
            pfc::string8 full_path;
            if (!parent_path.is_empty()) {
                full_path << parent_path << "/";
            }
            full_path << child_name;
            
            if (child->get_type() == contextmenu_item_node::type_command) {
                // Check if this matches our target path
                if (stricmp_utf8(full_path.c_str(), target_path.c_str()) == 0) {
                    child->execute();
                    return true;
                }
            } else if (child->get_type() == contextmenu_item_node::type_group) {
                // Recurse into submenu
                if (search_context_node(child, full_path)) {
                    return true;
                }
            }
        }
        return false;
    };
    
    // Start search from root
    contextmenu_node* root = cm->get_root();
    if (root && search_context_node(root, "")) {
        return true;
    }
    
    return false;
}

// Query the state of a foobar2000 menu command without executing it
// Returns checked/disabled flags for toggle-type commands
CommandState get_fb2k_action_state_by_path(const char* path, bool skip_context_menu) {
    CommandState result;
    if (!path || !*path) return result;

    pfc::string8 target_path(path);

    // Search main menu commands (same traversal logic as execute_fb2k_action_by_path)
    service_enum_t<mainmenu_commands> enumerator;
    service_ptr_t<mainmenu_commands> commands;

    while (enumerator.next(commands)) {
        service_ptr_t<mainmenu_commands_v2> commands_v2;
        commands->service_query_t(commands_v2);

        const auto command_count = commands->get_command_count();
        for (uint32_t command_index = 0; command_index < command_count; command_index++) {
            // Build the full path for this command
            pfc::string8 command_name;
            commands->get_name(command_index, command_name);

            // Get parent group names
            std::list<pfc::string8> name_parts;
            name_parts.push_back(command_name);

            GUID parent_id = commands->get_parent();
            while (parent_id != pfc::guid_null) {
                service_enum_t<mainmenu_group> group_enum;
                service_ptr_t<mainmenu_group> group;
                bool found = false;

                while (group_enum.next(group)) {
                    if (group->get_guid() == parent_id) {
                        service_ptr_t<mainmenu_group_popup> popup;
                        if (group->service_query_t(popup)) {
                            pfc::string8 group_name;
                            popup->get_display_string(group_name);
                            name_parts.push_front(group_name);
                        }
                        parent_id = group->get_parent();
                        found = true;
                        break;
                    }
                }
                if (!found) break;
            }

            // Build full path string
            pfc::string8 full_path;
            bool first = true;
            for (const auto& part : name_parts) {
                if (!first) full_path << "/";
                full_path << part;
                first = false;
            }

            // Check for match (case-insensitive)
            if (stricmp_utf8(full_path.c_str(), target_path.c_str()) == 0) {
                result.found = true;

                // Query display state for flags
                pfc::string8 display_text;
                t_uint32 flags = 0;
                commands->get_display(command_index, display_text, flags);

                result.checked = (flags & mainmenu_commands::flag_checked) != 0;
                result.disabled = (flags & mainmenu_commands::flag_disabled) != 0;

                // Cache the reference for fast polling
                result.cache_valid = true;
                result.is_context_menu = false;
                result.is_dynamic = false;
                result.cached_service = commands;
                result.cached_command_index = command_index;
                return result;
            }

            // For dynamic commands, check sub-items — but only if the parent
            // path could be a prefix of the target. This avoids calling
            // dynamic_instantiate() on unrelated components (e.g. ESLyric),
            // which can crash if the component isn't thread-safe.
            if (commands_v2.is_valid() && commands_v2->is_command_dynamic(command_index)) {
                // Build parent path (groups above this command, excluding command name)
                pfc::string8 parent_prefix;
                {
                    bool first_pp = true;
                    for (const auto& p : name_parts) {
                        if (&p != &name_parts.back()) {
                            if (!first_pp) parent_prefix << "/";
                            parent_prefix << p;
                            first_pp = false;
                        }
                    }
                }
                // Skip if target can't be under this parent
                if (!parent_prefix.is_empty()) {
                    bool is_prefix = (target_path.length() > parent_prefix.length() &&
                        _strnicmp(target_path.c_str(), parent_prefix.c_str(), parent_prefix.length()) == 0 &&
                        target_path.c_str()[parent_prefix.length()] == '/');
                    if (!is_prefix) continue;
                }

                mainmenu_node::ptr node = commands_v2->dynamic_instantiate(command_index);

                // Build base path (static menu groups above the dynamic command,
                // excluding the command name itself) before the lambda so it can
                // be captured by reference.
                std::list<pfc::string8> base_parts;
                pfc::string8 base_path_str;
                {
                    bool first_bp = true;
                    for (const auto& p : name_parts) {
                        if (&p != &name_parts.back()) {
                            base_parts.push_back(p);
                            if (!first_bp) base_path_str << "/";
                            base_path_str << p;
                            first_bp = false;
                        }
                    }
                }

                // Recursive lambda to search dynamic nodes
                std::function<bool(const mainmenu_node::ptr&, std::list<pfc::string8>)> search_node;
                search_node = [&](const mainmenu_node::ptr& n, std::list<pfc::string8> parts) -> bool {
                    if (!n.is_valid()) return false;

                    pfc::string8 display_name;
                    uint32_t node_flags;
                    n->get_display(display_name, node_flags);

                    switch (n->get_type()) {
                    case mainmenu_node::type_command: {
                        parts.push_back(display_name);

                        pfc::string8 node_path;
                        bool first_part = true;
                        for (const auto& p : parts) {
                            if (!first_part) node_path << "/";
                            node_path << p;
                            first_part = false;
                        }

                        if (stricmp_utf8(node_path.c_str(), target_path.c_str()) == 0) {
                            result.found = true;
                            result.checked = (node_flags & mainmenu_commands::flag_checked) != 0;
                            result.disabled = (node_flags & mainmenu_commands::flag_disabled) != 0;

                            // Cache for fast polling — store service + index + base path.
                            // base_path_str contains only the static menu groups above the
                            // dynamic command entry.  poll_fb2k_action_state() re-traverses
                            // the dynamic tree from its root, so the base path must NOT
                            // include path segments added by the tree itself.
                            result.cache_valid = true;
                            result.is_context_menu = false;
                            result.is_dynamic = true;
                            result.cached_service = commands;
                            result.cached_command_index = command_index;
                            result.cached_dynamic_subpath = target_path;
                            result.cached_dynamic_basepath = base_path_str;
                            return true;
                        }
                        return false;
                    }
                    case mainmenu_node::type_group: {
                        if (!display_name.is_empty()) {
                            parts.push_back(display_name);
                        }

                        for (size_t i = 0, count = n->get_children_count(); i < count; i++) {
                            if (search_node(n->get_child(i), parts)) {
                                return true;
                            }
                        }
                        return false;
                    }
                    default:
                        return false;
                    }
                };

                if (search_node(node, base_parts)) {
                    return result;
                }
            }
        }
    }

    // Main menu command not found - try context menu commands.
    // Skip during polling because init_context() builds the full context menu
    // tree for all components, which can crash components that aren't
    // thread-safe (e.g. ESLyric with multi-threaded rendering).
    if (skip_context_menu) {
        result.cache_valid = true;
        return result;
    }

    // Get selected tracks from the active playlist
    auto pm = playlist_manager::get();
    metadb_handle_list tracks;

    t_size active_playlist = pm->get_active_playlist();
    if (active_playlist != pfc_infinite) {
        bit_array_bittable selection(pm->playlist_get_item_count(active_playlist));
        pm->playlist_get_selection_mask(active_playlist, selection);
        
        bool has_selection = false;
        for (t_size i = 0; i < pm->playlist_get_item_count(active_playlist); i++) {
            if (selection.get(i)) {
                has_selection = true;
                break;
            }
        }
        
        if (has_selection) {
            pm->playlist_get_selected_items(active_playlist, tracks);
        } else {
            t_size focus = pm->playlist_get_focus_item(active_playlist);
            if (focus != pfc_infinite) {
                metadb_handle_ptr track;
                if (pm->playlist_get_item_handle(track, active_playlist, focus)) {
                    tracks.add_item(track);
                }
            }
        }
    }
    
    if (tracks.get_count() == 0) {
        return result;  // No tracks to operate on
    }
    
    // Create context menu manager and search for the command
    contextmenu_manager::ptr cm;
    contextmenu_manager::g_create(cm);
    cm->init_context(tracks, 0);
    
    // Recursive function to search context menu nodes
    std::function<bool(contextmenu_node*, pfc::string8)> search_context_node;
    search_context_node = [&](contextmenu_node* node, pfc::string8 parent_path) -> bool {
        if (!node) return false;
        
        t_size child_count = node->get_num_children();
        for (t_size i = 0; i < child_count; i++) {
            contextmenu_node* child = node->get_child(i);
            if (!child) continue;
            
            // Get node info using contextmenu_node API
            const char* child_name = child->get_name();
            if (!child_name) continue;
            
            contextmenu_item_node::t_type child_type = child->get_type();
            
            // Skip separators
            if (child_type == contextmenu_item_node::type_separator) continue;
            
            // Build full path for this node
            pfc::string8 full_path;
            if (!parent_path.is_empty()) {
                full_path << parent_path << "/";
            }
            full_path << child_name;
            
            if (child_type == contextmenu_item_node::type_command) {
                if (stricmp_utf8(full_path.c_str(), target_path.c_str()) == 0) {
                    result.found = true;
                    unsigned child_flags = child->get_display_flags();
                    result.checked = (child_flags & contextmenu_item_node::FLAG_CHECKED) != 0;
                    result.disabled = (child_flags & contextmenu_item_node::FLAG_DISABLED) != 0;
                    return true;
                }
            } else if (child_type == contextmenu_item_node::type_group) {
                if (search_context_node(child, full_path)) {
                    return true;
                }
            }
        }
        return false;
    };
    
    // Start search from root
    contextmenu_node* root = cm->get_root();
    if (root && search_context_node(root, "")) {
        return result;
    }

    // Command not found — cache this result so we don't re-enumerate every poll
    result.cache_valid = true;
    return result;
}

void poll_fb2k_action_state(CommandState& state) {
    if (!state.cache_valid) return;
    if (!state.found) return;  // Command not found on first lookup; skip re-enumeration

    if (state.is_context_menu) {
        // Context menu commands can't be cheaply re-polled without
        // re-creating the context menu tree, so just leave state as-is.
        // The full lookup will refresh on next settings change.
        return;
    }

    if (!state.is_dynamic) {
        // Static main menu command — direct get_display() call, no enumeration
        pfc::string8 display_text;
        t_uint32 flags = 0;
        state.cached_service->get_display(state.cached_command_index, display_text, flags);
        state.checked = (flags & mainmenu_commands::flag_checked) != 0;
        state.disabled = (flags & mainmenu_commands::flag_disabled) != 0;
        return;
    }

    // Dynamic command — must call dynamic_instantiate on the specific cached
    // service/index only (not enumerate all services)
    service_ptr_t<mainmenu_commands_v2> commands_v2;
    state.cached_service->service_query_t(commands_v2);
    if (!commands_v2.is_valid()) return;

    mainmenu_node::ptr node = commands_v2->dynamic_instantiate(state.cached_command_index);
    if (!node.is_valid()) return;

    pfc::string8 target_path = state.cached_dynamic_subpath;
    pfc::string8 base_path = state.cached_dynamic_basepath;

    // Search the dynamic tree starting from the cached base path
    std::function<bool(const mainmenu_node::ptr&, pfc::string8)> search_node;
    search_node = [&](const mainmenu_node::ptr& n, pfc::string8 current_path) -> bool {
        if (!n.is_valid()) return false;

        pfc::string8 display_name;
        uint32_t node_flags;
        n->get_display(display_name, node_flags);

        switch (n->get_type()) {
        case mainmenu_node::type_command: {
            pfc::string8 node_path = current_path;
            if (!node_path.is_empty()) node_path << "/";
            node_path << display_name;

            if (stricmp_utf8(node_path.c_str(), target_path.c_str()) == 0) {
                state.checked = (node_flags & mainmenu_commands::flag_checked) != 0;
                state.disabled = (node_flags & mainmenu_commands::flag_disabled) != 0;
                return true;
            }
            return false;
        }
        case mainmenu_node::type_group: {
            pfc::string8 group_path = current_path;
            if (!display_name.is_empty()) {
                if (!group_path.is_empty()) group_path << "/";
                group_path << display_name;
            }
            for (size_t i = 0, count = n->get_children_count(); i < count; i++) {
                if (search_node(n->get_child(i), group_path)) return true;
            }
            return false;
        }
        default:
            return false;
        }
    };

    search_node(node, base_path);
}

COLORREF get_nowbar_initial_bg_color() {
    int theme_mode = get_nowbar_theme_mode();
    bool dark;
    
    switch (theme_mode) {
        case 1:  // Force Dark
            dark = true;
            break;
        case 2:  // Force Light
            dark = false;
            break;
        default:  // Auto (0) - query foobar2000
            // Use tryGet() to safely check if ui_config_manager is available
            {
                auto api = ui_config_manager::tryGet();
                if (api.is_valid()) {
                    dark = api->is_dark_mode();
                } else {
                    // Default to dark if we can't determine (during early startup)
                    dark = true;
                }
            }
            break;
    }
    
    return dark ? RGB(24, 24, 24) : RGB(245, 245, 245);
}

bool get_nowbar_use_custom_fonts() {
    return cfg_nowbar_use_custom_fonts != 0;
}

LOGFONT get_nowbar_artist_font() {
    return cfg_nowbar_artist_font.get_value();
}

LOGFONT get_nowbar_track_font() {
    return cfg_nowbar_track_font.get_value();
}

LOGFONT get_nowbar_line3_font() {
    return cfg_nowbar_line3_font.get_value();
}

LOGFONT get_nowbar_time_font() {
    return cfg_nowbar_time_font.get_value();
}

void set_nowbar_artist_font(const LOGFONT& font) {
    // When enabling custom fonts for the first time, preserve other fonts' current appearance
    if (cfg_nowbar_use_custom_fonts == 0) {
        cfg_nowbar_track_font = get_nowbar_default_font(false);
        cfg_nowbar_line3_font = get_nowbar_default_font(true);
        cfg_nowbar_time_font = get_nowbar_default_time_font();
    }
    cfg_nowbar_artist_font = font;
    cfg_nowbar_use_custom_fonts = 1;
}

void set_nowbar_track_font(const LOGFONT& font) {
    // When enabling custom fonts for the first time, preserve other fonts' current appearance
    if (cfg_nowbar_use_custom_fonts == 0) {
        cfg_nowbar_artist_font = get_nowbar_default_font(true);
        cfg_nowbar_line3_font = get_nowbar_default_font(true);
        cfg_nowbar_time_font = get_nowbar_default_time_font();
    }
    cfg_nowbar_track_font = font;
    cfg_nowbar_use_custom_fonts = 1;
}

void set_nowbar_line3_font(const LOGFONT& font) {
    if (cfg_nowbar_use_custom_fonts == 0) {
        cfg_nowbar_artist_font = get_nowbar_default_font(true);
        cfg_nowbar_track_font = get_nowbar_default_font(false);
        cfg_nowbar_time_font = get_nowbar_default_time_font();
    }
    cfg_nowbar_line3_font = font;
    cfg_nowbar_use_custom_fonts = 1;
}

void set_nowbar_time_font(const LOGFONT& font) {
    // When enabling custom fonts for the first time, preserve other fonts' current appearance
    if (cfg_nowbar_use_custom_fonts == 0) {
        cfg_nowbar_artist_font = get_nowbar_default_font(true);
        cfg_nowbar_track_font = get_nowbar_default_font(false);
        cfg_nowbar_line3_font = get_nowbar_default_font(true);
    }
    cfg_nowbar_time_font = font;
    cfg_nowbar_use_custom_fonts = 1;
}

void set_nowbar_track_font_color(COLORREF color) {
    cfg_nowbar_track_font_color = static_cast<t_int32>(color);
}

void set_nowbar_artist_font_color(COLORREF color) {
    cfg_nowbar_artist_font_color = static_cast<t_int32>(color);
}

void set_nowbar_line3_font_color(COLORREF color) {
    cfg_nowbar_line3_font_color = static_cast<t_int32>(color);
}

void set_nowbar_time_font_color(COLORREF color) {
    cfg_nowbar_time_font_color = static_cast<t_int32>(color);
}

bool get_nowbar_track_font_color(COLORREF& color) {
    t_int32 val = cfg_nowbar_track_font_color;
    if (val < 0) return false;
    color = static_cast<COLORREF>(val);
    return true;
}

bool get_nowbar_artist_font_color(COLORREF& color) {
    t_int32 val = cfg_nowbar_artist_font_color;
    if (val < 0) return false;
    color = static_cast<COLORREF>(val);
    return true;
}

bool get_nowbar_line3_font_color(COLORREF& color) {
    t_int32 val = cfg_nowbar_line3_font_color;
    if (val < 0) return false;
    color = static_cast<COLORREF>(val);
    return true;
}

bool get_nowbar_time_font_color(COLORREF& color) {
    t_int32 val = cfg_nowbar_time_font_color;
    if (val < 0) return false;
    color = static_cast<COLORREF>(val);
    return true;
}

void reset_nowbar_fonts() {
    cfg_nowbar_use_custom_fonts = 0;
    cfg_nowbar_artist_font = get_nowbar_default_font(true);
    cfg_nowbar_track_font = get_nowbar_default_font(false);
    cfg_nowbar_line3_font = get_nowbar_default_font(true);
    cfg_nowbar_time_font = get_nowbar_default_time_font();
    cfg_nowbar_track_font_color = -1;
    cfg_nowbar_artist_font_color = -1;
    cfg_nowbar_line3_font_color = -1;
    cfg_nowbar_time_font_color = -1;
}

LOGFONT get_nowbar_default_font(bool is_artist) {
    LOGFONT lf = {};
    
    // Get DPI for proper scaling
    HDC hdc = GetDC(nullptr);
    int dpi = GetDeviceCaps(hdc, LOGPIXELSY);
    ReleaseDC(nullptr, hdc);
    
    // Artist: 12.6pt, Track: 15.4pt (40% larger than originals)
    int point_size = is_artist ? 13 : 15;
    lf.lfHeight = -MulDiv(point_size, dpi, 72);
    lf.lfWeight = is_artist ? FW_NORMAL : FW_BOLD;
    lf.lfCharSet = DEFAULT_CHARSET;
    lf.lfOutPrecision = OUT_TT_PRECIS;
    lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf.lfQuality = CLEARTYPE_QUALITY;
    lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
    wcscpy_s(lf.lfFaceName, L"Microsoft YaHei UI");

    return lf;
}

LOGFONT get_nowbar_default_time_font() {
    LOGFONT lf = {};

    HDC hdc = GetDC(nullptr);
    int dpi = GetDeviceCaps(hdc, LOGPIXELSY);
    ReleaseDC(nullptr, hdc);

    lf.lfHeight = -MulDiv(9, dpi, 72);
    lf.lfWeight = FW_NORMAL;
    lf.lfCharSet = DEFAULT_CHARSET;
    lf.lfOutPrecision = OUT_TT_PRECIS;
    lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf.lfQuality = CLEARTYPE_QUALITY;
    lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
    wcscpy_s(lf.lfFaceName, L"Microsoft YaHei UI");

    return lf;
}

// GUID for preferences page
const GUID guid_nowbar_preferences_page =
{ 0xABCDEF00, 0x1234, 0x5678, { 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x88 } };

//=============================================================================
// nowbar_preferences - preferences page instance implementation
//=============================================================================

nowbar_preferences::nowbar_preferences(preferences_page_callback::ptr callback)
    : m_hwnd(nullptr), m_callback(callback), m_has_changes(false), m_current_tab(0) {
}

HWND nowbar_preferences::get_wnd() {
    return m_hwnd;
}

t_uint32 nowbar_preferences::get_state() {
    t_uint32 state = preferences_state::resettable | preferences_state::dark_mode_supported;
    if (m_has_changes) {
        state |= preferences_state::changed;
    }
    return state;
}

void nowbar_preferences::apply() {
    apply_settings();
    m_has_changes = false;
    m_callback->on_state_changed();
}



void nowbar_preferences::reset() {
    reset_settings();
    m_has_changes = false;
    m_callback->on_state_changed();
}

void nowbar_preferences::init_tab_control() {
    HWND hTab = GetDlgItem(m_hwnd, IDC_TAB_CONTROL);

    TCITEM tie = {};
    tie.mask = TCIF_TEXT;

    tie.pszText = (LPWSTR)L"General";
    TabCtrl_InsertItem(hTab, 0, &tie);

    tie.pszText = (LPWSTR)L"Appearance";
    TabCtrl_InsertItem(hTab, 1, &tie);

    tie.pszText = (LPWSTR)L"Icons";
    TabCtrl_InsertItem(hTab, 2, &tie);

    tie.pszText = (LPWSTR)L"Custom Button";
    TabCtrl_InsertItem(hTab, 3, &tie);

    tie.pszText = (LPWSTR)L"Fonts && Colors";
    TabCtrl_InsertItem(hTab, 4, &tie);

    tie.pszText = (LPWSTR)L"About";
    TabCtrl_InsertItem(hTab, 5, &tie);
}

static const int g_tab0_controls[] = {
    IDC_DISPLAY_FORMAT_GROUP, IDC_LINE1_FORMAT_LABEL, IDC_LINE1_FORMAT_EDIT,
    IDC_LINE2_FORMAT_LABEL, IDC_LINE2_FORMAT_EDIT, IDC_LINE3_FORMAT_LABEL,
    IDC_LINE3_FORMAT_EDIT, IDC_RATING_STARS_LABEL, IDC_RATING_STARS_COMBO,
    IDC_MOOD_TAG_LABEL, IDC_MOOD_TAG_COMBO, IDC_PLAYBACK_PREVIEW_GROUP,
    IDC_SKIP_LOW_RATING_LABEL, IDC_SKIP_LOW_RATING_COMBO,
    IDC_SKIP_RATING_THRESHOLD_LABEL, IDC_SKIP_RATING_THRESHOLD_COMBO,
    IDC_VIS_GROUP, IDC_VIS_ENABLE_CHECK, IDC_VIS_60FPS_CHECK,
    IDC_VIS_SPECTRUM_RADIO, IDC_VIS_SPECTRUM_WIDTH_LABEL,
    IDC_VIS_SPECTRUM_WIDTH_COMBO, IDC_VIS_SPECTRUM_STYLE_LABEL,
    IDC_VIS_SPECTRUM_STYLE_COMBO, IDC_VIS_SPECTRUM_HEIGHT_LABEL,
    IDC_VIS_SPECTRUM_HEIGHT_COMBO, IDC_VIS_WAVEFORM_RADIO,
    IDC_VIS_WAVEFORM_STYLE_1, IDC_VIS_WAVEFORM_STYLE_2,
    IDC_VIS_WAVEFORM_WIDTH_LABEL, IDC_VIS_WAVEFORM_WIDTH_COMBO,
    IDC_PLAYBACK_TIME_LABEL, IDC_PLAYBACK_TIME_COMBO
};

static const int g_tab1_controls[] = {
    IDC_THEME_MODE_LABEL, IDC_THEME_MODE_COMBO, IDC_COVER_ARTWORK_LABEL,
    IDC_COVER_ARTWORK_COMBO, IDC_COVER_MARGIN_LABEL, IDC_COVER_MARGIN_COMBO,
    IDC_COVER_STYLE_LABEL, IDC_COVER_STYLE_COMBO, IDC_BACKGROUND_STYLE_LABEL,
    IDC_BACKGROUND_STYLE_COMBO, IDC_BAR_STYLE_LABEL, IDC_BAR_STYLE_COMBO,
    IDC_SEEKBAR_VISIBLE_LABEL, IDC_SEEKBAR_VISIBLE_COMBO, IDC_SEEKBAR_LENGTH_LABEL,
    IDC_SEEKBAR_LENGTH_COMBO, IDC_SEEKBAR_POSITION_LABEL, IDC_SEEKBAR_POSITION_SLIDER,
    IDC_SEEKBAR_POSITION_VALUE, IDC_SMOOTH_ANIMATIONS_LABEL, IDC_SMOOTH_ANIMATIONS_COMBO,
    IDC_ONLINE_ARTWORK_CHECK, IDC_FOO_ARTWORK_LINK, IDC_CBUTTON_3D_LABEL,
    IDC_CBUTTON_3D_COMBO, IDC_VOLUME_NUMBER_LABEL, IDC_VOLUME_NUMBER_COMBO,
    IDC_BUTTON_SCALING_CHECK, IDC_BUTTON_SCALING_SLIDER, IDC_BUTTON_SCALING_VALUE
};

static const int g_tab2_controls[] = {
    IDC_MOOD_ICON_LABEL, IDC_MOOD_ICON_COMBO, IDC_SHUFFLE_ICON_LABEL,
    IDC_SHUFFLE_ICON_COMBO, IDC_REPEAT_ICON_LABEL, IDC_REPEAT_ICON_COMBO,
    IDC_STOP_ICON_LABEL, IDC_STOP_ICON_COMBO, IDC_STOP_AFTER_CURRENT_LABEL,
    IDC_STOP_AFTER_CURRENT_COMBO, IDC_SUPER_ICON_LABEL, IDC_SUPER_ICON_COMBO,
    IDC_MINIPLAYER_ICON_LABEL, IDC_MINIPLAYER_ICON_COMBO, IDC_FOO_TRAYCONTROLS_LINK,
    IDC_HOVER_CIRCLES_LABEL, IDC_HOVER_CIRCLES_COMBO, IDC_ALTERNATE_ICONS_LABEL,
    IDC_ALTERNATE_ICONS_COMBO, IDC_PLAY_ICON_STYLE_LABEL, IDC_PLAY_ICON_STYLE_COMBO,
    IDC_AUTOHIDE_CBUTTONS_LABEL, IDC_AUTOHIDE_CBUTTONS_COMBO, IDC_VOLUME_ICON_LABEL,
    IDC_VOLUME_ICON_COMBO, IDC_VOLUME_BAR_LABEL, IDC_VOLUME_BAR_COMBO
};

static const int g_tab3_controls[] = {
    IDC_PROFILE_NAME_LABEL, IDC_PROFILE_COMBO, IDC_PROFILE_MENU_BTN,
    IDC_CBUTTON_ENABLE_LABEL, IDC_CBUTTON_ACTION_LABEL, IDC_CBUTTON_PATH_LABEL,
    IDC_CBUTTON1_ENABLE, IDC_CBUTTON1_ACTION, IDC_CBUTTON1_PATH, IDC_CBUTTON1_BROWSE,
    IDC_CBUTTON2_ENABLE, IDC_CBUTTON2_ACTION, IDC_CBUTTON2_PATH, IDC_CBUTTON2_BROWSE,
    IDC_CBUTTON3_ENABLE, IDC_CBUTTON3_ACTION, IDC_CBUTTON3_PATH, IDC_CBUTTON3_BROWSE,
    IDC_CBUTTON4_ENABLE, IDC_CBUTTON4_ACTION, IDC_CBUTTON4_PATH, IDC_CBUTTON4_BROWSE,
    IDC_CBUTTON5_ENABLE, IDC_CBUTTON5_ACTION, IDC_CBUTTON5_PATH, IDC_CBUTTON5_BROWSE,
    IDC_CBUTTON6_ENABLE, IDC_CBUTTON6_ACTION, IDC_CBUTTON6_PATH, IDC_CBUTTON6_BROWSE,
    IDC_CBUTTON_ICON_LABEL, IDC_CBUTTON_GLYPH_LABEL, IDC_CBUTTON_FONT_LABEL,
    IDC_CBUTTON1_GLYPH_SIZE, IDC_CBUTTON1_ICON, IDC_CBUTTON1_FONT,
    IDC_CBUTTON2_GLYPH_SIZE, IDC_CBUTTON2_ICON, IDC_CBUTTON2_FONT,
    IDC_CBUTTON3_GLYPH_SIZE, IDC_CBUTTON3_ICON, IDC_CBUTTON3_FONT,
    IDC_CBUTTON4_GLYPH_SIZE, IDC_CBUTTON4_ICON, IDC_CBUTTON4_FONT,
    IDC_CBUTTON5_GLYPH_SIZE, IDC_CBUTTON5_ICON, IDC_CBUTTON5_FONT,
    IDC_CBUTTON6_GLYPH_SIZE, IDC_CBUTTON6_ICON, IDC_CBUTTON6_FONT,
    IDC_CBUTTON1_ICON_LABEL, IDC_CBUTTON2_ICON_LABEL, IDC_CBUTTON3_ICON_LABEL,
    IDC_CBUTTON4_ICON_LABEL, IDC_CBUTTON5_ICON_LABEL, IDC_CBUTTON6_ICON_LABEL,
    IDC_CBUTTON_LABEL_LABEL, IDC_CBUTTON1_LABEL, IDC_CBUTTON2_LABEL,
    IDC_CBUTTON3_LABEL, IDC_CBUTTON4_LABEL, IDC_CBUTTON5_LABEL, IDC_CBUTTON6_LABEL
};

static const int g_tab4_controls[] = {
    IDC_FONTS_GROUP, IDC_TRACK_FONT_LABEL, IDC_TRACK_FONT_DISPLAY, IDC_TRACK_FONT_SELECT,
    IDC_ARTIST_FONT_LABEL, IDC_ARTIST_FONT_DISPLAY, IDC_ARTIST_FONT_SELECT,
    IDC_LINE3_FONT_LABEL, IDC_LINE3_FONT_DISPLAY, IDC_LINE3_FONT_SELECT,
    IDC_TIME_FONT_LABEL, IDC_TIME_FONT_DISPLAY, IDC_TIME_FONT_SELECT,
    IDC_COLORS_GROUP, IDC_CUSTOM_BUTTON_ACCENT_CHECK, IDC_BUTTON_ACCENT_BTN,
    IDC_CUSTOM_PLAY_ACCENT_CHECK, IDC_PLAY_ACCENT_BTN,
    IDC_CUSTOM_PROGRESS_ACCENT_CHECK, IDC_PROGRESS_ACCENT_BTN,
    IDC_CUSTOM_VOLUME_ACCENT_CHECK, IDC_VOLUME_ACCENT_BTN,
    IDC_CUSTOM_HOVER_COLOR_CHECK, IDC_HOVER_COLOR_BTN,
    IDC_SPECTRUM_COLOR_MODE_LABEL, IDC_CUSTOM_SPECTRUM_COLOR_CHECK, IDC_VIS_SPECTRUM_COLOR_BTN,
    IDC_SPECTRUM_OPACITY_LABEL, IDC_SPECTRUM_OPACITY_SLIDER, IDC_SPECTRUM_OPACITY_VALUE,
    IDC_SPECTRUM_COLOR_MODE_COMBO, IDC_SPECTRUM_COLOR2_BTN,
    IDC_CUSTOM_WAVEFORM_COLOR_CHECK, IDC_VIS_WAVEFORM_COLOR_BTN,
    IDC_CUSTOM_WAVEFORM_UNPLAYED_CHECK, IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN,
    IDC_CUSTOM_PROGRESS_TRACK_CHECK, IDC_PROGRESS_TRACK_BTN,
    IDC_CUSTOM_VOLUME_TRACK_CHECK, IDC_VOLUME_TRACK_BTN
};

static const int g_tab5_controls[] = {
    IDC_ABOUT_NAME, IDC_ABOUT_DESCRIPTION, IDC_ABOUT_REPO_LINK, IDC_ABOUT_DONATE_LINK,
    IDC_ABOUT_OTHER_LABEL, IDC_ABOUT_FOO_ARTWORK_LINK, IDC_ABOUT_FOO_TRAYCONTROLS_LINK, IDC_ABOUT_NOTE
};

static void show_tab_controls(HWND hwnd, int tab, int cmd_show) {
    const int* ctrls = nullptr;
    size_t count = 0;
    switch (tab) {
        case 0: ctrls = g_tab0_controls; count = _countof(g_tab0_controls); break;
        case 1: ctrls = g_tab1_controls; count = _countof(g_tab1_controls); break;
        case 2: ctrls = g_tab2_controls; count = _countof(g_tab2_controls); break;
        case 3: ctrls = g_tab3_controls; count = _countof(g_tab3_controls); break;
        case 4: ctrls = g_tab4_controls; count = _countof(g_tab4_controls); break;
        case 5: ctrls = g_tab5_controls; count = _countof(g_tab5_controls); break;
        default: return;
    }
    for (size_t i = 0; i < count; i++) {
        HWND hCtrl = GetDlgItem(hwnd, ctrls[i]);
        if (hCtrl) ShowWindow(hCtrl, cmd_show);
    }
}

// Helper to update Button Scaling slider visibility based on checkbox state and active tab
static void update_button_scaling_state(HWND hwnd) {
    int cur_tab = (int)SendDlgItemMessage(hwnd, IDC_TAB_CONTROL, TCM_GETCURSEL, 0, 0);
    BOOL checked = (IsDlgButtonChecked(hwnd, IDC_BUTTON_SCALING_CHECK) == BST_CHECKED);
    BOOL show = checked && (cur_tab == 1);
    ShowWindow(GetDlgItem(hwnd, IDC_BUTTON_SCALING_SLIDER), show ? SW_SHOW : SW_HIDE);
    ShowWindow(GetDlgItem(hwnd, IDC_BUTTON_SCALING_VALUE), show ? SW_SHOW : SW_HIDE);
}

void nowbar_preferences::switch_tab(int tab) {
    if (tab < 0 || tab > 5) return;
    int old_tab = m_current_tab;
    m_current_tab = tab;

    SendMessage(m_hwnd, WM_SETREDRAW, FALSE, 0);

    if (old_tab >= 0 && old_tab <= 5 && old_tab != tab) {
        show_tab_controls(m_hwnd, old_tab, SW_HIDE);
    }
    show_tab_controls(m_hwnd, tab, SW_SHOW);
    if (tab == 1) {
        update_button_scaling_state(m_hwnd);
    }

    SendMessage(m_hwnd, WM_SETREDRAW, TRUE, 0);
    RedrawWindow(m_hwnd, nullptr, nullptr, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
}

// Helper to update Visualization section enable/disable states
static void update_vis_section_state(HWND hwnd) {
    BOOL enabled = (IsDlgButtonChecked(hwnd, IDC_VIS_ENABLE_CHECK) == BST_CHECKED);
    BOOL spectrum_sel = (IsDlgButtonChecked(hwnd, IDC_VIS_SPECTRUM_RADIO) == BST_CHECKED);
    BOOL waveform_sel = (IsDlgButtonChecked(hwnd, IDC_VIS_WAVEFORM_RADIO) == BST_CHECKED);

    // Radio buttons and 60fps are enabled when the checkbox is checked
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_RADIO), enabled);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_RADIO), enabled);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_60FPS_CHECK), enabled);

    // Spectrum controls: enabled only if Enable checked AND Spectrum selected
    BOOL spec_on = enabled && spectrum_sel;
    int style_sel = (int)SendMessage(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_STYLE_COMBO), CB_GETCURSEL, 0, 0);
    BOOL spec_bars = spec_on && (style_sel != 1);  // Width not applicable in Curve mode
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_WIDTH_LABEL), spec_bars);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_WIDTH_COMBO), spec_bars);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_STYLE_LABEL), spec_on);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_STYLE_COMBO), spec_on);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_HEIGHT_LABEL), spec_on);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_HEIGHT_COMBO), spec_on);
    EnableWindow(GetDlgItem(hwnd, IDC_PLAYBACK_TIME_LABEL), spec_on);
    EnableWindow(GetDlgItem(hwnd, IDC_PLAYBACK_TIME_COMBO), spec_on);

    // Waveform controls: enabled only if Enable checked AND Waveform selected
    BOOL wave_on = enabled && waveform_sel;
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_STYLE_1), wave_on);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_STYLE_2), wave_on);
    BOOL wave_bars = wave_on && (IsDlgButtonChecked(hwnd, IDC_VIS_WAVEFORM_STYLE_1) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_WIDTH_LABEL), wave_bars);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_WIDTH_COMBO), wave_bars);
}

// Helper to enable/disable color buttons based on checkbox state
static void update_color_buttons_state(HWND hwnd) {
    EnableWindow(GetDlgItem(hwnd, IDC_BUTTON_ACCENT_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_BUTTON_ACCENT_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_PLAY_ACCENT_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_PLAY_ACCENT_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_PROGRESS_ACCENT_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_PROGRESS_ACCENT_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_VOLUME_ACCENT_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_VOLUME_ACCENT_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_HOVER_COLOR_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_HOVER_COLOR_CHECK) == BST_CHECKED);
    int color_mode = (int)SendMessage(GetDlgItem(hwnd, IDC_SPECTRUM_COLOR_MODE_COMBO), CB_GETCURSEL, 0, 0);
    BOOL spectrum_mode_has_custom = (color_mode == 1 || color_mode == 2);
    EnableWindow(GetDlgItem(hwnd, IDC_CUSTOM_SPECTRUM_COLOR_CHECK), spectrum_mode_has_custom);
    BOOL spectrum_custom = spectrum_mode_has_custom && (IsDlgButtonChecked(hwnd, IDC_CUSTOM_SPECTRUM_COLOR_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_COLOR_BTN), spectrum_custom);
    EnableWindow(GetDlgItem(hwnd, IDC_SPECTRUM_COLOR2_BTN), spectrum_custom && color_mode == 2);
    EnableWindow(GetDlgItem(hwnd, IDC_SPECTRUM_COLOR_MODE_LABEL), TRUE);
    EnableWindow(GetDlgItem(hwnd, IDC_SPECTRUM_COLOR_MODE_COMBO), TRUE);
    EnableWindow(GetDlgItem(hwnd, IDC_SPECTRUM_OPACITY_LABEL), TRUE);
    EnableWindow(GetDlgItem(hwnd, IDC_SPECTRUM_OPACITY_SLIDER), TRUE);
    EnableWindow(GetDlgItem(hwnd, IDC_SPECTRUM_OPACITY_VALUE), TRUE);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_COLOR_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_WAVEFORM_COLOR_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_WAVEFORM_UNPLAYED_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_PROGRESS_TRACK_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_PROGRESS_TRACK_CHECK) == BST_CHECKED);
    EnableWindow(GetDlgItem(hwnd, IDC_VOLUME_TRACK_BTN),
        IsDlgButtonChecked(hwnd, IDC_CUSTOM_VOLUME_TRACK_CHECK) == BST_CHECKED);
}

// Hook procedure to ensure color picker dialog appears on top
static UINT_PTR CALLBACK ColorPickerHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam) {
    if (uiMsg == WM_INITDIALOG) {
        // Bring the dialog to the foreground and make it topmost temporarily
        SetWindowPos(hdlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
        SetForegroundWindow(hdlg);
        // Remove topmost flag so it behaves normally after appearing
        SetWindowPos(hdlg, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
    }
    return 0;
}

// Helper to show the Windows color picker dialog.
// The 16 custom color slots persist across sessions via cfg_color_picker_custom.
static bool show_color_picker(HWND hwnd, COLORREF& color) {
    static COLORREF custom_colors[16] = {0};
    static bool loaded = false;

    // Load custom colors from cfg on first use
    if (!loaded) {
        loaded = true;
        pfc::string8 stored = cfg_color_picker_custom.get();
        if (!stored.is_empty()) {
            const char* p = stored.c_str();
            for (int i = 0; i < 16 && *p; i++) {
                char* end;
                unsigned long val = strtoul(p, &end, 16);
                custom_colors[i] = (COLORREF)val;
                p = end;
                if (*p == ',') p++;
            }
        }
    }

    CHOOSECOLOR cc = {};
    cc.lStructSize = sizeof(cc);
    cc.hwndOwner = hwnd;
    cc.rgbResult = color;
    cc.lpCustColors = custom_colors;
    cc.Flags = CC_FULLOPEN | CC_RGBINIT | CC_ENABLEHOOK;
    cc.lpfnHook = ColorPickerHookProc;
    bool ok = ChooseColor(&cc) != 0;

    // Save custom colors back to cfg (whether OK or Cancel — user may have
    // defined custom colors without clicking OK on the main color)
    {
        pfc::string8 buf;
        for (int i = 0; i < 16; i++) {
            if (i > 0) buf += ",";
            buf += pfc::format_hex(custom_colors[i], 6);
        }
        cfg_color_picker_custom = buf;
    }

    if (ok) {
        color = cc.rgbResult;
        return true;
    }
    return false;
}

// Helper to update Cover Margin combobox state based on Cover Artwork selection
static void update_cover_margin_state(HWND hwnd) {
    int coverArtworkSel = (int)SendMessage(GetDlgItem(hwnd, IDC_COVER_ARTWORK_COMBO), CB_GETCURSEL, 0, 0);
    // Cover Artwork: 0=Yes, 1=No - disable Cover Margin and Cover Style when artwork is hidden
    EnableWindow(GetDlgItem(hwnd, IDC_COVER_MARGIN_COMBO), coverArtworkSel == 0);
    EnableWindow(GetDlgItem(hwnd, IDC_COVER_STYLE_COMBO), coverArtworkSel == 0);
}

// Helper to update path control states based on action selection
static void update_cbutton_path_state(HWND hwnd, int action_id, int path_id, int browse_id) {
    int action = (int)SendMessage(GetDlgItem(hwnd, action_id), CB_GETCURSEL, 0, 0);
    HWND hPath = GetDlgItem(hwnd, path_id);
    HWND hBrowse = GetDlgItem(hwnd, browse_id);
    
    // 0=None, 1=Open URL, 2=Run Executable, 3=Foobar2k Action, 4=Open Folder
    switch (action) {
        case 0:  // None - disable both
            EnableWindow(hPath, FALSE);
            EnableWindow(hBrowse, FALSE);
            break;
        case 1:  // Open URL - enable path edit, hide browse
            EnableWindow(hPath, TRUE);
            EnableWindow(hBrowse, FALSE);
            break;
        case 2:  // Run Executable - enable path edit, enable browse
            EnableWindow(hPath, TRUE);
            EnableWindow(hBrowse, TRUE);
            break;
        case 3:  // Foobar2k Action - enable path edit, hide browse
            EnableWindow(hPath, TRUE);
            EnableWindow(hBrowse, FALSE);
            break;
        case 4:  // Open Folder - no path needed, disable both
            EnableWindow(hPath, FALSE);
            EnableWindow(hBrowse, FALSE);
            break;
        case 5:  // Output Device - no path needed, disable both
            EnableWindow(hPath, FALSE);
            EnableWindow(hBrowse, FALSE);
            break;
    }
}

static void update_all_cbutton_path_states(HWND hwnd) {
    update_cbutton_path_state(hwnd, IDC_CBUTTON1_ACTION, IDC_CBUTTON1_PATH, IDC_CBUTTON1_BROWSE);
    update_cbutton_path_state(hwnd, IDC_CBUTTON2_ACTION, IDC_CBUTTON2_PATH, IDC_CBUTTON2_BROWSE);
    update_cbutton_path_state(hwnd, IDC_CBUTTON3_ACTION, IDC_CBUTTON3_PATH, IDC_CBUTTON3_BROWSE);
    update_cbutton_path_state(hwnd, IDC_CBUTTON4_ACTION, IDC_CBUTTON4_PATH, IDC_CBUTTON4_BROWSE);
    update_cbutton_path_state(hwnd, IDC_CBUTTON5_ACTION, IDC_CBUTTON5_PATH, IDC_CBUTTON5_BROWSE);
    update_cbutton_path_state(hwnd, IDC_CBUTTON6_ACTION, IDC_CBUTTON6_PATH, IDC_CBUTTON6_BROWSE);
}

INT_PTR CALLBACK nowbar_preferences::ConfigProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    nowbar_preferences* p_this = nullptr;
    
    if (msg == WM_INITDIALOG) {
        p_this = reinterpret_cast<nowbar_preferences*>(lp);
        SetWindowLongPtr(hwnd, GWLP_USERDATA, lp);
        p_this->m_hwnd = hwnd;
        
        SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);

        // Hide inactive tab controls immediately before theming and population
        show_tab_controls(hwnd, 1, SW_HIDE);
        show_tab_controls(hwnd, 2, SW_HIDE);
        show_tab_controls(hwnd, 3, SW_HIDE);
        show_tab_controls(hwnd, 4, SW_HIDE);
        show_tab_controls(hwnd, 5, SW_HIDE);
        show_tab_controls(hwnd, 0, SW_SHOW);
        p_this->m_current_tab = 0;

        // Initialize dark mode hooks
        p_this->m_darkMode.AddDialogWithControls(hwnd);
        
        // Enable tab page texture
        EnableThemeDialogTexture(hwnd, ETDT_ENABLETAB);
        
        // Initialize tab control
        p_this->init_tab_control();
        
        // Initialize display format edit controls
        uSetDlgItemText(hwnd, IDC_LINE1_FORMAT_EDIT, cfg_nowbar_line1_format);
        uSetDlgItemText(hwnd, IDC_LINE2_FORMAT_EDIT, cfg_nowbar_line2_format);
        uSetDlgItemText(hwnd, IDC_LINE3_FORMAT_EDIT, cfg_nowbar_line3_format);
        
        // Initialize theme mode combobox
        HWND hThemeCombo = GetDlgItem(hwnd, IDC_THEME_MODE_COMBO);
        SendMessage(hThemeCombo, CB_ADDSTRING, 0, (LPARAM)L"Auto");
        SendMessage(hThemeCombo, CB_ADDSTRING, 0, (LPARAM)L"Dark");
        SendMessage(hThemeCombo, CB_ADDSTRING, 0, (LPARAM)L"Light");
        SendMessage(hThemeCombo, CB_ADDSTRING, 0, (LPARAM)L"Custom");
        SendMessage(hThemeCombo, CB_SETCURSEL, cfg_nowbar_theme_mode, 0);

        // Initialize cover artwork visibility combobox
        HWND hCoverArtworkCombo = GetDlgItem(hwnd, IDC_COVER_ARTWORK_COMBO);
        SendMessage(hCoverArtworkCombo, CB_ADDSTRING, 0, (LPARAM)L"Yes");
        SendMessage(hCoverArtworkCombo, CB_ADDSTRING, 0, (LPARAM)L"No");
        SendMessage(hCoverArtworkCombo, CB_SETCURSEL, cfg_nowbar_cover_artwork_visible ? 0 : 1, 0);

        // Initialize online artwork checkbox
        CheckDlgButton(hwnd, IDC_ONLINE_ARTWORK_CHECK, cfg_nowbar_online_artwork ? BST_CHECKED : BST_UNCHECKED);

        // Disable Online Artwork if foo_artwork is not installed
        if (!GetModuleHandleW(L"foo_artwork.dll")) {
            EnableWindow(GetDlgItem(hwnd, IDC_ONLINE_ARTWORK_CHECK), FALSE);
        }

        // Initialize smooth animations combobox (moved from end of list, now after Theme Mode)
        HWND hSmoothAnimCombo = GetDlgItem(hwnd, IDC_SMOOTH_ANIMATIONS_COMBO);
        SendMessage(hSmoothAnimCombo, CB_ADDSTRING, 0, (LPARAM)L"Enabled");
        SendMessage(hSmoothAnimCombo, CB_ADDSTRING, 0, (LPARAM)L"Disabled");
        SendMessage(hSmoothAnimCombo, CB_SETCURSEL, cfg_nowbar_smooth_animations ? 0 : 1, 0);

        // Initialize 3D Buttons combobox
        {
            HWND h3dButtonsCombo = GetDlgItem(hwnd, IDC_CBUTTON_3D_COMBO);
            SendMessage(h3dButtonsCombo, CB_ADDSTRING, 0, (LPARAM)L"Enabled");
            SendMessage(h3dButtonsCombo, CB_ADDSTRING, 0, (LPARAM)L"Disabled");
            SendMessage(h3dButtonsCombo, CB_SETCURSEL, cfg_nowbar_3d_buttons ? 0 : 1, 0);
        }

        // Initialize Volume Number combobox
        {
            HWND hVolNumCombo = GetDlgItem(hwnd, IDC_VOLUME_NUMBER_COMBO);
            SendMessage(hVolNumCombo, CB_ADDSTRING, 0, (LPARAM)L"Disabled");
            SendMessage(hVolNumCombo, CB_ADDSTRING, 0, (LPARAM)L"Enabled");
            SendMessage(hVolNumCombo, CB_SETCURSEL, cfg_nowbar_volume_number ? 1 : 0, 0);
        }

        // Initialize Playback Time combobox
        {
            HWND hPlaybackTimeCombo = GetDlgItem(hwnd, IDC_PLAYBACK_TIME_COMBO);
            SendMessage(hPlaybackTimeCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
            SendMessage(hPlaybackTimeCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
            SendMessage(hPlaybackTimeCombo, CB_SETCURSEL, cfg_nowbar_playback_time_visible ? 0 : 1, 0);
        }

        // Initialize background style combobox
        HWND hBgStyleCombo = GetDlgItem(hwnd, IDC_BACKGROUND_STYLE_COMBO);
        SendMessage(hBgStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Solid");
        SendMessage(hBgStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Artwork Colors");
        SendMessage(hBgStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Blurred Artwork");
        SendMessage(hBgStyleCombo, CB_SETCURSEL, cfg_nowbar_background_style, 0);
        
        // Initialize bar style combobox
        HWND hBarStyleCombo = GetDlgItem(hwnd, IDC_BAR_STYLE_COMBO);
        SendMessage(hBarStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Pill-shaped");
        SendMessage(hBarStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Rectangular");
        SendMessage(hBarStyleCombo, CB_SETCURSEL, cfg_nowbar_bar_style, 0);

        // Initialize seekbar visible combobox
        HWND hSeekbarVisibleCombo = GetDlgItem(hwnd, IDC_SEEKBAR_VISIBLE_COMBO);
        SendMessage(hSeekbarVisibleCombo, CB_ADDSTRING, 0, (LPARAM)L"On");
        SendMessage(hSeekbarVisibleCombo, CB_ADDSTRING, 0, (LPARAM)L"Off");
        SendMessage(hSeekbarVisibleCombo, CB_SETCURSEL, cfg_nowbar_seekbar_visible ? 0 : 1, 0);

        // Initialize seekbar length combobox
        HWND hSeekbarLengthCombo = GetDlgItem(hwnd, IDC_SEEKBAR_LENGTH_COMBO);
        SendMessage(hSeekbarLengthCombo, CB_ADDSTRING, 0, (LPARAM)L"Fixed");
        SendMessage(hSeekbarLengthCombo, CB_ADDSTRING, 0, (LPARAM)L"Scaling");
        SendMessage(hSeekbarLengthCombo, CB_SETCURSEL, cfg_nowbar_seekbar_length, 0);

        // Initialize seekbar position slider (-100 to +100, mapped to 0-200)
        {
            HWND hPosSlider = GetDlgItem(hwnd, IDC_SEEKBAR_POSITION_SLIDER);
            SendMessage(hPosSlider, TBM_SETRANGE, TRUE, MAKELPARAM(0, 200));
            SendMessage(hPosSlider, TBM_SETPOS, TRUE, cfg_nowbar_seekbar_position + 100);
            wchar_t buf[8];
            int val = (int)cfg_nowbar_seekbar_position;
            if (val > 0)
                wsprintfW(buf, L"+%d", val);
            else
                wsprintfW(buf, L"%d", val);
            SetDlgItemTextW(hwnd, IDC_SEEKBAR_POSITION_VALUE, buf);
        }

        // Initialize cover margin combobox
        HWND hCoverMarginCombo = GetDlgItem(hwnd, IDC_COVER_MARGIN_COMBO);
        SendMessage(hCoverMarginCombo, CB_ADDSTRING, 0, (LPARAM)L"Yes");
        SendMessage(hCoverMarginCombo, CB_ADDSTRING, 0, (LPARAM)L"No");
        SendMessage(hCoverMarginCombo, CB_SETCURSEL, cfg_nowbar_cover_margin ? 0 : 1, 0);

        // Initialize cover style combobox
        HWND hCoverStyleCombo = GetDlgItem(hwnd, IDC_COVER_STYLE_COMBO);
        SendMessage(hCoverStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Square");
        SendMessage(hCoverStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Rounded");
        SendMessage(hCoverStyleCombo, CB_SETCURSEL, get_nowbar_cover_style(), 0);

        // Update Cover Margin state based on Cover Artwork visibility
        update_cover_margin_state(hwnd);

        // Initialize button scaling checkbox and slider
        CheckDlgButton(hwnd, IDC_BUTTON_SCALING_CHECK, cfg_nowbar_button_scaling_enabled ? BST_CHECKED : BST_UNCHECKED);
        {
            HWND hBtnSlider = GetDlgItem(hwnd, IDC_BUTTON_SCALING_SLIDER);
            SendMessage(hBtnSlider, TBM_SETRANGE, TRUE, MAKELPARAM(60, 100));
            SendMessage(hBtnSlider, TBM_SETTICFREQ, 10, 0);
            int pct = cfg_nowbar_button_scaling_percent;
            if (pct < 60) pct = 60;
            if (pct > 100) pct = 100;
            SendMessage(hBtnSlider, TBM_SETPOS, TRUE, pct);
            wchar_t buf[8];
            wsprintfW(buf, L"%d%%", pct);
            SetDlgItemTextW(hwnd, IDC_BUTTON_SCALING_VALUE, buf);
        }
        update_button_scaling_state(hwnd);

        // Initialize mood icon visibility combobox
        HWND hMoodIconCombo = GetDlgItem(hwnd, IDC_MOOD_ICON_COMBO);
        SendMessage(hMoodIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hMoodIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hMoodIconCombo, CB_SETCURSEL, cfg_nowbar_mood_icon_visible ? 0 : 1, 0);

        // Initialize shuffle icon visibility combobox
        HWND hShuffleIconCombo = GetDlgItem(hwnd, IDC_SHUFFLE_ICON_COMBO);
        SendMessage(hShuffleIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hShuffleIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hShuffleIconCombo, CB_SETCURSEL, cfg_nowbar_shuffle_icon_visible ? 0 : 1, 0);

        // Initialize repeat icon visibility combobox
        HWND hRepeatIconCombo = GetDlgItem(hwnd, IDC_REPEAT_ICON_COMBO);
        SendMessage(hRepeatIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hRepeatIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hRepeatIconCombo, CB_SETCURSEL, cfg_nowbar_repeat_icon_visible ? 0 : 1, 0);

        // Initialize rating stars visibility combobox (0=Hidden, 1=Show, 2=Line 3)
        HWND hRatingStarsCombo = GetDlgItem(hwnd, IDC_RATING_STARS_COMBO);
        SendMessage(hRatingStarsCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hRatingStarsCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hRatingStarsCombo, CB_ADDSTRING, 0, (LPARAM)L"Line 3");
        {
            int rating_sel = 1;  // Default: Hidden
            if (cfg_nowbar_rating_visible == 1) rating_sel = 0;       // Show
            else if (cfg_nowbar_rating_visible == 2) rating_sel = 2;  // Line 3
            SendMessage(hRatingStarsCombo, CB_SETCURSEL, rating_sel, 0);
            // Grey out Line 3 edit box when Rating Stars is set to "Line 3"
            EnableWindow(GetDlgItem(hwnd, IDC_LINE3_FORMAT_EDIT), cfg_nowbar_rating_visible != 2);
        }

        // Initialize stop icon visibility combobox
        HWND hStopIconCombo = GetDlgItem(hwnd, IDC_STOP_ICON_COMBO);
        SendMessage(hStopIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hStopIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hStopIconCombo, CB_SETCURSEL, cfg_nowbar_stop_icon_visible ? 0 : 1, 0);

        // Initialize stop after current icon visibility combobox
        HWND hStopAfterCurrentCombo = GetDlgItem(hwnd, IDC_STOP_AFTER_CURRENT_COMBO);
        SendMessage(hStopAfterCurrentCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hStopAfterCurrentCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hStopAfterCurrentCombo, CB_SETCURSEL, cfg_nowbar_stop_after_current_icon_visible ? 0 : 1, 0);

        // Initialize super icon visibility combobox
        HWND hSuperIconCombo = GetDlgItem(hwnd, IDC_SUPER_ICON_COMBO);
        SendMessage(hSuperIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hSuperIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hSuperIconCombo, CB_SETCURSEL, cfg_nowbar_super_icon_visible ? 0 : 1, 0);

        // Initialize miniplayer icon visibility combobox
        HWND hMiniplayerIconCombo = GetDlgItem(hwnd, IDC_MINIPLAYER_ICON_COMBO);
        SendMessage(hMiniplayerIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hMiniplayerIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hMiniplayerIconCombo, CB_SETCURSEL, cfg_nowbar_miniplayer_icon_visible ? 0 : 1, 0);

        // Disable MiniPlayer Icon if foo_traycontrols is not installed
        if (!GetModuleHandleW(L"foo_traycontrols.dll")) {
            EnableWindow(GetDlgItem(hwnd, IDC_MINIPLAYER_ICON_LABEL), FALSE);
            EnableWindow(hMiniplayerIconCombo, FALSE);
        }

        // Initialize hover circles combobox
        HWND hHoverCirclesCombo = GetDlgItem(hwnd, IDC_HOVER_CIRCLES_COMBO);
        SendMessage(hHoverCirclesCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hHoverCirclesCombo, CB_ADDSTRING, 0, (LPARAM)L"Hide");
        SendMessage(hHoverCirclesCombo, CB_SETCURSEL, cfg_nowbar_hover_circles ? 0 : 1, 0);

        // Initialize alternate icons combobox
        HWND hAlternateIconsCombo = GetDlgItem(hwnd, IDC_ALTERNATE_ICONS_COMBO);
        SendMessage(hAlternateIconsCombo, CB_ADDSTRING, 0, (LPARAM)L"Style 1");
        SendMessage(hAlternateIconsCombo, CB_ADDSTRING, 0, (LPARAM)L"Style 2");
        SendMessage(hAlternateIconsCombo, CB_ADDSTRING, 0, (LPARAM)L"Style 3");
        SendMessage(hAlternateIconsCombo, CB_SETCURSEL, cfg_nowbar_alternate_icons, 0);

        // Initialize play icon style combobox
        HWND hPlayIconStyleCombo = GetDlgItem(hwnd, IDC_PLAY_ICON_STYLE_COMBO);
        SendMessage(hPlayIconStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Normal");
        SendMessage(hPlayIconStyleCombo, CB_ADDSTRING, 0, (LPARAM)L"Inverted");
        SendMessage(hPlayIconStyleCombo, CB_SETCURSEL, cfg_nowbar_play_icon_style, 0);

        // Grey out Play Icon Style when Alternate Icons is Style 2 or 3
        {
            BOOL enablePlayIcon = (cfg_nowbar_alternate_icons == 0) ? TRUE : FALSE;
            EnableWindow(GetDlgItem(hwnd, IDC_PLAY_ICON_STYLE_LABEL), enablePlayIcon);
            EnableWindow(GetDlgItem(hwnd, IDC_PLAY_ICON_STYLE_COMBO), enablePlayIcon);
        }

        // Initialize auto-hide C-buttons combobox
        HWND hAutohideCbuttonsCombo = GetDlgItem(hwnd, IDC_AUTOHIDE_CBUTTONS_COMBO);
        SendMessage(hAutohideCbuttonsCombo, CB_ADDSTRING, 0, (LPARAM)L"Yes");
        SendMessage(hAutohideCbuttonsCombo, CB_ADDSTRING, 0, (LPARAM)L"No");
        SendMessage(hAutohideCbuttonsCombo, CB_SETCURSEL, cfg_nowbar_cbutton_autohide ? 0 : 1, 0);

        // Initialize volume icon visibility combobox
        HWND hVolumeIconCombo = GetDlgItem(hwnd, IDC_VOLUME_ICON_COMBO);
        SendMessage(hVolumeIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hVolumeIconCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hVolumeIconCombo, CB_SETCURSEL, cfg_nowbar_volume_icon_visible ? 0 : 1, 0);

        // Initialize volume bar visibility combobox
        HWND hVolumeBarCombo = GetDlgItem(hwnd, IDC_VOLUME_BAR_COMBO);
        SendMessage(hVolumeBarCombo, CB_ADDSTRING, 0, (LPARAM)L"Show");
        SendMessage(hVolumeBarCombo, CB_ADDSTRING, 0, (LPARAM)L"Hidden");
        SendMessage(hVolumeBarCombo, CB_SETCURSEL, cfg_nowbar_volume_bar_visible ? 0 : 1, 0);

        // Initialize mood tag combobox
        HWND hMoodTagCombo = GetDlgItem(hwnd, IDC_MOOD_TAG_COMBO);
        SendMessage(hMoodTagCombo, CB_ADDSTRING, 0, (LPARAM)L"%FEEDBACK%");
        SendMessage(hMoodTagCombo, CB_ADDSTRING, 0, (LPARAM)L"%2003_LOVED%");
        SendMessage(hMoodTagCombo, CB_ADDSTRING, 0, (LPARAM)L"%LFM_LOVED%");
        SendMessage(hMoodTagCombo, CB_ADDSTRING, 0, (LPARAM)L"%SMP_LOVED%");
        SendMessage(hMoodTagCombo, CB_ADDSTRING, 0, (LPARAM)L"%MOOD%");
        SendMessage(hMoodTagCombo, CB_SETCURSEL, cfg_nowbar_mood_tag_mode, 0);

        // Initialize skip low rating combobox
        HWND hSkipLowRatingCombo = GetDlgItem(hwnd, IDC_SKIP_LOW_RATING_COMBO);
        SendMessage(hSkipLowRatingCombo, CB_ADDSTRING, 0, (LPARAM)L"Disabled");
        SendMessage(hSkipLowRatingCombo, CB_ADDSTRING, 0, (LPARAM)L"Enabled");
        SendMessage(hSkipLowRatingCombo, CB_SETCURSEL, cfg_nowbar_skip_low_rating_enabled ? 1 : 0, 0);

        // Initialize skip rating threshold combobox
        HWND hSkipRatingThresholdCombo = GetDlgItem(hwnd, IDC_SKIP_RATING_THRESHOLD_COMBO);
        SendMessage(hSkipRatingThresholdCombo, CB_ADDSTRING, 0, (LPARAM)L"1 (skip if rating = 1)");
        SendMessage(hSkipRatingThresholdCombo, CB_ADDSTRING, 0, (LPARAM)L"2 (skip if rating <= 2)");
        SendMessage(hSkipRatingThresholdCombo, CB_ADDSTRING, 0, (LPARAM)L"3 (skip if rating <= 3)");
        SendMessage(hSkipRatingThresholdCombo, CB_SETCURSEL, cfg_nowbar_skip_low_rating_threshold - 1, 0);
        // Enable/disable threshold combo based on skip low rating setting
        EnableWindow(hSkipRatingThresholdCombo, cfg_nowbar_skip_low_rating_enabled != 0);

        // Initialize Visualization section
        {
            int vis_mode = get_nowbar_visualization_mode();
            CheckDlgButton(hwnd, IDC_VIS_ENABLE_CHECK, (vis_mode != 0) ? BST_CHECKED : BST_UNCHECKED);
            CheckDlgButton(hwnd, IDC_VIS_60FPS_CHECK, cfg_nowbar_vis_60fps ? BST_CHECKED : BST_UNCHECKED);
            // Restore spectrum/waveform selection from the independent sub-mode setting
            // so the user's choice is remembered even when visualization is disabled.
            int vis_type = (vis_mode != 0) ? vis_mode : (int)cfg_nowbar_vis_type;
            CheckRadioButton(hwnd, IDC_VIS_SPECTRUM_RADIO, IDC_VIS_WAVEFORM_RADIO,
                (vis_type == 2) ? IDC_VIS_WAVEFORM_RADIO : IDC_VIS_SPECTRUM_RADIO);

            // Populate spectrum width combo (Thin/Normal/Wide)
            HWND hSpecWidth = GetDlgItem(hwnd, IDC_VIS_SPECTRUM_WIDTH_COMBO);
            SendMessage(hSpecWidth, CB_ADDSTRING, 0, (LPARAM)L"Thin");
            SendMessage(hSpecWidth, CB_ADDSTRING, 0, (LPARAM)L"Normal");
            SendMessage(hSpecWidth, CB_ADDSTRING, 0, (LPARAM)L"Wide");
            SendMessage(hSpecWidth, CB_SETCURSEL, cfg_nowbar_spectrum_width, 0);

            // Populate spectrum style combo (Bars/Curve/Dominoes)
            HWND hSpecStyle = GetDlgItem(hwnd, IDC_VIS_SPECTRUM_STYLE_COMBO);
            SendMessage(hSpecStyle, CB_ADDSTRING, 0, (LPARAM)L"Bars");
            SendMessage(hSpecStyle, CB_ADDSTRING, 0, (LPARAM)L"Curve");
            SendMessage(hSpecStyle, CB_ADDSTRING, 0, (LPARAM)L"Dominoes");
            SendMessage(hSpecStyle, CB_SETCURSEL, cfg_nowbar_spectrum_style, 0);

            // Populate spectrum height combo (Low/Normal/High)
            HWND hSpecHeight = GetDlgItem(hwnd, IDC_VIS_SPECTRUM_HEIGHT_COMBO);
            SendMessage(hSpecHeight, CB_ADDSTRING, 0, (LPARAM)L"Low");
            SendMessage(hSpecHeight, CB_ADDSTRING, 0, (LPARAM)L"Normal");
            SendMessage(hSpecHeight, CB_ADDSTRING, 0, (LPARAM)L"High");
            SendMessage(hSpecHeight, CB_SETCURSEL, cfg_nowbar_spectrum_height, 0);

            // Initialize spectrum opacity slider (0-100)
            HWND hOpacitySlider = GetDlgItem(hwnd, IDC_SPECTRUM_OPACITY_SLIDER);
            SendMessage(hOpacitySlider, TBM_SETRANGE, TRUE, MAKELPARAM(0, 100));
            SendMessage(hOpacitySlider, TBM_SETPOS, TRUE, cfg_nowbar_spectrum_opacity);
            {
                wchar_t buf[8];
                wsprintfW(buf, L"%d%%", (int)cfg_nowbar_spectrum_opacity);
                SetDlgItemTextW(hwnd, IDC_SPECTRUM_OPACITY_VALUE, buf);
            }

            // Initialize color mode combo
            {
                HWND hColorMode = GetDlgItem(hwnd, IDC_SPECTRUM_COLOR_MODE_COMBO);
                SendMessage(hColorMode, CB_ADDSTRING, 0, (LPARAM)L"Adaptive");
                SendMessage(hColorMode, CB_ADDSTRING, 0, (LPARAM)L"Solid");
                SendMessage(hColorMode, CB_ADDSTRING, 0, (LPARAM)L"Gradient");
                SendMessage(hColorMode, CB_ADDSTRING, 0, (LPARAM)L"Frequency");
                SendMessage(hColorMode, CB_SETCURSEL, cfg_nowbar_spectrum_gradient_mode, 0);
            }

            // Populate waveform width combo (Thin/Wide/Wide (4K))
            HWND hWaveWidth = GetDlgItem(hwnd, IDC_VIS_WAVEFORM_WIDTH_COMBO);
            SendMessage(hWaveWidth, CB_ADDSTRING, 0, (LPARAM)L"Thin");
            SendMessage(hWaveWidth, CB_ADDSTRING, 0, (LPARAM)L"Wide");
            SendMessage(hWaveWidth, CB_ADDSTRING, 0, (LPARAM)L"Wide (4K)");
            SendMessage(hWaveWidth, CB_SETCURSEL, cfg_nowbar_waveform_width, 0);

            // Initialize waveform style radio buttons (1 vs 2)
            CheckRadioButton(hwnd, IDC_VIS_WAVEFORM_STYLE_1, IDC_VIS_WAVEFORM_STYLE_2,
                (cfg_nowbar_waveform_style == 1) ? IDC_VIS_WAVEFORM_STYLE_2 : IDC_VIS_WAVEFORM_STYLE_1);

            update_vis_section_state(hwnd);
        }

        // Initialize font displays
        p_this->update_font_displays();

        // Initialize color custom checkboxes
        CheckDlgButton(hwnd, IDC_CUSTOM_BUTTON_ACCENT_CHECK, cfg_custom_button_accent_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_PLAY_ACCENT_CHECK, cfg_custom_play_accent_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_PROGRESS_ACCENT_CHECK, cfg_custom_progress_accent_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_VOLUME_ACCENT_CHECK, cfg_custom_volume_accent_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_HOVER_COLOR_CHECK, cfg_custom_hover_color_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_SPECTRUM_COLOR_CHECK, cfg_custom_spectrum_color_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_WAVEFORM_COLOR_CHECK, cfg_custom_waveform_color_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_WAVEFORM_UNPLAYED_CHECK, cfg_custom_waveform_unplayed_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_PROGRESS_TRACK_CHECK, cfg_custom_progress_track_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CUSTOM_VOLUME_TRACK_CHECK, cfg_custom_volume_track_enabled ? BST_CHECKED : BST_UNCHECKED);
        update_color_buttons_state(hwnd);

        // Initialize Profile combobox for Custom Button tab
        {
            HWND hProfileCombo = GetDlgItem(hwnd, IDC_PROFILE_COMBO);
            auto profiles = get_all_profiles();
            pfc::string8 current_name = get_current_profile_name();
            int sel_index = 0;
            for (size_t i = 0; i < profiles.size(); i++) {
                pfc::stringcvt::string_wide_from_utf8 wide_name(profiles[i].name.c_str());
                SendMessage(hProfileCombo, CB_ADDSTRING, 0, (LPARAM)wide_name.get_ptr());
                if (stricmp_utf8(profiles[i].name.c_str(), current_name.c_str()) == 0) {
                    sel_index = (int)i;
                }
            }
            SendMessage(hProfileCombo, CB_SETCURSEL, sel_index, 0);
        }

        // Initialize Custom Button tab controls
        // Populate action comboboxes with choices
        int cbutton_action_combos[] = {IDC_CBUTTON1_ACTION, IDC_CBUTTON2_ACTION, IDC_CBUTTON3_ACTION, IDC_CBUTTON4_ACTION, IDC_CBUTTON5_ACTION, IDC_CBUTTON6_ACTION};

        for (int id : cbutton_action_combos) {
            HWND hCombo = GetDlgItem(hwnd, id);
            SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)L"None");
            SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)L"Open URL");
            SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)L"Run Executable");
            SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)L"Foobar2k Action");
            SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)L"Open Folder");
            SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)L"Output Device");
        }
        
        // Set checkbox and combobox states from config
        CheckDlgButton(hwnd, IDC_CBUTTON1_ENABLE, cfg_cbutton1_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CBUTTON2_ENABLE, cfg_cbutton2_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CBUTTON3_ENABLE, cfg_cbutton3_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CBUTTON4_ENABLE, cfg_cbutton4_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CBUTTON5_ENABLE, cfg_cbutton5_enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(hwnd, IDC_CBUTTON6_ENABLE, cfg_cbutton6_enabled ? BST_CHECKED : BST_UNCHECKED);
        SendMessage(GetDlgItem(hwnd, IDC_CBUTTON1_ACTION), CB_SETCURSEL, cfg_cbutton1_action, 0);
        SendMessage(GetDlgItem(hwnd, IDC_CBUTTON2_ACTION), CB_SETCURSEL, cfg_cbutton2_action, 0);
        SendMessage(GetDlgItem(hwnd, IDC_CBUTTON3_ACTION), CB_SETCURSEL, cfg_cbutton3_action, 0);
        SendMessage(GetDlgItem(hwnd, IDC_CBUTTON4_ACTION), CB_SETCURSEL, cfg_cbutton4_action, 0);
        SendMessage(GetDlgItem(hwnd, IDC_CBUTTON5_ACTION), CB_SETCURSEL, cfg_cbutton5_action, 0);
        SendMessage(GetDlgItem(hwnd, IDC_CBUTTON6_ACTION), CB_SETCURSEL, cfg_cbutton6_action, 0);
        
        // Initialize path edit boxes
        uSetDlgItemText(hwnd, IDC_CBUTTON1_PATH, cfg_cbutton1_path);
        uSetDlgItemText(hwnd, IDC_CBUTTON2_PATH, cfg_cbutton2_path);
        uSetDlgItemText(hwnd, IDC_CBUTTON3_PATH, cfg_cbutton3_path);
        uSetDlgItemText(hwnd, IDC_CBUTTON4_PATH, cfg_cbutton4_path);
        uSetDlgItemText(hwnd, IDC_CBUTTON5_PATH, cfg_cbutton5_path);
        uSetDlgItemText(hwnd, IDC_CBUTTON6_PATH, cfg_cbutton6_path);
        
        // Initialize glyph comboboxes and size comboboxes
        {
            const wchar_t* size_presets[] = {
                L"50", L"60", L"70", L"80", L"90", L"100", L"120"
            };
            for (int btn = 0; btn < 6; btn++) {
                // Set current glyph value (accepts Unicode chars or U+XXXX notation)
                HWND hGlyph = GetDlgItem(hwnd, IDC_CBUTTON1_ICON + btn * 3);
                pfc::string8 cur_glyph = get_nowbar_cbutton_icon_path(btn);
                pfc::stringcvt::string_wide_from_utf8 wide_glyph(cur_glyph);
                SetWindowTextW(hGlyph, wide_glyph);

                // Populate size combobox with presets and set current value
                HWND hSize = GetDlgItem(hwnd, IDC_CBUTTON1_GLYPH_SIZE + btn * 3);
                for (auto* s : size_presets)
                    SendMessageW(hSize, CB_ADDSTRING, 0, (LPARAM)s);
                SetDlgItemInt(hwnd, IDC_CBUTTON1_GLYPH_SIZE + btn * 3, get_nowbar_cbutton_glyph_size(btn), FALSE);

                // Populate font combobox with presets and set current value
                HWND hFont = GetDlgItem(hwnd, IDC_CBUTTON1_FONT + btn);
                const wchar_t* font_presets[] = {
                    L"Segoe UI", L"Segoe MDL2 Assets", L"Segoe Fluent Icons",
                    L"Segoe UI Symbol", L"Material Icons Outlined",
                    L"Material Icons", L"Wingdings", L"Webdings"
                };
                for (auto* f : font_presets)
                    SendMessageW(hFont, CB_ADDSTRING, 0, (LPARAM)f);
                pfc::string8 cur_font = get_nowbar_cbutton_font(btn);
                pfc::stringcvt::string_wide_from_utf8 wide_font(cur_font);
                SetWindowTextW(hFont, wide_font);
            }
        }

        // Initialize tooltip label edit boxes
        uSetDlgItemText(hwnd, IDC_CBUTTON1_LABEL, cfg_cbutton1_label);
        uSetDlgItemText(hwnd, IDC_CBUTTON2_LABEL, cfg_cbutton2_label);
        uSetDlgItemText(hwnd, IDC_CBUTTON3_LABEL, cfg_cbutton3_label);
        uSetDlgItemText(hwnd, IDC_CBUTTON4_LABEL, cfg_cbutton4_label);
        uSetDlgItemText(hwnd, IDC_CBUTTON5_LABEL, cfg_cbutton5_label);
        uSetDlgItemText(hwnd, IDC_CBUTTON6_LABEL, cfg_cbutton6_label);

        // Update path control states based on action selection
        update_all_cbutton_path_states(hwnd);
        
        // Initialize About tab text
        {
            wchar_t about_name[128];
            swprintf_s(about_name, L"foo_nowbar v%hs", FOO_NOWBAR_VERSION_STRING);
            SetDlgItemTextW(hwnd, IDC_ABOUT_NAME, about_name);
            wchar_t about_desc[256];
            swprintf_s(about_desc, L"%hs", FOO_NOWBAR_DESCRIPTION);
            SetDlgItemTextW(hwnd, IDC_ABOUT_DESCRIPTION, about_desc);
        }

        SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
        RedrawWindow(hwnd, nullptr, nullptr, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
        
        p_this->m_has_changes = false;
    } else {
        p_this = reinterpret_cast<nowbar_preferences*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
    }
    
    if (p_this == nullptr) return FALSE;
    
    switch (msg) {
    case WM_COMMAND:
        switch (LOWORD(wp)) {
        case IDC_THEME_MODE_COMBO:
        case IDC_SMOOTH_ANIMATIONS_COMBO:
        case IDC_BACKGROUND_STYLE_COMBO:
        case IDC_BAR_STYLE_COMBO:
        case IDC_SEEKBAR_VISIBLE_COMBO:
        case IDC_SEEKBAR_LENGTH_COMBO:
        case IDC_COVER_MARGIN_COMBO:
        case IDC_COVER_STYLE_COMBO:
        case IDC_MOOD_ICON_COMBO:
        case IDC_SHUFFLE_ICON_COMBO:
        case IDC_REPEAT_ICON_COMBO:
        case IDC_STOP_ICON_COMBO:
        case IDC_STOP_AFTER_CURRENT_COMBO:
        case IDC_SUPER_ICON_COMBO:
        case IDC_MINIPLAYER_ICON_COMBO:
        case IDC_HOVER_CIRCLES_COMBO:
        case IDC_PLAY_ICON_STYLE_COMBO:
        case IDC_AUTOHIDE_CBUTTONS_COMBO:
        case IDC_CBUTTON_3D_COMBO:
        case IDC_VOLUME_NUMBER_COMBO:
        case IDC_PLAYBACK_TIME_COMBO:
        case IDC_VOLUME_ICON_COMBO:
        case IDC_VOLUME_BAR_COMBO:
        case IDC_MOOD_TAG_COMBO:
        case IDC_SKIP_RATING_THRESHOLD_COMBO:
        case IDC_VIS_SPECTRUM_WIDTH_COMBO:
        case IDC_VIS_SPECTRUM_HEIGHT_COMBO:
        case IDC_VIS_WAVEFORM_WIDTH_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                p_this->on_changed();
            }
            break;

        case IDC_ALTERNATE_ICONS_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                // Grey out Play Icon Style when Alternate Icons is Style 2 or 3
                int sel = (int)SendMessage((HWND)lp, CB_GETCURSEL, 0, 0);
                BOOL enable = (sel == 0) ? TRUE : FALSE;
                EnableWindow(GetDlgItem(hwnd, IDC_PLAY_ICON_STYLE_LABEL), enable);
                EnableWindow(GetDlgItem(hwnd, IDC_PLAY_ICON_STYLE_COMBO), enable);
                p_this->on_changed();
            }
            break;

        case IDC_RATING_STARS_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                // Grey out Line 3 edit box when Rating Stars is set to "Line 3"
                int sel = (int)SendMessage((HWND)lp, CB_GETCURSEL, 0, 0);
                EnableWindow(GetDlgItem(hwnd, IDC_LINE3_FORMAT_EDIT), sel != 2);
                p_this->on_changed();
            }
            break;

        case IDC_VIS_SPECTRUM_STYLE_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                update_vis_section_state(hwnd);
                p_this->on_changed();
            }
            break;

        case IDC_SKIP_LOW_RATING_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                // Enable/disable threshold combo based on skip low rating setting
                int sel = (int)SendMessage(GetDlgItem(hwnd, IDC_SKIP_LOW_RATING_COMBO), CB_GETCURSEL, 0, 0);
                EnableWindow(GetDlgItem(hwnd, IDC_SKIP_RATING_THRESHOLD_COMBO), sel == 1);
                p_this->on_changed();
            }
            break;

        case IDC_VIS_ENABLE_CHECK:
            if (HIWORD(wp) == BN_CLICKED) {
                update_vis_section_state(hwnd);
                p_this->on_changed();
            }
            break;

        case IDC_VIS_SPECTRUM_RADIO:
        case IDC_VIS_WAVEFORM_RADIO:
            if (HIWORD(wp) == BN_CLICKED) {
                CheckRadioButton(hwnd, IDC_VIS_SPECTRUM_RADIO, IDC_VIS_WAVEFORM_RADIO, LOWORD(wp));
                update_vis_section_state(hwnd);
                p_this->on_changed();
            }
            break;

        case IDC_VIS_WAVEFORM_STYLE_1:
        case IDC_VIS_WAVEFORM_STYLE_2:
            if (HIWORD(wp) == BN_CLICKED) {
                CheckRadioButton(hwnd, IDC_VIS_WAVEFORM_STYLE_1, IDC_VIS_WAVEFORM_STYLE_2, LOWORD(wp));
                if (IsDlgButtonChecked(hwnd, IDC_VIS_WAVEFORM_RADIO) != BST_CHECKED) {
                    CheckRadioButton(hwnd, IDC_VIS_SPECTRUM_RADIO, IDC_VIS_WAVEFORM_RADIO, IDC_VIS_WAVEFORM_RADIO);
                }
                update_vis_section_state(hwnd);
                p_this->on_changed();
            }
            break;

        case IDC_VIS_60FPS_CHECK:
            if (HIWORD(wp) == BN_CLICKED) {
                p_this->on_changed();
            }
            break;

        case IDC_VIS_SPECTRUM_COLOR_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_spectrum_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_spectrum_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_VIS_SPECTRUM_COLOR_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_VIS_WAVEFORM_COLOR_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_waveform_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_waveform_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_COLOR_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_waveform_unplayed_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_waveform_unplayed_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_PROGRESS_TRACK_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_progress_track_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_progress_track_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_PROGRESS_TRACK_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_VOLUME_TRACK_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_volume_track_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_volume_track_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_VOLUME_TRACK_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_SPECTRUM_COLOR2_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_spectrum_color2.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_spectrum_color2 = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_SPECTRUM_COLOR2_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_COVER_ARTWORK_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                update_cover_margin_state(hwnd);
                p_this->on_changed();
            }
            break;
        case IDC_ONLINE_ARTWORK_CHECK:
            p_this->on_changed();
            break;
        case IDC_BUTTON_SCALING_CHECK:
            update_button_scaling_state(hwnd);
            {
                bool checked = (IsDlgButtonChecked(hwnd, IDC_BUTTON_SCALING_CHECK) == BST_CHECKED);
                int pos = (int)SendMessage(GetDlgItem(hwnd, IDC_BUTTON_SCALING_SLIDER), TBM_GETPOS, 0, 0);
                set_nowbar_button_scaling_preview(checked, pos);
            }
            p_this->on_changed();
            break;

        case IDC_LINE1_FORMAT_EDIT:
        case IDC_LINE2_FORMAT_EDIT:
        case IDC_LINE3_FORMAT_EDIT:
            if (HIWORD(wp) == EN_CHANGE) {
                p_this->on_changed();
            }
            break;

        case IDC_PROFILE_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {

                // Save current profile before switching
                auto profiles = get_all_profiles();
                pfc::string8 current_name = get_current_profile_name();
                CButtonProfile* current_profile = find_profile(profiles, current_name.c_str());
                if (current_profile) {
                    save_config_to_profile(*current_profile);
                    save_all_profiles(profiles);
                }
                
                // Load newly selected profile
                int sel = (int)SendMessage(GetDlgItem(hwnd, IDC_PROFILE_COMBO), CB_GETCURSEL, 0, 0);
                if (sel >= 0 && sel < (int)profiles.size()) {
                    load_profile_to_config(profiles[sel]);
                    set_current_profile_name(profiles[sel].name.c_str());
                    
                    // Update UI controls with new profile settings
                    CheckDlgButton(hwnd, IDC_CBUTTON1_ENABLE, cfg_cbutton1_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON2_ENABLE, cfg_cbutton2_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON3_ENABLE, cfg_cbutton3_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON4_ENABLE, cfg_cbutton4_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON5_ENABLE, cfg_cbutton5_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON6_ENABLE, cfg_cbutton6_enabled ? BST_CHECKED : BST_UNCHECKED);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON1_ACTION), CB_SETCURSEL, cfg_cbutton1_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON2_ACTION), CB_SETCURSEL, cfg_cbutton2_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON3_ACTION), CB_SETCURSEL, cfg_cbutton3_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON4_ACTION), CB_SETCURSEL, cfg_cbutton4_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON5_ACTION), CB_SETCURSEL, cfg_cbutton5_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON6_ACTION), CB_SETCURSEL, cfg_cbutton6_action, 0);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_PATH, cfg_cbutton1_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_PATH, cfg_cbutton2_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_PATH, cfg_cbutton3_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_PATH, cfg_cbutton4_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_PATH, cfg_cbutton5_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_PATH, cfg_cbutton6_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_ICON, cfg_cbutton1_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_ICON, cfg_cbutton2_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_ICON, cfg_cbutton3_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_ICON, cfg_cbutton4_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_ICON, cfg_cbutton5_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_ICON, cfg_cbutton6_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_FONT, cfg_cbutton1_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_FONT, cfg_cbutton2_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_FONT, cfg_cbutton3_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_FONT, cfg_cbutton4_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_FONT, cfg_cbutton5_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_FONT, cfg_cbutton6_font);
                    SetDlgItemInt(hwnd, IDC_CBUTTON1_GLYPH_SIZE, cfg_cbutton1_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON2_GLYPH_SIZE, cfg_cbutton2_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON3_GLYPH_SIZE, cfg_cbutton3_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON4_GLYPH_SIZE, cfg_cbutton4_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON5_GLYPH_SIZE, cfg_cbutton5_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON6_GLYPH_SIZE, cfg_cbutton6_glyph_size, FALSE);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_LABEL, cfg_cbutton1_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_LABEL, cfg_cbutton2_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_LABEL, cfg_cbutton3_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_LABEL, cfg_cbutton4_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_LABEL, cfg_cbutton5_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_LABEL, cfg_cbutton6_label);
                    update_all_cbutton_path_states(hwnd);
                    p_this->on_changed();
                }
            }
            break;




        case IDC_PROFILE_MENU_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                // Get profiles first to check count for menu state
                auto profiles = get_all_profiles();
                pfc::string8 current_name = get_current_profile_name();
                
                // Create and show popup menu
                HMENU hMenu = CreatePopupMenu();
                AppendMenu(hMenu, MF_STRING, 1, L"New");
                AppendMenu(hMenu, MF_STRING, 2, L"Rename");
                // Gray out Delete if only one profile exists
                AppendMenu(hMenu, (profiles.size() <= 1) ? (MF_STRING | MF_GRAYED) : MF_STRING, 3, L"Delete");
                AppendMenu(hMenu, MF_SEPARATOR, 0, nullptr);
                AppendMenu(hMenu, MF_STRING, 4, L"Export...");
                AppendMenu(hMenu, MF_STRING, 5, L"Import...");
                
                // Get button position for menu placement
                RECT rc;
                GetWindowRect(GetDlgItem(hwnd, IDC_PROFILE_MENU_BTN), &rc);
                
                int cmd = TrackPopupMenu(hMenu, TPM_RETURNCMD | TPM_LEFTBUTTON, rc.left, rc.bottom, 0, hwnd, nullptr);
                DestroyMenu(hMenu);
                
                switch (cmd) {
                case 1: { // New - show input dialog for profile name
                    // Generate a suggested unique name
                    pfc::string8 base_name = "Profile ";
                    int num = (int)profiles.size() + 1;
                    pfc::string8 suggested_name;
                    suggested_name << base_name << num;
                    while (find_profile(profiles, suggested_name.c_str())) {
                        num++;
                        suggested_name.reset();
                        suggested_name << base_name << num;
                    }
                    
                    // Show input dialog
                    pfc::stringcvt::string_wide_from_utf8 suggested_wide(suggested_name.c_str());
                    pfc::string8 new_name;
                    if (show_input_dialog(hwnd, L"New Profile", L"Enter profile name:", suggested_wide.get_ptr(), new_name)) {
                        // Check if name already exists
                        if (find_profile(profiles, new_name.c_str())) {
                            MessageBoxW(hwnd, L"A profile with this name already exists.", L"Error", MB_OK | MB_ICONWARNING);
                            break;
                        }
                        
                        // Save current settings to current profile first
                        CButtonProfile* current_profile = find_profile(profiles, current_name.c_str());
                        if (current_profile) {
                            save_config_to_profile(*current_profile);
                        }
                        
                        // Create new profile with current settings
                        CButtonProfile new_profile;
                        new_profile.name = new_name;
                        save_config_to_profile(new_profile);
                        profiles.push_back(new_profile);
                        save_all_profiles(profiles);
                        set_current_profile_name(new_name.c_str());
                        
                        // Update combobox
                        HWND hCombo = GetDlgItem(hwnd, IDC_PROFILE_COMBO);
                        pfc::stringcvt::string_wide_from_utf8 wide_name(new_name.c_str());
                        int new_idx = (int)SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)wide_name.get_ptr());
                        SendMessage(hCombo, CB_SETCURSEL, new_idx, 0);
                        p_this->on_changed();
                    }
                    break;
                }

                case 2: { // Rename - show input dialog at cursor position
                    CButtonProfile* prof = find_profile(profiles, current_name.c_str());
                    if (prof) {
                        pfc::stringcvt::string_wide_from_utf8 current_wide(current_name.c_str());
                        pfc::string8 new_name;
                        if (show_input_dialog(hwnd, L"Rename Profile", L"Enter new profile name:", current_wide.get_ptr(), new_name)) {
                            // Check if name already exists (and is different from current)
                            if (stricmp_utf8(new_name.c_str(), current_name.c_str()) != 0 &&
                                find_profile(profiles, new_name.c_str())) {
                                MessageBoxW(hwnd, L"A profile with this name already exists.", L"Error", MB_OK | MB_ICONWARNING);
                            } else if (!new_name.is_empty()) {
                                prof->name = new_name;
                                save_all_profiles(profiles);
                                set_current_profile_name(new_name.c_str());
                                
                                // Rebuild combobox
                                HWND hCombo = GetDlgItem(hwnd, IDC_PROFILE_COMBO);
                                SendMessage(hCombo, CB_RESETCONTENT, 0, 0);
                                for (size_t i = 0; i < profiles.size(); i++) {
                                    pfc::stringcvt::string_wide_from_utf8 wide_name(profiles[i].name.c_str());
                                    SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)wide_name.get_ptr());
                                    if (stricmp_utf8(profiles[i].name.c_str(), new_name.c_str()) == 0) {
                                        SendMessage(hCombo, CB_SETCURSEL, i, 0);
                                    }
                                }
                                // Update edit text for CBS_DROPDOWN
                                pfc::stringcvt::string_wide_from_utf8 new_wide(new_name.c_str());
                                SetWindowTextW(hCombo, new_wide.get_ptr());
                                p_this->on_changed();
                            }
                        }
                    }
                    break;
                }




                case 3: { // Delete
                    // Show confirmation dialog
                    pfc::stringcvt::string_wide_from_utf8 current_wide(current_name.c_str());
                    std::wstring confirm_msg = L"Are you sure you want to delete the profile \"";
                    confirm_msg += current_wide.get_ptr();
                    confirm_msg += L"\"?";
                    
                    if (MessageBoxW(hwnd, confirm_msg.c_str(), L"Delete Profile", MB_YESNO | MB_ICONQUESTION) != IDYES) {
                        break;  // User cancelled
                    }
                    
                    // Find and remove current profile

                    for (auto it = profiles.begin(); it != profiles.end(); ++it) {
                        if (stricmp_utf8(it->name.c_str(), current_name.c_str()) == 0) {
                            profiles.erase(it);
                            break;
                        }
                    }
                    save_all_profiles(profiles);
                    
                    // Switch to first remaining profile
                    if (!profiles.empty()) {
                        load_profile_to_config(profiles[0]);
                        set_current_profile_name(profiles[0].name.c_str());
                    }
                    
                    // Rebuild combobox
                    HWND hCombo = GetDlgItem(hwnd, IDC_PROFILE_COMBO);
                    SendMessage(hCombo, CB_RESETCONTENT, 0, 0);
                    for (size_t i = 0; i < profiles.size(); i++) {
                        pfc::stringcvt::string_wide_from_utf8 wide_name(profiles[i].name.c_str());
                        SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)wide_name.get_ptr());
                    }
                    SendMessage(hCombo, CB_SETCURSEL, 0, 0);
                    
                    // Update UI with new profile settings
                    CheckDlgButton(hwnd, IDC_CBUTTON1_ENABLE, cfg_cbutton1_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON2_ENABLE, cfg_cbutton2_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON3_ENABLE, cfg_cbutton3_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON4_ENABLE, cfg_cbutton4_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON5_ENABLE, cfg_cbutton5_enabled ? BST_CHECKED : BST_UNCHECKED);
                    CheckDlgButton(hwnd, IDC_CBUTTON6_ENABLE, cfg_cbutton6_enabled ? BST_CHECKED : BST_UNCHECKED);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON1_ACTION), CB_SETCURSEL, cfg_cbutton1_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON2_ACTION), CB_SETCURSEL, cfg_cbutton2_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON3_ACTION), CB_SETCURSEL, cfg_cbutton3_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON4_ACTION), CB_SETCURSEL, cfg_cbutton4_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON5_ACTION), CB_SETCURSEL, cfg_cbutton5_action, 0);
                    SendMessage(GetDlgItem(hwnd, IDC_CBUTTON6_ACTION), CB_SETCURSEL, cfg_cbutton6_action, 0);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_PATH, cfg_cbutton1_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_PATH, cfg_cbutton2_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_PATH, cfg_cbutton3_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_PATH, cfg_cbutton4_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_PATH, cfg_cbutton5_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_PATH, cfg_cbutton6_path);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_ICON, cfg_cbutton1_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_ICON, cfg_cbutton2_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_ICON, cfg_cbutton3_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_ICON, cfg_cbutton4_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_ICON, cfg_cbutton5_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_ICON, cfg_cbutton6_icon);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_FONT, cfg_cbutton1_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_FONT, cfg_cbutton2_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_FONT, cfg_cbutton3_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_FONT, cfg_cbutton4_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_FONT, cfg_cbutton5_font);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_FONT, cfg_cbutton6_font);
                    SetDlgItemInt(hwnd, IDC_CBUTTON1_GLYPH_SIZE, cfg_cbutton1_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON2_GLYPH_SIZE, cfg_cbutton2_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON3_GLYPH_SIZE, cfg_cbutton3_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON4_GLYPH_SIZE, cfg_cbutton4_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON5_GLYPH_SIZE, cfg_cbutton5_glyph_size, FALSE);
                    SetDlgItemInt(hwnd, IDC_CBUTTON6_GLYPH_SIZE, cfg_cbutton6_glyph_size, FALSE);
                    uSetDlgItemText(hwnd, IDC_CBUTTON1_LABEL, cfg_cbutton1_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON2_LABEL, cfg_cbutton2_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON3_LABEL, cfg_cbutton3_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON4_LABEL, cfg_cbutton4_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON5_LABEL, cfg_cbutton5_label);
                    uSetDlgItemText(hwnd, IDC_CBUTTON6_LABEL, cfg_cbutton6_label);
                    update_all_cbutton_path_states(hwnd);
                    p_this->on_changed();
                    break;
                }

                case 4: { // Export
                    CButtonProfile* prof = find_profile(profiles, current_name.c_str());
                    if (prof) {
                        wchar_t filename[MAX_PATH] = L"";
                        pfc::stringcvt::string_wide_from_utf8 default_name(current_name.c_str());
                        wcsncpy_s(filename, default_name.get_ptr(), MAX_PATH - 1);
                        wcscat_s(filename, L".json");
                        
                        OPENFILENAMEW ofn = {};
                        ofn.lStructSize = sizeof(ofn);
                        ofn.hwndOwner = hwnd;
                        ofn.lpstrFilter = L"JSON Files (*.json)\0*.json\0All Files (*.*)\0*.*\0";
                        ofn.lpstrFile = filename;
                        ofn.nMaxFile = MAX_PATH;
                        ofn.Flags = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST;
                        ofn.lpstrDefExt = L"json";
                        
                        if (GetSaveFileNameW(&ofn)) {
                            if (export_profile_to_file(*prof, filename)) {
                                MessageBoxW(hwnd, L"Profile exported successfully.", L"Export", MB_OK | MB_ICONINFORMATION);
                            } else {
                                MessageBoxW(hwnd, L"Failed to export profile.", L"Error", MB_OK | MB_ICONERROR);
                            }
                        }
                    }
                    break;
                }
                case 5: { // Import
                    wchar_t filename[MAX_PATH] = L"";
                    OPENFILENAMEW ofn = {};
                    ofn.lStructSize = sizeof(ofn);
                    ofn.hwndOwner = hwnd;
                    ofn.lpstrFilter = L"JSON Files (*.json)\0*.json\0All Files (*.*)\0*.*\0";
                    ofn.lpstrFile = filename;
                    ofn.nMaxFile = MAX_PATH;
                    ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
                    
                    if (GetOpenFileNameW(&ofn)) {
                        CButtonProfile imported;
                        if (import_profile_from_file(filename, imported)) {
                            // Check for name collision
                            pfc::string8 import_name = imported.name;
                            int suffix = 1;
                            while (find_profile(profiles, import_name.c_str())) {
                                import_name.reset();
                                import_name << imported.name << " (" << suffix << ")";
                                suffix++;
                            }
                            imported.name = import_name;
                            
                            // Save current profile first
                            CButtonProfile* current_profile = find_profile(profiles, current_name.c_str());
                            if (current_profile) {
                                save_config_to_profile(*current_profile);
                            }
                            
                            // Add imported profile
                            profiles.push_back(imported);
                            save_all_profiles(profiles);
                            
                            // Load imported profile
                            load_profile_to_config(imported);
                            set_current_profile_name(imported.name.c_str());
                            
                            // Rebuild combobox
                            HWND hCombo = GetDlgItem(hwnd, IDC_PROFILE_COMBO);
                            SendMessage(hCombo, CB_RESETCONTENT, 0, 0);
                            int new_sel = 0;
                            for (size_t i = 0; i < profiles.size(); i++) {
                                pfc::stringcvt::string_wide_from_utf8 wide_name(profiles[i].name.c_str());
                                SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)wide_name.get_ptr());
                                if (stricmp_utf8(profiles[i].name.c_str(), imported.name.c_str()) == 0) {
                                    new_sel = (int)i;
                                }
                            }
                            SendMessage(hCombo, CB_SETCURSEL, new_sel, 0);
                            
                            // Update UI
                            CheckDlgButton(hwnd, IDC_CBUTTON1_ENABLE, cfg_cbutton1_enabled ? BST_CHECKED : BST_UNCHECKED);
                            CheckDlgButton(hwnd, IDC_CBUTTON2_ENABLE, cfg_cbutton2_enabled ? BST_CHECKED : BST_UNCHECKED);
                            CheckDlgButton(hwnd, IDC_CBUTTON3_ENABLE, cfg_cbutton3_enabled ? BST_CHECKED : BST_UNCHECKED);
                            CheckDlgButton(hwnd, IDC_CBUTTON4_ENABLE, cfg_cbutton4_enabled ? BST_CHECKED : BST_UNCHECKED);
                            CheckDlgButton(hwnd, IDC_CBUTTON5_ENABLE, cfg_cbutton5_enabled ? BST_CHECKED : BST_UNCHECKED);
                            CheckDlgButton(hwnd, IDC_CBUTTON6_ENABLE, cfg_cbutton6_enabled ? BST_CHECKED : BST_UNCHECKED);
                            SendMessage(GetDlgItem(hwnd, IDC_CBUTTON1_ACTION), CB_SETCURSEL, cfg_cbutton1_action, 0);
                            SendMessage(GetDlgItem(hwnd, IDC_CBUTTON2_ACTION), CB_SETCURSEL, cfg_cbutton2_action, 0);
                            SendMessage(GetDlgItem(hwnd, IDC_CBUTTON3_ACTION), CB_SETCURSEL, cfg_cbutton3_action, 0);
                            SendMessage(GetDlgItem(hwnd, IDC_CBUTTON4_ACTION), CB_SETCURSEL, cfg_cbutton4_action, 0);
                            SendMessage(GetDlgItem(hwnd, IDC_CBUTTON5_ACTION), CB_SETCURSEL, cfg_cbutton5_action, 0);
                            SendMessage(GetDlgItem(hwnd, IDC_CBUTTON6_ACTION), CB_SETCURSEL, cfg_cbutton6_action, 0);
                            uSetDlgItemText(hwnd, IDC_CBUTTON1_PATH, cfg_cbutton1_path);
                            uSetDlgItemText(hwnd, IDC_CBUTTON2_PATH, cfg_cbutton2_path);
                            uSetDlgItemText(hwnd, IDC_CBUTTON3_PATH, cfg_cbutton3_path);
                            uSetDlgItemText(hwnd, IDC_CBUTTON4_PATH, cfg_cbutton4_path);
                            uSetDlgItemText(hwnd, IDC_CBUTTON5_PATH, cfg_cbutton5_path);
                            uSetDlgItemText(hwnd, IDC_CBUTTON6_PATH, cfg_cbutton6_path);
                            uSetDlgItemText(hwnd, IDC_CBUTTON1_ICON, cfg_cbutton1_icon);
                            uSetDlgItemText(hwnd, IDC_CBUTTON2_ICON, cfg_cbutton2_icon);
                            uSetDlgItemText(hwnd, IDC_CBUTTON3_ICON, cfg_cbutton3_icon);
                            uSetDlgItemText(hwnd, IDC_CBUTTON4_ICON, cfg_cbutton4_icon);
                            uSetDlgItemText(hwnd, IDC_CBUTTON5_ICON, cfg_cbutton5_icon);
                            uSetDlgItemText(hwnd, IDC_CBUTTON6_ICON, cfg_cbutton6_icon);
                            uSetDlgItemText(hwnd, IDC_CBUTTON1_FONT, cfg_cbutton1_font);
                            uSetDlgItemText(hwnd, IDC_CBUTTON2_FONT, cfg_cbutton2_font);
                            uSetDlgItemText(hwnd, IDC_CBUTTON3_FONT, cfg_cbutton3_font);
                            uSetDlgItemText(hwnd, IDC_CBUTTON4_FONT, cfg_cbutton4_font);
                            uSetDlgItemText(hwnd, IDC_CBUTTON5_FONT, cfg_cbutton5_font);
                            uSetDlgItemText(hwnd, IDC_CBUTTON6_FONT, cfg_cbutton6_font);
                            SetDlgItemInt(hwnd, IDC_CBUTTON1_GLYPH_SIZE, cfg_cbutton1_glyph_size, FALSE);
                            SetDlgItemInt(hwnd, IDC_CBUTTON2_GLYPH_SIZE, cfg_cbutton2_glyph_size, FALSE);
                            SetDlgItemInt(hwnd, IDC_CBUTTON3_GLYPH_SIZE, cfg_cbutton3_glyph_size, FALSE);
                            SetDlgItemInt(hwnd, IDC_CBUTTON4_GLYPH_SIZE, cfg_cbutton4_glyph_size, FALSE);
                            SetDlgItemInt(hwnd, IDC_CBUTTON5_GLYPH_SIZE, cfg_cbutton5_glyph_size, FALSE);
                            SetDlgItemInt(hwnd, IDC_CBUTTON6_GLYPH_SIZE, cfg_cbutton6_glyph_size, FALSE);
                            uSetDlgItemText(hwnd, IDC_CBUTTON1_LABEL, cfg_cbutton1_label);
                            uSetDlgItemText(hwnd, IDC_CBUTTON2_LABEL, cfg_cbutton2_label);
                            uSetDlgItemText(hwnd, IDC_CBUTTON3_LABEL, cfg_cbutton3_label);
                            uSetDlgItemText(hwnd, IDC_CBUTTON4_LABEL, cfg_cbutton4_label);
                            uSetDlgItemText(hwnd, IDC_CBUTTON5_LABEL, cfg_cbutton5_label);
                            uSetDlgItemText(hwnd, IDC_CBUTTON6_LABEL, cfg_cbutton6_label);
                            update_all_cbutton_path_states(hwnd);
                            p_this->on_changed();

                            MessageBoxW(hwnd, L"Profile imported successfully.", L"Import", MB_OK | MB_ICONINFORMATION);
                        } else {
                            MessageBoxW(hwnd, L"Failed to import profile. Invalid file format.", L"Error", MB_OK | MB_ICONERROR);
                        }
                    }
                    break;
                }
                }
            }
            break;

        case IDC_CBUTTON1_ACTION:
        case IDC_CBUTTON2_ACTION:
        case IDC_CBUTTON3_ACTION:
        case IDC_CBUTTON4_ACTION:
        case IDC_CBUTTON5_ACTION:
        case IDC_CBUTTON6_ACTION:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                p_this->on_changed();
                // Update path control states when action changes
                update_all_cbutton_path_states(hwnd);
            }
            break;

        case IDC_CBUTTON1_ENABLE:
        case IDC_CBUTTON2_ENABLE:
        case IDC_CBUTTON3_ENABLE:
        case IDC_CBUTTON4_ENABLE:
        case IDC_CBUTTON5_ENABLE:
        case IDC_CBUTTON6_ENABLE:
            if (HIWORD(wp) == BN_CLICKED) {
                p_this->on_changed();
            }
            break;

        case IDC_CBUTTON1_PATH:
        case IDC_CBUTTON2_PATH:
        case IDC_CBUTTON3_PATH:
        case IDC_CBUTTON4_PATH:
        case IDC_CBUTTON5_PATH:
        case IDC_CBUTTON6_PATH:
            if (HIWORD(wp) == EN_CHANGE) {
                p_this->on_changed();
            }
            break;

        case IDC_CBUTTON1_BROWSE:
        case IDC_CBUTTON2_BROWSE:
        case IDC_CBUTTON3_BROWSE:
        case IDC_CBUTTON4_BROWSE:
        case IDC_CBUTTON5_BROWSE:
        case IDC_CBUTTON6_BROWSE:
            if (HIWORD(wp) == BN_CLICKED) {
                int path_id = 0;
                switch (LOWORD(wp)) {
                    case IDC_CBUTTON1_BROWSE: path_id = IDC_CBUTTON1_PATH; break;
                    case IDC_CBUTTON2_BROWSE: path_id = IDC_CBUTTON2_PATH; break;
                    case IDC_CBUTTON3_BROWSE: path_id = IDC_CBUTTON3_PATH; break;
                    case IDC_CBUTTON4_BROWSE: path_id = IDC_CBUTTON4_PATH; break;
                    case IDC_CBUTTON5_BROWSE: path_id = IDC_CBUTTON5_PATH; break;
                    case IDC_CBUTTON6_BROWSE: path_id = IDC_CBUTTON6_PATH; break;
                }
                wchar_t filename[MAX_PATH] = L"";
                OPENFILENAMEW ofn = {};
                ofn.lStructSize = sizeof(ofn);
                ofn.hwndOwner = hwnd;
                ofn.lpstrFilter = L"Executable Files (*.exe)\0*.exe\0All Files (*.*)\0*.*\0";
                ofn.lpstrFile = filename;
                ofn.nMaxFile = MAX_PATH;
                ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
                if (GetOpenFileNameW(&ofn)) {
                    SetDlgItemTextW(hwnd, path_id, filename);
                    p_this->on_changed();
                }
            }
            break;

        // Glyph edit changes
        case IDC_CBUTTON1_ICON:
        case IDC_CBUTTON2_ICON:
        case IDC_CBUTTON3_ICON:
        case IDC_CBUTTON4_ICON:
        case IDC_CBUTTON5_ICON:
        case IDC_CBUTTON6_ICON:
            if (HIWORD(wp) == EN_CHANGE) {
                p_this->on_changed();
            }
            break;

        // Tooltip label edit changes
        case IDC_CBUTTON1_LABEL:
        case IDC_CBUTTON2_LABEL:
        case IDC_CBUTTON3_LABEL:
        case IDC_CBUTTON4_LABEL:
        case IDC_CBUTTON5_LABEL:
        case IDC_CBUTTON6_LABEL:
            if (HIWORD(wp) == EN_CHANGE) {
                p_this->on_changed();
            }
            break;

        // Font combobox changes
        case IDC_CBUTTON1_FONT:
        case IDC_CBUTTON2_FONT:
        case IDC_CBUTTON3_FONT:
        case IDC_CBUTTON4_FONT:
        case IDC_CBUTTON5_FONT:
        case IDC_CBUTTON6_FONT:
            if (HIWORD(wp) == CBN_EDITCHANGE || HIWORD(wp) == CBN_SELCHANGE) {
                p_this->on_changed();
            }
            break;

        // Size combobox changes
        case IDC_CBUTTON1_GLYPH_SIZE:
        case IDC_CBUTTON2_GLYPH_SIZE:
        case IDC_CBUTTON3_GLYPH_SIZE:
        case IDC_CBUTTON4_GLYPH_SIZE:
        case IDC_CBUTTON5_GLYPH_SIZE:
        case IDC_CBUTTON6_GLYPH_SIZE:
            if (HIWORD(wp) == CBN_EDITCHANGE || HIWORD(wp) == CBN_SELCHANGE) {
                p_this->on_changed();
            }
            break;

        case IDC_TRACK_FONT_SELECT:
            if (HIWORD(wp) == BN_CLICKED) {
                p_this->select_track_font();
            }
            break;
            
        case IDC_ARTIST_FONT_SELECT:
            if (HIWORD(wp) == BN_CLICKED) {
                p_this->select_artist_font();
            }
            break;

        case IDC_LINE3_FONT_SELECT:
            if (HIWORD(wp) == BN_CLICKED) {
                p_this->select_line3_font();
            }
            break;

        case IDC_TIME_FONT_SELECT:
            if (HIWORD(wp) == BN_CLICKED) {
                p_this->select_time_font();
            }
            break;

        case IDC_BUTTON_ACCENT_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_button_accent_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_button_accent_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_BUTTON_ACCENT_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_PROGRESS_ACCENT_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_progress_accent_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_progress_accent_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_PROGRESS_ACCENT_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_VOLUME_ACCENT_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_volume_accent_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_volume_accent_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_VOLUME_ACCENT_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_PLAY_ACCENT_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_play_accent_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_play_accent_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_PLAY_ACCENT_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_HOVER_COLOR_BTN:
            if (HIWORD(wp) == BN_CLICKED) {
                COLORREF color = static_cast<COLORREF>(cfg_nowbar_hover_color.get_value());
                if (show_color_picker(hwnd, color)) {
                    cfg_nowbar_hover_color = color;
                    InvalidateRect(GetDlgItem(hwnd, IDC_HOVER_COLOR_BTN), nullptr, TRUE);
                    p_this->on_changed();
                }
            }
            break;

        case IDC_CUSTOM_BUTTON_ACCENT_CHECK:
        case IDC_CUSTOM_PLAY_ACCENT_CHECK:
        case IDC_CUSTOM_PROGRESS_ACCENT_CHECK:
        case IDC_CUSTOM_VOLUME_ACCENT_CHECK:
        case IDC_CUSTOM_HOVER_COLOR_CHECK:
        case IDC_CUSTOM_SPECTRUM_COLOR_CHECK:
        case IDC_CUSTOM_WAVEFORM_COLOR_CHECK:
        case IDC_CUSTOM_WAVEFORM_UNPLAYED_CHECK:
        case IDC_CUSTOM_PROGRESS_TRACK_CHECK:
        case IDC_CUSTOM_VOLUME_TRACK_CHECK:
            if (HIWORD(wp) == BN_CLICKED) {
                update_color_buttons_state(hwnd);
                p_this->on_changed();
            }
            break;

        case IDC_SPECTRUM_COLOR_MODE_COMBO:
            if (HIWORD(wp) == CBN_SELCHANGE) {
                update_color_buttons_state(hwnd);
                p_this->on_changed();
            }
            break;
        }
        break;

    case WM_HSCROLL:
        if ((HWND)lp == GetDlgItem(hwnd, IDC_SPECTRUM_OPACITY_SLIDER)) {
            int pos = (int)SendMessage(GetDlgItem(hwnd, IDC_SPECTRUM_OPACITY_SLIDER), TBM_GETPOS, 0, 0);
            wchar_t buf[8];
            wsprintfW(buf, L"%d%%", pos);
            SetDlgItemTextW(hwnd, IDC_SPECTRUM_OPACITY_VALUE, buf);
            p_this->on_changed();
        }
        if ((HWND)lp == GetDlgItem(hwnd, IDC_SEEKBAR_POSITION_SLIDER)) {
            int pos = (int)SendMessage(GetDlgItem(hwnd, IDC_SEEKBAR_POSITION_SLIDER), TBM_GETPOS, 0, 0);
            int offset = pos - 100;
            wchar_t buf[8];
            if (offset > 0)
                wsprintfW(buf, L"+%d", offset);
            else
                wsprintfW(buf, L"%d", offset);
            SetDlgItemTextW(hwnd, IDC_SEEKBAR_POSITION_VALUE, buf);
            p_this->on_changed();
        }
        if ((HWND)lp == GetDlgItem(hwnd, IDC_BUTTON_SCALING_SLIDER)) {
            int pos = (int)SendMessage(GetDlgItem(hwnd, IDC_BUTTON_SCALING_SLIDER), TBM_GETPOS, 0, 0);
            wchar_t buf[8];
            wsprintfW(buf, L"%d%%", pos);
            SetDlgItemTextW(hwnd, IDC_BUTTON_SCALING_VALUE, buf);
            bool checked = (IsDlgButtonChecked(hwnd, IDC_BUTTON_SCALING_CHECK) == BST_CHECKED);
            set_nowbar_button_scaling_preview(checked, pos);
            p_this->on_changed();
        }
        break;

    case WM_DRAWITEM:
        {
            DRAWITEMSTRUCT* dis = reinterpret_cast<DRAWITEMSTRUCT*>(lp);
            if (dis->CtlID == IDC_BUTTON_ACCENT_BTN || dis->CtlID == IDC_PROGRESS_ACCENT_BTN ||
                dis->CtlID == IDC_VOLUME_ACCENT_BTN || dis->CtlID == IDC_PLAY_ACCENT_BTN ||
                dis->CtlID == IDC_HOVER_COLOR_BTN ||
                dis->CtlID == IDC_VIS_SPECTRUM_COLOR_BTN || dis->CtlID == IDC_VIS_WAVEFORM_COLOR_BTN ||
                dis->CtlID == IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN ||
                dis->CtlID == IDC_PROGRESS_TRACK_BTN || dis->CtlID == IDC_VOLUME_TRACK_BTN ||
                dis->CtlID == IDC_SPECTRUM_COLOR2_BTN) {
                COLORREF color;
                if (dis->CtlID == IDC_BUTTON_ACCENT_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_button_accent_color.get_value());
                } else if (dis->CtlID == IDC_PROGRESS_ACCENT_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_progress_accent_color.get_value());
                } else if (dis->CtlID == IDC_PLAY_ACCENT_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_play_accent_color.get_value());
                } else if (dis->CtlID == IDC_HOVER_COLOR_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_hover_color.get_value());
                } else if (dis->CtlID == IDC_VIS_SPECTRUM_COLOR_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_spectrum_color.get_value());
                } else if (dis->CtlID == IDC_VIS_WAVEFORM_COLOR_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_waveform_color.get_value());
                } else if (dis->CtlID == IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_waveform_unplayed_color.get_value());
                } else if (dis->CtlID == IDC_PROGRESS_TRACK_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_progress_track_color.get_value());
                } else if (dis->CtlID == IDC_VOLUME_TRACK_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_volume_track_color.get_value());
                } else if (dis->CtlID == IDC_SPECTRUM_COLOR2_BTN) {
                    color = static_cast<COLORREF>(cfg_nowbar_spectrum_color2.get_value());
                } else {
                    color = static_cast<COLORREF>(cfg_nowbar_volume_accent_color.get_value());
                }
                HBRUSH hBrush = CreateSolidBrush(color);
                FillRect(dis->hDC, &dis->rcItem, hBrush);
                DeleteObject(hBrush);
                // Draw border
                FrameRect(dis->hDC, &dis->rcItem, (HBRUSH)GetStockObject(BLACK_BRUSH));
                return TRUE;
            }
        }
        break;

    case WM_NOTIFY:
        {
            NMHDR* pnmhdr = reinterpret_cast<NMHDR*>(lp);
            if (pnmhdr->idFrom == IDC_TAB_CONTROL && pnmhdr->code == TCN_SELCHANGE) {
                int sel = TabCtrl_GetCurSel(pnmhdr->hwndFrom);
                p_this->switch_tab(sel);
            }
            else if ((pnmhdr->idFrom == IDC_FOO_ARTWORK_LINK || pnmhdr->idFrom == IDC_FOO_TRAYCONTROLS_LINK ||
                      pnmhdr->idFrom == IDC_ABOUT_REPO_LINK || pnmhdr->idFrom == IDC_ABOUT_DONATE_LINK ||
                      pnmhdr->idFrom == IDC_ABOUT_FOO_ARTWORK_LINK || pnmhdr->idFrom == IDC_ABOUT_FOO_TRAYCONTROLS_LINK) &&
                     (pnmhdr->code == NM_CLICK || pnmhdr->code == NM_RETURN)) {
                NMLINK* pnmlink = reinterpret_cast<NMLINK*>(lp);
                ShellExecuteW(nullptr, L"open", pnmlink->item.szUrl, nullptr, nullptr, SW_SHOWNORMAL);
            }
        }
        break;
        
    case WM_DESTROY:
        if (s_preview_button_scaling_enabled >= 0 || s_preview_button_scaling_percent >= 0) {
            clear_nowbar_button_scaling_preview();
            nowbar::ControlPanelCore::notify_all_settings_changed();
        }
        p_this->m_hwnd = nullptr;
        break;
    }
    
    return FALSE;
}

void nowbar_preferences::on_changed() {
    m_has_changes = true;
    m_callback->on_state_changed();
}

void nowbar_preferences::apply_settings() {
    if (m_hwnd) {
        // Save display format strings
        pfc::string8 format_str;
        uGetDlgItemText(m_hwnd, IDC_LINE1_FORMAT_EDIT, format_str);
        cfg_nowbar_line1_format = format_str;
        uGetDlgItemText(m_hwnd, IDC_LINE2_FORMAT_EDIT, format_str);
        cfg_nowbar_line2_format = format_str;
        uGetDlgItemText(m_hwnd, IDC_LINE3_FORMAT_EDIT, format_str);
        cfg_nowbar_line3_format = format_str;

        // Save theme mode — reset custom font colors when theme changes
        {
            int old_theme = cfg_nowbar_theme_mode;
            int new_theme = (int)SendMessage(GetDlgItem(m_hwnd, IDC_THEME_MODE_COMBO), CB_GETCURSEL, 0, 0);
            if (new_theme != old_theme) {
                cfg_nowbar_track_font_color = -1;
                cfg_nowbar_artist_font_color = -1;
                cfg_nowbar_line3_font_color = -1;
                cfg_nowbar_time_font_color = -1;
            }
            cfg_nowbar_theme_mode = new_theme;
        }
        
        // Save smooth animations (0=Enabled, 1=Disabled in combobox -> config 1=Enabled, 0=Disabled)
        int smoothAnimSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SMOOTH_ANIMATIONS_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_smooth_animations = (smoothAnimSel == 0) ? 1 : 0;

        // Save 3D Buttons setting (0=Enabled, 1=Disabled in combobox -> config 1=Enabled, 0=Disabled)
        int threeDButtonsSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON_3D_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_3d_buttons = (threeDButtonsSel == 0) ? 1 : 0;

        // Save Volume Number setting (0=Disabled, 1=Enabled in combobox -> config 0=Disabled, 1=Enabled)
        int volNumSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VOLUME_NUMBER_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_volume_number = (volNumSel == 1) ? 1 : 0;

        // Save Playback Time setting (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int playbackTimeSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_PLAYBACK_TIME_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_playback_time_visible = (playbackTimeSel == 0) ? 1 : 0;

        // Save cover artwork visibility (0=Yes, 1=No in combobox -> config 1=Yes, 0=No)
        int coverArtworkSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_COVER_ARTWORK_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_cover_artwork_visible = (coverArtworkSel == 0) ? 1 : 0;

        // Save online artwork setting
        cfg_nowbar_online_artwork = (IsDlgButtonChecked(m_hwnd, IDC_ONLINE_ARTWORK_CHECK) == BST_CHECKED) ? 1 : 0;

        // Save bar style (0=Pill-shaped, 1=Rectangular)
        cfg_nowbar_bar_style = (int)SendMessage(GetDlgItem(m_hwnd, IDC_BAR_STYLE_COMBO), CB_GETCURSEL, 0, 0);

        // Save seekbar visible (0=On -> 1, 1=Off -> 0)
        {
            int seekbarVisibleSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SEEKBAR_VISIBLE_COMBO), CB_GETCURSEL, 0, 0);
            cfg_nowbar_seekbar_visible = (seekbarVisibleSel == 0) ? 1 : 0;
        }

        // Save seekbar length (0=Fixed, 1=Scaling)
        cfg_nowbar_seekbar_length = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SEEKBAR_LENGTH_COMBO), CB_GETCURSEL, 0, 0);

        // Save seekbar position offset (-100 to +100)
        cfg_nowbar_seekbar_position = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SEEKBAR_POSITION_SLIDER), TBM_GETPOS, 0, 0) - 100;

        // Save button scaling settings
        cfg_nowbar_button_scaling_enabled = (IsDlgButtonChecked(m_hwnd, IDC_BUTTON_SCALING_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_nowbar_button_scaling_percent = (int)SendMessage(GetDlgItem(m_hwnd, IDC_BUTTON_SCALING_SLIDER), TBM_GETPOS, 0, 0);
        clear_nowbar_button_scaling_preview();

        // Save cover margin setting (0=Yes, 1=No in combobox -> config 1=Yes, 0=No)
        int coverMarginSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_COVER_MARGIN_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_cover_margin = (coverMarginSel == 0) ? 1 : 0;

        // Save cover style setting (0=Square, 1=Rounded)
        cfg_nowbar_cover_style = (int)SendMessage(GetDlgItem(m_hwnd, IDC_COVER_STYLE_COMBO), CB_GETCURSEL, 0, 0);

        // Save mood icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int moodIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_MOOD_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_mood_icon_visible = (moodIconSel == 0) ? 1 : 0;

        // Save shuffle icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int shuffleIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SHUFFLE_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_shuffle_icon_visible = (shuffleIconSel == 0) ? 1 : 0;

        // Save repeat icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int repeatIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_REPEAT_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_repeat_icon_visible = (repeatIconSel == 0) ? 1 : 0;

        // Save rating stars visibility (combo: 0=Show, 1=Hidden, 2=Line 3 -> config: 1=Show, 0=Hidden, 2=Line 3)
        int ratingStarsSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_RATING_STARS_COMBO), CB_GETCURSEL, 0, 0);
        if (ratingStarsSel == 0) cfg_nowbar_rating_visible = 1;       // Show
        else if (ratingStarsSel == 2) cfg_nowbar_rating_visible = 2;  // Line 3
        else cfg_nowbar_rating_visible = 0;                           // Hidden

        // Save stop icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int stopIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_STOP_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_stop_icon_visible = (stopIconSel == 0) ? 1 : 0;

        // Save stop after current icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int stopAfterCurrentSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_STOP_AFTER_CURRENT_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_stop_after_current_icon_visible = (stopAfterCurrentSel == 0) ? 1 : 0;

        // Save super icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int superIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SUPER_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_super_icon_visible = (superIconSel == 0) ? 1 : 0;

        // Save miniplayer icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int miniplayerIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_MINIPLAYER_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_miniplayer_icon_visible = (miniplayerIconSel == 0) ? 1 : 0;

        // Save hover circles setting (0=Show, 1=Hide in combobox -> config 1=Show, 0=Hide)
        int hoverCirclesSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_HOVER_CIRCLES_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_hover_circles = (hoverCirclesSel == 0) ? 1 : 0;

        // Save alternate icons style (0=Style 1, 1=Style 2, 2=Style 3)
        cfg_nowbar_alternate_icons = (int)SendMessage(GetDlgItem(m_hwnd, IDC_ALTERNATE_ICONS_COMBO), CB_GETCURSEL, 0, 0);

        // Save play icon style setting (0=Dark, 1=Light)
        cfg_nowbar_play_icon_style = (int)SendMessage(GetDlgItem(m_hwnd, IDC_PLAY_ICON_STYLE_COMBO), CB_GETCURSEL, 0, 0);

        // Save auto-hide C-buttons setting (0=Yes, 1=No in combobox -> config 1=Yes, 0=No)
        int autohideCbuttonsSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_AUTOHIDE_CBUTTONS_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_cbutton_autohide = (autohideCbuttonsSel == 0) ? 1 : 0;

        // Save volume icon visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int volumeIconSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VOLUME_ICON_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_volume_icon_visible = (volumeIconSel == 0) ? 1 : 0;

        // Save volume bar visibility (0=Show, 1=Hidden in combobox -> config 1=Show, 0=Hidden)
        int volumeBarSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VOLUME_BAR_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_volume_bar_visible = (volumeBarSel == 0) ? 1 : 0;

        // Save mood tag mode (0=FEEDBACK, 1=2003_LOVED, 2=LFM_LOVED, 3=SMP_LOVED, 4=MOOD)
        cfg_nowbar_mood_tag_mode = (int)SendMessage(GetDlgItem(m_hwnd, IDC_MOOD_TAG_COMBO), CB_GETCURSEL, 0, 0);

        // Save skip low rating settings
        int skipLowRatingSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SKIP_LOW_RATING_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_skip_low_rating_enabled = (skipLowRatingSel == 1) ? 1 : 0;
        int skipRatingThresholdSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SKIP_RATING_THRESHOLD_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_skip_low_rating_threshold = skipRatingThresholdSel + 1;  // Convert 0-based to 1-3

        // Save visualization mode from checkbox + radio buttons
        {
            bool vis_enabled = (IsDlgButtonChecked(m_hwnd, IDC_VIS_ENABLE_CHECK) == BST_CHECKED);
            bool waveform_sel = (IsDlgButtonChecked(m_hwnd, IDC_VIS_WAVEFORM_RADIO) == BST_CHECKED);
            int sub_mode = waveform_sel ? 2 : 1;
            cfg_nowbar_vis_type = sub_mode;  // Always remember spectrum/waveform selection
            if (!vis_enabled) {
                cfg_nowbar_visualization_mode = 0;  // Disabled
            } else {
                cfg_nowbar_visualization_mode = sub_mode;
            }

            // Save per-visualization settings
            cfg_nowbar_spectrum_width = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_WIDTH_COMBO), CB_GETCURSEL, 0, 0);
            cfg_nowbar_spectrum_style = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_STYLE_COMBO), CB_GETCURSEL, 0, 0);
            cfg_nowbar_spectrum_height = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_HEIGHT_COMBO), CB_GETCURSEL, 0, 0);
            cfg_nowbar_spectrum_opacity = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SPECTRUM_OPACITY_SLIDER), TBM_GETPOS, 0, 0);
            cfg_nowbar_spectrum_gradient_mode = (int)SendMessage(GetDlgItem(m_hwnd, IDC_SPECTRUM_COLOR_MODE_COMBO), CB_GETCURSEL, 0, 0);
            cfg_nowbar_waveform_width = (int)SendMessage(GetDlgItem(m_hwnd, IDC_VIS_WAVEFORM_WIDTH_COMBO), CB_GETCURSEL, 0, 0);
            cfg_nowbar_waveform_style = (IsDlgButtonChecked(m_hwnd, IDC_VIS_WAVEFORM_STYLE_2) == BST_CHECKED) ? 1 : 0;
            cfg_nowbar_vis_60fps = (IsDlgButtonChecked(m_hwnd, IDC_VIS_60FPS_CHECK) == BST_CHECKED) ? 1 : 0;
            // Color buttons are saved immediately via color picker, no need to save here
        }

        // Save color custom enable flags
        cfg_custom_button_accent_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_BUTTON_ACCENT_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_play_accent_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_PLAY_ACCENT_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_progress_accent_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_PROGRESS_ACCENT_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_volume_accent_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_VOLUME_ACCENT_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_hover_color_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_HOVER_COLOR_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_spectrum_color_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_SPECTRUM_COLOR_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_waveform_color_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_WAVEFORM_COLOR_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_waveform_unplayed_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_WAVEFORM_UNPLAYED_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_progress_track_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_PROGRESS_TRACK_CHECK) == BST_CHECKED) ? 1 : 0;
        cfg_custom_volume_track_enabled = (IsDlgButtonChecked(m_hwnd, IDC_CUSTOM_VOLUME_TRACK_CHECK) == BST_CHECKED) ? 1 : 0;

        // Save background style setting
        int bgStyleSel = (int)SendMessage(GetDlgItem(m_hwnd, IDC_BACKGROUND_STYLE_COMBO), CB_GETCURSEL, 0, 0);
        cfg_nowbar_background_style = bgStyleSel;

        // Save Custom Button tab settings
        cfg_cbutton1_enabled = IsDlgButtonChecked(m_hwnd, IDC_CBUTTON1_ENABLE) == BST_CHECKED ? 1 : 0;
        cfg_cbutton2_enabled = IsDlgButtonChecked(m_hwnd, IDC_CBUTTON2_ENABLE) == BST_CHECKED ? 1 : 0;
        cfg_cbutton3_enabled = IsDlgButtonChecked(m_hwnd, IDC_CBUTTON3_ENABLE) == BST_CHECKED ? 1 : 0;
        cfg_cbutton4_enabled = IsDlgButtonChecked(m_hwnd, IDC_CBUTTON4_ENABLE) == BST_CHECKED ? 1 : 0;
        cfg_cbutton5_enabled = IsDlgButtonChecked(m_hwnd, IDC_CBUTTON5_ENABLE) == BST_CHECKED ? 1 : 0;
        cfg_cbutton6_enabled = IsDlgButtonChecked(m_hwnd, IDC_CBUTTON6_ENABLE) == BST_CHECKED ? 1 : 0;
        cfg_cbutton1_action = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON1_ACTION), CB_GETCURSEL, 0, 0);
        cfg_cbutton2_action = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON2_ACTION), CB_GETCURSEL, 0, 0);
        cfg_cbutton3_action = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON3_ACTION), CB_GETCURSEL, 0, 0);
        cfg_cbutton4_action = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON4_ACTION), CB_GETCURSEL, 0, 0);
        cfg_cbutton5_action = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON5_ACTION), CB_GETCURSEL, 0, 0);
        cfg_cbutton6_action = (int)SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON6_ACTION), CB_GETCURSEL, 0, 0);
        
        // Save Custom Button paths
        pfc::string8 path;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON1_PATH, path);
        cfg_cbutton1_path = path;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON2_PATH, path);
        cfg_cbutton2_path = path;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON3_PATH, path);
        cfg_cbutton3_path = path;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON4_PATH, path);
        cfg_cbutton4_path = path;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON5_PATH, path);
        cfg_cbutton5_path = path;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON6_PATH, path);
        cfg_cbutton6_path = path;
        
        // Save Custom Button glyph characters
        pfc::string8 glyph;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON1_ICON, glyph);
        cfg_cbutton1_icon = glyph;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON2_ICON, glyph);
        cfg_cbutton2_icon = glyph;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON3_ICON, glyph);
        cfg_cbutton3_icon = glyph;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON4_ICON, glyph);
        cfg_cbutton4_icon = glyph;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON5_ICON, glyph);
        cfg_cbutton5_icon = glyph;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON6_ICON, glyph);
        cfg_cbutton6_icon = glyph;

        // Save Custom Button glyph sizes
        cfg_cbutton1_glyph_size = GetDlgItemInt(m_hwnd, IDC_CBUTTON1_GLYPH_SIZE, NULL, FALSE);
        cfg_cbutton2_glyph_size = GetDlgItemInt(m_hwnd, IDC_CBUTTON2_GLYPH_SIZE, NULL, FALSE);
        cfg_cbutton3_glyph_size = GetDlgItemInt(m_hwnd, IDC_CBUTTON3_GLYPH_SIZE, NULL, FALSE);
        cfg_cbutton4_glyph_size = GetDlgItemInt(m_hwnd, IDC_CBUTTON4_GLYPH_SIZE, NULL, FALSE);
        cfg_cbutton5_glyph_size = GetDlgItemInt(m_hwnd, IDC_CBUTTON5_GLYPH_SIZE, NULL, FALSE);
        cfg_cbutton6_glyph_size = GetDlgItemInt(m_hwnd, IDC_CBUTTON6_GLYPH_SIZE, NULL, FALSE);

        // Save Custom Button font names
        pfc::string8 font_name;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON1_FONT, font_name);
        cfg_cbutton1_font = font_name;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON2_FONT, font_name);
        cfg_cbutton2_font = font_name;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON3_FONT, font_name);
        cfg_cbutton3_font = font_name;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON4_FONT, font_name);
        cfg_cbutton4_font = font_name;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON5_FONT, font_name);
        cfg_cbutton5_font = font_name;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON6_FONT, font_name);
        cfg_cbutton6_font = font_name;

        // Save Custom Button tooltip labels
        pfc::string8 label;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON1_LABEL, label);
        cfg_cbutton1_label = label;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON2_LABEL, label);
        cfg_cbutton2_label = label;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON3_LABEL, label);
        cfg_cbutton3_label = label;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON4_LABEL, label);
        cfg_cbutton4_label = label;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON5_LABEL, label);
        cfg_cbutton5_label = label;
        uGetDlgItemText(m_hwnd, IDC_CBUTTON6_LABEL, label);
        cfg_cbutton6_label = label;

        // Save current settings to the current profile
        {
            auto profiles = get_all_profiles();
            pfc::string8 current_name = get_current_profile_name();
            CButtonProfile* current_profile = find_profile(profiles, current_name.c_str());
            if (current_profile) {
                save_config_to_profile(*current_profile);
                save_all_profiles(profiles);
            }
            // Sync buttons 1-6 to the external config file
            save_config_file();
        }

        // Notify all registered instances to update
        nowbar::ControlPanelCore::notify_all_settings_changed();
    }
}

void nowbar_preferences::reset_settings() {
    if (m_hwnd) {
        if (m_current_tab == 0) {
            // Reset General tab settings (Display Format, Auto-hide C-buttons, Mood Tag, Skip Low Rating)
            cfg_nowbar_line1_format = "%title%";  // Default format
            cfg_nowbar_line2_format = "%artist%";  // Default format
            cfg_nowbar_line3_format = "";  // Default: disabled
            cfg_nowbar_mood_tag_mode = 0;  // FEEDBACK (default)
            cfg_nowbar_rating_visible = 0;  // Hidden (default)
            cfg_nowbar_skip_low_rating_enabled = 0;  // Disabled (default)
            cfg_nowbar_skip_low_rating_threshold = 1;  // 1 (default)
            cfg_nowbar_visualization_mode = 0;  // Disabled (default)
            cfg_nowbar_vis_type = 1;  // Default: Spectrum
            cfg_nowbar_spectrum_width = 1;  // Default: Normal
            cfg_nowbar_spectrum_style = 1;  // Default: Curve
            cfg_nowbar_spectrum_height = 2;  // Default: High
            cfg_nowbar_waveform_width = 0;  // Default: Thin
            cfg_nowbar_waveform_style = 0;  // Default: Waveform 1
            cfg_nowbar_vis_60fps = 0;  // Default: Disabled

            // Update General tab UI
            uSetDlgItemText(m_hwnd, IDC_LINE1_FORMAT_EDIT, "%title%");
            uSetDlgItemText(m_hwnd, IDC_LINE2_FORMAT_EDIT, "%artist%");
            uSetDlgItemText(m_hwnd, IDC_LINE3_FORMAT_EDIT, "");
            SendMessage(GetDlgItem(m_hwnd, IDC_MOOD_TAG_COMBO), CB_SETCURSEL, 0, 0);  // Default: FEEDBACK
            SendMessage(GetDlgItem(m_hwnd, IDC_RATING_STARS_COMBO), CB_SETCURSEL, 1, 0);  // Default: Hidden
            EnableWindow(GetDlgItem(m_hwnd, IDC_LINE3_FORMAT_EDIT), TRUE);  // Re-enable Line 3 edit
            SendMessage(GetDlgItem(m_hwnd, IDC_SKIP_LOW_RATING_COMBO), CB_SETCURSEL, 0, 0);  // Default: Disabled
            SendMessage(GetDlgItem(m_hwnd, IDC_SKIP_RATING_THRESHOLD_COMBO), CB_SETCURSEL, 0, 0);  // Default: 1
            EnableWindow(GetDlgItem(m_hwnd, IDC_SKIP_RATING_THRESHOLD_COMBO), FALSE);  // Disabled when skip is off
            // Reset Visualization section UI
            CheckDlgButton(m_hwnd, IDC_VIS_ENABLE_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_VIS_60FPS_CHECK, BST_UNCHECKED);
            CheckRadioButton(m_hwnd, IDC_VIS_SPECTRUM_RADIO, IDC_VIS_WAVEFORM_RADIO, IDC_VIS_SPECTRUM_RADIO);
            CheckRadioButton(m_hwnd, IDC_VIS_WAVEFORM_STYLE_1, IDC_VIS_WAVEFORM_STYLE_2, IDC_VIS_WAVEFORM_STYLE_1);
            SendMessage(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_WIDTH_COMBO), CB_SETCURSEL, 1, 0);  // Normal
            SendMessage(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_STYLE_COMBO), CB_SETCURSEL, 1, 0);  // Curve
            SendMessage(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_HEIGHT_COMBO), CB_SETCURSEL, 2, 0);  // High
            SendMessage(GetDlgItem(m_hwnd, IDC_VIS_WAVEFORM_WIDTH_COMBO), CB_SETCURSEL, 0, 0);  // Thin
            update_vis_section_state(m_hwnd);
        } else if (m_current_tab == 1) {
            // Reset Appearance tab settings
            cfg_nowbar_theme_mode = 0;  // Auto
            cfg_nowbar_cover_artwork_visible = 1;  // Yes (show artwork)
            cfg_nowbar_cover_margin = 1;  // Yes (margin enabled)
            cfg_nowbar_cover_style = 1;  // Rounded
            cfg_nowbar_background_style = 0;  // Solid
            cfg_nowbar_bar_style = 0;  // Pill-shaped
            cfg_nowbar_smooth_animations = 0;  // Disabled (default for performance)
            cfg_nowbar_3d_buttons = 1;  // Default: Enabled
            cfg_nowbar_online_artwork = 0;  // Default: Disabled

            // Update Appearance tab UI
            SendMessage(GetDlgItem(m_hwnd, IDC_THEME_MODE_COMBO), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_COVER_ARTWORK_COMBO), CB_SETCURSEL, 0, 0);  // Default: Yes
            SendMessage(GetDlgItem(m_hwnd, IDC_COVER_MARGIN_COMBO), CB_SETCURSEL, 0, 0);  // Default: Yes
            SendMessage(GetDlgItem(m_hwnd, IDC_COVER_STYLE_COMBO), CB_SETCURSEL, 1, 0);  // Default: Rounded
            SendMessage(GetDlgItem(m_hwnd, IDC_BACKGROUND_STYLE_COMBO), CB_SETCURSEL, 0, 0);  // Default: Solid
            SendMessage(GetDlgItem(m_hwnd, IDC_BAR_STYLE_COMBO), CB_SETCURSEL, 0, 0);
            cfg_nowbar_seekbar_visible = 1;  // Default: On
            SendMessage(GetDlgItem(m_hwnd, IDC_SEEKBAR_VISIBLE_COMBO), CB_SETCURSEL, 0, 0);  // Default: On
            cfg_nowbar_seekbar_length = 0;  // Default: Fixed
            SendMessage(GetDlgItem(m_hwnd, IDC_SEEKBAR_LENGTH_COMBO), CB_SETCURSEL, 0, 0);  // Default: Fixed
            cfg_nowbar_seekbar_position = 0;  // Default: centered
            SendMessage(GetDlgItem(m_hwnd, IDC_SEEKBAR_POSITION_SLIDER), TBM_SETPOS, TRUE, 100);
            SetDlgItemTextW(m_hwnd, IDC_SEEKBAR_POSITION_VALUE, L"0");
            SendMessage(GetDlgItem(m_hwnd, IDC_SMOOTH_ANIMATIONS_COMBO), CB_SETCURSEL, 1, 0);  // Default: Disabled (index 1)
            CheckDlgButton(m_hwnd, IDC_ONLINE_ARTWORK_CHECK, BST_UNCHECKED);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON_3D_COMBO), CB_SETCURSEL, 0, 0);  // Default: Enabled
            cfg_nowbar_volume_number = 0;  // Default: Disabled
            SendMessage(GetDlgItem(m_hwnd, IDC_VOLUME_NUMBER_COMBO), CB_SETCURSEL, 0, 0);  // Default: Disabled
            cfg_nowbar_playback_time_visible = 1;  // Default: Show
            SendMessage(GetDlgItem(m_hwnd, IDC_PLAYBACK_TIME_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
            update_cover_margin_state(m_hwnd);  // Re-enable Cover Margin (Cover Artwork is Yes)
            cfg_nowbar_button_scaling_enabled = 0;
            cfg_nowbar_button_scaling_percent = 80;
            clear_nowbar_button_scaling_preview();
            CheckDlgButton(m_hwnd, IDC_BUTTON_SCALING_CHECK, BST_UNCHECKED);
            SendMessage(GetDlgItem(m_hwnd, IDC_BUTTON_SCALING_SLIDER), TBM_SETPOS, TRUE, 80);
            SetDlgItemTextW(m_hwnd, IDC_BUTTON_SCALING_VALUE, L"80%");
            update_button_scaling_state(m_hwnd);
        } else if (m_current_tab == 2) {
            // Reset Icons tab settings
            cfg_nowbar_mood_icon_visible = 1;  // Show (visible)
            cfg_nowbar_shuffle_icon_visible = 1;  // Show (default)
            cfg_nowbar_repeat_icon_visible = 1;  // Show (default)
            cfg_nowbar_stop_icon_visible = 0;  // Hidden (default)
            cfg_nowbar_stop_after_current_icon_visible = 0;  // Hidden (default)
            cfg_nowbar_super_icon_visible = 1;  // Show (default)
            cfg_nowbar_miniplayer_icon_visible = 0;  // Hidden (default)
            cfg_nowbar_hover_circles = 1;  // Show (default)
            cfg_nowbar_alternate_icons = 0;  // Style 1 (default)
            cfg_nowbar_play_icon_style = 0;  // Dark (default)
            cfg_nowbar_cbutton_autohide = 0;  // No (default)
            cfg_nowbar_volume_icon_visible = 1;  // Show (default)
            cfg_nowbar_volume_bar_visible = 1;  // Show (default)

            // Update Icons tab UI
            SendMessage(GetDlgItem(m_hwnd, IDC_MOOD_ICON_COMBO), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_SHUFFLE_ICON_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
            SendMessage(GetDlgItem(m_hwnd, IDC_REPEAT_ICON_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
            SendMessage(GetDlgItem(m_hwnd, IDC_STOP_ICON_COMBO), CB_SETCURSEL, 1, 0);  // Default: Hidden
            SendMessage(GetDlgItem(m_hwnd, IDC_STOP_AFTER_CURRENT_COMBO), CB_SETCURSEL, 1, 0);  // Default: Hidden
            SendMessage(GetDlgItem(m_hwnd, IDC_SUPER_ICON_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
            SendMessage(GetDlgItem(m_hwnd, IDC_MINIPLAYER_ICON_COMBO), CB_SETCURSEL, 1, 0);  // Default: Hidden
            SendMessage(GetDlgItem(m_hwnd, IDC_HOVER_CIRCLES_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
            SendMessage(GetDlgItem(m_hwnd, IDC_ALTERNATE_ICONS_COMBO), CB_SETCURSEL, 0, 0);  // Default: Style 1
            SendMessage(GetDlgItem(m_hwnd, IDC_PLAY_ICON_STYLE_COMBO), CB_SETCURSEL, 0, 0);  // Default: Normal
            EnableWindow(GetDlgItem(m_hwnd, IDC_PLAY_ICON_STYLE_LABEL), TRUE);   // Re-enable after reset
            EnableWindow(GetDlgItem(m_hwnd, IDC_PLAY_ICON_STYLE_COMBO), TRUE);
            SendMessage(GetDlgItem(m_hwnd, IDC_AUTOHIDE_CBUTTONS_COMBO), CB_SETCURSEL, 1, 0);  // Default: No
            SendMessage(GetDlgItem(m_hwnd, IDC_VOLUME_ICON_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
            SendMessage(GetDlgItem(m_hwnd, IDC_VOLUME_BAR_COMBO), CB_SETCURSEL, 0, 0);  // Default: Show
        } else if (m_current_tab == 3) {
            // Reset Custom Button tab settings
            cfg_cbutton1_enabled = 0;
            cfg_cbutton2_enabled = 0;
            cfg_cbutton3_enabled = 0;
            cfg_cbutton4_enabled = 0;
            cfg_cbutton5_enabled = 0;
            cfg_cbutton6_enabled = 0;
            cfg_cbutton1_action = 0;
            cfg_cbutton2_action = 0;
            cfg_cbutton3_action = 0;
            cfg_cbutton4_action = 0;
            cfg_cbutton5_action = 0;
            cfg_cbutton6_action = 0;
            cfg_cbutton1_path = "";
            cfg_cbutton2_path = "";
            cfg_cbutton3_path = "";
            cfg_cbutton4_path = "";
            cfg_cbutton5_path = "";
            cfg_cbutton6_path = "";
            cfg_cbutton1_icon = "";
            cfg_cbutton2_icon = "";
            cfg_cbutton3_icon = "";
            cfg_cbutton4_icon = "";
            cfg_cbutton5_icon = "";
            cfg_cbutton6_icon = "";
            cfg_cbutton1_glyph_size = 80;
            cfg_cbutton2_glyph_size = 80;
            cfg_cbutton3_glyph_size = 80;
            cfg_cbutton4_glyph_size = 80;
            cfg_cbutton5_glyph_size = 80;
            cfg_cbutton6_glyph_size = 80;
            cfg_cbutton1_font = "Segoe UI";
            cfg_cbutton2_font = "Segoe UI";
            cfg_cbutton3_font = "Segoe UI";
            cfg_cbutton4_font = "Segoe UI";
            cfg_cbutton5_font = "Segoe UI";
            cfg_cbutton6_font = "Segoe UI";
            cfg_cbutton1_label = "";
            cfg_cbutton2_label = "";
            cfg_cbutton3_label = "";
            cfg_cbutton4_label = "";
            cfg_cbutton5_label = "";
            cfg_cbutton6_label = "";

            // Update UI
            CheckDlgButton(m_hwnd, IDC_CBUTTON1_ENABLE, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CBUTTON2_ENABLE, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CBUTTON3_ENABLE, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CBUTTON4_ENABLE, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CBUTTON5_ENABLE, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CBUTTON6_ENABLE, BST_UNCHECKED);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON1_ACTION), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON2_ACTION), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON3_ACTION), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON4_ACTION), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON5_ACTION), CB_SETCURSEL, 0, 0);
            SendMessage(GetDlgItem(m_hwnd, IDC_CBUTTON6_ACTION), CB_SETCURSEL, 0, 0);
            SetDlgItemTextW(m_hwnd, IDC_CBUTTON1_PATH, L"");
            SetDlgItemTextW(m_hwnd, IDC_CBUTTON2_PATH, L"");
            SetDlgItemTextW(m_hwnd, IDC_CBUTTON3_PATH, L"");
            SetDlgItemTextW(m_hwnd, IDC_CBUTTON4_PATH, L"");
            SetDlgItemTextW(m_hwnd, IDC_CBUTTON5_PATH, L"");
            SetDlgItemTextW(m_hwnd, IDC_CBUTTON6_PATH, L"");
            // Reset glyph and font comboboxes, and label fields
            for (int i = 0; i < 6; i++) {
                SetWindowTextW(GetDlgItem(m_hwnd, IDC_CBUTTON1_ICON + i * 3), L"");
                SetDlgItemInt(m_hwnd, IDC_CBUTTON1_GLYPH_SIZE + i * 3, 80, FALSE);
                SetWindowTextW(GetDlgItem(m_hwnd, IDC_CBUTTON1_FONT + i), L"Segoe UI");
                SetWindowTextW(GetDlgItem(m_hwnd, IDC_CBUTTON1_LABEL + i), L"");
            }
            update_all_cbutton_path_states(m_hwnd);
        } else if (m_current_tab == 4) {
            // Reset Fonts & Colors tab settings
            reset_nowbar_fonts();
            update_font_displays();

            // Reset all color custom flags to theme defaults
            cfg_custom_button_accent_enabled = 0;
            cfg_custom_play_accent_enabled = 0;
            cfg_custom_progress_accent_enabled = 0;
            cfg_custom_volume_accent_enabled = 0;
            cfg_custom_hover_color_enabled = 0;
            cfg_custom_spectrum_color_enabled = 0;
            cfg_custom_waveform_color_enabled = 0;
            cfg_custom_waveform_unplayed_enabled = 0;
            cfg_custom_progress_track_enabled = 0;
            cfg_custom_volume_track_enabled = 0;

            // Reset custom colors to defaults
            cfg_nowbar_button_accent_color = RGB(100, 180, 255);
            cfg_nowbar_play_accent_color = RGB(100, 180, 255);
            cfg_nowbar_progress_accent_color = RGB(140, 140, 140);
            cfg_nowbar_volume_accent_color = RGB(140, 140, 140);
            cfg_nowbar_hover_color = RGB(255, 255, 255);
            cfg_nowbar_spectrum_color = RGB(100, 180, 255);
            cfg_nowbar_spectrum_opacity = 75;
            cfg_nowbar_spectrum_gradient_mode = 0;
            cfg_nowbar_spectrum_color2 = RGB(30, 80, 160);
            cfg_nowbar_waveform_color = RGB(255, 85, 0);
            cfg_nowbar_waveform_unplayed_color = RGB(60, 60, 60);
            cfg_nowbar_progress_track_color = RGB(60, 60, 60);
            cfg_nowbar_volume_track_color = RGB(60, 60, 60);

            // Update UI
            CheckDlgButton(m_hwnd, IDC_CUSTOM_BUTTON_ACCENT_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_PLAY_ACCENT_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_PROGRESS_ACCENT_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_VOLUME_ACCENT_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_HOVER_COLOR_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_SPECTRUM_COLOR_CHECK, BST_UNCHECKED);
            SendMessage(GetDlgItem(m_hwnd, IDC_SPECTRUM_OPACITY_SLIDER), TBM_SETPOS, TRUE, 75);
            SetDlgItemTextW(m_hwnd, IDC_SPECTRUM_OPACITY_VALUE, L"75%");
            SendMessage(GetDlgItem(m_hwnd, IDC_SPECTRUM_COLOR_MODE_COMBO), CB_SETCURSEL, 0, 0);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_WAVEFORM_COLOR_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_WAVEFORM_UNPLAYED_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_PROGRESS_TRACK_CHECK, BST_UNCHECKED);
            CheckDlgButton(m_hwnd, IDC_CUSTOM_VOLUME_TRACK_CHECK, BST_UNCHECKED);
            update_color_buttons_state(m_hwnd);

            // Repaint color buttons
            InvalidateRect(GetDlgItem(m_hwnd, IDC_BUTTON_ACCENT_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_PLAY_ACCENT_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_PROGRESS_ACCENT_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_VOLUME_ACCENT_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_HOVER_COLOR_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_VIS_SPECTRUM_COLOR_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_SPECTRUM_COLOR2_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_VIS_WAVEFORM_COLOR_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_VIS_WAVEFORM_UNPLAYED_COLOR_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_PROGRESS_TRACK_BTN), nullptr, TRUE);
            InvalidateRect(GetDlgItem(m_hwnd, IDC_VOLUME_TRACK_BTN), nullptr, TRUE);
        }
        
        // Notify panels
        nowbar::ControlPanelCore::notify_all_settings_changed();
    }
}

void nowbar_preferences::update_font_displays() {
    if (!m_hwnd) return;
    
    // Track font
    if (get_nowbar_use_custom_fonts()) {
        LOGFONT lf = get_nowbar_track_font();
        pfc::string8 desc = format_font_name(lf);
        uSetDlgItemText(m_hwnd, IDC_TRACK_FONT_DISPLAY, desc);
    } else {
        uSetDlgItemText(m_hwnd, IDC_TRACK_FONT_DISPLAY, "Microsoft YaHei UI, 15pt, Bold (Default)");
    }
    
    // Artist font
    if (get_nowbar_use_custom_fonts()) {
        LOGFONT lf = get_nowbar_artist_font();
        pfc::string8 desc = format_font_name(lf);
        uSetDlgItemText(m_hwnd, IDC_ARTIST_FONT_DISPLAY, desc);
    } else {
        uSetDlgItemText(m_hwnd, IDC_ARTIST_FONT_DISPLAY, "Microsoft YaHei UI, 13pt, Regular (Default)");
    }

    // Line 3 font
    if (get_nowbar_use_custom_fonts()) {
        LOGFONT lf = get_nowbar_line3_font();
        pfc::string8 desc = format_font_name(lf);
        uSetDlgItemText(m_hwnd, IDC_LINE3_FONT_DISPLAY, desc);
    } else {
        uSetDlgItemText(m_hwnd, IDC_LINE3_FONT_DISPLAY, "Microsoft YaHei UI, 13pt, Regular (Default)");
    }

    // Time font
    if (get_nowbar_use_custom_fonts()) {
        LOGFONT lf = get_nowbar_time_font();
        pfc::string8 desc = format_font_name(lf);
        uSetDlgItemText(m_hwnd, IDC_TIME_FONT_DISPLAY, desc);
    } else {
        uSetDlgItemText(m_hwnd, IDC_TIME_FONT_DISPLAY, "Microsoft YaHei UI, 9pt, Regular (Default)");
    }
}

void nowbar_preferences::select_track_font() {
    LOGFONT lf = get_nowbar_use_custom_fonts() ? get_nowbar_track_font() : get_nowbar_default_font(false);

    CHOOSEFONT cf = {};
    cf.lStructSize = sizeof(cf);
    cf.hwndOwner = m_hwnd;
    cf.lpLogFont = &lf;
    cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS | CF_NOVERTFONTS | CF_SCALABLEONLY;
    COLORREF saved_color;
    if (get_nowbar_track_font_color(saved_color))
        cf.rgbColors = saved_color;

    COLORREF color_before = cf.rgbColors;
    if (ChooseFont(&cf)) {
        set_nowbar_track_font(lf);
        if (cf.rgbColors != color_before)
            set_nowbar_track_font_color(cf.rgbColors);
        update_font_displays();
        on_changed();
        nowbar::ControlPanelCore::notify_all_settings_changed();
    }
}

void nowbar_preferences::select_artist_font() {
    LOGFONT lf = get_nowbar_use_custom_fonts() ? get_nowbar_artist_font() : get_nowbar_default_font(true);

    CHOOSEFONT cf = {};
    cf.lStructSize = sizeof(cf);
    cf.hwndOwner = m_hwnd;
    cf.lpLogFont = &lf;
    cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS | CF_NOVERTFONTS | CF_SCALABLEONLY;
    COLORREF saved_color;
    if (get_nowbar_artist_font_color(saved_color))
        cf.rgbColors = saved_color;

    COLORREF color_before = cf.rgbColors;
    if (ChooseFont(&cf)) {
        set_nowbar_artist_font(lf);
        if (cf.rgbColors != color_before)
            set_nowbar_artist_font_color(cf.rgbColors);
        update_font_displays();
        on_changed();
        nowbar::ControlPanelCore::notify_all_settings_changed();
    }
}

void nowbar_preferences::select_line3_font() {
    LOGFONT lf = get_nowbar_use_custom_fonts() ? get_nowbar_line3_font() : get_nowbar_default_font(true);

    CHOOSEFONT cf = {};
    cf.lStructSize = sizeof(cf);
    cf.hwndOwner = m_hwnd;
    cf.lpLogFont = &lf;
    cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS | CF_NOVERTFONTS | CF_SCALABLEONLY;
    COLORREF saved_color;
    if (get_nowbar_line3_font_color(saved_color))
        cf.rgbColors = saved_color;

    COLORREF color_before = cf.rgbColors;
    if (ChooseFont(&cf)) {
        set_nowbar_line3_font(lf);
        if (cf.rgbColors != color_before)
            set_nowbar_line3_font_color(cf.rgbColors);
        update_font_displays();
        on_changed();
        nowbar::ControlPanelCore::notify_all_settings_changed();
    }
}

void nowbar_preferences::select_time_font() {
    LOGFONT lf = get_nowbar_use_custom_fonts() ? get_nowbar_time_font() : get_nowbar_default_time_font();

    CHOOSEFONT cf = {};
    cf.lStructSize = sizeof(cf);
    cf.hwndOwner = m_hwnd;
    cf.lpLogFont = &lf;
    cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS | CF_NOVERTFONTS | CF_SCALABLEONLY;
    COLORREF saved_color;
    if (get_nowbar_time_font_color(saved_color))
        cf.rgbColors = saved_color;

    COLORREF color_before = cf.rgbColors;
    if (ChooseFont(&cf)) {
        set_nowbar_time_font(lf);
        if (cf.rgbColors != color_before)
            set_nowbar_time_font_color(cf.rgbColors);
        update_font_displays();
        on_changed();
        nowbar::ControlPanelCore::notify_all_settings_changed();
    }
}

pfc::string8 nowbar_preferences::format_font_name(const LOGFONT& lf) {
    pfc::string8 result;

    // Convert face name to UTF-8 (LF_FACESIZE=32 wchar_t can need up to 96 bytes in UTF-8)
    char face_name[128];
    int conv = WideCharToMultiByte(CP_UTF8, 0, lf.lfFaceName, -1, face_name, sizeof(face_name), nullptr, nullptr);
    if (conv <= 0) face_name[0] = '\0';  // Fallback on conversion failure
    
    // Calculate point size from height
    HDC hdc = GetDC(nullptr);
    int point_size = MulDiv(-lf.lfHeight, 72, GetDeviceCaps(hdc, LOGPIXELSY));
    ReleaseDC(nullptr, hdc);
    
    // Format string
    result << face_name << ", " << point_size << "pt";
    if (lf.lfWeight >= FW_BOLD) {
        result << ", Bold";
    }
    if (lf.lfItalic) {
        result << ", Italic";
    }
    
    return result;
}

//=============================================================================
// nowbar_preferences_page - preferences page factory
//=============================================================================

const char* nowbar_preferences_page::get_name() {
    return "Now Bar";
}

GUID nowbar_preferences_page::get_guid() {
    return guid_nowbar_preferences_page;
}

GUID nowbar_preferences_page::get_parent_guid() {
    return preferences_page::guid_tools;
}

preferences_page_instance::ptr nowbar_preferences_page::instantiate(HWND parent, preferences_page_callback::ptr callback) {
    auto instance = fb2k::service_new<nowbar_preferences>(callback);
    
    // Create dialog
    HWND hwnd = CreateDialogParam(
        g_hInstance,
        MAKEINTRESOURCE(IDD_NOWBAR_PREFERENCES),
        parent,
        nowbar_preferences::ConfigProc,
        reinterpret_cast<LPARAM>(instance.get_ptr())
    );
    
    return instance;
}

// Register preferences page
static preferences_page_factory_t<nowbar_preferences_page> g_nowbar_preferences_factory;