#![allow(unsafe_code)]
#[cfg(all(target_os = "macos", feature = "macos"))]
use block2::RcBlock;
#[cfg(all(target_os = "macos", feature = "macos"))]
use objc2_app_kit::{
NSAppearance, NSColor, NSColorSpace, NSControlSize, NSFont, NSFontTraitsAttribute,
NSFontWeightRegular, NSFontWeightTrait, NSScroller, NSScrollerStyle, NSWorkspace,
};
#[cfg(all(target_os = "macos", feature = "macos"))]
use objc2_foundation::{NSDictionary, NSNumber, NSProcessInfo, NSString};
#[cfg(all(target_os = "macos", feature = "macos"))]
fn nscolor_to_rgba(color: &NSColor, srgb: &NSColorSpace) -> Option<crate::Rgba> {
let srgb_color = color.colorUsingColorSpace(srgb)?;
let r = srgb_color.redComponent() as f32;
let g = srgb_color.greenComponent() as f32;
let b = srgb_color.blueComponent() as f32;
let a = srgb_color.alphaComponent() as f32;
Some(crate::Rgba::from_f32(r, g, b, a))
}
const TEXT_INSERTION_POINT_MAJOR: u32 = 14;
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
fn has_text_insertion_point_color(version: crate::pipeline::OsVersion) -> bool {
version.major >= TEXT_INSERTION_POINT_MAJOR
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
fn disabled_checked_alpha(version: crate::pipeline::OsVersion) -> u8 {
if crate::pipeline::macos_generation(version).0.name == "macos-tahoe" {
0x73
} else {
0x80
}
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
fn apply_accent_fades(v: &mut crate::ThemeMode, disabled_checked_alpha: u8) {
v.switch.disabled_checked_background = v
.defaults
.accent_color
.map(|a| crate::Rgba::new(a.r, a.g, a.b, disabled_checked_alpha));
}
#[cfg(all(target_os = "macos", feature = "macos"))]
#[derive(Default)]
struct PerWidgetColors {
placeholder: Option<crate::Rgba>,
caret: Option<crate::Rgba>,
alternate_row: Option<crate::Rgba>,
header_foreground: Option<crate::Rgba>,
grid_color: Option<crate::Rgba>,
title_bar_foreground: Option<crate::Rgba>,
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_appearance_colors() -> (crate::ThemeDefaults, PerWidgetColors) {
let srgb = NSColorSpace::sRGBColorSpace();
let label_c = NSColor::labelColor();
let control_accent = NSColor::controlAccentColor();
let window_bg = NSColor::windowBackgroundColor();
let control_bg = NSColor::controlBackgroundColor();
let separator_c = NSColor::separatorColor();
let secondary_label = NSColor::secondaryLabelColor();
let alt_sel_text = NSColor::alternateSelectedControlTextColor();
let system_red = NSColor::systemRedColor();
let system_orange = NSColor::systemOrangeColor();
let system_green = NSColor::systemGreenColor();
let system_blue = NSColor::systemBlueColor();
let sel_content_bg = NSColor::selectedContentBackgroundColor();
let sel_text = NSColor::selectedTextColor();
let sel_text_bg = NSColor::selectedTextBackgroundColor();
let link_c = NSColor::linkColor();
let focus_c = NSColor::keyboardFocusIndicatorColor();
let disabled_text = NSColor::disabledControlTextColor();
let placeholder_c = NSColor::placeholderTextColor();
let insertion_point_c =
has_text_insertion_point_color(os_version()).then(NSColor::textInsertionPointColor);
let unemph_sel_bg = NSColor::unemphasizedSelectedContentBackgroundColor();
let alt_bg_colors = NSColor::alternatingContentBackgroundColors();
let header_text_c = NSColor::headerTextColor();
let grid_c = NSColor::gridColor();
let frame_text_c = NSColor::windowFrameTextColor();
let label = nscolor_to_rgba(&label_c, &srgb);
let defaults = crate::ThemeDefaults {
accent_color: nscolor_to_rgba(&control_accent, &srgb),
accent_text_color: nscolor_to_rgba(&alt_sel_text, &srgb),
background_color: nscolor_to_rgba(&window_bg, &srgb),
text_color: label,
surface_color: nscolor_to_rgba(&control_bg, &srgb),
border: crate::model::border::DefaultsBorderSpec {
color: nscolor_to_rgba(&separator_c, &srgb),
..Default::default()
},
muted_color: nscolor_to_rgba(&secondary_label, &srgb),
danger_color: nscolor_to_rgba(&system_red, &srgb),
danger_text_color: label,
warning_color: nscolor_to_rgba(&system_orange, &srgb),
warning_text_color: label,
success_color: nscolor_to_rgba(&system_green, &srgb),
success_text_color: label,
info_color: nscolor_to_rgba(&system_blue, &srgb),
info_text_color: label,
selection_background: nscolor_to_rgba(&sel_content_bg, &srgb),
selection_text_color: nscolor_to_rgba(&alt_sel_text, &srgb),
selection_inactive_background: nscolor_to_rgba(&unemph_sel_bg, &srgb),
text_selection_background: nscolor_to_rgba(&sel_text_bg, &srgb),
text_selection_color: nscolor_to_rgba(&sel_text, &srgb),
link_color: nscolor_to_rgba(&link_c, &srgb),
focus_ring_color: nscolor_to_rgba(&focus_c, &srgb),
disabled_text_color: nscolor_to_rgba(&disabled_text, &srgb),
..Default::default()
};
let alternate_row = if alt_bg_colors.count() >= 2 {
nscolor_to_rgba(&alt_bg_colors.objectAtIndex(1), &srgb)
} else {
None
};
let per_widget = PerWidgetColors {
placeholder: nscolor_to_rgba(&placeholder_c, &srgb),
caret: insertion_point_c
.as_ref()
.and_then(|c| nscolor_to_rgba(c, &srgb)),
alternate_row,
header_foreground: nscolor_to_rgba(&header_text_c, &srgb),
grid_color: nscolor_to_rgba(&grid_c, &srgb),
title_bar_foreground: nscolor_to_rgba(&frame_text_c, &srgb),
};
(defaults, per_widget)
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_variant(appearance: &NSAppearance) -> (crate::ThemeDefaults, PerWidgetColors) {
let data = std::cell::Cell::new(None);
{
let block = RcBlock::new(|| data.set(Some(read_appearance_colors())));
appearance.performAsCurrentDrawingAppearance(&block);
}
data.into_inner().unwrap_or_default()
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn apply_per_widget(v: &mut crate::ThemeMode, pw: PerWidgetColors) {
v.input.placeholder_color = pw.placeholder;
v.input.caret_color = pw.caret;
v.list.alternate_row_background = pw.alternate_row;
if let Some(color) = pw.header_foreground {
v.list.header_font.get_or_insert_default().color = Some(color);
}
v.list.grid_color = pw.grid_color;
if let Some(color) = pw.title_bar_foreground {
v.window.title_bar_font.get_or_insert_default().color = Some(color);
}
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
fn scrollbar_for_style(overlay: bool, width_for: impl Fn(bool) -> f64) -> crate::ScrollbarTheme {
crate::ScrollbarTheme {
groove_width: Some(width_for(overlay) as f32),
overlay_mode: Some(overlay),
..Default::default()
}
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_scrollbar(mtm: objc2::MainThreadMarker) -> crate::ScrollbarTheme {
let overlay = NSScroller::preferredScrollerStyle(mtm) == NSScrollerStyle::Overlay;
scrollbar_for_style(overlay, |overlay| {
let style = if overlay {
NSScrollerStyle::Overlay
} else {
NSScrollerStyle::Legacy
};
NSScroller::scrollerWidthForControlSize_scrollerStyle(NSControlSize::Regular, style, mtm)
})
}
#[cfg(all(target_os = "macos", feature = "macos"))]
pub(crate) fn os_version() -> crate::pipeline::OsVersion {
let v = NSProcessInfo::processInfo().operatingSystemVersion();
let part = |n: isize| u32::try_from(n).unwrap_or_default();
crate::pipeline::OsVersion::new(
part(v.majorVersion),
part(v.minorVersion),
part(v.patchVersion),
)
}
#[cfg(all(target_os = "macos", feature = "macos"))]
pub(crate) fn reduce_motion() -> bool {
NSWorkspace::sharedWorkspace().accessibilityDisplayShouldReduceMotion()
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_accessibility() -> (Option<bool>, Option<bool>, Option<bool>) {
let workspace = NSWorkspace::sharedWorkspace();
(
Some(reduce_motion()),
Some(workspace.accessibilityDisplayShouldIncreaseContrast()),
Some(workspace.accessibilityDisplayShouldReduceTransparency()),
)
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn nsfont_weight_to_css(font: &NSFont) -> Option<u16> {
let (traits_key, weight_key): (&NSString, &NSString) =
unsafe { (NSFontTraitsAttribute, NSFontWeightTrait) };
let traits_obj = font.fontDescriptor().objectForKey(traits_key)?;
let w = traits_obj
.downcast_ref::<NSDictionary>()?
.objectForKey(weight_key)?
.downcast_ref::<NSNumber>()?
.doubleValue();
let css = if w <= -0.75 {
100
} else if w <= -0.35 {
200
} else if w <= -0.1 {
300
} else if w <= 0.1 {
400
} else if w <= 0.27 {
500
} else if w <= 0.35 {
600
} else if w <= 0.5 {
700
} else if w <= 0.6 {
800
} else {
900
};
Some(css)
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn fontspec_from_nsfont(font: &NSFont) -> crate::FontSpec {
crate::FontSpec {
family: font
.familyName()
.map(|n| std::sync::Arc::from(n.to_string())),
size: Some(crate::model::font::FontSize::Pt(font.pointSize() as f32)),
weight: nsfont_weight_to_css(font),
..Default::default()
}
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_fonts() -> (crate::FontSpec, crate::FontSpec) {
let system_size = NSFont::systemFontSize();
let system_font = NSFont::systemFontOfSize(system_size);
let mono_font =
unsafe { NSFont::monospacedSystemFontOfSize_weight(system_size, NSFontWeightRegular) };
(
fontspec_from_nsfont(&system_font),
fontspec_from_nsfont(&mono_font),
)
}
#[cfg(all(target_os = "macos", feature = "system-fonts"))]
pub(crate) struct SystemUiFont {
pub(crate) family: String,
pub(crate) path: std::path::PathBuf,
}
#[cfg(all(target_os = "macos", feature = "system-fonts"))]
pub(crate) fn system_ui_font(italic: bool) -> Option<SystemUiFont> {
use objc2_core_foundation::{CFString, CFURL};
use objc2_core_text::{
CTFont, CTFontSymbolicTraits, CTFontUIFontType, kCTFontFamilyNameAttribute,
kCTFontURLAttribute,
};
let upright = unsafe { CTFont::new_ui_font_for_language(CTFontUIFontType::System, 0.0, None) }?;
let font = if italic {
let slanted = unsafe {
upright.copy_with_symbolic_traits(
0.0,
std::ptr::null(),
CTFontSymbolicTraits::ItalicTrait,
CTFontSymbolicTraits::ItalicTrait,
)
};
slanted.unwrap_or(upright)
} else {
upright
};
let (family_key, url_key) = unsafe { (kCTFontFamilyNameAttribute, kCTFontURLAttribute) };
let family = unsafe { font.attribute(family_key) }?
.downcast::<CFString>()
.ok()?
.to_string();
let path = unsafe { font.attribute(url_key) }?
.downcast::<CFURL>()
.ok()?
.to_file_path()?;
Some(SystemUiFont { family, path })
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_per_widget_fonts() -> (crate::FontSpec, crate::FontSpec, crate::FontSpec) {
let menu_font = NSFont::menuFontOfSize(0.0);
let tooltip_font = NSFont::toolTipsFontOfSize(0.0);
let title_bar_font = NSFont::titleBarFontOfSize(0.0);
(
fontspec_from_nsfont(&menu_font),
fontspec_from_nsfont(&tooltip_font),
fontspec_from_nsfont(&title_bar_font),
)
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
struct WidgetFontData {
menu_font: crate::FontSpec,
tooltip_font: crate::FontSpec,
title_bar_font: crate::FontSpec,
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
fn build_theme(
light_defaults: crate::ThemeDefaults,
dark_defaults: crate::ThemeDefaults,
widget_fonts: &WidgetFontData,
) -> crate::Theme {
let variant = |defaults: crate::ThemeDefaults| crate::ThemeMode {
defaults,
menu: crate::MenuTheme {
font: Some(widget_fonts.menu_font.clone()),
..Default::default()
},
tooltip: crate::TooltipTheme {
font: Some(widget_fonts.tooltip_font.clone()),
..Default::default()
},
window: crate::WindowTheme {
title_bar_font: Some(widget_fonts.title_bar_font.clone()),
..Default::default()
},
..Default::default()
};
crate::Theme {
name: "macOS".into(),
light: Some(variant(light_defaults)),
dark: Some(variant(dark_defaults)),
layout: crate::LayoutTheme::default(),
icon_set: Some(crate::IconSet::SfSymbols),
icon_theme: None,
}
}
#[cfg(all(target_os = "macos", feature = "macos"))]
pub(crate) struct MacosReader;
#[cfg(all(target_os = "macos", feature = "macos"))]
#[async_trait::async_trait]
impl crate::reader::ThemeReader for MacosReader {
async fn read(&self) -> crate::Result<crate::ReaderResult> {
read_macos()
}
}
#[cfg(all(target_os = "macos", feature = "macos"))]
fn read_macos() -> crate::Result<crate::ReaderResult> {
let light_name = NSString::from_str("NSAppearanceNameAqua");
let dark_name = NSString::from_str("NSAppearanceNameDarkAqua");
let light_appearance = NSAppearance::appearanceNamed(&light_name);
let dark_appearance = NSAppearance::appearanceNamed(&dark_name);
if light_appearance.is_none() && dark_appearance.is_none() {
return Err(crate::Error::ReaderFailed {
reader: crate::error::reader_names::MACOS,
source: "neither light nor dark NSAppearance could be created".into(),
});
}
let (font, mono_font) = read_fonts();
let (menu_font, tooltip_font, title_bar_font) = read_per_widget_fonts();
let widget_fonts = WidgetFontData {
menu_font,
tooltip_font,
title_bar_font,
};
let read = |appearance: Option<&NSAppearance>| match appearance {
Some(app) => {
let (mut defaults, pw) = read_variant(app);
defaults.font = font.clone();
defaults.mono_font = mono_font.clone();
(defaults, Some(pw))
}
None => (crate::ThemeDefaults::default(), None),
};
let (light_defaults, light_pw) = read(light_appearance.as_deref());
let (dark_defaults, dark_pw) = read(dark_appearance.as_deref());
let mut theme = build_theme(light_defaults, dark_defaults, &widget_fonts);
let scrollbar = objc2::MainThreadMarker::new().map(read_scrollbar);
let disabled_on_alpha = disabled_checked_alpha(os_version());
for (variant, pw) in [(&mut theme.light, light_pw), (&mut theme.dark, dark_pw)] {
let Some(v) = variant else { continue };
if let Some(pw) = pw {
apply_per_widget(v, pw);
}
apply_accent_fades(v, disabled_on_alpha);
if let Some(scrollbar) = &scrollbar {
v.scrollbar.merge(scrollbar);
}
}
let (reduce_motion, high_contrast, reduce_transparency) = read_accessibility();
let mut acc = crate::AccessibilityPreferences::default();
if let Some(rm) = reduce_motion {
acc.reduce_motion = rm;
}
if let Some(hc) = high_contrast {
acc.high_contrast = hc;
}
if let Some(rt) = reduce_transparency {
acc.reduce_transparency = rt;
}
let font_dpi = Some(72.0_f32);
let output = crate::ReaderOutput::Dual {
light: Box::new(theme.light.unwrap_or_default()),
dark: Box::new(theme.dark.unwrap_or_default()),
is_dark: crate::detect::detect_is_dark(),
};
Ok(crate::ReaderResult {
output,
name: theme.name,
icon_set: theme.icon_set,
layout: theme.layout,
font_dpi,
accessibility: acc,
})
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::model::font::FontSize;
#[cfg(all(target_os = "macos", feature = "macos"))]
#[test]
fn from_system_mode_is_the_os_appearance() {
let sys = crate::SystemTheme::from_system().unwrap();
let expected = if crate::detect::detect_is_dark() {
crate::ColorMode::Dark
} else {
crate::ColorMode::Light
};
assert_eq!(
sys.mode, expected,
"SystemTheme::mode must follow AppleInterfaceStyle"
);
}
fn sample_widget_fonts() -> WidgetFontData {
use crate::model::font::FontSize;
WidgetFontData {
menu_font: crate::FontSpec {
family: Some("SF Pro".into()),
size: Some(FontSize::Pt(14.0)),
weight: Some(400),
..Default::default()
},
tooltip_font: crate::FontSpec {
family: Some("SF Pro".into()),
size: Some(FontSize::Pt(11.0)),
weight: Some(400),
..Default::default()
},
title_bar_font: crate::FontSpec {
family: Some("SF Pro".into()),
size: Some(FontSize::Pt(13.0)),
weight: Some(700),
..Default::default()
},
}
}
fn sample_light_defaults() -> crate::ThemeDefaults {
use crate::model::font::FontSize;
crate::ThemeDefaults {
accent_color: Some(crate::Rgba::rgb(0, 122, 255)),
background_color: Some(crate::Rgba::rgb(246, 246, 246)),
text_color: Some(crate::Rgba::rgb(0, 0, 0)),
surface_color: Some(crate::Rgba::rgb(255, 255, 255)),
border: crate::model::border::DefaultsBorderSpec {
color: Some(crate::Rgba::rgb(200, 200, 200)),
..Default::default()
},
font: crate::FontSpec {
family: Some("SF Pro".into()),
size: Some(FontSize::Pt(13.0)),
weight: None,
..Default::default()
},
mono_font: crate::FontSpec {
family: Some("SF Mono".into()),
size: Some(FontSize::Pt(13.0)),
weight: None,
..Default::default()
},
..Default::default()
}
}
fn sample_dark_defaults() -> crate::ThemeDefaults {
use crate::model::font::FontSize;
crate::ThemeDefaults {
accent_color: Some(crate::Rgba::rgb(10, 132, 255)),
background_color: Some(crate::Rgba::rgb(30, 30, 30)),
text_color: Some(crate::Rgba::rgb(255, 255, 255)),
surface_color: Some(crate::Rgba::rgb(44, 44, 46)),
border: crate::model::border::DefaultsBorderSpec {
color: Some(crate::Rgba::rgb(56, 56, 58)),
..Default::default()
},
font: crate::FontSpec {
family: Some("SF Pro".into()),
size: Some(FontSize::Pt(13.0)),
weight: None,
..Default::default()
},
..Default::default()
}
}
#[test]
fn build_theme_populates_both_variants() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
assert!(theme.light.is_some(), "light variant should be Some");
assert!(theme.dark.is_some(), "dark variant should be Some");
let light = theme.light.as_ref().unwrap();
let dark = theme.dark.as_ref().unwrap();
assert_ne!(light.defaults.accent_color, dark.defaults.accent_color);
assert_ne!(
light.defaults.background_color,
dark.defaults.background_color
);
assert_eq!(light.defaults.font, dark.defaults.font);
}
#[test]
fn build_theme_name_is_macos() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
assert_eq!(theme.name, "macOS");
}
#[test]
fn build_theme_fonts_populated() {
use crate::model::font::FontSize;
let defaults = crate::ThemeDefaults {
font: crate::FontSpec {
family: Some("SF Pro".into()),
size: Some(FontSize::Pt(13.0)),
weight: None,
..Default::default()
},
mono_font: crate::FontSpec {
family: Some("SF Mono".into()),
size: Some(FontSize::Pt(13.0)),
weight: None,
..Default::default()
},
..Default::default()
};
let theme = build_theme(defaults.clone(), defaults, &sample_widget_fonts());
let light = theme.light.as_ref().unwrap();
assert_eq!(light.defaults.font.family.as_deref(), Some("SF Pro"));
assert_eq!(light.defaults.font.size, Some(FontSize::Pt(13.0)));
assert_eq!(light.defaults.mono_font.family.as_deref(), Some("SF Mono"));
assert_eq!(light.defaults.mono_font.size, Some(FontSize::Pt(13.0)));
let dark = theme.dark.as_ref().unwrap();
assert_eq!(dark.defaults.font.family.as_deref(), Some("SF Pro"));
assert_eq!(dark.defaults.font.size, Some(FontSize::Pt(13.0)));
}
#[test]
fn build_theme_defaults_empty_produces_nonempty_variant() {
let theme = build_theme(
crate::ThemeDefaults::default(),
crate::ThemeDefaults::default(),
&sample_widget_fonts(),
);
let light = theme.light.as_ref().unwrap();
assert!(
!light.is_empty(),
"light variant should have widget defaults"
);
let dark = theme.dark.as_ref().unwrap();
assert!(!dark.is_empty(), "dark variant should have widget defaults");
}
#[test]
fn build_theme_colors_propagated_correctly() {
let blue = crate::Rgba::rgb(0, 122, 255);
let red = crate::Rgba::rgb(255, 59, 48);
let light_defaults = crate::ThemeDefaults {
accent_color: Some(blue),
..Default::default()
};
let dark_defaults = crate::ThemeDefaults {
accent_color: Some(red),
..Default::default()
};
let theme = build_theme(light_defaults, dark_defaults, &sample_widget_fonts());
let light = theme.light.as_ref().unwrap();
let dark = theme.dark.as_ref().unwrap();
assert_eq!(light.defaults.accent_color, Some(blue));
assert_eq!(dark.defaults.accent_color, Some(red));
}
#[test]
fn a_custom_accent_reaches_the_accent_fills() {
let red = crate::Rgba::rgb(255, 59, 48);
let defaults = |accent| crate::ThemeDefaults {
accent_color: Some(accent),
..Default::default()
};
let theme = build_theme(defaults(red), defaults(red), &sample_widget_fonts());
for preset in ["macos-monterey", "macos-tahoe"] {
let mut mode = crate::Theme::preset(preset).unwrap().light.unwrap();
assert_ne!(mode.defaults.accent_color, Some(red), "{preset}");
mode.merge(theme.light.as_ref().unwrap());
let r = mode
.into_resolved(&crate::ResolutionContext::for_tests())
.unwrap();
assert_eq!(r.checkbox.checked_background, red, "{preset}");
assert_eq!(r.switch.checked_background, red, "{preset}");
assert_eq!(r.slider.fill_color, red, "{preset}");
assert_eq!(r.progress_bar.fill_color, red, "{preset}");
}
}
#[test]
fn build_theme_states_no_design_constants() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
for variant in [theme.light.as_ref(), theme.dark.as_ref()] {
let mut rest = variant.unwrap().clone();
rest.defaults = crate::ThemeDefaults::default();
rest.menu.font = None;
rest.tooltip.font = None;
rest.window.title_bar_font = None;
assert_eq!(
rest,
crate::ThemeMode::default(),
"build_theme states a value macOS did not report"
);
}
}
#[test]
fn build_theme_has_icon_set_sf_symbols() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
assert_eq!(theme.icon_set, Some(crate::IconSet::SfSymbols));
}
#[test]
fn build_theme_per_widget_fonts_populated() {
let wf = sample_widget_fonts();
let theme = build_theme(sample_light_defaults(), sample_dark_defaults(), &wf);
let light = theme.light.as_ref().unwrap();
assert_eq!(
light.menu.font.as_ref().unwrap().size,
Some(FontSize::Pt(14.0)),
"menu font size"
);
assert_eq!(
light.tooltip.font.as_ref().unwrap().size,
Some(FontSize::Pt(11.0)),
"tooltip font size"
);
assert_eq!(
light.window.title_bar_font.as_ref().unwrap().weight,
Some(700),
"title bar font weight"
);
let dark = theme.dark.as_ref().unwrap();
assert_eq!(light.menu.font, dark.menu.font);
assert_eq!(light.tooltip.font, dark.tooltip.font);
assert_eq!(light.window.title_bar_font, dark.window.title_bar_font);
}
#[test]
fn build_theme_per_widget_colors_not_populated_by_build() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
let light = theme.light.as_ref().unwrap();
assert!(
light.input.placeholder_color.is_none(),
"placeholder_color starts None (set by from_macos)"
);
assert!(
light.list.alternate_row_background.is_none(),
"alternate_row_background starts None"
);
assert!(light.list.header_font.is_none(), "header_font starts None");
assert!(light.list.grid_color.is_none(), "grid_color starts None");
}
#[test]
fn build_theme_scrollbar_overlay_not_set_by_build() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
let light = theme.light.as_ref().unwrap();
assert!(
light.scrollbar.overlay_mode.is_none(),
"overlay_mode starts None (set by from_macos)"
);
}
#[test]
fn a_disabled_on_switch_is_the_accent_at_its_generations_alpha() {
use crate::pipeline::OsVersion;
for (version, preset) in [
(OsVersion::new(12, 0, 0), "macos-monterey"),
(OsVersion::new(15, 7, 9), "macos-monterey"),
(OsVersion::new(16, 0, 0), "macos-monterey"),
(OsVersion::new(26, 6, 2), "macos-tahoe"),
(OsVersion::new(27, 0, 1), "macos-tahoe"),
] {
let theme = crate::Theme::preset(preset).unwrap();
for mode in [theme.light.as_ref().unwrap(), theme.dark.as_ref().unwrap()] {
let mut read = crate::ThemeMode {
defaults: crate::ThemeDefaults {
accent_color: mode.defaults.accent_color,
..Default::default()
},
..Default::default()
};
apply_accent_fades(&mut read, disabled_checked_alpha(version));
assert_eq!(
read.switch.disabled_checked_background,
mode.switch.disabled_checked_background,
"{preset} on {version}"
);
}
}
}
#[test]
fn a_custom_accent_reaches_the_disabled_on_switch_and_tahoes_segment() {
use crate::pipeline::OsVersion;
let red = crate::Rgba::rgb(224, 56, 62);
for (version, preset) in [
(OsVersion::new(15, 7, 9), "macos-monterey"),
(OsVersion::new(26, 6, 2), "macos-tahoe"),
] {
let alpha = disabled_checked_alpha(version);
let mut read = crate::ThemeMode {
defaults: crate::ThemeDefaults {
accent_color: Some(red),
..Default::default()
},
..Default::default()
};
apply_accent_fades(&mut read, alpha);
let mut mode = crate::Theme::preset(preset).unwrap().light.unwrap();
mode.merge(&read);
let r = mode
.into_resolved(&crate::ResolutionContext::for_tests())
.unwrap();
assert_eq!(
r.switch.disabled_checked_background,
Some(crate::Rgba::new(224, 56, 62, alpha)),
"{preset}"
);
assert_eq!(
r.segmented_control.active_background == red,
preset == "macos-tahoe",
"{preset}"
);
}
}
#[test]
fn the_insertion_point_colour_is_read_from_macos_14() {
use crate::pipeline::OsVersion;
assert!(!has_text_insertion_point_color(OsVersion::new(13, 7, 8)));
assert!(!has_text_insertion_point_color(OsVersion::new(12, 0, 0)));
assert!(has_text_insertion_point_color(OsVersion::new(14, 0, 0)));
assert!(has_text_insertion_point_color(OsVersion::new(15, 7, 9)));
assert!(has_text_insertion_point_color(OsVersion::new(16, 0, 0)));
assert!(has_text_insertion_point_color(OsVersion::new(26, 6, 2)));
}
#[test]
fn scrollbar_for_style_takes_the_styles_width() {
let width_for = |overlay: bool| if overlay { 16.0 } else { 15.0 };
let overlay = scrollbar_for_style(true, width_for);
assert_eq!(overlay.overlay_mode, Some(true));
assert_eq!(
overlay.groove_width,
Some(16.0),
"the overlay style's width"
);
let legacy = scrollbar_for_style(false, width_for);
assert_eq!(legacy.overlay_mode, Some(false));
assert_eq!(legacy.groove_width, Some(15.0), "the legacy style's width");
}
#[test]
fn build_theme_dialog_button_order_not_set_by_build() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
let light = theme.light.as_ref().unwrap();
assert!(
light.dialog.button_order.is_none(),
"button_order starts None (set by from_macos)"
);
}
#[test]
fn build_theme_accessibility_not_set_by_build() {
let theme = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
assert!(theme.light.is_some());
}
#[test]
fn test_macos_resolve_validate() {
let mut base = crate::Theme::preset("macos-monterey").unwrap();
let reader_output = build_theme(
sample_light_defaults(),
sample_dark_defaults(),
&sample_widget_fonts(),
);
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!("macOS resolve/validate pipeline failed (light): {e}");
});
assert_eq!(
resolved.defaults.accent_color,
crate::Rgba::rgb(0, 122, 255),
"accent should be from macOS reader"
);
assert_eq!(
resolved.defaults.font.family.as_ref(),
"SF Pro",
"font family should be from macOS reader"
);
let mut dark = base
.dark
.clone()
.expect("dark variant should exist after merge");
dark.resolve_all();
let resolved_dark = dark.validate().unwrap_or_else(|e| {
panic!("macOS resolve/validate pipeline failed (dark): {e}");
});
assert_eq!(
resolved_dark.defaults.accent_color,
crate::Rgba::rgb(10, 132, 255),
"dark accent should be from macOS reader"
);
}
#[cfg(all(target_os = "macos", feature = "macos"))]
#[test]
fn read_appearance_colors_reads_border_color_from_separator_color() {
let (defaults, _) = super::read_appearance_colors();
assert!(
defaults.border.color.is_some(),
"defaults.border.color should be read from NSColor.separatorColor"
);
}
#[cfg(all(target_os = "macos", feature = "macos"))]
#[test]
fn read_appearance_colors_maps_selection_and_shadow_as_platform_facts_names() {
let srgb = NSColorSpace::sRGBColorSpace();
let (defaults, _) = super::read_appearance_colors();
assert_eq!(
defaults.shadow_color, None,
"NSColor.shadowColor is not the drawn shadow (platform-facts.md:1057)"
);
assert_eq!(
defaults.selection_text_color,
nscolor_to_rgba(&NSColor::alternateSelectedControlTextColor(), &srgb)
);
assert_eq!(
defaults.text_selection_color,
nscolor_to_rgba(&NSColor::selectedTextColor(), &srgb)
);
assert_eq!(
defaults.text_selection_background,
nscolor_to_rgba(&NSColor::selectedTextBackgroundColor(), &srgb)
);
}
#[cfg(all(target_os = "macos", feature = "macos"))]
#[test]
fn from_system_reports_the_running_generation() {
let sys = crate::SystemTheme::from_system().unwrap();
let (preset, matched) = crate::pipeline::macos_generation(super::os_version());
assert_eq!(sys.preset, preset.name);
assert_eq!(sys.version_match, Some(matched));
}
#[cfg(all(target_os = "macos", feature = "macos"))]
#[test]
fn read_macos_leaves_the_text_field_selection_to_inheritance() {
let result = super::read_macos().unwrap();
assert!(
matches!(
&result.output,
crate::ReaderOutput::Dual { light, .. } if light.input.selection_background.is_none()
),
"the reader should return both variants, light input.selection_background unset: it \
inherits defaults.text_selection_background (platform-facts.md:1210)"
);
assert!(
matches!(
&result.output,
crate::ReaderOutput::Dual { dark, .. } if dark.input.selection_background.is_none()
),
"the reader should return both variants, dark input.selection_background unset: it \
inherits defaults.text_selection_background (platform-facts.md:1210)"
);
}
#[test]
fn macos_reader_exists() {
let _: Option<&dyn crate::reader::ThemeReader> = None;
#[cfg(all(target_os = "macos", feature = "macos"))]
{
let r: Box<dyn crate::reader::ThemeReader> = Box::new(super::MacosReader);
let _ = &r;
}
}
}