BlueGit

timfa posprint

Files

posprint / src / preview.rs

preview.rs

fixes
timfa Tim Falken · pushed by timfa · 4 months ago
4ab2186f History
preview.rs 14.9 KiB Download Raw
1use std::collections::HashMap;
2use std::path::{Path, PathBuf};
3
4use image::GrayImage;
5
6use crate::dsl::{
7 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, QrMode,
8};
9use crate::io::PosMetadata;
10use crate::datetime;
11use crate::params::{preview_barcode_sample, substitute_for_preview, substitute_inlines_for_preview};
12use crate::raster::{render_barcode, render_qr};
13use crate::text_wrap::{self, TextWrapStyle};
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct PreviewModel {
17 pub lines: Vec<PreviewLine>,
18 pub width_dots: u32,
19 pub width_mm: f32,
20}
21
22#[derive(Debug, Clone, PartialEq)]
23pub enum PreviewLine {
24 Text {
25 content: String,
26 align: Align,
27 style: TextStyle,
28 },
29 Rule,
30 Graphic {
31 image: GrayImage,
32 align: Align,
33 },
34 Error {
35 message: String,
36 align: Align,
37 },
38 Spacer(u8),
39}
40
41#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
42pub enum TextStyle {
43 #[default]
44 Normal,
45 Heading1,
46 Heading2,
47 Bold,
48 Italic,
49 Code,
50}
51
52pub fn render_preview(
53 document: &Document,
54 metadata: &PosMetadata,
55 base_dir: Option<&Path>,
56 preview_params: &HashMap<String, String>,
57) -> PreviewModel {
58 let width_dots = metadata.printable_dots() as u32;
59 let mut lines = Vec::new();
60
61 for block in &document.blocks {
62 match block {
63 Block::Paragraph { align, inlines } => {
64 let text = substitute_inlines_for_preview(inlines, preview_params);
65 let cols = text_wrap::wrap_cols(metadata, TextWrapStyle::Normal);
66 for line in text_wrap::wrap_text(&text, cols) {
67 lines.push(PreviewLine::Text {
68 content: line,
69 align: *align,
70 style: TextStyle::Normal,
71 });
72 }
73 }
74 Block::Heading { level, align, inlines } => {
75 let style = if *level == 1 {
76 TextStyle::Heading1
77 } else {
78 TextStyle::Heading2
79 };
80 let wrap_style = if *level == 1 {
81 TextWrapStyle::Heading1
82 } else {
83 TextWrapStyle::Heading2
84 };
85 let text = substitute_inlines_for_preview(inlines, preview_params);
86 let cols = text_wrap::wrap_cols(metadata, wrap_style);
87 for line in text_wrap::wrap_text(&text, cols) {
88 lines.push(PreviewLine::Text {
89 content: line,
90 align: *align,
91 style,
92 });
93 }
94 }
95 Block::Rule => lines.push(PreviewLine::Rule),
96 Block::Feed(n) => lines.push(PreviewLine::Spacer(*n)),
97 Block::Cut => lines.push(PreviewLine::Text {
98 content: "--- cut ---".into(),
99 align: Align::Center,
100 style: TextStyle::Code,
101 }),
102 Block::Image { path, width, align } => {
103 let path = substitute_for_preview(path, preview_params);
104 lines.push(render_image_preview(&path, *width, *align, metadata, base_dir));
105 }
106 Block::Barcode {
107 mode,
108 symbology,
109 data,
110 height,
111 align,
112 ..
113 } => {
114 let resolved = substitute_for_preview(data, preview_params);
115 lines.push(render_barcode_preview(
116 *mode,
117 *symbology,
118 data,
119 &resolved,
120 *height,
121 *align,
122 metadata,
123 ));
124 }
125 Block::Qr {
126 mode,
127 data,
128 size,
129 ecc,
130 version,
131 align,
132 } => {
133 let data = substitute_for_preview(data, preview_params);
134 lines.push(render_qr_preview(
135 *mode, &data, *size, *ecc, *version, *align, metadata,
136 ));
137 }
138 Block::Date { format, align } => {
139 let text = datetime::format_date(format.as_deref());
140 let cols = text_wrap::wrap_cols(metadata, TextWrapStyle::Normal);
141 for line in text_wrap::wrap_text(&text, cols) {
142 lines.push(PreviewLine::Text {
143 content: line,
144 align: *align,
145 style: TextStyle::Normal,
146 });
147 }
148 }
149 Block::Time { format, align } => {
150 let text = datetime::format_time(*format);
151 let cols = text_wrap::wrap_cols(metadata, TextWrapStyle::Normal);
152 for line in text_wrap::wrap_text(&text, cols) {
153 lines.push(PreviewLine::Text {
154 content: line,
155 align: *align,
156 style: TextStyle::Normal,
157 });
158 }
159 }
160 }
161 }
162
163 PreviewModel {
164 lines,
165 width_dots,
166 width_mm: metadata.page_width_mm,
167 }
168}
169
170fn render_barcode_preview(
171 mode: BarcodeMode,
172 symbology: BarcodeSymbology,
173 template_data: &str,
174 resolved_data: &str,
175 height: u8,
176 align: Align,
177 metadata: &PosMetadata,
178) -> PreviewLine {
179 let height_px = u32::from(height.max(20));
180 let resolved_data = resolved_data.trim();
181 match mode {
182 BarcodeMode::Raster | BarcodeMode::Native => {
183 match render_barcode(symbology, resolved_data, height_px) {
184 Ok(img) => scale_graphic_to_width(img, metadata.printable_dots() as u32, align),
185 Err(e) => {
186 if template_data.contains("${") {
187 if let Ok(img) =
188 render_barcode(symbology, preview_barcode_sample(symbology), height_px)
189 {
190 return scale_graphic_to_width(
191 img,
192 metadata.printable_dots() as u32,
193 align,
194 );
195 }
196 }
197 PreviewLine::Error {
198 message: format!(
199 "barcode: {e} ({} supports alphanumeric data; URLs and punctuation often fail)",
200 symbology.as_str()
201 ),
202 align,
203 }
204 }
205 }
206 }
207 }
208}
209
210fn render_qr_preview(
211 mode: QrMode,
212 data: &str,
213 size: u8,
214 ecc: crate::dsl::QrEcc,
215 version: Option<u8>,
216 align: Align,
217 metadata: &PosMetadata,
218) -> PreviewLine {
219 let module_pixels = u32::from(size.max(2));
220 match mode {
221 QrMode::Raster | QrMode::Native => match render_qr(data, version, ecc, module_pixels) {
222 Ok(img) => {
223 let max_w = (metadata.printable_dots() as u32).min(img.width());
224 scale_graphic_to_width(img, max_w, align)
225 }
226 Err(e) => PreviewLine::Error {
227 message: format!("qr: {e}"),
228 align,
229 },
230 },
231 }
232}
233
234fn render_image_preview(
235 path: &str,
236 width: ImageWidth,
237 align: Align,
238 metadata: &PosMetadata,
239 base_dir: Option<&Path>,
240) -> PreviewLine {
241 let resolved = resolve_image_path(path, base_dir);
242 match image::open(&resolved) {
243 Ok(img) => {
244 let gray = img.to_luma8();
245 let target = target_image_width(width, metadata);
246 let scaled = scale_gray_to_width(gray, target);
247 PreviewLine::Graphic {
248 image: scaled,
249 align,
250 }
251 }
252 Err(e) => PreviewLine::Error {
253 message: format!("image {path}: {e}"),
254 align,
255 },
256 }
257}
258
259fn scale_graphic_to_width(img: GrayImage, target_width: u32, align: Align) -> PreviewLine {
260 PreviewLine::Graphic {
261 image: scale_gray_to_width(img, target_width),
262 align,
263 }
264}
265
266fn scale_gray_to_width(gray: GrayImage, target_width: u32) -> GrayImage {
267 let (w, h) = gray.dimensions();
268 if w == 0 || h == 0 {
269 return gray;
270 }
271 let new_w = target_width.min(w).max(1);
272 if new_w == w {
273 return gray;
274 }
275 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
276 image::imageops::resize(
277 &gray,
278 new_w,
279 new_h,
280 image::imageops::FilterType::Nearest,
281 )
282}
283
284fn target_image_width(width: ImageWidth, metadata: &PosMetadata) -> u32 {
285 match width {
286 ImageWidth::Percent(pct) => {
287 (metadata.printable_dots() as u32 * pct as u32 / 100).max(1)
288 }
289 ImageWidth::Dots(d) => d as u32,
290 ImageWidth::Default => metadata.printable_dots() as u32,
291 }
292}
293
294fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> PathBuf {
295 let p = Path::new(path);
296 if p.is_absolute() {
297 p.to_path_buf()
298 } else if let Some(base) = base_dir {
299 base.join(p)
300 } else {
301 p.to_path_buf()
302 }
303}
304
305/// Pixels per millimetre on screen (preview uses configured page width).
306const PREVIEW_PX_PER_MM: f32 = 3.0;
307
308pub fn preview_content_width_px(metadata: &PosMetadata) -> f32 {
309 metadata.page_width_mm * PREVIEW_PX_PER_MM
310}
311
312/// User-controlled zoom factor applied on top of the mm-based layout.
313pub fn preview_zoom_scale(zoom: f32) -> f32 {
314 zoom.clamp(0.25, 4.0)
315}
316
317#[cfg(test)]
318mod tests {
319 use super::*;
320 use crate::dsl::parse;
321 use std::collections::HashMap;
322
323 #[test]
324 fn renders_paragraph_lines() {
325 let doc = parse("Line1\nLine2").unwrap();
326 let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new());
327 assert!(model.lines.len() >= 2);
328 }
329
330 #[test]
331 fn uses_placeholder_when_param_not_set() {
332 let doc = parse("${X}").unwrap();
333 let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new());
334 let PreviewLine::Text { content, .. } = &model.lines[0] else {
335 panic!();
336 };
337 assert_eq!(content, "1234567890");
338 }
339
340 #[test]
341 fn uses_dialog_params_in_preview() {
342 let doc = parse("Hello ${Name}").unwrap();
343 let mut params = HashMap::new();
344 params.insert("Name".into(), "Ada".into());
345 let model = render_preview(&doc, &PosMetadata::default(), None, &params);
346 let PreviewLine::Text { content, .. } = &model.lines[0] else {
347 panic!();
348 };
349 assert_eq!(content, "Hello Ada");
350 }
351
352 #[test]
353 fn renders_barcode_graphic() {
354 let doc = parse("@barcode CODE128 TEST").unwrap();
355 let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new());
356 assert!(model
357 .lines
358 .iter()
359 .any(|l| matches!(l, PreviewLine::Graphic { .. })));
360 }
361
362 #[test]
363 fn renders_barcode_with_unresolved_params() {
364 let doc = parse("@barcode CODE128 ${DocumentNumber}").unwrap();
365 let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new());
366 assert!(model
367 .lines
368 .iter()
369 .any(|l| matches!(l, PreviewLine::Graphic { .. })));
370 }
371
372 #[test]
373 fn renders_raster_code128_with_data_param() {
374 let doc = parse(
375 ":center:\n# Hello\n@qr ${Data}\n@barcode RASTER CODE128 ${Data}\n",
376 )
377 .unwrap();
378 let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new());
379 let graphics = model
380 .lines
381 .iter()
382 .filter(|l| matches!(l, PreviewLine::Graphic { .. }))
383 .count();
384 let errors: Vec<_> = model
385 .lines
386 .iter()
387 .filter_map(|l| match l {
388 PreviewLine::Error { message, .. } => Some(message.as_str()),
389 _ => None,
390 })
391 .collect();
392 assert_eq!(graphics, 2, "expected QR and barcode graphics, errors: {errors:?}");
393 }
394
395 #[test]
396 fn empty_param_value_uses_barcode_placeholder() {
397 let doc = parse("@barcode RASTER CODE128 ${Data}\n").unwrap();
398 let mut params = HashMap::new();
399 params.insert("Data".into(), String::new());
400 let model = render_preview(&doc, &PosMetadata::default(), None, &params);
401 assert!(model
402 .lines
403 .iter()
404 .any(|l| matches!(l, PreviewLine::Graphic { .. })));
405 }
406
407 #[test]
408 fn shared_data_param_url_still_renders_barcode_preview() {
409 let doc = parse("@qr ${Data}\n@barcode RASTER CODE128 ${Data}\n").unwrap();
410 let mut params = HashMap::new();
411 params.insert("Data".into(), "https://example.com".into());
412 let model = render_preview(&doc, &PosMetadata::default(), None, &params);
413 let graphics = model
414 .lines
415 .iter()
416 .filter(|l| matches!(l, PreviewLine::Graphic { .. }))
417 .count();
418 assert_eq!(graphics, 2, "QR and barcode preview should both render");
419 }
420
421 #[test]
422 fn persistent_center_heading_uses_center_in_preview() {
423 let doc = parse(":center:\n# Hello").unwrap();
424 let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new());
425 let PreviewLine::Text { align, content, .. } = &model.lines[0] else {
426 panic!();
427 };
428 assert_eq!(content, "Hello");
429 assert_eq!(*align, Align::Center);
430 }
431
432 #[test]
433 fn heading_wraps_in_preview_on_narrow_paper() {
434 let doc = parse("# Proof of Transfer").unwrap();
435 let meta = PosMetadata {
436 page_width_mm: 53.0,
437 ..Default::default()
438 };
439 let model = render_preview(&doc, &meta, None, &HashMap::new());
440 let text_lines: Vec<_> = model
441 .lines
442 .iter()
443 .filter_map(|l| match l {
444 PreviewLine::Text { content, style, .. } if *style == TextStyle::Heading1 => {
445 Some(content.as_str())
446 }
447 _ => None,
448 })
449 .collect();
450 assert_eq!(text_lines, vec!["Proof of", "Transfer"]);
451 }
452
453 #[test]
454 fn preview_width_follows_page_mm() {
455 let meta = PosMetadata {
456 page_width_mm: 58.0,
457 ..Default::default()
458 };
459 assert!((preview_content_width_px(&meta) - 58.0 * PREVIEW_PX_PER_MM).abs() < 0.01);
460 }
461}