#[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_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;
#[cfg(all(target_os = "windows", feature = "windows"))]
pub(crate) fn os_version() -> crate::pipeline::OsVersion {
let v = ::windows_version::OsVersion::current();
crate::pipeline::OsVersion::new(v.major, v.minor, v.build)
}
struct AllFonts {
msg: FontSpec,
caption: FontSpec,
menu: FontSpec,
status: FontSpec,
}
struct SysColors {
window_bg: crate::Rgba,
window_text: crate::Rgba,
btn_face: crate::Rgba,
btn_text: crate::Rgba,
highlight: crate::Rgba,
highlight_text: crate::Rgba,
hotlight: crate::Rgba,
gray_text: crate::Rgba,
}
struct AccessibilityData {
text_scaling_factor: Option<f32>,
high_contrast: Option<bool>,
reduce_motion: Option<bool>,
advanced_effects_enabled: Option<bool>,
}
#[cfg(all(target_os = "windows", feature = "windows"))]
pub(crate) fn win_color_to_rgba(c: ::windows::UI::Color) -> crate::Rgba {
crate::Rgba::new(c.R, c.G, c.B, c.A)
}
pub(crate) 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)
}
fn logfont_to_fontspec_raw(face_name: &[u16; 32], lf_height: i32, lf_weight: i32) -> FontSpec {
let trimmed = face_name.split(|&c| c == 0).next().unwrap_or(face_name);
let family = String::from_utf16_lossy(trimmed);
let points = lf_height.unsigned_abs() as f32 * 72.0 / LOGICAL_DPI as f32;
let weight = (lf_weight > 0).then(|| lf_weight.clamp(100, 900) as u16);
FontSpec {
family: Some(family.into()),
size: Some(crate::model::font::FontSize::Pt(points)),
weight,
..Default::default()
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
fn read_all_system_fonts() -> AllFonts {
let mut ncm = NONCLIENTMETRICSW {
cbSize: std::mem::size_of::<NONCLIENTMETRICSW>() as u32,
..Default::default()
};
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.border.line_width = Some(logical_system_metric(SM_CXBORDER));
}
#[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(17.0);
variant.defaults.border.line_width = Some(1.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 {
window_bg: sys_color(COLOR_WINDOW),
window_text: sys_color(COLOR_WINDOWTEXT),
btn_face: sys_color(COLOR_BTNFACE),
btn_text: sys_color(COLOR_BTNTEXT),
highlight: sys_color(COLOR_HIGHLIGHT),
highlight_text: sys_color(COLOR_HIGHLIGHTTEXT),
hotlight: sys_color(COLOR_HOTLIGHT),
gray_text: sys_color(COLOR_GRAYTEXT),
}
}
fn apply_sys_colors(variant: &mut crate::ThemeMode, colors: &SysColors) {
variant.defaults.text_color = Some(colors.window_text);
variant.defaults.background_color = Some(colors.window_bg);
variant.defaults.surface_color = Some(colors.window_bg);
variant.defaults.disabled_text_color = Some(colors.gray_text);
variant.defaults.selection_background = Some(colors.highlight);
variant.defaults.selection_text_color = Some(colors.highlight_text);
variant.defaults.accent_color = Some(colors.highlight);
variant.defaults.accent_text_color = Some(colors.highlight_text);
variant.defaults.link_color = Some(colors.hotlight);
variant.defaults.info_color = Some(colors.window_text);
variant.defaults.focus_ring_color = Some(colors.window_text);
variant.button.background_color = Some(colors.btn_face);
variant.button.font.get_or_insert_default().color = Some(colors.btn_text);
variant.button.primary_background = Some(colors.highlight);
variant.button.primary_text_color = Some(colors.highlight_text);
variant.button.checked_background = Some(colors.highlight);
variant.button.checked_text_color = Some(colors.highlight_text);
variant.input.background_color = Some(colors.btn_face);
variant.input.font.get_or_insert_default().color = Some(colors.btn_text);
variant.input.placeholder_color = Some(colors.window_text);
variant.menu.background_color = Some(colors.window_bg);
variant.menu.font.get_or_insert_default().color = Some(colors.btn_text);
variant.tooltip.background_color = Some(colors.window_bg);
variant.tooltip.font.get_or_insert_default().color = Some(colors.window_text);
variant.list.selection_background = Some(colors.highlight);
variant.list.selection_text_color = Some(colors.highlight_text);
variant.window.title_bar_background = Some(colors.window_bg);
variant.window.inactive_title_bar_background = Some(colors.window_bg);
variant.window.title_bar_font.get_or_insert_default().color = Some(colors.btn_text);
variant.window.inactive_title_bar_text_color = Some(colors.gray_text);
variant.defaults.border.color = Some(colors.window_text);
variant.defaults.border.opacity = Some(1.0);
let progress_border = variant.progress_bar.border.get_or_insert_default();
progress_border.line_width = Some(1.0);
progress_border.color = Some(colors.window_text);
variant.progress_bar.track_color = Some(colors.window_bg);
variant.checkbox.checked_background = Some(colors.highlight);
variant.switch.checked_background = Some(colors.highlight);
variant.slider.fill_color = Some(colors.highlight);
variant.progress_bar.fill_color = Some(colors.highlight);
variant.spinner.fill_color = Some(colors.highlight);
variant.segmented_control.background_color = Some(colors.btn_face);
variant
.segmented_control
.border
.get_or_insert_default()
.color = Some(colors.highlight);
variant.segmented_control.font.get_or_insert_default().color = Some(colors.btn_text);
variant.segmented_control.active_background = Some(colors.highlight);
variant.segmented_control.active_text_color = Some(colors.highlight_text);
variant.switch.hover_checked_background = Some(colors.btn_face);
variant.input.focus_border_color = Some(colors.highlight);
}
#[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 {
cbSize: std::mem::size_of::<HIGHCONTRASTW>() as u32,
..Default::default()
};
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
}
};
AccessibilityData {
text_scaling_factor,
high_contrast,
reduce_motion: read_reduce_motion(),
advanced_effects_enabled: settings.AdvancedEffectsEnabled().ok(),
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
#[allow(unsafe_code)]
pub(crate) fn read_reduce_motion() -> Option<bool> {
use ::windows::Win32::UI::WindowsAndMessaging::SPI_GETCLIENTAREAANIMATION;
let mut animation_enabled = ::windows::core::BOOL(1);
let success = unsafe {
SystemParametersInfoW(
SPI_GETCLIENTAREAANIMATION,
0,
Some(&mut animation_enabled as *mut _ as *mut _),
SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS(0),
)
};
success.is_ok().then(|| !animation_enabled.as_bool())
}
#[cfg(all(target_os = "windows", feature = "windows"))]
fn read_icon_sizes() -> (f32, f32) {
(
logical_system_metric(SM_CXSMICON),
logical_system_metric(SM_CXICON),
)
}
fn build_theme(
accent: crate::Rgba,
fg: crate::Rgba,
accent_shades: [Option<crate::Rgba>; 6],
fonts: AllFonts,
sys_colors: Option<&SysColors>,
icon_sizes: Option<(f32, f32)>,
accessibility: Option<&AccessibilityData>,
) -> crate::ReaderResult {
let dark = is_dark_mode(&fg);
let [dark1, dark2, dark3, _, light2, light3] = accent_shades;
let high_contrast = accessibility.and_then(|a| a.high_contrast) == Some(true);
let mut variant = crate::ThemeMode::default();
variant.defaults.accent_color = Some(accent);
let primary_bg = if dark { light2 } else { dark1 }.unwrap_or(accent);
variant.button.primary_background = Some(primary_bg);
variant.button.checked_background = Some(primary_bg);
variant.checkbox.checked_background = Some(primary_bg);
variant.switch.checked_background = Some(primary_bg);
variant.slider.fill_color = Some(primary_bg);
variant.progress_bar.fill_color = Some(primary_bg);
variant.spinner.fill_color = Some(primary_bg);
variant.defaults.link_color = if dark { light3 } else { dark2 };
variant.defaults.info_color = if dark { light2 } else { Some(accent) };
if !high_contrast {
variant.link.hover_text_color = if dark { light3 } else { dark3 };
variant.link.active_text_color = if dark { light2 } else { dark1 };
variant.input.focus_border_color = Some(primary_bg);
}
variant.defaults.font = fonts.msg;
variant.window.title_bar_font = Some(fonts.caption);
variant.menu.font = Some(fonts.menu);
variant.tooltip.font = Some(fonts.status.clone());
variant.status_bar.font = Some(fonts.status);
read_widget_sizing(&mut variant);
if let (true, Some(colors)) = (high_contrast, 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;
}
if let Some(enabled) = a.advanced_effects_enabled {
ap.reduce_transparency = !enabled;
}
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::SegoeFluent),
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: crate::error::reader_names::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: crate::error::reader_names::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: crate::error::reader_names::WINDOWS,
source: format!("GetColorValue(Foreground) failed: {e}").into(),
})?;
let accent_shades = read_accent_shades(&settings);
let fonts = read_all_system_fonts();
let (small, large) = read_icon_sizes();
let accessibility = read_accessibility(&settings);
let sys_colors = (accessibility.high_contrast == Some(true)).then(read_sys_colors);
Ok(build_theme(
accent,
fg,
accent_shades,
fonts,
sys_colors.as_ref(),
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), [None; 6],
default_fonts(),
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), [None; 6],
default_fonts(),
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);
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);
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, 50);
assert_eq!(fs.weight, Some(100));
let fs = logfont_to_fontspec_raw(&face, -16, 1000);
assert_eq!(fs.weight, Some(900));
}
#[test]
fn logfont_to_fontspec_weight_dontcare_is_no_weight() {
let face: [u16; 32] = [0; 32];
let fs = logfont_to_fontspec_raw(&face, -16, 0);
assert_eq!(fs.weight, None);
let fs = logfont_to_fontspec_raw(&face, -16, -400);
assert_eq!(fs.weight, None);
}
#[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 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_name_is_windows() {
assert_eq!(light_theme().name, "Windows");
}
const SHADES: [Option<crate::Rgba>; 6] = [
Some(crate::Rgba::rgb(0, 0, 1)),
Some(crate::Rgba::rgb(0, 0, 2)),
Some(crate::Rgba::rgb(0, 0, 3)),
Some(crate::Rgba::rgb(0, 0, 4)),
Some(crate::Rgba::rgb(0, 0, 5)),
Some(crate::Rgba::rgb(0, 0, 6)),
];
fn accent_fills(v: &crate::ThemeMode) -> [(&'static str, Option<crate::Rgba>); 6] {
[
("checkbox.checked_background", v.checkbox.checked_background),
("switch.checked_background", v.switch.checked_background),
("slider.fill_color", v.slider.fill_color),
("progress_bar.fill_color", v.progress_bar.fill_color),
("spinner.fill_color", v.spinner.fill_color),
("input.focus_border_color", v.input.focus_border_color),
]
}
#[test]
fn the_windows_11_switch_hover_composites_to_winuis() {
for (mode, winui) in [
(crate::ColorMode::Light, [0x18_u8, 0x75, 0xc5]),
(crate::ColorMode::Dark, [0x48, 0xb2, 0xe9]),
] {
let r = crate::Theme::preset("windows-11")
.unwrap()
.into_variant(mode)
.unwrap()
.into_resolved(&crate::ResolutionContext::for_tests())
.unwrap();
let s = &r.switch;
let layer = s
.hover_checked_background
.expect("windows-11 states the hover");
let [red, green, blue, _] = crate::color::composite_over(
layer.to_f32_array(),
s.checked_background.to_f32_array(),
);
let got = crate::Rgba::from_f32(red, green, blue, 1.0);
for (channel, (got, want)) in [got.r, got.g, got.b].into_iter().zip(winui).enumerate() {
assert!(
got.abs_diff(want) <= 1,
"{mode:?} channel {channel}: {got} against WinUI's {want}"
);
}
assert!(layer.a < 255, "{mode:?}: the hover is an opaque fill");
let other = crate::Rgba::rgb(0x8a, 0x2b, 0xe2);
let [red, green, blue, _] =
crate::color::composite_over(layer.to_f32_array(), other.to_f32_array());
let got = crate::Rgba::from_f32(red, green, blue, 1.0);
let winui = |s: u8, w: u8| 0.9 * f32::from(s) + 0.1 * f32::from(w);
for (channel, (got, want)) in [got.r, got.g, got.b]
.into_iter()
.zip([
winui(other.r, layer.r),
winui(other.g, layer.g),
winui(other.b, layer.b),
])
.enumerate()
{
assert!(
(f32::from(got) - want).abs() <= 1.0,
"{mode:?} channel {channel} over another shade: {got} against WinUI's {want}"
);
}
}
}
#[test]
fn build_theme_accent_shades_light_mode() {
let accent = crate::Rgba::rgb(0, 120, 215);
let theme = build_theme(
accent,
crate::Rgba::rgb(0, 0, 0),
SHADES,
default_fonts(),
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.accent_color, Some(accent));
assert_eq!(variant.button.primary_background, SHADES[0]);
assert_eq!(variant.button.checked_background, SHADES[0]);
for (field, value) in accent_fills(variant) {
assert_eq!(value, SHADES[0], "{field}");
}
assert_eq!(variant.defaults.link_color, SHADES[1]);
assert_eq!(variant.link.hover_text_color, SHADES[2]);
assert_eq!(variant.link.active_text_color, SHADES[0]);
assert_eq!(variant.defaults.info_color, Some(accent));
}
#[test]
fn build_theme_accent_shades_dark_mode() {
let accent = crate::Rgba::rgb(0, 120, 215);
let theme = build_theme(
accent,
crate::Rgba::rgb(255, 255, 255),
SHADES,
default_fonts(),
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.defaults.accent_color, Some(accent));
assert_eq!(variant.button.primary_background, SHADES[4]);
assert_eq!(variant.button.checked_background, SHADES[4]);
for (field, value) in accent_fills(variant) {
assert_eq!(value, SHADES[4], "{field}");
}
assert_eq!(variant.defaults.link_color, SHADES[5]);
assert_eq!(variant.link.hover_text_color, SHADES[5]);
assert_eq!(variant.link.active_text_color, SHADES[4]);
assert_eq!(variant.defaults.info_color, SHADES[4]);
}
#[test]
fn build_theme_without_shades_leaves_link_to_the_preset() {
let accent = crate::Rgba::rgb(0, 120, 215);
let theme = build_theme(
accent,
crate::Rgba::rgb(255, 255, 255),
[None; 6],
default_fonts(),
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.button.primary_background, Some(accent));
assert_eq!(variant.defaults.link_color, None);
assert_eq!(variant.defaults.info_color, None);
}
#[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),
[None; 6],
fonts,
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),
[None; 6],
fonts,
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_tooltip_font_from_status_font() {
let fonts = named_fonts();
let status = fonts.status.clone();
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
[None; 6],
fonts,
None,
None,
None,
);
let variant = reader_mode(&theme);
assert_eq!(variant.tooltip.font, Some(status));
}
#[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),
[None; 6],
fonts,
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 distinct_sys_colors() -> SysColors {
SysColors {
window_bg: crate::Rgba::rgb(1, 1, 1),
window_text: crate::Rgba::rgb(2, 2, 2),
btn_face: crate::Rgba::rgb(3, 3, 3),
btn_text: crate::Rgba::rgb(4, 4, 4),
highlight: crate::Rgba::rgb(5, 5, 5),
highlight_text: crate::Rgba::rgb(6, 6, 6),
hotlight: crate::Rgba::rgb(8, 8, 8),
gray_text: crate::Rgba::rgb(7, 7, 7),
}
}
fn reader_with_high_contrast(high_contrast: Option<bool>) -> crate::ReaderResult {
let accessibility = AccessibilityData {
text_scaling_factor: None,
high_contrast,
reduce_motion: None,
advanced_effects_enabled: None,
};
build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
[Some(crate::Rgba::rgb(0, 90, 170)); 6],
default_fonts(),
Some(&distinct_sys_colors()),
None,
Some(&accessibility),
)
}
#[test]
fn outside_high_contrast_the_reader_writes_only_the_accent_colours() {
for high_contrast in [Some(false), None] {
let result = reader_with_high_contrast(high_contrast);
let v = reader_mode(&result);
let font_color = |f: &Option<FontSpec>| f.as_ref().and_then(|f| f.color);
assert_eq!(v.defaults.accent_color, Some(crate::Rgba::rgb(0, 120, 215)));
assert_eq!(
v.button.primary_background,
Some(crate::Rgba::rgb(0, 90, 170))
);
assert_eq!(v.defaults.text_color, None);
assert_eq!(v.defaults.background_color, None);
assert_eq!(v.defaults.surface_color, None);
assert_eq!(v.defaults.disabled_text_color, None);
assert_eq!(v.defaults.selection_background, None);
assert_eq!(v.defaults.selection_text_color, None);
assert_eq!(v.defaults.accent_text_color, None);
assert_eq!(v.defaults.border.color, None);
assert_eq!(v.progress_bar.border, None);
assert_eq!(v.progress_bar.track_color, None);
assert_eq!(v.defaults.focus_ring_color, None);
assert_eq!(v.defaults.focus_ring_width, None);
assert_eq!(v.button.background_color, None);
assert_eq!(font_color(&v.button.font), None);
assert_eq!(v.button.primary_text_color, None);
assert_eq!(v.button.checked_text_color, None);
assert_eq!(v.menu.background_color, None);
assert_eq!(font_color(&v.menu.font), None);
assert_eq!(v.tooltip.background_color, None);
assert_eq!(font_color(&v.tooltip.font), None);
assert_eq!(v.input.background_color, None);
assert_eq!(font_color(&v.input.font), None);
assert_eq!(v.input.placeholder_color, None);
assert_eq!(v.list.selection_background, None);
assert_eq!(v.list.selection_text_color, None);
assert_eq!(v.window.title_bar_background, None);
assert_eq!(font_color(&v.window.title_bar_font), None);
assert_eq!(v.window.inactive_title_bar_background, None);
assert_eq!(v.window.inactive_title_bar_text_color, None);
assert_eq!(v.segmented_control.background_color, None);
assert_eq!(v.segmented_control.border, None);
assert_eq!(v.segmented_control.font, None);
assert_eq!(v.segmented_control.hover_background, None);
assert_eq!(v.segmented_control.active_background, None);
assert_eq!(v.segmented_control.active_text_color, None);
}
}
#[test]
fn under_high_contrast_the_reader_maps_the_system_colours() {
let result = reader_with_high_contrast(Some(true));
let v = reader_mode(&result);
let c = distinct_sys_colors();
let font_color = |f: &Option<FontSpec>| f.as_ref().and_then(|f| f.color);
assert_eq!(v.defaults.text_color, Some(c.window_text));
assert_eq!(v.defaults.background_color, Some(c.window_bg));
assert_eq!(v.defaults.surface_color, Some(c.window_bg));
assert_eq!(v.defaults.disabled_text_color, Some(c.gray_text));
assert_eq!(v.defaults.selection_background, Some(c.highlight));
assert_eq!(v.defaults.selection_text_color, Some(c.highlight_text));
assert_eq!(v.defaults.accent_color, Some(c.highlight));
assert_eq!(v.defaults.accent_text_color, Some(c.highlight_text));
assert_eq!(v.defaults.link_color, Some(c.hotlight));
assert_eq!(v.link.hover_text_color, None);
assert_eq!(v.link.active_text_color, None);
for (field, value) in accent_fills(v) {
assert_eq!(value, Some(c.highlight), "{field}");
}
assert_eq!(v.switch.hover_checked_background, Some(c.btn_face));
let seg = &v.segmented_control;
assert_eq!(seg.background_color, Some(c.btn_face));
assert_eq!(seg.border.as_ref().and_then(|b| b.color), Some(c.highlight));
assert_eq!(font_color(&seg.font), Some(c.btn_text));
assert_eq!(
seg.hover_background, None,
"a hovered item's highlight text has no field: the hover is not written"
);
assert_eq!(seg.active_background, Some(c.highlight));
assert_eq!(seg.active_text_color, Some(c.highlight_text));
assert_eq!(v.defaults.info_color, Some(c.window_text));
assert_eq!(
v.progress_bar.border.as_ref().and_then(|b| b.line_width),
Some(1.0)
);
assert_eq!(
v.progress_bar.border.as_ref().and_then(|b| b.color),
Some(c.window_text)
);
assert_eq!(v.progress_bar.track_color, Some(c.window_bg));
assert_eq!(v.defaults.border.color, Some(c.window_text));
assert_eq!(v.defaults.border.opacity, Some(1.0));
assert_eq!(v.defaults.focus_ring_color, Some(c.window_text));
assert_eq!(v.button.background_color, Some(c.btn_face));
assert_eq!(font_color(&v.button.font), Some(c.btn_text));
assert_eq!(v.button.primary_background, Some(c.highlight));
assert_eq!(v.button.primary_text_color, Some(c.highlight_text));
assert_eq!(v.button.checked_background, Some(c.highlight));
assert_eq!(v.button.checked_text_color, Some(c.highlight_text));
assert_eq!(v.input.background_color, Some(c.btn_face));
assert_eq!(font_color(&v.input.font), Some(c.btn_text));
assert_eq!(v.input.placeholder_color, Some(c.window_text));
assert_eq!(v.menu.background_color, Some(c.window_bg));
assert_eq!(font_color(&v.menu.font), Some(c.btn_text));
assert_eq!(v.tooltip.background_color, Some(c.window_bg));
assert_eq!(font_color(&v.tooltip.font), Some(c.window_text));
assert_eq!(v.list.selection_background, Some(c.highlight));
assert_eq!(v.list.selection_text_color, Some(c.highlight_text));
assert_eq!(v.window.title_bar_background, Some(c.window_bg));
assert_eq!(font_color(&v.window.title_bar_font), Some(c.btn_text));
assert_eq!(v.window.inactive_title_bar_background, Some(c.window_bg));
assert_eq!(v.window.inactive_title_bar_text_color, Some(c.gray_text));
assert_eq!(v.defaults.focus_ring_width, None);
}
#[test]
fn outside_high_contrast_the_title_bar_is_the_window_background() {
let mut base = crate::Theme::preset("windows-11").unwrap();
let r = reader_with_high_contrast(Some(false));
base.merge(&r.output.to_theme(&r.name, r.icon_set, &r.layout));
let tertiary = [
(base.light.clone().unwrap(), crate::Rgba::new(0, 0, 0, 0x72)),
(
base.dark.clone().unwrap(),
crate::Rgba::new(255, 255, 255, 0x87),
),
];
for (mut mode, tertiary_text) in tertiary {
mode.resolve_all();
let resolved = mode.validate().unwrap();
let window_bg = resolved.defaults.background_color;
assert_eq!(window_bg.a, 255);
assert_eq!(resolved.window.title_bar_background, window_bg);
assert_eq!(resolved.window.inactive_title_bar_background, window_bg);
assert_eq!(
resolved.window.title_bar_font.color,
resolved.defaults.text_color
);
assert_eq!(resolved.window.inactive_title_bar_text_color, tertiary_text);
}
}
#[test]
fn over_the_preset_the_selection_is_the_accent() {
let mut base = crate::Theme::preset("windows-11").unwrap();
let r = reader_with_high_contrast(Some(false));
base.merge(&r.output.to_theme(&r.name, r.icon_set, &r.layout));
let mut light = base.light.clone().unwrap();
light.resolve_all();
let resolved = light.validate().unwrap();
let accent = crate::Rgba::rgb(0, 120, 215);
assert_eq!(resolved.defaults.selection_background, accent);
assert_eq!(resolved.input.selection_background, accent);
}
#[test]
fn windows_11_controls_without_a_shadow_resolve_without_one() {
let theme = crate::Theme::preset("windows-11").unwrap();
for mode in [theme.light.clone().unwrap(), theme.dark.clone().unwrap()] {
let mut mode = mode;
mode.resolve_all();
let r = mode.validate().unwrap();
assert!(!r.input.border.shadow_enabled);
assert!(!r.checkbox.border.shadow_enabled);
assert!(!r.progress_bar.border.shadow_enabled);
assert!(!r.combo_box.border.shadow_enabled);
assert!(!r.segmented_control.border.shadow_enabled);
assert!(!r.expander.border.shadow_enabled);
}
}
#[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.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),
[None; 6],
read_all_system_fonts(),
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_icon_sizes() {
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
[None; 6],
default_fonts(),
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),
advanced_effects_enabled: None,
};
let theme = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
[None; 6],
default_fonts(),
None,
None,
Some(&accessibility),
);
assert!(matches!(
theme.output,
crate::ReaderOutput::Single { is_dark: false, .. }
));
}
#[test]
fn build_theme_reduce_transparency_is_advanced_effects_off() {
for (enabled, reduce) in [(Some(true), false), (Some(false), true), (None, false)] {
let accessibility = AccessibilityData {
text_scaling_factor: None,
high_contrast: None,
reduce_motion: None,
advanced_effects_enabled: enabled,
};
let result = build_theme(
crate::Rgba::rgb(0, 120, 215),
crate::Rgba::rgb(0, 0, 0),
[None; 6],
default_fonts(),
None,
None,
Some(&accessibility),
);
assert_eq!(
result.accessibility.reduce_transparency, reduce,
"AdvancedEffectsEnabled {enabled:?}"
);
}
}
#[test]
fn build_theme_includes_widget_sizing() {
let result = light_reader();
let variant = reader_mode(&result);
assert_eq!(variant.scrollbar.groove_width, Some(17.0));
assert_eq!(variant.scrollbar.min_thumb_length, Some(17.0));
assert_eq!(variant.defaults.focus_ring_width, None);
assert_eq!(variant.defaults.border.line_width, Some(1.0));
assert_eq!(variant.button.min_height, None);
assert_eq!(variant.splitter.divider_width, None);
assert_eq!(variant.menu.row_height, None);
assert_eq!(variant.defaults.border.corner_radius, None);
}
#[test]
fn build_theme_sets_the_accent_but_not_text_background_selection_focus() {
let result = light_reader();
let variant = reader_mode(&result);
assert_eq!(
variant.defaults.accent_color,
Some(crate::Rgba::rgb(0, 120, 215))
);
assert_eq!(variant.defaults.text_color, None);
assert_eq!(variant.defaults.background_color, None);
assert_eq!(variant.defaults.selection_background, None);
assert_eq!(variant.defaults.focus_ring_color, None);
}
#[test]
fn build_theme_leaves_focus_ring_width_to_the_preset() {
let result = light_reader();
assert_eq!(reader_mode(&result).defaults.focus_ring_width, None);
}
#[test]
fn build_theme_leaves_surface_to_the_preset() {
let result = light_reader();
assert_eq!(reader_mode(&result).defaults.surface_color, None);
}
#[test]
fn build_theme_leaves_disabled_text_to_the_preset() {
let result = light_reader();
assert_eq!(reader_mode(&result).defaults.disabled_text_color, None);
}
#[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 high_contrast_reader_over_the_preset_resolves() {
let mut base = crate::Theme::preset("windows-11").unwrap();
let r = reader_with_high_contrast(Some(true));
base.merge(&r.output.to_theme(&r.name, r.icon_set, &r.layout));
let mut light = base.light.clone().unwrap();
light.resolve_all();
let resolved = light.validate().unwrap_or_else(|e| {
panic!("high-contrast resolve/validate failed: {e}");
});
let c = distinct_sys_colors();
assert_eq!(resolved.button.background_color, c.btn_face);
assert_eq!(resolved.button.font.color, c.btn_text);
assert_eq!(resolved.list.selection_background, c.highlight);
}
#[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;
}
}
}