diff --git a/src-tauri/src/auto_theme/generator.rs b/src-tauri/src/auto_theme/generator.rs index 3bdad4199..ace5b36f3 100644 --- a/src-tauri/src/auto_theme/generator.rs +++ b/src-tauri/src/auto_theme/generator.rs @@ -2,7 +2,7 @@ use std::collections::HashMap; -use super::{GeneratedTheme, PaletteColor, ThemePalette}; +use super::{GeneratedTheme, PaletteColor, SystemColorScheme, ThemePalette}; /// Generate a full CSS theme from an extracted palette. pub fn generate_theme(palette: &ThemePalette, source: &str) -> GeneratedTheme { @@ -142,6 +142,193 @@ pub fn generate_theme(palette: &ThemePalette, source: &str) -> GeneratedTheme { } } +/// Generate a full CSS theme directly from a DE color scheme. +/// +/// Instead of k-means extraction, this maps the DE's semantic colors (window bg, +/// view bg, button bg, selection, etc.) directly to CSS variables — producing a +/// theme that matches the system look exactly. +pub fn generate_theme_from_scheme(scheme: &SystemColorScheme) -> GeneratedTheme { + let mut vars = HashMap::new(); + + // Determine dark/light from the window background + let window_bg = scheme + .window_bg + .unwrap_or(PaletteColor::new(40, 40, 40)); + let is_dark = window_bg.luminance() < 0.5; + + // ── Backgrounds ────────────────────────────────────────────────────── + vars.insert("--bg-primary".into(), window_bg.to_hex()); + + let bg_secondary = scheme.view_bg.unwrap_or_else(|| { + if is_dark { + window_bg.shift_lightness(0.03) + } else { + window_bg.shift_lightness(-0.03) + } + }); + vars.insert("--bg-secondary".into(), bg_secondary.to_hex()); + + let bg_tertiary = scheme.button_bg.unwrap_or_else(|| { + if is_dark { + window_bg.shift_lightness(0.10) + } else { + window_bg.shift_lightness(-0.10) + } + }); + vars.insert("--bg-tertiary".into(), bg_tertiary.to_hex()); + + // Hover: midpoint between primary and secondary + let bg_hover = scheme.window_bg_alt.unwrap_or_else(|| { + PaletteColor::new( + ((window_bg.r as u16 + bg_secondary.r as u16) / 2) as u8, + ((window_bg.g as u16 + bg_secondary.g as u16) / 2) as u8, + ((window_bg.b as u16 + bg_secondary.b as u16) / 2) as u8, + ) + }); + vars.insert("--bg-hover".into(), bg_hover.to_hex()); + + // ── Text ───────────────────────────────────────────────────────────── + let text_primary = scheme + .window_fg + .unwrap_or(if is_dark { + PaletteColor::new(223, 223, 223) + } else { + PaletteColor::new(36, 36, 36) + }); + let text_primary = ensure_text_contrast(text_primary, &window_bg, is_dark); + vars.insert("--text-primary".into(), text_primary.to_hex()); + + // Secondary: slightly dimmed from primary + let text_secondary = scheme.view_fg.unwrap_or_else(|| { + text_primary.shift_lightness(if is_dark { -0.10 } else { 0.10 }) + }); + vars.insert("--text-secondary".into(), text_secondary.to_hex()); + + let text_muted = scheme.window_fg_inactive.unwrap_or_else(|| { + text_primary.shift_lightness(if is_dark { -0.25 } else { 0.25 }) + }); + vars.insert("--text-muted".into(), text_muted.to_hex()); + + let text_disabled = text_muted.shift_lightness(if is_dark { -0.10 } else { 0.10 }); + vars.insert("--text-disabled".into(), text_disabled.to_hex()); + + // ── Accent (selection) ─────────────────────────────────────────────── + let accent = scheme + .accent + .or(scheme.selection_bg) + .unwrap_or(PaletteColor::new(0, 120, 215)); + vars.insert("--accent-primary".into(), accent.to_hex()); + + let accent_hover = scheme + .selection_hover + .unwrap_or_else(|| accent.shift_lightness(0.10)); + vars.insert("--accent-hover".into(), accent_hover.to_hex()); + vars.insert( + "--accent-active".into(), + accent.shift_lightness(-0.10).to_hex(), + ); + + // Button text on accent + let btn_text = scheme.selection_fg.unwrap_or( + if accent.luminance() < 0.5 { + PaletteColor::new(255, 255, 255) + } else { + PaletteColor::new(0, 0, 0) + }, + ); + vars.insert("--btn-primary-text".into(), btn_text.to_hex()); + + // ── Status colors ──────────────────────────────────────────────────── + // Use system negative/neutral if available, else fallback to safe defaults + let danger = scheme + .fg_negative + .unwrap_or(if is_dark { + PaletteColor::new(239, 68, 68) + } else { + PaletteColor::new(220, 38, 38) + }); + vars.insert("--danger".into(), danger.to_hex()); + vars.insert("--danger-bg".into(), danger.to_rgba(0.1)); + vars.insert("--danger-border".into(), danger.to_rgba(0.3)); + vars.insert( + "--danger-hover".into(), + danger.to_rgba(if is_dark { 0.2 } else { 0.15 }), + ); + + let warning = scheme + .fg_neutral + .unwrap_or(if is_dark { + PaletteColor::new(251, 191, 36) + } else { + PaletteColor::new(217, 119, 6) + }); + vars.insert("--warning".into(), warning.to_hex()); + vars.insert("--warning-bg".into(), warning.to_rgba(0.1)); + vars.insert("--warning-border".into(), warning.to_rgba(0.3)); + vars.insert( + "--warning-hover".into(), + warning.to_rgba(if is_dark { 0.2 } else { 0.15 }), + ); + + // ── Borders ────────────────────────────────────────────────────────── + let border_subtle = if is_dark { + window_bg.shift_lightness(0.06) + } else { + window_bg.shift_lightness(-0.06) + }; + let border_strong = if is_dark { + window_bg.shift_lightness(0.12) + } else { + window_bg.shift_lightness(-0.12) + }; + vars.insert("--border-subtle".into(), border_subtle.to_hex()); + vars.insert("--border-strong".into(), border_strong.to_hex()); + + // ── Alpha tokens ───────────────────────────────────────────────────── + let alpha_base = if is_dark { + (255, 255, 255) + } else { + (0, 0, 0) + }; + let alpha_levels: &[(f64, &str)] = &[ + (0.04, "--alpha-4"), + (0.05, "--alpha-5"), + (0.06, "--alpha-6"), + (0.08, "--alpha-8"), + (0.10, "--alpha-10"), + (0.15, "--alpha-15"), + (0.18, "--alpha-18"), + (0.20, "--alpha-20"), + (0.25, "--alpha-25"), + (0.30, "--alpha-30"), + (0.35, "--alpha-35"), + (0.40, "--alpha-40"), + (0.45, "--alpha-45"), + (0.50, "--alpha-50"), + (0.60, "--alpha-60"), + (0.70, "--alpha-70"), + (0.80, "--alpha-80"), + (0.85, "--alpha-85"), + (0.90, "--alpha-90"), + (0.95, "--alpha-95"), + ]; + for (alpha, name) in alpha_levels { + vars.insert( + name.to_string(), + format!( + "rgba({}, {}, {}, {})", + alpha_base.0, alpha_base.1, alpha_base.2, alpha + ), + ); + } + + GeneratedTheme { + variables: vars, + is_dark, + source: "system-colors".to_string(), + } +} + /// Ensure text has at least WCAG AA contrast (4.5:1) against the background. fn ensure_text_contrast( text: PaletteColor, diff --git a/src-tauri/src/auto_theme/mod.rs b/src-tauri/src/auto_theme/mod.rs index 2ca3698fd..dfc77e98d 100644 --- a/src-tauri/src/auto_theme/mod.rs +++ b/src-tauri/src/auto_theme/mod.rs @@ -166,6 +166,45 @@ pub struct GeneratedTheme { pub source: String, } +/// Full color scheme read from the desktop environment. +/// +/// Maps directly to the semantic color roles in KDE kdeglobals, GNOME dconf, etc. +/// Each field is optional because not all DEs expose all colors. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SystemColorScheme { + // Backgrounds + pub window_bg: Option, + pub window_bg_alt: Option, + pub view_bg: Option, + pub button_bg: Option, + pub header_bg: Option, + pub header_bg_inactive: Option, + pub tooltip_bg: Option, + + // Foregrounds (text) + pub window_fg: Option, + pub window_fg_inactive: Option, + pub view_fg: Option, + pub button_fg: Option, + + // Selection / accent + pub selection_bg: Option, + pub selection_fg: Option, + pub selection_hover: Option, + pub accent: Option, + + // Semantic + pub fg_link: Option, + pub fg_negative: Option, + pub fg_neutral: Option, + pub fg_positive: Option, + + // Window manager + pub wm_active_bg: Option, + pub wm_active_fg: Option, + pub wm_inactive_bg: Option, +} + #[cfg(test)] mod tests { use super::*; diff --git a/src-tauri/src/auto_theme/system.rs b/src-tauri/src/auto_theme/system.rs index 24f90d6a1..4ef215588 100644 --- a/src-tauri/src/auto_theme/system.rs +++ b/src-tauri/src/auto_theme/system.rs @@ -6,7 +6,7 @@ use std::fs; use std::path::PathBuf; use std::process::Command; -use super::PaletteColor; +use super::{PaletteColor, SystemColorScheme}; /// Supported desktop environments. #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] @@ -511,6 +511,141 @@ fn parse_cosmic_color(content: &str) -> Option { } } +// ── Full color scheme ──────────────────────────────────────────────────── + +/// Read the full system color scheme from the current DE. +pub fn get_system_color_scheme() -> Result { + let de = detect_desktop_environment(); + match de { + DesktopEnvironment::KdePlasma => get_kde_color_scheme(), + DesktopEnvironment::Gnome => get_gnome_color_scheme(), + _ => Err(format!( + "Full color scheme not supported for {}", + de.display_name() + )), + } +} + +fn get_kde_color_scheme() -> Result { + let home = env::var("HOME").map_err(|_| "HOME not set".to_string())?; + let config_path = format!("{}/.config/kdeglobals", home); + let content = + fs::read_to_string(&config_path).map_err(|e| format!("Cannot read kdeglobals: {}", e))?; + + // Also check [General] AccentColor + let accent_explicit = read_kde_color_key(&content, "[General]", "AccentColor"); + + let scheme = SystemColorScheme { + // Window + window_bg: read_kde_color_key(&content, "[Colors:Window]", "BackgroundNormal"), + window_bg_alt: read_kde_color_key(&content, "[Colors:Window]", "BackgroundAlternate"), + view_bg: read_kde_color_key(&content, "[Colors:View]", "BackgroundNormal"), + button_bg: read_kde_color_key(&content, "[Colors:Button]", "BackgroundNormal"), + header_bg: read_kde_color_key(&content, "[Colors:Header]", "BackgroundNormal"), + header_bg_inactive: read_kde_color_key(&content, "[Colors:Header][Inactive]", "BackgroundNormal"), + tooltip_bg: read_kde_color_key(&content, "[Colors:Tooltip]", "BackgroundNormal"), + + // Foregrounds + window_fg: read_kde_color_key(&content, "[Colors:Window]", "ForegroundNormal"), + window_fg_inactive: read_kde_color_key(&content, "[Colors:Window]", "ForegroundInactive"), + view_fg: read_kde_color_key(&content, "[Colors:View]", "ForegroundNormal"), + button_fg: read_kde_color_key(&content, "[Colors:Button]", "ForegroundNormal"), + + // Selection / accent + selection_bg: read_kde_color_key(&content, "[Colors:Selection]", "BackgroundNormal"), + selection_fg: read_kde_color_key(&content, "[Colors:Selection]", "ForegroundNormal"), + selection_hover: read_kde_color_key(&content, "[Colors:Selection]", "DecorationHover"), + accent: accent_explicit.or_else(|| { + read_kde_color_key(&content, "[Colors:Selection]", "DecorationFocus") + }), + + // Semantic + fg_link: read_kde_color_key(&content, "[Colors:Window]", "ForegroundLink"), + fg_negative: read_kde_color_key(&content, "[Colors:Window]", "ForegroundNegative"), + fg_neutral: read_kde_color_key(&content, "[Colors:Window]", "ForegroundNeutral"), + fg_positive: read_kde_color_key(&content, "[Colors:Window]", "ForegroundPositive"), + + // Window manager + wm_active_bg: read_kde_color_key(&content, "[WM]", "activeBackground"), + wm_active_fg: read_kde_color_key(&content, "[WM]", "activeForeground"), + wm_inactive_bg: read_kde_color_key(&content, "[WM]", "inactiveBackground"), + }; + + // Validate: at minimum we need window_bg and some accent + if scheme.window_bg.is_none() { + return Err("KDE color scheme missing Colors:Window BackgroundNormal".into()); + } + + Ok(scheme) +} + +fn get_gnome_color_scheme() -> Result { + // GNOME exposes much less via dconf. We can detect dark vs light and accent. + // Full background/text colors are determined by GTK theme, not easily readable. + let accent = get_gnome_accent().ok(); + + // Detect dark/light preference + let is_dark = Command::new("gsettings") + .args(["get", "org.gnome.desktop.interface", "color-scheme"]) + .output() + .ok() + .and_then(|o| { + if o.status.success() { + let val = String::from_utf8_lossy(&o.stdout).trim().to_lowercase(); + Some(val.contains("dark")) + } else { + None + } + }) + .unwrap_or(true); + + // Build a minimal scheme with GNOME defaults + let (bg, bg_alt, view_bg, btn_bg, fg, fg_inactive) = if is_dark { + ( + PaletteColor::new(36, 36, 36), // Adwaita Dark + PaletteColor::new(48, 48, 48), + PaletteColor::new(30, 30, 30), + PaletteColor::new(60, 60, 60), + PaletteColor::new(255, 255, 255), + PaletteColor::new(140, 140, 140), + ) + } else { + ( + PaletteColor::new(246, 245, 244), // Adwaita Light + PaletteColor::new(235, 235, 235), + PaletteColor::new(255, 255, 255), + PaletteColor::new(225, 225, 225), + PaletteColor::new(36, 36, 36), + PaletteColor::new(120, 120, 120), + ) + }; + + Ok(SystemColorScheme { + window_bg: Some(bg), + window_bg_alt: Some(bg_alt), + view_bg: Some(view_bg), + button_bg: Some(btn_bg), + header_bg: None, + header_bg_inactive: None, + tooltip_bg: None, + window_fg: Some(fg), + window_fg_inactive: Some(fg_inactive), + view_fg: Some(fg), + button_fg: Some(PaletteColor::new(255, 255, 255)), + selection_bg: accent.clone(), + selection_fg: Some(PaletteColor::new(255, 255, 255)), + selection_hover: None, + accent, + fg_link: None, + fg_negative: Some(PaletteColor::new(224, 27, 36)), + fg_neutral: Some(PaletteColor::new(205, 147, 9)), + fg_positive: Some(PaletteColor::new(38, 162, 105)), + wm_active_bg: None, + wm_active_fg: None, + wm_inactive_bg: None, + }) +} + fn is_image_path(path: &str) -> bool { let lower = path.to_lowercase(); lower.ends_with(".png") diff --git a/src-tauri/src/commands_v2.rs b/src-tauri/src/commands_v2.rs index 2d00dd256..2c5666ae4 100644 --- a/src-tauri/src/commands_v2.rs +++ b/src-tauri/src/commands_v2.rs @@ -10175,6 +10175,17 @@ pub async fn v2_generate_theme_from_wallpaper() -> Result Result { + let scheme = crate::auto_theme::system::get_system_color_scheme()?; + Ok(crate::auto_theme::generator::generate_theme_from_scheme(&scheme)) +} + +#[tauri::command] +pub fn v2_get_system_color_scheme() -> Result { + crate::auto_theme::system::get_system_color_scheme() +} + #[tauri::command] #[allow(non_snake_case)] pub async fn v2_extract_palette( diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index a8d83f92f..567068921 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -1110,6 +1110,8 @@ pub fn run() { commands_v2::v2_get_system_accent_color, commands_v2::v2_generate_theme_from_image, commands_v2::v2_generate_theme_from_wallpaper, + commands_v2::v2_generate_theme_from_system_colors, + commands_v2::v2_get_system_color_scheme, commands_v2::v2_extract_palette, ]) .run(tauri::generate_context!()) diff --git a/src/lib/stores/autoThemeStore.ts b/src/lib/stores/autoThemeStore.ts index 7f07ec5d8..fadcf6b97 100644 --- a/src/lib/stores/autoThemeStore.ts +++ b/src/lib/stores/autoThemeStore.ts @@ -144,85 +144,15 @@ function clearAutoThemeStorage(): void { // ── Internal: Theme generation strategies ─────────────────────────────────── -/** Try to generate theme from DE accent color. Returns null if unavailable. */ -async function tryAccentColorTheme(): Promise { +/** + * Try to generate theme from the DE's full color scheme. + * This reads backgrounds, text, accent, and all semantic colors directly + * from the DE configuration (kdeglobals for KDE, dconf for GNOME, etc.) + * — no wallpaper extraction or k-means needed. + */ +async function trySystemColorSchemeTheme(): Promise { try { - const accentColor = await invoke('v2_get_system_accent_color'); - // Build a theme using the accent color with a neutral dark base - // We generate from a synthetic image isn't ideal, so we build the theme - // by passing the accent to the wallpaper generator with a hint - // For now, use the accent as override on a wallpaper-based theme - // or generate a minimal theme from accent alone. - // - // Strategy: try wallpaper first (for backgrounds), but override accent with system accent - let baseTheme: GeneratedTheme | null = null; - try { - baseTheme = await invoke('v2_generate_theme_from_wallpaper'); - } catch { - // No wallpaper available, build from accent alone - } - - if (baseTheme) { - // Override accent variables with system accent color - const accentHex = `#${accentColor.r.toString(16).padStart(2, '0')}${accentColor.g.toString(16).padStart(2, '0')}${accentColor.b.toString(16).padStart(2, '0')}`; - baseTheme.variables['--accent-primary'] = accentHex; - // Compute hover/active shifts (simple lightness approximation) - baseTheme.variables['--accent-hover'] = shiftHexLightness(accentHex, 0.10); - baseTheme.variables['--accent-active'] = shiftHexLightness(accentHex, -0.10); - // Button text: white if accent is dark - const accentLum = (0.2126 * srgbLinear(accentColor.r) + 0.7152 * srgbLinear(accentColor.g) + 0.0722 * srgbLinear(accentColor.b)); - baseTheme.variables['--btn-primary-text'] = accentLum < 0.5 ? '#ffffff' : '#000000'; - baseTheme.source = 'system-accent+wallpaper'; - return baseTheme; - } - - // No wallpaper: build minimal theme from accent color only - // Use a neutral dark base - const isDark = true; // default to dark - const vars: Record = {}; - const accentHex = `#${accentColor.r.toString(16).padStart(2, '0')}${accentColor.g.toString(16).padStart(2, '0')}${accentColor.b.toString(16).padStart(2, '0')}`; - - // Dark base backgrounds - vars['--bg-primary'] = '#0f0f0f'; - vars['--bg-secondary'] = '#1a1a1a'; - vars['--bg-tertiary'] = '#2a2a2a'; - vars['--bg-hover'] = '#1f1f1f'; - - // Text - vars['--text-primary'] = '#ffffff'; - vars['--text-secondary'] = '#cccccc'; - vars['--text-muted'] = '#888888'; - vars['--text-disabled'] = '#555555'; - - // Accent from system - vars['--accent-primary'] = accentHex; - vars['--accent-hover'] = shiftHexLightness(accentHex, 0.10); - vars['--accent-active'] = shiftHexLightness(accentHex, -0.10); - const accentLum = (0.2126 * srgbLinear(accentColor.r) + 0.7152 * srgbLinear(accentColor.g) + 0.0722 * srgbLinear(accentColor.b)); - vars['--btn-primary-text'] = accentLum < 0.5 ? '#ffffff' : '#000000'; - - // Status - vars['--danger'] = '#ef4444'; - vars['--danger-bg'] = 'rgba(239, 68, 68, 0.1)'; - vars['--danger-border'] = 'rgba(239, 68, 68, 0.3)'; - vars['--danger-hover'] = 'rgba(239, 68, 68, 0.2)'; - vars['--warning'] = '#fbbf24'; - vars['--warning-bg'] = 'rgba(251, 191, 36, 0.1)'; - vars['--warning-border'] = 'rgba(251, 191, 36, 0.3)'; - vars['--warning-hover'] = 'rgba(251, 191, 36, 0.2)'; - - // Borders - vars['--border-subtle'] = '#2a2a2a'; - vars['--border-strong'] = '#3a3a3a'; - - // Alpha tokens (white-based for dark) - const alphaLevels = [0.04, 0.05, 0.06, 0.08, 0.10, 0.15, 0.18, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.60, 0.70, 0.80, 0.85, 0.90, 0.95]; - const alphaNames = ['4', '5', '6', '8', '10', '15', '18', '20', '25', '30', '35', '40', '45', '50', '60', '70', '80', '85', '90', '95']; - for (let i = 0; i < alphaLevels.length; i++) { - vars[`--alpha-${alphaNames[i]}`] = `rgba(255, 255, 255, ${alphaLevels[i]})`; - } - - return { variables: vars, is_dark: isDark, source: 'system-accent' }; + return await invoke('v2_generate_theme_from_system_colors'); } catch { return null; } @@ -238,58 +168,6 @@ async function generateFromImage(imagePath: string): Promise { return invoke('v2_generate_theme_from_image', { imagePath }); } -// ── Color math helpers (frontend-side, minimal) ───────────────────────────── - -function srgbLinear(c: number): number { - const s = c / 255; - return s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4); -} - -function shiftHexLightness(hex: string, amount: number): string { - const r = parseInt(hex.slice(1, 3), 16) / 255; - const g = parseInt(hex.slice(3, 5), 16) / 255; - const b = parseInt(hex.slice(5, 7), 16) / 255; - - const max = Math.max(r, g, b); - const min = Math.min(r, g, b); - let h = 0; - let s = 0; - const l = (max + min) / 2; - - if (max !== min) { - const d = max - min; - s = l > 0.5 ? d / (2 - max - min) : d / (max + min); - if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6; - else if (max === g) h = ((b - r) / d + 2) / 6; - else h = ((r - g) / d + 4) / 6; - } - - const newL = Math.max(0, Math.min(1, l + amount)); - - function hue2rgb(p: number, q: number, ht: number): number { - if (ht < 0) ht += 1; - if (ht > 1) ht -= 1; - if (ht < 1 / 6) return p + (q - p) * 6 * ht; - if (ht < 1 / 2) return q; - if (ht < 2 / 3) return p + (q - p) * (2 / 3 - ht) * 6; - return p; - } - - let nr: number, ng: number, nb: number; - if (s === 0) { - nr = ng = nb = newL; - } else { - const q = newL < 0.5 ? newL * (1 + s) : newL + s - newL * s; - const p = 2 * newL - q; - nr = hue2rgb(p, q, h + 1 / 3); - ng = hue2rgb(p, q, h); - nb = hue2rgb(p, q, h - 1 / 3); - } - - const toHex = (v: number) => Math.round(v * 255).toString(16).padStart(2, '0'); - return `#${toHex(nr)}${toHex(ng)}${toHex(nb)}`; -} - // ── Public API ────────────────────────────────────────────────────────────── /** @@ -319,17 +197,17 @@ export async function enableAutoTheme( let palette: ThemePalette | null = null; if (source === 'system') { - // Cascade: accent color → wallpaper → error - const accentTheme = await tryAccentColorTheme(); - if (accentTheme) { - theme = accentTheme; + // Cascade: full color scheme → wallpaper → error + const schemeTheme = await trySystemColorSchemeTheme(); + if (schemeTheme) { + theme = schemeTheme; } else { - // Fallback to wallpaper + // Fallback to wallpaper if DE color scheme is unavailable try { theme = await generateFromWallpaper(); } catch (wallpaperErr) { throw new Error( - `Could not infer system colors or wallpaper. ${wallpaperErr instanceof Error ? wallpaperErr.message : String(wallpaperErr)}` + `Could not read system color scheme or wallpaper. ${wallpaperErr instanceof Error ? wallpaperErr.message : String(wallpaperErr)}` ); } }