Add theming

Author: klaatu01

Cargo.lock

@@ -16,4 +16,4 @@ yal-core = { path = "./crates/yal-core" }
 fuzzy-matcher = "0.3.7"
 
 [workspace]
-members = ["src-tauri","crates/yal-core", "crates/lightsky-sys", "crates/lightsky"]
+members = ["src-tauri","crates/yal-core", "crates/lightsky-sys", "crates/lightsky", "crates/yal-theme"]

Cargo.toml

@@ -19,19 +19,21 @@ pub enum AlignV {
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct AppConfig {
-    // UI
+    pub window: Option<WindowConfig>,
+    pub theme: Option<String>,
+    pub font: Option<FontConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct FontConfig {
     pub font: Option<String>,
     pub font_size: Option<f32>,
-    pub bg_color: Option<String>,
-    pub fg_color: Option<String>,
-    pub bg_font_color: Option<String>,
-    pub fg_font_color: Option<String>,
+}
 
-    // Window size
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct WindowConfig {
     pub w_width: Option<f64>,
     pub w_height: Option<f64>,
-
-    // Alignment + margins (optional; defaults used if omitted)
     pub align_h: Option<AlignH>,  // "left" | "center" | "right"
     pub align_v: Option<AlignV>,  // "top"  | "center" | "bottom"
     pub margin_x: Option<f64>,    // px inset from left/right edges (default ~12)
@@ -41,6 +43,15 @@ pub struct AppConfig {
     pub w_radius: Option<f64>,    // window corner radius in px (default ~0)
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Theme {
+    pub name: Option<String>,
+    pub bg_color: Option<String>,      // background color
+    pub fg_color: Option<String>,      // foreground color used for highlighting
+    pub bg_font_color: Option<String>, // font color used for background items
+    pub fg_font_color: Option<String>, // font color used for foreground items
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct AppInfo {
     pub name: String,
@@ -59,6 +70,7 @@ pub struct WindowTarget {
 pub enum Command {
     App(AppInfo),
     Switch(WindowTarget),
+    Theme(String),
 }
 
 impl Display for Command {
@@ -78,13 +90,15 @@ impl Command {
                     t.app_name.clone()
                 }
             }
+            Command::Theme(name) => name.clone(),
         }
     }
 
     pub fn prefix(&self) -> &str {
         match self {
             Command::App(_) => "app",
             Command::Switch(_) => "switch",
+            Command::Theme(_) => "theme",
         }
     }
 }
@@ -93,13 +107,16 @@ impl Command {
 pub enum CommandKind {
     App,
     Switch,
+    Theme,
 }
 
 impl CommandKind {
     pub fn is_kind(&self, cmd: &Command) -> bool {
         matches!(
             (self, cmd),
-            (CommandKind::App, Command::App(_)) | (CommandKind::Switch, Command::Switch(_))
+            (CommandKind::App, Command::App(_))
+                | (CommandKind::Switch, Command::Switch(_))
+                | (CommandKind::Theme, Command::Theme(_))
         )
     }
 }

crates/yal-core/src/lib.rs

@@ -0,0 +1,7 @@
+[package]
+name = "yal-theme"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+yal-core = { path = "../yal-core" }

crates/yal-theme/Cargo.toml

@@ -0,0 +1,208 @@
+use yal_core::Theme;
+
+#[derive(Copy, Clone, Debug)]
+pub struct ThemeRef {
+    pub name: &'static str,
+    pub bg_color: &'static str,
+    pub fg_color: &'static str,
+    pub bg_font_color: &'static str,
+    pub fg_font_color: &'static str,
+}
+
+impl ThemeRef {
+    pub const fn new(
+        name: &'static str,
+        bg_color: &'static str,
+        fg_color: &'static str,
+        bg_font_color: &'static str,
+        fg_font_color: &'static str,
+    ) -> Self {
+        Self {
+            name,
+            bg_color,
+            fg_color,
+            bg_font_color,
+            fg_font_color,
+        }
+    }
+
+    pub fn to_owned(self) -> Theme {
+        Theme {
+            name: Some(self.name.to_string()),
+            bg_color: Some(self.bg_color.to_string()),
+            fg_color: Some(self.fg_color.to_string()),
+            bg_font_color: Some(self.bg_font_color.to_string()),
+            fg_font_color: Some(self.fg_font_color.to_string()),
+        }
+    }
+}
+
+impl From<ThemeRef> for Theme {
+    fn from(t: ThemeRef) -> Self {
+        t.to_owned()
+    }
+}
+
+/* ------------------------------ Theme constants ------------------------------ */
+/* Notes:
+ * - `fg_color` is treated as the *highlight background*.
+ * - `bg_font_color` is normal text on `bg_color`.
+ * - `fg_font_color` is text on the highlighted row (`fg_color`).
+ * Tweak to taste per your UI.
+ */
+
+// Monokai (classic)
+pub const MONOKAI: ThemeRef = ThemeRef::new(
+    "monokai", "#272822", // bg
+    "#49483E", // highlight bg
+    "#F8F8F2", // text on bg
+    "#FFFFFF", // text on highlight
+);
+
+// Dracula
+pub const DRACULA: ThemeRef = ThemeRef::new("dracula", "#282A36", "#44475A", "#F8F8F2", "#FFFFFF");
+
+// Catppuccin — Latte (light)
+pub const CATPPUCCIN_LATTE: ThemeRef = ThemeRef::new(
+    "catppuccin-latte",
+    "#EFF1F5", // base
+    "#CCD0DA", // surface2-ish as highlight
+    "#4C4F69", // text
+    "#1E1E2E", // strong text on highlight
+);
+
+// Catppuccin — Frappé (dark)
+pub const CATPPUCCIN_FRAPPE: ThemeRef = ThemeRef::new(
+    "catppuccin-frappe",
+    "#303446", // base
+    "#414559", // surface1
+    "#C6D0F5", // text
+    "#E6E9EF", // text on highlight
+);
+
+// Catppuccin — Macchiato (dark)
+pub const CATPPUCCIN_MACCHIATO: ThemeRef = ThemeRef::new(
+    "catppuccin-macchiato",
+    "#24273A",
+    "#363A4F",
+    "#CAD3F5",
+    "#E8E8E8",
+);
+
+// Catppuccin — Mocha (dark)
+pub const CATPPUCCIN_MOCHA: ThemeRef = ThemeRef::new(
+    "catppuccin-mocha",
+    "#1E1E2E",
+    "#313244",
+    "#CDD6F4",
+    "#E6E6E6",
+);
+
+// Solarized Dark
+pub const SOLARIZED_DARK: ThemeRef =
+    ThemeRef::new("solarized-dark", "#002B36", "#073642", "#93A1A1", "#FDF6E3");
+
+// Solarized Light
+pub const SOLARIZED_LIGHT: ThemeRef = ThemeRef::new(
+    "solarized-light",
+    "#FDF6E3",
+    "#EEE8D5",
+    "#586E75",
+    "#073642",
+);
+
+// Gruvbox Dark (hard-ish)
+pub const GRUVBOX_DARK: ThemeRef =
+    ThemeRef::new("gruvbox-dark", "#282828", "#3C3836", "#EBDBB2", "#FBF1C7");
+
+// Gruvbox Light
+pub const GRUVBOX_LIGHT: ThemeRef =
+    ThemeRef::new("gruvbox-light", "#FBF1C7", "#EBDBB2", "#3C3836", "#282828");
+
+// Nord
+pub const NORD: ThemeRef = ThemeRef::new("nord", "#2E3440", "#3B4252", "#D8DEE9", "#ECEFF4");
+
+// One Dark
+pub const ONE_DARK: ThemeRef =
+    ThemeRef::new("one-dark", "#282C34", "#3E4451", "#ABB2BF", "#FFFFFF");
+
+// Tokyo Night (classic)
+pub const TOKYO_NIGHT: ThemeRef =
+    ThemeRef::new("tokyo-night", "#1A1B26", "#2F334D", "#C0CAF5", "#E6E6E6");
+
+// Tokyo Night Storm
+pub const TOKYO_NIGHT_STORM: ThemeRef = ThemeRef::new(
+    "tokyo-night-storm",
+    "#24283B",
+    "#283457",
+    "#C0CAF5",
+    "#E6E6E6",
+);
+
+/* --------------------------------- Registry --------------------------------- */
+
+pub const ALL: &[ThemeRef] = &[
+    MONOKAI,
+    DRACULA,
+    CATPPUCCIN_LATTE,
+    CATPPUCCIN_FRAPPE,
+    CATPPUCCIN_MACCHIATO,
+    CATPPUCCIN_MOCHA,
+    SOLARIZED_DARK,
+    SOLARIZED_LIGHT,
+    GRUVBOX_DARK,
+    GRUVBOX_LIGHT,
+    NORD,
+    ONE_DARK,
+    TOKYO_NIGHT,
+    TOKYO_NIGHT_STORM,
+];
+
+/// Case-insensitive lookup. Supports a few aliases.
+pub fn by_name(name: &str) -> Option<ThemeRef> {
+    let n = name.trim().to_lowercase();
+    let normalized = match n.as_str() {
+        // aliases
+        "one" | "onedark" | "one-dark-pro" => "one-dark",
+        "tokyo" | "tokyonight" => "tokyo-night",
+        "tokyo-storm" | "tokyonight-storm" => "tokyo-night-storm",
+        "catppuccin" => "catppuccin-mocha", // default flavor
+        "catppuccin-latte" | "latte" => "catppuccin-latte",
+        "catppuccin-frappe" | "frappe" => "catppuccin-frappe",
+        "catppuccin-macchiato" | "macchiato" => "catppuccin-macchiato",
+        "catppuccin-mocha" | "mocha" => "catppuccin-mocha",
+        other => other,
+    };
+
+    ALL.iter().copied().find(|t| t.name == normalized)
+}
+
+/// Owned theme list (useful for config UIs).
+pub fn list_owned() -> Vec<Theme> {
+    ALL.iter().copied().map(Theme::from).collect()
+}
+
+/* ----------------------------------- Tests ---------------------------------- */
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn from_ref_to_owned() {
+        let t: Theme = MONOKAI.into();
+        assert_eq!(t.name.as_deref(), Some("monokai"));
+        assert_eq!(t.bg_color.as_deref(), Some("#272822"));
+        assert_eq!(t.fg_color.as_deref(), Some("#49483E"));
+    }
+
+    #[test]
+    fn lookup_aliases() {
+        assert_eq!(by_name("OneDark").unwrap().name, "one-dark");
+        assert_eq!(by_name("catppuccin").unwrap().name, "catppuccin-mocha");
+        assert_eq!(
+            by_name("tokyonight-storm").unwrap().name,
+            "tokyo-night-storm"
+        );
+    }
+}

crates/yal-theme/src/lib.rs

@@ -40,6 +40,7 @@ tauri-plugin-log = "2"
 log = "0.4.28"
 once_cell = "1.21.3"
 lightsky = { path = "../crates/lightsky" }
+yal-theme = { path = "../crates/yal-theme" }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-autostart = "2"

src-tauri/Cargo.toml

@@ -8,12 +8,14 @@ use yal_core::{AppInfo, Command, WindowTarget};
 use crate::{ax::AX, cmd::app::get_app_info};
 
 mod app;
+pub mod theme;
 
 #[tauri::command]
 pub fn run_cmd(app: tauri::AppHandle, cmd: Command) -> Result<(), String> {
     match cmd {
         Command::App(app_info) => run_app_cmd(app, app_info),
         Command::Switch(target) => run_switch_cmd(app, target),
+        Command::Theme(theme) => run_theme_cmd(app, theme),
     }
 }
 
@@ -30,6 +32,13 @@ fn run_switch_cmd(app: tauri::AppHandle, target: WindowTarget) -> Result<(), Str
     Ok(())
 }
 
+fn run_theme_cmd(app: tauri::AppHandle, theme: String) -> Result<(), String> {
+    let theme_manager = app.state::<Arc<RwLock<theme::ThemeManager>>>();
+    let mut theme_manager = theme_manager.write().unwrap();
+    theme_manager.apply_theme(&app, &theme);
+    Ok(())
+}
+
 pub fn get_cmds(app: &tauri::AppHandle) -> Vec<Command> {
     let ax = app.state::<Arc<RwLock<AX>>>();
     let ax = ax.read().unwrap();
@@ -53,5 +62,15 @@ pub fn get_cmds(app: &tauri::AppHandle) -> Vec<Command> {
         .map(Command::Switch)
         .collect::<Vec<Command>>();
 
-    [app_infos, switch_targets].concat()
+    let themes = app
+        .state::<Arc<RwLock<theme::ThemeManager>>>()
+        .read()
+        .unwrap()
+        .load_themes()
+        .into_iter()
+        .filter_map(|t| t.name)
+        .map(Command::Theme)
+        .collect::<Vec<Command>>();
+
+    [app_infos, switch_targets, themes].concat()
 }