mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 19:11:26 +00:00
- With art in some of the group's colors, a second Save Changes after another edit of a row kept the color the first save gave that row's swatch, and OK gave the group's colors by row order, which could overwrite a swatch no row lists. Both now match each swatch to its row, also through the color that row listed when an earlier save gave the swatch its color. - An excluded row leaves its swatch its own color at Save Changes and at OK, with or without art. `recolor.apply` takes "keep" in `groupColors` for a swatch that keeps its color without the Global Adjust. - `swatch.editGroup` given the color keys of the group's own colors keeps those colors unrounded and records no undo step.
729 lines
37 KiB
Rust
729 lines
37 KiB
Rust
//! Swatches panel commands: moving swatches between colour groups, the panel menu's Add Used
|
|
//! Colors, Select All Unused, Merge, Ungroup and Sort by Kind, and colours following the
|
|
//! document's colour mode.
|
|
|
|
use serde_json::{Value, json};
|
|
use vectorcraft_color::{Color, Paint};
|
|
|
|
use crate::*;
|
|
|
|
fn session() -> Session {
|
|
let mut s = Session::new();
|
|
s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
|
|
s
|
|
}
|
|
|
|
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
|
s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"))
|
|
}
|
|
|
|
fn doc(s: &Session) -> &vectorcraft_doc::Document {
|
|
&s.doc().unwrap().doc
|
|
}
|
|
|
|
fn undo_len(s: &Session) -> usize {
|
|
s.doc().unwrap().history.undo.len()
|
|
}
|
|
|
|
/// The swatch names of colour group `group`, or of the ungrouped swatches.
|
|
fn names(s: &Session, group: Option<&str>) -> Vec<String> {
|
|
let d = doc(s);
|
|
let list = match group {
|
|
Some(g) => &d.swatch_groups.iter().find(|x| x.name == g).unwrap().swatches,
|
|
None => &d.swatches,
|
|
};
|
|
list.iter().map(|w| w.name.clone()).collect()
|
|
}
|
|
|
|
#[test]
|
|
fn move_between_groups_is_one_undo_step() {
|
|
let mut s = session();
|
|
let before = doc(&s).clone();
|
|
let undo = undo_len(&s);
|
|
// Two ungrouped colours into Brights, before its second swatch, in the order given.
|
|
run(&mut s, "swatch.move", json!({"names": ["Orange", "Red"], "group": "Brights", "to": 1}));
|
|
assert_eq!(names(&s, Some("Brights"))[..4], ["Bright Red", "Orange", "Red", "Bright Yellow"]);
|
|
assert!(!names(&s, None).contains(&"Red".to_string()));
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
// Out of a group to the front of the ungrouped colours (`to` counts the current entries).
|
|
run(&mut s, "swatch.move", json!({"name": "Bright Green", "to": 1}));
|
|
assert_eq!(names(&s, None)[..3], ["[None]", "Bright Green", "White"]);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(*doc(&s), before);
|
|
// Reordering within a list; past the end goes last.
|
|
run(&mut s, "swatch.move", json!({"name": "White", "to": 999}));
|
|
assert_eq!(names(&s, None).last().map(String::as_str), Some("White"));
|
|
}
|
|
|
|
/// A swatch or color group moved to place 2^32 goes last. A 32-bit build read the place as 0 and
|
|
/// moved it to the front.
|
|
#[test]
|
|
fn move_past_u32_goes_last() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.move", json!({"name": "White", "to": 1u64 << 32}));
|
|
assert_eq!(names(&s, None).last().map(String::as_str), Some("White"));
|
|
run(&mut s, "swatch.move", json!({"name": "Grays", "to": 1u64 << 32}));
|
|
assert_eq!(doc(&s).swatch_groups.last().map(|g| g.name.as_str()), Some("Grays"));
|
|
}
|
|
|
|
#[test]
|
|
fn move_reorders_groups_and_refuses_bad_moves() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.move", json!({"name": "Brights", "to": 0}));
|
|
let groups: Vec<&str> = doc(&s).swatch_groups.iter().map(|g| g.name.as_str()).collect();
|
|
assert_eq!(groups, ["Brights", "Grays"]);
|
|
let undo = undo_len(&s);
|
|
for p in [
|
|
json!({"name": "Sunset", "group": "Grays"}),
|
|
json!({"name": "[None]"}),
|
|
json!({"name": "Grays", "group": "Brights"}),
|
|
json!({"names": ["Red", "Grays"]}),
|
|
json!({"name": "Red", "group": "Nope"}),
|
|
json!({}),
|
|
] {
|
|
assert!(s.execute("swatch.move", &p).is_err(), "{p}");
|
|
}
|
|
assert_eq!(undo_len(&s), undo, "failed moves leave no undo step");
|
|
assert!(doc(&s).swatch("Sunset").is_some_and(|w| matches!(w.paint, Paint::Gradient(_))));
|
|
}
|
|
|
|
fn rect_filled(s: &mut Session, fill: Value) -> NodeId {
|
|
let id = NodeId(run(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 10, "height": 10}))["id"].as_u64().unwrap());
|
|
let mut p = fill;
|
|
p["ids"] = json!([id.0]);
|
|
run(s, "paint.setFill", p);
|
|
run(s, "paint.setStroke", json!({"ids": [id.0], "none": true}));
|
|
id
|
|
}
|
|
|
|
fn fill(s: &Session, id: NodeId) -> Paint {
|
|
doc(s).node(id).unwrap().appearance.fill_paint()
|
|
}
|
|
|
|
#[test]
|
|
fn add_used_colors_skips_colours_that_have_swatches() {
|
|
let mut s = session();
|
|
rect_filled(&mut s, json!({"color": "#123456"}));
|
|
rect_filled(&mut s, json!({"color": "#ed1c24"}));
|
|
rect_filled(&mut s, json!({"swatch": "Orange"}));
|
|
let undo = undo_len(&s);
|
|
let r = run(&mut s, "swatch.addUsedColors", json!({}));
|
|
assert_eq!(r, json!({"added": ["R=18 G=52 B=86"], "linked": 0}), "Red and Orange are swatches already");
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
assert_eq!(run(&mut s, "swatch.addUsedColors", json!({}))["added"], json!([]));
|
|
// Only the selection's colours, as global swatches its paints link to.
|
|
let d = rect_filled(&mut s, json!({"color": "#abcdef"}));
|
|
rect_filled(&mut s, json!({"color": "#fedcba"}));
|
|
run(&mut s, "select.set", json!({"ids": [d.0]}));
|
|
let r = run(&mut s, "swatch.addUsedColors", json!({"selection": true, "global": true}));
|
|
assert_eq!(r, json!({"added": ["R=171 G=205 B=239"], "linked": 1}));
|
|
assert_eq!(
|
|
fill(&s, d),
|
|
Paint::Solid { color: vectorcraft_color::Color::from_hex("#abcdef").unwrap(), swatch: Some("R=171 G=205 B=239".into()), tint: 1.0 }
|
|
);
|
|
assert!(doc(&s).swatch("R=171 G=205 B=239").unwrap().global);
|
|
}
|
|
|
|
/// Give `id` the fill `p` exactly as written (a command would round or convert some colors).
|
|
fn set_fill(s: &mut Session, id: NodeId, p: Paint) {
|
|
std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(id).unwrap().appearance.set_fill(p);
|
|
}
|
|
|
|
/// Rectangles filled with repeated colors, near-equal colors that get the same name, a color and
|
|
/// its twin with a -0.0 component, a color whose name a swatch already has, and colors two
|
|
/// swatches already have (one of them through -0.0). Returns the rectangles in paint order.
|
|
fn used_colors_doc(s: &mut Session) -> Vec<NodeId> {
|
|
run(s, "swatch.new", json!({"name": "Gray K=33", "color": "#00ff00"}));
|
|
run(s, "swatch.new", json!({"name": "Zeroed", "color": "#0080ff"}));
|
|
let red = doc(s).swatch("Red").unwrap().paint.color().unwrap();
|
|
let colors = [
|
|
Color::rgb(0.2, 0.4, 0.6),
|
|
Color::rgb(0.2, 0.4, 0.6),
|
|
Color::rgb(0.2, 0.4, 0.6001),
|
|
Color::rgb(0.0, 0.4, 0.6),
|
|
Color::rgb(-0.0, 0.4, 0.6),
|
|
Color::gray(0.33),
|
|
Color::gray(0.3301),
|
|
red,
|
|
Color::rgb(-0.0, 128.0 / 255.0, 1.0),
|
|
Color::rgb(0.2, 0.4, 0.6001),
|
|
];
|
|
colors
|
|
.into_iter()
|
|
.map(|c| {
|
|
let id = rect_filled(s, json!({"color": "#000000"}));
|
|
set_fill(s, id, Paint::solid(c));
|
|
id
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
const USED_NAMES: [&str; 5] = ["R=51 G=102 B=153", "R=51 G=102 B=153 2", "R=0 G=102 B=153", "Gray K=33 2", "Gray K=33 3"];
|
|
|
|
#[test]
|
|
fn add_used_colors_adds_each_new_color_once_with_free_names() {
|
|
let mut s = session();
|
|
used_colors_doc(&mut s);
|
|
let before = doc(&s).clone();
|
|
let undo = undo_len(&s);
|
|
let r = run(&mut s, "swatch.addUsedColors", json!({}));
|
|
assert_eq!(r, json!({"added": USED_NAMES, "linked": 0}));
|
|
assert_eq!(names(&s, None)[names(&s, None).len() - 5..], USED_NAMES);
|
|
let color = |n: &str| doc(&s).swatch(n).unwrap().paint.color().unwrap();
|
|
assert_eq!(color("R=51 G=102 B=153 2"), Color::rgb(0.2, 0.4, 0.6001));
|
|
assert_eq!(color("Gray K=33 3"), Color::gray(0.3301));
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(*doc(&s), before);
|
|
}
|
|
|
|
#[test]
|
|
fn add_used_colors_global_links_every_paint_of_a_new_color() {
|
|
let mut s = session();
|
|
let ids = used_colors_doc(&mut s);
|
|
let r = run(&mut s, "swatch.addUsedColors", json!({"global": true}));
|
|
assert_eq!(r, json!({"added": USED_NAMES, "linked": 8}));
|
|
let link = |s: &Session, id: NodeId| match fill(s, id) {
|
|
Paint::Solid { swatch, .. } => swatch,
|
|
p => panic!("{p:?}"),
|
|
};
|
|
// The index in USED_NAMES of the swatch each rectangle links to.
|
|
let want = [Some(0), Some(0), Some(1), Some(2), Some(2), Some(3), Some(4), None, None, Some(1)];
|
|
let got: Vec<Option<String>> = ids.iter().map(|id| link(&s, *id)).collect();
|
|
assert_eq!(got, want.map(|i: Option<usize>| i.map(|i| USED_NAMES[i].to_string())));
|
|
assert!(USED_NAMES.iter().all(|n| doc(&s).swatch(n).unwrap().global));
|
|
}
|
|
|
|
/// A paint linked to Registration keeps its link when a new global swatch has the same color.
|
|
#[test]
|
|
fn add_used_colors_global_leaves_registration_links_alone() {
|
|
let mut s = session();
|
|
let reg_paint = Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0), swatch: Some(vectorcraft_color::swatch::REGISTRATION.into()), tint: 1.0 };
|
|
let registration = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
set_fill(&mut s, registration, reg_paint.clone());
|
|
let plain = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
set_fill(&mut s, plain, Paint::solid(Color::cmyk(1.0, 1.0, 1.0, 1.0)));
|
|
let r = run(&mut s, "swatch.addUsedColors", json!({"global": true}));
|
|
assert_eq!(r["linked"], json!(1), "{r}");
|
|
let name = r["added"][0].as_str().unwrap().to_string();
|
|
assert_eq!(fill(&s, registration), reg_paint);
|
|
assert_eq!(fill(&s, plain), Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0), swatch: Some(name), tint: 1.0 });
|
|
}
|
|
|
|
#[test]
|
|
fn unused_matches_links_tints_colors_gradients_and_patterns_exactly() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.edit", json!({"name": "Teal", "global": true}));
|
|
run(&mut s, "swatch.new", json!({"swatch": "Teal", "tint": 40}));
|
|
run(&mut s, "swatch.new", json!({"swatch": "Teal", "tint": 70}));
|
|
run(&mut s, "swatch.new", json!({"name": "Zeroed", "color": "#0080ff"}));
|
|
let teal = doc(&s).swatch("Teal").unwrap().paint.color().unwrap();
|
|
let tinted = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
set_fill(&mut s, tinted, Paint::Solid { color: teal.tinted(0.4), swatch: Some("Teal".into()), tint: 0.4 });
|
|
let zero = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
set_fill(&mut s, zero, Paint::solid(Color::rgb(-0.0, 128.0 / 255.0, 1.0)));
|
|
// Sunset's gradient without a link to it, beside gradients with Sunset's stop colors and a
|
|
// different midpoint or opacity; Ocean's with one stop moved, and Ocean's with another kind,
|
|
// method or dither.
|
|
let gradient = |s: &Session, n: &str| match &doc(s).swatch(n).unwrap().paint {
|
|
Paint::Gradient(g) => g.gradient.clone(),
|
|
p => panic!("{p:?}"),
|
|
};
|
|
let sunset = gradient(&s, "Sunset");
|
|
let (mut midpoint, mut opacity) = (sunset.clone(), sunset.clone());
|
|
midpoint.stops[0].midpoint = 0.3;
|
|
opacity.stops[1].opacity = 0.5;
|
|
let ocean = gradient(&s, "Ocean");
|
|
let (mut moved, mut radial, mut perceptual, mut dither) = (ocean.clone(), ocean.clone(), ocean.clone(), ocean);
|
|
moved.stops[0].offset += 0.25;
|
|
radial.kind = vectorcraft_color::GradientKind::Radial;
|
|
perceptual.method = vectorcraft_color::GradientMethod::Perceptual;
|
|
dither.dither = true;
|
|
for g in [midpoint, sunset.clone(), opacity, sunset, moved, radial, perceptual, dither] {
|
|
let id = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
set_fill(&mut s, id, Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(g))));
|
|
}
|
|
let r = rect_filled(&mut s, json!({"color": "#ff0000"}));
|
|
run(&mut s, "select.set", json!({"ids": [r.0]}));
|
|
run(&mut s, "object.pattern.make", json!({"name": "Dots", "width": 20, "height": 20}));
|
|
run(&mut s, "object.pattern.done", json!({}));
|
|
rect_filled(&mut s, json!({"swatch": "Dots"}));
|
|
let names = run(&mut s, "swatch.unused", json!({}))["names"].clone();
|
|
let names: Vec<&str> = names.as_array().unwrap().iter().filter_map(Value::as_str).collect();
|
|
for used in ["Teal", "Teal 40%", "Zeroed", "Sunset", "Dots"] {
|
|
assert!(!names.contains(&used), "{used} is used: {names:?}");
|
|
}
|
|
for unused in ["Teal 70%", "Ocean", "Orange", "Red"] {
|
|
assert!(names.contains(&unused), "{unused} is unused: {names:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn new_swatches_from_colors_are_numbered_after_names_already_taken() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.new", json!({"name": "R=255 G=0 B=0 2", "color": "#0000ff"}));
|
|
run(&mut s, "swatch.newGroup", json!({"name": "Mine"}));
|
|
let before = doc(&s).clone();
|
|
let undo = undo_len(&s);
|
|
// Near-equal colors with the same name, and a Lab color and its twin with a -0.0 component.
|
|
let colors = json!([
|
|
"#ff0000",
|
|
"#ff0000",
|
|
"#ff0000",
|
|
"#00ff00",
|
|
"#00ff00",
|
|
[0.2, 0.4, 0.6],
|
|
[0.2, 0.4, 0.6001],
|
|
{"l": 50, "a": 0.0, "b": 0},
|
|
{"l": 50, "a": -0.0, "b": 0}
|
|
]);
|
|
let r = run(&mut s, "swatch.new", json!({ "colors": colors }));
|
|
let want = [
|
|
"R=255 G=0 B=0",
|
|
"R=255 G=0 B=0 3",
|
|
"R=255 G=0 B=0 4",
|
|
"R=0 G=255 B=0",
|
|
"R=0 G=255 B=0 2",
|
|
"R=51 G=102 B=153",
|
|
"R=51 G=102 B=153 2",
|
|
"L=50 a=0 b=0",
|
|
"L=50 a=0 b=0 2",
|
|
];
|
|
assert_eq!(r, json!({"name": want[0], "names": want}));
|
|
assert_eq!(names(&s, None)[names(&s, None).len() - want.len()..], want);
|
|
assert!(matches!(doc(&s).swatch("L=50 a=0 b=0 2").unwrap().paint.color(), Some(Color::Lab { a, .. }) if a.is_sign_negative()));
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(*doc(&s), before);
|
|
let r = run(&mut s, "swatch.new", json!({"colors": ["#ff0000", "#ff0000", "#ff0000"]}));
|
|
assert_eq!(r["names"], json!(["R=255 G=0 B=0", "R=255 G=0 B=0 3", "R=255 G=0 B=0 4"]));
|
|
let r = run(&mut s, "swatch.new", json!({"colors": ["#ff0000", "#ff0000"], "group": "Mine"}));
|
|
assert_eq!(r["names"], json!(["R=255 G=0 B=0 5", "R=255 G=0 B=0 6"]));
|
|
assert_eq!(names(&s, Some("Mine")), ["R=255 G=0 B=0 5", "R=255 G=0 B=0 6"]);
|
|
}
|
|
|
|
#[test]
|
|
fn new_color_group_numbers_its_colors_after_the_group_and_its_moved_swatches() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.new", json!({"name": "R=255 G=0 B=0 2", "color": "#0000ff"}));
|
|
let r = run(
|
|
&mut s,
|
|
"swatch.newGroup",
|
|
json!({"name": "R=255 G=0 B=0", "swatches": ["R=255 G=0 B=0 2"], "colors": ["#ff0000", "#ff0000", "#00ff00", "#ff0000"]}),
|
|
);
|
|
let want = ["R=255 G=0 B=0 2", "R=255 G=0 B=0 3", "R=255 G=0 B=0 4", "R=0 G=255 B=0", "R=255 G=0 B=0 5"];
|
|
assert_eq!(r, json!({"name": "R=255 G=0 B=0", "swatches": want, "linked": 0}));
|
|
}
|
|
|
|
/// New Color Group from artwork lists each color once in paint order: a repeat and a twin with a
|
|
/// -0.0 component are the same color, near-equal colors with the same name are numbered after the
|
|
/// names already taken, and a paint linked to Registration brings no color. One undo step.
|
|
#[test]
|
|
fn new_color_group_from_artwork_lists_each_color_once_with_free_names() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.new", json!({"name": "R=0 G=102 B=153", "color": "#00ff00"}));
|
|
let colors = [
|
|
Color::rgb(0.2, 0.4, 0.6),
|
|
Color::rgb(0.0, 0.4, 0.6),
|
|
Color::rgb(0.2, 0.4, 0.6001),
|
|
Color::rgb(-0.0, 0.4, 0.6),
|
|
Color::rgb(0.2, 0.4, 0.6),
|
|
Color::lab(50.0, 0.0, 0.0),
|
|
Color::lab(50.0, -0.0, 0.0),
|
|
Color::lab(50.0, 0.0001, 0.0),
|
|
];
|
|
let mut ids: Vec<u64> = vec![];
|
|
for c in colors {
|
|
let id = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
set_fill(&mut s, id, Paint::solid(c));
|
|
ids.push(id.0);
|
|
}
|
|
let registration = rect_filled(&mut s, json!({"color": "#000000"}));
|
|
let reg_paint = Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0), swatch: Some(vectorcraft_color::swatch::REGISTRATION.into()), tint: 1.0 };
|
|
set_fill(&mut s, registration, reg_paint);
|
|
ids.push(registration.0);
|
|
run(&mut s, "select.set", json!({ "ids": ids }));
|
|
let before = doc(&s).clone();
|
|
let undo = undo_len(&s);
|
|
let r = run(&mut s, "swatch.newGroup", json!({"name": "R=51 G=102 B=153 2", "fromArtwork": true}));
|
|
let want = ["R=51 G=102 B=153", "R=0 G=102 B=153 2", "R=51 G=102 B=153 3", "L=50 a=0 b=0", "L=50 a=0 b=0 2"];
|
|
assert_eq!(r, json!({"name": "R=51 G=102 B=153 2", "swatches": want, "linked": 8}));
|
|
assert_eq!(names(&s, Some("R=51 G=102 B=153 2")), want);
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(*doc(&s), before);
|
|
}
|
|
|
|
/// New Color Group takes the named solid swatches in the order given. A name listed twice takes
|
|
/// the next swatch of that name, found ungrouped first and then in each colour group, and the
|
|
/// lists the swatches leave keep their order. Gradients and names no swatch has take nothing.
|
|
#[test]
|
|
fn new_color_group_takes_named_swatches_in_order_from_every_list() {
|
|
let mut s = session();
|
|
let twin = vectorcraft_color::Swatch { name: "Red".into(), paint: Paint::solid(Color::rgb(0.5, 0.0, 0.0)), global: false, spot: false };
|
|
std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc)
|
|
.swatch_groups
|
|
.iter_mut()
|
|
.find(|g| g.name == "Brights")
|
|
.unwrap()
|
|
.swatches
|
|
.push(twin.clone());
|
|
let red = doc(&s).swatch("Red").cloned().unwrap();
|
|
let mut ungrouped = names(&s, None);
|
|
let mut brights = names(&s, Some("Brights"));
|
|
let r = run(&mut s, "swatch.newGroup", json!({"name": "Mine", "swatches": ["Red", "Orange", "Sunset", "Red", "Missing", "Bright Red"]}));
|
|
assert_eq!(r["swatches"], json!(["Red", "Orange", "Red", "Bright Red"]));
|
|
let group = &doc(&s).swatch_groups.iter().find(|g| g.name == "Mine").unwrap().swatches;
|
|
assert_eq!(group[0], red);
|
|
assert_eq!(group[2], twin);
|
|
ungrouped.retain(|n| n != "Red" && n != "Orange");
|
|
brights.retain(|n| n != "Red" && n != "Bright Red");
|
|
assert_eq!(names(&s, None), ungrouped);
|
|
assert_eq!(names(&s, Some("Brights")), brights);
|
|
assert!(doc(&s).swatch("Sunset").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn edit_color_group_numbers_extra_colors_after_the_names_it_keeps() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.newGroup", json!({"name": "Mine", "colors": ["#ff0000", "#00ff00", "#0000ff"]}));
|
|
let before = doc(&s).clone();
|
|
let undo = undo_len(&s);
|
|
// Near-equal colors with the same name, and a Lab color and its twin with a -0.0 component.
|
|
let colors = json!([
|
|
"#0000ff",
|
|
"#ff0000",
|
|
"#ff0000",
|
|
"#ff0000",
|
|
"#ff0000",
|
|
"#00ff00",
|
|
[0.2, 0.4, 0.6],
|
|
[0.2, 0.4, 0.6001],
|
|
{"l": 50, "a": 0.0, "b": 0},
|
|
{"l": 50, "a": -0.0, "b": 0}
|
|
]);
|
|
let r = run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": colors, "rename": "R=255 G=0 B=0 2"}));
|
|
let want = [
|
|
"R=255 G=0 B=0",
|
|
"R=0 G=255 B=0",
|
|
"R=0 G=0 B=255",
|
|
"R=255 G=0 B=0 3",
|
|
"R=255 G=0 B=0 4",
|
|
"R=0 G=255 B=0 2",
|
|
"R=51 G=102 B=153",
|
|
"R=51 G=102 B=153 2",
|
|
"L=50 a=0 b=0",
|
|
"L=50 a=0 b=0 2",
|
|
];
|
|
assert_eq!(r, json!({"name": "R=255 G=0 B=0 2", "swatches": want, "relinked": 0}));
|
|
assert_eq!(names(&s, Some("R=255 G=0 B=0 2")), want);
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(*doc(&s), before);
|
|
}
|
|
|
|
/// `swatch.editGroup` with the group's own colors, in order, and its own name (or a blank one)
|
|
/// records no undo step; a new order, a new color or a new name records one.
|
|
#[test]
|
|
fn edit_color_group_with_its_own_colors_records_no_undo_step() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.newGroup", json!({"name": "Mine", "colors": ["#ff0000", "#00ff00"], "keepModel": true}));
|
|
let undo = undo_len(&s);
|
|
for p in [
|
|
json!({"group": "Mine", "colors": ["#ff0000", "#00ff00"]}),
|
|
json!({"group": "Mine", "colors": ["#ff0000", "#00ff00"], "rename": "Mine"}),
|
|
json!({"group": "Mine", "colors": ["#ff0000", "#00ff00"], "rename": " "}),
|
|
] {
|
|
let r = run(&mut s, "swatch.editGroup", p.clone());
|
|
assert_eq!(r, json!({"name": "Mine", "swatches": ["R=255 G=0 B=0", "R=0 G=255 B=0"], "relinked": 0}), "{p}");
|
|
assert_eq!(undo_len(&s), undo, "{p}: no undo step");
|
|
}
|
|
run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": ["#00ff00", "#ff0000"]}));
|
|
assert_eq!(undo_len(&s), undo + 1, "a new order is a step");
|
|
run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": ["#00ff00", "#ff0000"], "rename": "Yours"}));
|
|
assert_eq!(undo_len(&s), undo + 2, "a new name is a step");
|
|
}
|
|
|
|
/// `swatch.editGroup` with the color keys of the group's own colors records no undo step when a
|
|
/// color lies between the keys' steps, and a rename keeps that color unrounded; a color given as a
|
|
/// value is taken as it is.
|
|
#[test]
|
|
fn edit_color_group_with_its_own_color_keys_keeps_the_colors() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.newGroup", json!({"name": "Mine", "colors": [{"c": 60.005, "m": 0, "y": 0, "k": 0}, "#00ff00"], "keepModel": true}));
|
|
let colors = |s: &Session| -> Vec<Color> {
|
|
doc(s).swatch_groups.iter().find(|g| g.name == "Mine" || g.name == "Yours").unwrap().swatches.iter().filter_map(|w| w.paint.color()).collect()
|
|
};
|
|
let own = colors(&s);
|
|
let keys: Vec<String> = own.iter().map(|c| vectorcraft_color::recolor::ColorKey::of(c).to_string()).collect();
|
|
assert_ne!(crate::cmd::color_value(&json!(keys[0])), Some(own[0]), "the key rounds the color");
|
|
let undo = undo_len(&s);
|
|
run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": keys}));
|
|
assert_eq!(undo_len(&s), undo, "the group's own colors record no step");
|
|
run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": keys, "rename": "Yours"}));
|
|
assert_eq!(undo_len(&s), undo + 1, "a new name is a step");
|
|
assert_eq!(colors(&s), own, "the colors are kept unrounded");
|
|
// A color given as a value, not a key, is taken exactly, also within a key's step.
|
|
let Color::Cmyk { c, .. } = own[0] else { panic!("a CMYK swatch: {:?}", own[0]) };
|
|
let nudged = Color::cmyk(c - 0.000_002, 0.0, 0.0, 0.0);
|
|
assert_eq!(vectorcraft_color::recolor::ColorKey::of(&nudged), vectorcraft_color::recolor::ColorKey::of(&own[0]));
|
|
let p = json!({"group": "Yours", "colors": [{"c": c - 0.000_002, "m": 0, "y": 0, "k": 0}, "#00ff00"], "keepModel": true});
|
|
run(&mut s, "swatch.editGroup", p);
|
|
assert_eq!(undo_len(&s), undo + 2, "a new value is a step");
|
|
assert_eq!(colors(&s)[0], nudged);
|
|
}
|
|
|
|
#[test]
|
|
fn edit_color_group_with_a_null_removes_that_swatch() {
|
|
let mut s = session();
|
|
run(&mut s, "swatch.newGroup", json!({"name": "Mine", "colors": ["#ff0000", "#00ff00", "#0000ff"], "keepModel": true}));
|
|
let undo = undo_len(&s);
|
|
let r = run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": ["#ff0000", null, "#0000ff"]}));
|
|
assert_eq!(r["swatches"], json!(["R=255 G=0 B=0", "R=0 G=0 B=255"]));
|
|
assert_eq!(names(&s, Some("Mine")), ["R=255 G=0 B=0", "R=0 G=0 B=255"]);
|
|
assert_eq!(undo_len(&s), undo + 1, "a removed swatch is a step");
|
|
run(&mut s, "swatch.editGroup", json!({"group": "Mine", "colors": ["#ff0000", "#0000ff", null]}));
|
|
assert_eq!(undo_len(&s), undo + 1, "a null past the swatches removes nothing and records no step");
|
|
assert!(s.execute("swatch.editGroup", &json!({"group": "Mine", "colors": ["#ff0000", "nope"]})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn unused_leaves_out_linked_colours_gradients_and_patterns_in_use() {
|
|
let mut s = session();
|
|
let all = run(&mut s, "swatch.unused", json!({}));
|
|
assert!(!all["names"].as_array().unwrap().contains(&json!("[None]")));
|
|
assert!(all["names"].as_array().unwrap().contains(&json!("Sunset")));
|
|
run(&mut s, "swatch.edit", json!({"name": "Teal", "global": true}));
|
|
rect_filled(&mut s, json!({"swatch": "Teal"}));
|
|
run(&mut s, "swatch.edit", json!({"name": "Teal", "color": "#010203"}));
|
|
rect_filled(&mut s, json!({"swatch": "Sunset"}));
|
|
rect_filled(&mut s, json!({"color": "#ed1c24"}));
|
|
let r = rect_filled(&mut s, json!({"color": "#ff0000"}));
|
|
run(&mut s, "select.set", json!({"ids": [r.0]}));
|
|
run(&mut s, "object.pattern.make", json!({"name": "Dots", "width": 20, "height": 20}));
|
|
run(&mut s, "object.pattern.done", json!({}));
|
|
rect_filled(&mut s, json!({"swatch": "Dots"}));
|
|
let names = run(&mut s, "swatch.unused", json!({}))["names"].clone();
|
|
let names: Vec<&str> = names.as_array().unwrap().iter().filter_map(Value::as_str).collect();
|
|
for used in ["Teal", "Sunset", "Red", "Dots", "White"] {
|
|
assert!(!names.contains(&used), "{used} is used: {names:?}");
|
|
}
|
|
for unused in ["Orange", "Ocean", "Bright Red", "K=50"] {
|
|
assert!(names.contains(&unused), "{unused} is unused: {names:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn merge_keeps_the_first_and_relinks_the_others_art() {
|
|
let mut s = session();
|
|
for n in ["Red", "Orange"] {
|
|
run(&mut s, "swatch.edit", json!({"name": n, "global": true}));
|
|
}
|
|
let a = rect_filled(&mut s, json!({"swatch": "Red"}));
|
|
let b = rect_filled(&mut s, json!({"swatch": "Orange"}));
|
|
let red = doc(&s).swatch("Red").unwrap().paint.color().unwrap();
|
|
let before = doc(&s).clone();
|
|
let undo = undo_len(&s);
|
|
let r = run(&mut s, "swatch.merge", json!({"names": ["Red", "Orange"]}));
|
|
assert_eq!(r, json!({"name": "Red", "merged": ["Orange"], "relinked": 1}));
|
|
assert!(doc(&s).swatch("Orange").is_none());
|
|
assert_eq!(fill(&s, b), Paint::Solid { color: red, swatch: Some("Red".into()), tint: 1.0 });
|
|
assert_eq!(undo_len(&s), undo + 1);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(*doc(&s), before);
|
|
// A kept swatch that isn't global leaves the merged swatches' art unlinked, in its colour.
|
|
run(&mut s, "swatch.merge", json!({"names": ["Lime", "Red", "Bright Red"]}));
|
|
let lime = doc(&s).swatch("Lime").unwrap().paint.color().unwrap();
|
|
assert_eq!(fill(&s, a), Paint::solid(lime));
|
|
assert!(doc(&s).swatch("Red").is_none() && doc(&s).swatch("Bright Red").is_none());
|
|
for bad in [json!({"names": ["Lime"]}), json!({"names": ["Lime", "Sunset"]}), json!({"names": ["Lime", "Nope"]})] {
|
|
assert!(s.execute("swatch.merge", &bad).is_err(), "{bad}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ungroup_and_sort_by_kind_are_one_undo_step_each() {
|
|
let mut s = session();
|
|
let undo = undo_len(&s);
|
|
assert_eq!(run(&mut s, "swatch.ungroup", json!({"name": "Brights"}))["swatches"].as_array().unwrap().len(), 5);
|
|
assert!(doc(&s).swatch_groups.iter().all(|g| g.name != "Brights"));
|
|
assert_eq!(names(&s, None).last().map(String::as_str), Some("Bright Violet"));
|
|
assert!(s.execute("swatch.ungroup", &json!({"name": "Red"})).is_err());
|
|
// A gradient first, a spot colour among the process ones.
|
|
run(&mut s, "swatch.move", json!({"name": "Ocean", "to": 0}));
|
|
run(&mut s, "swatch.edit", json!({"name": "Orange", "spot": true}));
|
|
run(&mut s, "swatch.sortByKind", json!({}));
|
|
assert_eq!(undo_len(&s), undo + 4);
|
|
let rank = |w: &vectorcraft_color::Swatch| match &w.paint {
|
|
Paint::None => 0,
|
|
Paint::Solid { .. } if !w.spot => 1,
|
|
Paint::Solid { .. } => 2,
|
|
Paint::Gradient(_) => 3,
|
|
Paint::Pattern { .. } => 4,
|
|
};
|
|
let ranks: Vec<u8> = doc(&s).swatches.iter().map(rank).collect();
|
|
assert!(ranks.is_sorted(), "{ranks:?}");
|
|
let n = names(&s, None);
|
|
assert_eq!((n[0].as_str(), n[1].as_str()), ("[None]", "White"), "the order within a kind is kept");
|
|
assert_eq!(n[n.iter().position(|x| x == "Orange").unwrap() + 1], "Ocean", "the spot colour comes after the process ones, then the gradients");
|
|
}
|
|
|
|
#[test]
|
|
fn a_cmyk_document_starts_with_cmyk_swatches_and_stores_new_colours_as_cmyk() {
|
|
use vectorcraft_color::Color;
|
|
let mut s = Session::new();
|
|
run(&mut s, "file.new", json!({"width": 100, "height": 100, "colorMode": "cmyk"}));
|
|
assert_eq!(doc(&s).color_mode, vectorcraft_doc::ColorMode::Cmyk);
|
|
assert!(doc(&s).swatches_iter().filter_map(|w| w.paint.color()).all(|c| !matches!(c, Color::Rgb { .. })));
|
|
assert_eq!(doc(&s).swatch("Black").and_then(|w| w.paint.color()), Some(Color::cmyk(0.0, 0.0, 0.0, 1.0)));
|
|
// RGB colors separate through the color settings (Generic CMYK: red is C0 M97 Y100 K0).
|
|
let cms = vectorcraft_color::cms::active();
|
|
let managed = |c: Color| cms.convert(&c, vectorcraft_color::cms::Model::Cmyk, cms.settings().intent);
|
|
let a = rect_filled(&mut s, json!({"color": "#ff0000"}));
|
|
assert_eq!(fill(&s, a), Paint::solid(managed(Color::rgb(1.0, 0.0, 0.0))));
|
|
// Gray stays Gray; keepModel keeps RGB; gradient stops follow the document too.
|
|
run(&mut s, "paint.setFill", json!({"ids": [a.0], "color": {"gray": 0.4}}));
|
|
assert_eq!(fill(&s, a), Paint::solid(Color::gray(0.4)));
|
|
run(&mut s, "paint.setFill", json!({"ids": [a.0], "color": "#ff0000", "keepModel": true}));
|
|
assert_eq!(fill(&s, a), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
|
|
run(
|
|
&mut s,
|
|
"paint.setFill",
|
|
json!({"ids": [a.0], "gradient": {"stops": [{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#0000ff"}]}}),
|
|
);
|
|
let Paint::Gradient(g) = fill(&s, a) else { panic!("a gradient") };
|
|
assert!(g.gradient.stops.iter().all(|st| matches!(st.color, Color::Cmyk { .. })));
|
|
// A swatch made from a hex colour is CMYK as well; the document round-trips natively.
|
|
let name = run(&mut s, "swatch.new", json!({"color": "#00ff00"}))["name"].as_str().unwrap().to_string();
|
|
assert_eq!(doc(&s).swatch(&name).and_then(|w| w.paint.color()), Some(managed(Color::rgb(0.0, 1.0, 0.0))));
|
|
assert_eq!(name, "C=65 M=0 Y=100 K=0");
|
|
let json = serde_json::to_string(doc(&s)).unwrap();
|
|
assert_eq!(serde_json::from_str::<vectorcraft_doc::Document>(&json).unwrap(), *doc(&s));
|
|
}
|
|
|
|
/// The other swatch commands store RGB colors in a CMYK document as `swatch.new {color}` does:
|
|
/// `swatch.new {colors}`, `swatch.newGroup {colors}`, `swatch.editGroup {colors}` and
|
|
/// `swatch.edit {color}`. A color a swatch already has, and a color given with `mode`, keep their
|
|
/// model.
|
|
#[test]
|
|
fn a_cmyk_document_stores_rgb_colors_given_to_the_swatch_commands_as_cmyk() {
|
|
use vectorcraft_color::Color;
|
|
let mut s = Session::new();
|
|
run(&mut s, "file.new", json!({"width": 100, "height": 100, "colorMode": "cmyk"}));
|
|
let cms = vectorcraft_color::cms::active();
|
|
let managed = |c: Color| cms.convert(&c, vectorcraft_color::cms::Model::Cmyk, cms.settings().intent);
|
|
let (red, green) = (Color::rgb(1.0, 0.0, 0.0), Color::rgb(0.0, 1.0, 0.0));
|
|
let color = |s: &Session, n: &Value| doc(s).swatch(n.as_str().unwrap()).and_then(|w| w.paint.color());
|
|
let r = run(&mut s, "swatch.new", json!({"colors": ["#ff0000", {"c": 0, "m": 0, "y": 100, "k": 0}]}));
|
|
assert_eq!((color(&s, &r["names"][0]), color(&s, &r["names"][1])), (Some(managed(red)), Some(Color::cmyk(0.0, 0.0, 1.0, 0.0))));
|
|
let r = run(&mut s, "swatch.newGroup", json!({"name": "G", "colors": ["#00ff00"]}));
|
|
assert_eq!(color(&s, &r["swatches"][0]), Some(managed(green)));
|
|
let kept = run(&mut s, "swatch.newGroup", json!({"name": "K", "colors": ["#00ff00"], "keepModel": true}));
|
|
assert_eq!(color(&s, &kept["swatches"][0]), Some(green), "keepModel keeps RGB");
|
|
let r = run(&mut s, "swatch.editGroup", json!({"group": "G", "colors": ["#ff0000", "#00ff00"]}));
|
|
assert_eq!((color(&s, &r["swatches"][0]), color(&s, &r["swatches"][1])), (Some(managed(red)), Some(managed(green))));
|
|
let name = run(&mut s, "swatch.new", json!({"color": "#000000", "keepModel": true}))["name"].clone();
|
|
assert_eq!(color(&s, &name), Some(Color::BLACK));
|
|
run(&mut s, "swatch.edit", json!({"name": name, "color": "#ff0000"}));
|
|
assert_eq!(color(&s, &name), Some(managed(red)));
|
|
// An RGB swatch sent back unchanged stays RGB.
|
|
let rgb = run(&mut s, "swatch.new", json!({"color": "#00ff00", "keepModel": true}))["name"].clone();
|
|
run(&mut s, "swatch.edit", json!({"name": rgb, "color": "#00ff00", "global": true}));
|
|
assert_eq!(color(&s, &rgb), Some(green));
|
|
run(&mut s, "swatch.newGroup", json!({"name": "H", "swatches": [rgb]}));
|
|
let r = run(&mut s, "swatch.editGroup", json!({"group": "H", "colors": ["#00ff00", "#ff0000"]}));
|
|
assert_eq!((color(&s, &r["swatches"][0]), color(&s, &r["swatches"][1])), (Some(green), Some(managed(red))));
|
|
// With `mode`, the color is converted once, into that mode.
|
|
let r = run(&mut s, "swatch.new", json!({"color": "#00ff00", "mode": "rgb"}));
|
|
assert_eq!(color(&s, &r["name"]), Some(green));
|
|
let r = run(&mut s, "swatch.new", json!({"colors": ["#00ff00"], "mode": "rgb"}));
|
|
assert_eq!(color(&s, &r["names"][0]), Some(green));
|
|
}
|
|
|
|
/// In a CMYK document `swatch.new` (with `color`, `colors` or `mode`), `swatch.newGroup`,
|
|
/// `swatch.edit` (its `keepModel` and its `paint`'s) and `swatch.editGroup` refuse a `keepModel` given
|
|
/// as text or as another value that is not true or false, and the swatches and the undo history stay
|
|
/// as they were. Null is read as `keepModel` left out.
|
|
#[test]
|
|
fn the_swatch_commands_refuse_a_keep_model_given_as_text() {
|
|
use vectorcraft_color::Color;
|
|
let mut s = Session::new();
|
|
run(&mut s, "file.new", json!({"width": 100, "height": 100, "colorMode": "cmyk"}));
|
|
let cms = vectorcraft_color::cms::active();
|
|
let managed = |c: Color| cms.convert(&c, vectorcraft_color::cms::Model::Cmyk, cms.settings().intent);
|
|
let name = run(&mut s, "swatch.new", json!({"color": "#000000", "keepModel": true}))["name"].clone();
|
|
run(&mut s, "swatch.newGroup", json!({"name": "G", "colors": ["#00ff00"]}));
|
|
let before = (doc(&s).clone(), undo_len(&s));
|
|
let calls = [
|
|
("swatch.new", json!({"color": "#ff0000", "keepModel": "true"})),
|
|
("swatch.new", json!({"colors": ["#ff0000"], "keepModel": 1})),
|
|
("swatch.new", json!({"color": "#ff0000", "mode": "rgb", "keepModel": "false"})),
|
|
("swatch.newGroup", json!({"name": "K", "colors": ["#00ff00"], "keepModel": "true"})),
|
|
("swatch.edit", json!({"name": name, "color": "#ff0000", "keepModel": [true]})),
|
|
("swatch.edit", json!({"name": name, "paint": {"color": "#ff0000", "keepModel": "true"}, "mode": "cmyk"})),
|
|
("swatch.editGroup", json!({"group": "G", "colors": ["#ff0000"], "keepModel": "true"})),
|
|
];
|
|
for (cmd, p) in &calls {
|
|
let r = s.execute(cmd, p);
|
|
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if msg == "`keepModel` must be true or false"), "{cmd} {p}: {r:?}");
|
|
assert_eq!((doc(&s).clone(), undo_len(&s)), before, "{cmd} {p}");
|
|
}
|
|
let r = run(&mut s, "swatch.new", json!({"color": "#ff0000", "keepModel": null}));
|
|
assert_eq!(doc(&s).swatch(r["name"].as_str().unwrap()).and_then(|w| w.paint.color()), Some(managed(Color::rgb(1.0, 0.0, 0.0))));
|
|
}
|
|
|
|
/// The swatch commands refuse an on/off option given as text or as another value that is not true
|
|
/// or false, and `swatch.move` a `to` that is not a number, naming the key; the swatches and the
|
|
/// undo history stay as they were. True, false, numbers and null still work.
|
|
#[test]
|
|
fn the_swatch_commands_refuse_a_boolean_or_number_given_as_text() {
|
|
use crate::tests::{not_a_number, not_a_switch, not_refused};
|
|
let mut s = session();
|
|
run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20}));
|
|
run(&mut s, "paint.setFill", json!({"color": "#3366cc"}));
|
|
let name = run(&mut s, "swatch.new", json!({"color": "#000000"}))["name"].clone();
|
|
let mut calls: Vec<_> = [
|
|
("swatch.new", json!({"color": "#ff0000", "spot": "true"}), "spot"),
|
|
("swatch.new", json!({"color": "#ff0000", "global": 1}), "global"),
|
|
("swatch.delete", json!({"name": name, "unlink": "false"}), "unlink"),
|
|
("swatch.newGroup", json!({"name": "K", "colors": ["#00ff00"], "includeTints": "true"}), "includeTints"),
|
|
("swatch.newGroup", json!({"name": "K", "fromArtwork": "true"}), "fromArtwork"),
|
|
("swatch.newGroup", json!({"name": "K", "fromArtwork": true, "toGlobal": "false"}), "toGlobal"),
|
|
("swatch.edit", json!({"name": name, "spot": "true"}), "spot"),
|
|
("swatch.edit", json!({"name": name, "global": [true]}), "global"),
|
|
("swatch.addUsedColors", json!({"global": "true"}), "global"),
|
|
("swatch.addUsedColors", json!({"selection": 1}), "selection"),
|
|
]
|
|
.into_iter()
|
|
.map(|(cmd, p, key)| not_a_switch(cmd, p, key))
|
|
.collect();
|
|
calls.push(not_a_number("swatch.move", json!({"name": name, "to": "0"}), "to"));
|
|
let wrong = not_refused(&mut s, &calls);
|
|
assert!(wrong.is_empty(), "not refused: {wrong:#?}");
|
|
run(&mut s, "swatch.edit", json!({"name": name, "global": true, "spot": null}));
|
|
run(&mut s, "swatch.move", json!({"name": name, "to": 0}));
|
|
assert!(doc(&s).swatch(name.as_str().unwrap()).is_some_and(|w| w.global && !w.spot));
|
|
}
|
|
|
|
#[test]
|
|
fn rgb_documents_keep_colours_as_given_and_edits_keep_the_source_model() {
|
|
use vectorcraft_color::Color;
|
|
let mut s = session();
|
|
assert_eq!(doc(&s).swatch("Black").and_then(|w| w.paint.color()), Some(Color::rgb(0.0, 0.0, 0.0)));
|
|
let a = rect_filled(&mut s, json!({"color": "#ff0000"}));
|
|
assert_eq!(fill(&s, a), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
|
|
let b = rect_filled(&mut s, json!({"color": {"c": 0.0, "m": 1.0, "y": 0.0, "k": 0.0}}));
|
|
assert_eq!(fill(&s, b), Paint::solid(Color::cmyk(0.0, 1.0, 0.0, 0.0)), "an RGB document doesn't convert CMYK either");
|
|
// Recolor Artwork keeps the replaced colour's model.
|
|
run(&mut s, "select.set", json!({"ids": [b.0]}));
|
|
let hex = Color::cmyk(0.0, 1.0, 0.0, 0.0).to_hex();
|
|
run(&mut s, "recolor.apply", json!({"map": {hex: "#00ff00"}}));
|
|
assert!(matches!(fill(&s, b).color(), Some(Color::Cmyk { .. })));
|
|
// Blending ends of different models gives the document's model.
|
|
let c = rect_filled(&mut s, json!({"color": "#808080"}));
|
|
run(&mut s, "select.set", json!({"ids": [a.0, c.0, b.0]}));
|
|
run(&mut s, "edit.colors.blendFrontToBack", json!({}));
|
|
assert!(matches!(fill(&s, c).color(), Some(Color::Rgb { .. })));
|
|
}
|