mirror of
https://github.com/storytold/deckcraft.git
synced 2026-10-25 19:17:06 -06:00
LeonardoandClaude Sonnet 5.5
8aa76142c9
A text box with a glow in its shape properties but no fill and no line got a blurred ring round the whole box; PowerPoint shows only the text's own glow. The glow of a frame with a line, and of a filled shape, is unchanged. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2614 lines
125 KiB
Rust
2614 lines
125 KiB
Rust
use super::*;
|
||
use deckcraft_model::chart::{ChartType, Trendline, TrendlineType};
|
||
use deckcraft_model::style::ColorRef;
|
||
use deckcraft_model::text::TextBody;
|
||
use deckcraft_model::{Chart, Geom, Presentation, Shape, ShapeId, ShapeKind, ShapeStyle, Table, Xfrm};
|
||
|
||
fn deck_with(shapes: Vec<Shape>) -> Presentation {
|
||
let mut p = Presentation::default();
|
||
let s = std::sync::Arc::make_mut(&mut p.slides[0]);
|
||
s.shapes = shapes;
|
||
p
|
||
}
|
||
|
||
#[test]
|
||
fn blank_slide_renders_white_background() {
|
||
let p = Presentation::default();
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 0.25, ..Default::default() });
|
||
assert_eq!((img.width, img.height), (240, 135));
|
||
assert_eq!(img.pixel(5, 5), [255, 255, 255, 255]);
|
||
}
|
||
|
||
#[test]
|
||
fn shape_fill_uses_theme_accent() {
|
||
let sh = Shape {
|
||
id: ShapeId(500),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let accent = p.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent1);
|
||
let px = img.pixel(200, 150);
|
||
assert!((px[0] as i32 - accent.r as i32).abs() <= 2 && (px[2] as i32 - accent.b as i32).abs() <= 2, "{px:?} vs {accent:?}");
|
||
assert_eq!(img.pixel(50, 50), [255, 255, 255, 255]);
|
||
}
|
||
|
||
#[test]
|
||
fn render_shapes_draws_the_selection_on_a_transparent_canvas() {
|
||
let sh = Shape {
|
||
id: ShapeId(880),
|
||
xfrm: Some(Xfrm::new(100.0, 80.0, 60.0, 40.0)),
|
||
fill: Some(deckcraft_model::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0)))),
|
||
line: Some(deckcraft_model::Line::none()),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_shapes(&p, &p.slides[0], &[ShapeId(880)], 1.0).expect("picture");
|
||
let mid = img.pixel(img.width / 2, img.height / 2);
|
||
assert!(mid[0] > 200 && mid[1] < 40 && mid[3] > 200, "{mid:?}");
|
||
assert_eq!(img.pixel(0, 0)[3], 0, "{:?}", img.pixel(0, 0));
|
||
}
|
||
|
||
#[test]
|
||
fn ink_pressure_tapers_the_stroke_and_a_flat_half_stays_full_width() {
|
||
let opts = RenderOpts { scale: 1.0, ..Default::default() };
|
||
let tapered = render_slide(&ink_line(1.0, 0.12), 0, &opts);
|
||
let flat = render_slide(&ink_line(0.5, 0.5), 0, &opts);
|
||
let full = render_slide(&ink_line(1.0, 1.0), 0, &opts);
|
||
let heavy = dark_in(&tapered, 50, 140, 70, 130);
|
||
let light = dark_in(&tapered, 280, 360, 70, 130);
|
||
assert!(heavy > light * 3, "a firm point covers more of the slide than a light one ({heavy} vs {light})");
|
||
let (a, b) = (dark_in(&flat, 40, 370, 70, 130), dark_in(&full, 40, 370, 70, 130));
|
||
assert!(a > 100 && (a as i32 - b as i32).unsigned_abs() * 10 < a as u32, "the old constant 0.5 still draws at the pen width ({a} vs {b})");
|
||
}
|
||
|
||
fn ink_line(left: f32, right: f32) -> Presentation {
|
||
let points = (0..=40)
|
||
.map(|i| {
|
||
let pressure = if i < 20 { left } else { right };
|
||
(40.0 + f64::from(i) * 8.0, 100.0, pressure)
|
||
})
|
||
.collect();
|
||
let sh = Shape {
|
||
id: ShapeId(7),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)),
|
||
kind: ShapeKind::Ink {
|
||
strokes: vec![deckcraft_model::InkStroke { points, color: deckcraft_color::Rgba::rgb(0, 0, 0), width: 24.0, highlighter: false }],
|
||
},
|
||
..Default::default()
|
||
};
|
||
deck_with(vec![sh])
|
||
}
|
||
|
||
fn dark_in(img: &Image, x0: u32, x1: u32, y0: u32, y1: u32) -> usize {
|
||
let mut n = 0;
|
||
for y in y0..y1 {
|
||
for x in x0..x1 {
|
||
if img.pixel(x, y)[0] < 200 {
|
||
n += 1;
|
||
}
|
||
}
|
||
}
|
||
n
|
||
}
|
||
|
||
#[test]
|
||
fn text_draws_ink() {
|
||
let mut sh = Shape { id: ShapeId(501), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), text_box: true, ..Default::default() };
|
||
let mut t = TextBody::from_text("HELLO WORLD");
|
||
t.paragraphs[0].runs[0].props.size = Some(120.0);
|
||
sh.text = Some(t);
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 0.5, ..Default::default() });
|
||
let dark = img.pixels.as_chunks::<4>().0.iter().filter(|px| px[0] < 128).count();
|
||
assert!(dark > 500, "dark pixels {dark}");
|
||
}
|
||
|
||
#[test]
|
||
fn every_preset_renders_without_panic() {
|
||
let shapes: Vec<Shape> = deckcraft_geom::preset::CATALOG
|
||
.iter()
|
||
.enumerate()
|
||
.map(|(i, pr)| Shape {
|
||
id: ShapeId(1000 + i as u32),
|
||
xfrm: Some(Xfrm::new((i % 16) as f64 * 60.0, (i / 16) as f64 * 55.0, 50.0, 45.0)),
|
||
geom: Geom::preset(pr.name),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent2)),
|
||
..Default::default()
|
||
})
|
||
.collect();
|
||
let p = deck_with(shapes);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, edit: true, ..Default::default() });
|
||
assert_eq!(img.width, 960);
|
||
}
|
||
|
||
#[test]
|
||
fn effects_tables_charts_render() {
|
||
let mut sh = Shape {
|
||
id: ShapeId(600),
|
||
xfrm: Some(Xfrm::new(50.0, 50.0, 200.0, 100.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
sh.effects = Some(deckcraft_model::Effects {
|
||
outer_shadow: Some(deckcraft_model::style::Shadow {
|
||
color: ColorRef::rgb(deckcraft_color::Rgba::BLACK),
|
||
blur: 8.0,
|
||
dist: 6.0,
|
||
dir: 45.0,
|
||
inner: false,
|
||
sx: 1.0,
|
||
sy: 1.0,
|
||
kx: 0.0,
|
||
ky: 0.0,
|
||
align: String::new(),
|
||
rotate_with_shape: false,
|
||
}),
|
||
glow: Some(deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 200, 0)), radius: 6.0 }),
|
||
soft_edge: Some(4.0),
|
||
..Default::default()
|
||
});
|
||
let mut t = Table::new(3, 3, 300.0, 30.0);
|
||
t.cell_mut(0, 0).unwrap().text = TextBody::from_text("Head");
|
||
let tbl = Shape { id: ShapeId(601), xfrm: Some(Xfrm::new(300.0, 50.0, 300.0, 90.0)), kind: ShapeKind::Table(t), ..Default::default() };
|
||
let mut charts = vec![];
|
||
for (i, k) in [
|
||
ChartType::Column,
|
||
ChartType::Bar,
|
||
ChartType::Line,
|
||
ChartType::Pie,
|
||
ChartType::Doughnut,
|
||
ChartType::Area,
|
||
ChartType::Scatter,
|
||
ChartType::StackedColumn,
|
||
]
|
||
.iter()
|
||
.enumerate()
|
||
{
|
||
charts.push(Shape {
|
||
id: ShapeId(700 + i as u32),
|
||
xfrm: Some(Xfrm::new(i as f64 * 110.0, 300.0, 100.0, 100.0)),
|
||
kind: ShapeKind::Chart(Box::new(Chart::sample(*k))),
|
||
..Default::default()
|
||
});
|
||
}
|
||
let mut all = vec![sh, tbl];
|
||
all.extend(charts);
|
||
let p = deck_with(all);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
// Shadow darkens below-right of the shape (grey, past the glow), blurred by a third of its
|
||
// 8 pt blur radius.
|
||
let px = img.pixel(255, 155);
|
||
assert!(px[0] < 240 && px[0] == px[2], "{px:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn combo_chart_draws_columns_and_a_line_on_its_own_axis() {
|
||
// Columns in the hundreds of thousands, a green line in the thousands on the secondary axis:
|
||
// the line must sit up in the plot, not flat along the bottom of the primary scale.
|
||
let mut c = Chart::sample(ChartType::Combo);
|
||
c.title = None;
|
||
c.legend = None;
|
||
c.series.truncate(2);
|
||
c.categories = vec!["A".into(), "B".into(), "C".into()];
|
||
c.series[0].kind = Some(ChartType::Column);
|
||
c.series[0].values = vec![Some(200_000.0), Some(300_000.0), Some(250_000.0)];
|
||
c.series[1].kind = Some(ChartType::Line);
|
||
c.series[1].values = vec![Some(7_000.0), Some(7_000.0), Some(7_000.0)];
|
||
c.series[1].secondary_axis = true;
|
||
c.series[1].line = Some(deckcraft_model::style::Line::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 176, 80)), 3.0));
|
||
let sh = Shape { id: ShapeId(620), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let green = |x: u32, y0: u32, y1: u32| {
|
||
(y0..y1).any(|y| {
|
||
let p = img.pixel(x, y);
|
||
p[1] > 120 && p[0] < 80 && p[2] < 140
|
||
})
|
||
};
|
||
// The line is in the upper half (7 000 of an axis to 8 000), and columns fill the plot's bottom.
|
||
assert!(green(480, 20, 270), "line not in the upper half");
|
||
assert!(!green(480, 400, 500), "line along the bottom");
|
||
let col = img.pixel(480, 480);
|
||
assert!(col[0] < 250 || col[1] < 250 || col[2] < 250, "no column: {col:?}");
|
||
}
|
||
|
||
fn trend_chart(title: &str, kind: ChartType, ys: &[f64], trend: Trendline, y_max: f64) -> Chart {
|
||
let mut c = Chart::sample(kind);
|
||
c.title = Some(title.into());
|
||
c.legend = None;
|
||
c.categories = vec!["A".into(), "B".into(), "C".into(), "D".into()];
|
||
c.series.truncate(1);
|
||
c.series[0].name = "Data".into();
|
||
c.series[0].values = ys.iter().copied().map(Some).collect();
|
||
c.y_min = Some(0.0);
|
||
c.y_max = Some(y_max);
|
||
c.series[0].trendlines = vec![trend];
|
||
c
|
||
}
|
||
|
||
fn trend_line(kind: TrendlineType) -> Trendline {
|
||
Trendline { kind, disp_eq: true, disp_r_sqr: true, ..Default::default() }
|
||
}
|
||
|
||
/// Six charts, one trendline type each. `draw` drops the trendlines. `forecast` extends the linear fit.
|
||
fn trend_gallery(draw: bool, forecast: bool) -> Image {
|
||
let mut linear = trend_line(TrendlineType::Linear);
|
||
if forecast {
|
||
linear.forward = Some(1.0);
|
||
linear.backward = Some(0.5);
|
||
}
|
||
let mut poly = trend_line(TrendlineType::Poly);
|
||
poly.order = Some(2);
|
||
let mut ma = trend_line(TrendlineType::MovingAvg);
|
||
ma.period = Some(2);
|
||
let mut charts = vec![
|
||
trend_chart("Linear", ChartType::Column, &[3.0, 5.0, 7.0, 9.0], linear, 12.0),
|
||
trend_chart("Exponential", ChartType::LineMarkers, &[1.0, 2.0, 4.0, 8.0], trend_line(TrendlineType::Exp), 10.0),
|
||
trend_chart(
|
||
"Logarithmic",
|
||
ChartType::LineMarkers,
|
||
&[1.0_f64.ln(), 2.0_f64.ln(), 3.0_f64.ln(), 4.0_f64.ln()],
|
||
trend_line(TrendlineType::Log),
|
||
2.0,
|
||
),
|
||
trend_chart("Polynomial", ChartType::LineMarkers, &[1.0, 4.0, 9.0, 16.0], poly, 18.0),
|
||
trend_chart("Power", ChartType::LineMarkers, &[2.0, 2.0 * 2.0_f64.sqrt(), 2.0 * 3.0_f64.sqrt(), 4.0], trend_line(TrendlineType::Power), 6.0),
|
||
trend_chart("Moving average", ChartType::LineMarkers, &[2.0, 8.0, 4.0, 10.0], ma, 12.0),
|
||
];
|
||
if !draw {
|
||
for c in &mut charts {
|
||
c.series[0].trendlines.clear();
|
||
}
|
||
}
|
||
let shapes = charts
|
||
.into_iter()
|
||
.enumerate()
|
||
.map(|(i, c)| Shape {
|
||
id: ShapeId(800 + i as u32),
|
||
xfrm: Some(Xfrm::new(12.0 + (i % 3) as f64 * 316.0, 12.0 + (i / 3) as f64 * 264.0, 304.0, 252.0)),
|
||
kind: ShapeKind::Chart(Box::new(c)),
|
||
..Default::default()
|
||
})
|
||
.collect();
|
||
render_slide(&deck_with(shapes), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
}
|
||
|
||
#[test]
|
||
fn trendlines_draw_through_the_points_with_a_label() {
|
||
let on = trend_gallery(true, false);
|
||
let off = trend_gallery(false, false);
|
||
assert_eq!((on.width, on.height), (960, 540));
|
||
let dark = on
|
||
.pixels
|
||
.as_chunks::<4>()
|
||
.0
|
||
.iter()
|
||
.zip(off.pixels.as_chunks::<4>().0)
|
||
.filter(|(a, b)| a[0] < 50 && a[1] < 50 && a[2] < 50 && b[0] as i32 - a[0] as i32 > 20)
|
||
.count();
|
||
assert!(dark > 40, "dashed trendline ink {dark}");
|
||
// A scatter fit uses the real x values and still paints the dash.
|
||
let mut scatter = trend_chart("Scatter", ChartType::Scatter, &[2.0, 4.0, 6.0, 8.0], trend_line(TrendlineType::Linear), 10.0);
|
||
scatter.series[0].x_values = (1..=4).map(|x| Some(x as f64)).collect();
|
||
let sh = Shape {
|
||
id: ShapeId(810),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 480.0, 360.0)),
|
||
kind: ShapeKind::Chart(Box::new(scatter.clone())),
|
||
..Default::default()
|
||
};
|
||
let with = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
scatter.series[0].trendlines.clear();
|
||
let sh =
|
||
Shape { id: ShapeId(810), xfrm: Some(Xfrm::new(0.0, 0.0, 480.0, 360.0)), kind: ShapeKind::Chart(Box::new(scatter)), ..Default::default() };
|
||
let without = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let scatter_dark = with
|
||
.pixels
|
||
.as_chunks::<4>()
|
||
.0
|
||
.iter()
|
||
.zip(without.pixels.as_chunks::<4>().0)
|
||
.filter(|(a, b)| a[0] < 50 && a[1] < 50 && a[2] < 50 && b[0] as i32 - a[0] as i32 > 20)
|
||
.count();
|
||
assert!(scatter_dark > 20, "scatter trendline ink {scatter_dark}");
|
||
if std::env::var_os("DECKCRAFT_TREND_SHOT").is_some() {
|
||
let png = trend_gallery(true, true).to_png();
|
||
std::fs::write("/tmp/deckcraft-trendlines.png", &png).expect("write trendline screenshot");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn chart_axis_titles_are_drawn() {
|
||
let draw = |titles: (Option<String>, Option<String>)| {
|
||
let mut c = Chart::sample(ChartType::Column);
|
||
c.title = None;
|
||
c.legend = None;
|
||
c.axis_titles = titles;
|
||
let sh = Shape { id: ShapeId(624), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
};
|
||
let ink = |img: &Image, r: (u32, u32, u32, u32)| {
|
||
(r.0..r.2).flat_map(|x| (r.1..r.3).map(move |y| (x, y))).filter(|(x, y)| img.pixel(*x, *y)[0] < 160).count()
|
||
};
|
||
let bare = draw((None, None));
|
||
let titled = draw((Some("Month".into()), Some("Revenue".into())));
|
||
// A turned "Revenue" down the left edge, "Month" along the bottom.
|
||
let left = (38, 150, 62, 390);
|
||
let bottom = (380, 490, 580, 520);
|
||
assert!(ink(&titled, left) > ink(&bare, left) + 30, "value axis title");
|
||
assert!(ink(&titled, bottom) > ink(&bare, bottom) + 30, "category axis title");
|
||
}
|
||
|
||
#[test]
|
||
fn column_points_take_their_own_fill_and_smooth_lines_curve() {
|
||
// One column series where only the middle point is given a red c:dPt fill.
|
||
let mut c = Chart::sample(ChartType::Column);
|
||
c.title = None;
|
||
c.legend = None;
|
||
c.series.truncate(1);
|
||
c.categories = vec!["A".into(), "B".into(), "C".into()];
|
||
c.series[0].values = vec![Some(10.0), Some(10.0), Some(10.0)];
|
||
c.series[0].point_fills = vec![(1, deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))))];
|
||
let sh = Shape { id: ShapeId(621), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let red = |x: u32| (300..500).any(|y| img.pixel(x, y)[..3] == [255, 0, 0]);
|
||
assert!(red(480), "the middle column takes its point's fill");
|
||
assert!(!red(200) && !red(760), "the others keep the series colour");
|
||
|
||
// Two series, gap 150 %, no overlap: each bar is a band / 3.5 wide (PowerPoint's and
|
||
// LibreOffice's geometry), not band / 2.5 split in two.
|
||
let mut c = Chart::sample(ChartType::Column);
|
||
c.title = None;
|
||
c.legend = None;
|
||
c.series.truncate(2);
|
||
c.categories = vec!["A".into()];
|
||
c.series[0].values = vec![Some(10.0)];
|
||
c.series[1].values = vec![Some(10.0)];
|
||
c.series[0].fill = Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))));
|
||
(c.gap_width, c.overlap) = (1.5, 0.0);
|
||
let sh = Shape { id: ShapeId(622), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let y = (0..540).rev().find(|y| (0..960).any(|x| img.pixel(x, *y)[..3] == [255, 0, 0])).unwrap() - 5;
|
||
let reds = (0..960).filter(|x| img.pixel(*x, y)[..3] == [255, 0, 0]).count() as f64;
|
||
// The plot is ~850 px wide with one category: a bar is ~240 px (it was ~170 when the band
|
||
// was split as 1 + gap and then shared between the series).
|
||
assert!((200.0..280.0).contains(&reds), "bar {reds} px");
|
||
|
||
// A smoothed line through a peak overshoots no point but leaves the straight chord.
|
||
let pts = [kurbo::Point::new(0.0, 0.0), kurbo::Point::new(10.0, 10.0), kurbo::Point::new(20.0, 0.0)];
|
||
let p = crate::chart::smooth_path(&pts);
|
||
assert_eq!(p.elements().len(), 3, "a cubic per segment");
|
||
let mid = kurbo::ParamCurve::eval(&p.segments().next().unwrap(), 0.5);
|
||
assert!(mid.y > mid.x, "the first half bows towards the peak instead of following the chord: {mid:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn horizontal_bars_list_the_first_category_at_the_bottom_unless_reversed() {
|
||
let draw = |reversed: bool| {
|
||
let mut c = Chart::sample(ChartType::Bar);
|
||
c.title = None;
|
||
c.legend = None;
|
||
c.series.truncate(1);
|
||
c.categories = vec!["A".into(), "B".into(), "C".into()];
|
||
c.series[0].values = vec![Some(10.0), Some(10.0), Some(10.0)];
|
||
c.series[0].point_fills = vec![(0, deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))))];
|
||
c.cat_reversed = reversed;
|
||
let sh = Shape { id: ShapeId(623), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let rows: Vec<u32> = (0..540).filter(|y| (0..960).any(|x| img.pixel(x, *y)[..3] == [255, 0, 0])).collect();
|
||
(rows[0] + rows[rows.len() - 1]) / 2
|
||
};
|
||
assert!(draw(false) > 360, "first category at the bottom: {}", draw(false));
|
||
assert!(draw(true) < 180, "reversed: first category at the top: {}", draw(true));
|
||
}
|
||
|
||
#[test]
|
||
fn glow_of_an_unfilled_shape_follows_its_line() {
|
||
// A frame (no fill, thin line) with a strong glow: the glow lines its edge, the inside stays
|
||
// the slide's white, as PowerPoint draws it.
|
||
let glow = |fill: Option<Fill>| {
|
||
let mut sh = Shape {
|
||
id: ShapeId(610),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 300.0)),
|
||
fill,
|
||
line: Some(deckcraft_model::style::Line::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 176, 240)), 0.25)),
|
||
..Default::default()
|
||
};
|
||
sh.effects = Some(deckcraft_model::Effects {
|
||
glow: Some(deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 255)), radius: 8.0 }),
|
||
..Default::default()
|
||
});
|
||
render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
};
|
||
let img = glow(Some(Fill::None));
|
||
let inside = img.pixel(300, 250);
|
||
assert!(inside[0] > 245 && inside[1] > 245, "{inside:?}");
|
||
let edge = img.pixel(300, 97);
|
||
assert!(edge[0] < 230, "{edge:?}");
|
||
// A filled shape's glow is still the whole silhouette's (the fill covers its inside).
|
||
let img = glow(Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 255, 255)))));
|
||
assert!(img.pixel(300, 94)[0] < 240);
|
||
}
|
||
|
||
#[test]
|
||
fn glow_of_a_shape_with_no_fill_and_no_line_is_not_drawn() {
|
||
// A text box (no fill, no line) with a glow in its shape properties: PowerPoint shows no halo
|
||
// round the box (its text carries its own glow), so the box's edge and surroundings stay white.
|
||
let mut sh = Shape { id: ShapeId(611), xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 300.0)), fill: Some(Fill::None), ..Default::default() };
|
||
sh.effects = Some(deckcraft_model::Effects {
|
||
glow: Some(deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 255, 0)), radius: 15.0 }),
|
||
..Default::default()
|
||
});
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
for (x, y) in [(300, 250), (300, 100), (300, 95), (96, 250)] {
|
||
let px = img.pixel(x, y);
|
||
assert!(px[2] > 245, "({x}, {y}): {px:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn placeholder_prompts_only_in_edit_view() {
|
||
let p = Presentation::default();
|
||
let edit = render_slide(&p, 0, &RenderOpts { scale: 0.5, edit: true, ..Default::default() });
|
||
let show = render_slide(&p, 0, &RenderOpts { scale: 0.5, ..Default::default() });
|
||
let ink = |i: &Image| i.pixels.as_chunks::<4>().0.iter().filter(|px| px[0] < 200).count();
|
||
assert!(ink(&edit) > 100);
|
||
assert_eq!(ink(&show), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn png_encodes() {
|
||
let p = Presentation::default();
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 0.1, ..Default::default() });
|
||
let png = img.to_png();
|
||
assert!(png.starts_with(&[0x89, b'P', b'N', b'G']));
|
||
assert_eq!(image_dpi(&png), None, "an untagged screenshot stays without a resolution");
|
||
assert!(!img.to_jpeg(80).is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn a_retina_export_records_144_dpi_and_still_decodes() {
|
||
assert_eq!(dpi_for_scale(2.0), 144.0);
|
||
assert_eq!(dpi_for_scale(1.0), 72.0);
|
||
assert_eq!(dpi_for_scale(f64::NAN), 72.0);
|
||
let img = Image { width: 4, height: 2, pixels: [255, 0, 0, 255].repeat(8) };
|
||
let png = img.to_png_at(144.0);
|
||
assert_eq!(image_dpi(&png), Some((144.0, 144.0)));
|
||
let decoded = image::load_from_memory(&png).unwrap();
|
||
assert_eq!((decoded.width(), decoded.height()), (4, 2));
|
||
let again = images::stamp_png_dpi(&png, 72.0);
|
||
assert_eq!(again.len(), png.len(), "a second pHYs chunk is not written");
|
||
assert_eq!(image_dpi(&again), Some((144.0, 144.0)));
|
||
let jpeg = img.to_jpeg_at(90, Some(144.0));
|
||
assert_eq!(image_dpi(&jpeg), Some((144.0, 144.0)));
|
||
assert_eq!(image_dpi(&img.to_jpeg(90)), None);
|
||
}
|
||
|
||
#[test]
|
||
fn crop_dest_math() {
|
||
let r = crop_dest(Rect::new(0.0, 0.0, 100.0, 100.0), [0.5, 0.0, 0.0, 0.0]);
|
||
assert!((r.x0 + 100.0).abs() < 1e-9 && (r.width() - 200.0).abs() < 1e-9);
|
||
let r = crop_dest(Rect::new(0.0, 0.0, 100.0, 100.0), [f64::NAN, 2.0, -50.0, 0.0]);
|
||
assert!(r.x0.is_finite() && r.y1.is_finite());
|
||
}
|
||
|
||
#[test]
|
||
fn custom_path_parse() {
|
||
let p = parse_path("M 0 0 L 10 0 C 1 2 3 4 5 6 Q 1 1 2 2 Z garbage L x y");
|
||
assert!(p.elements().len() >= 5);
|
||
assert!(parse_path("").elements().is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn table_rows_of_zero_height_grow_to_fit_text() {
|
||
// pandoc and python-pptx write `<a:tr h="0">`: the stored row height is only a minimum.
|
||
let mut t = Table::new(3, 2, 300.0, 0.0);
|
||
for (r, row) in [["Col A", "Col B"], ["1", "alpha"], ["2", "beta"]].iter().enumerate() {
|
||
for (c, text) in row.iter().enumerate() {
|
||
t.cell_mut(r, c).unwrap().text = TextBody::from_text(text);
|
||
}
|
||
}
|
||
let tbl = Shape { id: ShapeId(610), xfrm: Some(Xfrm::new(100.0, 100.0, 300.0, 0.0)), kind: ShapeKind::Table(t.clone()), ..Default::default() };
|
||
let p = deck_with(vec![tbl]);
|
||
let ctx = deckcraft_model::resolve::Ctx::for_slide(&p, &p.slides[0]).unwrap();
|
||
let hs = crate::table::row_heights(&ctx, &t, &deckcraft_text::NoFields);
|
||
assert_eq!(hs.len(), 3);
|
||
assert!(hs.iter().all(|h| *h > 10.0), "{hs:?}");
|
||
let tops: Vec<f64> = crate::table::cell_rects(&t, &hs).iter().filter(|(_, c, _)| *c == 0).map(|(_, _, r)| r.y0).collect();
|
||
assert!(tops.len() == 3 && tops.windows(2).all(|w| w[1] > w[0] + 10.0), "{tops:?}");
|
||
// A taller stored height is kept.
|
||
let mut tall = t;
|
||
tall.rows[1].height = 200.0;
|
||
assert_eq!(crate::table::row_heights(&ctx, &tall, &deckcraft_text::NoFields)[1], 200.0);
|
||
// The PDF text layer gets every cell's text, rows one below the other.
|
||
let placed = place_slide(&p, 0);
|
||
let top = |s: &str| {
|
||
let pt = placed.texts.iter().find(|pt| pt.body.text() == s).unwrap_or_else(|| panic!("no placed text {s:?}"));
|
||
(pt.transform * kurbo::Point::new(0.0, pt.layout.lines[0].top)).y
|
||
};
|
||
assert!(top("Col A") < top("1") && top("1") < top("2"));
|
||
assert!((top("alpha") - top("1")).abs() < 1.0 && (top("beta") - top("2")).abs() < 1.0);
|
||
assert!(top("Col B") >= 100.0);
|
||
}
|
||
|
||
#[test]
|
||
fn blend_ends_match_the_slides_and_mixes_backdrops() {
|
||
let sh = Shape {
|
||
id: ShapeId(500),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
let mut p = deck_with(vec![sh.clone()]);
|
||
let mut dark = (*p.slides[0]).clone();
|
||
dark.background =
|
||
Some(deckcraft_model::Background::Fill { fill: deckcraft_model::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0))) });
|
||
p.slides.push(std::sync::Arc::new(dark));
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
let shapes = vec![(sh, false)];
|
||
// At the ends the frame is the slide itself; the shape stays opaque throughout.
|
||
assert_eq!(render_blend(&p, 0, 1, 1.0, &shapes, &[], &[], &o).pixels, render_slide(&p, 1, &o).pixels);
|
||
let mid = render_blend(&p, 0, 1, 0.5, &shapes, &[], &[], &o);
|
||
let px = mid.pixel(5, 5);
|
||
assert!((px[0] as i32 - 128).abs() <= 3, "{px:?}");
|
||
assert_eq!(mid.pixel(100, 75), render_slide(&p, 1, &o).pixel(100, 75));
|
||
// Hostile input: bad indices and NaN never panic.
|
||
assert_eq!(render_blend(&p, 0, 9, 0.5, &shapes, &[], &[], &o).width, 0);
|
||
let _ = render_blend(&p, 0, 1, f64::NAN, &shapes, &[], &[], &o);
|
||
}
|
||
|
||
fn text_shape(id: u32, text: &str, x: f64, y: f64) -> Shape {
|
||
let mut t = TextBody::from_text(text);
|
||
for p in &mut t.paragraphs {
|
||
for r in &mut p.runs {
|
||
r.props.size = Some(40.0);
|
||
}
|
||
}
|
||
Shape { id: ShapeId(id), xfrm: Some(Xfrm::new(x, y, 600.0, 120.0)), text_box: true, text: Some(t), ..Default::default() }
|
||
}
|
||
|
||
#[test]
|
||
fn morph_text_tokens_are_words_or_characters() {
|
||
let p = Presentation::default();
|
||
let rctx = Ctx::for_slide(&p, &p.slides[0]).unwrap();
|
||
let s = text_shape(1, "Hello big world\nHello", 0.0, 0.0);
|
||
let l = deckcraft_text::layout(
|
||
&rctx,
|
||
&s,
|
||
s.text.as_ref().unwrap(),
|
||
&Opts { rect: Rect::new(0.0, 0.0, 600.0, 120.0), fields: &deckcraft_text::NoFields, prompt_color: None, no_shrink: false },
|
||
);
|
||
assert_eq!(morph_text::token_keys(&l, false), ["Hello", "big", "world", "Hello"]);
|
||
assert_eq!(morph_text::token_keys(&l, true).concat(), "Hellobigworld".to_string() + "Hello");
|
||
assert_eq!(morph_text::token_keys(&l, true).len(), 18);
|
||
}
|
||
|
||
#[test]
|
||
fn morph_text_ends_match_the_slides() {
|
||
let from = Xfrm::new(100.0, 60.0, 600.0, 120.0);
|
||
let to = Xfrm::new(200.0, 300.0, 600.0, 120.0);
|
||
let mut p = deck_with(vec![text_shape(1, "Hello wide world", from.x, from.y)]);
|
||
let mut b = (*p.slides[0]).clone();
|
||
b.shapes = vec![text_shape(1, "world says Hello", to.x, to.y)];
|
||
p.slides.push(std::sync::Arc::new(b));
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
let frame = |t: f64| {
|
||
let x = Xfrm::new(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t, 600.0, 120.0);
|
||
let mut sb = text_shape(10, "world says Hello", 0.0, 0.0);
|
||
let mut sa = text_shape(11, "Hello wide world", 0.0, 0.0);
|
||
sb.xfrm = Some(x);
|
||
sa.xfrm = Some(x);
|
||
let tm = TextMorph { old: ShapeId(11), new: ShapeId(10), from, to, chars: false, t };
|
||
render_blend(&p, 0, 1, t, &[(sb, false), (sa, true)], &[tm], &[], &o)
|
||
};
|
||
// Warm up: faces load lazily (a background scan runs), so the first render may still fall back.
|
||
let _ = (render_slide(&p, 0, &o), render_slide(&p, 1, &o), frame(0.5));
|
||
let close = |a: &Image, b: &Image| a.pixels.iter().zip(&b.pixels).filter(|(x, y)| x.abs_diff(**y) > 8).count();
|
||
let d0 = close(&frame(0.0), &render_slide(&p, 0, &o));
|
||
assert!(d0 < 40, "start differs {d0}");
|
||
let d1 = close(&frame(1.0), &render_slide(&p, 1, &o));
|
||
assert!(d1 < 40, "end differs {d1}");
|
||
// Halfway the shared words are on their way: ink between the two texts' rows.
|
||
let mid = frame(0.5);
|
||
let ink = (95..140).flat_map(|y| (0..480).map(move |x| (x, y))).filter(|&(x, y)| mid.pixel(x, y)[0] < 128).count();
|
||
assert!(ink > 50, "ink {ink}");
|
||
}
|
||
|
||
/// A text box holding one run of `kind` (a field type, or plain text for `None`) saved as `saved`.
|
||
fn field_shape(kind: Option<&str>, saved: &str) -> Shape {
|
||
let mut sh = text_shape(1, saved, 40.0, 40.0);
|
||
if let (Some(k), Some(run)) = (kind, sh.text.as_mut().and_then(|t| t.paragraphs[0].runs.first_mut())) {
|
||
run.kind = deckcraft_model::text::RunKind::Field { field: k.into() };
|
||
}
|
||
sh
|
||
}
|
||
|
||
#[test]
|
||
fn date_fields_show_the_date_in_their_format() {
|
||
use deckcraft_text::datetime::DateTime;
|
||
let fri = DateTime::new(2026, 10, 9, 20, 5, 7);
|
||
let at = |p: &Presentation, now: DateTime| render_slide(p, 0, &RenderOpts { scale: 0.5, now: Some(now), ..Default::default() });
|
||
let mut p = deck_with(vec![field_shape(Some("datetime1"), "1/1/2000")]);
|
||
let _ = at(&p, fri); // faces load lazily
|
||
// The field shows the date (it changes with the clock), not its saved text.
|
||
let a = at(&p, fri);
|
||
assert!(diff_px(&a, &at(&p, DateTime::new(2027, 3, 4, 0, 0, 0))) > 0);
|
||
let shown = deck_with(vec![field_shape(None, "10/9/2026")]);
|
||
assert_eq!(diff_px(&a, &at(&shown, fri)), 0, "datetime1 is M/D/YYYY");
|
||
// Another slide's fixed date (a deck-wide Header & Footer text) doesn't replace it.
|
||
p.header_footer.date_text = "Fixed on another slide".into();
|
||
assert_eq!(diff_px(&a, &at(&p, fri)), 0);
|
||
// Every type has its format; the run's language orders numeric dates.
|
||
let f = Renderer::fields(&p, 0, &RenderOpts { now: Some(fri), ..Default::default() });
|
||
assert_eq!(f.field_in("datetime4", Some("en-US")).as_deref(), Some("October 9, 2026"));
|
||
assert_eq!(f.field_in("datetimeFigureOut", Some("en-GB")).as_deref(), Some("09/10/2026"));
|
||
assert_eq!(f.field("datetime13").as_deref(), Some("8:05:07 PM"));
|
||
assert_eq!(f.field("slidenum").as_deref(), Some("1"));
|
||
// A date the app can't compute (no clock, unknown type, other-language names) keeps the saved text.
|
||
assert_eq!(SlideFields { now: None, ..f }.field("datetime1"), None);
|
||
let unknown = deck_with(vec![field_shape(Some("datetime99"), "Saved text")]);
|
||
let plain = deck_with(vec![field_shape(None, "Saved text")]);
|
||
assert_eq!(diff_px(&at(&unknown, fri), &at(&plain, fri)), 0);
|
||
// An explicit override still wins.
|
||
let o = RenderOpts { date_text: Some("Today".into()), now: Some(fri), ..Default::default() };
|
||
assert_eq!(Renderer::fields(&p, 0, &o).field("datetime2").as_deref(), Some("Today"));
|
||
}
|
||
|
||
/// Channel values that differ noticeably between two images of the same size.
|
||
fn diff_px(a: &Image, b: &Image) -> usize {
|
||
a.pixels.iter().zip(&b.pixels).filter(|(x, y)| x.abs_diff(**y) > 64).count()
|
||
}
|
||
|
||
/// Two 8×8 frames, red then blue, 100 ms each.
|
||
fn two_frame_gif() -> Vec<u8> {
|
||
use image::{Delay, Frame, Rgba, RgbaImage};
|
||
let frame = |c: [u8; 4]| Frame::from_parts(RgbaImage::from_pixel(8, 8, Rgba(c)), 0, 0, Delay::from_numer_denom_ms(100, 1));
|
||
let mut out = Vec::new();
|
||
image::codecs::gif::GifEncoder::new(&mut out).encode_frames([frame([255, 0, 0, 255]), frame([0, 0, 255, 255])]).expect("gif");
|
||
out
|
||
}
|
||
|
||
#[test]
|
||
fn animated_gif_shows_the_frame_for_its_time() {
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("a.gif", "image/gif", two_frame_gif()).expect("media");
|
||
let fill = deckcraft_model::style::PictureFill { media, ..Default::default() };
|
||
let sh = Shape { id: ShapeId(600), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Picture { fill }, ..Default::default() };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let at = |t: Option<f64>| {
|
||
let times: Vec<(ShapeId, f64)> = t.map(|t| vec![(ShapeId(600), t)]).unwrap_or_default();
|
||
render_slide(&p, 0, &RenderOpts { scale: 0.1, gif_times: ×, ..Default::default() }).pixel(48, 27)
|
||
};
|
||
let red = |px: [u8; 4]| px[0] > 200 && px[2] < 60;
|
||
let blue = |px: [u8; 4]| px[2] > 200 && px[0] < 60;
|
||
assert!(red(at(None)), "no time: the first frame, as exports draw it");
|
||
assert!(red(at(Some(0.05))));
|
||
assert!(blue(at(Some(0.15))));
|
||
assert!(red(at(Some(0.25))), "it loops");
|
||
let bytes = p.media(media).map(|m| m.data.clone()).expect("media");
|
||
let adj = Default::default();
|
||
assert_eq!(gif_frame(&bytes, &adj, 0.15).map(|f| f.0), Some(1));
|
||
assert_eq!(gif_frame(&bytes, &adj, f64::NAN).map(|f| f.0), Some(0));
|
||
assert!(gif_frame(&std::sync::Arc::new(b"\x89PNG".to_vec()), &adj, 0.0).is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn morph_path_ends_match_the_slides() {
|
||
let from = Xfrm::new(100.0, 100.0, 200.0, 200.0);
|
||
let to = Xfrm::new(500.0, 150.0, 300.0, 150.0);
|
||
let form = |id: u32, g: &str, x: Xfrm| Shape {
|
||
id: ShapeId(id),
|
||
xfrm: Some(x),
|
||
geom: Geom::preset(g),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
let mut p = deck_with(vec![form(1, "ellipse", from)]);
|
||
let mut b = (*p.slides[0]).clone();
|
||
b.shapes = vec![form(1, "star5", to)];
|
||
p.slides.push(std::sync::Arc::new(b));
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
let frame = |t: f64| {
|
||
let lerp = |a: f64, b: f64| a + (b - a) * t;
|
||
let x = Xfrm::new(lerp(from.x, to.x), lerp(from.y, to.y), lerp(from.w, to.w), lerp(from.h, to.h));
|
||
let pm = PathMorph { id: ShapeId(10), from: Geom::preset("ellipse"), from_box: from, to_box: to, t };
|
||
render_blend(&p, 0, 1, t, &[(form(10, "star5", x), false)], &[], &[pm], &o)
|
||
};
|
||
// The morph splits the outlines into more curves, which flatten slightly differently: edge pixels
|
||
// may differ a little, a different shape differs a lot.
|
||
let differ = |a: &Image, b: &Image| a.pixels.iter().zip(&b.pixels).filter(|(x, y)| x.abs_diff(**y) > 60).count();
|
||
// At the start the star is still the circle, at the end the star.
|
||
let d0 = differ(&frame(0.0), &render_slide(&p, 0, &o));
|
||
assert!(d0 < 40, "start differs {d0}");
|
||
let d1 = differ(&frame(1.0), &render_slide(&p, 1, &o));
|
||
assert!(d1 < 40, "end differs {d1}");
|
||
// Without the morph the start would show the star.
|
||
let star = render_blend(&p, 0, 1, 0.0, &[(form(10, "star5", from), false)], &[], &[], &o);
|
||
assert!(differ(&star, &render_slide(&p, 0, &o)) > 400);
|
||
// Halfway the shape is filled around the middle of its box.
|
||
let mid = frame(0.5);
|
||
let c = (from.center().to_vec2() + to.center().to_vec2()) * 0.5 * 0.5;
|
||
assert_ne!(mid.pixel(c.x as u32, c.y as u32), [255, 255, 255, 255]);
|
||
}
|
||
|
||
#[test]
|
||
fn morph_path_fades_a_fill_only_one_side_has() {
|
||
let bx = Xfrm::new(100.0, 100.0, 200.0, 200.0);
|
||
let form = |id: u32, g: &str| Shape {
|
||
id: ShapeId(id),
|
||
xfrm: Some(bx),
|
||
geom: Geom::preset(g),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
let mut p = deck_with(vec![form(1, "rect")]);
|
||
let mut b = (*p.slides[0]).clone();
|
||
b.shapes = vec![form(1, "line")];
|
||
p.slides.push(std::sync::Arc::new(b));
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
let at = |t: f64| {
|
||
let pm = PathMorph { id: ShapeId(10), from: Geom::preset("rect"), from_box: bx, to_box: bx, t };
|
||
// A point near the line but not on it: inside the shape all the way.
|
||
render_blend(&p, 0, 1, t, &[(form(10, "line"), false)], &[], &[pm], &o).pixel(110, 90)
|
||
};
|
||
let (full, half, none) = (at(0.0), at(0.5), at(1.0));
|
||
assert_eq!(none, [255, 255, 255, 255]);
|
||
assert!(full[0] < 128, "{full:?}");
|
||
// Halfway the fill is half there: between the full colour and the white slide.
|
||
assert!(half[0] > full[0] + 40 && half[0] < 215, "{half:?} vs {full:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn morph_path_aligns_once_per_transition() {
|
||
let (from, to) = (Xfrm::new(0.0, 0.0, 200.0, 200.0), Xfrm::new(0.0, 0.0, 300.0, 150.0));
|
||
let star = Shape { geom: Geom::preset("star5"), ..Default::default() };
|
||
let pm = |t: f64| PathMorph { id: ShapeId(10), from: Geom::preset("ellipse"), from_box: from, to_box: to, t };
|
||
let els = |(g, f): (deckcraft_geom::preset::Geometry, Vec<_>)| (g.paths.iter().map(|p| p.path.elements().to_vec()).collect::<Vec<_>>(), f);
|
||
let mut cache = morph_path::Cache::default();
|
||
for t in [0.0, 0.3, 0.7, 1.0] {
|
||
let got = els(cache.geometry(&pm(t), &star, 250.0, 175.0));
|
||
// The same as aligning afresh.
|
||
assert_eq!(got, els(morph_path::Cache::default().geometry(&pm(t), &star, 250.0, 175.0)));
|
||
cache.sweep();
|
||
}
|
||
assert_eq!(cache.len(), 1);
|
||
// Another target outline is another morph.
|
||
let _ = cache.geometry(&pm(0.5), &Shape { geom: Geom::preset("rect"), ..Default::default() }, 250.0, 175.0);
|
||
assert_eq!(cache.len(), 2);
|
||
// A frame without morphs ends the transition: the cache empties.
|
||
cache.sweep();
|
||
cache.sweep();
|
||
assert_eq!(cache.len(), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn text_transform_unmirrors_flips() {
|
||
// Asymmetric text rect in a 100×50 box: flips move the rect, never mirror the text.
|
||
let tr = Rect::new(10.0, 0.0, 40.0, 50.0);
|
||
let at = |x: Xfrm, p: Point| text_transform(x.affine(), tr, 0.0) * p;
|
||
let near = |a: Point, b: Point| (a - b).hypot() < 1e-9;
|
||
let base = Xfrm::new(0.0, 0.0, 100.0, 50.0);
|
||
// flipH: the rect moves to 60..90 and the text still runs left to right.
|
||
let h = Xfrm { flip_h: true, ..base };
|
||
assert!(near(at(h, Point::new(10.0, 0.0)), Point::new(60.0, 0.0)));
|
||
assert!(near(at(h, Point::new(40.0, 50.0)), Point::new(90.0, 50.0)));
|
||
// flipV: the text is turned 180° in its (vertically mirrored) rect.
|
||
let v = Xfrm { flip_v: true, ..base };
|
||
assert!(near(at(v, Point::new(10.0, 0.0)), Point::new(40.0, 50.0)));
|
||
assert!(near(at(v, Point::new(40.0, 50.0)), Point::new(10.0, 0.0)));
|
||
// Both flips: the same as a 180° turn.
|
||
let hv = Xfrm { flip_h: true, flip_v: true, ..base };
|
||
let turned = Xfrm { rot: 180.0, ..base };
|
||
for p in [Point::new(10.0, 0.0), Point::new(40.0, 50.0), Point::new(25.0, 10.0)] {
|
||
assert!(near(at(hv, p), at(turned, p)));
|
||
}
|
||
// Unflipped and hostile input: plain transform, nothing NaN from the helper itself.
|
||
assert_eq!(text_transform(base.affine(), tr, 0.0), base.affine());
|
||
let _ = text_transform(h.affine(), Rect::new(f64::NAN, 0.0, f64::INFINITY, 1.0), f64::NAN);
|
||
}
|
||
|
||
/// Slide with text box `x` holding left-aligned, asymmetric text.
|
||
fn flipped_text(x: Xfrm, group: Option<Xfrm>) -> Image {
|
||
let mut s = text_shape(1, "Fly 42 RJ", 0.0, 0.0);
|
||
s.xfrm = Some(x);
|
||
let s = match group {
|
||
Some(g) => Shape {
|
||
id: ShapeId(2),
|
||
xfrm: Some(g),
|
||
kind: ShapeKind::Group { children: vec![s], child: Xfrm::new(0.0, 0.0, 600.0, 120.0) },
|
||
..Default::default()
|
||
},
|
||
None => s,
|
||
};
|
||
render_slide(&deck_with(vec![s]), 0, &RenderOpts { scale: 0.5, ..Default::default() })
|
||
}
|
||
|
||
fn differing(a: &Image, b: &Image) -> usize {
|
||
a.pixels.iter().zip(&b.pixels).filter(|(x, y)| x.abs_diff(**y) > 64).count()
|
||
}
|
||
|
||
#[test]
|
||
fn flipped_shapes_draw_readable_text() {
|
||
let base = Xfrm::new(180.0, 200.0, 600.0, 120.0);
|
||
let plain = flipped_text(base, None);
|
||
// Warm up: faces load lazily, so the first render may still fall back.
|
||
let plain = if differing(&plain, &flipped_text(base, None)) > 0 { flipped_text(base, None) } else { plain };
|
||
let turned = flipped_text(Xfrm { rot: 180.0, ..base }, None);
|
||
assert!(differing(&plain, &turned) > 200, "the comparisons below must mean something");
|
||
// flipH: text as unflipped (the text box is symmetric). flipV and both: turned 180°.
|
||
let d = differing(&plain, &flipped_text(Xfrm { flip_h: true, ..base }, None));
|
||
assert!(d < 40, "flipH mirrored the text: {d}");
|
||
let d = differing(&turned, &flipped_text(Xfrm { flip_v: true, ..base }, None));
|
||
assert!(d < 40, "flipV mirrored the text: {d}");
|
||
let d = differing(&turned, &flipped_text(Xfrm { flip_h: true, flip_v: true, ..base }, None));
|
||
assert!(d < 40, "flipH+flipV: {d}");
|
||
// Rotation then flipH: still the rotated text, not its mirror image.
|
||
let rot = Xfrm { rot: 30.0, ..base };
|
||
let d = differing(&flipped_text(rot, None), &flipped_text(Xfrm { flip_h: true, ..rot }, None));
|
||
assert!(d < 40, "rotated flipH: {d}");
|
||
// Groups: a flipped group's text isn't mirrored; a flipped child in a flipped group neither.
|
||
let child = Xfrm::new(0.0, 0.0, 600.0, 120.0);
|
||
let d = differing(&plain, &flipped_text(child, Some(Xfrm { flip_h: true, ..base })));
|
||
assert!(d < 40, "group flipH: {d}");
|
||
let d = differing(&plain, &flipped_text(Xfrm { flip_h: true, ..child }, Some(Xfrm { flip_h: true, ..base })));
|
||
assert!(d < 40, "flipH child in flipH group: {d}");
|
||
let d = differing(&turned, &flipped_text(child, Some(Xfrm { flip_v: true, ..base })));
|
||
assert!(d < 40, "group flipV: {d}");
|
||
}
|
||
|
||
/// A text box with one run of `props` (40 pt).
|
||
fn run_deck(props: deckcraft_model::RunProps) -> Presentation {
|
||
let mut sh = text_shape(1, "Linked text", 40.0, 40.0);
|
||
if let Some(run) = sh.text.as_mut().and_then(|t| t.paragraphs[0].runs.first_mut()) {
|
||
run.props = deckcraft_model::RunProps { size: Some(40.0), ..props };
|
||
}
|
||
deck_with(vec![sh])
|
||
}
|
||
|
||
#[test]
|
||
fn hyperlinks_draw_in_the_hyperlink_colour_underlined() {
|
||
use deckcraft_model::RunProps;
|
||
use deckcraft_model::text::{Action, Hyperlink};
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
let px = |p: &Presentation| render_slide(p, 0, &o);
|
||
let diff = |a: &Image, b: &Image| a.pixels.iter().zip(&b.pixels).filter(|(x, y)| x.abs_diff(**y) > 64).count();
|
||
let link = Some(Hyperlink {
|
||
action: Action::Url { url: "https://example.org".into() },
|
||
tooltip: String::new(),
|
||
highlight_click: false,
|
||
sound: None,
|
||
stop_sound: false,
|
||
zoom_return: None,
|
||
});
|
||
let hlink = Some(Fill::solid(ColorRef::scheme(deckcraft_color::SchemeSlot::Hlink)));
|
||
let red = Some(Fill::solid(ColorRef::rgb(Rgba::rgb(200, 0, 0))));
|
||
let _ = px(&run_deck(RunProps::default())); // faces load lazily
|
||
let linked = px(&run_deck(RunProps { link: link.clone(), ..Default::default() }));
|
||
assert!(diff(&linked, &px(&run_deck(RunProps::default()))) > 100, "a link doesn't look like plain text");
|
||
// Exactly the theme's hyperlink colour, single underline.
|
||
let styled = px(&run_deck(RunProps { fill: hlink, underline: Some("sng".into()), ..Default::default() }));
|
||
assert_eq!(diff(&linked, &styled), 0);
|
||
// A colour on the run itself wins; u="none" drops the underline.
|
||
let own = px(&run_deck(RunProps { link: link.clone(), fill: red.clone(), underline: Some("none".into()), ..Default::default() }));
|
||
assert_eq!(diff(&own, &px(&run_deck(RunProps { fill: red.clone(), ..Default::default() }))), 0);
|
||
let own = px(&run_deck(RunProps { link, fill: red.clone(), ..Default::default() }));
|
||
assert_eq!(diff(&own, &px(&run_deck(RunProps { fill: red, underline: Some("sng".into()), ..Default::default() }))), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn a_linear_gradient_ramps_like_powerpoint() {
|
||
// Black to white, left to right: PowerPoint draws 105 a quarter of the way and 186 half way
|
||
// (linear-light mix, S-shaped), not 64 and 128.
|
||
use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
|
||
let stop = |pos, c| GradientStop { pos, color: ColorRef::rgb(c) };
|
||
let sh = Shape {
|
||
id: ShapeId(700),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 800.0, 100.0)),
|
||
fill: Some(Fill::Gradient(Gradient {
|
||
tile: [0.0; 4],
|
||
stops: vec![stop(0.0, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
|
||
shape: GradientShape::Linear { angle: 0.0, scaled: false },
|
||
rotate_with_shape: true,
|
||
})),
|
||
line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
for (x, want) in [(200, 105), (400, 186), (600, 238)] {
|
||
let got = img.pixel(x, 50)[0] as i32;
|
||
assert!((got - want).abs() <= 4, "x {x}: {got} vs {want}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_gradient_with_a_stop_off_the_end_stays_linear() {
|
||
// Stops at 20 % and 100 %: PowerPoint blends linearly in sRGB (96 at 50 %, 175 at 75 %).
|
||
use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
|
||
let stop = |pos, c| GradientStop { pos, color: ColorRef::rgb(c) };
|
||
let sh = Shape {
|
||
id: ShapeId(701),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 800.0, 100.0)),
|
||
fill: Some(Fill::Gradient(Gradient {
|
||
tile: [0.0; 4],
|
||
stops: vec![stop(0.2, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
|
||
shape: GradientShape::Linear { angle: 0.0, scaled: false },
|
||
rotate_with_shape: true,
|
||
})),
|
||
line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
for (x, want) in [(400, 96), (600, 175)] {
|
||
let got = img.pixel(x, 50)[0] as i32;
|
||
assert!((got - want).abs() <= 4, "x {x}: {got} vs {want}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_shape_filled_with_the_background_shows_the_slide_background() {
|
||
// `useBgFill`: PowerPoint paints the slide's background into the shape, laid out on the
|
||
// slide. A white panel covers a black-to-grey background; a shape on it with the background
|
||
// fill is a window onto that background.
|
||
use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
|
||
let none = || Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() });
|
||
let panel = Shape {
|
||
id: ShapeId(710),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)),
|
||
fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 255, 255)))),
|
||
line: none(),
|
||
..Default::default()
|
||
};
|
||
let window = Shape {
|
||
id: ShapeId(711),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 760.0, 340.0)),
|
||
fill: Some(Fill::Background),
|
||
line: none(),
|
||
..Default::default()
|
||
};
|
||
let mut p = deck_with(vec![panel, window]);
|
||
let stop = |pos, v| GradientStop { pos, color: ColorRef::rgb(deckcraft_color::Rgba::rgb(v, v, v)) };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).background = Some(deckcraft_model::Background::Fill {
|
||
fill: Fill::Gradient(Gradient {
|
||
tile: [0.0; 4],
|
||
stops: vec![stop(0.0, 0), stop(0.5, 0), stop(1.0, 200)],
|
||
shape: GradientShape::Linear { angle: 0.0, scaled: false },
|
||
rotate_with_shape: true,
|
||
}),
|
||
});
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert_eq!(img.pixel(50, 50)[0], 255, "the panel stays white outside the window");
|
||
assert!(img.pixel(300, 270)[0] < 8, "the window shows the background's black half: {:?}", img.pixel(300, 270));
|
||
// Laid out on the slide: three quarters across the slide is half way from black to grey.
|
||
let v = img.pixel(720, 270)[0] as i32;
|
||
assert!((v - 100).abs() <= 6, "{v}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_background_is_laid_over_white() {
|
||
// A background picture stretched into the bottom-right quarter (fillRect l=50% t=50%), and a
|
||
// half-transparent colour: PowerPoint shows white around and under them, not transparency.
|
||
use deckcraft_model::style::{Fill, PictureFill, PictureMode};
|
||
let mut png = std::io::Cursor::new(Vec::new());
|
||
image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(4, 4, image::Rgb([0, 0, 200]))).write_to(&mut png, image::ImageFormat::Png).unwrap();
|
||
let mut p = deck_with(vec![]);
|
||
let media = p.add_media("bg.png", "image/png", png.into_inner()).expect("media");
|
||
let pf = PictureFill { media, mode: PictureMode::Stretch { fill_rect: [0.5, 0.5, 0.0, 0.0] }, ..Default::default() };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).background = Some(deckcraft_model::Background::Fill { fill: Fill::Picture(pf) });
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 0.5, ..Default::default() });
|
||
assert_eq!(img.pixel(20, 20), [255, 255, 255, 255], "white where the picture doesn't reach");
|
||
let q = img.pixel(400, 230);
|
||
assert!(q[2] > 190 && q[0] < 10 && q[3] == 255, "{q:?}");
|
||
let see_through = ColorRef::rgb(deckcraft_color::Rgba { r: 0, g: 0, b: 0, a: 128 });
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).background = Some(deckcraft_model::Background::Fill { fill: Fill::solid(see_through) });
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 0.5, ..Default::default() });
|
||
let g = img.pixel(20, 20);
|
||
assert!(g[3] == 255 && (g[0] as i32 - 127).abs() <= 3, "half-transparent black over white is grey: {g:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_transparent_background_leaves_the_slide_background_out() {
|
||
// #784: PNG export with a transparent background draws only what is on the slide. The
|
||
// background (a solid colour here) and its white underlay are left out; the shapes, and a
|
||
// shape filled with the background (`useBgFill`), still draw.
|
||
use deckcraft_model::style::Fill;
|
||
let blue = ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 200));
|
||
let red = Shape {
|
||
id: ShapeId(784),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)),
|
||
fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(220, 0, 0)))),
|
||
..Default::default()
|
||
};
|
||
let bg_filled = Shape { id: ShapeId(785), xfrm: Some(Xfrm::new(500.0, 100.0, 200.0, 100.0)), fill: Some(Fill::Background), ..Default::default() };
|
||
let mut p = deck_with(vec![red, bg_filled]);
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).background = Some(deckcraft_model::Background::Fill { fill: Fill::solid(blue) });
|
||
let opaque = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert_eq!(opaque.pixel(20, 20), [0, 0, 200, 255], "without the option the background draws");
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, transparent_background: true, ..Default::default() });
|
||
assert_eq!(img.pixel(20, 20), [0, 0, 0, 0], "no background, no white underlay");
|
||
assert_eq!(img.pixel(200, 150), [220, 0, 0, 255], "the slide's shapes still draw");
|
||
assert_eq!(img.pixel(600, 150), [0, 0, 200, 255], "a background-filled shape still shows the background");
|
||
// The default theme background (a style reference) is left out too.
|
||
let img = render_slide(&deck_with(vec![]), 0, &RenderOpts { scale: 0.25, transparent_background: true, ..Default::default() });
|
||
assert!(img.pixels.as_chunks::<4>().0.iter().all(|px| px[3] == 0), "a blank slide is fully transparent");
|
||
}
|
||
|
||
#[test]
|
||
fn colour_glyphs_paint_their_layers() {
|
||
// A COLRv0 test font (crates/render/tests/fixtures): U+E000 is a red square with a blue
|
||
// square in its middle, U+E001 a square in the text colour.
|
||
deckcraft_fonts::FontDb::global().add_font(include_bytes!("../tests/fixtures/colr-squares.ttf").to_vec());
|
||
let mut sh = Shape { id: ShapeId(720), xfrm: Some(Xfrm::new(0.0, 0.0, 400.0, 200.0)), text_box: true, ..Default::default() };
|
||
let mut t = TextBody::from_text("\u{E000} \u{E001}");
|
||
let props = &mut t.paragraphs[0].runs[0].props;
|
||
props.size = Some(72.0);
|
||
props.font = Some("DeckCraft Colr Squares".into());
|
||
props.fill = Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 160, 0))));
|
||
sh.text = Some(t);
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let count = |f: &dyn Fn(&[u8; 4]) -> bool| img.pixels.as_chunks::<4>().0.iter().filter(|px| f(px)).count();
|
||
let red = count(&|p| p[0] > 230 && p[1] < 30 && p[2] < 30);
|
||
let blue = count(&|p| p[0] < 30 && p[1] < 30 && p[2] > 230);
|
||
let green = count(&|p| p[0] < 30 && p[1] > 140 && p[1] < 180 && p[2] < 30);
|
||
// 72 pt squares: the blue one is 40 % of the side (16 % of the area).
|
||
assert!(red > 2500 && blue > 500, "red {red} blue {blue}");
|
||
let share = blue as f64 / (red + blue) as f64;
|
||
assert!((share - 0.16).abs() < 0.03, "blue share {share}");
|
||
// The text-colour glyph is as big as the other square.
|
||
assert!((green as f64 / (red + blue) as f64 - 1.0).abs() < 0.1, "green {green} vs {}", red + blue);
|
||
}
|
||
|
||
#[test]
|
||
fn a_text_gradient_starts_over_on_every_line() {
|
||
// PowerPoint fills each line of gradient text with the whole gradient, spanning that line
|
||
// (black at the top of every line to white at its bottom), not the text box.
|
||
use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
|
||
let stop = |pos, v| GradientStop { pos, color: ColorRef::rgb(deckcraft_color::Rgba::rgb(v, v, v)) };
|
||
let mut sh = Shape { id: ShapeId(730), xfrm: Some(Xfrm::new(0.0, 0.0, 600.0, 500.0)), text_box: true, ..Default::default() };
|
||
let mut t = TextBody::from_text("HHHH\nHHHH");
|
||
for p in &mut t.paragraphs {
|
||
let props = &mut p.runs[0].props;
|
||
props.size = Some(80.0);
|
||
props.fill = Some(Fill::Gradient(Gradient {
|
||
tile: [0.0; 4],
|
||
stops: vec![stop(0.0, 0), stop(1.0, 255)],
|
||
shape: GradientShape::Linear { angle: 90.0, scaled: false },
|
||
rotate_with_shape: true,
|
||
}));
|
||
}
|
||
sh.text = Some(t);
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
// Ink rows (any pixel not white), grouped into the two lines.
|
||
let ink = |y: u32| (0..600).any(|x| img.pixel(x, y)[0] < 250);
|
||
let mut bands: Vec<(u32, u32)> = vec![];
|
||
for y in 0..500 {
|
||
if ink(y) {
|
||
match bands.last_mut() {
|
||
Some(b) if b.1 + 1 == y => b.1 = y,
|
||
_ => bands.push((y, y)),
|
||
}
|
||
}
|
||
}
|
||
assert_eq!(bands.len(), 2, "{bands:?}");
|
||
// The darkest ink in the first rows of each line.
|
||
let top = |b: (u32, u32)| (b.0..b.0 + 6).flat_map(|y| (0..600).map(move |x| (x, y))).map(|(x, y)| img.pixel(x, y)[0]).min().unwrap();
|
||
let (a, b) = (top(bands[0]), top(bands[1]));
|
||
assert!(a < 140 && (a as i32 - b as i32).abs() < 25, "line tops {a} and {b}: the second line starts dark again");
|
||
// ...and each line ends light.
|
||
let bottom = |b: (u32, u32)| (b.1 - 5..=b.1).flat_map(|y| (0..600).map(move |x| (x, y))).map(|(x, y)| img.pixel(x, y)[0]).min().unwrap();
|
||
for band in bands {
|
||
assert!(bottom(band) > 150, "line {band:?} ends at {}", bottom(band));
|
||
}
|
||
}
|
||
|
||
/// A text box of big black "IIII" with `set` applied to its run.
|
||
fn effect_text(set: impl Fn(&mut deckcraft_model::text::RunProps)) -> Presentation {
|
||
let mut sh = Shape { id: ShapeId(740), xfrm: Some(Xfrm::new(100.0, 100.0, 600.0, 300.0)), text_box: true, ..Default::default() };
|
||
let mut t = TextBody::from_text("IIII");
|
||
let props = &mut t.paragraphs[0].runs[0].props;
|
||
props.size = Some(100.0);
|
||
props.fill = Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0))));
|
||
set(props);
|
||
sh.text = Some(t);
|
||
deck_with(vec![sh])
|
||
}
|
||
|
||
#[test]
|
||
fn text_glow_and_shadow_are_drawn() {
|
||
let count = |img: &Image, f: &dyn Fn(&[u8; 4]) -> bool| img.pixels.as_chunks::<4>().0.iter().filter(|px| f(px)).count();
|
||
let green = |p: &[u8; 4]| p[1] > 150 && p[0] < 120 && p[2] < 120;
|
||
let plain = effect_text(|_| {});
|
||
assert!(!needs_filters(&plain, &plain.slides[0]));
|
||
let img = render_slide(&plain, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert_eq!(count(&img, &green), 0);
|
||
// Glow: a green halo hugging the letters, needing the blur filter.
|
||
let glow =
|
||
effect_text(|p| p.glow = Some(deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 255, 0)), radius: 8.0 }));
|
||
assert!(needs_filters(&glow, &glow.slides[0]), "text glow blurs");
|
||
let img = render_slide(&glow, 0, &RenderOpts { scale: 1.0, threads: 4, ..Default::default() });
|
||
let halo = count(&img, &green);
|
||
assert!(halo > 300, "green halo pixels {halo}");
|
||
// Shadow: grey ink below and right of the letters, where the plain text has none.
|
||
let shadow = effect_text(|p| {
|
||
p.shadow = Some(deckcraft_model::style::Shadow {
|
||
color: ColorRef::rgb(deckcraft_color::Rgba { r: 0, g: 0, b: 0, a: 128 }),
|
||
blur: 2.0,
|
||
dist: 12.0,
|
||
dir: 45.0,
|
||
inner: false,
|
||
sx: 1.0,
|
||
sy: 1.0,
|
||
kx: 0.0,
|
||
ky: 0.0,
|
||
align: String::new(),
|
||
rotate_with_shape: false,
|
||
})
|
||
});
|
||
let img = render_slide(&shadow, 0, &RenderOpts { scale: 1.0, threads: 4, ..Default::default() });
|
||
let base = render_slide(&plain, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let grey = |p: &[u8; 4]| p[0] > 60 && p[0] < 230 && p[0] == p[1] && p[1] == p[2];
|
||
assert!(count(&img, &grey) > count(&base, &grey) + 300, "a grey shadow appears");
|
||
}
|
||
|
||
#[test]
|
||
fn pattern_fills_draw_powerpoints_tiles() {
|
||
// dkVert at one output pixel per pattern cell (0.75 pt): columns 11001100… across, as
|
||
// PowerPoint's export draws it; pct50 is a checkerboard.
|
||
use deckcraft_model::style::{Fill, PatternFill};
|
||
let rgb = |v| ColorRef::rgb(deckcraft_color::Rgba::rgb(v, v, v));
|
||
let shape = |id, x: f64, preset: &str| Shape {
|
||
id: ShapeId(id),
|
||
xfrm: Some(Xfrm::new(x, 0.0, 60.0, 60.0)),
|
||
fill: Some(Fill::Pattern(PatternFill { preset: preset.into(), fg: rgb(0), bg: rgb(255) })),
|
||
line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![shape(750, 0.0, "dkVert"), shape(751, 120.0, "pct50")]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 4.0 / 3.0, ..Default::default() });
|
||
let dark = |x: u32, y: u32| img.pixel(x, y)[0] < 128;
|
||
let row: Vec<bool> = (8..16).map(|x| dark(x, 20)).collect();
|
||
assert_eq!(row, [true, true, false, false, true, true, false, false], "dkVert columns");
|
||
assert!((8..16).all(|y| dark(8, y) == dark(8, 20)), "dkVert is vertical");
|
||
// pct50 starts at slide x = 120 pt = 160 px.
|
||
for (x, y) in [(168, 8), (169, 9), (170, 12)] {
|
||
assert_ne!(dark(x, y), dark(x + 1, y), "pct50 alternates across at {x},{y}");
|
||
assert_eq!(dark(x, y), dark(x + 1, y + 1), "pct50 repeats diagonally at {x},{y}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn compound_lines_draw_their_bands() {
|
||
// A 24 pt outline on a rectangle, as PowerPoint's export draws each kind (top edge, outside
|
||
// first): double 8/8/8, thin-thick 4.8/4.8/14.4, triple 4/4/8/4/4.
|
||
use deckcraft_model::style::{Compound, Fill, Line};
|
||
let runs = |c: Compound| {
|
||
let sh = Shape {
|
||
id: ShapeId(760),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 300.0, 200.0)),
|
||
fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 255, 255)))),
|
||
line: Some(Line {
|
||
fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0)))),
|
||
width: Some(24.0),
|
||
compound: Some(c),
|
||
..Default::default()
|
||
}),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 2.0, ..Default::default() });
|
||
// Down the middle of the top edge (y 100 pt), from 80 pt to 120 pt: lengths of dark and
|
||
// light runs in points.
|
||
let mut out: Vec<(bool, f64)> = vec![];
|
||
for y in 160..240 {
|
||
let dark = img.pixel(500, y)[0] < 128;
|
||
match out.last_mut() {
|
||
Some((d, n)) if *d == dark => *n += 0.5,
|
||
_ => out.push((dark, 0.5)),
|
||
}
|
||
}
|
||
out.into_iter().filter(|(d, _)| *d).map(|(_, n)| n).collect::<Vec<f64>>()
|
||
};
|
||
let close = |got: Vec<f64>, want: &[f64]| got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g - w).abs() <= 1.0);
|
||
assert!(close(runs(Compound::Single), &[24.0]));
|
||
let d = runs(Compound::Double);
|
||
assert!(close(d.clone(), &[8.0, 8.0]), "{d:?}");
|
||
let t = runs(Compound::ThinThick);
|
||
assert!(close(t.clone(), &[4.8, 14.4]), "{t:?}");
|
||
let k = runs(Compound::ThickThin);
|
||
assert!(close(k.clone(), &[14.4, 4.8]), "{k:?}");
|
||
let tri = runs(Compound::Triple);
|
||
assert!(close(tri.clone(), &[4.0, 8.0, 4.0]), "{tri:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn rect_path_gradients_draw_x_shaped_contours() {
|
||
// path="rect" from the centre, black to grey to white (linear): PowerPoint's colour position is
|
||
// the larger axis share, so 20 pt right of centre in a 280x200 box is 1/7 and 20 pt down 1/5.
|
||
use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
|
||
let stop = |pos, v| GradientStop { pos, color: ColorRef::rgb(deckcraft_color::Rgba::rgb(v, v, v)) };
|
||
let sh = Shape {
|
||
id: ShapeId(770),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 280.0, 200.0)),
|
||
fill: Some(Fill::Gradient(Gradient {
|
||
tile: [0.0; 4],
|
||
stops: vec![stop(0.0, 0), stop(0.5, 128), stop(1.0, 255)],
|
||
shape: GradientShape::Path { path: "rect".into(), focus: [0.5, 0.5, 0.5, 0.5] },
|
||
rotate_with_shape: true,
|
||
})),
|
||
line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let v = |x: u32, y: u32| img.pixel(x, y)[0] as f64;
|
||
assert!((v(160, 100) - 255.0 / 7.0).abs() < 6.0, "{}", v(160, 100));
|
||
assert!((v(140, 120) - 51.0).abs() < 6.0, "{}", v(140, 120));
|
||
// Along the diagonal to a corner the colour follows the vertical share.
|
||
assert!((v(168, 120) - 51.0).abs() < 6.0, "{}", v(168, 120));
|
||
}
|
||
|
||
#[test]
|
||
fn soft_edges_fade_to_the_outline() {
|
||
// An ellipse with a 12 pt soft edge: transparent at its outline, half opaque about 10 pt
|
||
// inside, opaque further in, as in PowerPoint's export (the fade follows the curve, not the
|
||
// bounding box).
|
||
let sh = Shape {
|
||
id: ShapeId(780),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 300.0, 200.0)),
|
||
geom: Geom::Preset { name: "ellipse".into(), adj: vec![] },
|
||
fill: Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0)))),
|
||
line: Some(deckcraft_model::style::Line { fill: Some(deckcraft_model::style::Fill::None), ..Default::default() }),
|
||
effects: Some(deckcraft_model::Effects { soft_edge: Some(12.0), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let alpha = |x: u32, y: u32| 1.0 - img.pixel(x, y)[0] as f64 / 255.0;
|
||
// Top of the ellipse is at y = 100, x = 250.
|
||
assert!(alpha(250, 101) < 0.08, "edge {}", alpha(250, 101));
|
||
let mid = alpha(250, 110);
|
||
assert!((0.3..0.7).contains(&mid), "0.85 r inside: {mid}");
|
||
assert!(alpha(250, 130) > 0.97, "inside {}", alpha(250, 130));
|
||
// Near the ends of the bounding box's top edge, outside the ellipse, nothing is drawn.
|
||
assert!(alpha(110, 105) < 0.01);
|
||
}
|
||
|
||
#[test]
|
||
fn a_file_defined_table_style_draws_its_parts() {
|
||
// Red table background (tblBg), see-through white on banded rows, a 4 pt blue left border and
|
||
// no inside lines: drawn from the definition, not DeckCraft's own look for the style.
|
||
use deckcraft_model::style::{Fill, Line};
|
||
use deckcraft_model::table::{TableBorder, TablePart, TablePartStyle, TableStyleDef};
|
||
let rgb = |r, g, b| ColorRef::rgb(deckcraft_color::Rgba::rgb(r, g, b));
|
||
let mut t = Table::new(4, 2, 400.0, 50.0);
|
||
t.style = "{ABCDEF01-2345-4678-9ABC-DEF012345678}".into();
|
||
t.first_row = false;
|
||
t.band_row = true;
|
||
let line = |c: ColorRef, w| TableBorder::Line { line: Line { fill: Some(Fill::solid(c)), width: Some(w), ..Default::default() } };
|
||
let mut whole = TablePartStyle { fill: Some(Fill::None), ..Default::default() };
|
||
whole.borders[0] = Some(line(rgb(0, 0, 255), 4.0));
|
||
whole.borders[4] = Some(TableBorder::Line { line: Line { fill: Some(Fill::None), ..Default::default() } });
|
||
let see_through = ColorRef::rgb(deckcraft_color::Rgba { r: 255, g: 255, b: 255, a: 51 });
|
||
let band = TablePartStyle { fill: Some(Fill::solid(see_through)), ..Default::default() };
|
||
let def = TableStyleDef {
|
||
id: t.style.clone(),
|
||
name: "Probe".into(),
|
||
parts: vec![(TablePart::WholeTbl, whole), (TablePart::Band1H, band)],
|
||
background: Some(TablePartStyle { fill: Some(Fill::solid(rgb(255, 0, 0))), ..Default::default() }),
|
||
raw: String::new(),
|
||
};
|
||
let tbl = Shape { id: ShapeId(790), xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)), kind: ShapeKind::Table(t), ..Default::default() };
|
||
let mut p = deck_with(vec![tbl]);
|
||
p.table_styles.push(def);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let px = |x, y| img.pixel(x, y);
|
||
// Row 1 (band1H): red with 20 % white over it; row 2 (band2H, undefined): plain red.
|
||
let banded = px(300, 125);
|
||
assert!(banded[0] > 250 && (40..65).contains(&banded[1]), "{banded:?}");
|
||
assert_eq!(px(300, 175)[..3], [255, 0, 0]);
|
||
// No line between the rows; a blue left border.
|
||
let edge = px(300, 150);
|
||
assert!(edge[0] > 240, "no inside line: {edge:?}");
|
||
let left = px(100, 175);
|
||
assert!(left[2] > 200 && left[0] < 60, "{left:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_table_fill_shows_behind_cells_without_their_own() {
|
||
// `a:tblPr` solidFill (tdf#127237): cells with no fill show the table's blue.
|
||
use deckcraft_model::style::Fill;
|
||
let mut t = Table::new(2, 2, 200.0, 50.0);
|
||
t.style = "none".into();
|
||
t.background = Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 112, 192))));
|
||
for r in 0..2 {
|
||
for c in 0..2 {
|
||
t.cell_mut(r, c).unwrap().fill = Some(Fill::None);
|
||
}
|
||
}
|
||
let tbl = Shape { id: ShapeId(795), xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)), kind: ShapeKind::Table(t), ..Default::default() };
|
||
let p = deck_with(vec![tbl]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert_eq!(img.pixel(150, 160)[..3], [0, 112, 192]);
|
||
assert_eq!(img.pixel(50, 50)[..3], [255, 255, 255]);
|
||
}
|
||
|
||
/// A white 280x200 pt rectangle at (20, 20) with `effects`, rendered at 1 px/pt.
|
||
fn effect_box(effects: deckcraft_model::Effects) -> Image {
|
||
use deckcraft_model::style::{Fill, Line};
|
||
let sh = Shape {
|
||
id: ShapeId(800),
|
||
xfrm: Some(Xfrm::new(20.0, 20.0, 280.0, 200.0)),
|
||
fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 255, 255)))),
|
||
line: Some(Line { fill: Some(Fill::None), ..Default::default() }),
|
||
effects: Some(effects),
|
||
..Default::default()
|
||
};
|
||
render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
}
|
||
|
||
fn shadow(blur: f64, dist: f64, dir: f64) -> deckcraft_model::style::Shadow {
|
||
deckcraft_model::style::Shadow {
|
||
color: ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0)),
|
||
blur,
|
||
dist,
|
||
dir,
|
||
inner: false,
|
||
sx: 1.0,
|
||
sy: 1.0,
|
||
kx: 0.0,
|
||
ky: 0.0,
|
||
align: String::new(),
|
||
rotate_with_shape: false,
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn shadows_and_glows_spread_like_powerpoints() {
|
||
let red = |img: &Image, x: u32, y: u32| img.pixel(x, y)[0] as i32;
|
||
// Outer shadow, 9 pt blur, no offset: PowerPoint's export reads 144, 204, 238 at 1, 3 and 5
|
||
// px outside the left edge.
|
||
let img = effect_box(deckcraft_model::Effects { outer_shadow: Some(shadow(9.0, 0.0, 0.0)), ..Default::default() });
|
||
for (d, want) in [(1, 144), (3, 204), (5, 238)] {
|
||
assert!((red(&img, 20 - d, 120) - want).abs() <= 6, "outer {d}: {}", red(&img, 20 - d, 120));
|
||
}
|
||
// Inner shadow pointing down-right (45 degrees): it falls inside along the bottom and right
|
||
// edges, not the top and left.
|
||
let mut sh = shadow(0.0, 10.0, 45.0);
|
||
sh.inner = true;
|
||
let img = effect_box(deckcraft_model::Effects { inner_shadow: Some(sh), ..Default::default() });
|
||
assert!(red(&img, 296, 120) < 20, "right edge {}", red(&img, 296, 120));
|
||
assert!(red(&img, 160, 216) < 20, "bottom edge {}", red(&img, 160, 216));
|
||
assert!(red(&img, 24, 120) > 250 && red(&img, 160, 24) > 250, "top and left stay clear");
|
||
// Inner shadow with a 9 pt blur and no offset: the same profile as the outer one, inside.
|
||
let mut sh = shadow(9.0, 0.0, 0.0);
|
||
sh.inner = true;
|
||
let img = effect_box(deckcraft_model::Effects { inner_shadow: Some(sh), ..Default::default() });
|
||
for (d, want) in [(0, 144), (2, 204), (4, 238)] {
|
||
assert!((red(&img, 20 + d, 120) - want).abs() <= 6, "inner {d}: {}", red(&img, 20 + d, 120));
|
||
}
|
||
// Glow of radius 10 pt: nearly solid 1 px out, about half strength 5 px out, gone by 10.
|
||
let glow = deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0)), radius: 10.0 };
|
||
let img = effect_box(deckcraft_model::Effects { glow: Some(glow), ..Default::default() });
|
||
assert!(red(&img, 19, 120) < 20);
|
||
assert!((60..170).contains(&red(&img, 15, 120)), "{}", red(&img, 15, 120));
|
||
assert!(red(&img, 10, 120) > 245);
|
||
}
|
||
|
||
/// A 400 × 200 text box at (100, 100) holding `text` at 40 pt, warped by `warp`.
|
||
fn wordart(warp: Option<&str>, text: &str) -> Presentation {
|
||
let mut t = TextBody::from_text(text);
|
||
t.paragraphs[0].runs[0].props.size = Some(40.0);
|
||
t.paragraphs[0].props.align = Some(deckcraft_model::text::Align::Center);
|
||
t.body.warp = warp.map(String::from);
|
||
deck_with(vec![Shape { id: ShapeId(700), xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)), text: Some(t), ..Default::default() }])
|
||
}
|
||
|
||
/// Ink box (x0, y0, x1, y1) of dark pixels, and the top ink row of each column.
|
||
fn ink(img: &Image) -> ((u32, u32, u32, u32), Vec<Option<u32>>) {
|
||
let mut b = (u32::MAX, u32::MAX, 0, 0);
|
||
let mut tops = vec![None; img.width as usize];
|
||
for y in 0..img.height {
|
||
for x in 0..img.width {
|
||
if img.pixel(x, y)[0] < 128 {
|
||
b = (b.0.min(x), b.1.min(y), b.2.max(x), b.3.max(y));
|
||
if tops[x as usize].is_none() {
|
||
tops[x as usize] = Some(y);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
(b, tops)
|
||
}
|
||
|
||
#[test]
|
||
fn wordart_arch_up_lifts_the_middle_of_the_line() {
|
||
let o = RenderOpts { scale: 1.0, ..Default::default() };
|
||
let flat = render_slide(&wordart(None, "ARCHED WORDART"), 0, &o);
|
||
let arched = render_slide(&wordart(Some("textArchUp"), "ARCHED WORDART"), 0, &o);
|
||
assert!(diff_px(&flat, &arched) > 1000);
|
||
let ((fx0, _, fx1, _), ftops) = ink(&flat);
|
||
let ((ax0, ay0, ax1, _), atops) = ink(&arched);
|
||
let top_near = |tops: &[Option<u32>], x: u32| (x.saturating_sub(15)..x + 15).filter_map(|i| tops.get(i as usize).copied().flatten()).min();
|
||
// Flat text: the ends and the middle stand on one line.
|
||
let (fl, fm) = (top_near(&ftops, fx0 + 20).unwrap(), top_near(&ftops, (fx0 + fx1) / 2).unwrap());
|
||
assert!(fl.abs_diff(fm) < 4, "flat {fl} {fm}");
|
||
// Arched: the line follows the top of the ellipse inscribed in the box, so the middle is
|
||
// at the box top and the ends sit clearly lower.
|
||
let (al, am, ar) = (top_near(&atops, ax0 + 20).unwrap(), top_near(&atops, (ax0 + ax1) / 2).unwrap(), top_near(&atops, ax1 - 20).unwrap());
|
||
assert!(al > am + 10 && ar > am + 10, "arched {al} {am} {ar}");
|
||
// At the box top (y = 100), give or take the font: Linux's fallback face reaches 79.
|
||
assert!((70..=110).contains(&ay0), "arch top {ay0}");
|
||
}
|
||
|
||
#[test]
|
||
fn wordart_plain_stretches_the_ink_over_the_text_rect() {
|
||
let img = render_slide(&wordart(Some("textPlain"), "PLAIN"), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let ((x0, y0, x1, y1), _) = ink(&img);
|
||
for (got, want) in [(x0, 100), (y0, 100), (x1, 499), (y1, 299)] {
|
||
assert!(got.abs_diff(want) <= 2, "ink box {:?}", (x0, y0, x1, y1));
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn unknown_or_absent_warps_draw_flat_text() {
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
// Warm the font database first (other tests load fonts concurrently).
|
||
let _ = render_slide(&wordart(None, "FLAT"), 0, &o);
|
||
let flat = render_slide(&wordart(None, "FLAT"), 0, &o);
|
||
for w in ["textNoShape", "bogus", ""] {
|
||
assert_eq!(diff_px(&flat, &render_slide(&wordart(Some(w), "FLAT"), 0, &o)), 0, "{w}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn every_warp_preset_renders_text_inside_the_slide() {
|
||
let o = RenderOpts { scale: 0.5, ..Default::default() };
|
||
for name in
|
||
["textArchUp", "textArchDown", "textCircle", "textButton", "textWave1", "textRingInside", "textCirclePour", "textDeflateInflateDeflate"]
|
||
{
|
||
let mut p = wordart(Some(name), "One line\nTwo line\nThree");
|
||
if let Some(b) = std::sync::Arc::make_mut(&mut p.slides[0]).shapes[0].text.as_mut() {
|
||
b.body.warp_adj = vec![f64::NAN, -1e12];
|
||
}
|
||
let img = render_slide(&p, 0, &o);
|
||
let ((x0, y0, x1, y1), _) = ink(&img);
|
||
assert!(x0 <= x1 && y0 <= y1, "{name}: no ink");
|
||
}
|
||
}
|
||
|
||
/// A placeable WMF, 2 × 1 inch (2880 × 1440 twips): a solid red brush and a rectangle over the
|
||
/// left half, nothing on the right.
|
||
fn half_red_wmf() -> Vec<u8> {
|
||
fn rec(func: u16, params: &[i16]) -> Vec<u8> {
|
||
let mut v = ((3 + params.len()) as u32).to_le_bytes().to_vec();
|
||
v.extend(func.to_le_bytes());
|
||
for p in params {
|
||
v.extend(p.to_le_bytes());
|
||
}
|
||
v
|
||
}
|
||
// CREATEBRUSHINDIRECT (solid, COLORREF 0x000000FF = red), SELECTOBJECT 0, RECTANGLE (bottom,
|
||
// right, top, left).
|
||
let body = [rec(0x02FC, &[0, 0xFF, 0, 0]), rec(0x012D, &[0]), rec(0x041B, &[1440, 1440, 0, 0]), rec(0, &[])].concat();
|
||
let mut f = 0x9AC6_CDD7u32.to_le_bytes().to_vec();
|
||
f.extend(0u16.to_le_bytes());
|
||
for v in [0i16, 0, 2880, 1440] {
|
||
f.extend(v.to_le_bytes());
|
||
}
|
||
f.extend(1440u16.to_le_bytes());
|
||
f.extend(0u32.to_le_bytes());
|
||
f.extend(0u16.to_le_bytes());
|
||
let total = (f.len() + 18 + body.len()) / 2;
|
||
for v in [1u16, 9, 0x300] {
|
||
f.extend(v.to_le_bytes());
|
||
}
|
||
f.extend((total as u32).to_le_bytes());
|
||
f.extend(16u16.to_le_bytes());
|
||
f.extend(0u32.to_le_bytes());
|
||
f.extend(0u16.to_le_bytes());
|
||
f.extend(body);
|
||
f
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_pictures_draw_their_vectors() {
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("image1.wmf", "image/x-wmf", half_red_wmf()).expect("media");
|
||
let fill = deckcraft_model::style::PictureFill { media, ..Default::default() };
|
||
let sh = Shape { id: ShapeId(600), xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)), kind: ShapeKind::Picture { fill }, ..Default::default() };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
for scale in [0.5, 1.0, 3.0] {
|
||
let img = render_slide(&p, 0, &RenderOpts { scale, ..Default::default() });
|
||
let at = |x: f64, y: f64| img.pixel((x * scale) as u32, (y * scale) as u32);
|
||
let left = at(200.0, 200.0);
|
||
assert!(left[0] > 200 && left[1] < 60 && left[2] < 60, "left half red at {scale}: {left:?}");
|
||
let right = at(400.0, 200.0);
|
||
assert!(right[0] > 200 && right[1] > 200 && right[2] > 200, "right half empty at {scale}: {right:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn broken_metafiles_draw_nothing_and_never_panic() {
|
||
let wmf = half_red_wmf();
|
||
let mut cases: Vec<Vec<u8>> = (0..wmf.len()).step_by(3).map(|n| wmf[..n].to_vec()).collect();
|
||
cases.push(vec![1, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF]);
|
||
let mut huge = wmf.clone();
|
||
huge[10] = 0xFF;
|
||
huge[11] = 0x7F;
|
||
cases.push(huge);
|
||
for bytes in cases {
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("image1.emf", "image/x-emf", bytes).expect("media");
|
||
let fill = deckcraft_model::style::PictureFill { media, ..Default::default() };
|
||
let sh = Shape { id: ShapeId(600), xfrm: Some(Xfrm::new(0.0, 0.0, 400.0, 200.0)), kind: ShapeKind::Picture { fill }, ..Default::default() };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let _ = render_slide(&p, 0, &RenderOpts { scale: 0.25, ..Default::default() });
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn an_object_deckcraft_doesnt_model_shows_its_preview_picture() {
|
||
// An embedded OLE object (or an unknown graphic) draws its preview stretched over its frame,
|
||
// as PowerPoint does; with no preview it draws nothing.
|
||
let png = {
|
||
let mut out = std::io::Cursor::new(vec![]);
|
||
image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(4, 2, image::Rgb([200, 20, 20])))
|
||
.write_to(&mut out, image::ImageFormat::Png)
|
||
.unwrap();
|
||
out.into_inner()
|
||
};
|
||
for with_preview in [true, false] {
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("image1.png", "image/png", png.clone()).expect("media");
|
||
let sh = Shape {
|
||
id: ShapeId(600),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)),
|
||
kind: ShapeKind::Opaque { xml: String::new(), preview: with_preview.then_some(media), label: "Package".into(), parts: vec![] },
|
||
..Default::default()
|
||
};
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
for (x, y) in [(110, 110), (300, 200), (490, 290)] {
|
||
let px = img.pixel(x, y);
|
||
let red = px[0] > 180 && px[1] < 60 && px[2] < 60;
|
||
assert_eq!(red, with_preview, "({x}, {y}) {px:?}");
|
||
}
|
||
assert!(img.pixel(520, 200)[1] > 200, "nothing outside the frame");
|
||
}
|
||
}
|
||
|
||
/// #270: a filled shape half off the slide's left edge, and one wholly below it.
|
||
fn off_slide_deck() -> Presentation {
|
||
let half = Shape {
|
||
id: ShapeId(2700),
|
||
xfrm: Some(Xfrm::new(-100.0, 100.0, 200.0, 100.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
let below = Shape {
|
||
id: ShapeId(2701),
|
||
xfrm: Some(Xfrm::new(400.0, 600.0, 100.0, 60.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent2)),
|
||
..Default::default()
|
||
};
|
||
deck_with(vec![half, below])
|
||
}
|
||
|
||
fn near(px: [u8; 4], c: deckcraft_color::Rgba) -> bool {
|
||
(px[0] as i32 - c.r as i32).abs() <= 3 && (px[1] as i32 - c.g as i32).abs() <= 3 && (px[2] as i32 - c.b as i32).abs() <= 3 && px[3] == 255
|
||
}
|
||
|
||
#[test]
|
||
fn shows_exports_and_thumbnails_clip_to_the_slide() {
|
||
let p = off_slide_deck();
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert_eq!((img.width, img.height), (960, 540));
|
||
let a1 = p.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent1);
|
||
// The on-slide half is there, nothing else is drawn outside the slide.
|
||
assert!(near(img.pixel(50, 150), a1), "{:?}", img.pixel(50, 150));
|
||
assert_eq!(img.pixel(150, 150), [255, 255, 255, 255]);
|
||
}
|
||
|
||
#[test]
|
||
fn the_editor_pasteboard_draws_shapes_off_the_slide() {
|
||
let p = off_slide_deck();
|
||
let extent = slide_extent(&p, 0);
|
||
let region = pasteboard_region((960, 540), 1.0, extent, Region { x: -300, y: -200, w: 1560, h: 1000 });
|
||
assert!(region.x <= -100 && region.y == 0 && region.y as i64 + region.h as i64 >= 660, "{region:?}");
|
||
let opts = RenderOpts { scale: 1.0, edit: true, offset: region.offset(), size: Some(region.size()), ..Default::default() };
|
||
let (img, drawn) = render_slide_drawn(&p, 0, &opts);
|
||
assert_eq!((img.width, img.height), region.size());
|
||
let at = |x: i32, y: i32| img.pixel((x - region.x) as u32, (y - region.y) as u32);
|
||
let a1 = p.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent1);
|
||
let a2 = p.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent2);
|
||
// Both halves of the straddling shape, at full strength, and the shape below the slide.
|
||
assert!(near(at(-50, 150), a1), "{:?}", at(-50, 150));
|
||
assert!(near(at(50, 150), a1), "{:?}", at(50, 150));
|
||
assert!(near(at(450, 630), a2), "{:?}", at(450, 630));
|
||
// The pasteboard itself stays clear (the UI's own colour shows through); the slide is white.
|
||
assert_eq!(at(-50, 50), [0, 0, 0, 0]);
|
||
assert_eq!(at(200, 300), [255, 255, 255, 255]);
|
||
// The drawing's reach, in slide space.
|
||
assert!(drawn.x0 <= -100.0 && drawn.y1 >= 660.0 && drawn.x1 >= 960.0, "{drawn:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn master_graphics_off_the_slide_show_on_the_pasteboard() {
|
||
let mut p = Presentation::default();
|
||
let m = std::sync::Arc::make_mut(&mut p.masters[0]);
|
||
m.shapes.push(Shape {
|
||
id: ShapeId(2702),
|
||
xfrm: Some(Xfrm::new(-150.0, 300.0, 100.0, 60.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent3)),
|
||
..Default::default()
|
||
});
|
||
let region = pasteboard_region((960, 540), 1.0, slide_extent(&p, 0), Region { x: -300, y: -100, w: 1500, h: 800 });
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, edit: true, offset: region.offset(), size: Some(region.size()), ..Default::default() });
|
||
let a3 = p.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent3);
|
||
assert!(near(img.pixel((-100 - region.x) as u32, (330 - region.y) as u32), a3));
|
||
}
|
||
|
||
#[test]
|
||
fn text_spilling_out_of_its_box_below_the_slide_is_reported() {
|
||
let mut sh = Shape { id: ShapeId(2703), xfrm: Some(Xfrm::new(100.0, 500.0, 400.0, 20.0)), ..Default::default() };
|
||
let mut t = TextBody::from_text("one\ntwo\nthree\nfour\nfive");
|
||
for para in &mut t.paragraphs {
|
||
for r in &mut para.runs {
|
||
r.props.size = Some(40.0);
|
||
}
|
||
}
|
||
sh.text = Some(t);
|
||
let p = deck_with(vec![sh]);
|
||
// The box estimate doesn't see the text below the slide; the render does.
|
||
assert!(slide_extent(&p, 0).y1 <= 540.0 + 4.0);
|
||
let (_, drawn) = render_slide_drawn(&p, 0, &RenderOpts { scale: 0.5, ..Default::default() });
|
||
assert!(drawn.y1 > 600.0, "{drawn:?}");
|
||
// A slide with nothing off it reaches just the slide.
|
||
let (_, drawn) = render_slide_drawn(&Presentation::default(), 0, &RenderOpts { scale: 0.5, edit: true, ..Default::default() });
|
||
assert_eq!(drawn, Rect::new(0.0, 0.0, 960.0, 540.0));
|
||
}
|
||
|
||
/// A placeable WMF (1440 units per inch, bounds `w` × `h`) holding `records` (function, parameter
|
||
/// bytes).
|
||
fn wmf_with(w: i16, h: i16, records: &[(u16, Vec<u8>)]) -> Vec<u8> {
|
||
let mut body = Vec::new();
|
||
for (func, params) in records {
|
||
let mut p = params.clone();
|
||
if p.len() % 2 == 1 {
|
||
p.push(0);
|
||
}
|
||
body.extend(((6 + p.len()) as u32 / 2).to_le_bytes());
|
||
body.extend(func.to_le_bytes());
|
||
body.extend(p);
|
||
}
|
||
body.extend([3, 0, 0, 0, 0, 0]);
|
||
let mut f = 0x9AC6_CDD7u32.to_le_bytes().to_vec();
|
||
f.extend(0u16.to_le_bytes());
|
||
for v in [0i16, 0, w, h] {
|
||
f.extend(v.to_le_bytes());
|
||
}
|
||
f.extend(1440u16.to_le_bytes());
|
||
f.extend(0u32.to_le_bytes());
|
||
f.extend(0u16.to_le_bytes());
|
||
let total = (f.len() + 18 + body.len()) / 2;
|
||
for v in [1u16, 9, 0x300] {
|
||
f.extend(v.to_le_bytes());
|
||
}
|
||
f.extend((total as u32).to_le_bytes());
|
||
f.extend(16u16.to_le_bytes());
|
||
f.extend(0u32.to_le_bytes());
|
||
f.extend(0u16.to_le_bytes());
|
||
f.extend(body);
|
||
f
|
||
}
|
||
|
||
fn i16s(v: &[i32]) -> Vec<u8> {
|
||
v.iter().flat_map(|x| (*x as i16).to_le_bytes()).collect()
|
||
}
|
||
|
||
/// CREATEFONTINDIRECT (height, escapement, face) then SELECTOBJECT of it (handle 0), transparent
|
||
/// background, and the alignment `ta`.
|
||
fn font_records(height: i32, esc: i32, face: &str, ta: i32) -> Vec<(u16, Vec<u8>)> {
|
||
let mut f = i16s(&[height, 0, esc, esc, 400]);
|
||
f.extend([0, 0, 0, if face.contains("dings") { 2 } else { 0 }, 0, 0, 0, 0]);
|
||
f.extend(face.as_bytes());
|
||
f.push(0);
|
||
vec![(0x02FB, f), (0x012D, i16s(&[0])), (0x0102, i16s(&[1])), (0x012E, i16s(&[ta]))]
|
||
}
|
||
|
||
/// EXTTEXTOUT at (x, y) with an optional dx array.
|
||
fn text_record(x: i32, y: i32, s: &str, dx: &[i32]) -> (u16, Vec<u8>) {
|
||
let mut v = i16s(&[y, x, s.len() as i32, 0]);
|
||
v.extend(s.as_bytes());
|
||
if s.len() % 2 == 1 {
|
||
v.push(0);
|
||
}
|
||
v.extend(i16s(dx));
|
||
(0x0A32, v)
|
||
}
|
||
|
||
/// Bounding box (x0, y0, x1, y1) of the pixels at least half opaque and darker than mid-grey.
|
||
fn mf_ink(img: &image::RgbaImage) -> Option<(u32, u32, u32, u32)> {
|
||
let mut b: Option<(u32, u32, u32, u32)> = None;
|
||
for (x, y, p) in img.enumerate_pixels() {
|
||
if p[3] > 128 && (p[0] as u32 + p[1] as u32 + p[2] as u32) < 384 {
|
||
b = Some(match b {
|
||
None => (x, y, x, y),
|
||
Some((a, c, d, e)) => (a.min(x), c.min(y), d.max(x), e.max(y)),
|
||
});
|
||
}
|
||
}
|
||
b
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_text_ink_lands_at_its_reference_point() {
|
||
// 2 × 1 inch (144 × 72 pt) drawn 288 px wide: 2 px per point. A 36-point "HH", top-left
|
||
// aligned at (72, 18) pt.
|
||
let mut recs = font_records(-720, 0, "Arial", 0);
|
||
recs.push(text_record(1440, 360, "HH", &[]));
|
||
let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
|
||
let (x0, y0, x1, y1) = mf_ink(&img).expect("text ink");
|
||
assert!((144..156).contains(&x0), "left edge at the reference point: {x0}");
|
||
assert!(x1 > x0 + 40 && x1 < 288, "two capitals wide: {x1}");
|
||
// The cell's top is at 36 px; a capital starts below the cell top and sits on the baseline.
|
||
assert!((38..72).contains(&y0), "cap top below the cell top: {y0}");
|
||
assert!((88..112).contains(&y1), "baseline one ascent below the top: {y1}");
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_text_centre_baseline_and_escapement() {
|
||
// TA_CENTER | TA_BASELINE at (72, 36) pt: the ink is centred on 144 px and sits on 72 px.
|
||
let mut recs = font_records(-720, 0, "Arial", 24 | 6);
|
||
recs.push(text_record(1440, 720, "HH", &[]));
|
||
let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
|
||
let (x0, _, x1, y1) = mf_ink(&img).expect("ink");
|
||
assert!(((x0 + x1) as i32 / 2 - 144).abs() <= 4, "centred: {x0}..{x1}");
|
||
assert!((69..=74).contains(&y1), "on the baseline: {y1}");
|
||
// Escapement 90°: the string runs up the picture.
|
||
let mut recs = font_records(-360, 900, "Arial", 24);
|
||
recs.push(text_record(1440, 1300, "HHHH", &[]));
|
||
let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
|
||
let (x0, y0, x1, y1) = mf_ink(&img).expect("ink");
|
||
assert!(y1 - y0 > 2 * (x1 - x0), "a vertical run: {x0} {y0} {x1} {y1}");
|
||
assert!(x1 <= 146 && y1 <= 132, "drawn up and left of the baseline origin (144, 130): {x1} {y1}");
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_text_follows_its_dx_array() {
|
||
// "HH" with the second H a full inch (144 px) after the first: two clumps of ink, a gap between.
|
||
let mut recs = font_records(-360, 0, "Arial", 24);
|
||
recs.push(text_record(360, 720, "HH", &[1440, 100]));
|
||
let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
|
||
let col_has_ink = |x: u32| (0..img.height()).any(|y| img.get_pixel(x, y)[3] > 128);
|
||
assert!((36..56).any(col_has_ink), "first H at 36 px");
|
||
assert!((180..200).any(col_has_ink), "second H one inch later");
|
||
assert!(!(70..170).any(col_has_ink), "nothing between them");
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_symbol_text_draws_a_bullet_not_a_box() {
|
||
// Webdings "n" is a filled circle (installed, or mapped to a black circle where it is not), as
|
||
// is Wingdings "l" in a symbol font that is not installed anywhere.
|
||
for (face, s) in [("Webdings", "n"), ("Wingdings Not Installed", "l")] {
|
||
let mut recs = font_records(-1080, 0, face, 0);
|
||
recs.push(text_record(360, 0, s, &[]));
|
||
let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
|
||
let (x0, y0, x1, y1) = mf_ink(&img).expect("ink");
|
||
assert!(x1 - x0 > 10 && y1 - y0 > 10, "{face}: a sizeable mark: {x0} {y0} {x1} {y1}");
|
||
let (cx, cy) = ((x0 + x1) / 2, (y0 + y1) / 2);
|
||
assert!(img.get_pixel(cx, cy)[3] > 200, "{face}: filled in the middle");
|
||
for (x, y) in [(x0, y0), (x1, y0), (x0, y1), (x1, y1)] {
|
||
assert!(img.get_pixel(x, y)[3] < 128, "{face}: round, not a box: corner ({x}, {y})");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_opaque_text_fills_its_cell() {
|
||
// OPAQUE background in red behind a space.
|
||
let mut recs = font_records(-720, 0, "Arial", 0);
|
||
recs.push((0x0102, i16s(&[2])));
|
||
recs.push((0x0201, 0x0000_00FFu32.to_le_bytes().to_vec()));
|
||
recs.push(text_record(1440, 360, " ", &[]));
|
||
let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
|
||
let p = img.get_pixel(148, 60);
|
||
assert!(p[0] > 200 && p[1] < 60 && p[3] > 200, "cell filled red: {p:?}");
|
||
assert!(img.get_pixel(140, 60)[3] < 50, "nothing left of the cell");
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_pattern_brush_tiles_and_averages_when_tiny() {
|
||
// A 1-bit 8 × 8 checker (palette white, black), a null pen and a one-inch square.
|
||
let mut dib: Vec<u8> = [40u32, 8, 8].iter().flat_map(|v| v.to_le_bytes()).collect();
|
||
dib.extend(1u16.to_le_bytes());
|
||
dib.extend(1u16.to_le_bytes());
|
||
dib.extend([0u8; 24]);
|
||
dib.extend([255, 255, 255, 0, 0, 0, 0, 0]);
|
||
for r in 0..8 {
|
||
dib.extend([if r % 2 == 0 { 0x55 } else { 0xAA }, 0, 0, 0]);
|
||
}
|
||
let mut brush = i16s(&[5, 0]);
|
||
brush.extend(dib);
|
||
let recs = vec![(0x0142, brush), (0x012D, i16s(&[0])), (0x012D, i16s(&[0x8008])), (0x041B, i16s(&[1440, 1440, 0, 0]))];
|
||
let bytes = wmf_with(1440, 1440, &recs);
|
||
// 4 px per point: a 0.75 pt cell is 3 px.
|
||
let img = crate::metafile::rasterize(&bytes, 288).expect("raster");
|
||
let (a, b) = (img.get_pixel(1, 1), img.get_pixel(4, 1));
|
||
assert!(a[3] > 200 && b[3] > 200);
|
||
assert!((a[0] as i32 - b[0] as i32).abs() > 200, "neighbouring cells alternate: {a:?} {b:?}");
|
||
// Far below one pixel per cell: the average grey.
|
||
let img = crate::metafile::rasterize(&bytes, 32).expect("raster");
|
||
let p = img.get_pixel(16, 16);
|
||
assert!((100..156).contains(&p[0]) && p[3] > 200, "average grey: {p:?}");
|
||
}
|
||
|
||
/// A 400 x 200 group at (100, 100) holding a dashed 4 pt rectangle and a 3 pt line with an
|
||
/// arrowhead, placed in the group's child coordinates by `to_child` (slide point to child point).
|
||
fn outlined_group(child: Xfrm, to_child: impl Fn(f64, f64) -> (f64, f64)) -> Image {
|
||
use deckcraft_model::style::{Dash, LineEnd};
|
||
let ink = |w: f64| deckcraft_model::style::Line { dash: None, ..deckcraft_model::style::Line::solid(ColorRef::rgb(Rgba::rgb(200, 0, 0)), w) };
|
||
let place = |x0: f64, y0: f64, x1: f64, y1: f64| {
|
||
let ((a, b), (c, d)) = (to_child(x0, y0), to_child(x1, y1));
|
||
Xfrm::new(a, b, c - a, d - b)
|
||
};
|
||
let rect = Shape {
|
||
id: ShapeId(11),
|
||
xfrm: Some(place(140.0, 120.0, 300.0, 200.0)),
|
||
geom: Geom::preset("rect"),
|
||
line: Some(deckcraft_model::style::Line { dash: Some(Dash::Preset { name: "dash".into() }), ..ink(4.0) }),
|
||
..Default::default()
|
||
};
|
||
let end = LineEnd { kind: "triangle".into(), w: "lg".into(), len: "lg".into() };
|
||
let line = Shape {
|
||
id: ShapeId(12),
|
||
xfrm: Some(Xfrm { flip_v: true, ..place(150.0, 170.0, 450.0, 260.0) }),
|
||
geom: Geom::preset("line"),
|
||
line: Some(deckcraft_model::style::Line { tail: Some(end), ..ink(3.0) }),
|
||
..Default::default()
|
||
};
|
||
let pts: Vec<(f64, f64, f32)> = [(160.0, 240.0), (260.0, 285.0)].iter().map(|(x, y)| to_child(*x, *y)).map(|(x, y)| (x, y, 1.0)).collect();
|
||
let ink = Shape {
|
||
id: ShapeId(13),
|
||
xfrm: Some(place(100.0, 100.0, 500.0, 300.0)),
|
||
kind: ShapeKind::Ink {
|
||
strokes: vec![deckcraft_model::InkStroke { points: pts, color: Rgba::rgb(200, 0, 0), width: 5.0, highlighter: false }],
|
||
},
|
||
..Default::default()
|
||
};
|
||
let group = Shape {
|
||
id: ShapeId(10),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)),
|
||
kind: ShapeKind::Group { children: vec![rect, line, ink], child },
|
||
..Default::default()
|
||
};
|
||
render_slide(&deck_with(vec![group]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
}
|
||
|
||
fn inked(img: &Image) -> usize {
|
||
img.pixels.as_chunks::<4>().0.iter().filter(|px| px[1] < 200).count()
|
||
}
|
||
|
||
#[test]
|
||
fn group_child_scale_does_not_scale_line_widths() {
|
||
// Children laid out 1:1 with the slide are the reference.
|
||
let reference = outlined_group(Xfrm::new(100.0, 100.0, 400.0, 200.0), |x, y| (x, y));
|
||
let drawn = inked(&reference);
|
||
assert!((500..20_000).contains(&drawn), "the reference draws thin lines: {drawn}");
|
||
// The same drawing in a small legacy child space (scale 100), and one scaled unevenly
|
||
// (100 across, 50 down): same outlines, same line widths, dashes and arrowhead.
|
||
let uniform = outlined_group(Xfrm::new(1.0, 1.0, 4.0, 2.0), |x, y| (1.0 + (x - 100.0) / 100.0, 1.0 + (y - 100.0) / 100.0));
|
||
let uneven = outlined_group(Xfrm::new(1.0, 1.0, 4.0, 4.0), |x, y| (1.0 + (x - 100.0) / 100.0, 1.0 + (y - 100.0) / 50.0));
|
||
for (name, img) in [("uniform", &uniform), ("uneven", &uneven)] {
|
||
let (n, d) = (inked(img), differing(&reference, img));
|
||
assert!(n.abs_diff(drawn) * 20 < drawn, "{name}: {n} inked pixels against {drawn}");
|
||
assert!(d * 20 < drawn, "{name}: {d} differing values against {drawn} inked pixels");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_picture_casts_its_shadow_from_its_pixels() {
|
||
// PowerPoint shades only where a picture paints: a logo on a transparent background casts the
|
||
// logo's shadow, not its frame's. Here the left half of the image is transparent.
|
||
let png = {
|
||
let img = image::RgbaImage::from_fn(8, 4, |x, _| if x < 4 { image::Rgba([0, 0, 0, 0]) } else { image::Rgba([20, 160, 20, 255]) });
|
||
let mut out = std::io::Cursor::new(vec![]);
|
||
image::DynamicImage::ImageRgba8(img).write_to(&mut out, image::ImageFormat::Png).unwrap();
|
||
out.into_inner()
|
||
};
|
||
let shadow = deckcraft_model::style::Shadow {
|
||
color: ColorRef::rgb(deckcraft_color::Rgba::BLACK),
|
||
blur: 0.0,
|
||
dist: 20.0,
|
||
dir: 90.0,
|
||
inner: false,
|
||
sx: 1.0,
|
||
sy: 1.0,
|
||
kx: 0.0,
|
||
ky: 0.0,
|
||
align: String::new(),
|
||
rotate_with_shape: false,
|
||
};
|
||
for as_fill in [false, true] {
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("logo.png", "image/png", png.clone()).expect("media");
|
||
let pf = deckcraft_model::style::PictureFill { media, ..Default::default() };
|
||
let mut sh = Shape { id: ShapeId(600), xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)), ..Default::default() };
|
||
if as_fill {
|
||
sh.fill = Some(Fill::Picture(pf));
|
||
sh.line = Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() });
|
||
} else {
|
||
sh.kind = ShapeKind::Picture { fill: pf };
|
||
}
|
||
sh.effects = Some(deckcraft_model::Effects { outer_shadow: Some(shadow.clone()), ..Default::default() });
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
// Below the picture, 10 pt down: shadow under the opaque right half only.
|
||
let left = img.pixel(200, 310);
|
||
let right = img.pixel(400, 310);
|
||
assert!(left[0] > 240, "no shadow under the transparent half ({as_fill}): {left:?}");
|
||
assert!(right[0] < 40, "shadow under the opaque half ({as_fill}): {right:?}");
|
||
// The transparent half shows the slide, not a shadow behind it.
|
||
assert!(img.pixel(200, 200)[0] > 240, "{as_fill}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn text_in_a_scaled_group_keeps_its_point_size() {
|
||
// A group's child coordinates scale its shapes' boxes, never their type: a 24 pt word in a
|
||
// group whose child space is 1/1600 of its size (as old decks write them) or 4 times it is
|
||
// 24 pt on the slide, and inside its box (it used to grow until the slide turned black).
|
||
let draw = |scale: f64| {
|
||
let mut p = Presentation::default();
|
||
let mut body = TextBody::from_text("Hello");
|
||
body.paragraphs[0].runs[0].props.size = Some(24.0);
|
||
body.paragraphs[0].runs[0].props.fill = Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::BLACK)));
|
||
let child = Shape { id: ShapeId(601), xfrm: Some(Xfrm::new(0.0, 0.0, 400.0 / scale, 200.0 / scale)), text: Some(body), ..Default::default() };
|
||
let g = Shape {
|
||
id: ShapeId(600),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)),
|
||
kind: ShapeKind::Group { children: vec![child], child: Xfrm::new(0.0, 0.0, 400.0 / scale, 200.0 / scale) },
|
||
..Default::default()
|
||
};
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![g];
|
||
render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
};
|
||
let ((_, y0, _, y1), _) = ink(&draw(1.0));
|
||
let plain = y1 - y0;
|
||
assert!(plain > 10 && plain < 30, "24 pt word ink height {plain}");
|
||
for scale in [1600.0, 4.0, 0.25] {
|
||
let ((x0, sy0, x1, sy1), _) = ink(&draw(scale));
|
||
assert!((sy1 - sy0).abs_diff(plain) <= 1, "scale {scale}: ink height {} vs {plain}", sy1 - sy0);
|
||
assert!(x0 >= 100 && x1 <= 500 && sy0 >= 100 && sy1 <= 300, "scale {scale}: ink inside the box");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_fill_overlay_blends_over_the_fill() {
|
||
// `a:fillOverlay blend="mult"`: a 50% grey multiplied over a light fill darkens it; "screen"
|
||
// lightens a dark one; the overlay stays inside the shape.
|
||
use deckcraft_model::style::FillOverlay;
|
||
let draw = |base: [u8; 3], blend: &str| {
|
||
let mut p = Presentation::default();
|
||
let mut sh = Shape {
|
||
id: ShapeId(600),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)),
|
||
fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(base[0], base[1], base[2])))),
|
||
line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
sh.effects = Some(deckcraft_model::Effects {
|
||
fill_overlay: Some(FillOverlay { blend: blend.into(), fill: Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(128, 128, 128))) }),
|
||
..Default::default()
|
||
});
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
(img.pixel(200, 150), img.pixel(50, 50))
|
||
};
|
||
let (mult, outside) = draw([200, 100, 50], "mult");
|
||
assert!((mult[0] as i32 - 100).abs() <= 3 && (mult[1] as i32 - 50).abs() <= 3 && (mult[2] as i32 - 25).abs() <= 3, "{mult:?}");
|
||
assert_eq!(&outside[..3], &[255, 255, 255], "nothing outside the shape");
|
||
let (screen, _) = draw([0, 0, 0], "screen");
|
||
assert!((screen[0] as i32 - 128).abs() <= 3, "{screen:?}");
|
||
let (over, _) = draw([200, 100, 50], "over");
|
||
assert!((over[0] as i32 - 128).abs() <= 3 && (over[1] as i32 - 128).abs() <= 3, "{over:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn dotted_and_wavy_underlines_draw_their_pattern() {
|
||
// Underlined spaces only, so the underline is the only ink: a red line under " ".
|
||
let row_runs = |u: &str| {
|
||
let mut sh = Shape { id: ShapeId(760), xfrm: Some(Xfrm::new(0.0, 0.0, 900.0, 300.0)), text_box: true, ..Default::default() };
|
||
let mut t = TextBody::from_text(" ");
|
||
let props = &mut t.paragraphs[0].runs[0].props;
|
||
props.size = Some(96.0);
|
||
props.underline = Some(u.into());
|
||
props.fill = Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))));
|
||
sh.text = Some(t);
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let red = |x: u32, y: u32| {
|
||
let px = img.pixel(x, y);
|
||
px[0] > 150 && px[1] < 120
|
||
};
|
||
// The ink's rows, and the number of separate red stretches along the most inked row.
|
||
let rows: Vec<u32> = (0..300).filter(|&y| (0..900).any(|x| red(x, y))).collect();
|
||
let best = rows.iter().copied().max_by_key(|&y| (0..900).filter(|&x| red(x, y)).count()).unwrap_or(0);
|
||
let stretches = (1..900).filter(|&x| red(x, best) && !red(x - 1, best)).count();
|
||
(rows.len(), stretches)
|
||
};
|
||
let (sng_rows, sng_runs) = row_runs("sng");
|
||
assert_eq!(sng_runs, 1, "a single line is one stretch");
|
||
let (_, dotted_runs) = row_runs("dotted");
|
||
assert!(dotted_runs > 10, "dots: {dotted_runs}");
|
||
let (wavy_rows, _) = row_runs("wavy");
|
||
assert!(wavy_rows > sng_rows, "a wave spans more rows ({wavy_rows}) than a single line ({sng_rows})");
|
||
}
|
||
|
||
#[test]
|
||
fn east_asian_vertical_text_stands_ideographs_upright() {
|
||
// "一" is a horizontal stroke. In eaVert text it stays horizontal (upright) while the line runs
|
||
// down the shape; in vert it lies on its side like Latin text.
|
||
let ink = |dir: deckcraft_model::text::TextDir| {
|
||
let mut sh = Shape { id: ShapeId(770), xfrm: Some(Xfrm::new(100.0, 50.0, 200.0, 400.0)), text_box: true, ..Default::default() };
|
||
let mut t = TextBody::from_text("一");
|
||
t.body.vert = Some(dir);
|
||
let props = &mut t.paragraphs[0].runs[0].props;
|
||
props.size = Some(80.0);
|
||
props.fill = Some(deckcraft_model::style::Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 0, 0))));
|
||
sh.text = Some(t);
|
||
let p = deck_with(vec![sh]);
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let (mut x0, mut y0, mut x1, mut y1) = (u32::MAX, u32::MAX, 0, 0);
|
||
for y in 0..540 {
|
||
for x in 0..960 {
|
||
if img.pixel(x, y)[0] < 128 {
|
||
(x0, y0, x1, y1) = (x0.min(x), y0.min(y), x1.max(x), y1.max(y));
|
||
}
|
||
}
|
||
}
|
||
assert!(x1 >= x0 && y1 >= y0, "no ink for {dir:?}");
|
||
(x1 - x0, y1 - y0)
|
||
};
|
||
let (w, h) = ink(deckcraft_model::text::TextDir::EaVertical);
|
||
assert!(w > h * 3, "eaVert: upright stroke {w}x{h}");
|
||
let (w, h) = ink(deckcraft_model::text::TextDir::Vertical);
|
||
assert!(h > w * 3, "vert: stroke on its side {w}x{h}");
|
||
}
|
||
|
||
#[test]
|
||
fn placed_shapes_give_the_click_boxes_of_a_slide_in_drawing_order() {
|
||
use deckcraft_model::text::{Action, Hyperlink};
|
||
let link =
|
||
Hyperlink { action: Action::NextSlide, tooltip: String::new(), highlight_click: false, sound: None, stop_sound: false, zoom_return: None };
|
||
let rect = |id: u32, x: f64, click: Option<Hyperlink>| Shape {
|
||
id: ShapeId(id),
|
||
xfrm: Some(Xfrm::new(x, 50.0, 100.0, 40.0)),
|
||
click,
|
||
..Default::default()
|
||
};
|
||
let group = Shape {
|
||
id: ShapeId(10),
|
||
xfrm: Some(Xfrm::new(300.0, 50.0, 200.0, 40.0)),
|
||
click: Some(link.clone()),
|
||
kind: ShapeKind::Group { children: vec![rect(11, 0.0, None), rect(12, 100.0, None)], child: Xfrm::new(0.0, 0.0, 200.0, 40.0) },
|
||
..Default::default()
|
||
};
|
||
let hidden = Shape { hidden: true, ..rect(13, 0.0, Some(link.clone())) };
|
||
let p = deck_with(vec![rect(1, 0.0, None), rect(2, 150.0, Some(link.clone())), hidden, group]);
|
||
let placed = place_slide(&p, 0);
|
||
// Back to front, a group before its children; the hidden shape is not there.
|
||
let ids: Vec<u32> = placed.shapes.iter().map(|s| s.id.0).collect();
|
||
assert_eq!(ids, vec![1, 2, 10, 11, 12]);
|
||
// Only the shapes with an action carry a link.
|
||
let linked: Vec<u32> = placed.shapes.iter().filter(|s| s.link.is_some()).map(|s| s.id.0).collect();
|
||
assert_eq!(linked, vec![2, 10]);
|
||
// The children know their group, whose box covers them.
|
||
let group = &placed.shapes[2];
|
||
assert!(group.is_group && group.parent.is_none());
|
||
for child in &placed.shapes[3..] {
|
||
assert_eq!(child.parent, Some(2));
|
||
assert!(child.rect.x0 >= group.rect.x0 - 0.01 && child.rect.x1 <= group.rect.x1 + 0.01);
|
||
}
|
||
// Shape actions come out as links owned by their shape, not as text links.
|
||
assert!(placed.links.iter().all(|l| !l.text));
|
||
assert_eq!(placed.links.iter().map(|l| l.shape.0).collect::<Vec<_>>(), vec![2, 10]);
|
||
}
|
||
|
||
#[test]
|
||
fn a_text_hyperlink_belongs_to_the_shape_that_holds_the_text() {
|
||
use deckcraft_model::text::{Action, Hyperlink};
|
||
let mut body = TextBody::from_text("click here");
|
||
for r in &mut body.paragraphs[0].runs {
|
||
r.props.link = Some(Hyperlink {
|
||
action: Action::FirstSlide,
|
||
tooltip: String::new(),
|
||
highlight_click: false,
|
||
sound: None,
|
||
stop_sound: false,
|
||
zoom_return: None,
|
||
});
|
||
}
|
||
let sh = Shape { id: ShapeId(7), xfrm: Some(Xfrm::new(100.0, 100.0, 300.0, 60.0)), text: Some(body), ..Default::default() };
|
||
let placed = place_slide(&deck_with(vec![sh]), 0);
|
||
assert!(placed.links.iter().any(|l| l.text && l.shape == ShapeId(7)));
|
||
assert!(placed.shapes.iter().all(|s| s.link.is_none()), "a text link is not the shape's own action");
|
||
}
|
||
|
||
#[test]
|
||
fn metafile_intersect_clip_rect_hides_the_rest_of_the_picture() {
|
||
let rec = |typ: u32, payload: &[u8]| {
|
||
let mut v = typ.to_le_bytes().to_vec();
|
||
v.extend(((8 + payload.len()) as u32).to_le_bytes());
|
||
v.extend(payload);
|
||
v
|
||
};
|
||
let rect = |l: i32, t: i32, r: i32, b: i32| [l, t, r, b].into_iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<_>>();
|
||
let mut body = rec(30, &rect(0, 0, 50, 50));
|
||
body.extend(rec(43, &rect(0, 0, 100, 50)));
|
||
let eof = rec(14, &[0; 12]);
|
||
let total = 88 + body.len() + eof.len();
|
||
let mut file = vec![0u8; 88];
|
||
file[0..4].copy_from_slice(&1u32.to_le_bytes());
|
||
file[4..8].copy_from_slice(&88u32.to_le_bytes());
|
||
file[8..24].copy_from_slice(&rect(0, 0, 100, 50));
|
||
file[40..44].copy_from_slice(&0x464D_4520u32.to_le_bytes());
|
||
file[44..48].copy_from_slice(&0x0001_0000u32.to_le_bytes());
|
||
file[48..52].copy_from_slice(&(total as u32).to_le_bytes());
|
||
file[52..56].copy_from_slice(&2u32.to_le_bytes());
|
||
file[56..58].copy_from_slice(&1u16.to_le_bytes());
|
||
file.extend(body);
|
||
file.extend(eof);
|
||
let img = crate::metafile::rasterize(&file, 100).expect("raster");
|
||
let opaque = |x: u32, y: u32| img.get_pixel(x, y)[3] > 200;
|
||
assert!(opaque(20, 25), "the clipped half is drawn");
|
||
assert!(!opaque(80, 25), "past the clip the picture stays clear, pixel {:?}", img.get_pixel(80, 25));
|
||
}
|
||
|
||
#[test]
|
||
fn tiny_chart_does_not_blank_the_slide() {
|
||
// A chart a few points wide used to panic in `f64::clamp` (gutter min above max), and the
|
||
// panic guard then blanked the whole slide. Render directly, without the guard.
|
||
let red = Shape {
|
||
id: ShapeId(800),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 200.0, 100.0)),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
..Default::default()
|
||
};
|
||
let mut shapes = vec![red];
|
||
for (i, k) in [ChartType::Column, ChartType::Bar, ChartType::Line, ChartType::Combo, ChartType::Scatter].iter().enumerate() {
|
||
shapes.push(Shape {
|
||
id: ShapeId(801 + i as u32),
|
||
xfrm: Some(Xfrm::new(500.0 + i as f64 * 5.0, 300.0, 0.9, 0.9)),
|
||
kind: ShapeKind::Chart(Box::new(Chart::sample(*k))),
|
||
..Default::default()
|
||
});
|
||
}
|
||
let p = deck_with(shapes);
|
||
let img = RENDERER.with(|r| r.borrow_mut().slide(&p, &p.slides[0], 0, &RenderOpts { scale: 1.0, ..Default::default() }));
|
||
let px = img.pixel(200, 150);
|
||
assert_ne!(px, [255, 255, 255, 255], "the other shape must still draw");
|
||
assert_eq!(crate::chart::clamp_soft(5.0, 10.5, 0.276), 0.276);
|
||
}
|
||
|
||
/// Shapes with depth under turned cameras (an `extrusionH` and, on two, an `extrusionClr`).
|
||
fn extruded_deck() -> Presentation {
|
||
let mk = |id: u32, x: f64, preset: &str, raw: &str| Shape {
|
||
id: ShapeId(id),
|
||
xfrm: Some(Xfrm::new(x, 170.0, 170.0, 130.0)),
|
||
geom: Geom::preset(preset),
|
||
style: Some(ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
|
||
effects: Some(deckcraft_model::Effects { raw3d: Some(raw.into()), ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
deck_with(vec![
|
||
mk(
|
||
700,
|
||
40.0,
|
||
"rect",
|
||
r#"<a:scene3d><a:camera prst="isometricOffAxis2Left"/><a:lightRig rig="threePt" dir="t"/></a:scene3d><a:sp3d extrusionH="381000"/>"#,
|
||
),
|
||
mk(
|
||
701,
|
||
280.0,
|
||
"ellipse",
|
||
r#"<a:scene3d><a:camera prst="isometricTopUp"/><a:lightRig rig="threePt" dir="t"/></a:scene3d><a:sp3d extrusionH="254000" contourW="63500"><a:extrusionClr><a:srgbClr val="C00000"/></a:extrusionClr><a:contourClr><a:srgbClr val="FFC000"/></a:contourClr></a:sp3d>"#,
|
||
),
|
||
mk(
|
||
702,
|
||
520.0,
|
||
"star5",
|
||
r#"<a:scene3d><a:camera prst="perspectiveContrastingLeftFacing"/><a:lightRig rig="threePt" dir="t"/></a:scene3d><a:sp3d extrusionH="508000"><a:extrusionClr><a:schemeClr val="accent2"/></a:extrusionClr></a:sp3d>"#,
|
||
),
|
||
mk(
|
||
703,
|
||
760.0,
|
||
"rect",
|
||
r#"<a:scene3d><a:camera prst="orthographicFront"/><a:lightRig rig="threePt" dir="t"/></a:scene3d><a:sp3d extrusionH="381000" contourW="76200" prstMaterial="metal"><a:contourClr><a:srgbClr val="00B050"/></a:contourClr></a:sp3d>"#,
|
||
),
|
||
])
|
||
}
|
||
|
||
#[test]
|
||
fn contours_band_the_outline_in_their_colour() {
|
||
let img = render_slide(&extruded_deck(), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let n = |x0: u32, x1: u32, f: &dyn Fn([u8; 4]) -> bool| {
|
||
let mut k = 0;
|
||
for y in 0..img.height {
|
||
for x in x0..x1.min(img.width) {
|
||
let i = ((y * img.width + x) * 4) as usize;
|
||
if img.pixels.get(i..i + 4).and_then(|p| <[u8; 4]>::try_from(p).ok()).is_some_and(f) {
|
||
k += 1;
|
||
}
|
||
}
|
||
}
|
||
k
|
||
};
|
||
// The ellipse's yellow contour and the flat rectangle's green one.
|
||
assert!(n(260, 480, &|p| p[0] > 200 && (150..230).contains(&p[1]) && p[2] < 80) > 200);
|
||
assert!(n(740, 960, &|p| p[0] < 80 && p[1] > 120 && p[2] < 120) > 300);
|
||
}
|
||
|
||
#[test]
|
||
fn extrusions_show_their_sides_under_a_turned_camera() {
|
||
let p = extruded_deck();
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
if let Ok(path) = std::env::var("DECKCRAFT_PNG_OUT") {
|
||
let _ = std::fs::write(path, img.to_png());
|
||
}
|
||
let count = |x0: u32, x1: u32, f: &dyn Fn([u8; 4]) -> bool| {
|
||
(x0..x1).flat_map(|x| (100..400).map(move |y| (x, y))).filter(|(x, y)| f(img.pixel(*x, *y))).count()
|
||
};
|
||
// The red sides of the ellipse; the dark accent-1 sides of the cube; none for a front camera.
|
||
assert!(count(250, 500, &|c| c[0] > 100 && c[1] < 40 && c[2] < 40) > 300, "red extrusion");
|
||
let flat = render_slide(&deck_with(vec![]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let ink = |img: &Image, x0: u32, x1: u32| {
|
||
(x0..x1).flat_map(|x| (100..400).map(move |y| (x, y))).filter(|(x, y)| img.pixel(*x, *y) != [255, 255, 255, 255]).count()
|
||
};
|
||
let mut no_depth = extruded_deck();
|
||
for sh in &mut std::sync::Arc::make_mut(&mut no_depth.slides[0]).shapes {
|
||
if let Some(fx) = sh.effects.as_mut() {
|
||
fx.raw3d = fx.raw3d.as_ref().map(|r| r.replace(" extrusionH=", " x="));
|
||
}
|
||
}
|
||
let thin = render_slide(&no_depth, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert!(ink(&img, 0, 260) > ink(&thin, 0, 260) + 1000, "the cube's sides add ink");
|
||
assert_eq!(ink(&img, 740, 960), ink(&thin, 740, 960), "a front camera shows no sides");
|
||
assert_eq!(ink(&flat, 0, 960), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn table_rows_below_the_slide_are_not_laid_out_and_the_slide_looks_the_same() {
|
||
// A fuzzed deck's 200 x 200 table of long text took 70 s to draw, most of it off the slide.
|
||
let table = |rows: usize| {
|
||
let mut t = Table::new(rows, 2, 400.0, 30.0);
|
||
for r in 0..rows {
|
||
for c in 0..2 {
|
||
t.cell_mut(r, c).unwrap().text = TextBody::from_text(&format!("Row {r} col {c}"));
|
||
}
|
||
}
|
||
Shape { id: ShapeId(611), xfrm: Some(Xfrm::new(50.0, 50.0, 400.0, 30.0 * rows as f64)), kind: ShapeKind::Table(t), ..Default::default() }
|
||
};
|
||
let opts = RenderOpts { scale: 0.5, ..Default::default() };
|
||
crate::table::TEXT_CELLS_DRAWN.with(|n| n.set(0));
|
||
let big = render_slide(&deck_with(vec![table(500)]), 0, &opts);
|
||
let drawn = crate::table::TEXT_CELLS_DRAWN.with(|n| n.get());
|
||
assert!(drawn > 2 * 10 && drawn < 2 * 40, "{drawn} cells drawn");
|
||
// 30 rows already run past the slide's bottom: the same picture.
|
||
let small = render_slide(&deck_with(vec![table(30)]), 0, &opts);
|
||
assert_eq!((big.width, big.height), (small.width, small.height));
|
||
let diff = (0..big.height).flat_map(|y| (0..big.width).map(move |x| (x, y))).filter(|&(x, y)| big.pixel(x, y) != small.pixel(x, y)).count();
|
||
assert_eq!(diff, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn office_2016_charts_draw_their_own_layouts() {
|
||
let chart = |kind: ChartType, vals: &[f64], subtotals: Vec<usize>| {
|
||
let c = Chart {
|
||
kind,
|
||
title: None,
|
||
legend: None,
|
||
gridlines: false,
|
||
subtotals,
|
||
categories: (0..vals.len()).map(|i| format!("C{i}")).collect(),
|
||
series: vec![deckcraft_model::chart::Series { values: vals.iter().map(|v| Some(*v)).collect(), ..Default::default() }],
|
||
..Default::default()
|
||
};
|
||
let sh = Shape { id: ShapeId(621), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
};
|
||
let ink = |img: &crate::Image, x: u32, y: u32| {
|
||
let p = img.pixel(x, y);
|
||
p[0] < 235 || p[1] < 235 || p[2] < 235
|
||
};
|
||
// Waterfall: the decrease floats (nothing under it near the axis), the total stands on it.
|
||
let img = chart(ChartType::Waterfall, &[100.0, 40.0, -25.0, 115.0], vec![3]);
|
||
let plot_bottom = (300..530).rev().find(|&y| ink(&img, 120, y)).unwrap_or(500);
|
||
let band = |i: f64| (80.0 + (900.0 - 80.0) * (i + 0.5) / 4.0) as u32;
|
||
assert!(!ink(&img, band(2.0), plot_bottom - 20), "the decrease bar reaches the axis");
|
||
assert!(ink(&img, band(3.0), plot_bottom - 20), "the total bar doesn't stand on the axis");
|
||
assert!(ink(&img, band(1.0), 100), "the increase bar is missing");
|
||
// Funnel, treemap and sunburst fill the middle of the chart.
|
||
for kind in [ChartType::Funnel, ChartType::Treemap, ChartType::Sunburst] {
|
||
let img = chart(kind, &[50.0, 30.0, 20.0], vec![]);
|
||
let covered = (0..540).step_by(10).flat_map(|y| (0..960).step_by(10).map(move |x| (x, y))).filter(|&(x, y)| ink(&img, x, y)).count();
|
||
assert!(covered > 1000, "{kind:?}: {covered} samples inked");
|
||
}
|
||
}
|
||
|
||
/// Histograms draw touching columns of their bins, Pareto charts add the cumulative line, and
|
||
/// box and whisker charts draw a box per group and series.
|
||
#[test]
|
||
fn histogram_pareto_and_box_charts_draw() {
|
||
let shot = |c: Chart| {
|
||
let sh = Shape { id: ShapeId(622), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
|
||
};
|
||
let inked = |img: &crate::Image| {
|
||
(0..540)
|
||
.step_by(6)
|
||
.flat_map(|y| (0..960).step_by(6).map(move |x| (x, y)))
|
||
.filter(|&(x, y)| {
|
||
let p = img.pixel(x, y);
|
||
p[0] < 200 || p[1] < 200 || p[2] < 200
|
||
})
|
||
.count()
|
||
};
|
||
let mut empty = Chart::sample(ChartType::Histogram);
|
||
empty.series[0].values.clear();
|
||
let blank = inked(&shot(empty));
|
||
for kind in [ChartType::Histogram, ChartType::Pareto, ChartType::BoxWhisker] {
|
||
let img = shot(Chart::sample(kind));
|
||
if let Ok(dir) = std::env::var("DECKCRAFT_CHART_SHOTS") {
|
||
let _ = std::fs::write(format!("{dir}/{kind:?}.png"), img.to_png());
|
||
}
|
||
let n = inked(&img);
|
||
assert!(n > blank + 400, "{kind:?}: {n} inked samples (blank {blank})");
|
||
}
|
||
}
|
||
|
||
/// Multi-level treemaps and sunbursts draw their groups: the treemap's group banners and the
|
||
/// sunburst's inner ring of groups, coloured by top-level group.
|
||
#[test]
|
||
fn multilevel_treemap_and_sunburst_draw_their_groups() {
|
||
for kind in [ChartType::Treemap, ChartType::Sunburst] {
|
||
let c = Chart::sample(kind);
|
||
let sh = Shape { id: ShapeId(623), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
if let Ok(dir) = std::env::var("DECKCRAFT_CHART_SHOTS") {
|
||
let _ = std::fs::write(format!("{dir}/{kind:?}-levels.png"), img.to_png());
|
||
}
|
||
// Distinct colours: one hue per top-level group plus lighter children.
|
||
let mut seen: Vec<[u8; 3]> = Vec::new();
|
||
for y in (60..520).step_by(8) {
|
||
for x in (40..920).step_by(8) {
|
||
let p = img.pixel(x, y);
|
||
let c = [p[0] / 16, p[1] / 16, p[2] / 16];
|
||
if c != [15, 15, 15] && !seen.contains(&c) {
|
||
seen.push(c);
|
||
}
|
||
}
|
||
}
|
||
assert!(seen.len() >= 6, "{kind:?}: {} colours", seen.len());
|
||
}
|
||
}
|
||
|
||
/// A region map without drawable geography falls back to coloured tiles on the value scale.
|
||
#[test]
|
||
fn region_map_draws_tiles_on_its_colour_scale() {
|
||
let names = ["Brest", "Vitebsk", "Gomel", "Grodno", "Minsk", "Mogilev", "Minsk City"];
|
||
let vals = [3.1, 2.2, 2.9, 4.8, 6.0, 1.4, 9.5];
|
||
let c = Chart {
|
||
kind: ChartType::RegionMap,
|
||
title: Some("Sales by region".into()),
|
||
categories: names.iter().map(|s| s.to_string()).collect(),
|
||
series: vec![deckcraft_model::chart::Series { name: "Sales".into(), values: vals.iter().map(|v| Some(*v)).collect(), ..Default::default() }],
|
||
data_labels: true,
|
||
..Default::default()
|
||
};
|
||
let sh = Shape { id: ShapeId(624), xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
if let Ok(dir) = std::env::var("DECKCRAFT_CHART_SHOTS") {
|
||
let _ = std::fs::write(format!("{dir}/RegionMap-tiles.png"), img.to_png());
|
||
}
|
||
let mut seen: Vec<[u8; 3]> = Vec::new();
|
||
for y in (60..520).step_by(6) {
|
||
for x in (40..920).step_by(6) {
|
||
let p = img.pixel(x, y);
|
||
let c = [p[0] / 16, p[1] / 16, p[2] / 16];
|
||
if c != [15, 15, 15] && !seen.contains(&c) {
|
||
seen.push(c);
|
||
}
|
||
}
|
||
}
|
||
assert!(seen.len() >= 5, "{} colours", seen.len());
|
||
}
|
||
|
||
/// Radar charts are polar, stock charts draw high-low lines (and up/down bars), and a combo
|
||
/// chart draws its line series over its columns.
|
||
#[test]
|
||
fn radar_stock_and_combo_draw_their_own_layouts() {
|
||
let mut ohlc = Chart::sample(ChartType::Stock);
|
||
ohlc.series.insert(
|
||
0,
|
||
deckcraft_model::chart::Series {
|
||
name: "Open".into(),
|
||
values: [44.0, 25.0, 38.0, 50.0, 35.0].iter().map(|v| Some(*v)).collect(),
|
||
..Default::default()
|
||
},
|
||
);
|
||
ohlc.up_down_bars = true;
|
||
let charts = [
|
||
("Radar", Chart::sample(ChartType::Radar)),
|
||
("FilledRadar", Chart::sample(ChartType::FilledRadar)),
|
||
("Stock", Chart::sample(ChartType::Stock)),
|
||
("StockOHLC", ohlc),
|
||
("Combo", Chart::sample(ChartType::Combo)),
|
||
];
|
||
for (name, c) in charts {
|
||
let sh = Shape {
|
||
id: ShapeId(625),
|
||
xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)),
|
||
kind: ShapeKind::Chart(Box::new(c.clone())),
|
||
..Default::default()
|
||
};
|
||
let img = render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
if let Ok(dir) = std::env::var("DECKCRAFT_CHART_SHOTS") {
|
||
let _ = std::fs::write(format!("{dir}/{name}.png"), img.to_png());
|
||
}
|
||
let ink = |x: u32, y: u32| img.pixel(x, y)[..3] != [255, 255, 255];
|
||
match name {
|
||
// The radar's top spoke runs straight up from the centre; a line chart has nothing there.
|
||
"Radar" | "FilledRadar" => assert!((150..260).any(|y| ink(480, y)), "{name}"),
|
||
// No series lines: well right of the first category there is only gridline grey.
|
||
"Stock" | "StockOHLC" => {
|
||
let coloured = (60..480).step_by(2).flat_map(|y| (40..920).step_by(4).map(move |x| (x, y))).any(|(x, y)| {
|
||
let p = img.pixel(x, y);
|
||
p[2] > p[0].saturating_add(60)
|
||
});
|
||
assert!(!coloured || name == "Stock", "{name}: series drawn as lines");
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn charts_in_degenerate_frames_draw_without_panicking() {
|
||
// A chart frame squashed to no width (cx="0" in a generated file) made the value labels'
|
||
// gutter clamp panic (its upper bound, a share of the width, fell below its lower bound).
|
||
// Every chart type and legend position must survive any frame size.
|
||
let p = Presentation::default();
|
||
let rctx = Ctx::for_slide(&p, &p.slides[0]).unwrap();
|
||
let kinds = [
|
||
ChartType::Column,
|
||
ChartType::StackedColumn,
|
||
ChartType::PercentColumn,
|
||
ChartType::Bar,
|
||
ChartType::StackedBar,
|
||
ChartType::PercentBar,
|
||
ChartType::Line,
|
||
ChartType::LineMarkers,
|
||
ChartType::StackedLine,
|
||
ChartType::Area,
|
||
ChartType::StackedArea,
|
||
ChartType::Pie,
|
||
ChartType::Doughnut,
|
||
ChartType::Scatter,
|
||
ChartType::Bubble,
|
||
ChartType::Radar,
|
||
ChartType::FilledRadar,
|
||
ChartType::Stock,
|
||
ChartType::Surface,
|
||
ChartType::Histogram,
|
||
ChartType::Pareto,
|
||
ChartType::BoxWhisker,
|
||
ChartType::Waterfall,
|
||
ChartType::Funnel,
|
||
ChartType::Treemap,
|
||
ChartType::Sunburst,
|
||
ChartType::Combo,
|
||
];
|
||
let mut ctx = vello_cpu::RenderContext::new(64, 64);
|
||
for k in kinds {
|
||
for (w, h) in [(0.0, 403.0), (403.0, 0.0), (0.0, 0.0), (2.0, 400.0), (400.0, 2.0), (12.0, 12.0)] {
|
||
for legend in [None, Some("b"), Some("t"), Some("r"), Some("l"), Some("tr")] {
|
||
let mut c = Chart::sample(k);
|
||
c.legend = legend.map(String::from);
|
||
crate::chart::draw(&mut ctx, &rctx, &c, kurbo::Affine::IDENTITY, w, h);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Renders the EMF at `$DECKCRAFT_EMF_IN` to `$DECKCRAFT_EMF_PNG` (a look-at helper; does nothing
|
||
/// without them).
|
||
#[test]
|
||
fn render_an_emf_file_to_look_at() {
|
||
let (Ok(src), Ok(out)) = (std::env::var("DECKCRAFT_EMF_IN"), std::env::var("DECKCRAFT_EMF_PNG")) else { return };
|
||
let Ok(bytes) = std::fs::read(&src) else { return };
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("image1.emf", "image/x-emf", bytes).expect("media");
|
||
let fill = deckcraft_model::style::PictureFill { media, ..Default::default() };
|
||
let sh = Shape { id: ShapeId(600), xfrm: Some(Xfrm::new(40.0, 40.0, 840.0, 400.0)), kind: ShapeKind::Picture { fill }, ..Default::default() };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let _ = std::fs::write(out, img.to_png());
|
||
}
|
||
|
||
#[test]
|
||
fn single_series_column_chart_varies_colours_by_point() {
|
||
let render = |vary: bool| {
|
||
let mut c = Chart::sample(ChartType::Column);
|
||
c.series.truncate(1);
|
||
c.vary_colors = vary;
|
||
let sh =
|
||
Shape { id: ShapeId(800), xfrm: Some(Xfrm::new(50.0, 50.0, 400.0, 300.0)), kind: ShapeKind::Chart(Box::new(c)), ..Default::default() };
|
||
render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() }).pixels
|
||
};
|
||
assert_ne!(render(true), render(false));
|
||
}
|
||
|
||
/// A 1024×1024 PNG of 2 px wide black and white vertical stripes.
|
||
fn fine_stripes_png() -> Vec<u8> {
|
||
let img =
|
||
image::RgbaImage::from_fn(1024, 1024, |x, _| if (x / 2) % 2 == 0 { image::Rgba([0, 0, 0, 255]) } else { image::Rgba([255, 255, 255, 255]) });
|
||
let mut out = std::io::Cursor::new(Vec::new());
|
||
image::DynamicImage::ImageRgba8(img).write_to(&mut out, image::ImageFormat::Png).expect("png");
|
||
out.into_inner()
|
||
}
|
||
|
||
#[test]
|
||
fn a_cropped_picture_is_decoded_at_the_resolution_of_the_whole_image() {
|
||
// The top-left sixteenth of the image in a 64 pt box: 64 image pixels over 64 output pixels.
|
||
// Decoding at the box's size instead of the whole image's blurs the stripes to grey (#762).
|
||
let mut p = Presentation::default();
|
||
let media = p.add_media("stripes.png", "image/png", fine_stripes_png()).expect("media");
|
||
let fill = deckcraft_model::style::PictureFill { media, crop: [0.0, 0.0, 15.0 / 16.0, 15.0 / 16.0], ..Default::default() };
|
||
let sh = Shape { id: ShapeId(600), xfrm: Some(Xfrm::new(100.0, 100.0, 64.0, 64.0)), kind: ShapeKind::Picture { fill }, ..Default::default() };
|
||
std::sync::Arc::make_mut(&mut p.slides[0]).shapes = vec![sh];
|
||
let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
|
||
let (mut sharp, mut total) = (0, 0);
|
||
for y in 110..154 {
|
||
for x in 110..154 {
|
||
let v = img.pixel(x, y)[0];
|
||
total += 1;
|
||
if !(48..=208).contains(&v) {
|
||
sharp += 1;
|
||
}
|
||
}
|
||
}
|
||
assert!(sharp * 10 >= total * 9, "the stripes stay sharp: {sharp} of {total} pixels black or white");
|
||
}
|
||
|
||
#[test]
|
||
fn empty_bullet_is_gray_only_while_editing_and_never_in_exports() {
|
||
use deckcraft_model::text::{Bullet, Paragraph};
|
||
let mut para = Paragraph::default();
|
||
para.props.bullet = Some(Bullet::Char { char: "•".into() });
|
||
para.props.margin_left = Some(24.0);
|
||
para.props.indent = Some(-24.0);
|
||
para.end_props.size = Some(32.0);
|
||
let sh = Shape {
|
||
id: ShapeId(901),
|
||
xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 120.0)),
|
||
text: Some(TextBody { paragraphs: vec![para], ..Default::default() }),
|
||
..Default::default()
|
||
};
|
||
let p = deck_with(vec![sh]);
|
||
let render = |edit, editing_text| render_slide(&p, 0, &RenderOpts { edit, editing_text, ..Default::default() });
|
||
let plain = render(false, None);
|
||
assert_eq!(plain.pixels, render(true, None).pixels);
|
||
assert_eq!(plain.pixels, render(false, Some(ShapeId(901))).pixels, "export ignores editor markers");
|
||
assert_eq!(plain.pixels, render(true, Some(ShapeId(902))).pixels, "other shapes stay empty");
|
||
let editing = render(true, Some(ShapeId(901)));
|
||
let changed: Vec<_> = editing.pixels.as_chunks::<4>().0.iter().zip(plain.pixels.as_chunks::<4>().0).filter(|(a, b)| a != b).collect();
|
||
assert!(!changed.is_empty(), "an empty bullet must be visible");
|
||
assert!(changed.iter().any(|(px, _)| px[0] == 179 && px[1] == 179 && px[2] == 179));
|
||
assert!(changed.iter().all(|(px, _)| px[0] >= 179 && px[0] == px[1] && px[1] == px[2]));
|
||
}
|