use super::chart::{
DRAWING_NS, DRAWING_TYPE, MAIN_NS, REL_NS, XML_DECL, drawings, max_object_id, part_text,
render_anchor, set_part,
};
use super::chart::{fill_xml, rebuild, set_attr, shape_format};
use super::image::{free_path, reanchor, rename, set_attribute, splice};
use super::xmlesc::escape;
use crate::model::chart::{ChartColor, Fill, ShapeFormat};
use crate::model::shape::Shape;
use crate::model::{Attachment, Spreadsheet, Worksheet};
use crate::reader::chart::{FILLS, Node, children};
use crate::reader::shape::{ShapeObject, child_element, scan_shapes};
use crate::style::DiffFont;
use core::ops::Range;
use std::borrow::Cow;
pub(super) fn prepare(book: Cow<'_, Spreadsheet>) -> Cow<'_, Spreadsheet> {
let dirty: Vec<usize> = book
.sheets()
.iter()
.enumerate()
.filter(|(_, sheet)| {
sheet.shapes.iter().any(|s| !s.is_unchanged())
|| drawings(sheet).any(|d| lost_shapes(&book, sheet, d))
})
.map(|(i, _)| i)
.collect();
if dirty.is_empty() {
return book;
}
let mut book = book.into_owned();
for index in dirty {
apply_sheet(&mut book, index);
}
Cow::Owned(book)
}
fn lost_shapes(book: &Spreadsheet, sheet: &Worksheet, drawing: &str) -> bool {
let mut from_here = sheet
.shapes
.iter()
.filter_map(|s| s.origin.as_ref())
.filter(|o| o.drawing == drawing)
.peekable();
if let Some(read) = from_here.peek().map(|o| o.read_from_drawing) {
return from_here.count() < read;
}
let Some(xml) = part_text(book, drawing) else {
return false;
};
if !xml.contains(":sp ") && !xml.contains(":sp>") && !xml.contains("<sp") {
return false;
}
scan_shapes(xml, None)
.iter()
.filter(|o| o.anchor.is_some())
.flat_map(|o| &o.shapes)
.any(|s| claimant(&sheet.shapes, drawing, s.id).is_none())
}
fn claimant(shapes: &[Shape], drawing: &str, id: u32) -> Option<usize> {
shapes.iter().position(|s| {
s.origin
.as_ref()
.is_some_and(|o| o.drawing == drawing && o.id == id)
})
}
fn apply_sheet(book: &mut Spreadsheet, index: usize) {
let Some(sheet) = book.sheet(index) else {
return;
};
let shapes = sheet.shapes.clone();
let mut paths: Vec<String> = drawings(sheet).map(str::to_owned).collect();
if paths.is_empty() {
if shapes.iter().all(|s| s.origin.is_some()) {
return;
}
let path = free_path(book, "xl/drawings/drawing", "xml");
let empty = format!(
r#"{XML_DECL}<xdr:wsDr xmlns:xdr="{DRAWING_NS}" xmlns:a="{MAIN_NS}"></xdr:wsDr>"#
);
set_part(book, &path, Some(DRAWING_TYPE), empty);
if let Some(sheet) = book.sheet_mut(index) {
sheet.attachments.push(Attachment {
kind: format!("{REL_NS}/drawing"),
target: path.clone(),
});
}
paths.push(path);
}
for (i, path) in paths.iter().enumerate() {
rewrite_drawing(book, path, &shapes, i == 0);
}
}
fn rewrite_drawing(book: &mut Spreadsheet, path: &str, shapes: &[Shape], takes_new: bool) {
let Some(xml) = part_text(book, path).map(str::to_owned) else {
return;
};
let mut splices: Vec<(Range<usize>, String)> = scan_shapes(&xml, None)
.iter()
.filter(|o| o.anchor.is_some())
.filter_map(|o| rewrite_object(&xml, o, path, shapes).map(|t| (o.span.clone(), t)))
.collect();
if takes_new {
let mut next_id = max_object_id(&xml);
let mut objects = String::new();
for shape in shapes.iter().filter(|s| s.origin.is_none()) {
next_id = next_id.saturating_add(1);
objects.push_str(&render_anchor(shape.anchor, &render_shape(shape, next_id)));
}
if !objects.is_empty() {
let close = xml.rfind("</").unwrap_or(xml.len());
splices.push((close..close, objects));
}
}
if !splices.is_empty() {
set_part(book, path, Some(DRAWING_TYPE), splice(&xml, splices));
}
}
fn rewrite_object(
xml: &str,
object: &ShapeObject,
drawing: &str,
shapes: &[Shape],
) -> Option<String> {
let base = object.span.start;
let original = &xml[object.span.clone()];
let alone = matches!(object.shapes.as_slice(), [s] if !s.grouped);
let mut splices: Vec<(Range<usize>, String)> = Vec::new();
let mut moved_to = None;
for element in &object.shapes {
let local = element.span.start - base..element.span.end - base;
let Some(index) = claimant(shapes, drawing, element.id) else {
if alone {
return Some(String::new());
}
splices.push((local, String::new()));
continue;
};
let shape = &shapes[index];
let Some(origin) = &shape.origin else {
continue;
};
let mut text = original[local.clone()].to_owned();
if shape.format != origin.format {
text = reformat(&text, &shape.format, &origin.format);
}
if shape.name != origin.name || shape.description != origin.description {
text = rename(&text, &shape.name, &shape.description);
}
if shape.geometry != origin.geometry
&& let Some(geometry) = &shape.geometry
{
text = regeometry(&text, geometry);
}
if (shape.rotation, shape.flip_h, shape.flip_v)
!= (origin.rotation, origin.flip_h, origin.flip_v)
{
text = retransform(&text, shape);
}
if shape.text != origin.text || shape.font != origin.font {
let font = (shape.font != origin.font).then_some((&shape.font, &origin.font));
text = retext(&text, &shape.text, font);
}
if text != original[local.clone()] {
splices.push((local, text));
}
if alone && shape.anchor != origin.anchor {
moved_to = Some(shape.anchor);
}
}
if splices.is_empty() && moved_to.is_none() {
return None;
}
let text = splice(original, splices);
Some(match moved_to {
Some(anchor) => reanchor(&text, anchor),
None => text,
})
}
fn reformat(element: &str, format: &ShapeFormat, read: &ShapeFormat) -> String {
let Some(properties) = child_element(element, "spPr") else {
return element.to_owned();
};
let start = properties.as_ptr() as usize - element.as_ptr() as usize;
let mut format = format.clone();
if format.source.is_none() {
format.source.clone_from(&read.source);
}
if format.source.is_none() {
return element.to_owned();
}
format!(
"{}{}{}",
&element[..start],
shape_format("", &format),
&element[start + properties.len()..]
)
}
fn retransform(element: &str, shape: &Shape) -> String {
let Some(properties) = child_element(element, "spPr") else {
return element.to_owned();
};
let base = properties.as_ptr() as usize - element.as_ptr() as usize;
if let Some(tag) = crate::reader::shape::start_tag(properties, "xfrm") {
let start = base + (tag.as_ptr() as usize - properties.as_ptr() as usize);
let end = start + tag.trim_end_matches('>').len();
let mut tag = element[start..end].to_owned();
for (name, value) in transform_attributes(shape) {
tag = set_attribute(&tag, name, &value);
}
return format!("{}{tag}{}", &element[..start], &element[end..]);
}
let Some(open) = properties
.find('>')
.filter(|>| !properties[..gt].ends_with('/'))
else {
return element.to_owned();
};
let at = base + open + 1;
let mut tag = "<a:xfrm/".to_owned();
for (name, value) in transform_attributes(shape) {
tag = set_attribute(&tag, name, &value);
}
format!("{}{tag}>{}", &element[..at], &element[at..])
}
fn transform_attributes(shape: &Shape) -> [(&'static str, String); 3] {
let flag = |on: bool| if on { "1" } else { "0" }.to_owned();
[
("rot", shape.rotation.to_string()),
("flipH", flag(shape.flip_h)),
("flipV", flag(shape.flip_v)),
]
}
fn regeometry(element: &str, geometry: &str) -> String {
let Some(start) = element.find("prstGeom ") else {
return element.to_owned();
};
let Some(end) = element[start..].find('>').map(|e| start + e) else {
return element.to_owned();
};
let tag = set_attribute(&element[start..end], "prst", geometry);
format!("{}{tag}{}", &element[..start], &element[end..])
}
fn retext(element: &str, text: &str, font: Option<(&DiffFont, &DiffFont)>) -> String {
let Some(sp) = children(element).into_iter().next() else {
return element.to_owned();
};
let own = if sp.prefix.is_empty() {
String::new()
} else {
format!("{}:", sp.prefix)
};
let Some(body) = sp.child("txBody") else {
let at = sp.inner_start + sp.inner.len();
let run = font.map_or_else(String::new, |(new, was)| run_props(None, new, was, "a:"));
let fresh = format!(
r#"<{own}txBody><a:bodyPr rtlCol="0" anchor="ctr"/><a:lstStyle/>{}</{own}txBody>"#,
paragraphs(text, "a:", "", &run)
);
return format!("{}{fresh}{}", &element[..at], &element[at..]);
};
let kids = body.children();
let keep: String = kids
.iter()
.filter(|k| matches!(k.name, "bodyPr" | "lstStyle"))
.map(|k| k.outer)
.collect();
let first = kids.iter().find(|k| k.name == "p");
let a = kids
.first()
.filter(|k| !k.prefix.is_empty())
.map_or_else(|| "a:".to_owned(), |k| format!("{}:", k.prefix));
let paragraph_props = first.and_then(|p| p.child("pPr")).map_or("", |n| n.outer);
let read = kids
.iter()
.filter(|k| k.name == "p")
.flat_map(Node::children)
.find_map(|r| r.child("rPr").filter(|_| r.name == "r"));
let run_props = match font {
Some((new, was)) => run_props(read.as_ref(), new, was, &a),
None => read.map_or_else(String::new, |n| n.outer.to_owned()),
};
let start = sp.inner_start + body.inner_start;
let end = start + body.inner.len();
format!(
"{}{keep}{}{}",
&element[..start],
paragraphs(text, &a, paragraph_props, &run_props),
&element[end..]
)
}
const RUN: &[&[&str]] = &[
&["ln"],
&FILLS,
&["effectLst", "effectDag"],
&["highlight"],
&["uLnTx", "uLn"],
&["uFillTx", "uFill"],
&["latin"],
&["ea"],
&["cs"],
&["sym"],
&["hlinkClick"],
&["hlinkMouseOver"],
&["rtl"],
&["extLst"],
];
fn run_props(read: Option<&Node<'_>>, font: &DiffFont, was: &DiffFont, a: &str) -> String {
let fresh = format!("<{a}rPr/>");
let parsed = children(&fresh);
let Some(node) = read.or_else(|| parsed.first()) else {
return String::new();
};
let flag = |on: Option<bool>| on.map(|b| if b { "1" } else { "0" }.to_owned());
let mut tag = node.tag.to_owned();
for (name, value) in [
("sz", font.size.map(|v| v.to_string())),
("b", flag(font.bold)),
("i", flag(font.italic)),
] {
tag = set_attr(&tag, name, value);
}
let mut owned = Vec::new();
if font.color != was.color {
let fill = font
.color
.as_ref()
.and_then(ChartColor::from_style)
.map_or_else(String::new, |c| fill_xml(&Fill::Solid(c)));
owned.push((1, fill));
}
if font.name != was.name {
let latin = font.name.as_ref().map_or_else(String::new, |n| {
format!(r#"<a:latin xmlns:a="{MAIN_NS}" typeface="{}"/>"#, escape(n))
});
owned.push((6, latin));
}
rebuild(node, RUN, &owned, |_| false, Some(tag))
}
fn paragraphs(text: &str, a: &str, paragraph_props: &str, run_props: &str) -> String {
text.split('\n')
.map(|line| {
let line = line.strip_suffix('\r').unwrap_or(line);
if line.is_empty() {
format!("<{a}p>{paragraph_props}</{a}p>")
} else {
format!(
"<{a}p>{paragraph_props}<{a}r>{run_props}<{a}t>{}</{a}t></{a}r></{a}p>",
escape(line)
)
}
})
.collect()
}
fn render_shape(shape: &Shape, id: u32) -> String {
let name = if shape.name.is_empty() {
format!("Shape {id}")
} else {
shape.name.clone()
};
let geometry = shape.geometry.as_deref().unwrap_or("rect");
let body = if shape.text.is_empty() {
String::new()
} else {
let run = if shape.font == DiffFont::default() {
String::new()
} else {
run_props(None, &shape.font, &DiffFont::default(), "a:")
};
format!(
r#"<xdr:txBody><a:bodyPr vertOverflow="clip" horzOverflow="clip" rtlCol="0" anchor="ctr"/><a:lstStyle/>{}</xdr:txBody>"#,
paragraphs(&shape.text, "a:", r#"<a:pPr algn="ctr"/>"#, &run)
)
};
let mut transform = String::new();
if shape.rotation != 0 {
transform = format!(r#" rot="{}""#, shape.rotation);
}
if shape.flip_h {
transform.push_str(r#" flipH="1""#);
}
if shape.flip_v {
transform.push_str(r#" flipV="1""#);
}
let properties = shape_format(
"",
&ShapeFormat {
source: Some(format!(
concat!(
r#"<xdr:spPr><a:xfrm{}><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></a:xfrm>"#,
r#"<a:prstGeom prst="{}"><a:avLst/></a:prstGeom></xdr:spPr>"#
),
transform,
escape(geometry)
)),
..shape.format.clone()
},
);
format!(
concat!(
r#"<xdr:sp macro="" textlink=""><xdr:nvSpPr><xdr:cNvPr id="{id}" name="{name}" descr="{descr}"/>"#,
r#"<xdr:cNvSpPr/></xdr:nvSpPr>{properties}"#,
r#"<xdr:style><a:lnRef idx="2"><a:schemeClr val="accent1"><a:shade val="50000"/></a:schemeClr></a:lnRef>"#,
r#"<a:fillRef idx="1"><a:schemeClr val="accent1"/></a:fillRef>"#,
r#"<a:effectRef idx="0"><a:schemeClr val="accent1"/></a:effectRef>"#,
r#"<a:fontRef idx="minor"><a:schemeClr val="lt1"/></a:fontRef></xdr:style>"#,
r#"{body}</xdr:sp><xdr:clientData/>"#
),
id = id,
name = escape(&name),
descr = escape(&shape.description),
properties = properties,
body = body,
)
}
#[cfg(test)]
mod tests {
use super::*;
const SHAPE: &str = concat!(
r#"<xdr:sp macro=""><xdr:nvSpPr><xdr:cNvPr id="2" name="Box"/><xdr:cNvSpPr/></xdr:nvSpPr>"#,
r#"<xdr:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr>"#,
r#"<xdr:txBody><a:bodyPr anchor="t"/><a:lstStyle/><a:p><a:pPr algn="l"/>"#,
r#"<a:r><a:rPr lang="ru-RU" b="1"/><a:t>old</a:t></a:r></a:p></xdr:txBody></xdr:sp>"#,
);
#[test]
fn new_text_keeps_the_formatting_of_the_old() {
let out = retext(SHAPE, "one & two\n\nthree", None);
assert!(out.contains(r#"<a:bodyPr anchor="t"/><a:lstStyle/>"#));
assert!(out.contains(
r#"<a:p><a:pPr algn="l"/><a:r><a:rPr lang="ru-RU" b="1"/><a:t>one & two</a:t></a:r></a:p>"#
));
assert!(out.contains(r#"<a:p><a:pPr algn="l"/></a:p>"#));
assert!(!out.contains("old"));
let body = children(&out)[0].child("txBody").unwrap();
assert_eq!(
crate::reader::shape::body_text(body.outer),
"one & two\n\nthree"
);
}
#[test]
fn a_shape_without_text_gets_a_body_and_geometry_is_an_attribute() {
let bare = SHAPE.replace(
&SHAPE[SHAPE.find("<xdr:txBody>").unwrap()..SHAPE.find("</xdr:sp>").unwrap()],
"",
);
let out = retext(&bare, "hi", None);
assert!(out.ends_with("<a:t>hi</a:t></a:r></a:p></xdr:txBody></xdr:sp>"));
assert!(regeometry(SHAPE, "ellipse").contains(r#"<a:prstGeom prst="ellipse">"#));
}
#[test]
fn a_turn_adds_the_transform_an_element_lacks() {
let mut shape = Shape::new(
"rect",
crate::model::chart::Anchor::Absolute {
x: 0,
y: 0,
width: 1,
height: 1,
},
);
shape.rotation = 60_000;
shape.flip_h = true;
let out = retransform(SHAPE, &shape);
assert!(out.contains(
r#"<xdr:spPr><a:xfrm rot="60000" flipH="1" flipV="0"/><a:prstGeom prst="rect">"#
));
}
}