pub mod colors;
pub mod fonts;
use crate::Rgba;
use crate::model::IconSizes;
pub fn from_kde_content_pure(
content: &str,
font_dpi: Option<f32>,
) -> crate::Result<(crate::Theme, Option<f32>, crate::AccessibilityPreferences)> {
let mut ini = create_kde_parser();
ini.read(content.to_string())
.map_err(|e| crate::Error::ReaderFailed {
reader: "kde",
source: e.into(),
})?;
let mut variant = crate::ThemeMode::default();
colors::populate_colors(&ini, &mut variant);
fonts::populate_fonts(&ini, &mut variant);
crate::kde_metrics::populate_widget_sizing(&mut variant);
let reduce_motion = if let Some(anim_str) = ini.get("KDE", "AnimationDurationFactor")
&& let Ok(value) = anim_str.trim().parse::<f32>()
{
value == 0.0
} else {
false
};
let accessibility = crate::AccessibilityPreferences {
reduce_motion,
..Default::default()
};
let resolved_dpi = font_dpi.or_else(|| parse_force_font_dpi(&ini));
let dark = is_dark_theme(&ini);
let name = ini
.get("General", "ColorScheme")
.unwrap_or_else(|| "KDE".to_string());
variant.defaults.icon_theme = ini
.get("Icons", "Theme")
.filter(|s| !s.is_empty())
.map(std::borrow::Cow::Owned);
let theme = if dark {
crate::Theme {
name: std::borrow::Cow::Owned(name),
light: None,
dark: Some(variant),
layout: crate::LayoutTheme::default(),
icon_set: None,
icon_theme: None,
}
} else {
crate::Theme {
name: std::borrow::Cow::Owned(name),
light: Some(variant),
dark: None,
layout: crate::LayoutTheme::default(),
icon_set: None,
icon_theme: None,
}
};
Ok((theme, resolved_dpi, accessibility))
}
pub(crate) fn from_kde_content(content: &str) -> crate::Result<crate::ReaderResult> {
let mut ini = create_kde_parser();
ini.read(content.to_string())
.map_err(|e| crate::Error::ReaderFailed {
reader: "kde",
source: e.into(),
})?;
let font_dpi = detect_font_dpi(&ini);
let (theme, _dpi, accessibility) = from_kde_content_pure(content, Some(font_dpi))?;
let is_dark = theme.dark.is_some() && theme.light.is_none();
let mut mode_data = if is_dark {
theme.dark.unwrap_or_default()
} else {
theme.light.unwrap_or_default()
};
if let Some(ref theme_name) = mode_data.defaults.icon_theme {
mode_data.defaults.icon_sizes = parse_icon_sizes_from_index_theme(theme_name);
}
let output = crate::ReaderOutput::Single {
mode: Box::new(mode_data),
is_dark,
};
Ok(crate::ReaderResult {
output,
name: theme.name,
icon_set: theme.icon_set,
layout: theme.layout,
font_dpi: Some(font_dpi),
accessibility,
})
}
fn parse_force_font_dpi(ini: &configparser::ini::Ini) -> Option<f32> {
let dpi_str = ini.get("General", "forceFontDPI")?;
let dpi = dpi_str.trim().parse::<f32>().ok()?;
if dpi > 0.0 { Some(dpi) } else { None }
}
fn detect_font_dpi(ini: &configparser::ini::Ini) -> f32 {
let dpi_str = ini
.get("General", "forceFontDPI")
.or_else(|| read_kcmfontsrc_key("General", "forceFontDPI"));
if let Some(dpi_str) = dpi_str
&& let Ok(dpi) = dpi_str.trim().parse::<f32>()
&& dpi > 0.0
{
return dpi;
}
if let Some(dpi) = crate::detect::xft_dpi() {
return dpi;
}
if let Some(dpi) = crate::detect::physical_dpi() {
return dpi;
}
96.0
}
pub(crate) fn read_kcmfontsrc_key(section: &str, key: &str) -> Option<String> {
let path = if let Ok(config_home) = std::env::var("XDG_CONFIG_HOME") {
if config_home.is_empty() {
None
} else {
Some(std::path::PathBuf::from(config_home).join("kcmfontsrc"))
}
} else {
None
}
.or_else(|| {
std::env::var("HOME").ok().map(|h| {
std::path::PathBuf::from(h)
.join(".config")
.join("kcmfontsrc")
})
})?;
let content = std::fs::read_to_string(path).ok()?;
let mut ini = create_kde_parser();
ini.read(content).ok()?;
ini.get(section, key)
}
pub(crate) fn parse_icon_sizes_from_content(ini: &configparser::ini::Ini) -> IconSizes {
let dirs_str = match ini.get("Icon Theme", "Directories") {
Some(s) if !s.trim().is_empty() => s,
_ => return IconSizes::default(),
};
let mut entries: Vec<(u32, String)> = Vec::new();
for dir_name in dirs_str.split(',') {
let dir_name = dir_name.trim();
if dir_name.is_empty() {
continue;
}
let size = ini
.get(dir_name, "Size")
.and_then(|s| s.trim().parse::<u32>().ok());
let context = ini.get(dir_name, "Context");
if let (Some(sz), Some(ctx)) = (size, context) {
entries.push((sz, ctx));
}
}
if entries.is_empty() {
return IconSizes::default();
}
let small = entries
.iter()
.filter(|(_, ctx)| ctx == "Actions" || ctx == "Status")
.map(|(sz, _)| *sz)
.min()
.map(|sz| sz as f32);
let toolbar = entries
.iter()
.filter(|(_, ctx)| ctx == "Actions")
.map(|(sz, _)| *sz)
.min_by_key(|sz| sz.abs_diff(22))
.map(|sz| sz as f32);
let large = {
let app_sizes: Vec<u32> = entries
.iter()
.filter(|(_, ctx)| ctx == "Applications")
.map(|(sz, _)| *sz)
.collect();
if app_sizes.is_empty() {
None
} else {
let ge32: Vec<u32> = app_sizes.iter().copied().filter(|&s| s >= 32).collect();
if ge32.is_empty() {
app_sizes.iter().copied().max().map(|sz| sz as f32)
} else {
ge32.iter().copied().min().map(|sz| sz as f32)
}
}
};
let dialog = ini
.get("Icon Theme", "DialogDefault")
.and_then(|s| s.trim().parse::<u32>().ok())
.map(|sz| sz as f32);
let panel = ini
.get("Icon Theme", "PanelDefault")
.and_then(|s| s.trim().parse::<u32>().ok())
.map(|sz| sz as f32);
IconSizes {
small,
toolbar,
large,
dialog,
panel,
}
}
pub(crate) fn parse_icon_sizes_from_index_theme(theme_name: &str) -> IconSizes {
let path = match find_index_theme_path(theme_name) {
Some(p) => p,
None => return IconSizes::default(),
};
let content = match std::fs::read_to_string(&path) {
Ok(c) => c,
Err(_) => return IconSizes::default(),
};
let mut ini = create_kde_parser();
if ini.read(content).is_err() {
return IconSizes::default();
}
parse_icon_sizes_from_content(&ini)
}
fn find_index_theme_path(theme_name: &str) -> Option<std::path::PathBuf> {
if let Ok(home) = std::env::var("HOME") {
let p = std::path::PathBuf::from(home)
.join(".local/share/icons")
.join(theme_name)
.join("index.theme");
if p.exists() {
return Some(p);
}
}
let data_dirs = std::env::var("XDG_DATA_DIRS")
.unwrap_or_else(|_| "/usr/local/share:/usr/share".to_string());
for dir in data_dirs.split(':') {
let dir = dir.trim();
if dir.is_empty() {
continue;
}
let p = std::path::PathBuf::from(dir)
.join("icons")
.join(theme_name)
.join("index.theme");
if p.exists() {
return Some(p);
}
}
None
}
pub(crate) struct KdeReader;
#[async_trait::async_trait]
impl crate::reader::ThemeReader for KdeReader {
async fn read(&self) -> crate::Result<crate::ReaderResult> {
let path = kdeglobals_path();
let content = std::fs::read_to_string(&path).map_err(|e| crate::Error::ReaderFailed {
reader: "kde",
source: format!("cannot read {}: {e}", path.display()).into(),
})?;
let mut result = from_kde_content(&content)?;
let mode = match &mut result.output {
crate::ReaderOutput::Single { mode, .. } => &mut **mode,
crate::ReaderOutput::Dual { light, .. } => &mut **light,
};
if mode.defaults.icon_theme.is_none()
&& let Some(parent) = path.parent()
{
let defaults_path = parent.join("kdedefaults").join("kdeglobals");
if let Ok(defaults_content) = std::fs::read_to_string(&defaults_path) {
let mut defaults_ini = create_kde_parser();
if defaults_ini.read(defaults_content).is_ok() {
mode.defaults.icon_theme = defaults_ini
.get("Icons", "Theme")
.filter(|s| !s.is_empty())
.map(std::borrow::Cow::Owned);
}
}
}
Ok(result)
}
}
pub(crate) fn create_kde_parser() -> configparser::ini::Ini {
let tmp = configparser::ini::Ini::new_cs();
let mut defaults = tmp.defaults();
defaults.delimiters = vec!['='];
configparser::ini::Ini::new_from_defaults(defaults)
}
pub(crate) fn parse_rgb(value: &str) -> Option<Rgba> {
let parts: Vec<&str> = value.split(',').collect();
let [r_s, g_s, b_s] = parts.as_slice() else {
return None;
};
let r = r_s.trim().parse::<u8>().ok()?;
let g = g_s.trim().parse::<u8>().ok()?;
let b = b_s.trim().parse::<u8>().ok()?;
Some(Rgba::rgb(r, g, b))
}
pub(crate) fn kdeglobals_path() -> std::path::PathBuf {
if let Ok(config_home) = std::env::var("XDG_CONFIG_HOME")
&& !config_home.is_empty()
{
return std::path::PathBuf::from(config_home).join("kdeglobals");
}
if let Ok(home) = std::env::var("HOME") {
return std::path::PathBuf::from(home)
.join(".config")
.join("kdeglobals");
}
std::path::PathBuf::from("/etc/xdg/kdeglobals")
}
#[cfg(test)]
fn kdeglobals_path_pure(xdg_config_home: Option<&str>, home: Option<&str>) -> std::path::PathBuf {
if let Some(config_home) = xdg_config_home
&& !config_home.is_empty()
{
return std::path::PathBuf::from(config_home).join("kdeglobals");
}
if let Some(home) = home {
return std::path::PathBuf::from(home)
.join(".config")
.join("kdeglobals");
}
std::path::PathBuf::from("/etc/xdg/kdeglobals")
}
#[cfg(test)]
pub(crate) fn from_kde_at(path: &std::path::Path) -> crate::Result<crate::Theme> {
let content = std::fs::read_to_string(path).map_err(|e| crate::Error::ReaderFailed {
reader: "kde",
source: Box::new(e),
})?;
let result = from_kde_content(&content)?;
Ok(result
.output
.to_theme(&result.name, result.icon_set, &result.layout))
}
pub(crate) fn is_dark_theme(ini: &configparser::ini::Ini) -> bool {
if let Some(bg_str) = ini.get("Colors:Window", "BackgroundNormal")
&& let Some(bg) = parse_rgb(&bg_str)
{
let luma = 0.299 * (bg.r as f32) + 0.587 * (bg.g as f32) + 0.114 * (bg.b as f32);
return luma < 128.0;
}
false
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::Rgba;
use crate::model::font::FontSize;
#[test]
fn parse_rgb_valid_breeze_accent() {
assert_eq!(parse_rgb("61,174,233"), Some(Rgba::rgb(61, 174, 233)));
}
#[test]
fn parse_rgb_handles_whitespace() {
assert_eq!(parse_rgb("0, 0, 0"), Some(Rgba::rgb(0, 0, 0)));
}
#[test]
fn parse_rgb_white() {
assert_eq!(parse_rgb("255,255,255"), Some(Rgba::rgb(255, 255, 255)));
}
#[test]
fn parse_rgb_invalid_text() {
assert_eq!(parse_rgb("invalid"), None);
}
#[test]
fn parse_rgb_too_few_components() {
assert_eq!(parse_rgb("1,2"), None);
}
#[test]
fn parse_rgb_too_many_components() {
assert_eq!(parse_rgb("1,2,3,4"), None);
}
#[test]
fn parse_rgb_out_of_u8_range() {
assert_eq!(parse_rgb("256,0,0"), None);
}
#[test]
fn parse_rgb_empty_string() {
assert_eq!(parse_rgb(""), None);
}
#[test]
fn kdeglobals_path_respects_xdg_config_home() {
let path = kdeglobals_path_pure(Some("/tmp/test"), Some("/home/user"));
assert_eq!(path, std::path::PathBuf::from("/tmp/test/kdeglobals"));
}
#[test]
fn kdeglobals_path_falls_back_to_home_config() {
let path = kdeglobals_path_pure(None, Some("/home/testuser"));
assert_eq!(
path,
std::path::PathBuf::from("/home/testuser")
.join(".config")
.join("kdeglobals")
);
}
#[test]
fn kdeglobals_path_fallback_to_etc_xdg() {
let path = kdeglobals_path_pure(None, None);
assert_eq!(path, std::path::PathBuf::from("/etc/xdg/kdeglobals"));
}
#[test]
fn is_dark_theme_detects_breeze_dark() {
let mut ini = create_kde_parser();
ini.read("[Colors:Window]\nBackgroundNormal=20,22,24\n".to_string())
.unwrap();
assert!(is_dark_theme(&ini));
}
#[test]
fn is_dark_theme_detects_breeze_light() {
let mut ini = create_kde_parser();
ini.read("[Colors:Window]\nBackgroundNormal=239,240,241\n".to_string())
.unwrap();
assert!(!is_dark_theme(&ini));
}
#[test]
fn is_dark_theme_defaults_false_when_missing() {
let ini = create_kde_parser();
assert!(!is_dark_theme(&ini));
}
#[test]
fn create_kde_parser_is_case_sensitive() {
let mut ini = create_kde_parser();
ini.read("[Colors:View]\nBackgroundNormal=255,255,255\n".to_string())
.unwrap();
assert!(ini.get("Colors:View", "BackgroundNormal").is_some());
}
#[test]
fn create_kde_parser_preserves_section_colons() {
let mut ini = create_kde_parser();
ini.read("[Colors:Window]\nForegroundNormal=0,0,0\n".to_string())
.unwrap();
assert!(ini.get("Colors:Window", "ForegroundNormal").is_some());
}
#[test]
fn create_kde_parser_equals_only_delimiter() {
let mut ini = create_kde_parser();
ini.read("[Test]\nsome:value=actual\n".to_string()).unwrap();
assert_eq!(ini.get("Test", "some:value"), Some("actual".to_string()));
}
const BREEZE_DARK_FULL: &str = "\
[General]
ColorScheme=BreezeDark
font=Noto Sans,10,-1,5,400,0,0,0,0,0,0,0,0,0,0,1
fixed=Hack,10,-1,5,400,0,0,0,0,0,0,0,0,0,0,1
menuFont=Noto Sans,9,-1,5,400,0,0,0,0,0,0,0,0,0,0,1
toolBarFont=Noto Sans,8,-1,5,400,0,0,0,0,0,0,0,0,0,0,1
smallestReadableFont=Noto Sans,7,-1,5,400,0,0,0,0,0,0,0,0,0,0,1
forceFontDPI=120
[KDE]
AnimationDurationFactor=0
[Icons]
Theme=breeze-dark
[Colors:View]
BackgroundNormal=35,38,41
BackgroundAlternate=30,33,36
ForegroundNormal=252,252,252
ForegroundInactive=161,169,177
ForegroundActive=61,174,233
ForegroundLink=29,153,243
ForegroundNegative=218,68,83
ForegroundNeutral=246,116,0
ForegroundPositive=39,174,96
ForegroundVisited=155,89,182
DecorationFocus=61,174,233
DecorationHover=29,153,243
[Colors:Window]
BackgroundNormal=49,54,59
BackgroundAlternate=44,49,54
ForegroundNormal=239,240,241
ForegroundInactive=161,169,177
ForegroundActive=61,174,233
ForegroundLink=29,153,243
ForegroundNegative=218,68,83
ForegroundNeutral=246,116,0
ForegroundPositive=39,174,96
DecorationFocus=61,174,233
DecorationHover=29,153,243
[Colors:Button]
BackgroundNormal=49,54,59
BackgroundAlternate=44,49,54
ForegroundNormal=239,240,241
ForegroundInactive=161,169,177
[Colors:Selection]
BackgroundNormal=61,174,233
BackgroundAlternate=29,153,243
ForegroundNormal=252,252,252
ForegroundInactive=161,169,177
[Colors:Tooltip]
BackgroundNormal=49,54,59
ForegroundNormal=252,252,252
[Colors:Complementary]
BackgroundNormal=42,46,50
ForegroundNormal=239,240,241
[Colors:Header]
BackgroundNormal=35,38,41
ForegroundNormal=252,252,252
[WM]
activeBackground=49,54,59
activeForeground=239,240,241
inactiveBackground=42,46,50
inactiveForeground=161,169,177
activeFont=Noto Sans,10,-1,5,75,0,0,0,0,0
";
const BREEZE_LIGHT_FULL: &str = "\
[General]
ColorScheme=BreezeLight
[Colors:View]
BackgroundNormal=255,255,255
ForegroundNormal=35,38,41
DecorationFocus=61,174,233
[Colors:Window]
BackgroundNormal=239,240,241
ForegroundNormal=35,38,41
ForegroundInactive=127,140,141
DecorationFocus=61,174,233
[Colors:Button]
BackgroundNormal=239,240,241
ForegroundNormal=35,38,41
[Colors:Selection]
BackgroundNormal=61,174,233
ForegroundNormal=255,255,255
[Colors:Tooltip]
BackgroundNormal=247,247,247
ForegroundNormal=35,38,41
";
const MINIMAL_FIXTURE: &str = "\
[Colors:Window]
BackgroundNormal=49,54,59
";
fn reader_mode(result: &crate::ReaderResult) -> &crate::ThemeMode {
match &result.output {
crate::ReaderOutput::Single { mode, .. } => mode,
crate::ReaderOutput::Dual { light, .. } => light,
}
}
#[test]
fn test_dark_theme_detection() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
assert!(
matches!(
result.output,
crate::ReaderOutput::Single { is_dark: true, .. }
),
"dark variant should be populated"
);
}
#[test]
fn test_light_theme_detection() {
let result = from_kde_content(BREEZE_LIGHT_FULL).unwrap();
assert!(
matches!(
result.output,
crate::ReaderOutput::Single { is_dark: false, .. }
),
"light variant should be populated"
);
}
#[test]
fn test_theme_name_from_colorscheme() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
assert_eq!(result.name, "BreezeDark");
}
#[test]
fn test_theme_name_fallback() {
let content = "[Colors:Window]\nBackgroundNormal=49,54,59\n";
let result = from_kde_content(content).unwrap();
assert_eq!(result.name, "KDE");
}
#[test]
fn test_colors_populated() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let variant = reader_mode(&result);
assert!(variant.defaults.accent_color.is_some());
assert!(variant.defaults.background_color.is_some());
assert!(variant.defaults.text_color.is_some());
}
#[test]
fn test_fonts_populated() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let variant = reader_mode(&result);
assert_eq!(variant.defaults.font.family.as_deref(), Some("Noto Sans"));
assert_eq!(variant.defaults.font.size, Some(FontSize::Pt(10.0)));
assert_eq!(variant.defaults.mono_font.family.as_deref(), Some("Hack"));
assert_eq!(variant.defaults.mono_font.size, Some(FontSize::Pt(10.0)));
}
#[test]
fn test_minimal_fixture_no_panic() {
let result = from_kde_content(MINIMAL_FIXTURE);
assert!(
result.is_ok(),
"minimal fixture should not panic: {result:?}"
);
let r = result.unwrap();
assert!(matches!(
r.output,
crate::ReaderOutput::Single { is_dark: true, .. }
));
}
#[test]
fn test_from_kde_content_populates_widget_sizing() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let variant = reader_mode(&result);
assert_eq!(variant.button.min_width, Some(80.0), "Button_MinWidth");
assert_eq!(
variant.scrollbar.groove_width,
Some(21.0),
"ScrollBar_Extend"
);
}
#[test]
fn test_empty_content() {
let result = from_kde_content("");
assert!(
result.is_ok(),
"empty content should produce Ok: {result:?}"
);
let r = result.unwrap();
assert_eq!(r.name, "KDE");
}
#[test]
fn test_missing_file() {
let path = std::path::PathBuf::from("/tmp/nonexistent_kde_test_dir_12345/kdeglobals");
let result = from_kde_at(&path);
assert!(result.is_err());
let err = result.unwrap_err();
let crate::Error::ReaderFailed { source, .. } = &err else {
panic!("expected ReaderFailed, got: {err:?}");
};
let msg = source.to_string();
assert!(
msg.contains("kdeglobals") || msg.contains("No such file"),
"unexpected error message: {msg}"
);
}
#[test]
fn test_button_colors_populated() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.button.background_color, Some(Rgba::rgb(49, 54, 59)));
assert_eq!(
v.button.font.as_ref().and_then(|f| f.color),
Some(Rgba::rgb(239, 240, 241))
);
}
#[test]
fn test_tooltip_colors_populated() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.tooltip.background_color, Some(Rgba::rgb(49, 54, 59)));
assert_eq!(
v.tooltip.font.as_ref().and_then(|f| f.color),
Some(Rgba::rgb(252, 252, 252))
);
}
#[test]
fn test_sidebar_colors_populated() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.sidebar.background_color, Some(Rgba::rgb(42, 46, 50)));
assert_eq!(
v.sidebar.font.as_ref().and_then(|f| f.color),
Some(Rgba::rgb(239, 240, 241))
);
}
#[test]
fn test_wm_title_bar_colors() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.window.title_bar_background, Some(Rgba::rgb(49, 54, 59)));
assert_eq!(
v.window.title_bar_font.as_ref().and_then(|f| f.color),
Some(Rgba::rgb(239, 240, 241))
);
assert_eq!(
v.window.inactive_title_bar_background,
Some(Rgba::rgb(42, 46, 50))
);
assert_eq!(
v.window.inactive_title_bar_text_color,
Some(Rgba::rgb(161, 169, 177))
);
}
#[test]
fn test_list_header_colors() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.list.header_background, Some(Rgba::rgb(35, 38, 41)));
assert_eq!(
v.list.header_font.as_ref().and_then(|f| f.color),
Some(Rgba::rgb(252, 252, 252))
);
}
#[test]
fn test_link_visited() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.link.visited_text_color, Some(Rgba::rgb(155, 89, 182)));
}
#[test]
fn test_animation_duration_factor_zero_sets_reduce_motion_true() {
let (_theme, _dpi, accessibility) = from_kde_content_pure(BREEZE_DARK_FULL, None).unwrap();
assert!(accessibility.reduce_motion);
}
#[test]
fn test_animation_duration_factor_nonzero_sets_reduce_motion_false() {
let content = "\
[Colors:Window]
BackgroundNormal=49,54,59
[KDE]
AnimationDurationFactor=1.0
";
let (_theme, _dpi, accessibility) = from_kde_content_pure(content, None).unwrap();
assert!(!accessibility.reduce_motion);
}
#[test]
fn test_force_font_dpi_sets_font_dpi() {
let (_theme, dpi, _accessibility) = from_kde_content_pure(BREEZE_DARK_FULL, None).unwrap();
assert_eq!(dpi, Some(120.0));
}
#[test]
fn test_missing_accessibility_leaves_defaults() {
let content = "\
[Colors:Window]
BackgroundNormal=49,54,59
";
let (_theme, dpi, accessibility) = from_kde_content_pure(content, None).unwrap();
assert!(!accessibility.reduce_motion);
assert_eq!(accessibility.text_scaling_factor, 1.0);
assert!(dpi.is_none());
}
#[test]
fn test_icon_theme_from_icons_theme() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
assert!(result.icon_set.is_none());
let v = reader_mode(&result);
assert_eq!(v.defaults.icon_theme.as_deref(), Some("breeze-dark"));
}
#[test]
fn test_icon_theme_none_when_missing() {
let content = "\
[Colors:Window]
BackgroundNormal=49,54,59
";
let result = from_kde_content(content).unwrap();
assert!(result.icon_set.is_none());
let v = reader_mode(&result);
assert!(v.defaults.icon_theme.is_none());
}
const BREEZE_INDEX_THEME: &str = "\
[Icon Theme]
Name=breeze-dark
Comment=Breeze Dark
Directories=actions/16,actions/22,actions/32,apps/16,apps/32,apps/48,status/16,status/22
[actions/16]
Size=16
Context=Actions
Type=Fixed
[actions/22]
Size=22
Context=Actions
Type=Fixed
[actions/32]
Size=32
Context=Actions
Type=Fixed
[apps/16]
Size=16
Context=Applications
Type=Fixed
[apps/32]
Size=32
Context=Applications
Type=Fixed
[apps/48]
Size=48
Context=Applications
Type=Fixed
[status/16]
Size=16
Context=Status
Type=Fixed
[status/22]
Size=22
Context=Status
Type=Fixed
";
#[test]
fn test_parse_icon_sizes_from_content() {
let mut ini = create_kde_parser();
ini.read(BREEZE_INDEX_THEME.to_string()).unwrap();
let sizes = parse_icon_sizes_from_content(&ini);
assert_eq!(
sizes.small,
Some(16.0),
"small should be 16 from actions/16 and status/16"
);
assert_eq!(
sizes.toolbar,
Some(22.0),
"toolbar should be 22 from actions/22"
);
assert_eq!(sizes.large, Some(32.0), "large should be 32 from apps/32");
assert!(sizes.dialog.is_none(), "dialog should remain None");
assert!(sizes.panel.is_none(), "panel should remain None");
}
#[test]
fn test_parse_icon_sizes_missing_theme() {
let sizes =
parse_icon_sizes_from_index_theme("nonexistent_theme_that_does_not_exist_12345");
assert!(
sizes.small.is_none(),
"small should be None for missing theme"
);
assert!(
sizes.toolbar.is_none(),
"toolbar should be None for missing theme"
);
assert!(
sizes.large.is_none(),
"large should be None for missing theme"
);
assert!(
sizes.dialog.is_none(),
"dialog should be None for missing theme"
);
assert!(
sizes.panel.is_none(),
"panel should be None for missing theme"
);
}
#[test]
fn test_parse_icon_sizes_empty_directories() {
let content = "\
[Icon Theme]
Name=empty
Directories=
";
let mut ini = create_kde_parser();
ini.read(content.to_string()).unwrap();
let sizes = parse_icon_sizes_from_content(&ini);
assert!(sizes.small.is_none());
assert!(sizes.toolbar.is_none());
assert!(sizes.large.is_none());
}
#[test]
fn test_parse_icon_sizes_no_icon_theme_section() {
let content = "\
[General]
Name=whatever
";
let mut ini = create_kde_parser();
ini.read(content.to_string()).unwrap();
let sizes = parse_icon_sizes_from_content(&ini);
assert!(sizes.small.is_none());
assert!(sizes.toolbar.is_none());
assert!(sizes.large.is_none());
}
#[test]
fn test_icon_sizes_populated_in_full_parse() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
if let Some(small) = v.defaults.icon_sizes.small {
assert!(
(8.0..=32.0).contains(&small),
"small icon size should be reasonable: {small}"
);
if let Some(large) = v.defaults.icon_sizes.large {
assert!(
(24.0..=128.0).contains(&large),
"large icon size should be reasonable: {large}"
);
assert!(large > small, "large should be bigger than small");
}
}
}
#[test]
fn test_dialog_button_order_not_set_by_reader() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(
v.dialog.button_order, None,
"reader must not hardcode button_order -- resolver handles it"
);
}
#[test]
fn test_widget_sizing_checkbox_indicator() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.checkbox.indicator_width, Some(20.0));
}
#[test]
fn test_widget_sizing_splitter() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
assert_eq!(v.splitter.divider_width, Some(1.0));
}
#[test]
fn test_menu_font_from_menufont() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
let mf = v.menu.font.as_ref().expect("menu.font should be set");
assert_eq!(mf.family.as_deref(), Some("Noto Sans"));
assert_eq!(mf.size, Some(FontSize::Pt(9.0)));
}
#[test]
fn test_toolbar_font_from_toolbarfont() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
let tf = v.toolbar.font.as_ref().expect("toolbar.font should be set");
assert_eq!(tf.family.as_deref(), Some("Noto Sans"));
assert_eq!(tf.size, Some(FontSize::Pt(8.0)));
}
#[test]
fn test_title_bar_font_from_wm_activefont() {
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let v = reader_mode(&result);
let tbf = v
.window
.title_bar_font
.as_ref()
.expect("title_bar_font should be set");
assert_eq!(tbf.family.as_deref(), Some("Noto Sans"));
assert_eq!(tbf.size, Some(FontSize::Pt(10.0)));
assert_eq!(tbf.weight, Some(700)); }
#[test]
fn test_kde_resolve_validate() {
let mut base = crate::Theme::preset("kde-breeze").unwrap();
let result = from_kde_content(BREEZE_DARK_FULL).unwrap();
let kde_theme = result
.output
.to_theme(&result.name, result.icon_set, &result.layout);
base.merge(&kde_theme);
let mut dark = base
.dark
.clone()
.expect("dark variant should exist after merge");
dark.resolve_all();
let resolved = dark.validate().unwrap_or_else(|e| {
panic!("KDE resolve/validate pipeline failed: {e}");
});
assert_eq!(
resolved.defaults.accent_color,
crate::Rgba::rgb(61, 174, 233),
"accent should be from KDE reader"
);
assert_eq!(
resolved.defaults.font.family.as_ref(),
"Noto Sans",
"font family should be from KDE reader"
);
assert_eq!(
resolved.button.background_color,
crate::Rgba::rgb(49, 54, 59),
"button bg should be from KDE reader"
);
assert_eq!(
resolved.window.title_bar_background,
crate::Rgba::rgb(49, 54, 59),
"title bar bg should be from KDE reader"
);
assert_eq!(
resolved.input.caret_color,
crate::Rgba::rgb(61, 174, 233),
"input.caret should be from KDE reader (DecorationFocus)"
);
assert_eq!(
resolved.dialog.button_order,
crate::DialogButtonOrder::PrimaryLeft,
"dialog button order should be leading affirmative for KDE"
);
}
#[test]
fn kde_reader_exists_and_implements_theme_reader() {
let r: Box<dyn crate::reader::ThemeReader> = Box::new(super::KdeReader);
let _: crate::Result<crate::ReaderResult> = pollster::block_on(r.read());
}
}