//! Where the desktop puts the window buttons, and which look they get. The parsers are pure //! functions over strings; the file reads at the bottom are thin. use crate::{Layout, policy::CaptionFamily}; use crate::desktop::DesktopKind; #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", test))] /// The value of `key` in `[section]` of an INI-style file (GTK's `settings.ini`, KDE's `kwinrc`). pub(crate) fn ini_value(text: &str, section: &str, key: &str) -> Option { let mut inside = false; for line in text.lines().map(str::trim) { if let Some(name) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) { inside = name == section; } else if inside && let Some((k, v)) = line.split_once('=') && k.trim() == key { return Some(v.trim().to_string()); } } None } #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", test))] /// KWin's button order (`[org.kde.kdecoration2]` `ButtonsOnLeft` / `ButtonsOnRight`, one letter a /// button: `I` minimize, `A` maximize, `X` close) as a GTK layout string. Missing keys keep KWin's /// defaults: the window menu on the left, minimize, maximize and close on the right. pub(crate) fn kwin_layout(kwinrc: &str) -> String { let side = |key: &str, default: &str| { let letters = ini_value(kwinrc, "org.kde.kdecoration2", key).unwrap_or_else(|| default.to_string()); letters .chars() .filter_map(|c| match c { 'I' => Some("minimize"), 'A' => Some("maximize"), 'X' => Some("close"), _ => None, }) .collect::>() .join(",") }; format!("{}:{}", side("ButtonsOnLeft", "MS"), side("ButtonsOnRight", "HIAX")) } #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", test))] /// The `gtk-decoration-layout` and `gtk-theme-name` of a GTK 3 `settings.ini`. pub(crate) fn gtk_settings(settings_ini: &str) -> (Option, Option) { (ini_value(settings_ini, "Settings", "gtk-decoration-layout"), ini_value(settings_ini, "Settings", "gtk-theme-name")) } /// The caption look. GNOME's apps are libadwaita's whatever the GTK theme, and KWin draws Breeze; /// elsewhere the GTK theme says (Adwaita, adw-gtk3, Yaru, Breeze), and any other theme gets the /// plain buttons. pub(crate) fn family(kind: DesktopKind, gtk_theme: Option<&str>) -> CaptionFamily { match kind { DesktopKind::Gnome => CaptionFamily::Adwaita, DesktopKind::Kde => CaptionFamily::Breeze, DesktopKind::Tiling | DesktopKind::Other => family_from_gtk_theme(gtk_theme), } } /// The family a GTK theme name stands for, else [`CaptionFamily::Generic`]. pub(crate) fn family_from_gtk_theme(gtk_theme: Option<&str>) -> CaptionFamily { let theme = gtk_theme.unwrap_or_default().trim().to_ascii_lowercase(); if ["adwaita", "adw-gtk3", "yaru"].iter().any(|p| theme.starts_with(p)) { CaptionFamily::Adwaita } else if theme.starts_with("breeze") { CaptionFamily::Breeze } else { CaptionFamily::Generic } } /// What a desktop that names no layout gets: GNOME's default shows Close only, GTK's all three. pub(crate) fn default_layout(kind: DesktopKind) -> Layout { if kind == DesktopKind::Gnome { Layout::parse("appmenu:close") } else { Layout::default() } } /// A parsed layout, or the default when the text names no usable button. #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", test))] fn parse_or_default(text: Option<&str>, kind: DesktopKind) -> Layout { text.map(Layout::parse).filter(Layout::is_usable).unwrap_or_else(|| default_layout(kind)) } /// The layout `kind` uses, read from the desktop's files (`kwinrc` on KDE, GTK's `settings.ini` /// elsewhere). GNOME's comes from `gsettings`, then GTK's `settings.ini`, then Close only. #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))] pub(crate) fn read_layout(kind: DesktopKind, var: &dyn Fn(&str) -> Option) -> Layout { match kind { DesktopKind::Gnome => { let from_gsettings = crate::platform::gsettings_button_layout().map(|v| Layout::parse(&v)).filter(Layout::is_usable); from_gsettings.unwrap_or_else(|| { let ini = read_config(var, "gtk-3.0/settings.ini").unwrap_or_default(); parse_or_default(gtk_settings(&ini).0.as_deref(), kind) }) } DesktopKind::Kde => { let rc = read_config(var, "kwinrc").unwrap_or_default(); parse_or_default(Some(&kwin_layout(&rc)), kind) } DesktopKind::Tiling | DesktopKind::Other => { let ini = read_config(var, "gtk-3.0/settings.ini").unwrap_or_default(); parse_or_default(gtk_settings(&ini).0.as_deref(), kind) } } } /// The GTK theme name from GTK 3's `settings.ini`. #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))] pub(crate) fn read_gtk_theme(var: &dyn Fn(&str) -> Option) -> Option { let from_env = var("GTK_THEME").map(|t| t.split(':').next().unwrap_or_default().to_string()).filter(|t| !t.is_empty()); from_env.or_else(|| read_config(var, "gtk-3.0/settings.ini").and_then(|ini| gtk_settings(&ini).1)) } #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", test))] /// The icon theme name for `kind`'s own setting (`kdeglobals` `[Icons] Theme` on KDE, GTK's /// `gtk-icon-theme-name` elsewhere), else the desktop's default theme. pub(crate) fn icon_theme(kind: DesktopKind, kdeglobals: &str, settings_ini: &str) -> String { let found = if kind == DesktopKind::Kde { ini_value(kdeglobals, "Icons", "Theme") } else { ini_value(settings_ini, "Settings", "gtk-icon-theme-name") }; found.filter(|t| !t.is_empty()).unwrap_or_else(|| if kind == DesktopKind::Kde { "breeze" } else { "Adwaita" }.to_string()) } /// [`icon_theme`] from the user's config files. #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))] pub(crate) fn read_icon_theme(kind: DesktopKind, var: &dyn Fn(&str) -> Option) -> String { let kdeglobals = if kind == DesktopKind::Kde { read_config(var, "kdeglobals").unwrap_or_default() } else { String::new() }; let ini = read_config(var, "gtk-3.0/settings.ini").unwrap_or_default(); icon_theme(kind, &kdeglobals, &ini) } /// A small file under the user's config directory (`XDG_CONFIG_HOME`, else `~/.config`). #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))] fn read_config(var: &dyn Fn(&str) -> Option, relative: &str) -> Option { use std::io::Read; let config = var("XDG_CONFIG_HOME") .filter(|d| std::path::Path::new(d).is_absolute()) .map(std::path::PathBuf::from) .or_else(|| var("HOME").map(|h| std::path::Path::new(&h).join(".config")))?; let mut bytes = Vec::new(); // Config files are small; the cap keeps a stray huge file from stalling startup. std::fs::File::open(config.join(relative)).ok()?.take(1 << 20).read_to_end(&mut bytes).ok()?; Some(String::from_utf8_lossy(&bytes).into_owned()) } #[cfg(test)] mod tests { use super::*; use crate::Button::{Close, Maximize, Minimize}; #[test] fn the_family_follows_the_desktop_then_the_gtk_theme() { assert_eq!(family(DesktopKind::Gnome, Some("Arc")), CaptionFamily::Adwaita); assert_eq!(family(DesktopKind::Kde, None), CaptionFamily::Breeze); assert_eq!(family(DesktopKind::Other, Some("adw-gtk3-dark")), CaptionFamily::Adwaita); assert_eq!(family(DesktopKind::Other, Some("Yaru-blue")), CaptionFamily::Adwaita); assert_eq!(family(DesktopKind::Other, Some("Breeze-Dark")), CaptionFamily::Breeze); assert_eq!(family(DesktopKind::Other, Some("Mint-Y")), CaptionFamily::Generic); assert_eq!(family(DesktopKind::Other, None), CaptionFamily::Generic); } #[test] fn kwin_button_letters_become_a_gtk_layout() { assert_eq!(kwin_layout(""), ":minimize,maximize,close", "KWin's defaults"); let rc = "[Desktops]\nButtonsOnLeft=X\n[org.kde.kdecoration2]\nButtonsOnLeft=XIA\nButtonsOnRight=\nlibrary=org.kde.breeze\n"; assert_eq!(kwin_layout(rc), "close,minimize,maximize:"); assert_eq!(ini_value(rc, "org.kde.kdecoration2", "library").as_deref(), Some("org.kde.breeze")); assert_eq!(ini_value(rc, "nope", "library"), None); // Garbage is just no buttons on that side, never a panic. assert_eq!(kwin_layout("[org.kde.kdecoration2]\nButtonsOnRight=\u{ff}\u{20ac}=X\n"), ":close"); } #[test] fn the_icon_theme_comes_from_the_setting_or_the_desktop_default() { let globals = "[Icons]\nTheme=breeze-dark\n"; let ini = "[Settings]\ngtk-icon-theme-name=Papirus\n"; assert_eq!(icon_theme(DesktopKind::Kde, globals, ini), "breeze-dark"); assert_eq!(icon_theme(DesktopKind::Other, globals, ini), "Papirus"); assert_eq!(icon_theme(DesktopKind::Gnome, "", ""), "Adwaita"); assert_eq!(icon_theme(DesktopKind::Kde, "", ini), "breeze"); } #[test] fn kwin_order_parses_into_a_layout() { let rc = "[org.kde.kdecoration2]\nButtonsOnLeft=XIA\nButtonsOnRight=\n"; let layout = Layout::parse(&kwin_layout(rc)); assert_eq!(layout.left, vec![Close, Minimize, Maximize]); assert!(layout.right.is_empty()); } #[test] fn gtk_settings_give_the_layout_and_theme() { let ini = "[Settings]\ngtk-theme-name=Yaru\ngtk-decoration-layout=close,maximize:\n"; assert_eq!(gtk_settings(ini), (Some("close,maximize:".into()), Some("Yaru".into()))); assert_eq!(gtk_settings(""), (None, None)); let layout = Layout::parse("close,maximize:"); assert_eq!((layout.left, layout.right), (vec![Close, Maximize], vec![])); } #[test] fn missing_or_unusable_layouts_fall_back_to_the_desktops_default() { assert_eq!(parse_or_default(None, DesktopKind::Gnome).right, vec![Close], "GNOME's default shows Close only"); assert_eq!(parse_or_default(Some("appmenu:spacer"), DesktopKind::Other).right, vec![Minimize, Maximize, Close]); assert_eq!(parse_or_default(Some("close:"), DesktopKind::Other).left, vec![Close]); } #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))] #[test] fn settings_files_are_read_from_the_config_dir() { let dir = std::env::temp_dir().join(format!("craft-window-layout-{}", std::process::id())); std::fs::create_dir_all(dir.join("gtk-3.0")).unwrap_or_default(); std::fs::write(dir.join("gtk-3.0/settings.ini"), "[Settings]\ngtk-theme-name=Yaru\ngtk-decoration-layout=close,maximize:\n") .unwrap_or_default(); std::fs::write(dir.join("kwinrc"), "[org.kde.kdecoration2]\nButtonsOnRight=AX\n").unwrap_or_default(); let path = dir.to_string_lossy().into_owned(); let var = move |k: &str| (k == "XDG_CONFIG_HOME").then(|| path.clone()); assert_eq!(read_gtk_theme(&var).as_deref(), Some("Yaru")); std::fs::write(dir.join("kdeglobals"), "[Icons]\nTheme=breeze-dark\n").unwrap_or_default(); assert_eq!(read_icon_theme(DesktopKind::Kde, &var), "breeze-dark"); let path2 = dir.to_string_lossy().into_owned(); let with_env = move |k: &str| match k { "XDG_CONFIG_HOME" => Some(path2.clone()), "GTK_THEME" => Some("Breeze:dark".to_string()), _ => None, }; assert_eq!(read_gtk_theme(&with_env).as_deref(), Some("Breeze"), "GTK_THEME wins over settings.ini"); assert_eq!(read_layout(DesktopKind::Other, &var).left, vec![Close, Maximize]); assert_eq!(read_layout(DesktopKind::Kde, &var).right, vec![Maximize, Close]); // A relative XDG_CONFIG_HOME is ignored, as the XDG spec says; with no HOME nothing is found. assert_eq!(read_gtk_theme(&|k: &str| (k == "XDG_CONFIG_HOME").then(|| "rel".to_string())), None); let _ = std::fs::remove_dir_all(dir); } }