mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-11 22:22:25 +00:00
Julius van der Vaart
7d73882d3a
Add Line Arrow, a 41st generated arrowhead: two arms as thick as the line (at 100 % scale) meeting at right angles in a sharp tip, cut square at their ends. It is saved by the new name `LineArrow`, appended so existing names stay stable, and listed third in the arrowhead menus after Arrow (open). Its arms spread four weights either side of the line, twice as wide as the other heads, so Arrowhead now states its own reach and half width. Visual bounds and clicks on the canvas (head_reach, head_contains) use them instead of one fixed 4.6 x 2 box; every other head keeps the sizes it had. Tests: the outline test checks each head against its own reach and half width; a new test checks the line arrow's tip, corners, open middle and arm thickness; outset_covers_arrowheads checks that the wider head grows the outset; the saved-name list includes LineArrow.
412 lines
20 KiB
Rust
412 lines
20 KiB
Rust
use super::*;
|
||
|
||
#[test]
|
||
fn hidden_attributes_show_again() {
|
||
let mut a = Appearance::default_art();
|
||
assert!(!a.has_hidden() && !a.show_all());
|
||
a.stroke_mut().unwrap().visible = false;
|
||
a.items[0].effects_mut().push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: false });
|
||
assert!(a.has_hidden());
|
||
assert!(a.show_all());
|
||
assert!(!a.has_hidden() && a.items.iter().all(AppearanceItem::visible) && a.items[0].effects()[0].visible);
|
||
}
|
||
|
||
#[test]
|
||
fn basic_appearance() {
|
||
let a = Appearance::default_art();
|
||
assert!(a.is_basic());
|
||
assert_eq!(a.fill_paint(), Paint::solid(Color::WHITE));
|
||
assert_eq!(a.stroke_width(), 1.0);
|
||
}
|
||
|
||
#[test]
|
||
fn rebase_moves_fills_by_the_box_and_strokes_by_their_inflated_box() {
|
||
use vectorcraft_color::{Gradient, GradientGeom, GradientPaint};
|
||
use vectorcraft_geom::{Point, Rect};
|
||
let placed = |x: f64| {
|
||
let mut g = GradientPaint::new(Gradient::default());
|
||
g.geom = Some(GradientGeom { start: Point::new(x, 0.0), end: Point::new(x + 10.0, 0.0), aspect: 1.0, focal: None });
|
||
Paint::Gradient(Box::new(g))
|
||
};
|
||
let mut a = Appearance::basic(placed(0.0), placed(-5.0), 10.0);
|
||
a.rebase_gradients(Rect::new(0.0, 0.0, 100.0, 100.0), Rect::new(100.0, 0.0, 300.0, 100.0));
|
||
let start = |p: Paint| match p {
|
||
Paint::Gradient(g) => g.geom.unwrap().start,
|
||
_ => panic!("a gradient"),
|
||
};
|
||
// The fill's start stays on the left edge; the stroke's on its inflated box's (−5 → 95).
|
||
assert_eq!((start(a.fill_paint()), start(a.stroke_paint())), (Point::new(100.0, 0.0), Point::new(95.0, 0.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn items_by_index() {
|
||
let mut a = Appearance::default_art();
|
||
a.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None)));
|
||
// [Fill white, Stroke black, Fill none]
|
||
assert_eq!(a.fill_at(None).unwrap().paint, Paint::None);
|
||
assert_eq!(a.fill_at(Some(0)).unwrap().paint, Paint::solid(Color::WHITE));
|
||
assert!(a.fill_at(Some(1)).is_none() && a.stroke_at(Some(0)).is_none() && a.fill_at(Some(9)).is_none());
|
||
assert_eq!(a.item_of_kind(Some(1), false), Some(1));
|
||
assert_eq!(a.item_of_kind(Some(1), true), None);
|
||
assert_eq!(a.fill_for(Some(1)).unwrap().paint, Paint::None);
|
||
assert!(a.set_fill_at(Some(0), Paint::solid(Color::BLACK)));
|
||
assert!(!a.set_stroke_at(Some(0), Paint::None));
|
||
assert_eq!(a.fill_at(Some(0)).unwrap().paint, Paint::solid(Color::BLACK));
|
||
a.effects_mut(Some(1)).unwrap().push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: true });
|
||
assert_eq!(a.effects_at(Some(1)).unwrap().len(), 1);
|
||
assert!(a.effects_at(None).unwrap().is_empty() && a.effects_mut(Some(3)).is_none());
|
||
assert_eq!((a.items[1].kind_name(), a.items[2].kind_name()), ("stroke", "fill"));
|
||
}
|
||
|
||
#[test]
|
||
fn basic_means_one_plain_fill_and_stroke() {
|
||
let stroke = || AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::BLACK), 1.0));
|
||
let mut a = Appearance { items: vec![stroke(), stroke()], ..Appearance::default() };
|
||
assert!(!a.is_basic(), "two strokes");
|
||
a.items.pop();
|
||
assert!(a.is_basic() && Appearance::default().is_basic());
|
||
let mut b = Appearance::default_art();
|
||
b.stroke_mut().unwrap().visible = false;
|
||
assert!(!b.is_basic(), "a hidden stroke");
|
||
let mut c = Appearance::default_art();
|
||
c.fill_mut().unwrap().opacity = 0.5;
|
||
assert!(!c.is_basic(), "fill opacity");
|
||
let mut d = Appearance::default_art();
|
||
d.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None)));
|
||
assert!(!d.is_basic(), "two fills");
|
||
let mut e = Appearance::default_art();
|
||
e.effects.push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: true });
|
||
assert!(!e.is_basic(), "an effect");
|
||
}
|
||
|
||
#[test]
|
||
fn set_creates_missing() {
|
||
let mut a = Appearance::default();
|
||
a.set_fill(Paint::solid(Color::BLACK));
|
||
a.set_stroke(Paint::solid(Color::WHITE));
|
||
assert_eq!(a.items.len(), 2);
|
||
assert!(matches!(a.items[0], AppearanceItem::Fill(_)));
|
||
}
|
||
|
||
/// #852: pen pressure is kept simplified along the stroke and read back by position.
|
||
#[test]
|
||
fn pressure_profile_samples_simplify_and_interpolate() {
|
||
// A steady ramp keeps only its ends; a bump keeps its peak.
|
||
let ramp = PressureProfile::from_samples((0..=100).map(|i| (i as f64 / 100.0, i as f64 / 100.0))).unwrap();
|
||
assert_eq!(ramp.points, vec![(0.0, 0.0), (1.0, 1.0)]);
|
||
assert!((ramp.at(0.25) - 0.25).abs() < 1e-9);
|
||
let bump = PressureProfile::from_samples([(0.0, 0.2), (0.3, 0.2), (0.5, 0.9), (0.7, 0.2), (1.0, 0.2)]).unwrap();
|
||
assert!(bump.points.contains(&(0.5, 0.9)) && (bump.at(0.4) - 0.55).abs() < 1e-9, "{bump:?}");
|
||
// Junk is clamped or dropped; positions never go back; nothing at all is no profile.
|
||
let junk = PressureProfile::from_samples([(f64::NAN, 0.5), (0.5, 7.0), (0.2, -1.0), (2.0, f64::INFINITY)]).unwrap();
|
||
assert_eq!(junk.points, vec![(0.5, 1.0), (0.5, 0.0)]);
|
||
assert!(PressureProfile::from_samples([(f64::NAN, 0.5)]).is_none());
|
||
assert_eq!(PressureProfile::default().at(0.3), PressureProfile::MID);
|
||
// A long noisy stroke stays bounded.
|
||
let noisy = PressureProfile::from_samples((0..1_000_000).map(|i| (i as f64 / 1e6, (i % 2) as f64))).unwrap();
|
||
assert!(noisy.points.len() <= PressureProfile::MAX_POINTS);
|
||
// Out-of-order points (a hand-edited file) still read within 0..1.
|
||
let odd = PressureProfile { points: vec![(1.0, 5.0), (0.0, -3.0)] };
|
||
assert!((0.0..=1.0).contains(&odd.at(0.5)));
|
||
}
|
||
|
||
#[test]
|
||
fn pressure_profile_extends_and_reverses() {
|
||
let old = PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] };
|
||
let added = PressureProfile { points: vec![(0.0, 1.0), (1.0, 0.0)] };
|
||
// A 30 pt path continued by 10 pt: its ramp fills the first three quarters.
|
||
let joined = PressureProfile::extended(Some(&old), 30.0, Some(&added), 10.0).unwrap();
|
||
assert!((joined.at(0.75) - 1.0).abs() < 1e-9 && (joined.at(0.375) - 0.5).abs() < 1e-9 && joined.at(1.0) == 0.0, "{joined:?}");
|
||
// A side without pressure is half way.
|
||
let half = PressureProfile::extended(None, 10.0, Some(&added), 10.0).unwrap();
|
||
assert_eq!(half.at(0.25), PressureProfile::MID);
|
||
assert!(PressureProfile::extended(None, 10.0, None, 10.0).is_none());
|
||
assert_eq!(PressureProfile::extended(Some(&old), 0.0, None, f64::NAN), Some(old.clone()));
|
||
assert_eq!(old.reversed().points, vec![(0.0, 1.0), (1.0, 0.0)]);
|
||
}
|
||
|
||
/// #764: a pen's bearing or barrel rotation is kept the shorter way round between samples, so
|
||
/// 170° then −170° turns through 180°, not through 0°.
|
||
#[test]
|
||
fn angle_profiles_join_samples_the_shorter_way_round() {
|
||
let across = AngleProfile::from_samples([(0.0, 170.0), (1.0, -170.0)]).unwrap();
|
||
assert_eq!(across.points, vec![(0.0, 170.0), (1.0, 190.0)]);
|
||
assert_eq!(across.at(0.5), 180.0);
|
||
assert!((across.at(0.75) + 175.0).abs() < 1e-9, "{}", across.at(0.75));
|
||
// Turns past a whole turn keep counting, and read back within −180..180°.
|
||
let spin = AngleProfile::from_samples((0..=40).map(|i| (f64::from(i) / 40.0, f64::from(i * 30) - 180.0))).unwrap();
|
||
assert!((spin.points.last().unwrap().1 - 1380.0).abs() < 1e-9, "{spin:?}");
|
||
assert!((spin.at(1.0) + 60.0).abs() < 1e-9 && spin.points.len() == 2, "{spin:?}");
|
||
// Junk is dropped; nothing at all is no profile, and no profile reads 0°.
|
||
let junk = AngleProfile::from_samples([(f64::NAN, 5.0), (0.5, f64::INFINITY), (0.2, 400.0)]).unwrap();
|
||
assert_eq!(junk.points, vec![(0.2, 40.0)]);
|
||
assert!(AngleProfile::from_samples([(0.5, f64::NAN)]).is_none());
|
||
assert_eq!(AngleProfile::default().at(0.3), 0.0);
|
||
let noisy = AngleProfile::from_samples((0..1_000_000).map(|i| (f64::from(i) / 1e6, f64::from(i % 2) * 90.0))).unwrap();
|
||
assert!(noisy.points.len() <= PressureProfile::MAX_POINTS);
|
||
// Continued: the old part, then the new one; a side without an angle is 0°. Reversed, the
|
||
// angles stay what they were.
|
||
let old = AngleProfile { points: vec![(0.0, 90.0), (1.0, 90.0)] };
|
||
let joined = AngleProfile::extended(Some(&old), 30.0, None, 10.0).unwrap();
|
||
assert!((joined.at(0.5) - 90.0).abs() < 1e-9 && joined.at(1.0) == 0.0, "{joined:?}");
|
||
assert!(AngleProfile::extended(None, 10.0, None, 10.0).is_none());
|
||
assert_eq!(AngleProfile::extended(Some(&old), 0.0, None, 0.0), Some(old.clone()));
|
||
assert_eq!(across.reversed().points, vec![(0.0, 190.0), (1.0, 170.0)]);
|
||
// A part that turned more than half a turn between two of its samples keeps that turn when
|
||
// the path is continued, and so does the new part.
|
||
let quarter_turns = AngleProfile::from_samples([(0.0, 0.0), (1.0 / 3.0, 90.0), (2.0 / 3.0, 180.0), (1.0, 270.0)]).unwrap();
|
||
assert_eq!(quarter_turns.points, vec![(0.0, 0.0), (1.0, 270.0)]);
|
||
let added = AngleProfile { points: vec![(0.0, -80.0), (1.0, 280.0)] };
|
||
let joined = AngleProfile::extended(Some(&quarter_turns), 10.0, Some(&added), 10.0).unwrap();
|
||
assert!((joined.at(0.25) - 135.0).abs() < 1e-9, "{joined:?}");
|
||
assert!((joined.at(0.75) - 100.0).abs() < 1e-9, "{joined:?}");
|
||
}
|
||
|
||
/// Strokes saved before pen pressure load as they were, and are written without it.
|
||
#[test]
|
||
fn strokes_without_pressure_round_trip_unchanged() {
|
||
let json = serde_json::to_value(StrokeLayer::new(Paint::None, 2.0)).unwrap();
|
||
for key in ["pressure", "tilt", "bearing", "rotation"] {
|
||
assert!(json.get(key).is_none(), "{key}");
|
||
}
|
||
let st: StrokeLayer = serde_json::from_value(json).unwrap();
|
||
assert_eq!(st.pressure, None);
|
||
let pressed = StrokeLayer { pressure: Some(PressureProfile::sample()), ..st };
|
||
let back: StrokeLayer = serde_json::from_value(serde_json::to_value(&pressed).unwrap()).unwrap();
|
||
assert_eq!(back, pressed);
|
||
let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
|
||
ap.stroke_mut().unwrap().pressure = Some(PressureProfile::sample());
|
||
assert_eq!(ap.without_pressure().stroke().unwrap().pressure, None);
|
||
// The pen's tilt, bearing and rotation load, save and stay behind the same way.
|
||
let posed = StrokeLayer {
|
||
tilt: Some(PressureProfile::sample()),
|
||
bearing: Some(AngleProfile::sample()),
|
||
rotation: Some(AngleProfile { points: vec![(0.0, -45.0)] }),
|
||
..back
|
||
};
|
||
let again: StrokeLayer = serde_json::from_value(serde_json::to_value(&posed).unwrap()).unwrap();
|
||
assert_eq!(again, posed);
|
||
let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
|
||
*ap.stroke_mut().unwrap() = posed;
|
||
let st = ap.without_pressure().stroke().cloned().unwrap();
|
||
assert_eq!((st.pressure, st.tilt, st.bearing, st.rotation), (None, None, None, None));
|
||
}
|
||
|
||
/// The Lens profile's widths at its middle, a quarter of the way along and past its end.
|
||
#[test]
|
||
fn profile_interp() {
|
||
let p = WidthProfile::lens();
|
||
assert_eq!(p.at(0.5), (1.0, 1.0));
|
||
// Half way up the lens the width curves above the straight ramp (0.5), flattening into its
|
||
// widest point (#5714).
|
||
assert_eq!(p.at(0.25), (0.625, 0.625));
|
||
assert_eq!(p.at(2.0), (0.0, 0.0));
|
||
}
|
||
|
||
#[test]
|
||
fn profile_presets_round_trip_their_ids() {
|
||
for p in WidthProfile::PRESETS {
|
||
let prof = WidthProfile::preset(p.id).unwrap();
|
||
assert_eq!(prof.preset_id(), Some(p.id));
|
||
assert_eq!(WidthProfile::id_of(Some(&prof)), p.id);
|
||
}
|
||
assert_eq!(WidthProfile::id_of(None), "uniform");
|
||
assert_eq!(WidthProfile::id_of(Some(&WidthProfile { points: vec![(0.0, 0.3, 0.3)] })), "custom");
|
||
assert!(WidthProfile::preset("nope").is_none());
|
||
assert_eq!(WidthProfile::lens().points, vec![(0.0, 0.0, 0.0), (0.5, 1.0, 1.0), (1.0, 0.0, 0.0)]);
|
||
}
|
||
|
||
#[test]
|
||
fn arrowhead_names_are_stable_and_every_one_is_listed_once() {
|
||
// Saved files store these names: they may only ever be appended to.
|
||
const SAVED: [&str; 41] = [
|
||
"Triangle",
|
||
"TriangleOpen",
|
||
"Circle",
|
||
"CircleOpen",
|
||
"Square",
|
||
"SquareOpen",
|
||
"Bar",
|
||
"Diamond",
|
||
"Arrow",
|
||
"ArrowOpen",
|
||
"Barbed",
|
||
"HalfArrowLeft",
|
||
"HalfArrowRight",
|
||
"Concave",
|
||
"DoubleBar",
|
||
"Feather",
|
||
"DotOnBar",
|
||
"Chevron",
|
||
"DoubleArrow",
|
||
"Target",
|
||
"Star",
|
||
"Cross",
|
||
"Plus",
|
||
"Hexagon",
|
||
"HexagonOpen",
|
||
"Tag",
|
||
"TagOpen",
|
||
"HalfCircle",
|
||
"Drop",
|
||
"Slash",
|
||
"DoubleSlash",
|
||
"DiamondOpen",
|
||
"TriangleReverse",
|
||
"Swallowtail",
|
||
"Bracket",
|
||
"Fork",
|
||
"Leaf",
|
||
"Kite",
|
||
"TriangleBar",
|
||
"Oval",
|
||
"LineArrow",
|
||
];
|
||
for name in SAVED {
|
||
let a: Arrowhead = serde_json::from_value(serde_json::json!(name)).unwrap();
|
||
assert_eq!(serde_json::to_value(a).unwrap(), name);
|
||
assert_eq!(Arrowhead::ALL.iter().filter(|x| **x == a).count(), 1, "{name} in the menu once");
|
||
}
|
||
let labels: std::collections::HashSet<&str> = Arrowhead::ALL.iter().map(|a| a.label()).collect();
|
||
assert_eq!(labels.len(), Arrowhead::ALL.len(), "labels are distinct");
|
||
}
|
||
|
||
#[test]
|
||
fn arrow_align_defaults_to_extend_and_round_trips() {
|
||
let mut st = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
|
||
assert_eq!(st.arrow_align, ArrowAlign::Extend);
|
||
// The default is not written, so older readers see the same JSON as before.
|
||
assert!(!serde_json::to_string(&st).unwrap().contains("arrow_align"));
|
||
let old: StrokeLayer = serde_json::from_str(r#"{"paint":{"type":"none"},"width":2.0}"#).unwrap();
|
||
assert_eq!(old.arrow_align, ArrowAlign::Extend);
|
||
st.arrow_align = ArrowAlign::Tip;
|
||
let back: StrokeLayer = serde_json::from_str(&serde_json::to_string(&st).unwrap()).unwrap();
|
||
assert_eq!(back, st);
|
||
}
|
||
|
||
#[test]
|
||
fn outset_covers_arrowheads() {
|
||
let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 4.0);
|
||
a.stroke_mut().unwrap().join = LineJoin::Round;
|
||
assert_eq!(a.outset(), 2.0);
|
||
let st = a.stroke_mut().unwrap();
|
||
st.end_arrow = Some(Arrowhead::Triangle);
|
||
st.arrow_scale = (100.0, 200.0);
|
||
assert_eq!(st.arrow_weight(false), 4.0);
|
||
assert_eq!(st.arrow_weight(true), 8.0);
|
||
let reach = Arrowhead::Triangle.reach();
|
||
assert_eq!((st.head_reach(false), st.head_reach(true)), (0.0, reach * 8.0 + 2.0));
|
||
// A 32 pt head whose tip sits up to its length (plus the cap) past the end point.
|
||
assert_eq!(a.outset(), reach * 8.0 + 2.0);
|
||
// The line arrow's arms spread twice as wide, so it reaches further from its tip.
|
||
a.stroke_mut().unwrap().end_arrow = Some(Arrowhead::LineArrow);
|
||
assert!(Arrowhead::LineArrow.reach() > reach);
|
||
assert_eq!(a.outset(), Arrowhead::LineArrow.reach() * 8.0 + 2.0);
|
||
a.stroke_mut().unwrap().end_arrow = Some(Arrowhead::Triangle);
|
||
a.stroke_mut().unwrap().width = 0.01;
|
||
assert_eq!(a.stroke().unwrap().arrow_weight(true), 0.25, "heads keep a minimum size");
|
||
}
|
||
|
||
#[test]
|
||
fn outset_depends_on_align() {
|
||
let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 10.0);
|
||
a.stroke_mut().unwrap().join = LineJoin::Round;
|
||
assert_eq!(a.outset(), 5.0);
|
||
a.stroke_mut().unwrap().align = StrokeAlign::Outside;
|
||
assert_eq!(a.outset(), 10.0);
|
||
// Open paths stroke inside-aligned strokes centred.
|
||
a.stroke_mut().unwrap().align = StrokeAlign::Inside;
|
||
assert_eq!(a.outset(), 5.0);
|
||
assert_eq!((a.stroke().unwrap().side_reach(true), a.stroke().unwrap().body(true)), (0.0, (10.0, Some(true))));
|
||
}
|
||
|
||
#[test]
|
||
fn outset_covers_miter_spikes_projecting_caps_and_profile_maxima() {
|
||
let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 2.0);
|
||
// Miter joins can spike out to the limit × half the weight.
|
||
assert_eq!(a.outset(), 10.0);
|
||
let st = a.stroke_mut().unwrap();
|
||
st.join = LineJoin::Bevel;
|
||
st.cap = LineCap::Square;
|
||
assert!((a.outset() - std::f64::consts::SQRT_2).abs() < 1e-12, "a projecting cap's corner");
|
||
let st = a.stroke_mut().unwrap();
|
||
st.cap = LineCap::Round;
|
||
st.profile = Some(WidthProfile { points: vec![(0.0, 0.5, 2.5), (1.0, 1.0, 1.0)] });
|
||
assert_eq!(st.profile_max(), 2.5);
|
||
assert_eq!(a.outset(), 2.5);
|
||
a.stroke_mut().unwrap().paint = Paint::None;
|
||
assert_eq!(a.outset(), 0.0, "an unpainted stroke");
|
||
}
|
||
|
||
#[test]
|
||
fn contents_slot_follows_item_edits_and_round_trips() {
|
||
let fill = || AppearanceItem::Fill(FillLayer::new(Paint::None));
|
||
let mut a = Appearance { items: vec![fill(), fill(), fill()], ..Appearance::default() };
|
||
assert_eq!((a.contents_at(), a.split_contents().1.len()), (0, 3), "all items above by default");
|
||
a.set_contents_at(1);
|
||
assert!(!a.is_basic());
|
||
// [0 | 1 2]: removing below shifts the slot, removing above doesn't.
|
||
a.remove_item(2);
|
||
assert_eq!(a.contents_at(), 1);
|
||
a.remove_item(0);
|
||
assert_eq!((a.contents_at(), a.contents_index), (0, None));
|
||
// Inserting next to the slot joins the item below it.
|
||
a.items.push(fill());
|
||
a.set_contents_at(1); // [0 | 1]
|
||
a.insert_item(1, fill());
|
||
assert_eq!(a.contents_at(), 2);
|
||
a.insert_item(3, fill()); // [0 1 | 2 3]
|
||
assert_eq!(a.contents_at(), 2);
|
||
// Moves keep their side when landing next to the slot, cross it otherwise.
|
||
assert_eq!(a.move_item(3, 2), Some(2));
|
||
assert_eq!(a.contents_at(), 2, "stays above");
|
||
a.move_item(3, 0);
|
||
assert_eq!(a.contents_at(), 3, "crossed below");
|
||
a.move_item(0, 3);
|
||
assert_eq!(a.contents_at(), 2, "crossed above");
|
||
assert_eq!(a.move_item(9, 0), None);
|
||
// Saved only when set; older files load with every item above.
|
||
let json = serde_json::to_string(&a).unwrap();
|
||
assert!(json.contains("\"contents_index\":2"));
|
||
assert_eq!(serde_json::from_str::<Appearance>(&json).unwrap(), a);
|
||
let old: Appearance = serde_json::from_str(r#"{"items":[]}"#).unwrap();
|
||
assert_eq!(old.contents_index, None);
|
||
assert!(!serde_json::to_string(&Appearance::default_art()).unwrap().contains("contents_index"));
|
||
}
|
||
|
||
/// The issue's case (#4174): two circles with different fills, the same stroke and the same
|
||
/// effect share the stroke and the effect, not the fills; a shared stroke at another place in one
|
||
/// stack maps to its own index there; nothing shared shares nothing; equal stacks share all.
|
||
#[test]
|
||
fn mixed_appearances_share_their_equal_rows() {
|
||
let stroke = AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 11.0));
|
||
let fill = |c: Color| AppearanceItem::Fill(FillLayer::new(Paint::solid(c)));
|
||
let feather = Effect { id: "stylize.feather".into(), params: serde_json::json!({"radius": 5}), visible: true };
|
||
let a = Appearance { items: vec![fill(Color::rgb(1.0, 1.0, 0.0)), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
|
||
let b = Appearance { items: vec![fill(Color::rgb(1.0, 0.0, 0.0)), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
|
||
let shared = SharedStack::of(&[&a, &b]);
|
||
assert_eq!(shared.items, vec![vec![1, 1]], "the stroke, not the fills");
|
||
assert_eq!(shared.effects, vec![vec![0, 0]]);
|
||
// The stroke under an extra fill in the second object.
|
||
let c =
|
||
Appearance { items: vec![fill(Color::BLACK), fill(Color::WHITE), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
|
||
let shared = SharedStack::of(&[&a, &c]);
|
||
assert_eq!(shared.items, vec![vec![1, 2]]);
|
||
assert_eq!(shared.item_in(1, 1), Some(2));
|
||
assert_eq!(shared.item_in(0, 1), None);
|
||
// Nothing alike.
|
||
let d = Appearance { items: vec![fill(Color::WHITE)], ..Appearance::default() };
|
||
let none = SharedStack::of(&[&a, &d]);
|
||
assert!(none.items.is_empty() && none.effects.is_empty());
|
||
// Equal stacks share everything, each row where it is.
|
||
assert_eq!(SharedStack::of(&[&a, &a.clone(), &a.clone()]).items, vec![vec![0, 0, 0], vec![1, 1, 1]]);
|
||
}
|
||
|
||
/// Matches keep their stacking order: two equal rows in the opposite order match once.
|
||
#[test]
|
||
fn aligned_rows_never_cross() {
|
||
assert_eq!(align(&[1, 2], &[2, 1], |a, b| a == b).iter().filter(|m| m.is_some()).count(), 1);
|
||
assert_eq!(align(&[1, 2, 3], &[9, 1, 3], |a, b| a == b), vec![Some(1), None, Some(2)]);
|
||
assert_eq!(align::<i32>(&[], &[1], |a, b| a == b), Vec::<Option<usize>>::new());
|
||
}
|