Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge #274: Text frames: column rules on screen, in PDF and in IDML; Column Rules in Text Frame Options

aiongg66d6479c0967
diff --cc crates/compose/src/tests.rs
index b815b015e,67f5541f6..1d21c3330
--- a/crates/compose/src/tests.rs
+++ b/crates/compose/src/tests.rs
@@@ -3082,493 -1878,119 +3082,610 @@@ fn vertical_lines_fit_the_em_box()
}
}
+/// A drop cap set in one of the document's own fonts measures its side bearing in that font.
+#[test]
+fn drop_cap_in_a_document_font_aligns_its_left_edge() {
+ use designcraft_geom::Shape as _;
+ const FAMILY: &str = "DocFont Drop Cap";
+ let text = format!("Once {LOREM}");
+ let mut chars: Vec<char> = text.chars().collect();
+ chars.sort_unstable();
+ chars.dedup();
+ let folder = std::env::temp_dir().join(format!("dc-compose-dropcap-docfont-{}", std::process::id()));
+ std::fs::create_dir_all(&folder).unwrap();
+ std::fs::write(folder.join("dropcap.ttf"), designcraft_fonts::testing::font_with_glyph(FAMILY, &chars, 'O').unwrap()).unwrap();
+ let scope = designcraft_fonts::FontDb::global().load_document_fonts(&folder).scope;
+ let para = ParaAttrs { left_indent: Some(10.0), ..drop_cap(2, 1) };
+ let (mut d, sid, _) = doc_with(&text, Rect::new(0.0, 0.0, 300.0, 1000.0), para);
+ d.font_scope = scope;
+ d.story_mut(sid).unwrap().format_chars(0..text.len(), |f| f.over.font_family = Some(FAMILY.into()));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let dc = &all_lines(&cs)[0].glyphs[0];
+ assert_eq!(dc.face.family, FAMILY);
+ let ink_left = dc.x + designcraft_fonts::FontDb::global().outline(dc.face.get(), dc.gid).bounding_box().x0 * dc.sx;
+ assert!(ink_left - dc.x > 0.5, "the O has a visible side bearing");
+ assert!((ink_left - 10.0).abs() < 1e-6, "ink at {ink_left}");
+ let _ = std::fs::remove_dir_all(&folder);
+}
+
+#[test]
+fn embedded_text_frames_compose_and_footnotes_retain_object_sources() {
+ use designcraft_doc::{AnchorPosition, AnchoredObject};
+ let (mut d, body, _) = doc_with("Body", Rect::new(20.0, 20.0, 400.0, 600.0), ParaAttrs::default());
+ let (fid, child) =
+ d.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 80.0, 40.0), d.default_layer(), "Embedded", ParaFormat::default()).unwrap();
+ let item = d.item(fid).unwrap().clone();
+ d.spread_mut(SpreadRef::Doc(0)).unwrap().items.retain(|i| i.id != fid);
+ let story = d.story_mut(body).unwrap();
+ story.insert_note(4, "Note", ParaFormat::default());
+ Arc::make_mut(&mut story.notes[0]).text.insert_object(0, AnchoredObject::new(item, AnchorPosition::Inline { y_offset: 0.0 }));
+ d.check().unwrap();
+ let child_cs = compose_story(&d, child, &ComposeOptions::default());
+ assert!(!child_cs.is_overset());
+ assert!(!child_cs.frame(fid).unwrap().lines.is_empty());
+ let cs = compose_story(&d, body, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ let note = &cs.frames[0].notes[0];
+ assert_eq!(note.text.story, StoryId(0));
+ assert_eq!(note.text.frames[0].objects[0].object.item.id, fid);
+
+ let cache = Cache::new();
+ assert!(!cache.get(&d, child, None).is_overset());
+ let note = Arc::make_mut(&mut d.story_mut(body).unwrap().notes[0]);
+ let anchor = Arc::make_mut(&mut note.text.objects[0]);
+ let original_path = anchor.item.path.clone();
+ anchor.item.path = designcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 80.0, 1.0));
+ assert!(cache.get(&d, child, None).is_overset(), "embedded frame geometry must invalidate cached composition");
+ Arc::make_mut(&mut Arc::make_mut(&mut d.story_mut(body).unwrap().notes[0]).text.objects[0]).item.path = original_path;
+
+ // A reference back into the owning story must be rejected before rendering.
+ let mut cycle = d.anchored_item(fid).unwrap().clone();
+ cycle.id = ItemId(d.alloc());
+ cycle.text_frame_mut().unwrap().story = body;
+ d.story_mut(body).unwrap().frames.push(cycle.id);
+ d.story_mut(child).unwrap().insert_object(0, AnchoredObject::new(cycle, AnchorPosition::Inline { y_offset: 0.0 }));
+ assert!(d.check().unwrap_err().to_string().contains("cyclic"));
+}
+
+#[test]
+fn inline_object_only_line_does_not_reserve_phantom_font_descent() {
+ use designcraft_doc::{AnchorPosition, AnchoredObject, Item, Shape};
+ let (mut d, sid, _) = doc_with("", Rect::new(0.0, 0.0, 10.0, 15.0), ParaAttrs::default());
+ let item = Item::new(ItemId(d.alloc()), d.default_layer(), Shape::Rectangle, designcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 7.0, 9.0)));
+ d.story_mut(sid).unwrap().insert_object(0, AnchoredObject::new(item, AnchorPosition::Inline { y_offset: 5.0 }));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ assert_eq!(cs.frames[0].objects.len(), 1);
+ assert_eq!(cs.frames[0].lines[0].descent, 0.0);
+ // Genuine geometric overflow must still be reported.
+ d.story_mut(sid).unwrap().objects[0] =
+ Arc::new(AnchoredObject::new(cs.frames[0].objects[0].object.item.clone(), AnchorPosition::Inline { y_offset: 7.0 }));
+ assert!(compose_story(&d, sid, &ComposeOptions::default()).is_overset());
+}
+
+#[test]
+fn composite_metrics_and_character_mappings_apply_inside_footnotes() {
+ use designcraft_doc::cjk::{CompositeFont, CompositeFontEntry};
+ let (mut d, sid, _) = doc_with("Body", Rect::new(0.0, 0.0, 300.0, 300.0), ParaAttrs::default());
+ d.styles_mut().composite_fonts.push(CompositeFont {
+ name: "Mixed".into(),
+ entries: vec![
+ CompositeFontEntry { family: "Source Serif 4".into(), ..Default::default() },
+ CompositeFontEntry {
+ characters: "12".into(),
+ family: "Source Sans 3".into(),
+ relative_size: 0.8,
+ horizontal_scale: 0.9,
+ vertical_scale: 1.1,
+ baseline_shift: 0.1,
+ scale_option: false,
+ ..Default::default()
+ },
+ CompositeFontEntry { characters: "2".into(), family: "Inter".into(), ..Default::default() },
+ ],
+ });
+ let story = d.story_mut(sid).unwrap();
+ story.insert_note(4, "A12", ParaFormat::default());
+ let note = Arc::make_mut(&mut story.notes[0]);
+ note.text.format_chars(0..3, |f| f.over.font_family = Some("CompositeFont/Mixed".into()));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let note = &cs.frames[0].notes[0];
+ let glyphs = &note.text.frames[0].lines[0].glyphs;
+ let a = glyphs.iter().find(|g| g.byte == 0 && g.len > 0).unwrap();
+ let one = glyphs.iter().find(|g| g.byte == 1 && g.len > 0).unwrap();
+ let two = glyphs.iter().find(|g| g.byte == 2 && g.len > 0).unwrap();
+ assert_eq!(a.face.family, "Source Serif 4");
+ assert_eq!(one.face.family, "Source Sans 3");
+ assert_eq!(two.face.family, "Inter");
+ let style = &note.text.styles[one.style as usize];
+ assert!((style.size - 9.6).abs() < 1e-8);
+ assert!(!note.text.styles.iter().any(|s| s.missing_font));
+}
+
+#[test]
+fn generated_note_labels_resolve_composite_components_and_keep_one_anchor() {
+ use designcraft_doc::cjk::{CompositeFont, CompositeFontEntry};
+ let (mut d, sid, _) = doc_with("Body", Rect::new(0.0, 0.0, 300.0, 300.0), ParaAttrs::default());
+ d.styles_mut().composite_fonts.push(CompositeFont {
+ name: "Generated Mixed".into(),
+ entries: vec![
+ CompositeFontEntry { family: "Source Serif 4".into(), ..Default::default() },
+ CompositeFontEntry { characters: "[]".into(), family: "Inter".into(), relative_size: 0.8, ..Default::default() },
+ ],
+ });
+ d.footnote_options.affix_in = designcraft_doc::notes::AffixIn::Both;
+ d.footnote_options.prefix = "[".into();
+ d.footnote_options.suffix = "]".into();
+ let story = d.story_mut(sid).unwrap();
+ story.insert_note(4, "Note", ParaFormat::default());
+ story.format_chars(4..7, |f| f.over.font_family = Some("Generated Mixed".into()));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let glyphs: Vec<_> = cs.frames[0].lines.iter().flat_map(|l| &l.glyphs).filter(|g| g.byte == 4).collect();
+ assert_eq!(glyphs.iter().filter(|g| g.len > 0).count(), 1);
+ assert_eq!(glyphs.iter().map(|g| g.rendered_char).collect::<String>(), "[1]");
+ assert!(glyphs.iter().all(|g| g.gid != 0));
+ assert!(glyphs.iter().filter(|g| matches!(g.rendered_char, '[' | ']')).all(|g| g.face.family == "Inter"));
+ assert_eq!(glyphs.iter().find(|g| g.rendered_char == '1').unwrap().face.family, "Source Serif 4");
+ assert_eq!(cs.frames[0].notes.len(), 1);
+}
+
+#[test]
+fn generated_note_labels_use_coverage_fallback() {
+ let font = designcraft_fonts::testing::font_with("Generated Label Coverage", &['\u{E888}']).unwrap();
+ designcraft_fonts::FontDb::global().add_font(font);
+ let (mut d, sid, _) = doc_with("Body", Rect::new(0.0, 0.0, 300.0, 300.0), ParaAttrs::default());
+ d.footnote_options.affix_in = designcraft_doc::notes::AffixIn::Both;
+ d.footnote_options.prefix = "\u{E888}".into();
+ d.footnote_options.suffix = "".into();
+ d.settings.glyph_fallback = true;
+ d.story_mut(sid).unwrap().insert_note(4, "Note", ParaFormat::default());
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let glyph = cs.frames[0].lines.iter().flat_map(|l| &l.glyphs).find(|g| g.rendered_char == '\u{E888}').unwrap();
+ assert_ne!(glyph.gid, 0);
+ assert_eq!(glyph.face.family, "Generated Label Coverage");
+}
+
+#[test]
+fn mojikumi_custom_pairs_change_positions_and_breaks_without_font_scaling() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "A1A1A1",
+ Rect::new(0.0, 0.0, 55.0, 300.0),
+ ParaAttrs { hyphenate: Some(false), composer: Some(Composer::SingleLine), ..Default::default() },
+ );
+ let before = compose_story(&d, sid, &ComposeOptions::default());
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Synthetic".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![
+ MojikumiAki { target_class: 18, side_class: 25, after: true, minimum: 1.0, desired: 1.0, maximum: 1.0, ..Default::default() },
+ MojikumiAki { target_class: 25, side_class: 18, after: true, minimum: 1.0, desired: 1.0, maximum: 1.0, ..Default::default() },
+ ],
+ });
+ d.story_mut(sid).unwrap().paras[0].para.mojikumi = Some("MojikumiTable/Synthetic".into());
+ let after = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(all_lines(&after).len() > all_lines(&before).len());
+ let a = &all_lines(&after)[0].glyphs;
+ let b = &all_lines(&before)[0].glyphs;
+ assert!((a[1].x - b[1].x - 12.0).abs() < 0.001);
+ assert_eq!(a[0].sx, b[0].sx);
+ assert!(all_lines(&after).iter().all(|l| l.end_x <= l.x1 + 0.01));
+}
+
+#[test]
+fn mojikumi_paragraph_indent_adds_to_paragraph_settings_and_rounds_no_glyphs() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "ABC",
+ Rect::new(0.0, 0.0, 200.0, 100.0),
+ ParaAttrs { first_line_indent: Some(7.0), mojikumi: Some("MojikumiTable/Indent".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Indent".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 23,
+ after: false,
+ minimum: 2.0,
+ desired: 2.0,
+ maximum: 2.0,
+ ..Default::default()
+ }],
+ });
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&cs)[0];
+ assert!((line.glyphs[0].x - 31.0).abs() < 0.001, "{}", line.glyphs[0].x);
+ assert_eq!(line.glyphs.len(), 3);
+}
+
+#[test]
+fn mojikumi_justifies_cjk_without_spaces_and_respects_fixed_spacing() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "A1A1",
+ Rect::new(0.0, 0.0, 100.0, 100.0),
+ ParaAttrs { align: Some(Align::FullyJustified), mojikumi: Some("MojikumiTable/Elastic".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Elastic".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 5.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!((all_lines(&cs)[0].end_x - 100.0).abs() < 0.001, "{}", all_lines(&cs)[0].end_x);
+}
+
+#[test]
+fn mojikumi_fixed_pairs_are_not_stretched_by_single_word_justification() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "A1A1",
+ Rect::new(0.0, 0.0, 150.0, 100.0),
+ ParaAttrs { align: Some(Align::FullyJustified), mojikumi: Some("MojikumiTable/Fixed".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Fixed".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: [(18, 25), (25, 18)]
+ .into_iter()
+ .map(|(target_class, side_class)| MojikumiAki {
+ target_class,
+ side_class,
+ after: true,
+ minimum: 0.25,
+ desired: 0.25,
+ maximum: 0.25,
+ ..Default::default()
+ })
+ .collect(),
+ });
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&cs)[0];
+ assert!(line.end_x < 100.0, "Fixed spacing was stretched: {}", line.end_x);
+ d.story_mut(sid).unwrap().paras[0].para.align = Some(Align::Left);
+ let ragged = compose_story(&d, sid, &ComposeOptions::default());
+ assert_eq!(line.end_x, all_lines(&ragged)[0].end_x);
+}
+
+#[test]
+fn mojikumi_kinsoku_push_in_and_push_out_select_different_legal_breaks() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let text = "甲乙丙丁戊己庚辛";
+ let (mut d, sid, _) = doc_with(
+ text,
+ Rect::new(0.0, 0.0, 45.0, 300.0),
+ ParaAttrs {
+ composer: Some(Composer::SingleLine),
+ mojikumi: Some("MojikumiTable/Compress".into()),
+ kinsoku_type: Some("KinsokuPushInFirst".into()),
+ ..Default::default()
+ },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Compress".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 12,
+ side_class: 12,
+ after: true,
+ minimum: 0.0,
+ desired: 1.0,
+ maximum: 1.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ let inside = compose_story(&d, sid, &ComposeOptions::default());
+ d.story_mut(sid).unwrap().paras[0].para.kinsoku_type = Some("KinsokuPushOutFirst".into());
+ let outside = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(all_lines(&inside)[0].range.end > all_lines(&outside)[0].range.end);
+ for cs in [&inside, &outside] {
+ assert!(all_lines(cs).iter().all(|l| l.end_x <= l.x1 + 0.01));
+ }
+}
+
+#[test]
+fn mojikumi_priority_and_elastic_line_start_are_used_in_placement() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with("A1B2", Rect::new(0.0, 0.0, 45.0, 100.0), ParaAttrs::default());
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ let middle_gap = all_lines(&natural)[0].glyphs[2].x - all_lines(&natural)[0].glyphs[1].x;
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Priority".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![
+ MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 10.0,
+ priority: 1,
+ ..Default::default()
+ },
+ MojikumiAki {
+ target_class: 25,
+ side_class: 18,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 10.0,
+ priority: 2,
+ ..Default::default()
+ },
+ ],
+ });
+ let para = &mut d.story_mut(sid).unwrap().paras[0].para;
+ para.mojikumi = Some("MojikumiTable/Priority".into());
+ para.align = Some(Align::FullyJustified);
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!((line.end_x - 45.0).abs() < 0.001);
+ assert!((line.glyphs[2].x - line.glyphs[1].x - middle_gap).abs() < 0.001, "Priority 2 was used before priority 1 was exhausted");
+
+ let (mut d, sid, _) = doc_with(
+ "A",
+ Rect::new(0.0, 0.0, 30.0, 100.0),
+ ParaAttrs { mojikumi: Some("MojikumiTable/Start".into()), align: Some(Align::FullyJustified), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Start".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 23,
+ after: false,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 5.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!((line.end_x - 30.0).abs() < 0.001);
+ assert!(line.glyphs[0].x > 10.0, "Leading gap must move the first outline too");
+}
+
+#[test]
+fn mojikumi_equal_priority_shares_leading_and_internal_space() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with("A1", Rect::new(0.0, 0.0, 40.0, 100.0), ParaAttrs::default());
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ let old = all_lines(&natural)[0];
+ let extra = 40.0 - old.end_x;
+ let old_second = old.glyphs[1].x;
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Shared".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: [(18, 23, false), (18, 25, true)]
+ .into_iter()
+ .map(|(target_class, side_class, after)| MojikumiAki {
+ target_class,
+ side_class,
+ after,
+ maximum: 10.0,
+ priority: 1,
+ ..Default::default()
+ })
+ .collect(),
+ });
+ let para = &mut d.story_mut(sid).unwrap().paras[0].para;
+ para.mojikumi = Some("MojikumiTable/Shared".into());
+ para.align = Some(Align::FullyJustified);
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!((line.glyphs[0].x - extra / 2.0).abs() < 0.001);
+ assert!((line.glyphs[1].x - old_second - extra).abs() < 0.001);
+ assert!((line.end_x - 40.0).abs() < 0.001);
+}
+
+#[test]
+fn mojikumi_nonfloating_and_leading_only_compression_fit_ragged_lines() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ for composer in [Composer::SingleLine, Composer::Paragraph] {
+ for leading in [true, false] {
+ let (mut d, sid, _) = doc_with(
+ "A",
+ Rect::new(0.0, 0.0, 15.0, 100.0),
+ ParaAttrs { composer: Some(composer), mojikumi: Some("MojikumiTable/Endpoint".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Endpoint".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: if leading { 23 } else { 22 },
+ after: !leading,
+ minimum: 0.0,
+ desired: 1.0,
+ maximum: 1.0,
+ priority: 1,
+ does_not_float: true,
+ }],
+ });
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!(line.end_x <= 15.0, "{composer:?}, leading={leading}: {}", line.end_x);
+ assert!(line.glyphs[0].x.abs() < 0.001, "Discrete leading gap must reach its endpoint");
+ }
+ }
+}
+
+#[test]
+fn mojikumi_places_custom_gap_after_combining_marks() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with("A\u{0323}\u{0301}1", Rect::new(0.0, 0.0, 200.0, 100.0), ParaAttrs::default());
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ let old = &all_lines(&natural)[0].glyphs;
+ assert!(old.len() >= 3, "Exercise a cluster with a separate combining glyph");
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Clusters".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 1.0,
+ desired: 1.0,
+ maximum: 1.0,
+ ..Default::default()
+ }],
+ });
+ d.story_mut(sid).unwrap().paras[0].para.mojikumi = Some("MojikumiTable/Clusters".into());
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let new = &all_lines(&result)[0].glyphs;
+ assert_eq!(new.len(), old.len());
+ for (before, after) in old.iter().zip(new) {
+ let expected = if before.rendered_char == '1' { 12.0 } else { 0.0 };
+ assert!((after.x - before.x - expected).abs() < 0.001, "Glyph {:?} moved incorrectly", before.rendered_char);
+ }
+}
+
+#[test]
+fn mojikumi_does_not_restore_fullwidth_blanks_to_narrow_tracked_punctuation() {
+ let family = "Mojikumi Narrow Body";
+ let font = designcraft_fonts::testing::font_mapping(family, &[('(', 'i'), ('A', 'A')]).unwrap();
+ designcraft_fonts::FontDb::global().add_font(font);
+ let (mut d, sid, _) = doc_with("(A", Rect::new(0.0, 0.0, 200.0, 100.0), ParaAttrs::default());
+ d.story_mut(sid).unwrap().format_chars(0.."(A".len(), |f| {
+ f.over.font_family = Some(family.into());
+ f.over.tracking = Some(1000.0);
+ });
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ d.story_mut(sid).unwrap().paras[0].para.mojikumi = Some("SimpChineseDefault".into());
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ for (a, b) in all_lines(&natural)[0].glyphs.iter().zip(&all_lines(&result)[0].glyphs) {
+ assert!((a.x - b.x).abs() < 0.001);
+ assert!((a.adv - b.adv).abs() < 0.001);
+ }
+}
++
+ fn ruled(text: &str, rect: Rect, columns: u32, edit: impl FnOnce(&mut Document, StoryId)) -> (Document, ItemId, Vec<Rect>) {
+ let (mut d, sid, fid) = doc_with(text, rect, ParaAttrs::default());
+ {
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.columns = columns;
+ o.gutter = 12.0;
+ o.inset = [10.0, 6.0, 20.0, 6.0];
+ o.column_rule = true;
+ o.column_rule_weight = 2.0;
+ o.column_rule_color = "[Black]".into();
+ }
+ edit(&mut d, sid);
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let rules = cs.frames[0].decos.iter().filter(|dc| dc.color == "[Black]").map(|dc| dc.rect).collect();
+ (d, fid, rules)
+ }
+
+ #[test]
+ fn column_rules_sit_in_the_gutters_inside_the_insets() {
+ // Two columns in 0..300 with 6 pt side insets: the gutter is centred on 150.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |_, _| {});
+ assert_eq!(rules.len(), 1, "{rules:?}");
+ let r = rules[0];
+ assert!((r.center().x - 150.0).abs() < 1e-9 && (r.width() - 2.0).abs() < 1e-9, "{r:?}");
+ assert!((r.y0 - 10.0).abs() < 1e-9 && (r.y1 - 180.0).abs() < 1e-9, "{r:?}");
+ // Three columns: one rule per gutter, each centred between its two columns.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 3, |_, _| {});
+ assert_eq!(rules.len(), 2, "{rules:?}");
+ let w = (288.0 - 24.0) / 3.0;
+ for (i, r) in rules.iter().enumerate() {
+ let edge = 6.0 + w * (i + 1) as f64 + 12.0 * i as f64;
+ assert!((r.center().x - (edge + 6.0)).abs() < 1e-9, "{i}: {r:?}");
+ }
+ // Off, or a single column: no rule.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 1, |_, _| {});
+ assert!(rules.is_empty());
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ let fid = d.story(sid).unwrap().frames[0];
+ d.item_mut(fid).unwrap().text_frame_mut().unwrap().options.column_rule = false;
+ });
+ assert!(rules.is_empty());
+ }
+
+ #[test]
+ fn column_rules_centre_on_unequal_gutters_and_ignore_bad_weights() {
+ let cols = [Rect::new(200.0, 0.0, 300.0, 50.0), Rect::new(0.0, 0.0, 100.0, 50.0), Rect::new(110.0, 0.0, 180.0, 50.0)];
+ let weight = |w: f64| TextFrameOptions { column_rule_weight: w, ..Default::default() };
+ let rules = column_rule_rects(&cols, &[], &weight(1.0));
+ let centres: Vec<f64> = rules.iter().map(|r| r.center().x).collect();
+ assert_eq!(centres, [105.0, 190.0]);
+ assert!(column_rule_rects(&cols, &[], &weight(f64::NAN)).is_empty());
+ assert!(column_rule_rects(&cols, &[], &weight(-1.0)).is_empty());
+ assert!((column_rule_rects(&cols, &[], &weight(1e12))[0].width() - 1000.0).abs() < 1e-9);
+ }
+
+ #[test]
+ fn column_rules_in_right_to_left_and_vertical_frames() {
+ let (_, _, rules) = ruled("نص", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ d.story_mut(sid).unwrap().direction = designcraft_doc::TextDirection::RightToLeft;
+ });
+ assert_eq!(rules.len(), 1);
+ assert!((rules[0].center().x - 150.0).abs() < 1e-9, "{rules:?}");
+ // Vertical type: the columns stack top to bottom, so the rule runs across the frame.
+ let (d, fid, rules) = ruled("縦書き", Rect::new(100.0, 100.0, 400.0, 300.0), 2, |d, sid| d.story_mut(sid).unwrap().vertical = true);
+ assert_eq!(rules.len(), 1);
+ let r = d.text_xf(d.item(fid).unwrap()).transform_rect_bbox(rules[0]);
+ // Text area: x 106..394, y 110..280; the gutter is centred on y 195.
+ assert!((r.x0 - 106.0).abs() < 1e-6 && (r.x1 - 394.0).abs() < 1e-6, "{r:?}");
+ assert!((r.center().y - 195.0).abs() < 1e-6 && (r.height() - 2.0).abs() < 1e-6, "{r:?}");
+ }
+
+ #[test]
+ fn column_rules_break_around_paragraphs_that_span_columns() {
+ let text = format!("A heading that spans both columns\n{LOREM} {LOREM}");
+ let (d, fid, rules) = ruled(&text, Rect::new(0.0, 0.0, 300.0, 400.0), 2, |d, sid| {
+ d.story_mut(sid).unwrap().paras[0].para.span_columns = Some(designcraft_doc::SpanColumns::Span(0));
+ });
+ let sid = d.item(fid).unwrap().text_frame().unwrap().story;
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let span: Vec<&Line> = cs.frames[0].lines.iter().filter(|l| l.para == 0).collect();
+ assert!(!span.is_empty() && span.iter().all(|l| l.x0 < 150.0 && l.x1 > 150.0), "the heading spans");
+ let (top, bottom) = (span[0].baseline - span[0].ascent, span[span.len() - 1].baseline + span[span.len() - 1].descent);
+ assert!(!rules.is_empty());
+ for r in &rules {
+ assert!(r.y1 <= top + 1e-9 || r.y0 >= bottom - 1e-9, "rule {r:?} cuts the span {top}..{bottom}");
+ }
+ // The rule resumes below the span and runs to the bottom of the columns.
+ assert!(rules.iter().any(|r| (r.y0 - bottom).abs() < 1e-9 && (r.y1 - 380.0).abs() < 1e-9), "{rules:?}");
+ }
+
+ #[test]
+ fn column_rules_take_their_offset_insets_and_tint() {
+ let (d, fid, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ let fid = d.story(sid).unwrap().frames[0];
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.column_rule_offset = 3.0;
+ o.column_rule_top_inset = 15.0;
+ o.column_rule_bottom_inset = 25.0;
+ o.column_rule_tint = 0.4;
+ });
+ // Gutter centre 150 moved 3 pt; columns 10..180 shortened to 25..155.
+ assert_eq!(rules.len(), 1, "{rules:?}");
+ let r = rules[0];
+ assert!((r.center().x - 153.0).abs() < 1e-9 && (r.y0 - 25.0).abs() < 1e-9 && (r.y1 - 155.0).abs() < 1e-9, "{r:?}");
+ let sid = d.item(fid).unwrap().text_frame().unwrap().story;
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(cs.frames[0].decos.iter().any(|dc| dc.rect == r && (dc.tint - 0.4).abs() < 1e-6));
+ // Insets that meet leave no rule.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ let fid = d.story(sid).unwrap().frames[0];
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.column_rule_top_inset = 100.0;
+ o.column_rule_bottom_inset = 100.0;
+ });
+ assert!(rules.is_empty(), "{rules:?}");
+ }
diff --cc crates/idml/src/import.rs
index 0bd5de8ac,600acf2f7..7787862cb
--- a/crates/idml/src/import.rs
+++ b/crates/idml/src/import.rs
@@@ -729,6 -686,15 +729,15 @@@ impl<'r> Importer<'r>
}
/// A swatch reference (Self id) → our swatch name; unnamed colours become value-named swatches.
+ /// A `TextFramePreference`, with its column rule colour resolved to a swatch.
- fn frame_options(&mut self, e: &El) -> TextFrameOptions {
- let mut o = text_frame_options(e);
- if let Some(r) = e.get("ColumnRuleStrokeColor") {
++ fn frame_options(&mut self, prefs: &[&El]) -> TextFrameOptions {
++ let mut o = text_frame_options(prefs);
++ if let Some(r) = Prefs(prefs).get("ColumnRuleStrokeColor") {
+ o.column_rule_color = self.swatch_ref(r);
+ }
+ o
+ }
+
fn swatch_ref(&mut self, r: &str) -> String {
if let Some(n) = self.swatch_names.get(r) {
return n.clone();
@@@ -929,7 -906,7 +938,7 @@@
.then(|| e.get("AppliedParagraphStyle").map(|r| self.para_style_ref(r)))
.flatten();
let text_frame = if e.get("EnableTextFrameGeneralOptions") == Some("true") {
- e.find("TextFramePreference").map(|t| text_frame_options(&[t]))
- e.find("TextFramePreference").map(|t| self.frame_options(t))
++ e.find("TextFramePreference").map(|t| self.frame_options(&[t]))
} else {
None
};
@@@ -2098,9 -2054,7 +2107,13 @@@
sid
}
};
- let mut options = e.find("TextFramePreference").map(|t| self.frame_options(t)).unwrap_or_default();
+ // Options the frame doesn't set come from its object style chain.
+ let prefs: Vec<&El> = std::iter::once(e).chain(self.object_style_chain(e)).filter_map(|s| s.find("TextFramePreference")).collect();
+ let mut options = text_frame_options(&prefs);
++ // `prefs` borrows the object styles, so the rule colour's swatch is resolved after it.
++ if let Some(r) = Prefs(&prefs).get("ColumnRuleStrokeColor").map(str::to_string) {
++ options.column_rule_color = self.swatch_ref(&r);
++ }
if let Some(g) = e.find("BaselineFrameGridOption")
&& g.get("UseCustomBaselineFrameGrid") == Some("true")
{
diff --cc crates/idml/src/tests.rs
index 4f27e1593,398fbf7b6..9ef95e63e
--- a/crates/idml/src/tests.rs
+++ b/crates/idml/src/tests.rs
@@@ -1243,289 -858,48 +1243,335 @@@ fn arabic_story_and_table_directions_su
assert_eq!(st.tables.values().next().unwrap().options.direction, designcraft_doc::TextDirection::RightToLeft);
}
+#[test]
+fn drop_caps_import_and_round_trip() {
+ // A style with a drop cap, its character style and a nested style through it; a paragraph
+ // overriding it locally.
+ let opener = r#"<ParagraphStyle Self="ParagraphStyle/Opener" Name="Opener" DropCapCharacters="1" DropCapLines="3">
+ <Properties><DropCapStyle type="object">CharacterStyle/Strong</DropCapStyle><AllNestedStyles type="list"><ListItem type="record">
+ <AppliedCharacterStyle type="object">CharacterStyle/Strong</AppliedCharacterStyle><Delimiter type="enumeration">Dropcap</Delimiter>
+ <Repetition type="long">1</Repetition><Inclusive type="boolean">true</Inclusive></ListItem></AllNestedStyles></Properties>
+ </ParagraphStyle>
+ </RootParagraphStyleGroup>"#;
+ let styles = STYLES.replace("</RootParagraphStyleGroup>", opener);
+ let story = r#"<?xml version="1.0" encoding="UTF-8"?>
+<idPkg:Story xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0">
+ <Story Self="s1">
+ <ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/Opener" DropCapCharacters="2" DropCapLines="2" DropCapStyle="CharacterStyle/$ID/[No character style]">
+ <CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>Once upon a time</Content></CharacterStyleRange>
+ </ParagraphStyleRange>
+ </Story>
+</idPkg:Story>"#;
+ let bytes = zip_files(&[
+ ("designmap.xml", DESIGNMAP),
+ ("Resources/Graphic.xml", GRAPHIC),
+ ("Resources/Styles.xml", &styles),
+ ("Resources/Preferences.xml", PREFS),
+ ("MasterSpreads/MasterSpread_m1.xml", MASTER),
+ ("Spreads/Spread_sp1.xml", SPREAD),
+ ("Stories/Story_s1.xml", story),
+ ]);
+ let check = |d: &Document| {
+ let st = d.styles.para("Opener").unwrap();
+ assert_eq!((st.para.drop_cap_chars, st.para.drop_cap_lines), (Some(1), Some(3)));
+ assert_eq!(st.para.drop_cap_style.as_deref(), Some("Strong"));
+ let ns = st.para.nested_styles.clone().unwrap();
+ assert_eq!((ns[0].style.as_str(), &ns[0].until), ("Strong", &designcraft_doc::NestedUntil::Dropcap));
+ let p = &d.stories.values().find(|s| s.text.starts_with("Once")).unwrap().paras[0];
+ assert_eq!((p.para.drop_cap_chars, p.para.drop_cap_lines), (Some(2), Some(2)));
+ assert_eq!(p.para.drop_cap_style.as_deref(), Some(st::NO_CHAR_STYLE));
+ };
+ let d = import_idml_with(&bytes, &|_| None).unwrap();
+ check(&d);
+ // The drop cap's character style isn't written to IDML (InDesign sets it through a Dropcap
+ // nested style); Align Left Edge and Scale for Descenders are, as DropcapDetail.
+ let mut d = d;
+ if let Some(s) = d.styles_mut().para_mut("Opener") {
+ s.para.drop_cap_align_left = Some(false);
+ s.para.drop_cap_scale_descenders = Some(true);
+ }
+ let bytes = export_idml(&d);
+ assert!(!zip_text(&bytes, "").contains("DropCapStyle"));
+ assert!(zip_text(&bytes, "Resources/Styles.xml").contains(r#"DropcapDetail="2""#));
+ let back = import_idml(&bytes).unwrap();
+ let st = back.styles.para("Opener").unwrap();
+ assert_eq!((st.para.drop_cap_chars, st.para.drop_cap_lines, st.para.drop_cap_style.as_deref()), (Some(1), Some(3), None));
+ assert_eq!((st.para.drop_cap_align_left, st.para.drop_cap_scale_descenders), (Some(false), Some(true)));
+ assert_eq!(st.para.nested_styles.as_ref().map(|n| n[0].until.clone()), Some(designcraft_doc::NestedUntil::Dropcap));
+}
+
+/// Frames take the corners and Text Frame Options they don't write from their object style chain,
+/// then `[None]`. Per-corner attributes win over the legacy all-corners pair, at each level; a
+/// corner shape without a radius takes the chain's radius.
+#[test]
+fn frames_inherit_object_style_corners_and_text_frame_options() {
+ use designcraft_doc::{AutoSize, FirstBaseline, VerticalJustification};
+ use designcraft_geom::corners::CornerShape as C;
+ // Anchors in the order top-left, bottom-left, bottom-right, top-right.
+ let path = |x: f64| {
+ let pts: String = [(x, 0.0), (x, 50.0), (x + 50.0, 50.0), (x + 50.0, 0.0)]
+ .iter()
+ .map(|(x, y)| format!(r#"<PathPointType Anchor="{x} {y}" LeftDirection="{x} {y}" RightDirection="{x} {y}"/>"#))
+ .collect();
+ format!(
+ r#"<Properties><PathGeometry><GeometryPathType PathOpen="false"><PathPointArray>{pts}</PathPointArray></GeometryPathType></PathGeometry></Properties>"#
+ )
+ };
+ let corners = |opt: &str, r: &str| {
+ ["TopLeft", "TopRight", "BottomLeft", "BottomRight"].map(|n| format!(r#"{n}CornerOption="{opt}" {n}CornerRadius="{r}""#)).join(" ")
+ };
+ let inset = |v: f64| {
+ format!(
+ r#"<Properties><InsetSpacing type="list">{}</InsetSpacing></Properties>"#,
+ r#"<ListItem type="unit">V</ListItem>"#.replace('V', &v.to_string()).repeat(4)
+ )
+ };
+ let designmap = format!(
+ r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Document xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="20.2" Self="d">
+<RootObjectStyleGroup Self="ro">
+ <ObjectStyle Self="ObjectStyle/$ID/[None]" Name="$ID/[None]" {none}>
+ <TextFramePreference TextColumnCount="1" TextColumnGutter="12" AutoSizingReferencePoint="CenterPoint" AutoSizingType="Off"/>
+ </ObjectStyle>
+ <ObjectStyle Self="ObjectStyle/Rounded" Name="Rounded" TopLeftCornerOption="RoundedCorner" TopRightCornerOption="RoundedCorner" BottomLeftCornerOption="RoundedCorner" BottomRightCornerOption="RoundedCorner" TopLeftCornerRadius="6">
+ <Properties><BasedOn type="object">ObjectStyle/$ID/[None]</BasedOn></Properties>
+ <TextFramePreference TextColumnCount="2" TextColumnGutter="18" VerticalJustification="CenterAlign" FirstBaselineOffset="LeadingOffset" MinimumFirstBaselineOffset="4" IgnoreWrap="true" AutoSizingType="HeightOnly">{inset}</TextFramePreference>
+ </ObjectStyle>
+ <ObjectStyle Self="ObjectStyle/Child" Name="Child" TopRightCornerOption="BevelCorner">
+ <Properties><BasedOn type="object">ObjectStyle/Rounded</BasedOn></Properties>
+ </ObjectStyle>
+</RootObjectStyleGroup>
+<Story Self="s1"/>
+<Spread Self="sp1"><Page Self="p1"/>
+<TextFrame Self="tf" ParentStory="s1" AppliedObjectStyle="ObjectStyle/Child" BottomRightCornerOption="InverseRoundedCorner" BottomRightCornerRadius="11.34">{p0}<TextFramePreference TextColumnCount="3"/></TextFrame>
+<Rectangle Self="legacy" AppliedObjectStyle="ObjectStyle/Rounded" CornerOption="BevelCorner" CornerRadius="5" TopLeftCornerOption="InsetCorner">{p1}</Rectangle>
+<Rectangle Self="one" TopRightCornerOption="RoundedCorner" TopRightCornerRadius="11.34">{p2}</Rectangle>
+<Rectangle Self="plain" AppliedObjectStyle="ObjectStyle/Rounded">{p3}</Rectangle>
+</Spread>
+</Document>"#,
+ none = corners("None", "12"),
+ inset = inset(3.0),
+ p0 = path(0.0),
+ p1 = path(100.0),
+ p2 = path(200.0),
+ p3 = path(300.0),
+ );
+ let d = import_idml_with(&zip_files(&[("designmap.xml", &designmap)]), &|_| None).unwrap();
+ let item = |n: usize| d.spreads[0].items[n].clone();
+ // Path order: top-left, bottom-left, bottom-right, top-right.
+ let shapes = |n: usize| item(n).corners.corners.map(|c| (c.shape, c.size));
+ assert_eq!(shapes(0), [(C::Rounded, 6.0), (C::Rounded, 12.0), (C::InverseRounded, 11.34), (C::Bevel, 12.0)]);
+ assert_eq!(shapes(1), [(C::Inset, 5.0), (C::Bevel, 5.0), (C::Bevel, 5.0), (C::Bevel, 5.0)]);
+ assert!(item(2).corners.corners.iter().enumerate().all(|(i, c)| (c.shape == C::Rounded) == (i == 3)));
+ assert_eq!(item(2).corners.corners[3].size, 11.34);
+ assert_eq!(shapes(3), [(C::Rounded, 6.0), (C::Rounded, 12.0), (C::Rounded, 12.0), (C::Rounded, 12.0)]);
+ let tf = item(0);
+ let o = &tf.text_frame().unwrap().options;
+ assert_eq!((o.columns, o.gutter, o.inset), (3, 18.0, [3.0; 4]));
+ assert_eq!((o.vertical_justification, o.first_baseline, o.first_baseline_min), (VerticalJustification::Center, FirstBaseline::Leading, 4.0));
+ assert_eq!((o.ignore_wrap, o.auto_size, o.auto_size_ref), (true, AutoSize::HeightOnly, 4));
+}
+
+/// InDesign's designmap lists layers back to front; `Document::layers[0]` is the front layer.
+#[test]
+fn layers_import_and_export_in_stacking_order() {
+ let designmap = r#"<Document xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" Self="d">
+ <Layer Self="L1" Name="Background"/>
+ <Layer Self="L2" Name="Content"/>
+ <idPkg:Spread src="Spreads/Spread_s.xml"/>
+ </Document>"#;
+ let spread = r#"<idPkg:Spread xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging">
+ <Spread Self="s">
+ <Page Self="p" GeometricBounds="0 0 100 100" ItemTransform="1 0 0 1 0 0"/>
+ <Rectangle Self="r" ItemLayer="L1">
+ <Properties><PathGeometry><GeometryPathType PathOpen="false"><PathPointArray>
+ <PathPointType Anchor="0 0"/><PathPointType Anchor="0 100"/>
+ <PathPointType Anchor="100 100"/><PathPointType Anchor="100 0"/>
+ </PathPointArray></GeometryPathType></PathGeometry></Properties>
+ </Rectangle>
+ </Spread>
+ </idPkg:Spread>"#;
+ let d = import_idml(&zip_files(&[("designmap.xml", designmap), ("Spreads/Spread_s.xml", spread)])).unwrap();
+ let names = |d: &Document| d.layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
+ assert_eq!(names(&d), ["Content", "Background"]);
+ assert_eq!(d.spreads[0].items[0].layer, d.layers[1].id, "the rectangle stays on Background");
+
+ let bytes = export_idml(&d);
+ let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice())).unwrap();
+ let mut map = String::new();
+ std::io::Read::read_to_string(&mut zip.by_name("designmap.xml").unwrap(), &mut map).unwrap();
+ let (bg, content) = (map.find(r#"Name="Background""#).unwrap(), map.find(r#"Name="Content""#).unwrap());
+ assert!(bg < content, "designmap lists the back layer first");
+ let back = import_idml(&bytes).unwrap();
+ assert_eq!(names(&back), ["Content", "Background"]);
+ assert_eq!(back.spreads[0].items[0].layer, back.layers[1].id);
+}
+
+/// Synthetic forward references: both a body anchor and a footnote anchor own
+/// a group containing a text frame whose story is serialized later.
+#[test]
+fn round_trips_anchored_text_frames_in_body_and_footnotes() {
+ use designcraft_doc::{AnchorPosition, AnchoredObject, Content, Item, ItemId};
+ use std::sync::Arc;
+ let mut d = Document::new(&NewDocument::default());
+ let layer = d.default_layer();
+ let (_, body) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(20.0, 20.0, 400.0, 600.0), layer, "Body", ParaFormat::default()).unwrap();
+ d.story_mut(body).unwrap().insert_note(4, "Note", ParaFormat::default());
+ for in_note in [false, true] {
+ let (frame, _) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 60.0, 30.0), layer, "Symbol", ParaFormat::default()).unwrap();
+ let child = d.item(frame).unwrap().clone();
+ d.spread_mut(SpreadRef::Doc(0)).unwrap().items.retain(|i| i.id != frame);
+ let mut group = Item::new(ItemId(d.alloc()), layer, Shape::Group, Default::default());
+ group.content = Content::Group { items: vec![Arc::new(child)] };
+ let anchor = AnchoredObject::new(group, AnchorPosition::Inline { y_offset: 2.0 });
+ let story = d.story_mut(body).unwrap();
+ if in_note {
+ Arc::make_mut(&mut story.notes[0]).text.insert_object(0, anchor);
+ } else {
+ story.insert_object(0, anchor);
+ }
+ }
+ d.check().unwrap();
+ for _ in 0..2 {
+ d = import_idml(&export_idml(&d)).unwrap();
+ d.check().unwrap();
+ assert_eq!(d.stories.len(), 3);
+ let body = d.stories.values().find(|s| !s.notes.is_empty()).unwrap();
+ assert_eq!(body.notes.len(), 1);
+ assert_eq!(body.objects.len(), 1);
+ assert_eq!(body.notes[0].text.objects.len(), 1);
+ let children: Vec<_> = d.anchored_items().into_iter().filter(|(_, i)| i.text_frame().is_some()).collect();
+ assert_eq!(children.len(), 2);
+ for (_, item) in children {
+ let story = d.story(item.text_frame().unwrap().story).unwrap();
+ assert_eq!(story.text, "Symbol");
+ assert_eq!(story.frames, vec![item.id]);
+ }
+ }
+}
+
+#[test]
+fn composite_references_resolve_by_identity_and_export_as_objects() {
+ let map = DESIGNMAP.replace("</Document>", r#"
+ <CompositeFont Self="CompositeFont/opaque%3a17" Name="Mixed%3a literal">
+ <CompositeFontEntry Name="Base" FontStyle="$ID/Regular"><Properties><AppliedFont type="string">Source Serif 4</AppliedFont></Properties></CompositeFontEntry>
+ <CompositeFontEntry Name="Digits" CustomCharacters="0123456789" FontStyle="$ID/Bold" RelativeSize="80" HorizontalScale="90" VerticalScale="110" BaselineShift="5" ScaleOption="false"><Properties><AppliedFont type="string">Source Sans 3</AppliedFont></Properties></CompositeFontEntry>
+ </CompositeFont></Document>"#);
+ let styles = STYLES
+ .replace("<AppliedFont type=\"string\">Source Serif 4</AppliedFont>", "<AppliedFont type=\"object\">CompositeFont/opaque%3a17</AppliedFont>");
+ let story = r#"<idPkg:Story xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging"><Story Self="s1"><ParagraphStyleRange><CharacterStyleRange><Content>A1</Content><Footnote><ParagraphStyleRange><CharacterStyleRange><Content>B2</Content></CharacterStyleRange></ParagraphStyleRange></Footnote></CharacterStyleRange></ParagraphStyleRange></Story></idPkg:Story>"#;
+ let bytes = zip_files(&[
+ ("designmap.xml", &map),
+ ("Resources/Styles.xml", &styles),
+ ("Resources/Graphic.xml", GRAPHIC),
+ ("Resources/Preferences.xml", PREFS),
+ ("MasterSpreads/MasterSpread_m1.xml", MASTER),
+ ("Spreads/Spread_sp1.xml", SPREAD),
+ ("Stories/Story_s1.xml", story),
+ ]);
+ let d = import_idml(&bytes).unwrap();
+ let f = &d.styles.composite_fonts[0];
+ assert_eq!(f.name, "Mixed%3a literal", "display names are not encoded identifiers");
+ let body = d.stories.values().find(|s| !s.notes.is_empty()).unwrap();
+ for text in [body.as_ref(), &body.notes[0].text] {
+ let (_, base) = d.styles.resolve_para(&text.paras[0]);
+ let p = d.styles.resolve_char(&base, &text.chars[0].format);
+ assert_eq!(d.styles.composite_font(&p.font_family), Some(f));
+ }
+ let output = export_idml(&d);
+ let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&output)).unwrap();
+ let mut xml = String::new();
+ std::io::Read::read_to_string(&mut zip.by_name("Resources/Styles.xml").unwrap(), &mut xml).unwrap();
+ assert!(xml.contains("<AppliedFont type=\"object\">CompositeFont/Mixed%253a literal</AppliedFont>"), "{xml}");
+ let back = import_idml(&output).unwrap();
+ assert_eq!(back.styles.composite_fonts, d.styles.composite_fonts);
+}
+
+#[test]
+fn malformed_mojikumi_rows_are_not_silently_coerced() {
+ let good = r#"<OverrideMojikumiAkiType TargetMojikumiClass="12" SideMojikumiClass="18" SideIsAfterTarget="true" Minimum="0" Desired="0.25" Maximum="0.5" CompressionPriority="3" AkiDoesNotFloat="false"/>"#;
+ for (key, value) in [
+ ("TargetMojikumiClass", "12.9"),
+ ("SideMojikumiClass", "65536"),
+ ("Minimum", "NaN"),
+ ("Desired", "oops"),
+ ("Minimum", "0.4"),
+ ("Maximum", "0.1"),
+ ("Maximum", "101"),
+ ("CompressionPriority", "10"),
+ ("AkiDoesNotFloat", "maybe"),
+ ] {
+ let mut row = crate::xml::parse(good.as_bytes()).unwrap();
+ row.set(key, value);
+ let mut xml = String::new();
+ row.write(&mut xml, 0);
+ let map = DESIGNMAP.replace("</Document>", &format!("<MojikumiTable Name=\"Bad\" BasedOnMojikumiSet=\"SimpChineseDefault\"><Properties><OverrideMojikumiAkiList>{xml}</OverrideMojikumiAkiList></Properties></MojikumiTable></Document>"));
+ let bytes = zip_files(&[
+ ("designmap.xml", &map),
+ ("Resources/Graphic.xml", GRAPHIC),
+ ("Resources/Styles.xml", STYLES),
+ ("Resources/Preferences.xml", PREFS),
+ ("MasterSpreads/MasterSpread_m1.xml", MASTER),
+ ("Spreads/Spread_sp1.xml", SPREAD),
+ ("Stories/Story_s1.xml", STORY),
+ ]);
+ if matches!((key, value), ("Minimum", "0.4") | ("Maximum", "0.1" | "101") | ("CompressionPriority", "10")) {
+ // Finite, representable rules survive import even if composition
+ // cannot apply them. The resolver supplies a diagnostic instead.
+ let document = import_idml(&bytes).unwrap();
+ document.check().unwrap();
+ assert!(designcraft_doc::mojikumi::Rules::resolve(&document.styles, "MojikumiTable/Bad").is_err());
+ let restored = import_idml(&export_idml(&document)).unwrap();
+ assert_eq!(restored.styles.mojikumi_tables, document.styles.mojikumi_tables);
+ } else {
+ let err = import_idml(&bytes).unwrap_err().to_string();
+ assert!(err.contains("Mojikumi"), "{key}={value}: {err}");
+ }
+ }
+}
++
+ #[test]
+ fn imports_column_rules_from_frames_and_object_styles() {
+ let rule = r#"ColumnRuleOverride="true" ColumnRuleStrokeWidth="2.5" ColumnRuleStrokeColor="Color/Black" ColumnRuleStrokeTint="40"
+ ColumnRuleStrokeType="StrokeStyle/$ID/Solid" ColumnRuleOverprintOverride="false" ColumnRuleOffset="-3" ColumnRuleTopInset="6"
+ ColumnRuleBottomInset="9" ColumnRuleInsetChainOverride="false""#;
+ let styles = format!(
+ r#"<ObjectStyle Self="ObjectStyle/Padded" Name="Padded" EnableTextFrameGeneralOptions="true"><TextFramePreference TextColumnCount="2" {rule}/></ObjectStyle>"#
+ );
+ let d = inset_fixture(&format!(r#"<TextFramePreference TextColumnCount="3" {rule}/>"#), &styles);
+ let style = d.styles.object.iter().find(|s| s.name == "Padded").unwrap().text_frame.clone().unwrap();
+ for o in [d.spreads[0].items[0].text_frame().unwrap().options.clone(), style] {
+ assert!(o.column_rule, "{o:?}");
+ assert_eq!(o.column_rule_weight, 2.5);
+ assert_eq!(o.column_rule_color, designcraft_color::swatch::BLACK);
+ assert!((o.column_rule_tint - 0.4).abs() < 1e-6);
+ assert_eq!((o.column_rule_offset, o.column_rule_top_inset, o.column_rule_bottom_inset), (-3.0, 6.0, 9.0));
+ }
+ // Absent attributes: no rule, InDesign's defaults.
+ let d = inset_fixture(r#"<TextFramePreference TextColumnCount="3"/>"#, "");
+ assert_eq!(d.spreads[0].items[0].text_frame().unwrap().options, designcraft_doc::TextFrameOptions { columns: 3, ..Default::default() });
+ }
+
+ #[test]
+ fn column_rules_round_trip() {
+ let mut d = small_doc();
+ let fid = d.spreads[0].items[0].id;
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.columns = 2;
+ o.column_rule = true;
+ o.column_rule_weight = 0.75;
+ o.column_rule_color = "Brand".into();
+ o.column_rule_tint = 0.5;
+ o.column_rule_offset = 1.5;
+ o.column_rule_top_inset = 4.0;
+ o.column_rule_bottom_inset = 2.0;
+ let want = o.clone();
+ let bytes = export_idml(&d);
+ let back = import_idml(&bytes).unwrap();
+ let got = back.spreads[0].items.iter().find_map(|i| i.text_frame().filter(|t| t.options.column_rule)).unwrap().options.clone();
+ assert_eq!(got, want);
+ // Frames without a rule stay without one.
+ let plain = export_idml(&small_doc());
+ let back = import_idml(&plain).unwrap();
+ assert!(back.spreads.iter().flat_map(|s| &s.items).filter_map(|i| i.text_frame()).all(|t| !t.options.column_rule));
+ }
diff --cc crates/pdf/src/tests.rs
index 6d683492b,27fec660a..10174056c
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@@ -424,31 -338,23 +424,52 @@@ fn missing_glyphs_print_as_boxes()
assert_eq!(boxes(&paths), 1, "{paths:?}");
}
+#[test]
+fn exports_embedded_text_from_footnotes() {
+ use designcraft_doc::{AnchorPosition, AnchoredObject};
+ use std::sync::Arc;
+ let mut d = doc_with_text("Body");
+ let body = *d.stories.keys().next().unwrap();
+ let (fid, _) =
+ d.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 100.0, 40.0), d.default_layer(), "Embedded", ParaFormat::default()).unwrap();
+ let item = d.item(fid).unwrap().clone();
+ d.spread_mut(SpreadRef::Doc(0)).unwrap().items.retain(|i| i.id != fid);
+ let story = d.story_mut(body).unwrap();
+ story.insert_note(4, "Note", ParaFormat::default());
+ Arc::make_mut(&mut story.notes[0]).text.insert_object(0, AnchoredObject::new(item, AnchorPosition::Inline { y_offset: 0.0 }));
+ d.check().unwrap();
+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();
+ let text = extract_text(&bytes).join("");
+ assert!(text.contains("Embedded"), "{text}");
+}
+
+#[test]
+fn fills_open_contours_without_changing_strokes() {
+ let mut d = Document::new(&NewDocument::default());
+ add_box(&mut d, Rect::new(40.0, 50.0, 62.0, 67.0), designcraft_color::swatch::BLACK);
+ let id = d.spreads[0].items[0].id;
+ d.item_mut(id).unwrap().path.subpaths[0].closed = false;
+ let (_, paths) = drawn(&export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap());
+ assert!(paths.iter().any(|r| (r.width() - 22.0).abs() < 0.01 && (r.height() - 17.0).abs() < 0.01), "{paths:?}");
+}
++
+ #[test]
+ fn column_rules_are_drawn() {
+ let rules = |on: bool| {
+ let mut d = doc_with_text("Column text");
+ let fid = d.stories.values().next().unwrap().frames[0];
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.columns = 3;
+ o.gutter = 12.0;
+ o.inset = [0.0; 4];
+ o.column_rule = on;
+ o.column_rule_weight = 2.0;
+ let (_, paths) = drawn(&export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap());
+ paths.into_iter().filter(|r| (r.width() - 2.0).abs() < 0.01 && (r.height() - 264.0).abs() < 0.01).map(|r| r.center().x).collect::<Vec<_>>()
+ };
+ // 540 pt wide in three columns with 12 pt gutters: columns of 172 pt from x 36.
+ let xs = rules(true);
+ assert_eq!(xs.len(), 2, "{xs:?}");
+ assert!((xs[0] - 214.0).abs() < 0.01 && (xs[1] - 398.0).abs() < 0.01, "{xs:?}");
+ assert!(rules(false).is_empty());
+ }
diff --cc crates/ui-egui/src/dialogs.rs
index 0b7529c7f,5955f960f..a3c278ca6
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@@ -1368,37 -1521,10 +1546,18 @@@ pub fn show(app: &mut DesignApp, ctx: &
});
}
"textFrameOptions" => {
- egui::Grid::new("tfo").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Number of columns"));
- text_field(ui, &mut d, "columns", 80.0);
- ui.end_row();
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Gutter"));
- text_field(ui, &mut d, "gutter", 80.0);
- ui.end_row();
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Inset spacing"));
- text_field(ui, &mut d, "inset", 80.0);
- ui.end_row();
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Vertical justification"));
- let cur = d.s("verticalJustification");
- egui::ComboBox::from_id_salt("vj").selected_text(crate::rtl::widget(ui, crate::i18n::tr(&app.ui.language, &cur))).show_ui(ui, |ui| {
- for v in ["top", "center", "bottom", "justify"] {
- if ui.selectable_label(cur == v, crate::rtl::widget(ui, crate::i18n::tr(&app.ui.language, v))).clicked() {
- d.fields.insert("verticalJustification".into(), json!(v));
- }
- }
- });
- ui.end_row();
- });
+ seed_text_frame_options(app, &mut d);
+ text_frame_options_dialog(app, ui, &mut d);
}
"documentSetup" => document_setup(app, ui, &mut d),
+ "alert" => {
+ let file = d.s("file");
+ if !file.is_empty() {
+ crate::rtl::label(ui, egui::RichText::new(crate::rtl::isolate(&file)).font(semibold(13.0)));
+ ui.add_space(4.0);
+ }
+ crate::rtl::label(ui, d.s("message"));
+ }
_ => {}
}
ui.add_space(12.0);
@@@ -3486,147 -2819,53 +3651,193 @@@ fn find_font(app: &mut DesignApp, ui: &
mod tests {
use super::*;
+ fn command_app(id: &str, fields: Value) -> DesignApp {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.ui.dialog = Some(Dialog::new(&format!("cmd:{id}"), fields));
+ app
+ }
+
+ #[test]
+ fn generic_new_document_preserves_typed_values_and_text_entry() {
+ for pages in [json!(2), json!(" 2 ")] {
+ let mut app = command_app(
+ "file.new",
+ json!({
+ "preset": "A4", "pages": pages, "facingPages": false, "gutter": 0,
+ "margins": {"top": 10, "bottom": 20, "inside": 30, "outside": 40},
+ "title": " ", "status": "internal", "primaryTextFrame": true
+ }),
+ );
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ assert_eq!(doc.page_count(), 2);
+ assert!(!doc.settings.facing_pages);
+ assert!(doc.title.starts_with("Untitled-"));
+ for page in doc.spreads.iter().flat_map(|s| &s.pages) {
+ assert!((page.width - 595.2755905511812).abs() < 0.01);
+ assert!((page.height - 841.8897637795277).abs() < 0.01);
+ assert_eq!(page.columns.gutter, 0.0);
+ assert_eq!(page.margins.top, 10.0);
+ assert_eq!(page.margins.outside, 40.0);
+ }
+ assert!(doc.spreads.iter().all(|s| s.items.is_empty()), "undocumented fields stay excluded");
+ assert!(app.ui.dialog.is_none());
+ }
+ }
+
+ #[test]
+ fn generic_command_preserves_array_geometry() {
+ let mut app = command_app("file.new", json!({}));
+ confirm(&mut app).unwrap();
+ app.ui.dialog = Some(Dialog::new("cmd:frame.create", json!({"rect": [10, 20, 110, 220]})));
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ let item = doc.spreads.iter().flat_map(|s| &s.items).next().unwrap();
+ assert_eq!(item.bounds(), designcraft_geom::Rect::new(10.0, 20.0, 110.0, 220.0));
+ }
+
+ #[test]
+ fn generic_explicit_null_uses_the_commands_existing_semantics() {
+ // file.new accepts null width by using the selected preset's width.
+ for width in [Value::Null, json!("null")] {
+ let mut app = command_app("file.new", json!({"preset": "A4", "width": width, "title": " Sample layout "}));
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ assert_eq!(doc.title, "Sample layout");
+ assert!((doc.settings.page_width - 595.2755905511812).abs() < 0.01);
+ }
+ }
+
+ #[test]
+ fn generic_invalid_number_retains_dialog_without_creating_document() {
+ let mut app = command_app("file.new", json!({"width": 0}));
+ assert!(confirm(&mut app).is_err());
+ assert!(app.session.active().is_none());
+ let dialog = app.ui.dialog.as_ref().unwrap();
+ assert_eq!(dialog.fields["width"], 0);
+ assert!(dialog.fields["status"].as_str().unwrap().contains("page size out of range"));
+ }
+
+ fn draw(app: &mut DesignApp, ctx: &egui::Context) {
+ let input =
+ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1400.0, 900.0))), ..Default::default() };
+ let mut out = ctx.run_ui(input, |ui| {
+ app.logic(&ui.ctx().clone());
+ app.ui(ui);
+ });
+ out.textures_delta.clear();
+ }
+
+ /// A paragraph styled "Ruled Child", whose Rule Below comes from its parent "Ruled".
+ fn ruled_paragraph() -> (DesignApp, Value) {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let rule = json!({"on": true, "weight": 3.0, "color": "[Black]", "tint": 0.5, "columnWidth": false, "offset": 4.0, "leftIndent": 6.0, "rightIndent": 2.0});
+ app.run("style.paragraph.create", json!({"name": "Ruled", "para": {"ruleBelow": rule}})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Ruled Child", "basedOn": "Ruled"})).unwrap();
+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 400], "content": "text", "text": "One"})).unwrap();
+ app.run("text.select", json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();
+ app.run("style.paragraph.apply", json!({"name": "Ruled Child"})).unwrap();
+ (app, rule)
+ }
+
+ fn undo_steps(app: &DesignApp) -> usize {
+ app.session.doc().map_or(0, |st| st.history.undo.len())
+ }
+
+ #[test]
+ fn paragraph_rules_dialog_shows_the_rule_and_applies_one_field() {
+ let (mut app, rule) = ruled_paragraph();
+ let ctx = egui::Context::default();
+ app.run("app.paragraphRulesDialog", json!({"rule": "ruleBelow"})).unwrap();
+ draw(&mut app, &ctx);
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!(d.id, "paragraphRules");
+ let current = d.fields["current"].clone();
+ assert_eq!(shown_rule(&d, "", "ruleBelow", &current), rule, "the inherited rule");
+ assert_eq!(shown_rule(&d, "", "ruleAbove", &current)["on"], false);
+ // Pick a colour, as the Color menu does.
+ app.ui.dialog.as_mut().unwrap().fields.insert("ruleBelow.color".into(), json!("[Registration]"));
+ draw(&mut app, &ctx);
+ let before = undo_steps(&app);
+ confirm(&mut app).unwrap();
+ assert_eq!(undo_steps(&app), before + 1, "one undo step");
+ let mut want = rule.clone();
+ want["color"] = json!("[Registration]");
+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], want);
+ app.run("edit.undo", json!({})).unwrap();
+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], rule);
+ }
+
+ #[test]
+ fn paragraph_style_options_edit_one_rule_field() {
+ let (mut app, rule) = ruled_paragraph();
+ let ctx = egui::Context::default();
+ app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled Child", "section": "rules", "rule": "ruleBelow"})));
+ draw(&mut app, &ctx);
+ let resolved = |app: &DesignApp| serde_json::to_value(app.session.doc().unwrap().doc.styles.resolve_para_style("Ruled Child").0).unwrap();
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!(shown_rule(&d, "p.", "ruleBelow", &resolved(&app)), rule, "inherited from the parent style");
+ app.ui.dialog.as_mut().unwrap().fields.insert("p.ruleBelow.weight".into(), json!(1.5));
+ draw(&mut app, &ctx);
+ let before = undo_steps(&app);
+ confirm(&mut app).unwrap();
+ assert_eq!(undo_steps(&app), before + 1, "one undo step");
+ let mut want = rule.clone();
+ want["weight"] = json!(1.5);
+ assert_eq!(resolved(&app)["ruleBelow"], want);
+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], want, "the paragraph follows its style");
+ app.run("edit.undo", json!({})).unwrap();
+ assert_eq!(resolved(&app)["ruleBelow"], rule);
+ }
+
#[test]
+ fn text_frame_options_change_only_what_was_edited() {
+ let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let r = app.run("frame.create", json!({"rect": [36, 36, 336, 236], "content": "text", "text": "Hello"})).unwrap();
+ let id = designcraft_doc::ItemId(r["id"].as_u64().unwrap());
+ app.run("object.textFrameOptions", json!({"ids": [id.0], "columns": 2, "inset": [1, 2, 3, 4]})).unwrap();
+ let opts = |app: &DesignApp| app.session.doc().unwrap().doc.item(id).unwrap().text_frame().unwrap().options.clone();
+ let before = opts(&app);
+ let open = |app: &mut DesignApp, fields: &[(&str, Value)]| {
+ app.ui.dialog = Some(Dialog::new("textFrameOptions", json!({})));
+ let mut d = app.ui.dialog.take().unwrap();
+ seed_text_frame_options(app, &mut d);
+ for (k, v) in fields {
+ d.fields.insert((*k).into(), v.clone());
+ }
+ app.ui.dialog = Some(d);
+ confirm(app)
+ };
+ // OK without edits changes nothing (no undo step either).
+ assert_eq!(open(&mut app, &[]).unwrap(), Value::Null);
+ assert_eq!(opts(&app), before);
+ // The rule's weight is in points; unequal insets the user didn't touch stay.
+ open(&mut app, &[("columnRule", json!(true)), ("columnRuleWeight", json!("6"))]).unwrap();
+ let o = opts(&app);
+ assert!(o.column_rule && o.column_rule_weight == 6.0, "{o:?}");
+ assert_eq!((o.inset, o.columns, o.gutter), (before.inset, before.columns, before.gutter));
+ // One of the rule's insets edited: the other rule settings stay.
+ open(&mut app, &[("columnRuleBottomInset", json!("0p9")), ("columnRuleTint", json!("40"))]).unwrap();
+ let o = opts(&app);
+ assert_eq!((o.column_rule_bottom_inset, o.column_rule_top_inset, o.column_rule_offset, o.column_rule_weight), (9.0, 0.0, 0.0, 6.0));
+ assert!((o.column_rule_tint - 0.4).abs() < 1e-6 && o.column_rule);
+ // One inset side edited: the others keep their values.
+ open(&mut app, &[("insetLeft", json!("1p0"))]).unwrap();
+ assert_eq!(opts(&app).inset, [1.0, 12.0, 3.0, 4.0]);
+ // An unknown swatch is an error and the dialog stays open.
+ let e = open(&mut app, &[("columnRuleColor", json!("Mauve"))]).unwrap_err();
+ assert!(e.contains("Mauve") && app.ui.dialog.is_some(), "{e}");
+ assert_eq!(opts(&app).column_rule_color, designcraft_color::swatch::BLACK);
+ // Each OK is one undo step.
+ for _ in 0..3 {
+ app.run("edit.undo", json!({})).unwrap();
+ }
+ assert_eq!(opts(&app), before);
+ }
+
+ #[test]
fn parses_command_params() {
let f = command_fields("{name, type: custom|lastPageNumber|chapterNumber, text?, rule?: {on, weight}, flag?: bool} — creates");
let keys: Vec<&str> = f.iter().map(|f| f.key.as_str()).collect();