diff --git a/crates/flow/src/from_doc.rs b/crates/flow/src/from_doc.rs index 810e67d55..791bb60ce 100644 --- a/crates/flow/src/from_doc.rs +++ b/crates/flow/src/from_doc.rs @@ -418,10 +418,11 @@ fn drawing_inline(doc: &Document, o: &InlineObject, opts: FlowOpts, depth: usize } } -/// The placement a flow keeps for a drawing: when it floats, or turns or mirrors it in line. +/// Keep placement, transforms, and explicit stacking metadata even for inline drawings. +/// Presence alone does not imply anchoring: the retained Float keeps its original wrap. fn kept_float(f: &craft_wordmodel::para::Float) -> Option> { let turned = f.rot.is_finite() && f.rot.rem_euclid(360.0) > 0.001 && f.rot.rem_euclid(360.0) < 359.999; - (f.wrap != craft_wordmodel::para::Wrap::Inline || turned || f.flip_h || f.flip_v).then(|| Box::new(f.clone())) + (f.wrap != craft_wordmodel::para::Wrap::Inline || turned || f.flip_h || f.flip_v || f.z != 0).then(|| Box::new(f.clone())) } fn flow_comment(doc: &Document, c: &craft_wordmodel::Comment, parent: Option, opts: FlowOpts) -> FComment { @@ -1254,3 +1255,18 @@ impl ListCounter { } } } + +#[cfg(test)] +mod stacking_tests { + #[test] + fn explicit_inline_stacking_preserves_wrap_without_creating_an_anchor() { + use craft_wordmodel::para::{Float, Wrap}; + let f = Float { z: u32::MAX, ..Float::default() }; + assert_eq!(f.wrap, Wrap::Inline); + let kept = super::kept_float(&f).unwrap(); + assert_eq!(kept.wrap, Wrap::Inline); + assert_eq!(kept.z, u32::MAX); + assert_eq!(kept.rot, f.rot); + assert!(super::kept_float(&Float::default()).is_none()); + } +} diff --git a/crates/flow/src/types.rs b/crates/flow/src/types.rs index f1c281c62..d5abb7537 100644 --- a/crates/flow/src/types.rs +++ b/crates/flow/src/types.rs @@ -170,8 +170,9 @@ pub struct Img { pub w: f32, pub h: f32, pub alt: String, - /// How a floating picture is placed and wrapped, for formats that keep it (ODT); `None`: in - /// line with the text. + /// Placement and drawing metadata for formats that keep it (ODT). `None` is inline; + /// `Some` may also be inline, retaining rotation, mirroring or explicit stacking order. + /// The Float wrap, not the Option, determines anchoring. pub float: Option>, /// The embedded object this picture shows, kept whole (ODT only; see [`OdfObject`]). pub object: Option>, diff --git a/crates/odf/src/text/body.rs b/crates/odf/src/text/body.rs index f07595676..1b2793258 100644 --- a/crates/odf/src/text/body.rs +++ b/crates/odf/src/text/body.rs @@ -1261,6 +1261,7 @@ impl Body<'_> { self.group = Some(OpenGroup { anchor: get(a, "text:anchor-type").map(String::from), page: get(a, "text:anchor-page-number").map(String::from), + z: crate::text::frames::z_of(a), style: get(a, "draw:style-name").map(String::from), members: Vec::new(), }); diff --git a/crates/odf/src/text/body/drawing.rs b/crates/odf/src/text/body/drawing.rs index 28cb8cb12..eeb466f59 100644 --- a/crates/odf/src/text/body/drawing.rs +++ b/crates/odf/src/text/body/drawing.rs @@ -67,6 +67,7 @@ pub(in crate::text) struct OpenGroup { pub(in crate::text) anchor: Option, /// Its `text:anchor-page-number`. pub(in crate::text) page: Option, + pub(in crate::text) z: u32, pub(in crate::text) style: Option, pub(in crate::text) members: Vec, } @@ -103,8 +104,9 @@ impl Body<'_> { f.flip_v ^= v; } // Kept when it floats, or turns or mirrors the object in line. - let float = float - .filter(|f| f.wrap != craft_wordmodel::para::Wrap::Inline || crate::text::frames::turned(f) || f.flip_h || f.flip_v || f.y != 0.0); + let float = float.filter(|f| { + f.wrap != craft_wordmodel::para::Wrap::Inline || crate::text::frames::turned(f) || f.flip_h || f.flip_v || f.y != 0.0 || f.z != 0 + }); if let Some(blocks) = &boxed && self.take_watermark(blocks) { @@ -353,7 +355,8 @@ impl Body<'_> { let mut float = crate::text::frames::float_of(g.anchor.as_deref(), Some(&crate::text::writer::pt(x0)), Some(&crate::text::writer::pt(y0)), &graphic); float.page = crate::text::frames::page_of(g.anchor.as_deref(), g.page.as_deref(), &graphic); - let float = (float.wrap != craft_wordmodel::para::Wrap::Inline).then(|| Box::new(float)); + float.z = g.z; + let float = (float.wrap != craft_wordmodel::para::Wrap::Inline || float.z != 0).then(|| Box::new(float)); let fit = |v: f32| if v.is_finite() { v.clamp(1.0, MAX_LEN) } else { 1.0 }; self.push_inline(Inline::Group { w: fit(x1 - x0), h: fit(y1 - y0), float, members }); } diff --git a/crates/odf/src/text/frames.rs b/crates/odf/src/text/frames.rs index 44a31357a..6e1e22c6f 100644 --- a/crates/odf/src/text/frames.rs +++ b/crates/odf/src/text/frames.rs @@ -443,47 +443,78 @@ pub(super) fn z_of(a: &Attrs) -> u32 { get(a, "draw:z-index").and_then(|v| v.trim().parse::().ok()).map_or(0, |z| z.saturating_add(1)) } -/// `float`'s place in the stacking order as `draw:z-index` (see [`z_of`]). One without a stored -/// order (made in WordCraft, or nothing to place) takes `unset`, which the writer puts above every -/// stored order, where [`Float::z`] stacks it. -pub(crate) fn z_index(float: Option<&Float>, unset: u32) -> u32 { +/// Export orders leave room for the one-more representation used on import. +/// At the upper boundary, remove an unused model order rather than saturating. +#[derive(Clone, Copy, Default)] +pub(crate) struct Stacking { + unset: u32, + gap: Option, +} + +/// A stored order stays below every unset order; equal stored orders remain equal. +pub(crate) fn z_index(float: Option<&Float>, stacking: Stacking) -> u32 { match float.map(|f| f.z) { - Some(z) if z > 0 => z - 1, - _ => unset, + Some(z) if z > 0 => z - 1 - u32::from(stacking.gap.is_some_and(|gap| z > gap)), + _ => stacking.unset, } } -/// The `draw:z-index` the objects of `doc` without a stored order take: past the highest stored -/// one (a stored order is one more than its `draw:z-index`), 0 when none has one. A group's -/// members are written with their own orders too, so theirs count as well as the floating -/// objects' ([`craft_wordmodel::Document::stacking_orders`]). -pub(crate) fn unset_z_index(doc: &craft_wordmodel::Document) -> u32 { +/// Include group members and inline frames too: the ODF writer emits their orders. +pub(crate) fn stacking(doc: &craft_wordmodel::Document) -> Result { use craft_wordmodel::para::{GroupChild, InlineObject}; - fn members(children: &[GroupChild], depth: usize, top: &mut u32) { + use std::collections::BTreeSet; + fn members(children: &[GroupChild], depth: usize, orders: &mut BTreeSet, unset: &mut bool) { for c in children { + if let Some((_, _, f)) = c.obj.frame() + && f.z > 0 + { + orders.insert(f.z); + } if let Some((_, _, f)) = c.obj.frame() { - *top = (*top).max(f.z); + *unset |= f.z == 0; } if let InlineObject::Group { children, .. } = &c.obj && depth < craft_flow::MAX_GROUP_DEPTH { - members(children, depth + 1, top); + members(children, depth + 1, orders, unset); } } } - let mut top = doc.stacking_orders().0.last().copied().unwrap_or(0); + let (mut orders, unset_count) = doc.stacking_orders(); + let mut unset = unset_count > 0; for blocks in std::iter::once(&doc.body).chain(doc.parts.values().map(|p| &p.blocks)) { for b in blocks { craft_wordmodel::walk::each_para(b, 0, &mut |p| { for o in &p.objects { + if let Some((_, _, f)) = o.frame() + && f.z > 0 + { + orders.insert(f.z); + } + if let Some((_, _, f)) = o.frame() { + unset |= f.z == 0; + } if let InlineObject::Group { children, .. } = o { - members(children, 0, &mut top); + members(children, 0, &mut orders, &mut unset); } } }); } } - top + let top = orders.last().copied().unwrap_or(0); + if top < u32::MAX || !unset { + return Ok(Stacking { unset: top, gap: None }); + } + // Find a missing positive value in linear time in the number of distinct orders, + // not the numeric range. This needs no second map and preserves relative order. + let mut gap = 1u32; + for z in orders { + if z != gap { + break; + } + gap = gap.checked_add(1).ok_or("too many distinct ODF stacking orders")?; + } + Ok(Stacking { unset: top - 1, gap: Some(gap) }) } /// How far a frame `h` points tall in line with the text is raised from standing on the diff --git a/crates/odf/src/text/package.rs b/crates/odf/src/text/package.rs index c64306eeb..f7a9d164d 100644 --- a/crates/odf/src/text/package.rs +++ b/crates/odf/src/text/package.rs @@ -1038,7 +1038,7 @@ fn export_as(doc: &Document, mime: &str) -> Result, String> { // Paragraphs kept as read name their own automatic styles: WordCraft's take another prefix. let kept = doc.kept.of("odt"); let mut w = if kept.is_some() { Writer::with_prefix(KEPT_PREFIX) } else { Writer::default() }; - w.unset_z = super::frames::unset_z_index(doc); + w.stacking = super::frames::stacking(doc)?; w.note_numbers = Some([false, true].map(|endnote| { let o = doc.note_options(&doc.last_section, endnote); (o.num_fmt, o.num_start) @@ -1167,7 +1167,7 @@ fn export_as(doc: &Document, mime: &str) -> Result, String> { let mut hw = Writer::with_prefix(if kept.is_some() { "wcM" } else { "M" }); // Headers' and footers' new pictures and objects skip the kept files' names too. hw.reserved = std::sync::Arc::clone(&w.reserved); - hw.unset_z = w.unset_z; + hw.stacking = w.stacking; hw.accents = accents; hw.variables.clone_from(&w.variables); let parts: Vec = pages.iter().map(|(_, sec)| page_parts(doc, sec, &mut hw)).collect(); diff --git a/crates/odf/src/text/tests_more/floats.rs b/crates/odf/src/text/tests_more/floats.rs index 0fff3797a..00f18408a 100644 --- a/crates/odf/src/text/tests_more/floats.rs +++ b/crates/odf/src/text/tests_more/floats.rs @@ -509,3 +509,66 @@ fn a_frame_offering_several_formats_shows_the_first_it_can_read() { let d = import(&zip_of(&[("content.xml", only.as_bytes()), ("Pictures/a.svm", &svm)])).unwrap(); assert_eq!(pictures(&d), 0); } + +/// Export must leave room for import's one-more encoding, including group members. +#[test] +fn extreme_stacking_orders_remain_distinct_after_repeated_roundtrips() { + for (grouped, location) in [(false, 0), (true, 0), (false, 1), (true, 1), (false, 2), (true, 2), (false, 3)] { + let shapes = r#""#.repeat(5); + let objects = if grouped { + format!(r#"{shapes}"#) + } else { + shapes.replace("{objects}"# + ); + let mut d = import(&zip_of(&[("content.xml", content.as_bytes())])).unwrap(); + let zs = [1, u32::MAX - 1, u32::MAX, u32::MAX, 0]; + if grouped { + d.objects_mut(&|o| matches!(o, InlineObject::Group { .. }), &mut |o| { + let InlineObject::Group { float, children, .. } = o else { return }; + float.z = 1; + for (child, z) in children.iter_mut().zip(zs) { + child.obj.float_mut().unwrap().z = z; + } + }); + } else { + let mut orders = zs.into_iter(); + d.objects_mut(&|o| o.frame().is_some(), &mut |o| { + let f = o.float_mut().unwrap(); + f.z = orders.next().unwrap(); + if location == 3 && f.wrap == Wrap::Inline { + f.y = 6.0; + } + }); + } + let mut expected = + vec!["0".to_string(), (u32::MAX - 3).to_string(), (u32::MAX - 2).to_string(), (u32::MAX - 2).to_string(), (u32::MAX - 1).to_string()]; + if grouped { + expected.insert(0, "0".into()); + } + if location == 1 || location == 2 { + let blocks = std::mem::replace(&mut d.body, vec![craft_wordmodel::para_block(craft_wordmodel::Paragraph::new())]); + let kind = if location == 1 { craft_wordmodel::PartKind::Header } else { craft_wordmodel::PartKind::Footer }; + d.parts.insert(1, craft_wordmodel::Part { kind, blocks, body: Default::default() }); + if location == 1 { + d.last_section.headers.default = Some(1); + } else { + d.last_section.footers.default = Some(1); + } + } + for pass in 0..3 { + let bytes = crate::text::tests::export_model(&d).unwrap(); + let content = crate::text::tests::entry(&bytes, if location == 1 || location == 2 { "styles.xml" } else { "content.xml" }); + let actual: Vec<&str> = content.split(r#"draw:z-index=""#).skip(1).filter_map(|s| s.split('"').next()).collect(); + assert_eq!(actual, expected, "grouped={grouped}, location={location}, pass={pass}: {content}"); + if location == 3 { + assert!(content.contains(r#"text:anchor-type="as-char""#), "inline must remain inline"); + assert!(content.contains(r#"svg:y="-78pt""#), "baseline raise must survive: {content}"); + } + d = import(&bytes).unwrap(); + } + } +} diff --git a/crates/odf/src/text/writer.rs b/crates/odf/src/text/writer.rs index 220f5afab..dc4282945 100644 --- a/crates/odf/src/text/writer.rs +++ b/crates/odf/src/text/writer.rs @@ -176,8 +176,8 @@ pub(super) struct Writer { pub(super) named_text: std::collections::BTreeSet, /// Text boxes written so far (their frames' names). boxes: usize, - /// The `draw:z-index` of objects without a stored stacking order (see `frames::unset_z_index`). - pub(super) unset_z: u32, + /// Export stacking orders, also used by the header/footer writer. + pub(super) stacking: super::frames::Stacking, /// Notes written so far (their ids), and footnotes and endnotes among them (their numbers). notes: usize, footnotes: u32, diff --git a/crates/odf/src/text/writer/charts.rs b/crates/odf/src/text/writer/charts.rs index 9c6c2a504..76d9e56e8 100644 --- a/crates/odf/src/text/writer/charts.rs +++ b/crates/odf/src/text/writer/charts.rs @@ -200,7 +200,7 @@ impl Writer { // Always placed by a style (see `image_frame`). let (anchor, props, xy) = placement(place, c.w, c.h); let (anchor, style) = (anchor, format!(" draw:style-name=\"{}\"{xy}", self.graphic_style(props))); - let z = place.z_index(self.unset_z); + let z = place.z_index(self.stacking); out.push_str(&format!( "{inner}", self.prefix, diff --git a/crates/odf/src/text/writer/drawing.rs b/crates/odf/src/text/writer/drawing.rs index 6a5f08feb..115dd9b02 100644 --- a/crates/odf/src/text/writer/drawing.rs +++ b/crates/odf/src/text/writer/drawing.rs @@ -72,8 +72,8 @@ pub(in crate::text) enum Place<'a> { impl<'a> Place<'a> { /// Its place in the stacking order (ยง19.231 `draw:z-index`, see `frames::z_of`), `unset` /// without a stored one. - pub(in crate::text) fn z_index(self, unset: u32) -> u32 { - crate::text::frames::z_index(self.float(), unset) + pub(in crate::text) fn z_index(self, stacking: crate::text::frames::Stacking) -> u32 { + crate::text::frames::z_index(self.float(), stacking) } /// What turns or mirrors the object, and places it in the text. @@ -324,7 +324,7 @@ impl Writer { let (anchor, props, xy) = placement(place, img.w, img.h); let (anchor, style) = (anchor, format!(" draw:style-name=\"{}\"{xy}", self.graphic_style(format!("{}{props}{clip}", super::GRAPHICS_PARENT)))); - let z = place.z_index(self.unset_z); + let z = place.z_index(self.stacking); out.push_str(&format!( "{inner}", self.prefix, @@ -361,7 +361,7 @@ impl Writer { let (anchor, props, _) = placement(Place::Text(float.filter(|f| f.wrap != craft_wordmodel::para::Wrap::Inline)), size.0, size.1); let style = self.graphic_style(props); self.boxes += 1; - let z = crate::text::frames::z_index(float, self.unset_z); + let z = crate::text::frames::z_index(float, self.stacking); out.push_str(&format!("", self.prefix, self.boxes)); let at = Place::Text(float).origin(); self.members(members, at, 0, out); @@ -421,7 +421,7 @@ impl Writer { .and_then(|c| c.next.as_deref()) .map(|n| format!(" draw:chain-next-name=\"{}{}\"", self.prefix, x(n))) .unwrap_or_default(); - let z = place.z_index(self.unset_z); + let z = place.z_index(self.stacking); out.push_str(&format!( "{body}", x(&name), @@ -524,7 +524,7 @@ impl Writer { }) .unwrap_or_default(); let conn = self.conn_attrs(kind, look); - let z = place.z_index(self.unset_z); + let z = place.z_index(self.stacking); out.push_str(&format!( "<{element} draw:name=\"{}Shape{}\" draw:style-name=\"{style}\"{anchor}{at}{conn} draw:z-index=\"{z}\">{body}{geometry}", self.prefix, self.boxes,