Skip to content

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

refactor(engine): move cmd/threads.rs tests to cmd/threads/tests.rs

aiongge8a069ebc2c6
diff --git a/crates/engine/src/cmd/threads.rs b/crates/engine/src/cmd/threads.rs
index 420856962..4382ae0b2 100644
--- a/crates/engine/src/cmd/threads.rs
+++ b/crates/engine/src/cmd/threads.rs
@@ -708,1272 +708,4 @@ fn break_thread(s: &mut Session, p: &Value) -> Result<Value> {
}
#[cfg(test)]
-mod tests {
- use super::*;
-
- const TEXT: &str = "The quick brown fox jumps over the lazy dog and keeps running far beyond the first frame of this story. ";
-
- fn setup() -> (Session, u64, u64) {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let a = s.execute("text.create", &json!({"x": 10, "y": 10, "text": TEXT.repeat(4), "area": {"width": 150, "height": 60}})).unwrap()["id"]
- .as_u64()
- .unwrap();
- let b = s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap()["id"].as_u64().unwrap();
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- (s, a, b)
- }
-
- fn text(s: &Session, id: u64) -> String {
- match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
- NodeKind::Text(t) => t.plain_text(),
- _ => panic!("not text"),
- }
- }
-
- #[test]
- fn thread_flows_reflows_on_edit_and_survives_delete() {
- let (mut s, a, b) = setup();
- s.execute("text.thread.create", &json!({})).unwrap();
- let (ta, tb) = (text(&s, a), text(&s, b));
- assert!(!ta.is_empty() && !tb.is_empty());
- assert_eq!(format!("{ta}{tb}"), TEXT.repeat(4));
- // Editing the first frame re-flows into the second.
- s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "NEW "})).unwrap();
- assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), format!("NEW {}", TEXT.repeat(4)));
- assert_ne!(text(&s, b), tb, "the overflow moved on");
- // Deleting the first frame moves all its text into the second.
- s.execute("select.set", &json!({"ids": [a]})).unwrap();
- s.execute("edit.clear", &json!({})).unwrap();
- assert_eq!(text(&s, b), format!("NEW {}", TEXT.repeat(4)));
- assert!(s.doc().unwrap().doc.text_threads.is_empty(), "a one-frame thread is no thread");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(s.doc().unwrap().doc.text_threads.len(), 1);
- }
-
- #[test]
- fn edits_copy_only_the_stories_of_threads_whose_frames_changed() {
- let (mut s, a, b) = setup();
- s.execute("text.thread.create", &json!({})).unwrap();
- let c = s.execute("text.create", &json!({"x": 10, "y": 200, "text": TEXT.repeat(2), "area": {"width": 150, "height": 40}})).unwrap()["id"]
- .as_u64()
- .unwrap();
- let d = s.execute("shape.rectangle", &json!({"x": 200, "y": 220, "width": 150, "height": 60})).unwrap()["id"].as_u64().unwrap();
- s.execute("select.set", &json!({"ids": [c, d]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- let texts = |s: &Session| [a, b, c, d].map(|id| text(s, id));
- let copied = || COPIED.with(std::cell::Cell::get);
- let (shown, start) = (texts(&s), copied());
- // A rectangle drawn, moved and dragged beside the threads changes none of their frames.
- let r = s.execute("shape.rectangle", &json!({"x": 400, "y": 250, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
- s.execute("select.set", &json!({"ids": [r]})).unwrap();
- s.execute("object.move", &json!({"dx": 5, "dy": 0})).unwrap();
- s.begin_interaction("Move").unwrap();
- for dx in 1..=3 {
- s.preview("object.move", &json!({"dx": dx, "dy": 0})).unwrap();
- }
- s.commit_interaction().unwrap();
- assert_eq!(copied(), start, "edits beside the threads copied their stories");
- assert_eq!(texts(&s), shown);
- // Typing in the first thread copies and re-flows that thread's story only.
- s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "NEW "})).unwrap();
- assert_eq!(copied(), start + 1);
- assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), format!("NEW {}", TEXT.repeat(4)));
- assert_eq!(texts(&s)[2..], shown[2..]);
- let ids = |t: [u64; 2]| t.map(NodeId).to_vec();
- assert_eq!(s.doc().unwrap().doc.text_threads, [ids([a, b]), ids([c, d])]);
- }
-
- /// Time edits of a story of 50,000 characters threaded through 8 frames, each frame wrapping
- /// around an ellipse, with one style, a style change every 10 words and a style change at every
- /// word: 21 characters typed into the first frame, then 200 moves of a rectangle below the
- /// frames and 200 frames of a drag of it.
- /// Run with `cargo test --release -p vectorcraft-engine --lib threaded_story_edit_timing -- --ignored --nocapture`.
- #[test]
- #[ignore = "manual timing probe; wall-clock performance depends on machine load"]
- fn threaded_story_edit_timing() {
- fn median(s: &mut Session, n: u32, f: &dyn Fn(&mut Session, f64)) -> f64 {
- let mut ms: Vec<f64> = (1..=n)
- .map(|i| {
- let start = std::time::Instant::now();
- f(s, f64::from(i));
- start.elapsed().as_secs_f64() * 1000.0
- })
- .collect();
- ms.sort_by(f64::total_cmp);
- ms[ms.len() / 2]
- }
- let story = format!("{}\n", TEXT.repeat(6).trim_end()).repeat(81)[..50_000].to_string();
- for words in [0, 10, 1] {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 4400, "height": 1200})).unwrap();
- let area = json!({"width": 500, "height": 900});
- let first = s.execute("text.create", &json!({"x": 20, "y": 20, "text": story, "size": 9, "area": area})).unwrap()["id"].as_u64().unwrap();
- if words > 0 {
- s.edit("Restyle", |d, _| {
- let Some(NodeKind::Text(t)) = d.node_mut(NodeId(first)).map(|n| &mut n.kind) else { panic!("not text") };
- let style = t.runs[0].style.clone();
- let pieces: Vec<&str> = story.split_inclusive([' ', '\n']).collect();
- t.runs = pieces
- .chunks(words)
- .enumerate()
- .map(|(i, c)| {
- let mut run = TextRun::new(c.concat(), style.clone());
- run.style.underline = i % 2 == 1;
- run
- })
- .collect();
- refresh_bounds(t);
- Ok(())
- })
- .unwrap();
- }
- let mut ids = vec![first];
- for k in 1..8 {
- let frame = json!({"x": 20 + k * 540, "y": 20, "width": 500, "height": 900});
- ids.push(s.execute("shape.rectangle", &frame).unwrap()["id"].as_u64().unwrap());
- }
- s.execute("select.set", &json!({"ids": ids})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- for k in 0..8 {
- let e = s.execute("shape.ellipse", &json!({"x": 195 + k * 540, "y": 395, "width": 150, "height": 150})).unwrap()["id"].clone();
- s.execute("object.textWrap.make", &json!({"ids": [e]})).unwrap();
- }
- let r = s.execute("shape.rectangle", &json!({"x": 20, "y": 1100, "width": 30, "height": 30})).unwrap()["id"].clone();
- s.execute("select.set", &json!({"ids": [r]})).unwrap();
- let typing = median(&mut s, 21, &|s, _| {
- s.execute("text.editRange", &json!({"id": first, "start": 0, "end": 0, "insert": "x"})).unwrap();
- });
- let edit = median(&mut s, 200, &|s, _| {
- s.execute("object.move", &json!({"dx": 0.5, "dy": 0})).unwrap();
- });
- s.begin_interaction("Move").unwrap();
- let frame = median(&mut s, 200, &|s, i| {
- s.preview("object.move", &json!({"dx": i * 0.25, "dy": 0})).unwrap();
- });
- s.commit_interaction().unwrap();
- let d = &s.doc().unwrap().doc;
- let runs: usize = ids.iter().filter_map(|id| text_of(d, NodeId(*id))).map(|t| t.runs.len()).sum();
- println!("{runs} runs in 8 frames: typing {typing:.1} ms, a move below them {edit:.3} ms, a drag frame {frame:.3} ms (medians)");
- }
- }
-
- fn new_id(v: Value) -> u64 {
- v["id"].as_u64().unwrap()
- }
-
- fn threads(s: &Session) -> Vec<Vec<u64>> {
- s.doc().unwrap().doc.text_threads.iter().map(|t| t.iter().map(|i| i.0).collect()).collect()
- }
-
- /// Bounds of area type `id`'s frame on the page.
- fn frame_box(s: &Session, id: u64) -> vectorcraft_geom::Rect {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("not area type") };
- let TextKind::Area { frame } = &t.kind else { panic!("not area type") };
- t.xf.transform_rect_bbox(frame.bounds().unwrap())
- }
-
- /// #2572: the text loaded from an out port threads into a closed path, into a new frame of the
- /// first one's shape and size at a point, and into a new rectangle, each in one undo step.
- #[test]
- fn add_threads_into_a_path_a_frame_at_a_point_and_a_rectangle() {
- let (mut s, a, b) = setup();
- assert_eq!(new_id(s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap()), b);
- assert_eq!(threads(&s), [[a, b]]);
- assert!(!text(&s, b).is_empty(), "the overflow flowed into the path");
- assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), TEXT.repeat(4));
- assert_eq!(s.doc().unwrap().selection.objects, [NodeId(a), NodeId(b)]);
- s.execute("edit.undo", &json!({})).unwrap();
- assert!(threads(&s).is_empty());
- assert!(matches!(s.doc().unwrap().doc.node(NodeId(b)).unwrap().kind, NodeKind::Path { .. }), "undo gives the path back");
-
- let c = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [400, 200]})).unwrap());
- assert_eq!(frame_box(&s, c), vectorcraft_geom::Rect::new(400.0, 200.0, 550.0, 260.0), "the first frame's size, its top-left at the click");
- let d = new_id(s.execute("text.thread.add", &json!({"from": c, "rect": [10, 100, 300, 150]})).unwrap());
- assert_eq!(frame_box(&s, d), vectorcraft_geom::Rect::new(10.0, 100.0, 310.0, 250.0));
- assert_eq!(threads(&s), [[a, c, d]], "each new frame comes after the one it was threaded from");
- assert_eq!(format!("{}{}{}", text(&s, a), text(&s, c), text(&s, d)), TEXT.repeat(4));
- assert!(!text(&s, d).is_empty());
- // A frame threaded from the middle of a thread goes in after it.
- let e = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [0, 0]})).unwrap());
- assert_eq!(threads(&s), [[a, e, c, d]]);
- s.execute("edit.undo", &json!({})).unwrap();
- assert!(s.doc().unwrap().doc.node(NodeId(e)).is_none());
- assert_eq!(threads(&s), [[a, c, d]]);
- }
-
- /// #2572: the text loaded from an in port threads back: the new frame or the path clicked comes
- /// before the frame it was loaded from, so the story starts there and flows on into it; in the
- /// middle of a thread the new frame goes in between, each in one undo step.
- #[test]
- fn add_before_threads_the_story_from_the_new_frame_into_the_clicked_one() {
- let (mut s, a, b) = setup();
- let c = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [400, 200], "before": true})).unwrap());
- assert_eq!(threads(&s), [[c, a]]);
- assert_eq!(frame_box(&s, c), vectorcraft_geom::Rect::new(400.0, 200.0, 550.0, 260.0), "the clicked frame's size at the click");
- assert!(TEXT.repeat(4).starts_with(&text(&s, c)) && !text(&s, c).is_empty(), "the story starts in the new frame: {:?}", text(&s, c));
- assert_eq!(format!("{}{}", text(&s, c), text(&s, a)), TEXT.repeat(4));
- assert_eq!(s.doc().unwrap().selection.objects, [NodeId(a), NodeId(c)]);
- // In between the frame and the one before it.
- let d = new_id(s.execute("text.thread.add", &json!({"from": a, "rect": [10, 100, 300, 150], "before": true})).unwrap());
- assert_eq!(threads(&s), [[c, d, a]]);
- assert_eq!(format!("{}{}{}", text(&s, c), text(&s, d), text(&s, a)), TEXT.repeat(4));
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [[c, a]]);
- // A closed path clicked with the in port's text comes first, with the start of the story.
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(new_id(s.execute("text.thread.add", &json!({"from": a, "to": b, "before": true})).unwrap()), b);
- assert_eq!(threads(&s), [[b, a]]);
- assert!(TEXT.repeat(4).starts_with(&text(&s, b)) && !text(&s, b).is_empty());
- assert_eq!(format!("{}{}", text(&s, b), text(&s, a)), TEXT.repeat(4));
- // `before: false` is the out port's.
- let e = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [0, 0], "before": false})).unwrap());
- assert_eq!(threads(&s), [[b, a, e]]);
- }
-
- /// Type on a path along a line beside the area type of [`setup`].
- fn type_on_a_line(s: &mut Session) -> u64 {
- let line = new_id(s.execute("shape.line", &json!({"x1": 10, "y1": 250, "x2": 110, "y2": 250})).unwrap());
- new_id(s.execute("text.createInPath", &json!({"path": line, "mode": "onPath", "text": ""})).unwrap())
- }
-
- /// Type on a path threads as area type does, in any mix: a story flows from area type along a
- /// path and on into area type, and a new frame threaded from type on a path at a point is type
- /// on a path of the same shape.
- #[test]
- fn type_on_a_path_threads_with_area_type() {
- let (mut s, a, b) = setup();
- let on_path = type_on_a_line(&mut s);
- s.execute("text.thread.add", &json!({"from": a, "to": on_path})).unwrap();
- s.execute("text.thread.add", &json!({"from": on_path, "to": b})).unwrap();
- assert_eq!(threads(&s), [[a, on_path, b]]);
- let shares = [a, on_path, b].map(|id| text(&s, id));
- assert!(shares.iter().all(|t| !t.is_empty()), "each frame takes a share: {shares:?}");
- assert_eq!(shares.concat(), TEXT.repeat(4));
-
- let c = new_id(s.execute("text.thread.add", &json!({"from": on_path, "at": [300, 250]})).unwrap());
- let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(c)).unwrap().kind else { panic!("not text") };
- assert!(matches!(t.kind, TextKind::OnPath { .. }), "type on a path, as the frame it was threaded from");
- assert_eq!(threads(&s), [[a, on_path, c, b]]);
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [[a, on_path, b]]);
- }
-
- /// Type on a path released from its thread gives its text back to the frame before it.
- #[test]
- fn type_on_a_path_is_released_from_its_thread() {
- let (mut s, a, _) = setup();
- let on_path = type_on_a_line(&mut s);
- s.execute("text.thread.add", &json!({"from": a, "to": on_path})).unwrap();
- assert!(!text(&s, on_path).is_empty());
- s.execute("select.set", &json!({"ids": [on_path]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert!(threads(&s).is_empty());
- assert!(text(&s, on_path).is_empty());
- assert_eq!(text(&s, a), TEXT.repeat(4));
- }
-
- /// Area type threaded into from an out port takes the overflow at once, before its own text.
- #[test]
- fn add_into_area_type_flows_the_story_into_it() {
- let (mut s, a, _) = setup();
- let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 100, "text": "Own text.", "area": {"width": 150, "height": 190}})).unwrap());
- s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
- assert_eq!(threads(&s), [[a, c]]);
- assert_eq!(format!("{}{}", text(&s, a), text(&s, c)), format!("{}Own text.", TEXT.repeat(4)));
- assert!(text(&s, c).len() > "Own text.".len(), "the overflow flowed into the frame: {:?}", text(&s, c));
- }
-
- #[test]
- fn add_refuses_bad_params_and_leaves_the_document_alone() {
- let (mut s, a, b) = setup();
- let line = new_id(s.execute("shape.line", &json!({"x1": 0, "y1": 280, "x2": 50, "y2": 290})).unwrap());
- let before = s.doc().unwrap().doc.clone();
- for p in [
- json!({"to": b}),
- json!({"from": b, "at": [0, 0]}),
- json!({"from": 9999, "at": [0, 0]}),
- json!({"from": -1, "at": [0, 0]}),
- json!({"from": a}),
- json!({"from": a, "to": b, "at": [0, 0]}),
- json!({"from": a, "to": a}),
- json!({"from": a, "to": line}),
- json!({"from": a, "to": 9999}),
- json!({"from": a, "at": [0]}),
- json!({"from": a, "at": ["1", 2]}),
- json!({"from": a, "rect": [0, 0, -10, 10]}),
- json!({"from": a, "rect": [0, 0, 10, 0]}),
- json!({"from": a, "rect": [0, 0, 10]}),
- json!({"from": a, "rect": "big"}),
- json!({"from": a, "at": [0, 0], "before": "yes"}),
- json!({"from": a, "at": [0, 0], "before": 1}),
- ] {
- assert!(s.execute("text.thread.add", &p).is_err(), "{p} was accepted");
- assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "{p} changed the document");
- }
- s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap();
- let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 200, "text": "x", "area": {"width": 50, "height": 20}})).unwrap());
- assert!(s.execute("text.thread.add", &json!({"from": c, "to": b})).is_err(), "a frame already threaded");
- }
-
- /// A frame released from a thread that keeps two or more frames gives its text back to them:
- /// the story flows through them once.
- #[test]
- fn release_from_a_longer_thread_keeps_the_story_once() {
- let (mut s, a, b) = setup();
- let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 100, "text": "", "area": {"width": 150, "height": 40}})).unwrap());
- s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
- s.execute("text.thread.add", &json!({"from": c, "to": b})).unwrap();
- assert_eq!(threads(&s), [[a, c, b]]);
- s.execute("select.set", &json!({"ids": [c]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert_eq!(threads(&s), [[a, b]]);
- assert!(text(&s, c).is_empty());
- assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), TEXT.repeat(4));
- }
-
- /// A thread of `n` frames (2 or 3), each showing part of the story: area type `a` of [`setup`],
- /// for 3 an area type frame that is empty until it is threaded, then the rectangle `b`.
- fn thread_of(n: usize) -> (Session, Vec<u64>) {
- let (mut s, a, b) = setup();
- let frames = if n == 3 {
- let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 100, "text": "", "area": {"width": 150, "height": 40}})).unwrap());
- s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
- s.execute("text.thread.add", &json!({"from": c, "to": b})).unwrap();
- vec![a, c, b]
- } else {
- s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap();
- vec![a, b]
- };
- assert_eq!(threads(&s), std::slice::from_ref(&frames));
- assert!(frames.iter().all(|id| !text(&s, *id).is_empty()), "each frame shows part of the story");
- (s, frames)
- }
-
- /// Convert To Point Type on a frame of threaded text takes it out of its thread with the text
- /// it holds, and the other frames keep the text they hold: the story holds each character once.
- /// A thread left with one frame is no thread. Undo threads the frame again.
- #[test]
- fn a_frame_converted_to_point_type_leaves_its_thread_with_its_text() {
- // Soft wraps of the point type become line breaks, so its characters are compared without
- // white space.
- let squeeze = |t: &str| t.split_whitespace().collect::<String>();
- for n in [2, 3] {
- for k in 0..n {
- let (mut s, frames) = thread_of(n);
- let shown: Vec<String> = frames.iter().map(|id| text(&s, *id)).collect();
- let id = frames[k];
- s.execute("type.convertToPointType", &json!({"ids": [id]})).unwrap();
- let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind else { panic!("not text") };
- assert!(matches!(t.kind, TextKind::Point), "{n} frames, frame {k}: point type");
- assert_eq!(squeeze(&text(&s, id)), squeeze(&shown[k]), "{n} frames, frame {k}: the point type keeps its text");
- for (f, before) in frames.iter().zip(&shown).filter(|(f, _)| **f != id) {
- assert_eq!(text(&s, *f), *before, "{n} frames, frame {k}: frame {f} keeps its text");
- }
- let rest: Vec<u64> = frames.iter().copied().filter(|f| *f != id).collect();
- assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{n} frames, frame {k}");
- let all: String = frames.iter().map(|f| text(&s, *f)).collect();
- assert_eq!(squeeze(&all), squeeze(&TEXT.repeat(4)), "{n} frames, frame {k}: each character once");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), std::slice::from_ref(&frames));
- assert_eq!(frames.iter().map(|f| text(&s, *f)).collect::<Vec<_>>(), shown, "{n} frames, frame {k}: undo");
- }
- }
- }
-
- #[test]
- fn release_and_remove() {
- let (mut s, a, b) = setup();
- s.execute("text.thread.create", &json!({})).unwrap();
- let tb = text(&s, b);
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("text.thread.remove", &json!({})).unwrap();
- assert_eq!(text(&s, b), tb, "remove keeps what each frame shows");
- assert!(s.doc().unwrap().doc.text_threads.is_empty());
- s.execute("edit.undo", &json!({})).unwrap();
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert_eq!(text(&s, b), "");
- assert_eq!(text(&s, a), TEXT.repeat(4), "the story returns to the remaining frame");
- }
-
- /// `story` threaded through three area type frames, of 150 by 60, 40 and `last` points, each
- /// showing part of it.
- fn three_frames(story: &str, last: f64) -> (Session, [u64; 3]) {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let frame = |s: &mut Session, x: f64, y: f64, h: f64, text: &str| {
- new_id(s.execute("text.create", &json!({"x": x, "y": y, "text": text, "area": {"width": 150, "height": h}})).unwrap())
- };
- let a = frame(&mut s, 10.0, 10.0, 60.0, story);
- let b = frame(&mut s, 10.0, 100.0, 40.0, "");
- let c = frame(&mut s, 200.0, 10.0, last, "");
- s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap();
- s.execute("text.thread.add", &json!({"from": b, "to": c})).unwrap();
- assert_eq!(threads(&s), [[a, b, c]]);
- assert!([a, b, c].iter().all(|id| !text(&s, *id).is_empty()), "each frame shows part of the story");
- (s, [a, b, c])
- }
-
- fn continues(s: &Session, id: u64) -> bool {
- text_of(&s.doc().unwrap().doc, NodeId(id)).is_some_and(|t| t.first_para_continues)
- }
-
- /// A double-click on a threaded port breaks the thread there: the story flows into the frames
- /// before the break and the frames after it are left empty, still threaded with each other
- /// when two or more. One undo step restores the thread and its text.
- #[test]
- fn break_splits_the_thread_and_the_story_flows_into_the_first_part() {
- let story = TEXT.repeat(12);
- let (mut s, [a, b, c]) = three_frames(&story, 40.0);
- let d = new_id(s.execute("text.create", &json!({"x": 200, "y": 100, "text": "", "area": {"width": 150, "height": 100}})).unwrap());
- s.execute("text.thread.add", &json!({"from": c, "to": d})).unwrap();
- let all = [a, b, c, d];
- let shown: Vec<String> = all.iter().map(|id| text(&s, *id)).collect();
- assert!(shown.iter().all(|t| !t.is_empty()), "each frame shows part of the story");
- let joined = |s: &Session, ids: &[u64]| ids.iter().map(|id| text(s, *id)).collect::<String>();
- // (frame, port, threads after, the frames that hold the story, the frames left empty)
- let cases = [
- (a, "out", vec![vec![b, c, d]], vec![a], vec![b, c, d]),
- (b, "in", vec![vec![b, c, d]], vec![a], vec![b, c, d]),
- (b, "out", vec![vec![a, b], vec![c, d]], vec![a, b], vec![c, d]),
- (d, "in", vec![vec![a, b, c]], vec![a, b, c], vec![d]),
- (c, "out", vec![vec![a, b, c]], vec![a, b, c], vec![d]),
- ];
- for (id, port, after, full, empty) in cases {
- let case = format!("{port} port of {id}");
- s.execute("text.thread.break", &json!({"id": id, "port": port})).unwrap();
- assert_eq!(threads(&s), after, "{case}");
- assert_eq!(joined(&s, &full), story, "{case}: the story flows into the first part");
- assert!(empty.iter().all(|id| text(&s, *id).is_empty()), "{case}: the frames after the break are empty");
- assert!(!continues(&s, empty[0]), "{case}: the first frame after the break starts a paragraph");
- assert!(!continues(&s, a), "{case}: the first frame starts the story");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [all.to_vec()], "{case}: undo");
- assert_eq!(all.iter().map(|id| text(&s, *id)).collect::<Vec<_>>(), shown, "{case}: undo");
- }
- }
-
- #[test]
- fn break_refuses_a_port_with_no_thread_and_bad_params() {
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(4), 200.0);
- let lone = new_id(s.execute("text.create", &json!({"x": 400, "y": 10, "text": "Alone.", "area": {"width": 100, "height": 100}})).unwrap());
- let ids = [a, b, c, lone];
- let shown: Vec<String> = ids.iter().map(|id| text(&s, *id)).collect();
- let before = threads(&s);
- for params in [
- json!({"id": a, "port": "in"}),
- json!({"id": c, "port": "out"}),
- json!({"id": lone, "port": "out"}),
- json!({"id": lone, "port": "in"}),
- json!({"id": a, "port": "up"}),
- json!({"id": a}),
- json!({"port": "out"}),
- json!({"id": 9999, "port": "out"}),
- ] {
- assert!(s.execute("text.thread.break", &params).is_err(), "{params}");
- }
- assert_eq!(threads(&s), before);
- assert_eq!(ids.iter().map(|id| text(&s, *id)).collect::<Vec<_>>(), shown);
- }
-
- /// Whether the document holds area type or type on a path `id`.
- fn is_frame(s: &Session, id: u64) -> bool {
- text_of(&s.doc().unwrap().doc, NodeId(id)).is_some()
- }
-
- /// Create Outlines and Object › Expand on frames of threaded text take them out of their
- /// thread with the text they show, which their outlines draw, and the other frames keep the
- /// text they hold: each character is in the document once. A thread left with one frame is no
- /// thread. Undo threads the frames again.
- #[test]
- fn outlined_frames_leave_their_thread_with_their_text() {
- for command in ["type.createOutlines", "object.expand"] {
- for out in [&[0][..], &[1], &[2], &[0, 2]] {
- let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
- let shown = frames.map(|id| text(&s, id));
- assert_eq!(shown.concat(), TEXT.repeat(4));
- let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
- s.execute("select.set", &json!({"ids": ids})).unwrap();
- s.execute(command, &json!({})).unwrap();
- let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
- for id in &ids {
- assert!(!is_frame(&s, *id), "{command} {out:?}: frame {id} is outlined");
- }
- let st = s.doc().unwrap();
- let groups = st.selection.objects.iter().filter(|g| matches!(st.doc.node(**g).map(|n| &n.kind), Some(NodeKind::Group { .. })));
- assert_eq!(groups.count(), ids.len(), "{command} {out:?}: the outlines are selected");
- for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
- assert_eq!(text(&s, *id), *before, "{command} {out:?}: frame {id} keeps its text");
- }
- assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{command} {out:?}");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [frames], "{command} {out:?}: undo");
- assert_eq!(frames.map(|id| text(&s, id)), shown, "{command} {out:?}: undo");
- }
- }
- }
-
- /// Expand Appearance outlines a frame with an effect, and the frame leaves its thread with the
- /// text it shows; Object › Expand of such a frame expands its appearance first.
- #[test]
- fn a_frame_whose_appearance_expands_leaves_its_thread_with_its_text() {
- for command in ["effect.expandAppearance", "object.expand"] {
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(4), 200.0);
- s.execute("effect.apply", &json!({"effect": "distort.roughen", "ids": [b]})).unwrap();
- let shown = [a, b, c].map(|id| text(&s, id));
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute(command, &json!({})).unwrap();
- assert!(!is_frame(&s, b), "{command}: the frame is outlined");
- assert_eq!((text(&s, a), text(&s, c)), (shown[0].clone(), shown[2].clone()), "{command}: the other frames keep their text");
- assert_eq!(threads(&s), [[a, c]], "{command}");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [[a, b, c]], "{command}: undo");
- assert_eq!([a, b, c].map(|id| text(&s, id)), shown, "{command}: undo");
- }
- }
-
- /// Object › Flatten Transparency outlines frames of threaded text with Convert All Text to
- /// Outlines, and turns transparent frames into flat regions or an image: each such frame leaves
- /// its thread with the text it shows, and the other frames keep the text they hold. Undo threads
- /// the frames again. When the last frame is flattened, the frame before it takes the text it has
- /// no room for.
- #[test]
- fn flattened_frames_leave_their_thread_with_their_text() {
- let cases = [(json!({"textToOutlines": true}), false), (json!({}), true), (json!({"balance": 0}), true)];
- for (options, transparent) in cases {
- for out in [&[0][..], &[1], &[2], &[0, 2]] {
- let case = format!("{options} {out:?}");
- let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
- let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
- if transparent {
- s.execute("transparency.set", &json!({"ids": ids, "opacity": 50})).unwrap();
- }
- let shown = frames.map(|id| text(&s, id));
- assert_eq!(shown.concat(), TEXT.repeat(4));
- let mut p = options.clone();
- p["ids"] = json!(ids);
- s.execute("object.flattenTransparency", &p).unwrap();
- let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
- for id in &ids {
- assert!(!is_frame(&s, *id), "{case}: frame {id} is flattened");
- }
- for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
- assert_eq!(text(&s, *id), *before, "{case}: frame {id} keeps its text");
- }
- assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{case}");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [frames], "{case}: undo");
- assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
- }
- }
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
- let shown = [a, b, c].map(|id| text(&s, id));
- let laid = {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
- vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
- };
- assert!(laid.overflow, "the last frame has more text than it shows");
- let end = laid.lines.last().map_or(0, |l| l.end);
- let hidden = shown[2][end..].trim_start_matches(' ');
- s.execute("object.flattenTransparency", &json!({"ids": [c], "textToOutlines": true})).unwrap();
- assert_eq!(text(&s, a), shown[0]);
- assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "the frame before it keeps its text and takes the rest");
- assert_eq!(threads(&s), [[a, b]]);
- }
-
- /// Expand Appearance keeps type whose only effect is a shadow or Crop Marks as type under a new
- /// id, in a group under the frame's id: the type takes the frame's place in its thread, and
- /// each frame keeps its text, the last frame the text it has no room for too. Type in a group
- /// with Crop Marks keeps its id and stays in its thread.
- #[test]
- fn type_that_expand_appearance_keeps_takes_its_frames_place() {
- for (effect, grouped) in [("stylize.dropShadow", false), ("cropMarks", false), ("cropMarks", true)] {
- for k in [1, 2] {
- let case = format!("{effect} grouped {grouped} frame {k}");
- let (mut s, frames) = three_frames(&TEXT.repeat(12), 100.0);
- let id = frames[k];
- s.execute("select.set", &json!({"ids": [id]})).unwrap();
- let target = if grouped { new_id(s.execute("object.group", &json!({})).unwrap()) } else { id };
- s.execute("effect.apply", &json!({"effect": effect, "item": null, "ids": [target]})).unwrap();
- let shown = frames.map(|id| text(&s, id));
- s.execute("select.set", &json!({"ids": [target]})).unwrap();
- s.execute("effect.expandAppearance", &json!({})).unwrap();
- let mut types = vec![];
- if let Some(n) = s.doc().unwrap().doc.node(NodeId(target)) {
- n.walk(&mut |m| {
- if matches!(m.kind, NodeKind::Text(_)) {
- types.push(m.id.0);
- }
- });
- }
- let [kept] = types[..] else { panic!("{case}: the type is kept: {types:?}") };
- assert_eq!(kept == id, grouped, "{case}: the type has a new id unless it was in a group");
- let mut now = frames;
- now[k] = kept;
- assert_eq!(threads(&s), [now], "{case}: the type takes the frame's place");
- assert_eq!(now.map(|id| text(&s, id)), shown, "{case}: each frame keeps its text");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [frames], "{case}: undo");
- assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
- }
- }
- }
-
- /// The text that does not fit a thread's last frame, which its outlines do not draw, stays in
- /// the story: when the last frame is outlined, the frame before it takes that text after its
- /// own.
- #[test]
- fn outlining_the_last_frame_keeps_the_text_it_has_no_room_for() {
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
- let shown = [a, b, c].map(|id| text(&s, id));
- let laid = {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
- vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
- };
- assert!(laid.overflow, "the last frame has more text than it shows");
- let end = laid.lines.last().map_or(0, |l| l.end);
- let hidden = shown[2][end..].trim_start_matches(' ');
- s.execute("select.set", &json!({"ids": [c]})).unwrap();
- s.execute("type.createOutlines", &json!({})).unwrap();
- assert_eq!(text(&s, a), shown[0]);
- assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "the frame before it keeps its text and takes the rest");
- assert_eq!(threads(&s), [[a, b]]);
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!([a, b, c].map(|id| text(&s, id)), shown);
- }
-
- /// Object › Rasterize on frames of threaded text takes them out of their thread with the text
- /// they show, which the image draws, and the other frames keep the text they hold. Undo threads
- /// the frames again. When the last frame is rasterized, the frame before it takes the text it
- /// has no room for.
- #[test]
- fn rasterized_frames_leave_their_thread_with_their_text() {
- for clip in [false, true] {
- for out in [&[0][..], &[1], &[2], &[0, 2]] {
- let case = format!("clippingMask {clip} {out:?}");
- let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
- let shown = frames.map(|id| text(&s, id));
- assert_eq!(shown.concat(), TEXT.repeat(4));
- let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
- s.execute("select.set", &json!({"ids": ids})).unwrap();
- s.execute("object.rasterize", &json!({"ppi": 36, "clippingMask": clip})).unwrap();
- let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
- for id in &ids {
- assert!(!is_frame(&s, *id), "{case}: frame {id} is rasterized");
- }
- for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
- assert_eq!(text(&s, *id), *before, "{case}: frame {id} keeps its text");
- }
- assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{case}");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [frames], "{case}: undo");
- assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
- }
- }
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
- let shown = [a, b, c].map(|id| text(&s, id));
- let laid = {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
- vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
- };
- assert!(laid.overflow, "the last frame has more text than it shows");
- let end = laid.lines.last().map_or(0, |l| l.end);
- let hidden = shown[2][end..].trim_start_matches(' ');
- s.execute("select.set", &json!({"ids": [c]})).unwrap();
- s.execute("object.rasterize", &json!({"ppi": 36})).unwrap();
- assert_eq!(text(&s, a), shown[0]);
- assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "the frame before it keeps its text and takes the rest");
- assert_eq!(threads(&s), [[a, b]]);
- }
-
- /// Frame `id`'s first line: whether its first paragraph continues from the frame before, where
- /// its text starts from the frame's left edge, and how many list markers it starts with.
- fn first_line(s: &Session, id: u64) -> (bool, f64, usize) {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("not area type") };
- let TextKind::Area { frame } = &t.kind else { panic!("not area type") };
- let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
- let l = &lay.lines[0];
- let x = lay.glyphs[l.glyph_start..l.glyph_end].iter().find(|g| g.len > 0).map_or(f64::NAN, |g| g.origin.x);
- let markers = lay.markers.iter().filter(|m| lay.glyphs[m.glyphs.start].line == 0).count();
- (t.first_para_continues, (x - frame.bounds().unwrap().x0 - 1e-9).round(), markers)
- }
-
- /// A paragraph's first-line indent and bullet belong to its first line, in the frame it starts
- /// in: the frame it continues into starts at its left indent, without the bullet. Re-flowing,
- /// saving and opening keep it. In a frame that is no longer threaded and in a copy of a frame,
- /// the first paragraph has its first-line indent and bullet.
- #[test]
- fn a_paragraph_continued_into_the_next_frame_starts_it_without_its_first_line_indent_or_bullet() {
- let (mut s, a, b) = setup();
- s.execute("text.thread.create", &json!({})).unwrap();
- s.execute("text.setFormat", &json!({"ids": [a, b], "list": "bullet"})).unwrap();
- assert_eq!((first_line(&s, a), first_line(&s, b)), ((false, 18.0, 1), (true, 18.0, 0)));
- s.execute("text.setFormat", &json!({"ids": [a, b], "list": "none", "leftIndent": 0, "firstLineIndent": 24})).unwrap();
- assert_eq!((first_line(&s, a), first_line(&s, b)), ((false, 24.0, 0), (true, 0.0, 0)));
- assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), TEXT.repeat(4));
- // Typing re-flows the story and keeps it.
- s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "NEW "})).unwrap();
- assert_eq!(first_line(&s, b), (true, 0.0, 0));
- // Saved and opened: a native file re-flows its threads, a restored document keeps its text.
- for name in ["thread.vectorcraft", "thread.eps"] {
- let bytes = if name.ends_with(".eps") {
- let r = s.execute("document.exportEps", &json!({})).unwrap();
- vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
- } else {
- vectorcraft_format::save(&s.doc().unwrap().doc, false)
- };
- let r = s.execute("document.open", &json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes)})).unwrap();
- assert_eq!(r["restored"], name.ends_with(".eps"), "{r}");
- assert_eq!(threads(&s), [[a, b]], "{name}");
- assert_eq!((first_line(&s, a), first_line(&s, b)), ((false, 24.0, 0), (true, 0.0, 0)), "{name}");
- }
- // A copy of the second frame is in no thread, and starts with the indent.
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- let copy = s.execute("edit.duplicate", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
- assert_eq!((first_line(&s, b), first_line(&s, copy)), ((true, 0.0, 0), (false, 24.0, 0)));
- // …and so is a pasted one, and each copy's cached bounds and baselines are its own layout's.
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("edit.copy", &json!({})).unwrap();
- let pasted = s.execute("edit.paste", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
- let dragged = s.execute("layer.move", &json!({"ids": [b], "target": a, "place": "above", "copy": true})).unwrap()["ids"][0].as_u64().unwrap();
- assert_eq!((first_line(&s, pasted), first_line(&s, dragged)), ((false, 24.0, 0), (false, 24.0, 0)));
- // Every text object in the document has the cached bounds and baselines of its own layout.
- let own_caches = |s: &Session, what: &str| {
- let mut texts = vec![];
- s.doc().unwrap().doc.walk(|n| {
- if let NodeKind::Text(t) = &n.kind {
- texts.push((n.id, t));
- }
- });
- for (id, t) in texts {
- let mut fresh = (**t).clone();
- refresh_bounds(&mut fresh);
- assert!(t.cached_bounds.is_some() && t.cached_bounds == fresh.cached_bounds, "{what}: {id:?}");
- assert_eq!(t.cached_baselines, fresh.cached_baselines, "{what}: {id:?}");
- }
- };
- own_caches(&s, "copies");
- // Release to Layers (Build), Release Opacity Mask, Edit Opacity Mask and Draw Inside copy the
- // frame too.
- let layer = s.doc().unwrap().doc.layer_containing(NodeId(b)).unwrap().0;
- s.execute("layer.releaseToLayers", &json!({"id": layer, "build": true})).unwrap();
- own_caches(&s, "Release to Layers (Build)");
- s.execute("edit.undo", &json!({})).unwrap();
- s.execute("transparency.makeOpacityMask", &json!({"ids": [a, b]})).unwrap();
- s.execute("transparency.releaseOpacityMask", &json!({})).unwrap();
- own_caches(&s, "Release Opacity Mask");
- s.execute("edit.undo", &json!({})).unwrap();
- s.execute("transparency.editOpacityMask", &json!({"id": a})).unwrap();
- own_caches(&s, "Edit Opacity Mask");
- s.execute("transparency.stopEditingOpacityMask", &json!({})).unwrap();
- for _ in 0..3 {
- s.execute("edit.undo", &json!({})).unwrap();
- }
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("view.drawMode", &json!({"mode": "inside"})).unwrap();
- s.execute("shape.rectangle", &json!({"x": 210, "y": 20, "width": 20, "height": 20})).unwrap();
- own_caches(&s, "Draw Inside");
- s.execute("edit.undo", &json!({})).unwrap();
- s.execute("view.drawMode", &json!({"mode": "normal"})).unwrap();
- assert_eq!((threads(&s), first_line(&s, b)), (vec![vec![a, b]], (true, 0.0, 0)));
- // Remove Threading: each frame keeps its text, and its first paragraph starts in it.
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("text.thread.remove", &json!({})).unwrap();
- assert_eq!(first_line(&s, b), (false, 24.0, 0));
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(first_line(&s, b), (true, 0.0, 0));
- // Released, the frame is empty and starts the next text typed into it as a paragraph.
- let continues = |s: &Session, id: u64| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
- NodeKind::Text(t) => t.first_para_continues,
- _ => panic!("not text"),
- };
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert!(text(&s, b).is_empty() && !continues(&s, b));
- s.execute("edit.undo", &json!({})).unwrap();
- // With the first frame released, the second one holds the whole story and starts it.
- s.execute("select.set", &json!({"ids": [a]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert!(threads(&s).is_empty() && text(&s, a).is_empty());
- assert_eq!(first_line(&s, b), (false, 24.0, 0));
- s.execute("edit.undo", &json!({})).unwrap();
- // Converted to point type, it is in no thread, and its first line starts at the indent where
- // the frame's left edge was.
- let left = frame_box(&s, b).x0;
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("type.convertToPointType", &json!({})).unwrap();
- assert!(!continues(&s, b));
- {
- let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(b)).unwrap().kind else { panic!("not text") };
- let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
- let g = lay.glyphs.iter().find(|g| g.len > 0).unwrap();
- let x = (t.xf * g.origin).x - left;
- assert!((x - 24.0).abs() < 1e-6, "{x}");
- }
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(first_line(&s, b), (true, 0.0, 0));
- // Text that ends the first frame with a paragraph break: the second frame starts a
- // paragraph, with its indent.
- let all = text(&s, a).len();
- s.execute("text.editRange", &json!({"id": a, "start": 0, "end": all, "insert": "Short line.\n".repeat(12)})).unwrap();
- assert!(text(&s, a).ends_with('\n'), "{:?}", text(&s, a));
- assert_eq!(first_line(&s, b), (false, 24.0, 0));
- }
-
- /// When Create Outlines takes frames out of a thread, a frame that now starts its thread or is
- /// in no thread starts its paragraph with the first-line indent; a frame after one that ends
- /// inside the paragraph still continues it. The frames that stay hold each character they held
- /// once, and keep their text when no mark changes. Undo marks the frames again.
- #[test]
- fn a_frame_that_starts_its_thread_after_outlining_has_its_first_line_indent() {
- for (out, want) in [
- (&[0][..], [None, Some(false), Some(true)]),
- (&[0, 2], [None, Some(false), None]),
- (&[1], [Some(false), None, Some(true)]),
- (&[2], [Some(false), Some(true), None]),
- ] {
- let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
- s.execute("text.setFormat", &json!({"ids": frames, "leftIndent": 0, "firstLineIndent": 24})).unwrap();
- let before = frames.map(|id| first_line(&s, id));
- assert_eq!(before, [(false, 24.0, 0), (true, 0.0, 0), (true, 0.0, 0)], "{out:?}");
- let shown = frames.map(|id| text(&s, id));
- assert_eq!(shown.concat(), TEXT.repeat(4), "{out:?}: the last frame has room for the rest");
- let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
- s.execute("select.set", &json!({"ids": ids})).unwrap();
- s.execute("type.createOutlines", &json!({})).unwrap();
- let stay: Vec<usize> = (0..3).filter(|k| want[*k].is_some()).collect();
- for k in &stay {
- let on = want[*k] == Some(true);
- let indent = if on { 0.0 } else { 24.0 };
- assert_eq!(first_line(&s, frames[*k]), (on, indent, 0), "{out:?}: frame {k}");
- }
- let held: String = stay.iter().map(|k| shown[*k].as_str()).collect();
- assert_eq!(stay.iter().map(|k| text(&s, frames[*k])).collect::<String>(), held, "{out:?}: each character once");
- if stay.iter().all(|k| want[*k] == Some(before[*k].0)) {
- for k in &stay {
- assert_eq!(text(&s, frames[*k]), shown[*k], "{out:?}: frame {k} keeps its text");
- }
- }
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(frames.map(|id| first_line(&s, id)), before, "{out:?}: undo");
- }
- }
-
- /// The text that a thread's last frame has no room for is measured as the frame lays it out,
- /// without the first-line indent of the paragraph it continues: when the frame is outlined, the
- /// frame before it takes only that text.
- #[test]
- fn outlining_a_continued_last_frame_keeps_only_the_text_it_has_no_room_for() {
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
- s.execute("text.setFormat", &json!({"ids": [a, b, c], "leftIndent": 0, "firstLineIndent": 72})).unwrap();
- assert_eq!(first_line(&s, c), (true, 0.0, 0));
- let shown = [a, b, c].map(|id| text(&s, id));
- let laid = {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
- vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
- };
- assert!(laid.overflow, "the last frame has more text than it shows");
- let end = laid.lines.last().map_or(0, |l| l.end);
- let hidden = shown[2][end..].trim_start_matches(' ');
- s.execute("select.set", &json!({"ids": [c]})).unwrap();
- s.execute("type.createOutlines", &json!({})).unwrap();
- assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]));
- }
-
- /// The text that a thread's last frame has no room for is measured with the frame's numbered
- /// paragraphs counted on from the frames before it: when the frame is outlined, the frame before
- /// it takes only that text.
- #[test]
- fn outlining_a_numbered_last_frame_keeps_only_the_text_it_has_no_room_for() {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let items: String = (1..=7).map(|i| format!("Item {i}\n")).collect();
- let story = format!("{items}{}", TEXT.repeat(4));
- let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 106}})).unwrap());
- let c = new_id(s.execute("text.create", &json!({"x": 200, "y": 10, "text": "", "area": {"width": 150, "height": 20}})).unwrap());
- s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
- // A hanging indent that "I." fits and "VIII." does not: the text after "VIII." starts at
- // the next tab stop.
- s.execute("text.setFormat", &json!({"ids": [a, c], "number": "upperRoman", "leftIndent": 14, "firstLineIndent": -14})).unwrap();
- let shown = [a, c].map(|id| text(&s, id));
- assert!(shown[0].ends_with("Item 7\n") && shown[1].starts_with("The quick"), "{shown:?}");
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)).cloned() else { panic!("not area type") };
- assert_eq!(t.list_count, 7);
- let laid = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
- assert_eq!(laid.markers.first().map(|m| m.text.as_str()), Some("VIII."));
- assert!(laid.overflow, "the last frame has more text than it shows");
- let end = laid.lines.last().map_or(0, |l| l.end);
- let from_one = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &TextObject { list_count: 0, ..t });
- assert_ne!(from_one.lines.last().map_or(0, |l| l.end), end, "counted from 1, the frame would show other text");
- let hidden = shown[1][end..].trim_start_matches(' ');
- s.execute("select.set", &json!({"ids": [c]})).unwrap();
- s.execute("type.createOutlines", &json!({})).unwrap();
- assert_eq!(text(&s, a), format!("{}{hidden}", shown[0]));
- }
-
- /// A story of one-line paragraphs that each start with a quotation mark, threaded from area
- /// type `a` into the rectangle `b`, which shows the paragraphs that `a` has no room for.
- fn quoted_thread() -> (Session, u64, u64) {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let story = "“Quoted.”\n".repeat(20);
- let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 60}})).unwrap());
- let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- assert!(text(&s, b).starts_with('“'));
- (s, a, b)
- }
-
- /// Frame `id`'s Optical Margin Alignment setting, and whether its glyphs start left of its frame
- /// (its lines' opening quotation marks hang).
- fn optical(s: &Session, id: u64) -> (bool, bool) {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("not area type") };
- let TextKind::Area { frame } = &t.kind else { panic!("not area type") };
- (t.optical_margin, t.cached_bounds.unwrap().x0 < frame.bounds().unwrap().x0 - 1.0)
- }
-
- /// Optical Margin Alignment is a setting of the whole thread: Type › Optical Margin Alignment
- /// in any frame sets it in every frame of the thread, in one undo step, and the lines in every
- /// frame hang. Typing keeps it, and frames taken out of the thread keep it.
- #[test]
- fn optical_margin_alignment_is_set_for_every_frame_of_a_thread() {
- let (mut s, a, b) = quoted_thread();
- assert_eq!((optical(&s, a), optical(&s, b)), ((false, false), (false, false)));
- s.execute("select.set", &json!({"ids": [a]})).unwrap();
- let r = s.execute("type.opticalMarginAlignment", &json!({})).unwrap();
- assert_eq!(r, json!({"on": true, "ids": [a, b]}));
- assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)), "the second frame's lines hang too");
- // Turned off from the second frame, it is off in both, and one undo turns it back on in both.
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- assert_eq!(s.execute("type.opticalMarginAlignment", &json!({})).unwrap()["on"], false);
- assert_eq!((optical(&s, a), optical(&s, b)), ((false, false), (false, false)));
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
- // Typing in the first frame re-flows the story and keeps the setting.
- s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "“New.”\n"})).unwrap();
- assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
- // Any edit that sets one frame sets the thread.
- s.edit("Set", |d, _| {
- let Some(NodeKind::Text(t)) = d.node_mut(NodeId(b)).map(|n| &mut n.kind) else { panic!("not text") };
- t.optical_margin = false;
- refresh_bounds(t);
- Ok(())
- })
- .unwrap();
- assert_eq!((optical(&s, a), optical(&s, b)), ((false, false), (false, false)));
- s.execute("edit.undo", &json!({})).unwrap();
- // Released or unthreaded, each frame keeps it.
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert_eq!((optical(&s, a).0, optical(&s, b).0), (true, true));
- s.execute("edit.undo", &json!({})).unwrap();
- s.execute("text.thread.remove", &json!({})).unwrap();
- assert!(threads(&s).is_empty());
- assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
- }
-
- /// Threading type into a thread gives the joined thread the setting of its first frame.
- #[test]
- fn a_thread_takes_its_first_frames_optical_margin_alignment() {
- let (mut s, a, b) = quoted_thread();
- s.execute("text.thread.remove", &json!({})).unwrap();
- s.execute("type.opticalMarginAlignment", &json!({"ids": [a], "on": true})).unwrap();
- assert_eq!((optical(&s, a).0, optical(&s, b).0), (true, false));
- // Threaded again in stacking order: the second frame takes the first one's setting.
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!((optical(&s, a).0, optical(&s, b).0), (true, false));
- // From `b`'s out port into `a`: `a` joins `b`'s thread after it and takes its setting.
- s.execute("text.thread.add", &json!({"from": b, "to": a})).unwrap();
- assert_eq!(threads(&s), [[b, a]]);
- assert_eq!((optical(&s, a).0, optical(&s, b).0), (false, false));
- // A new frame threaded from a frame takes the thread's setting.
- s.execute("type.opticalMarginAlignment", &json!({"ids": [a], "on": true})).unwrap();
- let c = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [400, 10]})).unwrap());
- assert_eq!([a, b, c].map(|id| optical(&s, id).0), [true; 3]);
- }
-
- /// A file saved with the frames of one thread set differently opens with the first frame's
- /// setting in every frame: a native file, and an EPS file restored from the document it carries.
- #[test]
- fn a_thread_saved_with_differing_frames_opens_with_the_first_frames_setting() {
- let (mut s, a, b) = quoted_thread();
- for (first, name) in [(true, "old.vectorcraft"), (false, "old.vectorcraft"), (true, "old.eps"), (false, "old.eps")] {
- for (id, on) in [(a, first), (b, !first)] {
- let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
- let Some(NodeKind::Text(t)) = doc.node_mut(NodeId(id)).map(|n| &mut n.kind) else { panic!("not text") };
- t.optical_margin = on;
- }
- let bytes = if name.ends_with(".eps") {
- let r = s.execute("document.exportEps", &json!({})).unwrap();
- vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
- } else {
- vectorcraft_format::save(&s.doc().unwrap().doc, false)
- };
- let r = s.execute("document.open", &json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes)})).unwrap();
- assert_eq!(r["restored"], name.ends_with(".eps"), "{r}");
- assert_eq!(threads(&s), [[a, b]], "{name}");
- assert_eq!((optical(&s, a), optical(&s, b)), ((first, first), (first, first)), "{name}, first frame {first}");
- }
- }
-
- /// One count runs through a thread: the second frame's numbered paragraphs go on from the
- /// first frame's, also after an edit, a save and a reopen. A pasted or duplicated copy of a
- /// frame, a frame converted to point type, the frames of a thread that Remove Threading breaks
- /// and the frame a Release Selection leaves alone count from 1.
- #[test]
- fn numbered_list_paragraphs_count_on_through_a_thread() {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let items = (1..=10).map(|i| format!("Item {i}")).collect::<Vec<_>>().join("\n");
- let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": items, "area": {"width": 150, "height": 60}})).unwrap());
- let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- s.execute("text.setFormat", &json!({"ids": [a, b], "list": "number"})).unwrap();
- let numbers = |s: &Session, id: u64| {
- let Some(NodeKind::Text(t)) = s.doc().unwrap().doc.node(NodeId(id)).map(|n| &n.kind) else { panic!("text") };
- vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).markers.iter().map(|m| m.text.clone()).collect::<Vec<_>>()
- };
- let all = |from: usize| (from..=10).map(|n| format!("{n}.")).collect::<Vec<_>>();
- let first = numbers(&s, a);
- assert!((2..10).contains(&first.len()), "both frames hold items: {first:?}");
- assert_eq!([first.clone(), numbers(&s, b)].concat(), all(1));
- // Typing a paragraph into the first frame numbers it and moves the rest on.
- s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "Item 0\n"})).unwrap();
- assert_eq!([numbers(&s, a), numbers(&s, b)].concat(), [vec!["1.".to_string()], all(2), vec!["11.".to_string()]].concat());
- s.execute("edit.undo", &json!({})).unwrap();
- let reopened = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
- let Some(NodeKind::Text(back)) = reopened.node(NodeId(b)).map(|n| &n.kind) else { panic!("text") };
- let after: Vec<String> = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), back).markers.iter().map(|m| m.text.clone()).collect();
- assert_eq!(after, all(first.len() + 1), "reopened");
- // A pasted copy of the second frame is in no thread.
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("edit.copy", &json!({})).unwrap();
- s.execute("edit.paste", &json!({})).unwrap();
- let copy = s.doc().unwrap().selection.objects.first().copied().unwrap();
- assert_ne!(copy, NodeId(b));
- assert_eq!(numbers(&s, copy.0).first().map(String::as_str), Some("1."));
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- let duplicate = s.execute("edit.duplicate", &json!({"dx": 10})).unwrap()["ids"][0].as_u64().unwrap();
- assert_eq!(numbers(&s, duplicate).first().map(String::as_str), Some("1."), "a duplicate");
- let layer = s.doc().unwrap().doc.layers[0].id.0;
- let moved = s.execute("layer.move", &json!({"ids": [b], "target": layer, "copy": true})).unwrap()["ids"][0].as_u64().unwrap();
- assert_eq!(numbers(&s, moved).first().map(String::as_str), Some("1."), "a copy dragged in the Layers panel");
- assert_eq!(numbers(&s, b), all(first.len() + 1), "the frame itself");
- // Convert To Point Type takes the second frame out of the thread with its text.
- s.execute("type.convertToPointType", &json!({"ids": [b]})).unwrap();
- assert!(threads(&s).is_empty());
- assert_eq!(numbers(&s, b).first().map(String::as_str), Some("1."), "the frame converted to point type");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(numbers(&s, b), all(first.len() + 1), "undo");
- // Remove Threading: each frame is a story of its own.
- s.execute("select.set", &json!({"ids": [a]})).unwrap();
- s.execute("text.thread.remove", &json!({})).unwrap();
- assert!(threads(&s).is_empty());
- assert_eq!(numbers(&s, b).first().map(String::as_str), Some("1."));
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(numbers(&s, b), all(first.len() + 1), "undo");
- // Release Selection of the first frame: the second one holds the whole story, from 1.
- s.execute("select.set", &json!({"ids": [a]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert!(threads(&s).is_empty());
- assert_eq!(numbers(&s, b), all(1), "the frame left holds the story");
- }
-
- /// New Symbol from a numbered thread keeps each frame's count in the symbol's art, so the art
- /// looks as it did; Break Link puts the frames in no thread, and each counts from 1.
- #[test]
- fn a_symbol_made_of_a_numbered_thread_keeps_its_numbers() {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let items = (1..=10).map(|i| format!("Item {i}")).collect::<Vec<_>>().join("\n");
- let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": items, "area": {"width": 150, "height": 60}})).unwrap());
- let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- s.execute("text.setFormat", &json!({"ids": [a, b], "list": "number"})).unwrap();
- let count = |t: &TextObject| t.list_count;
- let carried = text_of(&s.doc().unwrap().doc, NodeId(b)).map(count).unwrap();
- assert!(carried > 0);
- let instance = new_id(s.execute("symbol.new", &json!({"name": "Numbered"})).unwrap());
- let counts = |n: &Node| {
- let mut counts = vec![];
- n.walk(&mut |n| {
- if let NodeKind::Text(t) = &n.kind {
- counts.push(t.list_count);
- }
- });
- counts.sort_unstable();
- counts
- };
- let doc = &s.doc().unwrap().doc;
- assert_eq!(counts(&doc.symbols.iter().find(|x| x.name == "Numbered").unwrap().art), [0, carried]);
- // Break Link puts the frames on the artboard in no thread: each counts from 1.
- s.execute("select.set", &json!({"ids": [instance]})).unwrap();
- s.execute("symbol.breakLink", &json!({})).unwrap();
- let doc = &s.doc().unwrap().doc;
- assert_eq!(doc.layers.iter().flat_map(|l| counts(l)).collect::<Vec<_>>(), [0, 0]);
- }
-
- /// The text of each frame in symbol `name`'s art, sorted.
- fn symbol_texts(s: &Session, name: &str) -> Vec<String> {
- let doc = &s.doc().unwrap().doc;
- let Some(sym) = doc.symbols.iter().find(|x| x.name == name) else { panic!("no symbol {name}") };
- let mut texts = vec![];
- sym.art.walk(&mut |n| {
- if let NodeKind::Text(t) = &n.kind {
- texts.push(t.plain_text());
- }
- });
- texts.sort();
- texts
- }
-
- /// New Symbol and Redefine Symbol on frames of threaded text replace them with an instance
- /// whose art holds the text they show, and the frames leave their thread: the other frames keep
- /// the text they hold, so each character is drawn once. Undo threads the frames again. When the
- /// last frame goes into the symbol, the frame before it takes the text it has no room for, and
- /// the symbol's art holds only the text the frame shows.
- #[test]
- fn frames_made_into_a_symbol_leave_their_thread_with_their_text() {
- let symbol = |s: &mut Session, command: &str, ids: &[u64]| {
- let name = if command == "symbol.update" {
- let mark = new_id(s.execute("shape.rectangle", &json!({"x": 400, "y": 200, "width": 20, "height": 20})).unwrap());
- s.execute("select.set", &json!({"ids": [mark]})).unwrap();
- s.execute("symbol.new", &json!({"name": "Mark"})).unwrap();
- "Mark"
- } else {
- "Story"
- };
- s.execute("select.set", &json!({"ids": ids})).unwrap();
- s.execute(command, &json!({"name": name})).unwrap();
- name
- };
- for command in ["symbol.new", "symbol.update"] {
- for out in [&[0][..], &[1], &[2], &[0, 2]] {
- let case = format!("{command} {out:?}");
- let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
- let shown = frames.map(|id| text(&s, id));
- assert_eq!(shown.concat(), TEXT.repeat(4));
- let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
- let name = symbol(&mut s, command, &ids);
- let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
- for id in &ids {
- assert!(!is_frame(&s, *id), "{case}: frame {id} is in the symbol");
- }
- let mut held: Vec<String> = out.iter().map(|k| shown[*k].clone()).collect();
- held.sort();
- assert_eq!(symbol_texts(&s, name), held, "{case}: the symbol's art holds the text the frames show");
- for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
- assert_eq!(text(&s, *id), *before, "{case}: frame {id} keeps its text");
- }
- assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{case}");
- s.execute("edit.undo", &json!({})).unwrap();
- assert_eq!(threads(&s), [frames], "{case}: undo");
- assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
- }
- let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
- let shown = [a, b, c].map(|id| text(&s, id));
- let laid = {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
- vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
- };
- assert!(laid.overflow, "the last frame has more text than it shows");
- let end = laid.lines.last().map_or(0, |l| l.end);
- let hidden = shown[2][end..].trim_start_matches(' ');
- let name = symbol(&mut s, command, &[c]);
- assert_eq!(text(&s, a), shown[0], "{command}");
- assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "{command}: the frame before it keeps its text and takes the rest");
- assert_eq!(threads(&s), [[a, b]], "{command}");
- let held = symbol_texts(&s, name);
- let held: Vec<&str> = held.iter().map(|t| t.trim_end()).collect();
- assert_eq!(held, [shown[2][..end].trim_end()], "{command}: the symbol's art holds what the frame shows");
- // With every frame of the thread in the symbol, the last frame keeps all its text.
- let (mut s, frames) = three_frames(&TEXT.repeat(12), 100.0);
- let mut shown = frames.map(|id| text(&s, id)).to_vec();
- shown.sort();
- let name = symbol(&mut s, command, &frames);
- assert_eq!(symbol_texts(&s, name), shown, "{command}: the whole thread");
- assert!(threads(&s).is_empty(), "{command}: the whole thread");
- }
- }
-
- /// A frame of a numbered thread pasted while an opacity mask is edited numbers from 1 in the
- /// mask art too.
- #[test]
- fn a_frame_pasted_into_an_edited_opacity_mask_numbers_from_1() {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let items = (1..=10).map(|i| format!("Item {i}")).collect::<Vec<_>>().join("\n");
- let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": items, "area": {"width": 150, "height": 60}})).unwrap());
- let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- s.execute("text.setFormat", &json!({"ids": [a, b], "list": "number"})).unwrap();
- assert!(text_of(&s.doc().unwrap().doc, NodeId(b)).is_some_and(|t| t.list_count > 0));
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- s.execute("edit.copy", &json!({})).unwrap();
- let obj = new_id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 400, "height": 280})).unwrap());
- let m = new_id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 200})).unwrap());
- s.execute("select.set", &json!({"ids": [obj, m]})).unwrap();
- s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
- s.execute("transparency.editOpacityMask", &json!({})).unwrap();
- s.execute("edit.paste", &json!({})).unwrap();
- let doc = &s.doc().unwrap().doc;
- let mut counts = vec![];
- doc.node(NodeId(obj)).unwrap().extras().mask.as_ref().unwrap().art.walk(&mut |n| {
- if let NodeKind::Text(t) = &n.kind {
- counts.push(t.list_count);
- }
- });
- assert_eq!(counts, [0], "the pasted frame in the mask art");
- }
-
- /// A duplicate of a frame that carried a count of 99 or more numbers from 1 and has the layout
- /// bounds of what it draws: "01." leaves the text at the left indent, where a three-digit
- /// number pushed it on to the next tab stop and the paragraph took more lines.
- #[test]
- fn a_duplicated_frame_numbers_from_1_with_its_own_bounds() {
- let mut s = Session::new();
- s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
- let story = format!("{}Itemized lists paragraph text", "x\n".repeat(110));
- let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 1500}})).unwrap());
- let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 100, "height": 300})).unwrap());
- s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
- s.execute("text.thread.create", &json!({})).unwrap();
- s.execute("text.setFormat", &json!({"ids": [a, b], "number": "twoDigits"})).unwrap();
- s.execute("select.set", &json!({"ids": [b]})).unwrap();
- let copy = s.execute("edit.duplicate", &json!({"dx": 200})).unwrap()["ids"][0].as_u64().unwrap();
- let laid = |s: &Session, id: u64| {
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("area type") };
- let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
- (lay.markers[0].text.clone(), lay.lines.len(), lay.bounds, t.cached_bounds.unwrap())
- };
- let (number, lines, _, _) = laid(&s, b);
- let (copy_number, copy_lines, bounds, cached) = laid(&s, copy);
- assert!(number.len() == 4 && number.starts_with('1'), "a three-digit number: {number}");
- assert_eq!(copy_number, "01.");
- assert!(copy_lines < lines, "{copy_lines} {lines}");
- assert!((cached.y1 - bounds.y1).abs() < 1e-6, "the copy's bounds: {cached:?} {bounds:?}");
- }
-
- /// Release Selection that leaves one frame of a thread gives that frame the whole story and
- /// the layout bounds of its new text.
- #[test]
- fn the_frame_a_release_leaves_alone_has_the_bounds_of_the_whole_story() {
- let (mut s, a, b) = setup();
- s.execute("text.thread.create", &json!({})).unwrap();
- s.execute("select.set", &json!({"ids": [a]})).unwrap();
- s.execute("text.thread.releaseSelection", &json!({})).unwrap();
- assert!(threads(&s).is_empty());
- assert_eq!(text(&s, b), TEXT.repeat(4));
- let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(b)) else { panic!("area type") };
- let bounds = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).bounds;
- let cached = t.cached_bounds.unwrap();
- assert!((cached.y0 - bounds.y0).abs() < 1e-6 && (cached.y1 - bounds.y1).abs() < 1e-6, "{cached:?} {bounds:?}");
- }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/threads/tests.rs b/crates/engine/src/cmd/threads/tests.rs
new file mode 100644
index 000000000..07531d4ed
--- /dev/null
+++ b/crates/engine/src/cmd/threads/tests.rs
@@ -0,0 +1,1267 @@
+use super::*;
+
+const TEXT: &str = "The quick brown fox jumps over the lazy dog and keeps running far beyond the first frame of this story. ";
+
+fn setup() -> (Session, u64, u64) {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let a = s.execute("text.create", &json!({"x": 10, "y": 10, "text": TEXT.repeat(4), "area": {"width": 150, "height": 60}})).unwrap()["id"]
+ .as_u64()
+ .unwrap();
+ let b = s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap()["id"].as_u64().unwrap();
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ (s, a, b)
+}
+
+fn text(s: &Session, id: u64) -> String {
+ match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+ NodeKind::Text(t) => t.plain_text(),
+ _ => panic!("not text"),
+ }
+}
+
+#[test]
+fn thread_flows_reflows_on_edit_and_survives_delete() {
+ let (mut s, a, b) = setup();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ let (ta, tb) = (text(&s, a), text(&s, b));
+ assert!(!ta.is_empty() && !tb.is_empty());
+ assert_eq!(format!("{ta}{tb}"), TEXT.repeat(4));
+ // Editing the first frame re-flows into the second.
+ s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "NEW "})).unwrap();
+ assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), format!("NEW {}", TEXT.repeat(4)));
+ assert_ne!(text(&s, b), tb, "the overflow moved on");
+ // Deleting the first frame moves all its text into the second.
+ s.execute("select.set", &json!({"ids": [a]})).unwrap();
+ s.execute("edit.clear", &json!({})).unwrap();
+ assert_eq!(text(&s, b), format!("NEW {}", TEXT.repeat(4)));
+ assert!(s.doc().unwrap().doc.text_threads.is_empty(), "a one-frame thread is no thread");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(s.doc().unwrap().doc.text_threads.len(), 1);
+}
+
+#[test]
+fn edits_copy_only_the_stories_of_threads_whose_frames_changed() {
+ let (mut s, a, b) = setup();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ let c = s.execute("text.create", &json!({"x": 10, "y": 200, "text": TEXT.repeat(2), "area": {"width": 150, "height": 40}})).unwrap()["id"]
+ .as_u64()
+ .unwrap();
+ let d = s.execute("shape.rectangle", &json!({"x": 200, "y": 220, "width": 150, "height": 60})).unwrap()["id"].as_u64().unwrap();
+ s.execute("select.set", &json!({"ids": [c, d]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ let texts = |s: &Session| [a, b, c, d].map(|id| text(s, id));
+ let copied = || COPIED.with(std::cell::Cell::get);
+ let (shown, start) = (texts(&s), copied());
+ // A rectangle drawn, moved and dragged beside the threads changes none of their frames.
+ let r = s.execute("shape.rectangle", &json!({"x": 400, "y": 250, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+ s.execute("select.set", &json!({"ids": [r]})).unwrap();
+ s.execute("object.move", &json!({"dx": 5, "dy": 0})).unwrap();
+ s.begin_interaction("Move").unwrap();
+ for dx in 1..=3 {
+ s.preview("object.move", &json!({"dx": dx, "dy": 0})).unwrap();
+ }
+ s.commit_interaction().unwrap();
+ assert_eq!(copied(), start, "edits beside the threads copied their stories");
+ assert_eq!(texts(&s), shown);
+ // Typing in the first thread copies and re-flows that thread's story only.
+ s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "NEW "})).unwrap();
+ assert_eq!(copied(), start + 1);
+ assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), format!("NEW {}", TEXT.repeat(4)));
+ assert_eq!(texts(&s)[2..], shown[2..]);
+ let ids = |t: [u64; 2]| t.map(NodeId).to_vec();
+ assert_eq!(s.doc().unwrap().doc.text_threads, [ids([a, b]), ids([c, d])]);
+}
+
+/// Time edits of a story of 50,000 characters threaded through 8 frames, each frame wrapping
+/// around an ellipse, with one style, a style change every 10 words and a style change at every
+/// word: 21 characters typed into the first frame, then 200 moves of a rectangle below the
+/// frames and 200 frames of a drag of it.
+/// Run with `cargo test --release -p vectorcraft-engine --lib threaded_story_edit_timing -- --ignored --nocapture`.
+#[test]
+#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
+fn threaded_story_edit_timing() {
+ fn median(s: &mut Session, n: u32, f: &dyn Fn(&mut Session, f64)) -> f64 {
+ let mut ms: Vec<f64> = (1..=n)
+ .map(|i| {
+ let start = std::time::Instant::now();
+ f(s, f64::from(i));
+ start.elapsed().as_secs_f64() * 1000.0
+ })
+ .collect();
+ ms.sort_by(f64::total_cmp);
+ ms[ms.len() / 2]
+ }
+ let story = format!("{}\n", TEXT.repeat(6).trim_end()).repeat(81)[..50_000].to_string();
+ for words in [0, 10, 1] {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 4400, "height": 1200})).unwrap();
+ let area = json!({"width": 500, "height": 900});
+ let first = s.execute("text.create", &json!({"x": 20, "y": 20, "text": story, "size": 9, "area": area})).unwrap()["id"].as_u64().unwrap();
+ if words > 0 {
+ s.edit("Restyle", |d, _| {
+ let Some(NodeKind::Text(t)) = d.node_mut(NodeId(first)).map(|n| &mut n.kind) else { panic!("not text") };
+ let style = t.runs[0].style.clone();
+ let pieces: Vec<&str> = story.split_inclusive([' ', '\n']).collect();
+ t.runs = pieces
+ .chunks(words)
+ .enumerate()
+ .map(|(i, c)| {
+ let mut run = TextRun::new(c.concat(), style.clone());
+ run.style.underline = i % 2 == 1;
+ run
+ })
+ .collect();
+ refresh_bounds(t);
+ Ok(())
+ })
+ .unwrap();
+ }
+ let mut ids = vec![first];
+ for k in 1..8 {
+ let frame = json!({"x": 20 + k * 540, "y": 20, "width": 500, "height": 900});
+ ids.push(s.execute("shape.rectangle", &frame).unwrap()["id"].as_u64().unwrap());
+ }
+ s.execute("select.set", &json!({"ids": ids})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ for k in 0..8 {
+ let e = s.execute("shape.ellipse", &json!({"x": 195 + k * 540, "y": 395, "width": 150, "height": 150})).unwrap()["id"].clone();
+ s.execute("object.textWrap.make", &json!({"ids": [e]})).unwrap();
+ }
+ let r = s.execute("shape.rectangle", &json!({"x": 20, "y": 1100, "width": 30, "height": 30})).unwrap()["id"].clone();
+ s.execute("select.set", &json!({"ids": [r]})).unwrap();
+ let typing = median(&mut s, 21, &|s, _| {
+ s.execute("text.editRange", &json!({"id": first, "start": 0, "end": 0, "insert": "x"})).unwrap();
+ });
+ let edit = median(&mut s, 200, &|s, _| {
+ s.execute("object.move", &json!({"dx": 0.5, "dy": 0})).unwrap();
+ });
+ s.begin_interaction("Move").unwrap();
+ let frame = median(&mut s, 200, &|s, i| {
+ s.preview("object.move", &json!({"dx": i * 0.25, "dy": 0})).unwrap();
+ });
+ s.commit_interaction().unwrap();
+ let d = &s.doc().unwrap().doc;
+ let runs: usize = ids.iter().filter_map(|id| text_of(d, NodeId(*id))).map(|t| t.runs.len()).sum();
+ println!("{runs} runs in 8 frames: typing {typing:.1} ms, a move below them {edit:.3} ms, a drag frame {frame:.3} ms (medians)");
+ }
+}
+
+fn new_id(v: Value) -> u64 {
+ v["id"].as_u64().unwrap()
+}
+
+fn threads(s: &Session) -> Vec<Vec<u64>> {
+ s.doc().unwrap().doc.text_threads.iter().map(|t| t.iter().map(|i| i.0).collect()).collect()
+}
+
+/// Bounds of area type `id`'s frame on the page.
+fn frame_box(s: &Session, id: u64) -> vectorcraft_geom::Rect {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("not area type") };
+ let TextKind::Area { frame } = &t.kind else { panic!("not area type") };
+ t.xf.transform_rect_bbox(frame.bounds().unwrap())
+}
+
+/// #2572: the text loaded from an out port threads into a closed path, into a new frame of the
+/// first one's shape and size at a point, and into a new rectangle, each in one undo step.
+#[test]
+fn add_threads_into_a_path_a_frame_at_a_point_and_a_rectangle() {
+ let (mut s, a, b) = setup();
+ assert_eq!(new_id(s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap()), b);
+ assert_eq!(threads(&s), [[a, b]]);
+ assert!(!text(&s, b).is_empty(), "the overflow flowed into the path");
+ assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), TEXT.repeat(4));
+ assert_eq!(s.doc().unwrap().selection.objects, [NodeId(a), NodeId(b)]);
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert!(matches!(s.doc().unwrap().doc.node(NodeId(b)).unwrap().kind, NodeKind::Path { .. }), "undo gives the path back");
+
+ let c = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [400, 200]})).unwrap());
+ assert_eq!(frame_box(&s, c), vectorcraft_geom::Rect::new(400.0, 200.0, 550.0, 260.0), "the first frame's size, its top-left at the click");
+ let d = new_id(s.execute("text.thread.add", &json!({"from": c, "rect": [10, 100, 300, 150]})).unwrap());
+ assert_eq!(frame_box(&s, d), vectorcraft_geom::Rect::new(10.0, 100.0, 310.0, 250.0));
+ assert_eq!(threads(&s), [[a, c, d]], "each new frame comes after the one it was threaded from");
+ assert_eq!(format!("{}{}{}", text(&s, a), text(&s, c), text(&s, d)), TEXT.repeat(4));
+ assert!(!text(&s, d).is_empty());
+ // A frame threaded from the middle of a thread goes in after it.
+ let e = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [0, 0]})).unwrap());
+ assert_eq!(threads(&s), [[a, e, c, d]]);
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert!(s.doc().unwrap().doc.node(NodeId(e)).is_none());
+ assert_eq!(threads(&s), [[a, c, d]]);
+}
+
+/// #2572: the text loaded from an in port threads back: the new frame or the path clicked comes
+/// before the frame it was loaded from, so the story starts there and flows on into it; in the
+/// middle of a thread the new frame goes in between, each in one undo step.
+#[test]
+fn add_before_threads_the_story_from_the_new_frame_into_the_clicked_one() {
+ let (mut s, a, b) = setup();
+ let c = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [400, 200], "before": true})).unwrap());
+ assert_eq!(threads(&s), [[c, a]]);
+ assert_eq!(frame_box(&s, c), vectorcraft_geom::Rect::new(400.0, 200.0, 550.0, 260.0), "the clicked frame's size at the click");
+ assert!(TEXT.repeat(4).starts_with(&text(&s, c)) && !text(&s, c).is_empty(), "the story starts in the new frame: {:?}", text(&s, c));
+ assert_eq!(format!("{}{}", text(&s, c), text(&s, a)), TEXT.repeat(4));
+ assert_eq!(s.doc().unwrap().selection.objects, [NodeId(a), NodeId(c)]);
+ // In between the frame and the one before it.
+ let d = new_id(s.execute("text.thread.add", &json!({"from": a, "rect": [10, 100, 300, 150], "before": true})).unwrap());
+ assert_eq!(threads(&s), [[c, d, a]]);
+ assert_eq!(format!("{}{}{}", text(&s, c), text(&s, d), text(&s, a)), TEXT.repeat(4));
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [[c, a]]);
+ // A closed path clicked with the in port's text comes first, with the start of the story.
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(new_id(s.execute("text.thread.add", &json!({"from": a, "to": b, "before": true})).unwrap()), b);
+ assert_eq!(threads(&s), [[b, a]]);
+ assert!(TEXT.repeat(4).starts_with(&text(&s, b)) && !text(&s, b).is_empty());
+ assert_eq!(format!("{}{}", text(&s, b), text(&s, a)), TEXT.repeat(4));
+ // `before: false` is the out port's.
+ let e = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [0, 0], "before": false})).unwrap());
+ assert_eq!(threads(&s), [[b, a, e]]);
+}
+
+/// Type on a path along a line beside the area type of [`setup`].
+fn type_on_a_line(s: &mut Session) -> u64 {
+ let line = new_id(s.execute("shape.line", &json!({"x1": 10, "y1": 250, "x2": 110, "y2": 250})).unwrap());
+ new_id(s.execute("text.createInPath", &json!({"path": line, "mode": "onPath", "text": ""})).unwrap())
+}
+
+/// Type on a path threads as area type does, in any mix: a story flows from area type along a
+/// path and on into area type, and a new frame threaded from type on a path at a point is type
+/// on a path of the same shape.
+#[test]
+fn type_on_a_path_threads_with_area_type() {
+ let (mut s, a, b) = setup();
+ let on_path = type_on_a_line(&mut s);
+ s.execute("text.thread.add", &json!({"from": a, "to": on_path})).unwrap();
+ s.execute("text.thread.add", &json!({"from": on_path, "to": b})).unwrap();
+ assert_eq!(threads(&s), [[a, on_path, b]]);
+ let shares = [a, on_path, b].map(|id| text(&s, id));
+ assert!(shares.iter().all(|t| !t.is_empty()), "each frame takes a share: {shares:?}");
+ assert_eq!(shares.concat(), TEXT.repeat(4));
+
+ let c = new_id(s.execute("text.thread.add", &json!({"from": on_path, "at": [300, 250]})).unwrap());
+ let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(c)).unwrap().kind else { panic!("not text") };
+ assert!(matches!(t.kind, TextKind::OnPath { .. }), "type on a path, as the frame it was threaded from");
+ assert_eq!(threads(&s), [[a, on_path, c, b]]);
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [[a, on_path, b]]);
+}
+
+/// Type on a path released from its thread gives its text back to the frame before it.
+#[test]
+fn type_on_a_path_is_released_from_its_thread() {
+ let (mut s, a, _) = setup();
+ let on_path = type_on_a_line(&mut s);
+ s.execute("text.thread.add", &json!({"from": a, "to": on_path})).unwrap();
+ assert!(!text(&s, on_path).is_empty());
+ s.execute("select.set", &json!({"ids": [on_path]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert!(text(&s, on_path).is_empty());
+ assert_eq!(text(&s, a), TEXT.repeat(4));
+}
+
+/// Area type threaded into from an out port takes the overflow at once, before its own text.
+#[test]
+fn add_into_area_type_flows_the_story_into_it() {
+ let (mut s, a, _) = setup();
+ let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 100, "text": "Own text.", "area": {"width": 150, "height": 190}})).unwrap());
+ s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
+ assert_eq!(threads(&s), [[a, c]]);
+ assert_eq!(format!("{}{}", text(&s, a), text(&s, c)), format!("{}Own text.", TEXT.repeat(4)));
+ assert!(text(&s, c).len() > "Own text.".len(), "the overflow flowed into the frame: {:?}", text(&s, c));
+}
+
+#[test]
+fn add_refuses_bad_params_and_leaves_the_document_alone() {
+ let (mut s, a, b) = setup();
+ let line = new_id(s.execute("shape.line", &json!({"x1": 0, "y1": 280, "x2": 50, "y2": 290})).unwrap());
+ let before = s.doc().unwrap().doc.clone();
+ for p in [
+ json!({"to": b}),
+ json!({"from": b, "at": [0, 0]}),
+ json!({"from": 9999, "at": [0, 0]}),
+ json!({"from": -1, "at": [0, 0]}),
+ json!({"from": a}),
+ json!({"from": a, "to": b, "at": [0, 0]}),
+ json!({"from": a, "to": a}),
+ json!({"from": a, "to": line}),
+ json!({"from": a, "to": 9999}),
+ json!({"from": a, "at": [0]}),
+ json!({"from": a, "at": ["1", 2]}),
+ json!({"from": a, "rect": [0, 0, -10, 10]}),
+ json!({"from": a, "rect": [0, 0, 10, 0]}),
+ json!({"from": a, "rect": [0, 0, 10]}),
+ json!({"from": a, "rect": "big"}),
+ json!({"from": a, "at": [0, 0], "before": "yes"}),
+ json!({"from": a, "at": [0, 0], "before": 1}),
+ ] {
+ assert!(s.execute("text.thread.add", &p).is_err(), "{p} was accepted");
+ assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "{p} changed the document");
+ }
+ s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap();
+ let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 200, "text": "x", "area": {"width": 50, "height": 20}})).unwrap());
+ assert!(s.execute("text.thread.add", &json!({"from": c, "to": b})).is_err(), "a frame already threaded");
+}
+
+/// A frame released from a thread that keeps two or more frames gives its text back to them:
+/// the story flows through them once.
+#[test]
+fn release_from_a_longer_thread_keeps_the_story_once() {
+ let (mut s, a, b) = setup();
+ let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 100, "text": "", "area": {"width": 150, "height": 40}})).unwrap());
+ s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
+ s.execute("text.thread.add", &json!({"from": c, "to": b})).unwrap();
+ assert_eq!(threads(&s), [[a, c, b]]);
+ s.execute("select.set", &json!({"ids": [c]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert_eq!(threads(&s), [[a, b]]);
+ assert!(text(&s, c).is_empty());
+ assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), TEXT.repeat(4));
+}
+
+/// A thread of `n` frames (2 or 3), each showing part of the story: area type `a` of [`setup`],
+/// for 3 an area type frame that is empty until it is threaded, then the rectangle `b`.
+fn thread_of(n: usize) -> (Session, Vec<u64>) {
+ let (mut s, a, b) = setup();
+ let frames = if n == 3 {
+ let c = new_id(s.execute("text.create", &json!({"x": 10, "y": 100, "text": "", "area": {"width": 150, "height": 40}})).unwrap());
+ s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
+ s.execute("text.thread.add", &json!({"from": c, "to": b})).unwrap();
+ vec![a, c, b]
+ } else {
+ s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap();
+ vec![a, b]
+ };
+ assert_eq!(threads(&s), std::slice::from_ref(&frames));
+ assert!(frames.iter().all(|id| !text(&s, *id).is_empty()), "each frame shows part of the story");
+ (s, frames)
+}
+
+/// Convert To Point Type on a frame of threaded text takes it out of its thread with the text
+/// it holds, and the other frames keep the text they hold: the story holds each character once.
+/// A thread left with one frame is no thread. Undo threads the frame again.
+#[test]
+fn a_frame_converted_to_point_type_leaves_its_thread_with_its_text() {
+ // Soft wraps of the point type become line breaks, so its characters are compared without
+ // white space.
+ let squeeze = |t: &str| t.split_whitespace().collect::<String>();
+ for n in [2, 3] {
+ for k in 0..n {
+ let (mut s, frames) = thread_of(n);
+ let shown: Vec<String> = frames.iter().map(|id| text(&s, *id)).collect();
+ let id = frames[k];
+ s.execute("type.convertToPointType", &json!({"ids": [id]})).unwrap();
+ let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind else { panic!("not text") };
+ assert!(matches!(t.kind, TextKind::Point), "{n} frames, frame {k}: point type");
+ assert_eq!(squeeze(&text(&s, id)), squeeze(&shown[k]), "{n} frames, frame {k}: the point type keeps its text");
+ for (f, before) in frames.iter().zip(&shown).filter(|(f, _)| **f != id) {
+ assert_eq!(text(&s, *f), *before, "{n} frames, frame {k}: frame {f} keeps its text");
+ }
+ let rest: Vec<u64> = frames.iter().copied().filter(|f| *f != id).collect();
+ assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{n} frames, frame {k}");
+ let all: String = frames.iter().map(|f| text(&s, *f)).collect();
+ assert_eq!(squeeze(&all), squeeze(&TEXT.repeat(4)), "{n} frames, frame {k}: each character once");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), std::slice::from_ref(&frames));
+ assert_eq!(frames.iter().map(|f| text(&s, *f)).collect::<Vec<_>>(), shown, "{n} frames, frame {k}: undo");
+ }
+ }
+}
+
+#[test]
+fn release_and_remove() {
+ let (mut s, a, b) = setup();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ let tb = text(&s, b);
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("text.thread.remove", &json!({})).unwrap();
+ assert_eq!(text(&s, b), tb, "remove keeps what each frame shows");
+ assert!(s.doc().unwrap().doc.text_threads.is_empty());
+ s.execute("edit.undo", &json!({})).unwrap();
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert_eq!(text(&s, b), "");
+ assert_eq!(text(&s, a), TEXT.repeat(4), "the story returns to the remaining frame");
+}
+
+/// `story` threaded through three area type frames, of 150 by 60, 40 and `last` points, each
+/// showing part of it.
+fn three_frames(story: &str, last: f64) -> (Session, [u64; 3]) {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let frame = |s: &mut Session, x: f64, y: f64, h: f64, text: &str| {
+ new_id(s.execute("text.create", &json!({"x": x, "y": y, "text": text, "area": {"width": 150, "height": h}})).unwrap())
+ };
+ let a = frame(&mut s, 10.0, 10.0, 60.0, story);
+ let b = frame(&mut s, 10.0, 100.0, 40.0, "");
+ let c = frame(&mut s, 200.0, 10.0, last, "");
+ s.execute("text.thread.add", &json!({"from": a, "to": b})).unwrap();
+ s.execute("text.thread.add", &json!({"from": b, "to": c})).unwrap();
+ assert_eq!(threads(&s), [[a, b, c]]);
+ assert!([a, b, c].iter().all(|id| !text(&s, *id).is_empty()), "each frame shows part of the story");
+ (s, [a, b, c])
+}
+
+fn continues(s: &Session, id: u64) -> bool {
+ text_of(&s.doc().unwrap().doc, NodeId(id)).is_some_and(|t| t.first_para_continues)
+}
+
+/// A double-click on a threaded port breaks the thread there: the story flows into the frames
+/// before the break and the frames after it are left empty, still threaded with each other
+/// when two or more. One undo step restores the thread and its text.
+#[test]
+fn break_splits_the_thread_and_the_story_flows_into_the_first_part() {
+ let story = TEXT.repeat(12);
+ let (mut s, [a, b, c]) = three_frames(&story, 40.0);
+ let d = new_id(s.execute("text.create", &json!({"x": 200, "y": 100, "text": "", "area": {"width": 150, "height": 100}})).unwrap());
+ s.execute("text.thread.add", &json!({"from": c, "to": d})).unwrap();
+ let all = [a, b, c, d];
+ let shown: Vec<String> = all.iter().map(|id| text(&s, *id)).collect();
+ assert!(shown.iter().all(|t| !t.is_empty()), "each frame shows part of the story");
+ let joined = |s: &Session, ids: &[u64]| ids.iter().map(|id| text(s, *id)).collect::<String>();
+ // (frame, port, threads after, the frames that hold the story, the frames left empty)
+ let cases = [
+ (a, "out", vec![vec![b, c, d]], vec![a], vec![b, c, d]),
+ (b, "in", vec![vec![b, c, d]], vec![a], vec![b, c, d]),
+ (b, "out", vec![vec![a, b], vec![c, d]], vec![a, b], vec![c, d]),
+ (d, "in", vec![vec![a, b, c]], vec![a, b, c], vec![d]),
+ (c, "out", vec![vec![a, b, c]], vec![a, b, c], vec![d]),
+ ];
+ for (id, port, after, full, empty) in cases {
+ let case = format!("{port} port of {id}");
+ s.execute("text.thread.break", &json!({"id": id, "port": port})).unwrap();
+ assert_eq!(threads(&s), after, "{case}");
+ assert_eq!(joined(&s, &full), story, "{case}: the story flows into the first part");
+ assert!(empty.iter().all(|id| text(&s, *id).is_empty()), "{case}: the frames after the break are empty");
+ assert!(!continues(&s, empty[0]), "{case}: the first frame after the break starts a paragraph");
+ assert!(!continues(&s, a), "{case}: the first frame starts the story");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [all.to_vec()], "{case}: undo");
+ assert_eq!(all.iter().map(|id| text(&s, *id)).collect::<Vec<_>>(), shown, "{case}: undo");
+ }
+}
+
+#[test]
+fn break_refuses_a_port_with_no_thread_and_bad_params() {
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(4), 200.0);
+ let lone = new_id(s.execute("text.create", &json!({"x": 400, "y": 10, "text": "Alone.", "area": {"width": 100, "height": 100}})).unwrap());
+ let ids = [a, b, c, lone];
+ let shown: Vec<String> = ids.iter().map(|id| text(&s, *id)).collect();
+ let before = threads(&s);
+ for params in [
+ json!({"id": a, "port": "in"}),
+ json!({"id": c, "port": "out"}),
+ json!({"id": lone, "port": "out"}),
+ json!({"id": lone, "port": "in"}),
+ json!({"id": a, "port": "up"}),
+ json!({"id": a}),
+ json!({"port": "out"}),
+ json!({"id": 9999, "port": "out"}),
+ ] {
+ assert!(s.execute("text.thread.break", &params).is_err(), "{params}");
+ }
+ assert_eq!(threads(&s), before);
+ assert_eq!(ids.iter().map(|id| text(&s, *id)).collect::<Vec<_>>(), shown);
+}
+
+/// Whether the document holds area type or type on a path `id`.
+fn is_frame(s: &Session, id: u64) -> bool {
+ text_of(&s.doc().unwrap().doc, NodeId(id)).is_some()
+}
+
+/// Create Outlines and Object › Expand on frames of threaded text take them out of their
+/// thread with the text they show, which their outlines draw, and the other frames keep the
+/// text they hold: each character is in the document once. A thread left with one frame is no
+/// thread. Undo threads the frames again.
+#[test]
+fn outlined_frames_leave_their_thread_with_their_text() {
+ for command in ["type.createOutlines", "object.expand"] {
+ for out in [&[0][..], &[1], &[2], &[0, 2]] {
+ let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
+ let shown = frames.map(|id| text(&s, id));
+ assert_eq!(shown.concat(), TEXT.repeat(4));
+ let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
+ s.execute("select.set", &json!({"ids": ids})).unwrap();
+ s.execute(command, &json!({})).unwrap();
+ let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
+ for id in &ids {
+ assert!(!is_frame(&s, *id), "{command} {out:?}: frame {id} is outlined");
+ }
+ let st = s.doc().unwrap();
+ let groups = st.selection.objects.iter().filter(|g| matches!(st.doc.node(**g).map(|n| &n.kind), Some(NodeKind::Group { .. })));
+ assert_eq!(groups.count(), ids.len(), "{command} {out:?}: the outlines are selected");
+ for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
+ assert_eq!(text(&s, *id), *before, "{command} {out:?}: frame {id} keeps its text");
+ }
+ assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{command} {out:?}");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [frames], "{command} {out:?}: undo");
+ assert_eq!(frames.map(|id| text(&s, id)), shown, "{command} {out:?}: undo");
+ }
+ }
+}
+
+/// Expand Appearance outlines a frame with an effect, and the frame leaves its thread with the
+/// text it shows; Object › Expand of such a frame expands its appearance first.
+#[test]
+fn a_frame_whose_appearance_expands_leaves_its_thread_with_its_text() {
+ for command in ["effect.expandAppearance", "object.expand"] {
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(4), 200.0);
+ s.execute("effect.apply", &json!({"effect": "distort.roughen", "ids": [b]})).unwrap();
+ let shown = [a, b, c].map(|id| text(&s, id));
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute(command, &json!({})).unwrap();
+ assert!(!is_frame(&s, b), "{command}: the frame is outlined");
+ assert_eq!((text(&s, a), text(&s, c)), (shown[0].clone(), shown[2].clone()), "{command}: the other frames keep their text");
+ assert_eq!(threads(&s), [[a, c]], "{command}");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [[a, b, c]], "{command}: undo");
+ assert_eq!([a, b, c].map(|id| text(&s, id)), shown, "{command}: undo");
+ }
+}
+
+/// Object › Flatten Transparency outlines frames of threaded text with Convert All Text to
+/// Outlines, and turns transparent frames into flat regions or an image: each such frame leaves
+/// its thread with the text it shows, and the other frames keep the text they hold. Undo threads
+/// the frames again. When the last frame is flattened, the frame before it takes the text it has
+/// no room for.
+#[test]
+fn flattened_frames_leave_their_thread_with_their_text() {
+ let cases = [(json!({"textToOutlines": true}), false), (json!({}), true), (json!({"balance": 0}), true)];
+ for (options, transparent) in cases {
+ for out in [&[0][..], &[1], &[2], &[0, 2]] {
+ let case = format!("{options} {out:?}");
+ let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
+ let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
+ if transparent {
+ s.execute("transparency.set", &json!({"ids": ids, "opacity": 50})).unwrap();
+ }
+ let shown = frames.map(|id| text(&s, id));
+ assert_eq!(shown.concat(), TEXT.repeat(4));
+ let mut p = options.clone();
+ p["ids"] = json!(ids);
+ s.execute("object.flattenTransparency", &p).unwrap();
+ let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
+ for id in &ids {
+ assert!(!is_frame(&s, *id), "{case}: frame {id} is flattened");
+ }
+ for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
+ assert_eq!(text(&s, *id), *before, "{case}: frame {id} keeps its text");
+ }
+ assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{case}");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [frames], "{case}: undo");
+ assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
+ }
+ }
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
+ let shown = [a, b, c].map(|id| text(&s, id));
+ let laid = {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
+ vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
+ };
+ assert!(laid.overflow, "the last frame has more text than it shows");
+ let end = laid.lines.last().map_or(0, |l| l.end);
+ let hidden = shown[2][end..].trim_start_matches(' ');
+ s.execute("object.flattenTransparency", &json!({"ids": [c], "textToOutlines": true})).unwrap();
+ assert_eq!(text(&s, a), shown[0]);
+ assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "the frame before it keeps its text and takes the rest");
+ assert_eq!(threads(&s), [[a, b]]);
+}
+
+/// Expand Appearance keeps type whose only effect is a shadow or Crop Marks as type under a new
+/// id, in a group under the frame's id: the type takes the frame's place in its thread, and
+/// each frame keeps its text, the last frame the text it has no room for too. Type in a group
+/// with Crop Marks keeps its id and stays in its thread.
+#[test]
+fn type_that_expand_appearance_keeps_takes_its_frames_place() {
+ for (effect, grouped) in [("stylize.dropShadow", false), ("cropMarks", false), ("cropMarks", true)] {
+ for k in [1, 2] {
+ let case = format!("{effect} grouped {grouped} frame {k}");
+ let (mut s, frames) = three_frames(&TEXT.repeat(12), 100.0);
+ let id = frames[k];
+ s.execute("select.set", &json!({"ids": [id]})).unwrap();
+ let target = if grouped { new_id(s.execute("object.group", &json!({})).unwrap()) } else { id };
+ s.execute("effect.apply", &json!({"effect": effect, "item": null, "ids": [target]})).unwrap();
+ let shown = frames.map(|id| text(&s, id));
+ s.execute("select.set", &json!({"ids": [target]})).unwrap();
+ s.execute("effect.expandAppearance", &json!({})).unwrap();
+ let mut types = vec![];
+ if let Some(n) = s.doc().unwrap().doc.node(NodeId(target)) {
+ n.walk(&mut |m| {
+ if matches!(m.kind, NodeKind::Text(_)) {
+ types.push(m.id.0);
+ }
+ });
+ }
+ let [kept] = types[..] else { panic!("{case}: the type is kept: {types:?}") };
+ assert_eq!(kept == id, grouped, "{case}: the type has a new id unless it was in a group");
+ let mut now = frames;
+ now[k] = kept;
+ assert_eq!(threads(&s), [now], "{case}: the type takes the frame's place");
+ assert_eq!(now.map(|id| text(&s, id)), shown, "{case}: each frame keeps its text");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [frames], "{case}: undo");
+ assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
+ }
+ }
+}
+
+/// The text that does not fit a thread's last frame, which its outlines do not draw, stays in
+/// the story: when the last frame is outlined, the frame before it takes that text after its
+/// own.
+#[test]
+fn outlining_the_last_frame_keeps_the_text_it_has_no_room_for() {
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
+ let shown = [a, b, c].map(|id| text(&s, id));
+ let laid = {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
+ vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
+ };
+ assert!(laid.overflow, "the last frame has more text than it shows");
+ let end = laid.lines.last().map_or(0, |l| l.end);
+ let hidden = shown[2][end..].trim_start_matches(' ');
+ s.execute("select.set", &json!({"ids": [c]})).unwrap();
+ s.execute("type.createOutlines", &json!({})).unwrap();
+ assert_eq!(text(&s, a), shown[0]);
+ assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "the frame before it keeps its text and takes the rest");
+ assert_eq!(threads(&s), [[a, b]]);
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!([a, b, c].map(|id| text(&s, id)), shown);
+}
+
+/// Object › Rasterize on frames of threaded text takes them out of their thread with the text
+/// they show, which the image draws, and the other frames keep the text they hold. Undo threads
+/// the frames again. When the last frame is rasterized, the frame before it takes the text it
+/// has no room for.
+#[test]
+fn rasterized_frames_leave_their_thread_with_their_text() {
+ for clip in [false, true] {
+ for out in [&[0][..], &[1], &[2], &[0, 2]] {
+ let case = format!("clippingMask {clip} {out:?}");
+ let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
+ let shown = frames.map(|id| text(&s, id));
+ assert_eq!(shown.concat(), TEXT.repeat(4));
+ let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
+ s.execute("select.set", &json!({"ids": ids})).unwrap();
+ s.execute("object.rasterize", &json!({"ppi": 36, "clippingMask": clip})).unwrap();
+ let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
+ for id in &ids {
+ assert!(!is_frame(&s, *id), "{case}: frame {id} is rasterized");
+ }
+ for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
+ assert_eq!(text(&s, *id), *before, "{case}: frame {id} keeps its text");
+ }
+ assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{case}");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [frames], "{case}: undo");
+ assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
+ }
+ }
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
+ let shown = [a, b, c].map(|id| text(&s, id));
+ let laid = {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
+ vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
+ };
+ assert!(laid.overflow, "the last frame has more text than it shows");
+ let end = laid.lines.last().map_or(0, |l| l.end);
+ let hidden = shown[2][end..].trim_start_matches(' ');
+ s.execute("select.set", &json!({"ids": [c]})).unwrap();
+ s.execute("object.rasterize", &json!({"ppi": 36})).unwrap();
+ assert_eq!(text(&s, a), shown[0]);
+ assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "the frame before it keeps its text and takes the rest");
+ assert_eq!(threads(&s), [[a, b]]);
+}
+
+/// Frame `id`'s first line: whether its first paragraph continues from the frame before, where
+/// its text starts from the frame's left edge, and how many list markers it starts with.
+fn first_line(s: &Session, id: u64) -> (bool, f64, usize) {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("not area type") };
+ let TextKind::Area { frame } = &t.kind else { panic!("not area type") };
+ let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
+ let l = &lay.lines[0];
+ let x = lay.glyphs[l.glyph_start..l.glyph_end].iter().find(|g| g.len > 0).map_or(f64::NAN, |g| g.origin.x);
+ let markers = lay.markers.iter().filter(|m| lay.glyphs[m.glyphs.start].line == 0).count();
+ (t.first_para_continues, (x - frame.bounds().unwrap().x0 - 1e-9).round(), markers)
+}
+
+/// A paragraph's first-line indent and bullet belong to its first line, in the frame it starts
+/// in: the frame it continues into starts at its left indent, without the bullet. Re-flowing,
+/// saving and opening keep it. In a frame that is no longer threaded and in a copy of a frame,
+/// the first paragraph has its first-line indent and bullet.
+#[test]
+fn a_paragraph_continued_into_the_next_frame_starts_it_without_its_first_line_indent_or_bullet() {
+ let (mut s, a, b) = setup();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ s.execute("text.setFormat", &json!({"ids": [a, b], "list": "bullet"})).unwrap();
+ assert_eq!((first_line(&s, a), first_line(&s, b)), ((false, 18.0, 1), (true, 18.0, 0)));
+ s.execute("text.setFormat", &json!({"ids": [a, b], "list": "none", "leftIndent": 0, "firstLineIndent": 24})).unwrap();
+ assert_eq!((first_line(&s, a), first_line(&s, b)), ((false, 24.0, 0), (true, 0.0, 0)));
+ assert_eq!(format!("{}{}", text(&s, a), text(&s, b)), TEXT.repeat(4));
+ // Typing re-flows the story and keeps it.
+ s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "NEW "})).unwrap();
+ assert_eq!(first_line(&s, b), (true, 0.0, 0));
+ // Saved and opened: a native file re-flows its threads, a restored document keeps its text.
+ for name in ["thread.vectorcraft", "thread.eps"] {
+ let bytes = if name.ends_with(".eps") {
+ let r = s.execute("document.exportEps", &json!({})).unwrap();
+ vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
+ } else {
+ vectorcraft_format::save(&s.doc().unwrap().doc, false)
+ };
+ let r = s.execute("document.open", &json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes)})).unwrap();
+ assert_eq!(r["restored"], name.ends_with(".eps"), "{r}");
+ assert_eq!(threads(&s), [[a, b]], "{name}");
+ assert_eq!((first_line(&s, a), first_line(&s, b)), ((false, 24.0, 0), (true, 0.0, 0)), "{name}");
+ }
+ // A copy of the second frame is in no thread, and starts with the indent.
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ let copy = s.execute("edit.duplicate", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
+ assert_eq!((first_line(&s, b), first_line(&s, copy)), ((true, 0.0, 0), (false, 24.0, 0)));
+ // …and so is a pasted one, and each copy's cached bounds and baselines are its own layout's.
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ let pasted = s.execute("edit.paste", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
+ let dragged = s.execute("layer.move", &json!({"ids": [b], "target": a, "place": "above", "copy": true})).unwrap()["ids"][0].as_u64().unwrap();
+ assert_eq!((first_line(&s, pasted), first_line(&s, dragged)), ((false, 24.0, 0), (false, 24.0, 0)));
+ // Every text object in the document has the cached bounds and baselines of its own layout.
+ let own_caches = |s: &Session, what: &str| {
+ let mut texts = vec![];
+ s.doc().unwrap().doc.walk(|n| {
+ if let NodeKind::Text(t) = &n.kind {
+ texts.push((n.id, t));
+ }
+ });
+ for (id, t) in texts {
+ let mut fresh = (**t).clone();
+ refresh_bounds(&mut fresh);
+ assert!(t.cached_bounds.is_some() && t.cached_bounds == fresh.cached_bounds, "{what}: {id:?}");
+ assert_eq!(t.cached_baselines, fresh.cached_baselines, "{what}: {id:?}");
+ }
+ };
+ own_caches(&s, "copies");
+ // Release to Layers (Build), Release Opacity Mask, Edit Opacity Mask and Draw Inside copy the
+ // frame too.
+ let layer = s.doc().unwrap().doc.layer_containing(NodeId(b)).unwrap().0;
+ s.execute("layer.releaseToLayers", &json!({"id": layer, "build": true})).unwrap();
+ own_caches(&s, "Release to Layers (Build)");
+ s.execute("edit.undo", &json!({})).unwrap();
+ s.execute("transparency.makeOpacityMask", &json!({"ids": [a, b]})).unwrap();
+ s.execute("transparency.releaseOpacityMask", &json!({})).unwrap();
+ own_caches(&s, "Release Opacity Mask");
+ s.execute("edit.undo", &json!({})).unwrap();
+ s.execute("transparency.editOpacityMask", &json!({"id": a})).unwrap();
+ own_caches(&s, "Edit Opacity Mask");
+ s.execute("transparency.stopEditingOpacityMask", &json!({})).unwrap();
+ for _ in 0..3 {
+ s.execute("edit.undo", &json!({})).unwrap();
+ }
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("view.drawMode", &json!({"mode": "inside"})).unwrap();
+ s.execute("shape.rectangle", &json!({"x": 210, "y": 20, "width": 20, "height": 20})).unwrap();
+ own_caches(&s, "Draw Inside");
+ s.execute("edit.undo", &json!({})).unwrap();
+ s.execute("view.drawMode", &json!({"mode": "normal"})).unwrap();
+ assert_eq!((threads(&s), first_line(&s, b)), (vec![vec![a, b]], (true, 0.0, 0)));
+ // Remove Threading: each frame keeps its text, and its first paragraph starts in it.
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("text.thread.remove", &json!({})).unwrap();
+ assert_eq!(first_line(&s, b), (false, 24.0, 0));
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(first_line(&s, b), (true, 0.0, 0));
+ // Released, the frame is empty and starts the next text typed into it as a paragraph.
+ let continues = |s: &Session, id: u64| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+ NodeKind::Text(t) => t.first_para_continues,
+ _ => panic!("not text"),
+ };
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert!(text(&s, b).is_empty() && !continues(&s, b));
+ s.execute("edit.undo", &json!({})).unwrap();
+ // With the first frame released, the second one holds the whole story and starts it.
+ s.execute("select.set", &json!({"ids": [a]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert!(threads(&s).is_empty() && text(&s, a).is_empty());
+ assert_eq!(first_line(&s, b), (false, 24.0, 0));
+ s.execute("edit.undo", &json!({})).unwrap();
+ // Converted to point type, it is in no thread, and its first line starts at the indent where
+ // the frame's left edge was.
+ let left = frame_box(&s, b).x0;
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("type.convertToPointType", &json!({})).unwrap();
+ assert!(!continues(&s, b));
+ {
+ let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(b)).unwrap().kind else { panic!("not text") };
+ let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
+ let g = lay.glyphs.iter().find(|g| g.len > 0).unwrap();
+ let x = (t.xf * g.origin).x - left;
+ assert!((x - 24.0).abs() < 1e-6, "{x}");
+ }
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(first_line(&s, b), (true, 0.0, 0));
+ // Text that ends the first frame with a paragraph break: the second frame starts a
+ // paragraph, with its indent.
+ let all = text(&s, a).len();
+ s.execute("text.editRange", &json!({"id": a, "start": 0, "end": all, "insert": "Short line.\n".repeat(12)})).unwrap();
+ assert!(text(&s, a).ends_with('\n'), "{:?}", text(&s, a));
+ assert_eq!(first_line(&s, b), (false, 24.0, 0));
+}
+
+/// When Create Outlines takes frames out of a thread, a frame that now starts its thread or is
+/// in no thread starts its paragraph with the first-line indent; a frame after one that ends
+/// inside the paragraph still continues it. The frames that stay hold each character they held
+/// once, and keep their text when no mark changes. Undo marks the frames again.
+#[test]
+fn a_frame_that_starts_its_thread_after_outlining_has_its_first_line_indent() {
+ for (out, want) in [
+ (&[0][..], [None, Some(false), Some(true)]),
+ (&[0, 2], [None, Some(false), None]),
+ (&[1], [Some(false), None, Some(true)]),
+ (&[2], [Some(false), Some(true), None]),
+ ] {
+ let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
+ s.execute("text.setFormat", &json!({"ids": frames, "leftIndent": 0, "firstLineIndent": 24})).unwrap();
+ let before = frames.map(|id| first_line(&s, id));
+ assert_eq!(before, [(false, 24.0, 0), (true, 0.0, 0), (true, 0.0, 0)], "{out:?}");
+ let shown = frames.map(|id| text(&s, id));
+ assert_eq!(shown.concat(), TEXT.repeat(4), "{out:?}: the last frame has room for the rest");
+ let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
+ s.execute("select.set", &json!({"ids": ids})).unwrap();
+ s.execute("type.createOutlines", &json!({})).unwrap();
+ let stay: Vec<usize> = (0..3).filter(|k| want[*k].is_some()).collect();
+ for k in &stay {
+ let on = want[*k] == Some(true);
+ let indent = if on { 0.0 } else { 24.0 };
+ assert_eq!(first_line(&s, frames[*k]), (on, indent, 0), "{out:?}: frame {k}");
+ }
+ let held: String = stay.iter().map(|k| shown[*k].as_str()).collect();
+ assert_eq!(stay.iter().map(|k| text(&s, frames[*k])).collect::<String>(), held, "{out:?}: each character once");
+ if stay.iter().all(|k| want[*k] == Some(before[*k].0)) {
+ for k in &stay {
+ assert_eq!(text(&s, frames[*k]), shown[*k], "{out:?}: frame {k} keeps its text");
+ }
+ }
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(frames.map(|id| first_line(&s, id)), before, "{out:?}: undo");
+ }
+}
+
+/// The text that a thread's last frame has no room for is measured as the frame lays it out,
+/// without the first-line indent of the paragraph it continues: when the frame is outlined, the
+/// frame before it takes only that text.
+#[test]
+fn outlining_a_continued_last_frame_keeps_only_the_text_it_has_no_room_for() {
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
+ s.execute("text.setFormat", &json!({"ids": [a, b, c], "leftIndent": 0, "firstLineIndent": 72})).unwrap();
+ assert_eq!(first_line(&s, c), (true, 0.0, 0));
+ let shown = [a, b, c].map(|id| text(&s, id));
+ let laid = {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
+ vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
+ };
+ assert!(laid.overflow, "the last frame has more text than it shows");
+ let end = laid.lines.last().map_or(0, |l| l.end);
+ let hidden = shown[2][end..].trim_start_matches(' ');
+ s.execute("select.set", &json!({"ids": [c]})).unwrap();
+ s.execute("type.createOutlines", &json!({})).unwrap();
+ assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]));
+}
+
+/// The text that a thread's last frame has no room for is measured with the frame's numbered
+/// paragraphs counted on from the frames before it: when the frame is outlined, the frame before
+/// it takes only that text.
+#[test]
+fn outlining_a_numbered_last_frame_keeps_only_the_text_it_has_no_room_for() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let items: String = (1..=7).map(|i| format!("Item {i}\n")).collect();
+ let story = format!("{items}{}", TEXT.repeat(4));
+ let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 106}})).unwrap());
+ let c = new_id(s.execute("text.create", &json!({"x": 200, "y": 10, "text": "", "area": {"width": 150, "height": 20}})).unwrap());
+ s.execute("text.thread.add", &json!({"from": a, "to": c})).unwrap();
+ // A hanging indent that "I." fits and "VIII." does not: the text after "VIII." starts at
+ // the next tab stop.
+ s.execute("text.setFormat", &json!({"ids": [a, c], "number": "upperRoman", "leftIndent": 14, "firstLineIndent": -14})).unwrap();
+ let shown = [a, c].map(|id| text(&s, id));
+ assert!(shown[0].ends_with("Item 7\n") && shown[1].starts_with("The quick"), "{shown:?}");
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)).cloned() else { panic!("not area type") };
+ assert_eq!(t.list_count, 7);
+ let laid = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
+ assert_eq!(laid.markers.first().map(|m| m.text.as_str()), Some("VIII."));
+ assert!(laid.overflow, "the last frame has more text than it shows");
+ let end = laid.lines.last().map_or(0, |l| l.end);
+ let from_one = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &TextObject { list_count: 0, ..t });
+ assert_ne!(from_one.lines.last().map_or(0, |l| l.end), end, "counted from 1, the frame would show other text");
+ let hidden = shown[1][end..].trim_start_matches(' ');
+ s.execute("select.set", &json!({"ids": [c]})).unwrap();
+ s.execute("type.createOutlines", &json!({})).unwrap();
+ assert_eq!(text(&s, a), format!("{}{hidden}", shown[0]));
+}
+
+/// A story of one-line paragraphs that each start with a quotation mark, threaded from area
+/// type `a` into the rectangle `b`, which shows the paragraphs that `a` has no room for.
+fn quoted_thread() -> (Session, u64, u64) {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let story = "“Quoted.”\n".repeat(20);
+ let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 60}})).unwrap());
+ let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ assert!(text(&s, b).starts_with('“'));
+ (s, a, b)
+}
+
+/// Frame `id`'s Optical Margin Alignment setting, and whether its glyphs start left of its frame
+/// (its lines' opening quotation marks hang).
+fn optical(s: &Session, id: u64) -> (bool, bool) {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("not area type") };
+ let TextKind::Area { frame } = &t.kind else { panic!("not area type") };
+ (t.optical_margin, t.cached_bounds.unwrap().x0 < frame.bounds().unwrap().x0 - 1.0)
+}
+
+/// Optical Margin Alignment is a setting of the whole thread: Type › Optical Margin Alignment
+/// in any frame sets it in every frame of the thread, in one undo step, and the lines in every
+/// frame hang. Typing keeps it, and frames taken out of the thread keep it.
+#[test]
+fn optical_margin_alignment_is_set_for_every_frame_of_a_thread() {
+ let (mut s, a, b) = quoted_thread();
+ assert_eq!((optical(&s, a), optical(&s, b)), ((false, false), (false, false)));
+ s.execute("select.set", &json!({"ids": [a]})).unwrap();
+ let r = s.execute("type.opticalMarginAlignment", &json!({})).unwrap();
+ assert_eq!(r, json!({"on": true, "ids": [a, b]}));
+ assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)), "the second frame's lines hang too");
+ // Turned off from the second frame, it is off in both, and one undo turns it back on in both.
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ assert_eq!(s.execute("type.opticalMarginAlignment", &json!({})).unwrap()["on"], false);
+ assert_eq!((optical(&s, a), optical(&s, b)), ((false, false), (false, false)));
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
+ // Typing in the first frame re-flows the story and keeps the setting.
+ s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "“New.”\n"})).unwrap();
+ assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
+ // Any edit that sets one frame sets the thread.
+ s.edit("Set", |d, _| {
+ let Some(NodeKind::Text(t)) = d.node_mut(NodeId(b)).map(|n| &mut n.kind) else { panic!("not text") };
+ t.optical_margin = false;
+ refresh_bounds(t);
+ Ok(())
+ })
+ .unwrap();
+ assert_eq!((optical(&s, a), optical(&s, b)), ((false, false), (false, false)));
+ s.execute("edit.undo", &json!({})).unwrap();
+ // Released or unthreaded, each frame keeps it.
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert_eq!((optical(&s, a).0, optical(&s, b).0), (true, true));
+ s.execute("edit.undo", &json!({})).unwrap();
+ s.execute("text.thread.remove", &json!({})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
+}
+
+/// Threading type into a thread gives the joined thread the setting of its first frame.
+#[test]
+fn a_thread_takes_its_first_frames_optical_margin_alignment() {
+ let (mut s, a, b) = quoted_thread();
+ s.execute("text.thread.remove", &json!({})).unwrap();
+ s.execute("type.opticalMarginAlignment", &json!({"ids": [a], "on": true})).unwrap();
+ assert_eq!((optical(&s, a).0, optical(&s, b).0), (true, false));
+ // Threaded again in stacking order: the second frame takes the first one's setting.
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ assert_eq!((optical(&s, a), optical(&s, b)), ((true, true), (true, true)));
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!((optical(&s, a).0, optical(&s, b).0), (true, false));
+ // From `b`'s out port into `a`: `a` joins `b`'s thread after it and takes its setting.
+ s.execute("text.thread.add", &json!({"from": b, "to": a})).unwrap();
+ assert_eq!(threads(&s), [[b, a]]);
+ assert_eq!((optical(&s, a).0, optical(&s, b).0), (false, false));
+ // A new frame threaded from a frame takes the thread's setting.
+ s.execute("type.opticalMarginAlignment", &json!({"ids": [a], "on": true})).unwrap();
+ let c = new_id(s.execute("text.thread.add", &json!({"from": a, "at": [400, 10]})).unwrap());
+ assert_eq!([a, b, c].map(|id| optical(&s, id).0), [true; 3]);
+}
+
+/// A file saved with the frames of one thread set differently opens with the first frame's
+/// setting in every frame: a native file, and an EPS file restored from the document it carries.
+#[test]
+fn a_thread_saved_with_differing_frames_opens_with_the_first_frames_setting() {
+ let (mut s, a, b) = quoted_thread();
+ for (first, name) in [(true, "old.vectorcraft"), (false, "old.vectorcraft"), (true, "old.eps"), (false, "old.eps")] {
+ for (id, on) in [(a, first), (b, !first)] {
+ let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+ let Some(NodeKind::Text(t)) = doc.node_mut(NodeId(id)).map(|n| &mut n.kind) else { panic!("not text") };
+ t.optical_margin = on;
+ }
+ let bytes = if name.ends_with(".eps") {
+ let r = s.execute("document.exportEps", &json!({})).unwrap();
+ vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
+ } else {
+ vectorcraft_format::save(&s.doc().unwrap().doc, false)
+ };
+ let r = s.execute("document.open", &json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes)})).unwrap();
+ assert_eq!(r["restored"], name.ends_with(".eps"), "{r}");
+ assert_eq!(threads(&s), [[a, b]], "{name}");
+ assert_eq!((optical(&s, a), optical(&s, b)), ((first, first), (first, first)), "{name}, first frame {first}");
+ }
+}
+
+/// One count runs through a thread: the second frame's numbered paragraphs go on from the
+/// first frame's, also after an edit, a save and a reopen. A pasted or duplicated copy of a
+/// frame, a frame converted to point type, the frames of a thread that Remove Threading breaks
+/// and the frame a Release Selection leaves alone count from 1.
+#[test]
+fn numbered_list_paragraphs_count_on_through_a_thread() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let items = (1..=10).map(|i| format!("Item {i}")).collect::<Vec<_>>().join("\n");
+ let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": items, "area": {"width": 150, "height": 60}})).unwrap());
+ let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ s.execute("text.setFormat", &json!({"ids": [a, b], "list": "number"})).unwrap();
+ let numbers = |s: &Session, id: u64| {
+ let Some(NodeKind::Text(t)) = s.doc().unwrap().doc.node(NodeId(id)).map(|n| &n.kind) else { panic!("text") };
+ vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).markers.iter().map(|m| m.text.clone()).collect::<Vec<_>>()
+ };
+ let all = |from: usize| (from..=10).map(|n| format!("{n}.")).collect::<Vec<_>>();
+ let first = numbers(&s, a);
+ assert!((2..10).contains(&first.len()), "both frames hold items: {first:?}");
+ assert_eq!([first.clone(), numbers(&s, b)].concat(), all(1));
+ // Typing a paragraph into the first frame numbers it and moves the rest on.
+ s.execute("text.editRange", &json!({"id": a, "start": 0, "end": 0, "insert": "Item 0\n"})).unwrap();
+ assert_eq!([numbers(&s, a), numbers(&s, b)].concat(), [vec!["1.".to_string()], all(2), vec!["11.".to_string()]].concat());
+ s.execute("edit.undo", &json!({})).unwrap();
+ let reopened = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
+ let Some(NodeKind::Text(back)) = reopened.node(NodeId(b)).map(|n| &n.kind) else { panic!("text") };
+ let after: Vec<String> = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), back).markers.iter().map(|m| m.text.clone()).collect();
+ assert_eq!(after, all(first.len() + 1), "reopened");
+ // A pasted copy of the second frame is in no thread.
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ s.execute("edit.paste", &json!({})).unwrap();
+ let copy = s.doc().unwrap().selection.objects.first().copied().unwrap();
+ assert_ne!(copy, NodeId(b));
+ assert_eq!(numbers(&s, copy.0).first().map(String::as_str), Some("1."));
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ let duplicate = s.execute("edit.duplicate", &json!({"dx": 10})).unwrap()["ids"][0].as_u64().unwrap();
+ assert_eq!(numbers(&s, duplicate).first().map(String::as_str), Some("1."), "a duplicate");
+ let layer = s.doc().unwrap().doc.layers[0].id.0;
+ let moved = s.execute("layer.move", &json!({"ids": [b], "target": layer, "copy": true})).unwrap()["ids"][0].as_u64().unwrap();
+ assert_eq!(numbers(&s, moved).first().map(String::as_str), Some("1."), "a copy dragged in the Layers panel");
+ assert_eq!(numbers(&s, b), all(first.len() + 1), "the frame itself");
+ // Convert To Point Type takes the second frame out of the thread with its text.
+ s.execute("type.convertToPointType", &json!({"ids": [b]})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert_eq!(numbers(&s, b).first().map(String::as_str), Some("1."), "the frame converted to point type");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(numbers(&s, b), all(first.len() + 1), "undo");
+ // Remove Threading: each frame is a story of its own.
+ s.execute("select.set", &json!({"ids": [a]})).unwrap();
+ s.execute("text.thread.remove", &json!({})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert_eq!(numbers(&s, b).first().map(String::as_str), Some("1."));
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(numbers(&s, b), all(first.len() + 1), "undo");
+ // Release Selection of the first frame: the second one holds the whole story, from 1.
+ s.execute("select.set", &json!({"ids": [a]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert_eq!(numbers(&s, b), all(1), "the frame left holds the story");
+}
+
+/// New Symbol from a numbered thread keeps each frame's count in the symbol's art, so the art
+/// looks as it did; Break Link puts the frames in no thread, and each counts from 1.
+#[test]
+fn a_symbol_made_of_a_numbered_thread_keeps_its_numbers() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let items = (1..=10).map(|i| format!("Item {i}")).collect::<Vec<_>>().join("\n");
+ let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": items, "area": {"width": 150, "height": 60}})).unwrap());
+ let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ s.execute("text.setFormat", &json!({"ids": [a, b], "list": "number"})).unwrap();
+ let count = |t: &TextObject| t.list_count;
+ let carried = text_of(&s.doc().unwrap().doc, NodeId(b)).map(count).unwrap();
+ assert!(carried > 0);
+ let instance = new_id(s.execute("symbol.new", &json!({"name": "Numbered"})).unwrap());
+ let counts = |n: &Node| {
+ let mut counts = vec![];
+ n.walk(&mut |n| {
+ if let NodeKind::Text(t) = &n.kind {
+ counts.push(t.list_count);
+ }
+ });
+ counts.sort_unstable();
+ counts
+ };
+ let doc = &s.doc().unwrap().doc;
+ assert_eq!(counts(&doc.symbols.iter().find(|x| x.name == "Numbered").unwrap().art), [0, carried]);
+ // Break Link puts the frames on the artboard in no thread: each counts from 1.
+ s.execute("select.set", &json!({"ids": [instance]})).unwrap();
+ s.execute("symbol.breakLink", &json!({})).unwrap();
+ let doc = &s.doc().unwrap().doc;
+ assert_eq!(doc.layers.iter().flat_map(|l| counts(l)).collect::<Vec<_>>(), [0, 0]);
+}
+
+/// The text of each frame in symbol `name`'s art, sorted.
+fn symbol_texts(s: &Session, name: &str) -> Vec<String> {
+ let doc = &s.doc().unwrap().doc;
+ let Some(sym) = doc.symbols.iter().find(|x| x.name == name) else { panic!("no symbol {name}") };
+ let mut texts = vec![];
+ sym.art.walk(&mut |n| {
+ if let NodeKind::Text(t) = &n.kind {
+ texts.push(t.plain_text());
+ }
+ });
+ texts.sort();
+ texts
+}
+
+/// New Symbol and Redefine Symbol on frames of threaded text replace them with an instance
+/// whose art holds the text they show, and the frames leave their thread: the other frames keep
+/// the text they hold, so each character is drawn once. Undo threads the frames again. When the
+/// last frame goes into the symbol, the frame before it takes the text it has no room for, and
+/// the symbol's art holds only the text the frame shows.
+#[test]
+fn frames_made_into_a_symbol_leave_their_thread_with_their_text() {
+ let symbol = |s: &mut Session, command: &str, ids: &[u64]| {
+ let name = if command == "symbol.update" {
+ let mark = new_id(s.execute("shape.rectangle", &json!({"x": 400, "y": 200, "width": 20, "height": 20})).unwrap());
+ s.execute("select.set", &json!({"ids": [mark]})).unwrap();
+ s.execute("symbol.new", &json!({"name": "Mark"})).unwrap();
+ "Mark"
+ } else {
+ "Story"
+ };
+ s.execute("select.set", &json!({"ids": ids})).unwrap();
+ s.execute(command, &json!({"name": name})).unwrap();
+ name
+ };
+ for command in ["symbol.new", "symbol.update"] {
+ for out in [&[0][..], &[1], &[2], &[0, 2]] {
+ let case = format!("{command} {out:?}");
+ let (mut s, frames) = three_frames(&TEXT.repeat(4), 200.0);
+ let shown = frames.map(|id| text(&s, id));
+ assert_eq!(shown.concat(), TEXT.repeat(4));
+ let ids: Vec<u64> = out.iter().map(|k| frames[*k]).collect();
+ let name = symbol(&mut s, command, &ids);
+ let rest: Vec<u64> = frames.iter().copied().filter(|id| !ids.contains(id)).collect();
+ for id in &ids {
+ assert!(!is_frame(&s, *id), "{case}: frame {id} is in the symbol");
+ }
+ let mut held: Vec<String> = out.iter().map(|k| shown[*k].clone()).collect();
+ held.sort();
+ assert_eq!(symbol_texts(&s, name), held, "{case}: the symbol's art holds the text the frames show");
+ for (id, before) in frames.iter().zip(&shown).filter(|(id, _)| rest.contains(id)) {
+ assert_eq!(text(&s, *id), *before, "{case}: frame {id} keeps its text");
+ }
+ assert_eq!(threads(&s), if rest.len() >= 2 { vec![rest] } else { vec![] }, "{case}");
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(threads(&s), [frames], "{case}: undo");
+ assert_eq!(frames.map(|id| text(&s, id)), shown, "{case}: undo");
+ }
+ let (mut s, [a, b, c]) = three_frames(&TEXT.repeat(12), 100.0);
+ let shown = [a, b, c].map(|id| text(&s, id));
+ let laid = {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(c)) else { panic!("not area type") };
+ vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t)
+ };
+ assert!(laid.overflow, "the last frame has more text than it shows");
+ let end = laid.lines.last().map_or(0, |l| l.end);
+ let hidden = shown[2][end..].trim_start_matches(' ');
+ let name = symbol(&mut s, command, &[c]);
+ assert_eq!(text(&s, a), shown[0], "{command}");
+ assert_eq!(text(&s, b), format!("{}{hidden}", shown[1]), "{command}: the frame before it keeps its text and takes the rest");
+ assert_eq!(threads(&s), [[a, b]], "{command}");
+ let held = symbol_texts(&s, name);
+ let held: Vec<&str> = held.iter().map(|t| t.trim_end()).collect();
+ assert_eq!(held, [shown[2][..end].trim_end()], "{command}: the symbol's art holds what the frame shows");
+ // With every frame of the thread in the symbol, the last frame keeps all its text.
+ let (mut s, frames) = three_frames(&TEXT.repeat(12), 100.0);
+ let mut shown = frames.map(|id| text(&s, id)).to_vec();
+ shown.sort();
+ let name = symbol(&mut s, command, &frames);
+ assert_eq!(symbol_texts(&s, name), shown, "{command}: the whole thread");
+ assert!(threads(&s).is_empty(), "{command}: the whole thread");
+ }
+}
+
+/// A frame of a numbered thread pasted while an opacity mask is edited numbers from 1 in the
+/// mask art too.
+#[test]
+fn a_frame_pasted_into_an_edited_opacity_mask_numbers_from_1() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let items = (1..=10).map(|i| format!("Item {i}")).collect::<Vec<_>>().join("\n");
+ let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": items, "area": {"width": 150, "height": 60}})).unwrap());
+ let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap());
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ s.execute("text.setFormat", &json!({"ids": [a, b], "list": "number"})).unwrap();
+ assert!(text_of(&s.doc().unwrap().doc, NodeId(b)).is_some_and(|t| t.list_count > 0));
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ let obj = new_id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 400, "height": 280})).unwrap());
+ let m = new_id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 200})).unwrap());
+ s.execute("select.set", &json!({"ids": [obj, m]})).unwrap();
+ s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
+ s.execute("transparency.editOpacityMask", &json!({})).unwrap();
+ s.execute("edit.paste", &json!({})).unwrap();
+ let doc = &s.doc().unwrap().doc;
+ let mut counts = vec![];
+ doc.node(NodeId(obj)).unwrap().extras().mask.as_ref().unwrap().art.walk(&mut |n| {
+ if let NodeKind::Text(t) = &n.kind {
+ counts.push(t.list_count);
+ }
+ });
+ assert_eq!(counts, [0], "the pasted frame in the mask art");
+}
+
+/// A duplicate of a frame that carried a count of 99 or more numbers from 1 and has the layout
+/// bounds of what it draws: "01." leaves the text at the left indent, where a three-digit
+/// number pushed it on to the next tab stop and the paragraph took more lines.
+#[test]
+fn a_duplicated_frame_numbers_from_1_with_its_own_bounds() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+ let story = format!("{}Itemized lists paragraph text", "x\n".repeat(110));
+ let a = new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 1500}})).unwrap());
+ let b = new_id(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 100, "height": 300})).unwrap());
+ s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ s.execute("text.setFormat", &json!({"ids": [a, b], "number": "twoDigits"})).unwrap();
+ s.execute("select.set", &json!({"ids": [b]})).unwrap();
+ let copy = s.execute("edit.duplicate", &json!({"dx": 200})).unwrap()["ids"][0].as_u64().unwrap();
+ let laid = |s: &Session, id: u64| {
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(id)) else { panic!("area type") };
+ let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
+ (lay.markers[0].text.clone(), lay.lines.len(), lay.bounds, t.cached_bounds.unwrap())
+ };
+ let (number, lines, _, _) = laid(&s, b);
+ let (copy_number, copy_lines, bounds, cached) = laid(&s, copy);
+ assert!(number.len() == 4 && number.starts_with('1'), "a three-digit number: {number}");
+ assert_eq!(copy_number, "01.");
+ assert!(copy_lines < lines, "{copy_lines} {lines}");
+ assert!((cached.y1 - bounds.y1).abs() < 1e-6, "the copy's bounds: {cached:?} {bounds:?}");
+}
+
+/// Release Selection that leaves one frame of a thread gives that frame the whole story and
+/// the layout bounds of its new text.
+#[test]
+fn the_frame_a_release_leaves_alone_has_the_bounds_of_the_whole_story() {
+ let (mut s, a, b) = setup();
+ s.execute("text.thread.create", &json!({})).unwrap();
+ s.execute("select.set", &json!({"ids": [a]})).unwrap();
+ s.execute("text.thread.releaseSelection", &json!({})).unwrap();
+ assert!(threads(&s).is_empty());
+ assert_eq!(text(&s, b), TEXT.repeat(4));
+ let Some(t) = text_of(&s.doc().unwrap().doc, NodeId(b)) else { panic!("area type") };
+ let bounds = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).bounds;
+ let cached = t.cached_bounds.unwrap();
+ assert!((cached.y0 - bounds.y0).abs() < 1e-6 && (cached.y1 - bounds.y1).abs() < 1e-6, "{cached:?} {bounds:?}");
+}