CamWight
f6a47a49d7
Colour vision modes (Protan, Deutan, Tritan) in Preferences > Graphics, with palettes, shader and icon colours adapted per mode, translations and tests.
862 lines
38 KiB
Rust
862 lines
38 KiB
Rust
//! Colour vision modes (#778), measured. Colours that appear together must stay apart (CIEDE2000
|
|
//! 10 or more) for normal vision and for the loss each mode is for, with two simulations of that
|
|
//! loss: Machado, Oliveira and Fernandes 2009 (severity 1) and Brettel, Viénot and Mollon 1997.
|
|
//! The instruments are checked first: CIEDE2000 on the 34 pairs Sharma, Wu and Dalal published
|
|
//! with their paper, Brettel on white and its own anchors.
|
|
//!
|
|
//! When a token edit breaks a mode here, give that token a value in the mode's table
|
|
//! (`assets/styles/ui/palettes.rs`) that passes.
|
|
|
|
use std::collections::BTreeSet;
|
|
|
|
use egui::Color32;
|
|
use serde_json::json;
|
|
|
|
use crate::theme::{ColorVision, Tokens};
|
|
|
|
type Rgb8 = [u8; 3];
|
|
type V3 = [f64; 3];
|
|
type M3 = [[f64; 3]; 3];
|
|
|
|
/// The smallest difference a pair may have (CIEDE2000).
|
|
const FLOOR: f64 = 10.0;
|
|
/// The shading the analysis colours get in the shader (`lit`: 0.55 turned away, 1 facing the eye).
|
|
const LIT: [f64; 4] = [0.55, 0.7, 0.85, 1.0];
|
|
const MODES: [ColorVision; 3] = [ColorVision::Protan, ColorVision::Deutan, ColorVision::Tritan];
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
enum Eye {
|
|
Normal,
|
|
Protan,
|
|
Deutan,
|
|
Tritan,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
enum Instrument {
|
|
Machado,
|
|
Brettel,
|
|
}
|
|
|
|
/// The loss a mode is for.
|
|
fn eye(mode: ColorVision) -> Eye {
|
|
match mode {
|
|
ColorVision::Off => Eye::Normal,
|
|
ColorVision::Protan => Eye::Protan,
|
|
ColorVision::Deutan => Eye::Deutan,
|
|
ColorVision::Tritan => Eye::Tritan,
|
|
}
|
|
}
|
|
|
|
// ---- the instruments ----
|
|
|
|
fn to_lin(c: f64) -> f64 {
|
|
if c <= 0.04045 { c / 12.92 } else { ((c + 0.055) / 1.055).powf(2.4) }
|
|
}
|
|
|
|
fn to_srgb(c: f64) -> f64 {
|
|
if c <= 0.0031308 { 12.92 * c } else { 1.055 * c.powf(1.0 / 2.4) - 0.055 }
|
|
}
|
|
|
|
fn mul(m: &M3, v: V3) -> V3 {
|
|
[0, 1, 2].map(|r| m[r][0] * v[0] + m[r][1] * v[1] + m[r][2] * v[2])
|
|
}
|
|
|
|
fn mat(a: &M3, b: &M3) -> M3 {
|
|
[0, 1, 2].map(|r| [0, 1, 2].map(|c| (0..3).map(|k| a[r][k] * b[k][c]).sum()))
|
|
}
|
|
|
|
fn inv(m: &M3) -> M3 {
|
|
let [[a, b, c], [d, e, f], [g, h, i]] = *m;
|
|
let det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
|
|
[
|
|
[(e * i - f * h) / det, (c * h - b * i) / det, (b * f - c * e) / det],
|
|
[(f * g - d * i) / det, (a * i - c * g) / det, (c * d - a * f) / det],
|
|
[(d * h - e * g) / det, (b * g - a * h) / det, (a * e - b * d) / det],
|
|
]
|
|
}
|
|
|
|
fn cross(u: V3, v: V3) -> V3 {
|
|
[u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]]
|
|
}
|
|
|
|
fn dot(u: V3, v: V3) -> f64 {
|
|
u[0] * v[0] + u[1] * v[1] + u[2] * v[2]
|
|
}
|
|
|
|
/// Machado, Oliveira, Fernandes 2009, severity 1.0, on linear sRGB (the authors' Table 1).
|
|
fn machado(eye: Eye) -> M3 {
|
|
match eye {
|
|
Eye::Protan => [[0.152286, 1.052583, -0.204868], [0.114503, 0.786281, 0.099216], [-0.003882, -0.048116, 1.051998]],
|
|
Eye::Deutan => [[0.367322, 0.860646, -0.227968], [0.280085, 0.672501, 0.047413], [-0.011820, 0.042940, 0.968881]],
|
|
Eye::Tritan => [[1.255528, -0.076749, -0.178779], [-0.078411, 0.930809, 0.147602], [0.004733, 0.691367, 0.303900]],
|
|
Eye::Normal => [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
|
|
}
|
|
}
|
|
|
|
/// Linear sRGB to CIE XYZ (D65), IEC 61966-2-1.
|
|
const XYZ_FROM_LIN: M3 = [[0.4124564, 0.3575761, 0.1804375], [0.2126729, 0.7151522, 0.0721750], [0.0193339, 0.1191920, 0.9503041]];
|
|
/// XYZ to cone responses (LMS), Smith and Pokorny 1975.
|
|
const LMS_FROM_XYZ: M3 = [[0.15514, 0.54312, -0.03286], [-0.15514, 0.45684, 0.03286], [0.0, 0.0, 0.00801]];
|
|
/// CIE 1931 2-degree colour matching functions (CIE 018:2019) at Brettel's anchors.
|
|
const CIE_475: V3 = [0.1421, 0.1126, 1.0419];
|
|
const CIE_485: V3 = [0.05795001, 0.1693, 0.6162];
|
|
const CIE_575: V3 = [0.8425, 0.9154, 0.0018];
|
|
const CIE_660: V3 = [0.1649, 0.061, 0.0];
|
|
|
|
/// The missing cone (0 L, 1 M, 2 S) and the two anchor wavelengths of its half-planes.
|
|
fn anchors(eye: Eye) -> (usize, V3, V3) {
|
|
match eye {
|
|
Eye::Protan => (0, CIE_475, CIE_575),
|
|
Eye::Deutan => (1, CIE_475, CIE_575),
|
|
Eye::Normal | Eye::Tritan => (2, CIE_485, CIE_660),
|
|
}
|
|
}
|
|
|
|
/// Brettel, Viénot, Mollon 1997: the missing cone's response is put back on one of two half-planes
|
|
/// through white and an anchor colour, chosen by the side of the white axis the colour is on.
|
|
fn brettel(eye: Eye, lin: V3) -> V3 {
|
|
let lms = mat(&LMS_FROM_XYZ, &XYZ_FROM_LIN);
|
|
let (c, w1, w2) = anchors(eye);
|
|
let white = mul(&lms, [1.0; 3]);
|
|
let (a1, a2) = (mul(&LMS_FROM_XYZ, w1), mul(&LMS_FROM_XYZ, w2));
|
|
let mut axis = [0.0; 3];
|
|
axis[c] = 1.0;
|
|
let sep = cross(white, axis);
|
|
let mut q = mul(&lms, lin);
|
|
let n = if dot(q, sep) * dot(a1, sep) >= 0.0 { cross(white, a1) } else { cross(white, a2) };
|
|
q[c] = -(0..3).filter(|k| *k != c).map(|k| n[k] * q[k]).sum::<f64>() / n[c];
|
|
mul(&inv(&lms), q)
|
|
}
|
|
|
|
/// What an eye sees of an sRGB colour, as sRGB 0..1.
|
|
fn simulate(c: Rgb8, eye: Eye, how: Instrument) -> V3 {
|
|
let srgb = c.map(|v| f64::from(v) / 255.0);
|
|
if eye == Eye::Normal {
|
|
return srgb;
|
|
}
|
|
let lin = srgb.map(to_lin);
|
|
let out = match how {
|
|
Instrument::Machado => mul(&machado(eye), lin),
|
|
Instrument::Brettel => brettel(eye, lin),
|
|
};
|
|
out.map(|v| to_srgb(v.clamp(0.0, 1.0)))
|
|
}
|
|
|
|
/// CIELAB (D65) of an sRGB colour.
|
|
fn lab(srgb: V3) -> V3 {
|
|
let [x, y, z] = mul(&XYZ_FROM_LIN, srgb.map(to_lin));
|
|
let f = |t: f64| if t > (6.0f64 / 29.0).powi(3) { t.cbrt() } else { t / (3.0 * (6.0f64 / 29.0).powi(2)) + 4.0 / 29.0 };
|
|
let (fx, fy, fz) = (f(x / 0.95047), f(y), f(z / 1.08883));
|
|
[116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz)]
|
|
}
|
|
|
|
/// CIEDE2000 (Sharma, Wu, Dalal 2005).
|
|
fn de2000(l1: V3, l2: V3) -> f64 {
|
|
let ([lightness1, a1, b1], [lightness2, a2, b2]) = (l1, l2);
|
|
let (c1, c2) = (a1.hypot(b1), a2.hypot(b2));
|
|
let cb = (c1 + c2) / 2.0;
|
|
let g = 0.5 * (1.0 - (cb.powi(7) / (cb.powi(7) + 25f64.powi(7))).sqrt());
|
|
let (a1p, a2p) = ((1.0 + g) * a1, (1.0 + g) * a2);
|
|
let (c1p, c2p) = (a1p.hypot(b1), a2p.hypot(b2));
|
|
let hue = |b: f64, a: f64, c: f64| if c == 0.0 { 0.0 } else { b.atan2(a).to_degrees().rem_euclid(360.0) };
|
|
let (h1p, h2p) = (hue(b1, a1p, c1p), hue(b2, a2p, c2p));
|
|
let dlp = lightness2 - lightness1;
|
|
let dcp = c2p - c1p;
|
|
let dhp = if c1p * c2p == 0.0 {
|
|
0.0
|
|
} else if (h2p - h1p).abs() <= 180.0 {
|
|
h2p - h1p
|
|
} else if h2p - h1p > 180.0 {
|
|
h2p - h1p - 360.0
|
|
} else {
|
|
h2p - h1p + 360.0
|
|
};
|
|
let dhp_big = 2.0 * (c1p * c2p).sqrt() * (dhp / 2.0).to_radians().sin();
|
|
let lbp = (lightness1 + lightness2) / 2.0;
|
|
let cbp = (c1p + c2p) / 2.0;
|
|
let hbp = if c1p * c2p == 0.0 {
|
|
h1p + h2p
|
|
} else if (h1p - h2p).abs() <= 180.0 {
|
|
(h1p + h2p) / 2.0
|
|
} else if h1p + h2p < 360.0 {
|
|
(h1p + h2p + 360.0) / 2.0
|
|
} else {
|
|
(h1p + h2p - 360.0) / 2.0
|
|
};
|
|
let cos = |deg: f64| deg.to_radians().cos();
|
|
let t = 1.0 - 0.17 * cos(hbp - 30.0) + 0.24 * cos(2.0 * hbp) + 0.32 * cos(3.0 * hbp + 6.0) - 0.20 * cos(4.0 * hbp - 63.0);
|
|
let dtheta = 30.0 * (-((hbp - 275.0) / 25.0).powi(2)).exp();
|
|
let rc = 2.0 * (cbp.powi(7) / (cbp.powi(7) + 25f64.powi(7))).sqrt();
|
|
let sl = 1.0 + 0.015 * (lbp - 50.0).powi(2) / (20.0 + (lbp - 50.0).powi(2)).sqrt();
|
|
let sc = 1.0 + 0.045 * cbp;
|
|
let sh = 1.0 + 0.015 * cbp * t;
|
|
let rt = -(2.0 * dtheta).to_radians().sin() * rc;
|
|
((dlp / sl).powi(2) + (dcp / sc).powi(2) + (dhp_big / sh).powi(2) + rt * (dcp / sc) * (dhp_big / sh)).sqrt()
|
|
}
|
|
|
|
fn diff(a: Rgb8, b: Rgb8, eye: Eye, how: Instrument) -> f64 {
|
|
de2000(lab(simulate(a, eye, how)), lab(simulate(b, eye, how)))
|
|
}
|
|
|
|
fn normal(a: Rgb8, b: Rgb8) -> f64 {
|
|
diff(a, b, Eye::Normal, Instrument::Machado)
|
|
}
|
|
|
|
/// The smallest difference for normal vision and for the mode's loss (both instruments).
|
|
fn worst(mode: ColorVision, a: Rgb8, b: Rgb8) -> f64 {
|
|
let e = eye(mode);
|
|
normal(a, b).min(diff(a, b, e, Instrument::Machado)).min(diff(a, b, e, Instrument::Brettel))
|
|
}
|
|
|
|
// ---- the colours that appear together ----
|
|
|
|
fn rgb(c: Color32) -> Rgb8 {
|
|
[c.r(), c.g(), c.b()]
|
|
}
|
|
|
|
/// A translucent colour over an opaque ground, in sRGB (close to egui's blend).
|
|
fn over(c: Color32, ground: Color32) -> Rgb8 {
|
|
let [r, g, b, a] = c.to_srgba_unmultiplied();
|
|
let k = f64::from(a) / 255.0;
|
|
let mix = |f: u8, g: u8| (f64::from(f) * k + f64::from(g) * (1.0 - k)).round() as u8;
|
|
[mix(r, ground.r()), mix(g, ground.g()), mix(b, ground.b())]
|
|
}
|
|
|
|
/// An analysis colour as the shader shades it.
|
|
fn lit(c: [f32; 3], k: f64) -> Rgb8 {
|
|
c.map(|x| ((f64::from(x) * 255.0).round() * k).min(255.0).round() as u8)
|
|
}
|
|
|
|
struct Group {
|
|
name: &'static str,
|
|
/// Colours that must differ from each other.
|
|
members: Vec<(&'static str, Rgb8)>,
|
|
/// What they are drawn on.
|
|
grounds: Vec<(&'static str, Rgb8)>,
|
|
}
|
|
|
|
fn group(name: &'static str, members: &[(&'static str, Color32)], grounds: &[(&'static str, Color32)]) -> Group {
|
|
for (n, c) in members.iter().chain(grounds) {
|
|
assert_eq!(c.a(), 255, "{name}: {n} is translucent; put it over its ground first");
|
|
}
|
|
Group { name, members: members.iter().map(|(n, c)| (*n, rgb(*c))).collect(), grounds: grounds.iter().map(|(n, c)| (*n, rgb(*c))).collect() }
|
|
}
|
|
|
|
/// Every group of meaning-carrying colours that appear together (and the icons' colours, drawn on
|
|
/// the toolbar with their caller's ink, fill and accent). Each colour is named by its `Tokens`
|
|
/// field, so `every_token_is_measured_or_carries_no_meaning` knows which tokens are measured.
|
|
fn groups(t: &Tokens) -> Vec<Group> {
|
|
let lift = |c: Color32| {
|
|
Color32::from_rgb(c.r().saturating_add(t.hover_face_lift), c.g().saturating_add(t.hover_face_lift), c.b().saturating_add(t.hover_face_lift))
|
|
};
|
|
let ic = &t.icons;
|
|
let a = &t.analysis;
|
|
let mut out = vec![
|
|
group(
|
|
"sketch lines",
|
|
&[
|
|
("sketch", t.sketch),
|
|
("sketch_fixed", t.sketch_fixed),
|
|
("sketch_locked", t.sketch_locked),
|
|
("sketch_projected", t.sketch_projected),
|
|
("sketch_lost", t.sketch_lost),
|
|
("sketch_construction", t.sketch_construction),
|
|
("sketch_centerline", t.sketch_centerline),
|
|
("preview_sketch", t.preview_sketch),
|
|
],
|
|
&[("viewport_top", t.viewport_top), ("viewport_bottom", t.viewport_bottom)],
|
|
),
|
|
group(
|
|
"sketch points",
|
|
&[("sketch_point", t.sketch_point), ("sketch_point_free", t.sketch_point_free), ("sketch_locked", t.sketch_locked)],
|
|
&[("viewport_top", t.viewport_top)],
|
|
),
|
|
group(
|
|
"timeline",
|
|
&[("timeline_item", t.timeline_item), ("timeline_item_error", t.timeline_item_error), ("hover", t.hover), ("accent_soft", t.accent_soft)],
|
|
&[],
|
|
),
|
|
group("UI text", &[("error", t.error), ("warning", t.warning), ("text", t.text)], &[("panel", t.panel)]),
|
|
group("origin axes", &[("axis_x", t.axis_x), ("axis_y", t.axis_y), ("axis_z", t.axis_z)], &[("viewport_top", t.viewport_top)]),
|
|
group("view triad", &[("triad[0]", t.triad[0]), ("triad[1]", t.triad[1]), ("triad[2]", t.triad[2])], &[("viewport_top", t.viewport_top)]),
|
|
group("gizmo", &[("gizmo[0]", t.gizmo[0]), ("gizmo[1]", t.gizmo[1]), ("gizmo[2]", t.gizmo[2])], &[("viewport_top", t.viewport_top)]),
|
|
group("bend lines", &[("bend_up", t.bend_up), ("bend_down", t.bend_down)], &[("viewport_top", t.viewport_top)]),
|
|
group("box select", &[("box_window", t.box_window), ("box_crossing", t.box_crossing)], &[("viewport_top", t.viewport_top)]),
|
|
group(
|
|
"selection",
|
|
&[
|
|
("body", t.body),
|
|
("sel_face", t.sel_face),
|
|
("body_selected", t.body_selected),
|
|
("hover_face_lift", lift(t.body)),
|
|
("preview_add", t.preview_add),
|
|
],
|
|
&[],
|
|
),
|
|
group("section", &[("section_cap", t.section_cap)], &[("body", t.body)]),
|
|
group("interference", &[("interference", t.interference)], &[("body", t.body)]),
|
|
// The scale's three stops, unlit. Shaded (a stop at one angle to the light, the next at
|
|
// another), middle and tight merge for a red-green loss (3.3 protan, 5.2 deutan) and flat
|
|
// and middle for tritan (4.6). That is the scale's own fault, in Off too: #975.
|
|
group(
|
|
"curvature map",
|
|
&[
|
|
("analysis.curvature[0]", crate::theme::srgb(a.curvature[0])),
|
|
("analysis.curvature[1]", crate::theme::srgb(a.curvature[1])),
|
|
("analysis.curvature[2]", crate::theme::srgb(a.curvature[2])),
|
|
],
|
|
&[],
|
|
),
|
|
group(
|
|
"ribbon accents",
|
|
&[("glyph_text", t.glyph_text), ("sketch_accent", t.sketch_accent), ("construction_geom", t.construction_geom)],
|
|
&[("toolbar", t.toolbar)],
|
|
),
|
|
group(
|
|
"origin icon",
|
|
&[("icons.axes[0]", ic.axes[0]), ("icons.axes[1]", ic.axes[1]), ("icons.axes[2]", ic.axes[2])],
|
|
&[("toolbar", t.toolbar)],
|
|
),
|
|
group(
|
|
"accessibility icon",
|
|
&[("icons.access[0]", ic.access[0]), ("icons.access[1]", ic.access[1]), ("icon_fill", t.icon_fill), ("icon", t.icon)],
|
|
&[],
|
|
),
|
|
group("draft icon", &[("icons.draft[0]", ic.draft[0]), ("icons.draft[1]", ic.draft[1]), ("icon", t.icon)], &[]),
|
|
group(
|
|
"curvature icon",
|
|
&[("icons.curvature[0]", ic.curvature[0]), ("icons.curvature[1]", ic.curvature[1]), ("icons.curvature[2]", ic.curvature[2])],
|
|
&[],
|
|
),
|
|
group(
|
|
"appearance icon",
|
|
&[("icons.paint[0]", ic.paint[0]), ("icons.paint[1]", ic.paint[1]), ("icons.paint[2]", ic.paint[2]), ("icon_fill", t.icon_fill)],
|
|
&[],
|
|
),
|
|
group("environment icon", &[("icons.sky", ic.sky), ("icons.floor", ic.floor), ("icons.highlight", ic.highlight)], &[]),
|
|
group("warning icon", &[("icons.warning", ic.warning), ("icon", t.icon)], &[("toolbar", t.toolbar)]),
|
|
group("interference icon", &[("icons.interference", ic.interference), ("icon", t.icon)], &[("toolbar", t.toolbar)]),
|
|
group("folder icons", &[("icons.folder", ic.folder), ("icons.plane", ic.plane), ("icons.fold", ic.fold), ("icon", t.icon)], &[]),
|
|
group("sheet icons", &[("icons.sheet", ic.sheet), ("icons.sheet_2", ic.sheet_2), ("icon", t.icon)], &[]),
|
|
group(
|
|
"app bar buttons",
|
|
&[("app_bar_icon[0]", t.app_bar_icon[0]), ("app_bar_icon[1]", t.app_bar_icon[1]), ("app_bar_icon[2]", t.app_bar_icon[2])],
|
|
&[("app_bar", t.app_bar)],
|
|
),
|
|
group("logo", &[("logo[0]", t.logo[0]), ("logo[1]", t.logo[1]), ("logo[2]", t.logo[2])], &[("app_bar", t.app_bar)]),
|
|
];
|
|
// The removed part of a cut preview is translucent over the body.
|
|
if let Some(sel) = out.iter_mut().find(|g| g.name == "selection") {
|
|
sel.members.push(("preview_cut", over(t.preview_cut, t.body)));
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Measured by the shaded check in `every_mode_keeps_colours_apart_for_its_eye`.
|
|
const SHADED: [&str; 2] = ["analysis.draft", "analysis.access"];
|
|
|
|
/// Tokens no colour vision mode needs to keep apart, and why. A new token fails
|
|
/// `every_token_is_measured_or_carries_no_meaning` until it is in a group above or here.
|
|
const NO_MEANING: &[(&str, &str)] = &[
|
|
// The window's chrome: grounds, text and borders (measured as grounds where meaning sits on them).
|
|
("panel_header", "chrome"),
|
|
("border", "chrome"),
|
|
("text_dim", "secondary text"),
|
|
("accent", "the one interface accent"),
|
|
("timeline", "the timeline's ground"),
|
|
("dialog_bg", "chrome"),
|
|
("dialog_border", "chrome"),
|
|
("chip", "a label's ground"),
|
|
("heading_bg", "chrome"),
|
|
("subheading_bg", "chrome"),
|
|
("overlay", "a chip's ground over the view"),
|
|
("app_bar_text", "text"),
|
|
("app_bar_hover", "a hovered tab, translucent white"),
|
|
("app_bar_tab_edge", "an inactive tab's outline, translucent white"),
|
|
("timeline_marker", "the rollback marker, alone"),
|
|
("field", "a field's ground"),
|
|
// Highlights: shades of the accent blue over what they mark, by design close to each other.
|
|
("sel_edge", "selection highlight"),
|
|
("sel_edge_rim", "selection highlight"),
|
|
("hover_edge", "hover highlight"),
|
|
("hover_edge_halo", "hover highlight"),
|
|
("sel_profile", "selection highlight"),
|
|
("sel_profile_edge", "selection highlight"),
|
|
("hover_profile", "hover highlight"),
|
|
("hover_profile_edge", "hover highlight"),
|
|
("sel_vertex", "selection highlight"),
|
|
("rubber_band", "the shape being drawn"),
|
|
("manipulator", "a drag handle, alone"),
|
|
// Planes, points, the grid and the model's edges: one neutral each, told apart by shape.
|
|
("origin_plane", "a plane, told apart by its place"),
|
|
("origin_plane_edge", "a plane's edge"),
|
|
("origin_plane_hover", "hover highlight"),
|
|
("origin_point", "the origin, alone"),
|
|
("construction_plane", "a plane"),
|
|
("body_edge", "the model's edges"),
|
|
("grid", "the grid"),
|
|
("grid_major", "the grid"),
|
|
("profile_fill", "a closed profile's tint"),
|
|
("dimension", "dimension text"),
|
|
("dimension_driven", "dimension text, dimmed"),
|
|
("glyph_bg", "a constraint glyph's ground"),
|
|
("glyph_edge", "a constraint glyph's edge"),
|
|
// The navigation cube: labelled faces.
|
|
("cube_face", "labelled"),
|
|
("cube_border", "labelled"),
|
|
("cube_text", "labelled"),
|
|
("cube_hover", "hover highlight"),
|
|
// Not a colour, or the end of a mark that is measured elsewhere.
|
|
("analysis.hatch", "a flag: stripes on the failing faces"),
|
|
("logo[3]", "the mark's white edge"),
|
|
// Icon colours that are a shade of a measured one, or one mark alone.
|
|
("icons.sheet_light", "a lighter shade of a sheet"),
|
|
("icons.sheet_line", "lines on a sheet"),
|
|
("icons.glint", "a highlight"),
|
|
("icons.stripe", "zebra stripes, grey"),
|
|
("icons.agent", "the agent's pointer, alone"),
|
|
("icons.marker_halo", "a dark halo under a marker"),
|
|
];
|
|
|
|
/// Every token field, by path (`sketch`, `analysis.draft`, `logo[3]`…): the arrays of distinct
|
|
/// meanings by element where only some elements are measured.
|
|
fn token_fields(t: &Tokens) -> BTreeSet<String> {
|
|
let text = format!("{t:#?}");
|
|
let mut out = BTreeSet::new();
|
|
let mut parent: Option<String> = None;
|
|
for line in text.lines() {
|
|
let indent = line.len() - line.trim_start().len();
|
|
let Some((name, rest)) = line.trim_start().split_once(": ") else { continue };
|
|
match indent {
|
|
4 if rest.ends_with('{') => parent = Some(name.to_string()),
|
|
4 => {
|
|
parent = None;
|
|
out.insert(name.to_string());
|
|
}
|
|
8 => {
|
|
if let Some(p) = &parent {
|
|
out.insert(format!("{p}.{name}"));
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// A group member's token field (`triad[0]` is part of `triad`).
|
|
fn field_of(name: &str) -> &str {
|
|
name.split('[').next().unwrap_or(name)
|
|
}
|
|
|
|
#[test]
|
|
fn every_token_is_measured_or_carries_no_meaning() {
|
|
for t in [Tokens::light(), Tokens::dark()] {
|
|
let measured: BTreeSet<&str> =
|
|
groups(&t).iter().flat_map(|g| g.members.iter().chain(&g.grounds).map(|(n, _)| field_of(n))).chain(SHADED).collect();
|
|
// An element of an array (`logo[3]`) is listed for the record; its array is measured.
|
|
let listed: BTreeSet<&str> = NO_MEANING.iter().map(|(n, _)| field_of(n)).collect();
|
|
let fields = token_fields(&t);
|
|
let unplaced: Vec<&String> = fields.iter().filter(|f| !measured.contains(f.as_str()) && !listed.contains(f.as_str())).collect();
|
|
assert!(unplaced.is_empty(), "tokens neither measured (`groups`) nor listed in `NO_MEANING`: {unplaced:?}");
|
|
let stale: Vec<&&str> = measured.iter().chain(&listed).filter(|f| !fields.contains(**f)).collect();
|
|
assert!(stale.is_empty(), "names that are not token fields: {stale:?}");
|
|
let both: Vec<&str> = NO_MEANING.iter().map(|(n, _)| *n).filter(|n| !n.contains('[') && measured.contains(n)).collect();
|
|
assert!(both.is_empty(), "measured and also listed as carrying no meaning: {both:?}");
|
|
}
|
|
}
|
|
|
|
/// Every pair in the groups: (group, name a, a, name b, b).
|
|
fn pairs(t: &Tokens) -> Vec<(String, Rgb8, Rgb8)> {
|
|
let mut out = Vec::new();
|
|
for g in groups(t) {
|
|
for (i, (na, a)) in g.members.iter().enumerate() {
|
|
for (nb, b) in g.members.iter().skip(i + 1).chain(&g.grounds) {
|
|
out.push((format!("{}: {na} vs {nb}", g.name), *a, *b));
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Pairs under the floor that the tables leave as they are (decided for #778). Each is close to
|
|
/// the floor for normal vision too, and construction and centerline lines also differ by their
|
|
/// dash patterns.
|
|
fn left_as_they_are(mode: ColorVision, dark: bool) -> BTreeSet<String> {
|
|
let mut v = vec!["sketch lines: sketch_construction vs sketch_centerline"];
|
|
if mode == ColorVision::Tritan {
|
|
v.push("sketch lines: sketch_lost vs sketch_centerline");
|
|
v.push(if dark { "timeline: hover vs accent_soft" } else { "timeline: timeline_item vs accent_soft" });
|
|
v.push("selection: sel_face vs preview_add");
|
|
}
|
|
v.into_iter().map(String::from).collect()
|
|
}
|
|
|
|
// ---- the tests ----
|
|
|
|
/// Sharma, Wu, Dalal, "The CIEDE2000 Color-Difference Formula: Implementation Notes,
|
|
/// Supplementary Test Data, and Mathematical Observations", Color Research and Application 30
|
|
/// (2005), Table 1: L*, a*, b* of each pair, then the difference.
|
|
const SHARMA: [[f64; 7]; 34] = [
|
|
[50.0000, 2.6772, -79.7751, 50.0000, 0.0000, -82.7485, 2.0425],
|
|
[50.0000, 3.1571, -77.2803, 50.0000, 0.0000, -82.7485, 2.8615],
|
|
[50.0000, 2.8361, -74.0200, 50.0000, 0.0000, -82.7485, 3.4412],
|
|
[50.0000, -1.3802, -84.2814, 50.0000, 0.0000, -82.7485, 1.0000],
|
|
[50.0000, -1.1848, -84.8006, 50.0000, 0.0000, -82.7485, 1.0000],
|
|
[50.0000, -0.9009, -85.5211, 50.0000, 0.0000, -82.7485, 1.0000],
|
|
[50.0000, 0.0000, 0.0000, 50.0000, -1.0000, 2.0000, 2.3669],
|
|
[50.0000, -1.0000, 2.0000, 50.0000, 0.0000, 0.0000, 2.3669],
|
|
[50.0000, 2.4900, -0.0010, 50.0000, -2.4900, 0.0009, 7.1792],
|
|
[50.0000, 2.4900, -0.0010, 50.0000, -2.4900, 0.0010, 7.1792],
|
|
[50.0000, 2.4900, -0.0010, 50.0000, -2.4900, 0.0011, 7.2195],
|
|
[50.0000, 2.4900, -0.0010, 50.0000, -2.4900, 0.0012, 7.2195],
|
|
[50.0000, -0.0010, 2.4900, 50.0000, 0.0009, -2.4900, 4.8045],
|
|
[50.0000, -0.0010, 2.4900, 50.0000, 0.0010, -2.4900, 4.8045],
|
|
[50.0000, -0.0010, 2.4900, 50.0000, 0.0011, -2.4900, 4.7461],
|
|
[50.0000, 2.5000, 0.0000, 50.0000, 0.0000, -2.5000, 4.3065],
|
|
[50.0000, 2.5000, 0.0000, 73.0000, 25.0000, -18.0000, 27.1492],
|
|
[50.0000, 2.5000, 0.0000, 61.0000, -5.0000, 29.0000, 22.8977],
|
|
[50.0000, 2.5000, 0.0000, 56.0000, -27.0000, -3.0000, 31.9030],
|
|
[50.0000, 2.5000, 0.0000, 58.0000, 24.0000, 15.0000, 19.4535],
|
|
[50.0000, 2.5000, 0.0000, 50.0000, 3.1736, 0.5854, 1.0000],
|
|
[50.0000, 2.5000, 0.0000, 50.0000, 3.2972, 0.0000, 1.0000],
|
|
[50.0000, 2.5000, 0.0000, 50.0000, 1.8634, 0.5757, 1.0000],
|
|
[50.0000, 2.5000, 0.0000, 50.0000, 3.2592, 0.3350, 1.0000],
|
|
[60.2574, -34.0099, 36.2677, 60.4626, -34.1751, 39.4387, 1.2644],
|
|
[63.0109, -31.0961, -5.8663, 62.8187, -29.7946, -4.0864, 1.2630],
|
|
[61.2901, 3.7196, -5.3901, 61.4292, 2.2480, -4.9620, 1.8731],
|
|
[35.0831, -44.1164, 3.7933, 35.0232, -40.0716, 1.5901, 1.8645],
|
|
[22.7233, 20.0904, -46.6940, 23.0331, 14.9730, -42.5619, 2.0373],
|
|
[36.4612, 47.8580, 18.3852, 36.2715, 50.5065, 21.2231, 1.4146],
|
|
[90.8027, -2.0831, 1.4410, 91.1528, -1.6435, 0.0447, 1.4441],
|
|
[90.9257, -0.5406, -0.9208, 88.6381, -0.8985, -0.7239, 1.5381],
|
|
[6.7747, -0.2908, -2.4247, 5.8714, -0.0985, -2.2286, 0.6377],
|
|
[2.0776, 0.0795, -1.1350, 0.9033, -0.0636, -0.5514, 0.9082],
|
|
];
|
|
|
|
#[test]
|
|
fn ciede2000_reproduces_sharmas_test_pairs() {
|
|
for (i, p) in SHARMA.iter().enumerate() {
|
|
let got = de2000([p[0], p[1], p[2]], [p[3], p[4], p[5]]);
|
|
assert!((got - p[6]).abs() < 1e-4, "pair {}: {got}, published {}", i + 1, p[6]);
|
|
// The formula is symmetric.
|
|
assert!((de2000([p[3], p[4], p[5]], [p[0], p[1], p[2]]) - got).abs() < 1e-9, "pair {}", i + 1);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_simulations_keep_white_and_brettels_anchors() {
|
|
let lms = mat(&LMS_FROM_XYZ, &XYZ_FROM_LIN);
|
|
for e in [Eye::Protan, Eye::Deutan, Eye::Tritan] {
|
|
let w = brettel(e, [1.0; 3]);
|
|
assert!(w.iter().all(|v| (v - 1.0).abs() < 1e-9), "{e:?}: white -> {w:?}");
|
|
let (_, a1, a2) = anchors(e);
|
|
for a in [a1, a2] {
|
|
let lin = mul(&inv(&lms), mul(&LMS_FROM_XYZ, a));
|
|
let back = brettel(e, lin);
|
|
assert!(lin.iter().zip(back).all(|(x, y)| (x - y).abs() < 1e-9), "{e:?}: anchor {lin:?} -> {back:?}");
|
|
}
|
|
let m = machado(e);
|
|
assert!(m.iter().all(|row| (row.iter().sum::<f64>() - 1.0).abs() < 1e-5), "{e:?}: Machado keeps white");
|
|
}
|
|
// Known losses: pure red and green merge for a red-green loss, blue and green for a blue one.
|
|
let (red, green, blue) = ([220, 60, 60], [60, 170, 60], [60, 100, 230]);
|
|
assert!(normal(red, green) > 60.0);
|
|
for how in [Instrument::Machado, Instrument::Brettel] {
|
|
assert!(diff(red, green, Eye::Deutan, how) < 10.0, "{how:?}");
|
|
assert!(diff(blue, green, Eye::Tritan, how) < diff(blue, green, Eye::Normal, how), "{how:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn off_gives_the_theme_unchanged() {
|
|
assert_eq!(Tokens::themed(false, ColorVision::Off), Tokens::light());
|
|
assert_eq!(Tokens::themed(true, ColorVision::Off), Tokens::dark());
|
|
for dark in [false, true] {
|
|
assert!(!Tokens::themed(dark, ColorVision::Off).analysis.hatch);
|
|
// Protan and Deutan share the red-green table.
|
|
assert_eq!(Tokens::themed(dark, ColorVision::Protan), Tokens::themed(dark, ColorVision::Deutan));
|
|
}
|
|
}
|
|
|
|
/// The token fields whose `Debug` text differs (`triad`, `analysis.draft`…), so a field cannot
|
|
/// change in a mode by accident.
|
|
fn changed_fields(a: &Tokens, b: &Tokens) -> BTreeSet<String> {
|
|
let (la, lb) = (format!("{a:#?}"), format!("{b:#?}"));
|
|
let (la, lb): (Vec<&str>, Vec<&str>) = (la.lines().collect(), lb.lines().collect());
|
|
assert_eq!(la.len(), lb.len());
|
|
let mut out = BTreeSet::new();
|
|
for i in (0..la.len()).filter(|i| la[*i] != lb[*i]) {
|
|
// The named fields above this line, innermost first, up to a field of `Tokens`.
|
|
let mut path = Vec::new();
|
|
let mut indent = usize::MAX;
|
|
for line in la[..=i].iter().rev() {
|
|
let here = line.len() - line.trim_start().len();
|
|
if here < indent
|
|
&& let Some((name, _)) = line.trim_start().split_once(':')
|
|
&& name.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
|
|
{
|
|
path.push(name.to_string());
|
|
indent = here;
|
|
}
|
|
if indent <= 4 {
|
|
break;
|
|
}
|
|
}
|
|
path.reverse();
|
|
out.insert(path.join("."));
|
|
}
|
|
out
|
|
}
|
|
|
|
#[test]
|
|
fn each_mode_changes_only_its_table() {
|
|
let set = |s: &[&str]| s.iter().map(|x| x.to_string()).collect::<BTreeSet<_>>();
|
|
let red_green_both = [
|
|
"triad",
|
|
"gizmo",
|
|
"analysis.draft",
|
|
"analysis.access",
|
|
"analysis.hatch",
|
|
"icons.axes",
|
|
"icons.access",
|
|
"icons.draft",
|
|
"bend_up",
|
|
"bend_down",
|
|
"sketch_accent",
|
|
"preview_sketch",
|
|
];
|
|
let mut red_green_light = red_green_both.to_vec();
|
|
red_green_light.extend(["sketch_projected", "sketch_locked", "timeline_item_error"]);
|
|
for (dark, mode, want) in [
|
|
(false, ColorVision::Protan, set(&red_green_light)),
|
|
(true, ColorVision::Protan, set(&red_green_both)),
|
|
(false, ColorVision::Deutan, set(&red_green_light)),
|
|
(true, ColorVision::Deutan, set(&red_green_both)),
|
|
(false, ColorVision::Tritan, set(&["sketch_locked", "box_crossing", "preview_sketch", "analysis.hatch"])),
|
|
(true, ColorVision::Tritan, set(&["sketch_locked", "box_crossing", "glyph_text", "preview_sketch", "analysis.hatch"])),
|
|
] {
|
|
let base = Tokens::themed(dark, ColorVision::Off);
|
|
assert_eq!(changed_fields(&base, &Tokens::themed(dark, mode)), want, "{mode:?}, dark {dark}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn every_mode_keeps_colours_apart_for_its_eye() {
|
|
let mut report = Vec::new();
|
|
for dark in [false, true] {
|
|
let off = Tokens::themed(dark, ColorVision::Off);
|
|
for mode in MODES {
|
|
let on = Tokens::themed(dark, mode);
|
|
let mut left = BTreeSet::new();
|
|
for ((name, a0, b0), (_, a1, b1)) in pairs(&off).into_iter().zip(pairs(&on)) {
|
|
// Close for everybody by design (hover tints, a shade of one hue), and not changed
|
|
// by the mode: not a colour vision fault.
|
|
if normal(a0, b0) < FLOOR && (a0, b0) == (a1, b1) {
|
|
continue;
|
|
}
|
|
let w = worst(mode, a1, b1);
|
|
if w < FLOOR {
|
|
report.push(format!("{mode:?} dark={dark} {name}: {w:.1} (before {:.1})", worst(mode, a0, b0)));
|
|
left.insert(name);
|
|
}
|
|
}
|
|
assert_eq!(left, left_as_they_are(mode, dark), "{mode:?}, dark {dark}: {report:#?}");
|
|
// Draft and Accessibility, for faces at any angle to the light against each other.
|
|
let a = &on.analysis;
|
|
let shaded = [(a.draft[0], a.draft[1]), (a.draft[0], a.draft[2]), (a.draft[1], a.draft[2]), (a.access[0], a.access[1])];
|
|
for (p, q) in shaded {
|
|
for x in LIT {
|
|
for y in LIT {
|
|
let w = worst(mode, lit(p, x), lit(q, y));
|
|
assert!(w >= FLOOR, "{mode:?}, dark {dark}: {p:?} lit {x} vs {q:?} lit {y}: {w:.1}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_shader_gets_the_modes_colours_and_its_stripes() {
|
|
for dark in [false, true] {
|
|
let off = crate::gpu::analysis_colors(&Tokens::themed(dark, ColorVision::Off).analysis);
|
|
assert_eq!(off[32], 0.0, "no stripes in Off");
|
|
for mode in MODES {
|
|
let t = Tokens::themed(dark, mode);
|
|
let v = crate::gpu::analysis_colors(&t.analysis);
|
|
assert_eq!(v[32], 1.0, "{mode:?}: stripes on the bad faces");
|
|
assert_eq!(v[..3], t.analysis.draft[0], "{mode:?}");
|
|
assert_eq!(v[16..19], t.analysis.access[1], "{mode:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- the preference ----
|
|
|
|
/// Every message the Colour vision section shows (the heading, the mode names and their
|
|
/// tooltips, the sample's names and the note) is in every catalogue, translated: in Japanese,
|
|
/// Korean, Russian and Chinese none is the English text. (German keeps "Protan", "Deutan" and
|
|
/// "Tritan".)
|
|
#[test]
|
|
fn the_sections_messages_are_in_every_catalog() {
|
|
let load = |text: &str| -> serde_json::Map<String, serde_json::Value> { serde_json::from_str(text).unwrap() };
|
|
let english = load(include_str!("../../../assets/locales/en.json"));
|
|
let ids: Vec<&str> = ColorVision::ALL
|
|
.into_iter()
|
|
.flat_map(|m| [m.label_id(), m.help_id()])
|
|
.chain(crate::prefs::COLOUR_VISION_SAMPLE)
|
|
.chain(["ui.colour_vision", "ui.colour_vision_mode", "ui.colour_vision_sample", "ui.colour_vision_note"])
|
|
.collect();
|
|
for (lang, text) in [
|
|
("de", include_str!("../../../assets/locales/de.json")),
|
|
("ja", include_str!("../../../assets/locales/ja.json")),
|
|
("ko", include_str!("../../../assets/locales/ko.json")),
|
|
("ru", include_str!("../../../assets/locales/ru.json")),
|
|
("zh", include_str!("../../../assets/locales/zh.json")),
|
|
] {
|
|
let catalog = load(text);
|
|
for id in &ids {
|
|
let (Some(en), Some(here)) = (english.get(*id), catalog.get(*id)) else {
|
|
panic!("{lang}: missing message {id} (English: {})", english.contains_key(*id));
|
|
};
|
|
assert!(lang == "de" || here != en, "{lang}: {id} is the English text {en}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn app() -> crate::SolveApp {
|
|
crate::SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default())
|
|
}
|
|
|
|
#[test]
|
|
fn saved_preferences_load_the_mode_and_a_bad_one_loads_as_off() {
|
|
use crate::prefs::Prefs;
|
|
// Saved before the mode existed.
|
|
let old: Prefs = serde_json::from_value(json!({"theme": "light"})).unwrap();
|
|
assert_eq!((old.color_vision, old.theme.as_str()), (ColorVision::Off, "light"));
|
|
for mode in ColorVision::ALL {
|
|
let p = Prefs { color_vision: mode, ..Prefs::default() };
|
|
let v = serde_json::to_value(&p).unwrap();
|
|
assert_eq!(v["color_vision"], mode.id());
|
|
assert_eq!(serde_json::from_value::<Prefs>(v).unwrap(), p);
|
|
}
|
|
// A value this version doesn't know (a later SolidCraft's mode, a hand edit) is Off, and the
|
|
// rest of the preferences still load.
|
|
for bad in [json!("achromat"), json!("PROTAN"), json!(""), json!(3), json!(null), json!(true), json!({"protan": 1}), json!(["tritan"])] {
|
|
let p: Prefs = serde_json::from_value(json!({"theme": "light", "color_vision": bad})).unwrap();
|
|
assert_eq!((p.color_vision, p.theme.as_str()), (ColorVision::Off, "light"), "{bad}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ui_prefs_sets_each_mode_and_refuses_anything_else() {
|
|
let mut app = app();
|
|
for mode in ColorVision::ALL {
|
|
let out = crate::prefs::set(&mut app, &json!({"color_vision": mode.id()})).unwrap();
|
|
assert_eq!(out["color_vision"], mode.id());
|
|
assert_eq!(app.preferences.color_vision, mode);
|
|
}
|
|
let long = "p".repeat(1 << 20);
|
|
for bad in [
|
|
json!("purple"),
|
|
json!("Protan"),
|
|
json!(" protan"),
|
|
json!(""),
|
|
json!(long),
|
|
json!(2),
|
|
json!(-1.5),
|
|
json!(null),
|
|
json!(false),
|
|
json!([]),
|
|
json!({}),
|
|
] {
|
|
let before = app.preferences.clone();
|
|
let err = crate::prefs::set(&mut app, &json!({"color_vision": bad, "theme": "light"})).unwrap_err();
|
|
assert!(err.contains("off, protan, deutan or tritan"), "{err}");
|
|
assert_eq!(app.preferences, before, "a refused value changes nothing");
|
|
}
|
|
}
|
|
|
|
/// Random values (fixed seed): strings near the four ids and far from them, numbers, nesting.
|
|
/// `ui.prefs` takes exactly the four ids and refuses the rest without a change; saved
|
|
/// preferences load every value, unknown ones as Off. Nothing panics.
|
|
#[test]
|
|
fn random_values_never_panic_and_only_the_four_ids_are_taken() {
|
|
fn value(next: &mut impl FnMut() -> u64, depth: u32) -> serde_json::Value {
|
|
let ids = ["off", "protan", "deutan", "tritan"];
|
|
match next() % if depth > 3 { 6 } else { 8 } {
|
|
0 => json!(ids[(next() % 4) as usize]),
|
|
1 => {
|
|
// A near miss: one id with a character changed, added or taken away.
|
|
let mut s: Vec<char> = ids[(next() % 4) as usize].chars().collect();
|
|
let i = (next() % s.len() as u64) as usize;
|
|
match next() % 3 {
|
|
0 => s[i] = char::from_u32((next() % 0x2FFF) as u32).unwrap_or('?'),
|
|
1 => s.insert(i, ['\0', ' ', 'É', '\u{301}', 'ـ'][(next() % 5) as usize]),
|
|
_ => {
|
|
s.remove(i);
|
|
}
|
|
}
|
|
json!(s.into_iter().collect::<String>())
|
|
}
|
|
2 => json!((0..next() % 40).map(|_| char::from_u32((next() % 0x10FFFF) as u32).unwrap_or('x')).collect::<String>()),
|
|
3 => json!(next() as i64),
|
|
4 => json!(Some(f64::from_bits(next())).filter(|x| x.is_finite()).unwrap_or(0.5)),
|
|
5 => [json!(null), json!(true), json!(false)][(next() % 3) as usize].clone(),
|
|
6 => json!((0..next() % 4).map(|_| value(next, depth + 1)).collect::<Vec<_>>()),
|
|
_ => json!({"color_vision": value(next, depth + 1)}),
|
|
}
|
|
}
|
|
let mut seed = 0x9E37_79B9_7F4A_7C15u64;
|
|
let mut next = move || {
|
|
seed ^= seed << 13;
|
|
seed ^= seed >> 7;
|
|
seed ^= seed << 17;
|
|
seed
|
|
};
|
|
let mut app = app();
|
|
let mut taken = 0;
|
|
for _ in 0..4000 {
|
|
let v = value(&mut next, 0);
|
|
let id = v.as_str().and_then(ColorVision::from_id);
|
|
let before = app.preferences.clone();
|
|
match crate::prefs::set(&mut app, &json!({"color_vision": v})) {
|
|
Ok(_) => {
|
|
taken += 1;
|
|
assert_eq!(Some(app.preferences.color_vision), id, "{v}");
|
|
}
|
|
Err(e) => {
|
|
assert!(id.is_none() && e.contains("off, protan, deutan or tritan"), "{v}: {e}");
|
|
assert_eq!(app.preferences, before, "{v}");
|
|
}
|
|
}
|
|
let saved: crate::prefs::Prefs = serde_json::from_value(json!({"theme": "light", "color_vision": v})).unwrap();
|
|
assert_eq!((saved.color_vision, saved.theme.as_str()), (id.unwrap_or_default(), "light"), "{v}");
|
|
}
|
|
assert!(taken > 200, "the four ids came up {taken} times");
|
|
}
|
|
|
|
#[test]
|
|
fn cancel_puts_the_mode_back_ok_keeps_it_and_restore_defaults_resets_graphics_only() {
|
|
let mut app = app();
|
|
let control = |app: &mut crate::SolveApp, p: serde_json::Value| crate::prefs::control(app, &p).unwrap();
|
|
control(&mut app, json!({"open": "Graphics"}));
|
|
control(&mut app, json!({"color_vision": "protan"}));
|
|
assert_eq!(app.preferences.color_vision, ColorVision::Protan);
|
|
control(&mut app, json!({"button": "cancel"}));
|
|
assert_eq!(app.preferences.color_vision, ColorVision::Off);
|
|
control(&mut app, json!({"open": "Graphics"}));
|
|
control(&mut app, json!({"color_vision": "tritan", "button": "ok"}));
|
|
assert_eq!(app.preferences.color_vision, ColorVision::Tritan);
|
|
// Restore Defaults on another page leaves it.
|
|
control(&mut app, json!({"open": "General"}));
|
|
control(&mut app, json!({"button": "defaults"}));
|
|
assert_eq!(app.preferences.color_vision, ColorVision::Tritan);
|
|
control(&mut app, json!({"open": "Graphics"}));
|
|
control(&mut app, json!({"button": "defaults"}));
|
|
assert_eq!(app.preferences.color_vision, ColorVision::Off);
|
|
control(&mut app, json!({"button": "ok"}));
|
|
}
|