#[cfg(all(target_os = "windows", feature = "windows"))]
use ::windows::UI::ViewManagement::{UIColorType, UISettings};
#[cfg(all(target_os = "windows", feature = "windows"))]
use ::windows::Win32::UI::HiDpi::{GetSystemMetricsForDpi, SystemParametersInfoForDpi};
#[cfg(all(target_os = "windows", feature = "windows"))]
use ::windows::Win32::UI::WindowsAndMessaging::{
NONCLIENTMETRICSW, SM_CXBORDER, SM_CXFOCUSBORDER, SM_CXICON, SM_CXSMICON, SM_CXVSCROLL,
SM_CYVTHUMB, SPI_GETNONCLIENTMETRICS, SYSTEM_METRICS_INDEX,
SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS, SystemParametersInfoW, USER_DEFAULT_SCREEN_DPI,
};
use crate::model::FontSpec;
struct AllFonts {
msg: FontSpec,
caption: FontSpec,
menu: FontSpec,
status: FontSpec,
}
struct SysColors {
btn_face: crate::Rgba,
btn_text: crate::Rgba,
menu_bg: crate::Rgba,
menu_text: crate::Rgba,
info_bg: crate::Rgba,
info_text: crate::Rgba,
window_bg: crate::Rgba,
window_text: crate::Rgba,
highlight: crate::Rgba,
highlight_text: crate::Rgba,
caption_text: crate::Rgba,
inactive_caption_text: crate::Rgba,
gray_text: crate::Rgba,
}
struct AccessibilityData {
text_scaling_factor: Option<f32>,
high_contrast: Option<bool>,
reduce_motion: Option<bool>,
}
#[cfg(all(target_os = "windows", feature = "windows"))]
fn win_color_to_rgba(c: ::windows::UI::Color) -> crate::Rgba {
crate::Rgba::new(c.R, c.G, c.B, c.A)
}
fn is_dark_mode(fg: &crate::Rgba) -> bool {
let luma = 0.299 * (fg.r as f32) + 0.587 * (fg.g as f32) + 0.114 * (fg.b as f32);
luma > 128.0
}
#[cfg(all(target_os = "windows", feature = "windows"))]
fn read_accent_shades(settings: &UISettings) -> [Option<crate::Rgba>; 6] {
let variants = [
UIColorType::AccentDark1,
UIColorType::AccentDark2,
UIColorType::AccentDark3,
UIColorType::AccentLight1,
UIColorType::AccentLight2,
UIColorType::AccentLight3,
];
variants.map(|ct| settings.GetColorValue(ct).ok().map(win_color_to_rgba))
}
pub(crate) const LOGICAL_DPI: u32 = 96;
#[cfg(all(target_os = "windows", feature = "windows"))]
fn logfont_to_fontspec(lf: &::windows::Win32::Graphics::Gdi::LOGFONTW) -> FontSpec {
logfont_to_fontspec_raw(&lf.lfFaceName, lf.lfHeight, lf.lfWeight, LOGICAL_DPI)
}
fn logfont_to_fontspec_raw(
face_name: &[u16; 32],
lf_height: i32,
lf_weight: i32,
dpi: u32,
) -> FontSpec {
let trimmed = face_name.split(|&c| c == 0).next().unwrap_or(face_name);
let family = String::from_utf16_lossy(trimmed);
let points = if dpi == 0 {
0.0
} else {
lf_height.unsigned_abs() as f32 * 72.0 / dpi as f32
};
let weight = (lf_weight.clamp(100, 900)) as u16;
FontSpec {
family: Some(family.into()),
size: Some(crate::model::font::FontSize::Pt(points)),
weight: Some(weight),
..Default::default()
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn read_all_system_fonts() -> AllFonts {
let mut ncm = NONCLIENTMETRICSW::default();
ncm.cbSize = std::mem::size_of::<NONCLIENTMETRICSW>() as u32;
let success = unsafe {
SystemParametersInfoForDpi(
SPI_GETNONCLIENTMETRICS.0,
ncm.cbSize,
Some(&mut ncm as *mut _ as *mut _),
0,
USER_DEFAULT_SCREEN_DPI,
)
};
if success.is_ok() {
AllFonts {
msg: logfont_to_fontspec(&ncm.lfMessageFont),
caption: logfont_to_fontspec(&ncm.lfCaptionFont),
menu: logfont_to_fontspec(&ncm.lfMenuFont),
status: logfont_to_fontspec(&ncm.lfStatusFont),
}
} else {
AllFonts {
msg: FontSpec::default(),
caption: FontSpec::default(),
menu: FontSpec::default(),
status: FontSpec::default(),
}
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn logical_system_metric(index: SYSTEM_METRICS_INDEX) -> f32 {
unsafe { GetSystemMetricsForDpi(index, USER_DEFAULT_SCREEN_DPI) as f32 }
}
#[cfg(all(target_os = "windows", feature = "windows"))]
fn read_widget_sizing(variant: &mut crate::ThemeMode) {
variant.scrollbar.groove_width = Some(logical_system_metric(SM_CXVSCROLL));
variant.scrollbar.min_thumb_length = Some(logical_system_metric(SM_CYVTHUMB));
variant.defaults.focus_ring_width = Some(logical_system_metric(SM_CXFOCUSBORDER));
variant.defaults.border.line_width = Some(logical_system_metric(SM_CXBORDER));
winui3_widget_sizing(variant);
}
#[cfg(not(all(target_os = "windows", feature = "windows")))]
fn read_widget_sizing(variant: &mut crate::ThemeMode) {
variant.scrollbar.groove_width = Some(17.0);
variant.scrollbar.min_thumb_length = Some(40.0);
variant.defaults.focus_ring_width = Some(1.0); variant.defaults.border.line_width = Some(1.0); winui3_widget_sizing(variant);
}
pub(crate) fn winui3_widget_sizing(variant: &mut crate::ThemeMode) {
variant.button.min_height = Some(32.0);
let border = variant.button.border.get_or_insert_default();
border.padding_left = Some(11.0);
border.padding_right = Some(11.0);
variant.checkbox.indicator_width = Some(20.0);
variant.checkbox.radio_dot_diameter = Some(12.0);
variant.checkbox.label_gap = Some(8.0);
variant.input.min_height = Some(32.0);
let border = variant.input.border.get_or_insert_default();
border.padding_left = Some(10.0);
border.padding_right = Some(6.0);
let border = variant.text_area.border.get_or_insert_default();
border.padding_left = Some(10.0);
border.padding_right = Some(6.0);
variant.slider.track_height = Some(4.0);
variant.slider.thumb_diameter = Some(18.0);
variant.progress_bar.track_height = Some(1.0);
variant.tab.min_height = Some(32.0);
variant.tab.item_gap = Some(0.0);
let border = variant.tab.border.get_or_insert_default();
border.padding_left = Some(8.0);
border.padding_right = Some(8.0);
variant.menu.row_height = Some(23.0);
let border = variant.menu.border.get_or_insert_default();
border.padding_left = Some(11.0);
border.padding_right = Some(11.0);
let border = variant.tooltip.border.get_or_insert_default();
border.padding_left = Some(9.0);
border.padding_right = Some(9.0);
border.padding_top = Some(6.0);
border.padding_bottom = Some(8.0);
variant.list.row_height = Some(40.0);
let border = variant.list.border.get_or_insert_default();
border.padding_left = Some(16.0);
border.padding_right = Some(12.0);
variant.toolbar.bar_height = Some(48.0);
variant.toolbar.item_gap = Some(0.0);
variant.splitter.divider_width = Some(4.0);
}
pub(crate) fn colorref_to_rgba(c: u32) -> crate::Rgba {
let r = (c & 0xFF) as u8;
let g = ((c >> 8) & 0xFF) as u8;
let b = ((c >> 16) & 0xFF) as u8;
crate::Rgba::rgb(r, g, b)
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn read_sys_colors() -> SysColors {
use ::windows::Win32::Graphics::Gdi::*;
fn sys_color(index: SYS_COLOR_INDEX) -> crate::Rgba {
let c = unsafe { GetSysColor(index) };
colorref_to_rgba(c)
}
SysColors {
btn_face: sys_color(COLOR_BTNFACE),
btn_text: sys_color(COLOR_BTNTEXT),
menu_bg: sys_color(COLOR_MENU),
menu_text: sys_color(COLOR_MENUTEXT),
info_bg: sys_color(COLOR_INFOBK),
info_text: sys_color(COLOR_INFOTEXT),
window_bg: sys_color(COLOR_WINDOW),
window_text: sys_color(COLOR_WINDOWTEXT),
highlight: sys_color(COLOR_HIGHLIGHT),
highlight_text: sys_color(COLOR_HIGHLIGHTTEXT),
caption_text: sys_color(COLOR_CAPTIONTEXT),
inactive_caption_text: sys_color(COLOR_INACTIVECAPTIONTEXT),
gray_text: sys_color(COLOR_GRAYTEXT),
}
}
fn apply_sys_colors(variant: &mut crate::ThemeMode, colors: &SysColors) {
variant.button.background_color = Some(colors.btn_face);
variant.button.font.get_or_insert_default().color = Some(colors.btn_text);
variant.menu.background_color = Some(colors.menu_bg);
variant.menu.font.get_or_insert_default().color = Some(colors.menu_text);
variant.tooltip.background_color = Some(colors.info_bg);
variant.tooltip.font.get_or_insert_default().color = Some(colors.info_text);
variant.input.background_color = Some(colors.window_bg);
variant.input.font.get_or_insert_default().color = Some(colors.window_text);
variant.input.placeholder_color = Some(colors.gray_text);
variant.list.selection_background = Some(colors.highlight);
variant.list.selection_text_color = Some(colors.highlight_text);
variant.window.title_bar_font.get_or_insert_default().color = Some(colors.caption_text);
variant.window.inactive_title_bar_text_color = Some(colors.inactive_caption_text);
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn read_dwm_colorization() -> Option<crate::Rgba> {
use ::windows::Win32::Graphics::Dwm::DwmGetColorizationColor;
let mut colorization: u32 = 0;
let mut opaque_blend = ::windows::core::BOOL::default();
unsafe { DwmGetColorizationColor(&mut colorization, &mut opaque_blend) }.ok()?;
Some(dwm_color_to_rgba(colorization))
}
fn dwm_color_to_rgba(c: u32) -> crate::Rgba {
let a = ((c >> 24) & 0xFF) as u8;
let r = ((c >> 16) & 0xFF) as u8;
let g = ((c >> 8) & 0xFF) as u8;
let b = (c & 0xFF) as u8;
crate::Rgba::new(r, g, b, a)
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn read_inactive_caption_color() -> crate::Rgba {
use ::windows::Win32::Graphics::Gdi::{COLOR_INACTIVECAPTION, GetSysColor};
let c = unsafe { GetSysColor(COLOR_INACTIVECAPTION) };
colorref_to_rgba(c)
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn read_accessibility(settings: &UISettings) -> AccessibilityData {
let text_scaling_factor = settings.TextScaleFactor().ok().map(|f| f as f32);
let high_contrast = {
use ::windows::Win32::UI::Accessibility::{HCF_HIGHCONTRASTON, HIGHCONTRASTW};
use ::windows::Win32::UI::WindowsAndMessaging::*;
let mut hc = HIGHCONTRASTW::default();
hc.cbSize = std::mem::size_of::<HIGHCONTRASTW>() as u32;
let success = unsafe {
SystemParametersInfoW(
SPI_GETHIGHCONTRAST,
hc.cbSize,
Some(&mut hc as *mut _ as *mut _),
SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS(0),
)
};
if success.is_ok() {
Some(hc.dwFlags.contains(HCF_HIGHCONTRASTON))
} else {
None
}
};
let reduce_motion = {
let mut animation_enabled = ::windows::core::BOOL(1);
let success = unsafe {
SystemParametersInfoW(
::windows::Win32::UI::WindowsAndMessaging::SPI_GETCLIENTAREAANIMATION,
0,
Some(&mut animation_enabled as *mut _ as *mut _),
SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS(0),
)
};
if success.is_ok() {
Some(!animation_enabled.as_bool())
} else {
None
}
};
AccessibilityData {
text_scaling_factor,
high_contrast,
reduce_motion,
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
fn read_icon_sizes() -> (f32, f32) {
(
logical_system_metric(SM_CXSMICON),
logical_system_metric(SM_CXICON),
)
}
#[allow(clippy::too_many_arguments)]
fn build_theme(
accent: crate::Rgba,
fg: crate::Rgba,
bg: crate::Rgba,
accent_shades: [Option<crate::Rgba>; 6],
fonts: AllFonts,
sys_colors: Option<&SysColors>,
dwm_title_bar: Option<crate::Rgba>,
inactive_title_bar: Option<crate::Rgba>,
icon_sizes: Option<(f32, f32)>,
accessibility: Option<&AccessibilityData>,
) -> crate::ReaderResult {
let dark = is_dark_mode(&fg);
let primary_bg = if dark {
accent_shades[3].unwrap_or(accent)
} else {
accent_shades[0].unwrap_or(accent)
};
let mut variant = crate::ThemeMode::default();
variant.defaults.accent_color = Some(accent);
variant.defaults.text_color = Some(fg);
variant.defaults.background_color = Some(bg);
variant.defaults.selection_background = Some(accent);
variant.defaults.focus_ring_color = Some(accent);
variant.defaults.surface_color = Some(bg);
variant.button.primary_background = Some(primary_bg);
variant.button.primary_text_color = Some(fg);
variant.button.checked_background = Some(primary_bg);
let disabled_r = fg.r.midpoint(bg.r);
let disabled_g = fg.g.midpoint(bg.g);
let disabled_b = fg.b.midpoint(bg.b);
variant.defaults.disabled_text_color =
Some(crate::Rgba::rgb(disabled_r, disabled_g, disabled_b));
variant.defaults.font = fonts.msg;
variant.window.title_bar_font = Some(fonts.caption);
variant.menu.font = Some(fonts.menu);
variant.status_bar.font = Some(fonts.status);
variant.defaults.border.corner_radius = Some(4.0);
variant.defaults.border.corner_radius_lg = Some(8.0);
variant.defaults.border.shadow_enabled = Some(true);
read_widget_sizing(&mut variant);
variant.dialog.button_order = Some(crate::model::DialogButtonOrder::PrimaryLeft);
if let Some(color) = dwm_title_bar {
variant.window.title_bar_background = Some(color);
}
if let Some(color) = inactive_title_bar {
variant.window.inactive_title_bar_background = Some(color);
}
if let Some(colors) = sys_colors {
apply_sys_colors(&mut variant, colors);
}
if let Some((small, large)) = icon_sizes {
variant.defaults.icon_sizes.small = Some(small);
variant.defaults.icon_sizes.large = Some(large);
}
let acc = if let Some(a) = accessibility {
let mut ap = crate::AccessibilityPreferences::default();
if let Some(tsf) = a.text_scaling_factor {
ap.text_scaling_factor = tsf;
}
if let Some(rm) = a.reduce_motion {
ap.reduce_motion = rm;
}
if let Some(hc) = a.high_contrast {
ap.high_contrast = hc;
}
ap
} else {
crate::AccessibilityPreferences::default()
};
let font_dpi = Some(LOGICAL_DPI as f32);
let output = crate::ReaderOutput::Single {
mode: Box::new(variant),
is_dark: dark,
};
crate::ReaderResult {
output,
name: "Windows".into(),
icon_set: Some(crate::IconSet::SegoeIcons),
layout: crate::LayoutTheme::default(),
font_dpi,
accessibility: acc,
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
pub(crate) struct WindowsReader;
#[cfg(all(target_os = "windows", feature = "windows"))]
#[async_trait::async_trait]
impl crate::reader::ThemeReader for WindowsReader {
async fn read(&self) -> crate::Result<crate::ReaderResult> {
read_windows()
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
fn read_windows() -> crate::Result<crate::ReaderResult> {
let settings = UISettings::new().map_err(|e| crate::Error::ReaderFailed {
reader: "windows",
source: format!("UISettings unavailable: {e}").into(),
})?;
let accent = settings
.GetColorValue(UIColorType::Accent)
.map(win_color_to_rgba)
.map_err(|e| crate::Error::ReaderFailed {
reader: "windows",
source: format!("GetColorValue(Accent) failed: {e}").into(),
})?;
let fg = settings
.GetColorValue(UIColorType::Foreground)
.map(win_color_to_rgba)
.map_err(|e| crate::Error::ReaderFailed {
reader: "windows",
source: format!("GetColorValue(Foreground) failed: {e}").into(),
})?;
let bg = settings
.GetColorValue(UIColorType::Background)
.map(win_color_to_rgba)
.map_err(|e| crate::Error::ReaderFailed {
reader: "windows",
source: format!("GetColorValue(Background) failed: {e}").into(),
})?;
let accent_shades = read_accent_shades(&settings);
let fonts = read_all_system_fonts();
let sys_colors = read_sys_colors();
let dwm_title_bar = read_dwm_colorization();
let inactive_title_bar = Some(read_inactive_caption_color());
let (small, large) = read_icon_sizes();
let accessibility = read_accessibility(&settings);
Ok(build_theme(
accent,
fg,
bg,
accent_shades,
fonts,
Some(&sys_colors),
dwm_title_bar,
inactive_title_bar,
Some((small, large)),
Some(&accessibility),
))
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::model::font::FontSize;
fn default_fonts() -> AllFonts {
AllFonts {
msg: FontSpec::default(),
caption: FontSpec::default(),
menu: FontSpec::default(),
status: FontSpec::default(),
}
}
fn named_fonts() -> AllFonts {
use crate::model::font::FontSize;
AllFonts {
msg: FontSpec {
family: Some("Segoe UI".into()),
size: Some(FontSize::Pt(9.0)),
weight: Some(400),
..Default::default()
},
caption: FontSpec {
family: Some("Segoe UI".into()),
size: Some(FontSize::Pt(9.0)),
weight: Some(700),
..Default::default()
},
menu: FontSpec {
family: Some("Segoe UI".into()),
size: Some(FontSize::Pt(9.0)),
weight: Some(400),
..Default::default()
},
status: FontSpec {
family: Some("Segoe UI".into()),
size: Some(FontSize::Pt(8.0)),
weight: Some(400),
..Default::default()
},
}
}
fn reader_mode(result: &crate::ReaderResult) -> &crate::ThemeMode {
match &result.output {
crate::ReaderOutput::Single { mode, .. } => mode,
crate::ReaderOutput::Dual { light, .. } => light,
}
}
fn light_reader() -> crate::ReaderResult {
build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0), crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
None,
None,
None,
None,
None,
)
}
fn light_theme() -> crate::Theme {
let r = light_reader();
r.output.to_theme(&r.name, r.icon_set, &r.layout)
}
fn dark_reader() -> crate::ReaderResult {
build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(255, 255, 255), crate::Rgba::rgb(0, 0, 0),
[None; 6],
default_fonts(),
None,
None,
None,
None,
None,
)
}
fn dark_theme() -> crate::Theme {
let r = dark_reader();
r.output.to_theme(&r.name, r.icon_set, &r.layout)
}
#[test]
fn is_dark_mode_white_foreground_returns_true() {
let fg = crate::Rgba::rgb(255, 255, 255);
assert!(is_dark_mode(&fg));
}
#[test]
fn is_dark_mode_black_foreground_returns_false() {
let fg = crate::Rgba::rgb(0, 0, 0);
assert!(!is_dark_mode(&fg));
}
#[test]
fn is_dark_mode_mid_gray_boundary_returns_false() {
let fg = crate::Rgba::rgb(128, 128, 128);
assert!(!is_dark_mode(&fg));
}
#[test]
fn logfont_to_fontspec_extracts_family_size_weight() {
let mut face: [u16; 32] = [0; 32];
for (i, ch) in "Segoe UI".encode_utf16().enumerate() {
face[i] = ch;
}
let fs = logfont_to_fontspec_raw(&face, -16, 400, 96);
assert_eq!(fs.family.as_deref(), Some("Segoe UI"));
assert_eq!(fs.size, Some(FontSize::Pt(12.0))); assert_eq!(fs.weight, Some(400));
}
#[test]
fn logfont_to_fontspec_bold_weight_700() {
let face: [u16; 32] = [0; 32];
let fs = logfont_to_fontspec_raw(&face, -16, 700, 96);
assert_eq!(fs.weight, Some(700));
}
#[test]
fn logfont_to_fontspec_weight_clamped_to_range() {
let face: [u16; 32] = [0; 32];
let fs = logfont_to_fontspec_raw(&face, -16, 0, 96);
assert_eq!(fs.weight, Some(100));
let fs = logfont_to_fontspec_raw(&face, -16, 1000, 96);
assert_eq!(fs.weight, Some(900));
}
#[test]
fn colorref_to_rgba_correct_rgb_extraction() {
let rgba = colorref_to_rgba(0x00AABBCC);
assert_eq!(rgba.r, 0xCC);
assert_eq!(rgba.g, 0xBB);
assert_eq!(rgba.b, 0xAA);
assert_eq!(rgba.a, 255); }
#[test]
fn colorref_to_rgba_black() {
let rgba = colorref_to_rgba(0x00000000);
assert_eq!(rgba, crate::Rgba::rgb(0, 0, 0));
}
#[test]
fn colorref_to_rgba_white() {
let rgba = colorref_to_rgba(0x00FFFFFF);
assert_eq!(rgba, crate::Rgba::rgb(255, 255, 255));
}
#[test]
fn dwm_color_to_rgba_extracts_argb() {
let rgba = dwm_color_to_rgba(0xCC112233);
assert_eq!(rgba.r, 0x11);
assert_eq!(rgba.g, 0x22);
assert_eq!(rgba.b, 0x33);
assert_eq!(rgba.a, 0xCC);
}
#[test]
fn build_theme_dark_mode_populates_dark_variant_only() {
let theme = dark_theme();
assert!(theme.dark.is_some(), "dark variant should be Some");
assert!(theme.light.is_none(), "light variant should be None");
}
#[test]
fn build_theme_light_mode_populates_light_variant_only() {
let theme = light_theme();
assert!(theme.light.is_some(), "light variant should be Some");
assert!(theme.dark.is_none(), "dark variant should be None");
}
#[test]
fn build_theme_sets_defaults_accent_fg_bg_selection() {
let accent = crate::Rgba::rgb(0, 120, 215);
let fg = crate::Rgba::rgb(0, 0, 0);
let bg = crate::Rgba::rgb(255, 255, 255);
let theme = build_theme(
accent,
fg,
bg,
[None; 6],
default_fonts(),
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.accent_color, Some(accent));
assert_eq!(variant.defaults.text_color, Some(fg));
assert_eq!(variant.defaults.background_color, Some(bg));
assert_eq!(variant.defaults.selection_background, Some(accent));
assert_eq!(variant.defaults.focus_ring_color, Some(accent));
}
#[test]
fn build_theme_name_is_windows() {
assert_eq!(light_theme().name, "Windows");
}
#[test]
fn build_theme_accent_shades_light_mode() {
let accent = crate::Rgba::rgb(0, 120, 215);
let dark1 = crate::Rgba::rgb(0, 90, 170);
let mut shades = [None; 6];
shades[0] = Some(dark1);
let theme = build_theme(
accent,
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
shades,
default_fonts(),
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.accent_color, Some(accent));
}
#[test]
fn build_theme_accent_shades_dark_mode() {
let accent = crate::Rgba::rgb(0, 120, 215);
let light1 = crate::Rgba::rgb(60, 160, 240);
let mut shades = [None; 6];
shades[3] = Some(light1);
let theme = build_theme(
accent,
crate::Rgba::rgb(255, 255, 255),
crate::Rgba::rgb(0, 0, 0),
shades,
default_fonts(),
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.accent_color, Some(accent));
}
#[test]
fn build_theme_sets_title_bar_font() {
let fonts = named_fonts();
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
fonts,
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
let title_font = variant
.window
.title_bar_font
.as_ref()
.expect("title_bar_font");
assert_eq!(title_font.family.as_deref(), Some("Segoe UI"));
assert_eq!(title_font.weight, Some(700));
}
#[test]
fn build_theme_sets_menu_and_status_bar_fonts() {
let fonts = named_fonts();
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
fonts,
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
let menu_font = variant.menu.font.as_ref().expect("menu.font");
assert_eq!(menu_font.family.as_deref(), Some("Segoe UI"));
let status_font = variant.status_bar.font.as_ref().expect("status_bar.font");
assert_eq!(status_font.size, Some(FontSize::Pt(8.0)));
}
#[test]
fn build_theme_sets_defaults_font_from_msg_font() {
let fonts = named_fonts();
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
fonts,
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.font.family.as_deref(), Some("Segoe UI"));
assert_eq!(variant.defaults.font.size, Some(FontSize::Pt(9.0)));
}
fn sample_sys_colors() -> SysColors {
SysColors {
btn_face: crate::Rgba::rgb(240, 240, 240),
btn_text: crate::Rgba::rgb(0, 0, 0),
menu_bg: crate::Rgba::rgb(255, 255, 255),
menu_text: crate::Rgba::rgb(0, 0, 0),
info_bg: crate::Rgba::rgb(255, 255, 225),
info_text: crate::Rgba::rgb(0, 0, 0),
window_bg: crate::Rgba::rgb(255, 255, 255),
window_text: crate::Rgba::rgb(0, 0, 0),
highlight: crate::Rgba::rgb(0, 120, 215),
highlight_text: crate::Rgba::rgb(255, 255, 255),
caption_text: crate::Rgba::rgb(0, 0, 0),
inactive_caption_text: crate::Rgba::rgb(128, 128, 128),
gray_text: crate::Rgba::rgb(109, 109, 109),
}
}
#[test]
fn build_theme_with_sys_colors_populates_widgets() {
let colors = sample_sys_colors();
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
Some(&colors),
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(
variant.button.background_color,
Some(crate::Rgba::rgb(240, 240, 240))
);
assert_eq!(
variant.button.font.as_ref().and_then(|f| f.color),
Some(crate::Rgba::rgb(0, 0, 0))
);
assert_eq!(
variant.menu.background_color,
Some(crate::Rgba::rgb(255, 255, 255))
);
assert_eq!(
variant.menu.font.as_ref().and_then(|f| f.color),
Some(crate::Rgba::rgb(0, 0, 0))
);
assert_eq!(
variant.tooltip.background_color,
Some(crate::Rgba::rgb(255, 255, 225))
);
assert_eq!(
variant.tooltip.font.as_ref().and_then(|f| f.color),
Some(crate::Rgba::rgb(0, 0, 0))
);
assert_eq!(
variant.input.background_color,
Some(crate::Rgba::rgb(255, 255, 255))
);
assert_eq!(
variant.input.font.as_ref().and_then(|f| f.color),
Some(crate::Rgba::rgb(0, 0, 0))
);
assert_eq!(
variant.list.selection_background,
Some(crate::Rgba::rgb(0, 120, 215))
);
assert_eq!(
variant.list.selection_text_color,
Some(crate::Rgba::rgb(255, 255, 255))
);
assert_eq!(
variant.window.title_bar_font.as_ref().and_then(|f| f.color),
Some(crate::Rgba::rgb(0, 0, 0)),
"caption_text -> window.title_bar_font.color"
);
assert_eq!(
variant.window.inactive_title_bar_text_color,
Some(crate::Rgba::rgb(128, 128, 128)),
"inactive_caption_text -> window.inactive_title_bar_text_color"
);
assert_eq!(
variant.input.placeholder_color,
Some(crate::Rgba::rgb(109, 109, 109)),
"gray_text -> input.placeholder_color"
);
}
#[test]
fn build_theme_sets_focus_ring_width() {
let result = light_reader();
let variant = reader_mode(&result);
assert!(
variant.defaults.focus_ring_width.is_some(),
"focus_ring_width should be set from SM_CXFOCUSBORDER"
);
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
#[test]
fn system_metrics_are_logical_at_any_system_dpi() {
let at_96 =
|index| unsafe { GetSystemMetricsForDpi(index, USER_DEFAULT_SCREEN_DPI) } as f32;
let _ = unsafe {
::windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext(
::windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
)
};
let mut variant = crate::ThemeMode::default();
read_widget_sizing(&mut variant);
assert_eq!(variant.scrollbar.groove_width, Some(at_96(SM_CXVSCROLL)));
assert_eq!(variant.scrollbar.min_thumb_length, Some(at_96(SM_CYVTHUMB)));
assert_eq!(
variant.defaults.focus_ring_width,
Some(at_96(SM_CXFOCUSBORDER))
);
assert_eq!(variant.defaults.border.line_width, Some(at_96(SM_CXBORDER)));
let (small, large) = read_icon_sizes();
assert_eq!(small, at_96(SM_CXSMICON));
assert_eq!(large, at_96(SM_CXICON));
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
#[test]
fn fonts_resolve_to_logical_pixels_at_any_system_dpi() {
let _ = unsafe {
::windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext(
::windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
)
};
let mut ncm = NONCLIENTMETRICSW {
cbSize: std::mem::size_of::<NONCLIENTMETRICSW>() as u32,
..Default::default()
};
unsafe {
::windows::Win32::UI::HiDpi::SystemParametersInfoForDpi(
SPI_GETNONCLIENTMETRICS.0,
ncm.cbSize,
Some(&mut ncm as *mut _ as *mut _),
0,
USER_DEFAULT_SCREEN_DPI,
)
}
.unwrap();
let logical = ncm.lfMessageFont.lfHeight.unsigned_abs() as f32;
assert!(logical > 0.0, "no message font at 96 DPI");
assert_eq!(LOGICAL_DPI, USER_DEFAULT_SCREEN_DPI);
let result = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
read_all_system_fonts(),
None,
None,
None,
None,
None,
);
let font_dpi = result.font_dpi.unwrap();
let size = reader_mode(&result)
.defaults
.font
.size
.unwrap()
.to_logical_px(font_dpi);
assert!(
(size - logical).abs() < 1e-3,
"message font resolves to {size}px at font_dpi {font_dpi}; logical is {logical}px"
);
}
#[test]
fn build_theme_reports_logical_font_dpi() {
assert_eq!(light_reader().font_dpi, Some(96.0));
}
#[test]
fn build_theme_sets_border_line_width() {
let result = light_reader();
let variant = reader_mode(&result);
assert!(
variant.defaults.border.line_width.is_some(),
"defaults.border.line_width should be set from SM_CXBORDER"
);
}
#[test]
fn build_theme_with_dwm_color_sets_title_bar_background() {
let dwm_color = crate::Rgba::new(0, 120, 215, 200);
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
None,
Some(dwm_color),
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.window.title_bar_background, Some(dwm_color));
}
#[test]
fn build_theme_with_inactive_title_bar() {
let inactive = crate::Rgba::rgb(200, 200, 200);
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
None,
None,
Some(inactive),
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.window.inactive_title_bar_background, Some(inactive));
}
#[test]
fn build_theme_with_icon_sizes() {
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
None,
None,
None,
Some((16.0, 32.0)),
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.icon_sizes.small, Some(16.0));
assert_eq!(variant.defaults.icon_sizes.large, Some(32.0));
}
#[test]
fn build_theme_with_accessibility() {
let accessibility = AccessibilityData {
text_scaling_factor: Some(1.5),
high_contrast: Some(true),
reduce_motion: Some(false),
};
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
None,
None,
None,
None,
Some(&accessibility),
);
assert!(matches!(
theme.output,
crate::ReaderOutput::Single { is_dark: false, .. }
));
}
#[test]
fn build_theme_sets_dialog_primary_left() {
let result = light_reader();
let variant = reader_mode(&result);
assert_eq!(
variant.dialog.button_order,
Some(crate::model::DialogButtonOrder::PrimaryLeft)
);
}
#[test]
fn build_theme_sets_geometry_defaults() {
let result = light_reader();
let variant = reader_mode(&result);
assert_eq!(variant.defaults.border.corner_radius, Some(4.0));
assert_eq!(variant.defaults.border.corner_radius_lg, Some(8.0));
assert_eq!(variant.defaults.border.shadow_enabled, Some(true));
}
#[test]
fn build_theme_includes_widget_sizing() {
let result = light_reader();
let variant = reader_mode(&result);
assert_eq!(variant.button.min_height, Some(32.0));
assert_eq!(variant.checkbox.indicator_width, Some(20.0));
assert_eq!(variant.checkbox.radio_dot_diameter, Some(12.0));
assert_eq!(variant.tab.item_gap, Some(0.0));
assert_eq!(variant.input.min_height, Some(32.0));
assert_eq!(variant.slider.thumb_diameter, Some(18.0));
assert_eq!(variant.progress_bar.track_height, Some(1.0));
assert!(variant.scrollbar.groove_width.is_some());
assert_eq!(variant.menu.row_height, Some(23.0));
assert_eq!(variant.splitter.divider_width, Some(4.0));
}
#[test]
fn build_theme_surface_equals_bg() {
let bg = crate::Rgba::rgb(255, 255, 255);
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
bg,
[None; 6],
default_fonts(),
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.surface_color, Some(bg));
}
#[test]
fn build_theme_disabled_foreground_is_midpoint() {
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0), crate::Rgba::rgb(255, 255, 255), [None; 6],
default_fonts(),
None,
None,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(
variant.defaults.disabled_text_color,
Some(crate::Rgba::rgb(127, 127, 127))
);
}
#[test]
fn build_theme_returns_native_theme_with_theme_variant() {
let theme = light_theme();
let variant: &crate::ThemeMode = theme.light.as_ref().unwrap();
let _ = variant.defaults.accent_color;
let _ = variant.window.title_bar_font;
let _ = variant.menu.font;
let _ = variant.status_bar.font;
let _ = variant.button.background_color;
let _ = variant.defaults.icon_sizes.small;
let _ = variant.defaults.icon_sizes.toolbar;
let _ = variant.dialog.button_order;
}
#[test]
fn test_windows_resolve_validate() {
let mut base = crate::Theme::preset("windows-11").unwrap();
let reader_output = light_theme();
base.merge(&reader_output);
let mut light = base
.light
.clone()
.expect("light variant should exist after merge");
light.resolve_all();
let resolved = light.validate().unwrap_or_else(|e| {
panic!("Windows resolve/validate pipeline failed: {e}");
});
assert_eq!(
resolved.defaults.accent_color,
crate::Rgba::rgb(0, 120, 215),
"accent should be from Windows reader"
);
assert_eq!(
resolved.defaults.font.family.as_ref(),
"Segoe UI",
"font family should be from Windows reader"
);
assert_eq!(
resolved.dialog.button_order,
crate::DialogButtonOrder::PrimaryLeft,
"dialog button order should be leading-affirmative (primary leftmost) for Windows per MS Common Buttons / WinUI 3 guidance"
);
}
#[test]
fn windows_reader_exists() {
let _: Option<&dyn crate::reader::ThemeReader> = None;
#[cfg(all(target_os = "windows", feature = "windows"))]
{
let r: Box<dyn crate::reader::ThemeReader> = Box::new(super::WindowsReader);
let _ = &r;
}
}
}