Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

refactor(ui-egui): move panels/color.rs tests to panels/color/tests.rs

aionggbfcd245bb613
diff --git a/crates/ui-egui/src/panels/color.rs b/crates/ui-egui/src/panels/color.rs
index 379a3a025..c1153ce46 100644
--- a/crates/ui-egui/src/panels/color.rs
+++ b/crates/ui-egui/src/panels/color.rs
@@ -749,599 +749,4 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use vectorcraft_engine::Session;
-
- fn app() -> VectorcraftApp {
- let mut app = VectorcraftApp::new(Session::new(), Default::default());
- app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
- app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
- app
- }
-
- /// Run the panel for one frame with `events` and `modifiers`; returns the spectrum's rect (when
- /// the options are shown) and the panel's height.
- fn frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>, modifiers: egui::Modifiers) -> (Option<Rect>, f32) {
- frame_with(app, ctx, events, modifiers, "color-spectrum")
- }
-
- /// [`frame`] returning the rect of the panel's widget `id` instead of the spectrum's.
- fn frame_with(
- app: &mut VectorcraftApp,
- ctx: &egui::Context,
- events: Vec<egui::Event>,
- modifiers: egui::Modifiers,
- id: impl std::hash::Hash + std::fmt::Debug,
- ) -> (Option<Rect>, f32) {
- let mut out = (None, 0.0);
- let events = std::iter::once(egui::Event::ModifiersChanged(modifiers)).chain(events).collect();
- let input = egui::RawInput { events, ..Default::default() };
- let mut full = ctx.run_ui(input, |ui| {
- show(app, ui);
- out = (ctx.read_response(ui.scope_id().with(&id)).map(|r| r.rect), ui.min_rect().height());
- });
- full.textures_delta.clear();
- out
- }
-
- /// Click the spectrum at (x, y) (0..1 each) with `modifiers` held.
- fn click_spectrum(app: &mut VectorcraftApp, ctx: &egui::Context, (x, y): (f32, f32), modifiers: egui::Modifiers) {
- let r = frame(app, ctx, vec![], modifiers).0.expect("the spectrum is drawn");
- let pos = egui::pos2(r.left() + x * r.width(), r.top() + y * r.height());
- let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers };
- frame(app, ctx, vec![egui::Event::PointerMoved(pos), button(true)], modifiers);
- frame(app, ctx, vec![button(false)], modifiers);
- frame(app, ctx, vec![], egui::Modifiers::NONE);
- }
-
- #[test]
- fn a_recent_colour_recolours_the_selected_gradient_stop() {
- // #835: it replaced the whole gradient with the colour.
- let mut app = app();
- app.run("paint.setFill", json!({"color": "#ff0000"})).unwrap();
- let stops = json!([{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#000000"}]);
- app.run("paint.setFill", json!({"gradient": {"stops": stops, "start": [10, 35], "end": [60, 35]}})).unwrap();
- app.select_tool("gradient");
- app.run("gradient.selectStop", json!({"index": 1})).unwrap();
- let red = app.session.recent_colors.iter().position(|c| c.to_hex() == "#ff0000").expect("red is a recent colour");
- let ctx = egui::Context::default();
- let none = egui::Modifiers::NONE;
- let chip = frame_with(&mut app, &ctx, vec![], none, ("recent", red)).0.expect("the chip is drawn").center();
- let button = |pressed| egui::Event::PointerButton { pos: chip, button: egui::PointerButton::Primary, pressed, modifiers: none };
- frame(&mut app, &ctx, vec![egui::Event::PointerMoved(chip), button(true)], none);
- frame(&mut app, &ctx, vec![button(false)], none);
- let Paint::Gradient(g) = crate::panels::current_paints(&app).0 else { panic!("still a gradient") };
- let hex: Vec<String> = g.gradient.stops.iter().map(|s| s.color.to_hex()).collect();
- assert_eq!(hex, ["#ffffff", "#ff0000"]);
- }
-
- /// In a CMYK document the sliders keep the model picked in the panel for a gradient stop and a
- /// freeform point, as they do for a solid fill.
- #[test]
- fn a_gradient_stop_and_a_freeform_point_keep_the_panels_model_in_a_cmyk_document() {
- let mut app = app();
- app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
- let stops = json!([{"offset": 0, "color": {"c": 0, "m": 0, "y": 0, "k": 0}}, {"offset": 1, "color": {"c": 0, "m": 100, "y": 100, "k": 0}}]);
- app.run("paint.setFill", json!({"gradient": {"stops": stops}})).unwrap();
- app.select_tool("gradient");
- app.run("gradient.selectStop", json!({"index": 1})).unwrap();
- let orange = Color::rgb8(255, 128, 0);
- let tgt = target_with(&app, false);
- apply(&mut app, &tgt, orange, Live::Released, false);
- let Paint::Gradient(g) = crate::panels::current_paints(&app).0 else { panic!("still a gradient") };
- assert_eq!(g.gradient.stops[1].color, orange);
- app.run("paint.editGradient", json!({"kind": "freeform"})).unwrap();
- let tgt = target_with(&app, false);
- assert!(matches!(tgt, Target::Point { index: 0, .. }), "a freeform point is the target");
- apply(&mut app, &tgt, orange, Live::Released, false);
- let Paint::Gradient(g) = crate::panels::current_paints(&app).0 else { panic!("still a gradient") };
- assert_eq!(g.freeform.map(|f| f.points[0].color), Some(orange));
- }
-
- /// One headless frame of the panel menu; returns its painted labels.
- fn menu_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> Vec<(String, Rect)> {
- let raw = egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(236.0, 400.0))), events, ..Default::default() };
- let mut out = ctx.run_ui(raw, |ui| menu(app, ui));
- out.textures_delta.clear();
- crate::tests_removeanchors::shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>())
- }
-
- /// Click the panel menu's item `label`.
- fn click_menu_item(app: &mut VectorcraftApp, ctx: &egui::Context, label: &str) {
- let labels = menu_frame(app, ctx, vec![]);
- let at = labels.iter().find(|(t, _)| t.trim() == label).map(|(_, r)| r.center()).unwrap_or_else(|| panic!("no {label} in the menu"));
- let button =
- |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
- menu_frame(app, ctx, vec![egui::Event::PointerMoved(at), button(true)]);
- menu_frame(app, ctx, vec![button(false)]);
- }
-
- /// In a CMYK document the panel menu's Create New Swatch saves the color the panel shows in
- /// that color's model: an RGB object gives an RGB swatch, and CMYK, gray and spot colors give
- /// swatches of their own colors.
- #[test]
- fn create_new_swatch_keeps_the_shown_colors_model_in_a_cmyk_document() {
- let mut app = app();
- app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
- app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 60, "y": 90, "k": 0}, "spot": true})).unwrap();
- let ctx = egui::Context::default();
- crate::theme::install_fonts(&ctx);
- let newest = |app: &VectorcraftApp| app.session.doc().unwrap().doc.swatches.last().cloned().expect("a swatch");
- let ink = app.session.doc().unwrap().doc.swatch("Ink").and_then(|w| w.paint.color()).unwrap();
- for (fill, model) in [
- (json!({"color": "#336699", "keepModel": true}), vectorcraft_color::cms::Model::Rgb),
- (json!({"color": {"c": 10, "m": 20, "y": 30, "k": 5}}), vectorcraft_color::cms::Model::Cmyk),
- (json!({"color": {"gray": 0.4}}), vectorcraft_color::cms::Model::Gray),
- (json!({"swatch": "Ink"}), ink.model()),
- ] {
- app.run("paint.setFill", fill.clone()).unwrap();
- let shown = crate::panels::current_paints(&app).0.color().expect("a solid fill");
- assert_eq!(shown.model(), model, "{fill}");
- let count = app.session.doc().unwrap().doc.swatches.len();
- click_menu_item(&mut app, &ctx, "Create New Swatch…");
- assert_eq!(app.session.doc().unwrap().doc.swatches.len(), count + 1, "{fill}: one new swatch");
- let w = newest(&app);
- assert_eq!(w.paint.color(), Some(shown), "{fill}: the swatch has the shown color, {}", w.name);
- }
- }
-
- fn paints_hex(app: &VectorcraftApp) -> (String, String) {
- let (f, s) = crate::panels::current_paints(app);
- (f.color().map(|c| c.to_hex()).unwrap_or_default(), s.color().map(|c| c.to_hex()).unwrap_or_default())
- }
-
- #[test]
- fn a_drag_on_the_spectrum_holds_still_near_white() {
- let mut app = app();
- let ctx = egui::Context::default();
- let none = egui::Modifiers::NONE;
- // White needs no warning, #fefefe the web one, a pale violet both: one panel height.
- let heights: Vec<f32> = ["#ffffff", "#fefefe", "#ded3ff"]
- .iter()
- .map(|c| {
- app.run("paint.setFill", json!({"color": c})).unwrap();
- frame(&mut app, &ctx, vec![], none);
- frame(&mut app, &ctx, vec![], none).1
- })
- .collect();
- assert!(heights.windows(2).all(|w| w[0] == w[1]), "{heights:?}");
- // Drag along the spectrum's top edge (pale colours, some out of gamut), stopping at each
- // point: the colour holds while the pointer does.
- let r = frame(&mut app, &ctx, vec![], none).0.expect("the spectrum is drawn");
- let at = |x: f32| egui::pos2(r.left() + x * r.width(), r.top() + 2.0);
- let button = |pressed| egui::Event::PointerButton { pos: at(0.02), button: egui::PointerButton::Primary, pressed, modifiers: none };
- frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at(0.02)), button(true)], none);
- for i in 1..20 {
- frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at(i as f32 * 0.05))], none);
- let fills: Vec<String> = (0..3)
- .map(|_| {
- frame(&mut app, &ctx, vec![], none);
- paints_hex(&app).0
- })
- .collect();
- assert!(fills.windows(2).all(|w| w[0] == w[1]), "at {}: {fills:?}", i as f32 * 0.05);
- }
- frame(&mut app, &ctx, vec![button(false)], none);
- }
-
- #[test]
- fn tandem_keeps_ratios() {
- let t = tandem(Mode::Rgb, &[100.0, 50.0, 25.0], 0, 200.0);
- assert_eq!(t, vec![200.0, 100.0, 50.0]);
- // It stops where a component reaches its maximum.
- let t = tandem(Mode::Rgb, &[200.0, 100.0, 0.0], 1, 200.0);
- assert_eq!(t, vec![255.0, 127.5, 0.0]);
- let t = tandem(Mode::Cmyk, &[10.0, 40.0, 20.0, 5.0], 1, 20.0);
- assert_eq!(t, vec![5.0, 20.0, 10.0, 2.5]);
- // From 0 the others move by the same amount.
- assert_eq!(tandem(Mode::Rgb, &[0.0, 50.0, 250.0], 0, 10.0), vec![10.0, 60.0, 255.0]);
- assert!(Mode::Rgb.tandem() && Mode::Cmyk.tandem() && !Mode::Hsb.tandem() && !Mode::Grayscale.tandem());
- }
-
- #[test]
- fn the_mode_follows_the_colours_model() {
- let cmyk = Color::cmyk(0.1, 0.2, 0.3, 0.4);
- let rgb = Color::rgb(0.2, 0.4, 0.6);
- assert_eq!(display_mode(Some(Mode::Rgb), Some(&cmyk)), Mode::Cmyk);
- assert_eq!(display_mode(Some(Mode::Hsb), Some(&rgb)), Mode::Hsb, "HSB is remembered for RGB colours");
- assert_eq!(display_mode(Some(Mode::Cmyk), Some(&rgb)), Mode::Rgb);
- assert_eq!(display_mode(Some(Mode::Rgb), Some(&Color::gray(0.5))), Mode::Grayscale);
- assert_eq!(display_mode(Some(Mode::Cmyk), None), Mode::Cmyk);
- assert_eq!(convert_to(Mode::Hsb, &rgb), rgb);
- assert!(matches!(convert_to(Mode::Cmyk, &rgb), Color::Cmyk { .. }));
- assert_eq!(convert_to(Mode::WebSafe, &rgb).to_hex(), "#336699");
- assert_eq!(Mode::Rgb.next(), Mode::Hsb);
- assert_eq!(Mode::WebSafe.next(), Mode::Grayscale);
- // In the panel: an RGB pick, then a CMYK object shows its 4 sliders.
- let mut app = app();
- let ctx = egui::Context::default();
- app.ui.color_mode = Some(Mode::Rgb);
- app.run("paint.setFill", json!({"color": {"c": 0.1, "m": 0.2, "y": 0.3, "k": 0.4}})).unwrap();
- frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- let _ = ctx.run_ui(Default::default(), |ui| {
- let mode = shown_mode(&app, target(&app, ui).color().as_ref());
- assert_eq!(mode.labels(), ["C", "M", "Y", "K"]);
- });
- }
-
- /// The slider labels one frame of the panel draws.
- fn slider_labels(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<String> {
- fn texts(s: &egui::Shape, out: &mut Vec<String>) {
- match s {
- egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
- egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
- _ => {}
- }
- }
- let mut full = ctx.run_ui(Default::default(), |ui| show(app, ui));
- full.textures_delta.clear();
- let mut out = vec![];
- full.shapes.iter().for_each(|s| texts(&s.shape, &mut out));
- out.retain(|t| ["K", "R", "G", "B", "H", "S", "C", "M", "Y"].contains(&t.as_str()));
- out
- }
-
- /// #1675: the mode picked last is kept with the UI state, which the app saves with its
- /// preferences, so after a restart the panel shows the defaults for new art in it. A selected
- /// colour still shows in its own model.
- #[test]
- fn the_picked_mode_comes_back_after_a_restart() {
- let mut app = app();
- app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
- app.run("select.none", json!({})).unwrap();
- let ctx = egui::Context::default();
- assert_eq!(slider_labels(&mut app, &ctx), ["R", "G", "B"], "the white default is RGB");
- let _ = ctx.run_ui(Default::default(), |ui| {
- let tgt = target(&app, ui);
- set_mode(&mut app, &tgt, Mode::Cmyk);
- });
- assert_eq!(slider_labels(&mut app, &ctx), ["C", "M", "Y", "K"]);
- // Quit and start again: the saved UI state comes back, the session and the panel are new.
- let saved: crate::UiState = serde_json::from_value(serde_json::to_value(&app.ui).unwrap()).unwrap();
- let mut app = VectorcraftApp::new(Session::new(), Default::default());
- app.ui = saved.sanitized();
- app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
- app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
- assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Rgb { .. })), "the defaults start as RGB white");
- let ctx = egui::Context::default();
- assert_eq!(slider_labels(&mut app, &ctx), ["C", "M", "Y", "K"]);
- app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
- app.run("paint.setFill", json!({"color": "#336699", "keepModel": true})).unwrap();
- assert_eq!(slider_labels(&mut app, &ctx), ["R", "G", "B"], "an RGB object shows RGB");
- // A saved value that isn't a menu mode reads as none, and the rest of the state still loads.
- for v in [json!("lab"), json!("CMYK"), json!(3), serde_json::Value::Null] {
- let ui: crate::UiState = serde_json::from_value(json!({"color_mode": v, "place_link": false})).unwrap();
- assert_eq!((ui.color_mode, ui.place_link), (None, false), "{v}");
- }
- assert_eq!(serde_json::from_value::<crate::UiState>(json!({"color_mode": "websafe"})).unwrap().color_mode, Some(Mode::WebSafe));
- }
-
- #[test]
- fn lab_colours_show_lab_sliders_with_signed_ranges() {
- let lab = Color::lab(50.0, -20.0, 30.0);
- assert_eq!(Mode::of(&lab), Mode::Lab);
- assert_eq!(display_mode(Some(Mode::Rgb), Some(&lab)), Mode::Lab);
- assert!(!Mode::ALL.contains(&Mode::Lab), "not a panel menu mode");
- assert_eq!(components(Mode::Lab, &lab), vec![50.0, -20.0, 30.0]);
- assert_eq!(from_components(Mode::Lab, &[50.0, -20.0, 30.0]), lab);
- assert_eq!(from_components(Mode::Lab, &[150.0, -300.0, 300.0]), Color::lab(100.0, -128.0, 127.0), "clamped");
- assert_eq!((Mode::Lab.unit(1, -128.0), Mode::Lab.unit(2, 127.0), Mode::Lab.unit(0, 50.0)), (0.0, 1.0, 0.5));
- assert_eq!((Mode::Lab.value_at(1, 0.0), Mode::Lab.value_at(0, 1.0)), (-128.0, 100.0));
- assert_eq!((Mode::Rgb.value_at(0, 0.5), Mode::WebSafe.value_at(0, 0.45)), (128.0, 102.0), "other modes as before");
- assert_eq!(track_color(Mode::Lab, &[50.0, -20.0, 30.0], 1, 0.0), Color::lab(50.0, -128.0, 30.0));
- assert_eq!(convert_to(Mode::Lab, &Color::rgb(1.0, 0.0, 0.0)).model(), vectorcraft_color::cms::Model::Lab);
- // In the panel: a Lab fill shows L, a, b.
- let mut app = app();
- let ctx = egui::Context::default();
- app.run("paint.setFill", json!({"color": {"l": 50, "a": -20, "b": 30}})).unwrap();
- frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- let _ = ctx.run_ui(Default::default(), |ui| {
- let mode = shown_mode(&app, target(&app, ui).color().as_ref());
- assert_eq!(mode.labels(), ["L", "a", "b"]);
- });
- }
-
- #[test]
- fn pure_blue_is_out_of_gamut_in_rgb() {
- let mut app = app();
- let ctx = egui::Context::default();
- app.run("paint.setFill", json!({"color": "#0000ff"})).unwrap();
- frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- let (of, fix) = pstate::<Option<(Color, Option<Color>)>>(&ctx, "color-gamut").expect("RGB mode checks the gamut");
- assert_eq!(of.to_hex(), "#0000ff");
- assert!(fix.is_some_and(|f| !f.out_of_gamut()));
- app.run("paint.setFill", json!({"color": "#808080"})).unwrap();
- frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- assert_eq!(pstate::<Option<(Color, Option<Color>)>>(&ctx, "color-gamut").unwrap().1, None);
- }
-
- #[test]
- fn alt_click_on_the_spectrum_paints_the_stroke() {
- let mut app = app();
- let ctx = egui::Context::default();
- app.run("paint.setFill", json!({"color": "#123456"})).unwrap();
- app.run("paint.setStroke", json!({"color": "#000000", "focus": false})).unwrap();
- assert!(app.session.fill_active);
- click_spectrum(&mut app, &ctx, (0.0, 0.5), egui::Modifiers::ALT);
- assert_eq!(paints_hex(&app), ("#123456".into(), "#ff0000".into()), "the stroke changes");
- assert!(app.session.fill_active, "the fill stays in front");
- // A plain click paints the fill.
- click_spectrum(&mut app, &ctx, (0.0, 0.5), egui::Modifiers::NONE);
- assert_eq!(paints_hex(&app).0, "#ff0000");
- }
-
- #[test]
- fn shift_click_on_the_spectrum_cycles_modes() {
- let mut app = app();
- let ctx = egui::Context::default();
- app.run("paint.setFill", json!({"color": "#336699"})).unwrap();
- click_spectrum(&mut app, &ctx, (0.5, 0.5), egui::Modifiers::SHIFT);
- assert_eq!(app.ui.color_mode, Some(Mode::Hsb));
- assert_eq!(paints_hex(&app).0, "#336699", "HSB keeps the RGB colour");
- click_spectrum(&mut app, &ctx, (0.5, 0.5), egui::Modifiers::SHIFT);
- assert_eq!(app.ui.color_mode, Some(Mode::Cmyk));
- assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Cmyk { .. })), "CMYK converts the colour");
- }
-
- #[test]
- fn double_clicking_a_proxy_opens_the_color_picker_for_it() {
- let mut app = app();
- let ctx = egui::Context::default();
- // One frame of the proxy alone; returns the stroke square's rect.
- let run = |app: &mut VectorcraftApp, time: f64, events: Vec<egui::Event>| {
- let input = egui::RawInput { time: Some(time), events, ..Default::default() };
- let mut rect = None;
- let mut out = ctx.run_ui(input, |ui| {
- crate::panels::proxy(app, ui, 40.0);
- rect = ctx.read_response(ui.scope_id().with("stroke-proxy")).map(|r| r.rect);
- });
- out.textures_delta.clear();
- rect
- };
- let pos = run(&mut app, 0.0, vec![]).expect("the stroke square is drawn").right_bottom() - vec2(3.0, 3.0);
- let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
- run(&mut app, 0.1, vec![egui::Event::PointerMoved(pos), button(true)]);
- run(&mut app, 0.15, vec![button(false)]);
- assert!(!app.session.fill_active, "a click brings the stroke to the front");
- assert!(app.ui.dialog.is_none());
- run(&mut app, 0.2, vec![button(true)]);
- run(&mut app, 0.25, vec![button(false)]);
- let d = app.ui.dialog.as_ref().expect("a double-click opens the Color Picker");
- assert_eq!(d.kind, "colorPicker");
- assert!(d.bool("stroke"));
- }
-
- #[test]
- fn a_global_colour_shows_tint_mode_and_the_t_slider_sets_its_tint() {
- let mut app = app();
- let ctx = egui::Context::default();
- app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 1, "y": 0, "k": 0}, "spot": true})).unwrap();
- app.run("paint.setFill", json!({"swatch": "Ink", "tint": 50})).unwrap();
- frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- let _ = ctx.run_ui(Default::default(), |ui| {
- let tgt = target(&app, ui);
- let t = tgt.tint().expect("Tint mode");
- assert_eq!((t.swatch.as_str(), t.spot, t.tint, t.base), ("Ink", true, 0.5, Color::cmyk(0.0, 1.0, 0.0, 0.0)));
- });
- // The chip's name and the T row are drawn; a click on the slider's right part raises the
- // tint and keeps the link.
- let texts = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
- fn walk(s: &egui::Shape, out: &mut Vec<(String, egui::Pos2)>) {
- match s {
- egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.pos + t.galley.rect.center().to_vec2())),
- egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
- _ => {}
- }
- }
- let screen = Rect::from_min_size(egui::Pos2::ZERO, vec2(260.0, 600.0));
- let mut out = ctx.run_ui(egui::RawInput { events, screen_rect: Some(screen), ..Default::default() }, |ui| show(app, ui));
- out.textures_delta.clear();
- let mut v = vec![];
- out.shapes.iter().for_each(|c| walk(&c.shape, &mut v));
- v
- };
- let drawn = texts(&mut app, vec![]);
- let at = |label: &str| drawn.iter().find(|(t, _)| t == label).map(|(_, p)| *p);
- assert!(at("Ink").is_some(), "the swatch's name: {drawn:?}");
- let (t_label, field) = (at("T").expect("the T row"), at("50%").expect("the tint field"));
- let pos = egui::pos2(field.x - 40.0, t_label.y);
- let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
- texts(&mut app, vec![egui::Event::PointerMoved(pos), button(true)]);
- texts(&mut app, vec![button(false)]);
- let Paint::Solid { swatch, tint, .. } = crate::panels::current_paints(&app).0 else { panic!() };
- assert_eq!(swatch.as_deref(), Some("Ink"));
- assert!(tint > 0.6 && tint < 1.0, "{tint}");
- // Picking a mode makes it a process colour.
- let _ = ctx.run_ui(Default::default(), |ui| {
- let tgt = target(&app, ui);
- set_mode(&mut app, &tgt, Mode::Cmyk);
- });
- assert!(matches!(crate::panels::current_paints(&app).0, Paint::Solid { swatch: None, .. }));
- }
-
- /// Screen readers get each slider's number and the text of the field beside it, with the
- /// component's range: R, G and B from 0 to 255, H in degrees, S, B, the inks and T in percent.
- #[test]
- fn screen_readers_get_the_numbers_the_fields_show() {
- use crate::widgets::accessibility_tests::{slider_value, tree};
- let mut app = app();
- let v = |n: f64, max: f64, text: &str| (Some(n), Some(0.0), Some(max), Some(text.to_string()));
- app.run("paint.setFill", json!({"color": "#ff8000"})).unwrap();
- let rgb = tree(|ui| show(&mut app, ui));
- assert_eq!(slider_value(&rgb, "R"), v(255.0, 255.0, "255"));
- assert_eq!(slider_value(&rgb, "G"), v(128.0, 255.0, "128"));
- assert_eq!(slider_value(&rgb, "B"), v(0.0, 255.0, "0"));
- app.run("ui.colorPanel", json!({"mode": "hsb"})).unwrap();
- let hsb = tree(|ui| show(&mut app, ui));
- assert_eq!(slider_value(&hsb, "H"), v(30.0, 360.0, "30°"));
- assert_eq!(slider_value(&hsb, "S"), v(100.0, 100.0, "100%"));
- assert_eq!(slider_value(&hsb, "B"), v(100.0, 100.0, "100%"));
- app.run("paint.setFill", json!({"color": {"c": 10, "m": 20, "y": 30, "k": 40}})).unwrap();
- let cmyk = tree(|ui| show(&mut app, ui));
- assert_eq!(slider_value(&cmyk, "C"), v(10.0, 100.0, "10%"));
- assert_eq!(slider_value(&cmyk, "K"), v(40.0, 100.0, "40%"));
- app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 1, "y": 0, "k": 0}, "spot": true})).unwrap();
- app.run("paint.setFill", json!({"swatch": "Ink", "tint": 35})).unwrap();
- let tint = tree(|ui| show(&mut app, ui));
- assert_eq!(slider_value(&tint, "T"), v(35.0, 100.0, "35%"));
- }
-
- #[test]
- fn hide_options_leaves_the_proxy_and_spectrum() {
- let mut app = app();
- let ctx = egui::Context::default();
- let (spectrum, full) = frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- assert!(spectrum.is_some());
- assert_eq!(app.run("ui.colorPanel", json!({"options": false})).unwrap()["options"], false);
- let (_, hidden) = frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- assert!(hidden <= 44.0 && full > 150.0, "{hidden} / {full}");
- app.run("ui.colorPanel", json!({"options": true})).unwrap();
- assert_eq!(frame(&mut app, &ctx, vec![], egui::Modifiers::NONE).1, full);
- }
-
- /// Hide Options is kept with the UI state, which the app saves with its preferences. A saved
- /// value that isn't true or false reads as Show Options, and the rest of the state still loads.
- #[test]
- fn hide_options_comes_back_after_a_restart() {
- let mut app = app();
- app.run("ui.colorPanel", json!({"options": false})).unwrap();
- let saved: crate::UiState = serde_json::from_value(serde_json::to_value(&app.ui).unwrap()).unwrap();
- assert!(saved.color_hide_options);
- assert_eq!(crate::control::inspect(&app, &egui::Context::default())["ui"]["color_hide_options"], true);
- for v in [json!(7), json!("hide"), json!({}), Value::Null] {
- let ui: crate::UiState = serde_json::from_value(json!({"color_hide_options": v, "color_mode": "future", "place_link": false})).unwrap();
- assert_eq!((ui.color_hide_options, ui.color_mode, ui.place_link), (false, None, false), "{v}");
- }
- }
-
- /// `ui.colorPanel {mode}` picks a mode as the panel menu does: HSB shows an RGB fill as H, S and
- /// B, and CMYK converts it as one undo step.
- #[test]
- fn ui_color_panel_picks_a_mode_as_the_menu_does() {
- let mut app = app();
- let ctx = egui::Context::default();
- app.run("paint.setFill", json!({"color": "#336699"})).unwrap();
- let r = app.run("ui.colorPanel", json!({"mode": "hsb"})).unwrap();
- assert_eq!(r, json!({"mode": "hsb", "options": true, "shown": "hsb"}));
- assert_eq!(slider_labels(&mut app, &ctx), ["H", "S", "B"]);
- assert_eq!(crate::control::inspect(&app, &ctx)["ui"]["color_mode"], "hsb");
- assert_eq!(paints_hex(&app).0, "#336699", "HSB keeps the RGB color");
- assert_eq!(app.run("ui.colorPanel", json!({"mode": "cmyk"})).unwrap()["shown"], "cmyk");
- assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Cmyk { .. })), "CMYK converts the color");
- app.run("edit.undo", json!({})).unwrap();
- assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Rgb { .. })), "undo restores it");
- assert_eq!(paints_hex(&app).0, "#336699");
- // `{}` reads the settings: CMYK stays picked, and the RGB fill shows in its own model.
- assert_eq!(app.run("ui.colorPanel", json!({})).unwrap(), json!({"mode": "cmyk", "options": true, "shown": "rgb"}));
- // A tint of a global swatch shows Tint mode.
- app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 1, "y": 0, "k": 0}, "spot": true})).unwrap();
- app.run("paint.setFill", json!({"swatch": "Ink", "tint": 50})).unwrap();
- assert_eq!(app.run("ui.colorPanel", json!({})).unwrap()["shown"], "tint");
- }
-
- /// A mode the panel menu doesn't list, Lab included, and an options value that isn't true or
- /// false answer an error, and the command then changes nothing.
- #[test]
- fn ui_color_panel_answers_an_error_for_a_mode_off_the_menu() {
- let mut app = app();
- for m in [json!("lab"), json!("oklch"), json!("hsl"), json!("future"), json!("RGB"), json!(3)] {
- let e = app.run("ui.colorPanel", json!({"mode": m})).unwrap_err();
- assert_eq!(e, "`mode` must be grayscale, rgb, hsb, cmyk or websafe", "{m}");
- }
- assert_eq!(app.run("ui.colorPanel", json!({"mode": "cmyk", "options": "no"})).unwrap_err(), "`options` must be true or false");
- assert_eq!((app.ui.color_mode, app.ui.color_hide_options), (None, false));
- }
-
- /// `ui.colorPanel` answers every junk parameter, with and without a document, without a panic.
- #[test]
- fn ui_color_panel_answers_junk_params_without_a_panic() {
- let doc = crate::menus::UI_COMMANDS.iter().find(|c| c.0 == "ui.colorPanel").expect("registered").3;
- let mut app = app();
- app.run("paint.setFill", json!({"color": "#336699"})).unwrap();
- for p in vectorcraft_testkit::strategies::junk_params(doc, "/nonexistent").into_iter().chain(vectorcraft_testkit::strategies::junk_values()) {
- let _ = app.run("ui.colorPanel", p);
- }
- let mut app = VectorcraftApp::new(Session::new(), Default::default());
- assert_eq!(app.run("ui.colorPanel", json!({"mode": "cmyk"})).unwrap()["mode"], "cmyk");
- }
-
- #[test]
- fn a_mixed_selection_has_no_colour_to_edit() {
- let mut app = app();
- let ctx = egui::Context::default();
- let b = app.run("shape.rectangle", json!({"x": 80, "y": 10, "width": 50, "height": 50})).unwrap()["id"].clone();
- app.run("select.all", json!({})).unwrap();
- app.run("paint.setFill", json!({"color": "#ff0000"})).unwrap();
- app.run("paint.setFill", json!({"color": "#00ff00", "ids": [b]})).unwrap();
- frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
- assert_eq!(crate::panels::mixed_paints(&app, &ctx), (true, false));
- let _ = ctx.run_ui(Default::default(), |ui| assert_eq!(target(&app, ui).color(), None));
- app.run("paint.setFill", json!({"color": "#0000ff"})).unwrap();
- assert_eq!(crate::panels::mixed_paints(&app, &ctx), (false, false), "a new revision recomputes it");
- }
-
- #[test]
- fn rgb_roundtrip() {
- let c = Color::rgb8(230, 120, 40);
- let v = components(Mode::Rgb, &c);
- assert_eq!(v.iter().map(|x| x.round() as i32).collect::<Vec<_>>(), vec![230, 120, 40]);
- assert_eq!(from_components(Mode::Rgb, &v).to_hex(), c.to_hex());
- }
-
- #[test]
- fn hsb_roundtrip_and_ranges() {
- let c = Color::rgb8(230, 120, 40);
- let v = components(Mode::Hsb, &c);
- assert!(v[0] > 0.0 && v[0] < 360.0 && v[1] <= 100.0 && v[2] <= 100.0);
- assert_eq!(from_components(Mode::Hsb, &v).to_hex(), c.to_hex());
- assert_eq!(Mode::Hsb.max(0), 360.0);
- assert_eq!(Mode::Hsb.suffix(0), "°");
- }
-
- #[test]
- fn cmyk_and_gray_keep_model() {
- let c = from_components(Mode::Cmyk, &[10.0, 20.0, 30.0, 40.0]);
- assert!(matches!(c, Color::Cmyk { .. }));
- let v = components(Mode::Cmyk, &c);
- assert!((v[3] - 40.0).abs() < 1e-3);
- let g = from_components(Mode::Grayscale, &[25.0]);
- assert_eq!(g, Color::gray(0.25));
- assert!((components(Mode::Grayscale, &g)[0] - 25.0).abs() < 1e-4);
- // Grayscale view of an RGB colour uses luminance.
- assert!((components(Mode::Grayscale, &Color::WHITE)[0]).abs() < 1e-4);
- }
-
- #[test]
- fn web_safe_snaps() {
- let c = Color::rgb8(230, 120, 40);
- let w = web_safe(&c);
- assert_eq!(w.to_hex(), "#ff6633");
- assert!(is_web_safe(&w));
- assert!(!is_web_safe(&c));
- assert_eq!(from_components(Mode::WebSafe, &[230.0, 120.0, 40.0]).to_hex(), "#ff6633");
- }
-
- #[test]
- fn slider_tracks_vary_one_component() {
- let comps = [230.0, 120.0, 40.0];
- let a = track_color(Mode::Rgb, &comps, 0, 0.0).to_rgba8(1.0);
- let b = track_color(Mode::Rgb, &comps, 0, 1.0).to_rgba8(1.0);
- assert_eq!((a[0], a[1], a[2]), (0, 120, 40));
- assert_eq!((b[0], b[1], b[2]), (255, 120, 40));
- let h = track_color(Mode::Hsb, &[0.0, 100.0, 100.0], 0, 1.0 / 3.0).to_hex();
- assert_eq!(h, "#00ff00");
- }
-
- #[test]
- fn spectrum_and_hex() {
- assert_eq!(spectrum_at(Mode::Rgb, 0.0, 0.0).to_hex(), "#ffffff");
- assert_eq!(spectrum_at(Mode::Rgb, 0.0, 0.5).to_hex(), "#ff0000");
- assert_eq!(spectrum_at(Mode::Rgb, 0.3, 1.0).to_hex(), "#000000");
- assert_eq!(spectrum_at(Mode::Grayscale, 1.0, 0.3), Color::gray(1.0));
- assert_eq!(parse_hex("E67828").unwrap().to_hex(), "#e67828");
- assert_eq!(parse_hex("#fff").unwrap().to_hex(), "#ffffff");
- assert!(parse_hex("zz").is_none());
- assert!(parse_hex("12345").is_none());
- }
-}
+mod tests;
diff --git a/crates/ui-egui/src/panels/color/tests.rs b/crates/ui-egui/src/panels/color/tests.rs
new file mode 100644
index 000000000..8d89d498b
--- /dev/null
+++ b/crates/ui-egui/src/panels/color/tests.rs
@@ -0,0 +1,594 @@
+use super::*;
+use vectorcraft_engine::Session;
+
+fn app() -> VectorcraftApp {
+ let mut app = VectorcraftApp::new(Session::new(), Default::default());
+ app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+ app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
+ app
+}
+
+/// Run the panel for one frame with `events` and `modifiers`; returns the spectrum's rect (when
+/// the options are shown) and the panel's height.
+fn frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>, modifiers: egui::Modifiers) -> (Option<Rect>, f32) {
+ frame_with(app, ctx, events, modifiers, "color-spectrum")
+}
+
+/// [`frame`] returning the rect of the panel's widget `id` instead of the spectrum's.
+fn frame_with(
+ app: &mut VectorcraftApp,
+ ctx: &egui::Context,
+ events: Vec<egui::Event>,
+ modifiers: egui::Modifiers,
+ id: impl std::hash::Hash + std::fmt::Debug,
+) -> (Option<Rect>, f32) {
+ let mut out = (None, 0.0);
+ let events = std::iter::once(egui::Event::ModifiersChanged(modifiers)).chain(events).collect();
+ let input = egui::RawInput { events, ..Default::default() };
+ let mut full = ctx.run_ui(input, |ui| {
+ show(app, ui);
+ out = (ctx.read_response(ui.scope_id().with(&id)).map(|r| r.rect), ui.min_rect().height());
+ });
+ full.textures_delta.clear();
+ out
+}
+
+/// Click the spectrum at (x, y) (0..1 each) with `modifiers` held.
+fn click_spectrum(app: &mut VectorcraftApp, ctx: &egui::Context, (x, y): (f32, f32), modifiers: egui::Modifiers) {
+ let r = frame(app, ctx, vec![], modifiers).0.expect("the spectrum is drawn");
+ let pos = egui::pos2(r.left() + x * r.width(), r.top() + y * r.height());
+ let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers };
+ frame(app, ctx, vec![egui::Event::PointerMoved(pos), button(true)], modifiers);
+ frame(app, ctx, vec![button(false)], modifiers);
+ frame(app, ctx, vec![], egui::Modifiers::NONE);
+}
+
+#[test]
+fn a_recent_colour_recolours_the_selected_gradient_stop() {
+ // #835: it replaced the whole gradient with the colour.
+ let mut app = app();
+ app.run("paint.setFill", json!({"color": "#ff0000"})).unwrap();
+ let stops = json!([{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#000000"}]);
+ app.run("paint.setFill", json!({"gradient": {"stops": stops, "start": [10, 35], "end": [60, 35]}})).unwrap();
+ app.select_tool("gradient");
+ app.run("gradient.selectStop", json!({"index": 1})).unwrap();
+ let red = app.session.recent_colors.iter().position(|c| c.to_hex() == "#ff0000").expect("red is a recent colour");
+ let ctx = egui::Context::default();
+ let none = egui::Modifiers::NONE;
+ let chip = frame_with(&mut app, &ctx, vec![], none, ("recent", red)).0.expect("the chip is drawn").center();
+ let button = |pressed| egui::Event::PointerButton { pos: chip, button: egui::PointerButton::Primary, pressed, modifiers: none };
+ frame(&mut app, &ctx, vec![egui::Event::PointerMoved(chip), button(true)], none);
+ frame(&mut app, &ctx, vec![button(false)], none);
+ let Paint::Gradient(g) = crate::panels::current_paints(&app).0 else { panic!("still a gradient") };
+ let hex: Vec<String> = g.gradient.stops.iter().map(|s| s.color.to_hex()).collect();
+ assert_eq!(hex, ["#ffffff", "#ff0000"]);
+}
+
+/// In a CMYK document the sliders keep the model picked in the panel for a gradient stop and a
+/// freeform point, as they do for a solid fill.
+#[test]
+fn a_gradient_stop_and_a_freeform_point_keep_the_panels_model_in_a_cmyk_document() {
+ let mut app = app();
+ app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
+ let stops = json!([{"offset": 0, "color": {"c": 0, "m": 0, "y": 0, "k": 0}}, {"offset": 1, "color": {"c": 0, "m": 100, "y": 100, "k": 0}}]);
+ app.run("paint.setFill", json!({"gradient": {"stops": stops}})).unwrap();
+ app.select_tool("gradient");
+ app.run("gradient.selectStop", json!({"index": 1})).unwrap();
+ let orange = Color::rgb8(255, 128, 0);
+ let tgt = target_with(&app, false);
+ apply(&mut app, &tgt, orange, Live::Released, false);
+ let Paint::Gradient(g) = crate::panels::current_paints(&app).0 else { panic!("still a gradient") };
+ assert_eq!(g.gradient.stops[1].color, orange);
+ app.run("paint.editGradient", json!({"kind": "freeform"})).unwrap();
+ let tgt = target_with(&app, false);
+ assert!(matches!(tgt, Target::Point { index: 0, .. }), "a freeform point is the target");
+ apply(&mut app, &tgt, orange, Live::Released, false);
+ let Paint::Gradient(g) = crate::panels::current_paints(&app).0 else { panic!("still a gradient") };
+ assert_eq!(g.freeform.map(|f| f.points[0].color), Some(orange));
+}
+
+/// One headless frame of the panel menu; returns its painted labels.
+fn menu_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> Vec<(String, Rect)> {
+ let raw = egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(236.0, 400.0))), events, ..Default::default() };
+ let mut out = ctx.run_ui(raw, |ui| menu(app, ui));
+ out.textures_delta.clear();
+ crate::tests_removeanchors::shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>())
+}
+
+/// Click the panel menu's item `label`.
+fn click_menu_item(app: &mut VectorcraftApp, ctx: &egui::Context, label: &str) {
+ let labels = menu_frame(app, ctx, vec![]);
+ let at = labels.iter().find(|(t, _)| t.trim() == label).map(|(_, r)| r.center()).unwrap_or_else(|| panic!("no {label} in the menu"));
+ let button =
+ |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
+ menu_frame(app, ctx, vec![egui::Event::PointerMoved(at), button(true)]);
+ menu_frame(app, ctx, vec![button(false)]);
+}
+
+/// In a CMYK document the panel menu's Create New Swatch saves the color the panel shows in
+/// that color's model: an RGB object gives an RGB swatch, and CMYK, gray and spot colors give
+/// swatches of their own colors.
+#[test]
+fn create_new_swatch_keeps_the_shown_colors_model_in_a_cmyk_document() {
+ let mut app = app();
+ app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
+ app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 60, "y": 90, "k": 0}, "spot": true})).unwrap();
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx);
+ let newest = |app: &VectorcraftApp| app.session.doc().unwrap().doc.swatches.last().cloned().expect("a swatch");
+ let ink = app.session.doc().unwrap().doc.swatch("Ink").and_then(|w| w.paint.color()).unwrap();
+ for (fill, model) in [
+ (json!({"color": "#336699", "keepModel": true}), vectorcraft_color::cms::Model::Rgb),
+ (json!({"color": {"c": 10, "m": 20, "y": 30, "k": 5}}), vectorcraft_color::cms::Model::Cmyk),
+ (json!({"color": {"gray": 0.4}}), vectorcraft_color::cms::Model::Gray),
+ (json!({"swatch": "Ink"}), ink.model()),
+ ] {
+ app.run("paint.setFill", fill.clone()).unwrap();
+ let shown = crate::panels::current_paints(&app).0.color().expect("a solid fill");
+ assert_eq!(shown.model(), model, "{fill}");
+ let count = app.session.doc().unwrap().doc.swatches.len();
+ click_menu_item(&mut app, &ctx, "Create New Swatch…");
+ assert_eq!(app.session.doc().unwrap().doc.swatches.len(), count + 1, "{fill}: one new swatch");
+ let w = newest(&app);
+ assert_eq!(w.paint.color(), Some(shown), "{fill}: the swatch has the shown color, {}", w.name);
+ }
+}
+
+fn paints_hex(app: &VectorcraftApp) -> (String, String) {
+ let (f, s) = crate::panels::current_paints(app);
+ (f.color().map(|c| c.to_hex()).unwrap_or_default(), s.color().map(|c| c.to_hex()).unwrap_or_default())
+}
+
+#[test]
+fn a_drag_on_the_spectrum_holds_still_near_white() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ let none = egui::Modifiers::NONE;
+ // White needs no warning, #fefefe the web one, a pale violet both: one panel height.
+ let heights: Vec<f32> = ["#ffffff", "#fefefe", "#ded3ff"]
+ .iter()
+ .map(|c| {
+ app.run("paint.setFill", json!({"color": c})).unwrap();
+ frame(&mut app, &ctx, vec![], none);
+ frame(&mut app, &ctx, vec![], none).1
+ })
+ .collect();
+ assert!(heights.windows(2).all(|w| w[0] == w[1]), "{heights:?}");
+ // Drag along the spectrum's top edge (pale colours, some out of gamut), stopping at each
+ // point: the colour holds while the pointer does.
+ let r = frame(&mut app, &ctx, vec![], none).0.expect("the spectrum is drawn");
+ let at = |x: f32| egui::pos2(r.left() + x * r.width(), r.top() + 2.0);
+ let button = |pressed| egui::Event::PointerButton { pos: at(0.02), button: egui::PointerButton::Primary, pressed, modifiers: none };
+ frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at(0.02)), button(true)], none);
+ for i in 1..20 {
+ frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at(i as f32 * 0.05))], none);
+ let fills: Vec<String> = (0..3)
+ .map(|_| {
+ frame(&mut app, &ctx, vec![], none);
+ paints_hex(&app).0
+ })
+ .collect();
+ assert!(fills.windows(2).all(|w| w[0] == w[1]), "at {}: {fills:?}", i as f32 * 0.05);
+ }
+ frame(&mut app, &ctx, vec![button(false)], none);
+}
+
+#[test]
+fn tandem_keeps_ratios() {
+ let t = tandem(Mode::Rgb, &[100.0, 50.0, 25.0], 0, 200.0);
+ assert_eq!(t, vec![200.0, 100.0, 50.0]);
+ // It stops where a component reaches its maximum.
+ let t = tandem(Mode::Rgb, &[200.0, 100.0, 0.0], 1, 200.0);
+ assert_eq!(t, vec![255.0, 127.5, 0.0]);
+ let t = tandem(Mode::Cmyk, &[10.0, 40.0, 20.0, 5.0], 1, 20.0);
+ assert_eq!(t, vec![5.0, 20.0, 10.0, 2.5]);
+ // From 0 the others move by the same amount.
+ assert_eq!(tandem(Mode::Rgb, &[0.0, 50.0, 250.0], 0, 10.0), vec![10.0, 60.0, 255.0]);
+ assert!(Mode::Rgb.tandem() && Mode::Cmyk.tandem() && !Mode::Hsb.tandem() && !Mode::Grayscale.tandem());
+}
+
+#[test]
+fn the_mode_follows_the_colours_model() {
+ let cmyk = Color::cmyk(0.1, 0.2, 0.3, 0.4);
+ let rgb = Color::rgb(0.2, 0.4, 0.6);
+ assert_eq!(display_mode(Some(Mode::Rgb), Some(&cmyk)), Mode::Cmyk);
+ assert_eq!(display_mode(Some(Mode::Hsb), Some(&rgb)), Mode::Hsb, "HSB is remembered for RGB colours");
+ assert_eq!(display_mode(Some(Mode::Cmyk), Some(&rgb)), Mode::Rgb);
+ assert_eq!(display_mode(Some(Mode::Rgb), Some(&Color::gray(0.5))), Mode::Grayscale);
+ assert_eq!(display_mode(Some(Mode::Cmyk), None), Mode::Cmyk);
+ assert_eq!(convert_to(Mode::Hsb, &rgb), rgb);
+ assert!(matches!(convert_to(Mode::Cmyk, &rgb), Color::Cmyk { .. }));
+ assert_eq!(convert_to(Mode::WebSafe, &rgb).to_hex(), "#336699");
+ assert_eq!(Mode::Rgb.next(), Mode::Hsb);
+ assert_eq!(Mode::WebSafe.next(), Mode::Grayscale);
+ // In the panel: an RGB pick, then a CMYK object shows its 4 sliders.
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.ui.color_mode = Some(Mode::Rgb);
+ app.run("paint.setFill", json!({"color": {"c": 0.1, "m": 0.2, "y": 0.3, "k": 0.4}})).unwrap();
+ frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ let _ = ctx.run_ui(Default::default(), |ui| {
+ let mode = shown_mode(&app, target(&app, ui).color().as_ref());
+ assert_eq!(mode.labels(), ["C", "M", "Y", "K"]);
+ });
+}
+
+/// The slider labels one frame of the panel draws.
+fn slider_labels(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<String> {
+ fn texts(s: &egui::Shape, out: &mut Vec<String>) {
+ match s {
+ egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+ egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+ _ => {}
+ }
+ }
+ let mut full = ctx.run_ui(Default::default(), |ui| show(app, ui));
+ full.textures_delta.clear();
+ let mut out = vec![];
+ full.shapes.iter().for_each(|s| texts(&s.shape, &mut out));
+ out.retain(|t| ["K", "R", "G", "B", "H", "S", "C", "M", "Y"].contains(&t.as_str()));
+ out
+}
+
+/// #1675: the mode picked last is kept with the UI state, which the app saves with its
+/// preferences, so after a restart the panel shows the defaults for new art in it. A selected
+/// colour still shows in its own model.
+#[test]
+fn the_picked_mode_comes_back_after_a_restart() {
+ let mut app = app();
+ app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
+ app.run("select.none", json!({})).unwrap();
+ let ctx = egui::Context::default();
+ assert_eq!(slider_labels(&mut app, &ctx), ["R", "G", "B"], "the white default is RGB");
+ let _ = ctx.run_ui(Default::default(), |ui| {
+ let tgt = target(&app, ui);
+ set_mode(&mut app, &tgt, Mode::Cmyk);
+ });
+ assert_eq!(slider_labels(&mut app, &ctx), ["C", "M", "Y", "K"]);
+ // Quit and start again: the saved UI state comes back, the session and the panel are new.
+ let saved: crate::UiState = serde_json::from_value(serde_json::to_value(&app.ui).unwrap()).unwrap();
+ let mut app = VectorcraftApp::new(Session::new(), Default::default());
+ app.ui = saved.sanitized();
+ app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+ app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
+ assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Rgb { .. })), "the defaults start as RGB white");
+ let ctx = egui::Context::default();
+ assert_eq!(slider_labels(&mut app, &ctx), ["C", "M", "Y", "K"]);
+ app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
+ app.run("paint.setFill", json!({"color": "#336699", "keepModel": true})).unwrap();
+ assert_eq!(slider_labels(&mut app, &ctx), ["R", "G", "B"], "an RGB object shows RGB");
+ // A saved value that isn't a menu mode reads as none, and the rest of the state still loads.
+ for v in [json!("lab"), json!("CMYK"), json!(3), serde_json::Value::Null] {
+ let ui: crate::UiState = serde_json::from_value(json!({"color_mode": v, "place_link": false})).unwrap();
+ assert_eq!((ui.color_mode, ui.place_link), (None, false), "{v}");
+ }
+ assert_eq!(serde_json::from_value::<crate::UiState>(json!({"color_mode": "websafe"})).unwrap().color_mode, Some(Mode::WebSafe));
+}
+
+#[test]
+fn lab_colours_show_lab_sliders_with_signed_ranges() {
+ let lab = Color::lab(50.0, -20.0, 30.0);
+ assert_eq!(Mode::of(&lab), Mode::Lab);
+ assert_eq!(display_mode(Some(Mode::Rgb), Some(&lab)), Mode::Lab);
+ assert!(!Mode::ALL.contains(&Mode::Lab), "not a panel menu mode");
+ assert_eq!(components(Mode::Lab, &lab), vec![50.0, -20.0, 30.0]);
+ assert_eq!(from_components(Mode::Lab, &[50.0, -20.0, 30.0]), lab);
+ assert_eq!(from_components(Mode::Lab, &[150.0, -300.0, 300.0]), Color::lab(100.0, -128.0, 127.0), "clamped");
+ assert_eq!((Mode::Lab.unit(1, -128.0), Mode::Lab.unit(2, 127.0), Mode::Lab.unit(0, 50.0)), (0.0, 1.0, 0.5));
+ assert_eq!((Mode::Lab.value_at(1, 0.0), Mode::Lab.value_at(0, 1.0)), (-128.0, 100.0));
+ assert_eq!((Mode::Rgb.value_at(0, 0.5), Mode::WebSafe.value_at(0, 0.45)), (128.0, 102.0), "other modes as before");
+ assert_eq!(track_color(Mode::Lab, &[50.0, -20.0, 30.0], 1, 0.0), Color::lab(50.0, -128.0, 30.0));
+ assert_eq!(convert_to(Mode::Lab, &Color::rgb(1.0, 0.0, 0.0)).model(), vectorcraft_color::cms::Model::Lab);
+ // In the panel: a Lab fill shows L, a, b.
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.run("paint.setFill", json!({"color": {"l": 50, "a": -20, "b": 30}})).unwrap();
+ frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ let _ = ctx.run_ui(Default::default(), |ui| {
+ let mode = shown_mode(&app, target(&app, ui).color().as_ref());
+ assert_eq!(mode.labels(), ["L", "a", "b"]);
+ });
+}
+
+#[test]
+fn pure_blue_is_out_of_gamut_in_rgb() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.run("paint.setFill", json!({"color": "#0000ff"})).unwrap();
+ frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ let (of, fix) = pstate::<Option<(Color, Option<Color>)>>(&ctx, "color-gamut").expect("RGB mode checks the gamut");
+ assert_eq!(of.to_hex(), "#0000ff");
+ assert!(fix.is_some_and(|f| !f.out_of_gamut()));
+ app.run("paint.setFill", json!({"color": "#808080"})).unwrap();
+ frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ assert_eq!(pstate::<Option<(Color, Option<Color>)>>(&ctx, "color-gamut").unwrap().1, None);
+}
+
+#[test]
+fn alt_click_on_the_spectrum_paints_the_stroke() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.run("paint.setFill", json!({"color": "#123456"})).unwrap();
+ app.run("paint.setStroke", json!({"color": "#000000", "focus": false})).unwrap();
+ assert!(app.session.fill_active);
+ click_spectrum(&mut app, &ctx, (0.0, 0.5), egui::Modifiers::ALT);
+ assert_eq!(paints_hex(&app), ("#123456".into(), "#ff0000".into()), "the stroke changes");
+ assert!(app.session.fill_active, "the fill stays in front");
+ // A plain click paints the fill.
+ click_spectrum(&mut app, &ctx, (0.0, 0.5), egui::Modifiers::NONE);
+ assert_eq!(paints_hex(&app).0, "#ff0000");
+}
+
+#[test]
+fn shift_click_on_the_spectrum_cycles_modes() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.run("paint.setFill", json!({"color": "#336699"})).unwrap();
+ click_spectrum(&mut app, &ctx, (0.5, 0.5), egui::Modifiers::SHIFT);
+ assert_eq!(app.ui.color_mode, Some(Mode::Hsb));
+ assert_eq!(paints_hex(&app).0, "#336699", "HSB keeps the RGB colour");
+ click_spectrum(&mut app, &ctx, (0.5, 0.5), egui::Modifiers::SHIFT);
+ assert_eq!(app.ui.color_mode, Some(Mode::Cmyk));
+ assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Cmyk { .. })), "CMYK converts the colour");
+}
+
+#[test]
+fn double_clicking_a_proxy_opens_the_color_picker_for_it() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ // One frame of the proxy alone; returns the stroke square's rect.
+ let run = |app: &mut VectorcraftApp, time: f64, events: Vec<egui::Event>| {
+ let input = egui::RawInput { time: Some(time), events, ..Default::default() };
+ let mut rect = None;
+ let mut out = ctx.run_ui(input, |ui| {
+ crate::panels::proxy(app, ui, 40.0);
+ rect = ctx.read_response(ui.scope_id().with("stroke-proxy")).map(|r| r.rect);
+ });
+ out.textures_delta.clear();
+ rect
+ };
+ let pos = run(&mut app, 0.0, vec![]).expect("the stroke square is drawn").right_bottom() - vec2(3.0, 3.0);
+ let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
+ run(&mut app, 0.1, vec![egui::Event::PointerMoved(pos), button(true)]);
+ run(&mut app, 0.15, vec![button(false)]);
+ assert!(!app.session.fill_active, "a click brings the stroke to the front");
+ assert!(app.ui.dialog.is_none());
+ run(&mut app, 0.2, vec![button(true)]);
+ run(&mut app, 0.25, vec![button(false)]);
+ let d = app.ui.dialog.as_ref().expect("a double-click opens the Color Picker");
+ assert_eq!(d.kind, "colorPicker");
+ assert!(d.bool("stroke"));
+}
+
+#[test]
+fn a_global_colour_shows_tint_mode_and_the_t_slider_sets_its_tint() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 1, "y": 0, "k": 0}, "spot": true})).unwrap();
+ app.run("paint.setFill", json!({"swatch": "Ink", "tint": 50})).unwrap();
+ frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ let _ = ctx.run_ui(Default::default(), |ui| {
+ let tgt = target(&app, ui);
+ let t = tgt.tint().expect("Tint mode");
+ assert_eq!((t.swatch.as_str(), t.spot, t.tint, t.base), ("Ink", true, 0.5, Color::cmyk(0.0, 1.0, 0.0, 0.0)));
+ });
+ // The chip's name and the T row are drawn; a click on the slider's right part raises the
+ // tint and keeps the link.
+ let texts = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
+ fn walk(s: &egui::Shape, out: &mut Vec<(String, egui::Pos2)>) {
+ match s {
+ egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.pos + t.galley.rect.center().to_vec2())),
+ egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
+ _ => {}
+ }
+ }
+ let screen = Rect::from_min_size(egui::Pos2::ZERO, vec2(260.0, 600.0));
+ let mut out = ctx.run_ui(egui::RawInput { events, screen_rect: Some(screen), ..Default::default() }, |ui| show(app, ui));
+ out.textures_delta.clear();
+ let mut v = vec![];
+ out.shapes.iter().for_each(|c| walk(&c.shape, &mut v));
+ v
+ };
+ let drawn = texts(&mut app, vec![]);
+ let at = |label: &str| drawn.iter().find(|(t, _)| t == label).map(|(_, p)| *p);
+ assert!(at("Ink").is_some(), "the swatch's name: {drawn:?}");
+ let (t_label, field) = (at("T").expect("the T row"), at("50%").expect("the tint field"));
+ let pos = egui::pos2(field.x - 40.0, t_label.y);
+ let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
+ texts(&mut app, vec![egui::Event::PointerMoved(pos), button(true)]);
+ texts(&mut app, vec![button(false)]);
+ let Paint::Solid { swatch, tint, .. } = crate::panels::current_paints(&app).0 else { panic!() };
+ assert_eq!(swatch.as_deref(), Some("Ink"));
+ assert!(tint > 0.6 && tint < 1.0, "{tint}");
+ // Picking a mode makes it a process colour.
+ let _ = ctx.run_ui(Default::default(), |ui| {
+ let tgt = target(&app, ui);
+ set_mode(&mut app, &tgt, Mode::Cmyk);
+ });
+ assert!(matches!(crate::panels::current_paints(&app).0, Paint::Solid { swatch: None, .. }));
+}
+
+/// Screen readers get each slider's number and the text of the field beside it, with the
+/// component's range: R, G and B from 0 to 255, H in degrees, S, B, the inks and T in percent.
+#[test]
+fn screen_readers_get_the_numbers_the_fields_show() {
+ use crate::widgets::accessibility_tests::{slider_value, tree};
+ let mut app = app();
+ let v = |n: f64, max: f64, text: &str| (Some(n), Some(0.0), Some(max), Some(text.to_string()));
+ app.run("paint.setFill", json!({"color": "#ff8000"})).unwrap();
+ let rgb = tree(|ui| show(&mut app, ui));
+ assert_eq!(slider_value(&rgb, "R"), v(255.0, 255.0, "255"));
+ assert_eq!(slider_value(&rgb, "G"), v(128.0, 255.0, "128"));
+ assert_eq!(slider_value(&rgb, "B"), v(0.0, 255.0, "0"));
+ app.run("ui.colorPanel", json!({"mode": "hsb"})).unwrap();
+ let hsb = tree(|ui| show(&mut app, ui));
+ assert_eq!(slider_value(&hsb, "H"), v(30.0, 360.0, "30°"));
+ assert_eq!(slider_value(&hsb, "S"), v(100.0, 100.0, "100%"));
+ assert_eq!(slider_value(&hsb, "B"), v(100.0, 100.0, "100%"));
+ app.run("paint.setFill", json!({"color": {"c": 10, "m": 20, "y": 30, "k": 40}})).unwrap();
+ let cmyk = tree(|ui| show(&mut app, ui));
+ assert_eq!(slider_value(&cmyk, "C"), v(10.0, 100.0, "10%"));
+ assert_eq!(slider_value(&cmyk, "K"), v(40.0, 100.0, "40%"));
+ app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 1, "y": 0, "k": 0}, "spot": true})).unwrap();
+ app.run("paint.setFill", json!({"swatch": "Ink", "tint": 35})).unwrap();
+ let tint = tree(|ui| show(&mut app, ui));
+ assert_eq!(slider_value(&tint, "T"), v(35.0, 100.0, "35%"));
+}
+
+#[test]
+fn hide_options_leaves_the_proxy_and_spectrum() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ let (spectrum, full) = frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ assert!(spectrum.is_some());
+ assert_eq!(app.run("ui.colorPanel", json!({"options": false})).unwrap()["options"], false);
+ let (_, hidden) = frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ assert!(hidden <= 44.0 && full > 150.0, "{hidden} / {full}");
+ app.run("ui.colorPanel", json!({"options": true})).unwrap();
+ assert_eq!(frame(&mut app, &ctx, vec![], egui::Modifiers::NONE).1, full);
+}
+
+/// Hide Options is kept with the UI state, which the app saves with its preferences. A saved
+/// value that isn't true or false reads as Show Options, and the rest of the state still loads.
+#[test]
+fn hide_options_comes_back_after_a_restart() {
+ let mut app = app();
+ app.run("ui.colorPanel", json!({"options": false})).unwrap();
+ let saved: crate::UiState = serde_json::from_value(serde_json::to_value(&app.ui).unwrap()).unwrap();
+ assert!(saved.color_hide_options);
+ assert_eq!(crate::control::inspect(&app, &egui::Context::default())["ui"]["color_hide_options"], true);
+ for v in [json!(7), json!("hide"), json!({}), Value::Null] {
+ let ui: crate::UiState = serde_json::from_value(json!({"color_hide_options": v, "color_mode": "future", "place_link": false})).unwrap();
+ assert_eq!((ui.color_hide_options, ui.color_mode, ui.place_link), (false, None, false), "{v}");
+ }
+}
+
+/// `ui.colorPanel {mode}` picks a mode as the panel menu does: HSB shows an RGB fill as H, S and
+/// B, and CMYK converts it as one undo step.
+#[test]
+fn ui_color_panel_picks_a_mode_as_the_menu_does() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ app.run("paint.setFill", json!({"color": "#336699"})).unwrap();
+ let r = app.run("ui.colorPanel", json!({"mode": "hsb"})).unwrap();
+ assert_eq!(r, json!({"mode": "hsb", "options": true, "shown": "hsb"}));
+ assert_eq!(slider_labels(&mut app, &ctx), ["H", "S", "B"]);
+ assert_eq!(crate::control::inspect(&app, &ctx)["ui"]["color_mode"], "hsb");
+ assert_eq!(paints_hex(&app).0, "#336699", "HSB keeps the RGB color");
+ assert_eq!(app.run("ui.colorPanel", json!({"mode": "cmyk"})).unwrap()["shown"], "cmyk");
+ assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Cmyk { .. })), "CMYK converts the color");
+ app.run("edit.undo", json!({})).unwrap();
+ assert!(matches!(crate::panels::current_paints(&app).0.color(), Some(Color::Rgb { .. })), "undo restores it");
+ assert_eq!(paints_hex(&app).0, "#336699");
+ // `{}` reads the settings: CMYK stays picked, and the RGB fill shows in its own model.
+ assert_eq!(app.run("ui.colorPanel", json!({})).unwrap(), json!({"mode": "cmyk", "options": true, "shown": "rgb"}));
+ // A tint of a global swatch shows Tint mode.
+ app.run("swatch.new", json!({"name": "Ink", "color": {"c": 0, "m": 1, "y": 0, "k": 0}, "spot": true})).unwrap();
+ app.run("paint.setFill", json!({"swatch": "Ink", "tint": 50})).unwrap();
+ assert_eq!(app.run("ui.colorPanel", json!({})).unwrap()["shown"], "tint");
+}
+
+/// A mode the panel menu doesn't list, Lab included, and an options value that isn't true or
+/// false answer an error, and the command then changes nothing.
+#[test]
+fn ui_color_panel_answers_an_error_for_a_mode_off_the_menu() {
+ let mut app = app();
+ for m in [json!("lab"), json!("oklch"), json!("hsl"), json!("future"), json!("RGB"), json!(3)] {
+ let e = app.run("ui.colorPanel", json!({"mode": m})).unwrap_err();
+ assert_eq!(e, "`mode` must be grayscale, rgb, hsb, cmyk or websafe", "{m}");
+ }
+ assert_eq!(app.run("ui.colorPanel", json!({"mode": "cmyk", "options": "no"})).unwrap_err(), "`options` must be true or false");
+ assert_eq!((app.ui.color_mode, app.ui.color_hide_options), (None, false));
+}
+
+/// `ui.colorPanel` answers every junk parameter, with and without a document, without a panic.
+#[test]
+fn ui_color_panel_answers_junk_params_without_a_panic() {
+ let doc = crate::menus::UI_COMMANDS.iter().find(|c| c.0 == "ui.colorPanel").expect("registered").3;
+ let mut app = app();
+ app.run("paint.setFill", json!({"color": "#336699"})).unwrap();
+ for p in vectorcraft_testkit::strategies::junk_params(doc, "/nonexistent").into_iter().chain(vectorcraft_testkit::strategies::junk_values()) {
+ let _ = app.run("ui.colorPanel", p);
+ }
+ let mut app = VectorcraftApp::new(Session::new(), Default::default());
+ assert_eq!(app.run("ui.colorPanel", json!({"mode": "cmyk"})).unwrap()["mode"], "cmyk");
+}
+
+#[test]
+fn a_mixed_selection_has_no_colour_to_edit() {
+ let mut app = app();
+ let ctx = egui::Context::default();
+ let b = app.run("shape.rectangle", json!({"x": 80, "y": 10, "width": 50, "height": 50})).unwrap()["id"].clone();
+ app.run("select.all", json!({})).unwrap();
+ app.run("paint.setFill", json!({"color": "#ff0000"})).unwrap();
+ app.run("paint.setFill", json!({"color": "#00ff00", "ids": [b]})).unwrap();
+ frame(&mut app, &ctx, vec![], egui::Modifiers::NONE);
+ assert_eq!(crate::panels::mixed_paints(&app, &ctx), (true, false));
+ let _ = ctx.run_ui(Default::default(), |ui| assert_eq!(target(&app, ui).color(), None));
+ app.run("paint.setFill", json!({"color": "#0000ff"})).unwrap();
+ assert_eq!(crate::panels::mixed_paints(&app, &ctx), (false, false), "a new revision recomputes it");
+}
+
+#[test]
+fn rgb_roundtrip() {
+ let c = Color::rgb8(230, 120, 40);
+ let v = components(Mode::Rgb, &c);
+ assert_eq!(v.iter().map(|x| x.round() as i32).collect::<Vec<_>>(), vec![230, 120, 40]);
+ assert_eq!(from_components(Mode::Rgb, &v).to_hex(), c.to_hex());
+}
+
+#[test]
+fn hsb_roundtrip_and_ranges() {
+ let c = Color::rgb8(230, 120, 40);
+ let v = components(Mode::Hsb, &c);
+ assert!(v[0] > 0.0 && v[0] < 360.0 && v[1] <= 100.0 && v[2] <= 100.0);
+ assert_eq!(from_components(Mode::Hsb, &v).to_hex(), c.to_hex());
+ assert_eq!(Mode::Hsb.max(0), 360.0);
+ assert_eq!(Mode::Hsb.suffix(0), "°");
+}
+
+#[test]
+fn cmyk_and_gray_keep_model() {
+ let c = from_components(Mode::Cmyk, &[10.0, 20.0, 30.0, 40.0]);
+ assert!(matches!(c, Color::Cmyk { .. }));
+ let v = components(Mode::Cmyk, &c);
+ assert!((v[3] - 40.0).abs() < 1e-3);
+ let g = from_components(Mode::Grayscale, &[25.0]);
+ assert_eq!(g, Color::gray(0.25));
+ assert!((components(Mode::Grayscale, &g)[0] - 25.0).abs() < 1e-4);
+ // Grayscale view of an RGB colour uses luminance.
+ assert!((components(Mode::Grayscale, &Color::WHITE)[0]).abs() < 1e-4);
+}
+
+#[test]
+fn web_safe_snaps() {
+ let c = Color::rgb8(230, 120, 40);
+ let w = web_safe(&c);
+ assert_eq!(w.to_hex(), "#ff6633");
+ assert!(is_web_safe(&w));
+ assert!(!is_web_safe(&c));
+ assert_eq!(from_components(Mode::WebSafe, &[230.0, 120.0, 40.0]).to_hex(), "#ff6633");
+}
+
+#[test]
+fn slider_tracks_vary_one_component() {
+ let comps = [230.0, 120.0, 40.0];
+ let a = track_color(Mode::Rgb, &comps, 0, 0.0).to_rgba8(1.0);
+ let b = track_color(Mode::Rgb, &comps, 0, 1.0).to_rgba8(1.0);
+ assert_eq!((a[0], a[1], a[2]), (0, 120, 40));
+ assert_eq!((b[0], b[1], b[2]), (255, 120, 40));
+ let h = track_color(Mode::Hsb, &[0.0, 100.0, 100.0], 0, 1.0 / 3.0).to_hex();
+ assert_eq!(h, "#00ff00");
+}
+
+#[test]
+fn spectrum_and_hex() {
+ assert_eq!(spectrum_at(Mode::Rgb, 0.0, 0.0).to_hex(), "#ffffff");
+ assert_eq!(spectrum_at(Mode::Rgb, 0.0, 0.5).to_hex(), "#ff0000");
+ assert_eq!(spectrum_at(Mode::Rgb, 0.3, 1.0).to_hex(), "#000000");
+ assert_eq!(spectrum_at(Mode::Grayscale, 1.0, 0.3), Color::gray(1.0));
+ assert_eq!(parse_hex("E67828").unwrap().to_hex(), "#e67828");
+ assert_eq!(parse_hex("#fff").unwrap().to_hex(), "#ffffff");
+ assert!(parse_hex("zz").is_none());
+ assert!(parse_hex("12345").is_none());
+}