use super::*;
use day_spec::{Color, Ink, SystemColor};
use objc2::rc::Weak;
use objc2_app_kit::NSAppearance;
use std::ptr::NonNull;
pub(super) fn is_dark_match(best_match: Option<&str>) -> bool {
best_match.is_some_and(|n| n.contains("DarkAqua"))
}
pub(super) fn map_pair(pair: (Color, Color), f: impl Fn(Color) -> Color) -> Ink {
let (light, dark) = (f(pair.0), f(pair.1));
if light == dark {
Ink::Fixed(light)
} else {
Ink::adaptive(light, dark)
}
}
pub(super) fn role_color(role: SystemColor) -> Retained<NSColor> {
match role {
SystemColor::Accent => NSColor::controlAccentColor(),
SystemColor::Text => NSColor::labelColor(),
SystemColor::SecondaryText => NSColor::secondaryLabelColor(),
SystemColor::TertiaryText => NSColor::tertiaryLabelColor(),
SystemColor::Placeholder => NSColor::placeholderTextColor(),
SystemColor::Link => NSColor::linkColor(),
SystemColor::Separator => NSColor::separatorColor(),
SystemColor::ControlFill => {
if <NSColor as objc2::ClassType>::class()
.responds_to(objc2::sel!(quaternarySystemFillColor))
{
NSColor::quaternarySystemFillColor()
} else {
NSColor::controlColor()
}
}
SystemColor::Background | SystemColor::GroupedBackground => {
NSColor::windowBackgroundColor()
}
SystemColor::Surface => NSColor::controlBackgroundColor(),
SystemColor::ElevatedSurface => NSColor::underPageBackgroundColor(),
SystemColor::Selection => NSColor::selectedTextBackgroundColor(),
SystemColor::Destructive => NSColor::systemRedColor(),
SystemColor::Success => NSColor::systemGreenColor(),
SystemColor::Warning => NSColor::systemOrangeColor(),
}
}
pub(super) fn standard_appearance(appearance: &NSAppearance) -> Option<Retained<NSAppearance>> {
let names = objc2_foundation::NSArray::from_slice(&[
unsafe { objc2_app_kit::NSAppearanceNameAqua },
unsafe { objc2_app_kit::NSAppearanceNameDarkAqua },
]);
appearance
.bestMatchFromAppearancesWithNames(&names)
.and_then(|n| NSAppearance::appearanceNamed(&n))
}
fn is_dark(appearance: &NSAppearance) -> bool {
let names = objc2_foundation::NSArray::from_slice(&[
unsafe { objc2_app_kit::NSAppearanceNameAqua },
unsafe { objc2_app_kit::NSAppearanceNameDarkAqua },
]);
let best = appearance.bestMatchFromAppearancesWithNames(&names);
is_dark_match(best.map(|n| n.to_string()).as_deref())
}
#[must_use]
pub fn nsink(ink: Ink) -> Retained<NSColor> {
match ink {
Ink::Fixed(c) => nscolor(c),
Ink::System { role, alpha: None } => role_color(role),
Ink::Adaptive { light, dark } => {
let (light, dark) = (nscolor(light), nscolor(dark));
let provider = block2::RcBlock::new(move |appearance: NonNull<NSAppearance>| {
let appearance = unsafe { appearance.as_ref() };
let pick = if is_dark(appearance) { &dark } else { &light };
NonNull::from(&**pick)
});
unsafe { NSColor::colorWithName_dynamicProvider(None, &provider) }
}
Ink::System {
role,
alpha: Some(alpha),
} => {
let provider = block2::RcBlock::new(move |appearance: NonNull<NSAppearance>| {
let appearance = unsafe { appearance.as_ref() };
let c = color_in(appearance, Ink::system(role)).with_alpha(alpha);
let ptr = Retained::autorelease_return(nscolor(c));
unsafe { NonNull::new_unchecked(ptr) }
});
unsafe { NSColor::colorWithName_dynamicProvider(None, &provider) }
}
}
}
pub(super) fn srgb(color: &NSColor) -> Option<Color> {
let c = color.colorUsingColorSpace(&objc2_app_kit::NSColorSpace::sRGBColorSpace())?;
Some(Color::rgba(
c.redComponent(),
c.greenComponent(),
c.blueComponent(),
c.alphaComponent(),
))
}
pub(super) fn ink_now(ink: Ink) -> Color {
match ink {
Ink::Fixed(c) => c,
_ => srgb(&nsink(ink)).unwrap_or_else(|| ink.resolved()),
}
}
pub(super) fn color_in(appearance: &NSAppearance, ink: Ink) -> Color {
if let Ink::Fixed(c) = ink {
return c;
}
let out = Cell::new(ink.resolved());
let block = block2::StackBlock::new(|| out.set(ink_now(ink)));
match standard_appearance(appearance) {
Some(standard) => standard.performAsCurrentDrawingAppearance(&block),
None => appearance.performAsCurrentDrawingAppearance(&block),
}
out.get()
}
pub(super) fn color_for(view: &NSView, ink: Ink) -> Color {
match ink {
Ink::Fixed(c) => c,
_ => color_in(&view.effectiveAppearance(), ink),
}
}
pub(super) fn cg_for(view: &NSView, ink: Ink) -> Retained<objc2_core_graphics::CGColor> {
nscolor(color_for(view, ink)).CGColor()
}
fn pair_now(ink: Ink) -> (Color, Color) {
match ink {
Ink::Fixed(c) => (c, c),
Ink::Adaptive { light, dark } => (light, dark),
Ink::System { .. } => {
let side = |name: &objc2_app_kit::NSAppearanceName| {
NSAppearance::appearanceNamed(name)
.map_or_else(|| ink.resolved(), |a| color_in(&a, ink))
};
let (aqua, dark) = unsafe {
(
objc2_app_kit::NSAppearanceNameAqua,
objc2_app_kit::NSAppearanceNameDarkAqua,
)
};
(side(aqua), side(dark))
}
}
}
pub(super) fn map_ink(ink: Ink, f: impl Fn(Color) -> Color) -> Ink {
match ink {
Ink::Fixed(c) => Ink::Fixed(f(c)),
_ => map_pair(pair_now(ink), f),
}
}
thread_local! {
static TINTED: RefCell<Vec<Weak<NSButton>>> = const { RefCell::new(Vec::new()) };
}
pub(super) fn track_tinted(btn: &NSButton) {
TINTED.with(|t| {
let mut t = t.borrow_mut();
t.retain(|w| {
w.load()
.is_some_and(|b| !std::ptr::eq(Retained::as_ptr(&b), std::ptr::from_ref(btn)))
});
t.push(Weak::new(btn));
});
}
pub(super) fn refresh_layers() {
let live: Vec<Retained<NSButton>> = TINTED.with(|t| {
let mut t = t.borrow_mut();
t.retain(|w| w.load().is_some());
t.iter().filter_map(Weak::load).collect()
});
for btn in live {
let style = BUTTON_STYLES.with(|m| m.borrow().get(&ptr_of(&btn)).copied());
if let Some(day_spec::props::ButtonStyleSpec::Tinted(ink)) = style
&& let Some(layer) = btn.layer()
{
layer.setBackgroundColor(Some(&cg_for(&btn, ink)));
}
}
}
pub(super) fn refresh_layers_soon() {
refresh_layers();
dispatch2::DispatchQueue::main().exec_async(|| ffi_guard::contain((), refresh_layers));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dark_matches_by_the_best_match_name() {
assert!(is_dark_match(Some("NSAppearanceNameDarkAqua")));
assert!(!is_dark_match(Some("NSAppearanceNameAqua")));
assert!(!is_dark_match(None));
}
#[test]
fn a_mapped_pair_stays_a_pair_unless_both_sides_agree() {
let white = Color::rgb(1.0, 1.0, 1.0);
let black = Color::rgb(0.0, 0.0, 0.0);
let on = |c: Color| {
if c.r > 0.5 { black } else { white }
};
assert_eq!(map_pair((white, black), on), Ink::adaptive(black, white));
assert_eq!(map_pair((black, black), on), Ink::Fixed(white));
}
}