use std::collections::HashMap; use std::path::{Path, PathBuf}; use image::GrayImage; use crate::dsl::{ Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, QrMode, }; use crate::io::PosMetadata; use crate::datetime; use crate::params::{preview_barcode_sample, substitute_for_preview, substitute_inlines_for_preview}; use crate::raster::{render_barcode, render_qr}; use crate::text_wrap::{self, TextWrapStyle}; #[derive(Debug, Clone, PartialEq)] pub struct PreviewModel { pub lines: Vec, pub width_dots: u32, pub width_mm: f32, } #[derive(Debug, Clone, PartialEq)] pub enum PreviewLine { Text { content: String, align: Align, style: TextStyle, }, Rule, Graphic { image: GrayImage, align: Align, }, Error { message: String, align: Align, }, Spacer(u8), } #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub enum TextStyle { #[default] Normal, Heading1, Heading2, Bold, Italic, Code, } pub fn render_preview( document: &Document, metadata: &PosMetadata, base_dir: Option<&Path>, preview_params: &HashMap, ) -> PreviewModel { let width_dots = metadata.printable_dots() as u32; let mut lines = Vec::new(); for block in &document.blocks { match block { Block::Paragraph { align, inlines } => { let text = substitute_inlines_for_preview(inlines, preview_params); let cols = text_wrap::wrap_cols(metadata, TextWrapStyle::Normal); for line in text_wrap::wrap_text(&text, cols) { lines.push(PreviewLine::Text { content: line, align: *align, style: TextStyle::Normal, }); } } Block::Heading { level, align, inlines } => { let style = if *level == 1 { TextStyle::Heading1 } else { TextStyle::Heading2 }; let wrap_style = if *level == 1 { TextWrapStyle::Heading1 } else { TextWrapStyle::Heading2 }; let text = substitute_inlines_for_preview(inlines, preview_params); let cols = text_wrap::wrap_cols(metadata, wrap_style); for line in text_wrap::wrap_text(&text, cols) { lines.push(PreviewLine::Text { content: line, align: *align, style, }); } } Block::Rule => lines.push(PreviewLine::Rule), Block::Feed(n) => lines.push(PreviewLine::Spacer(*n)), Block::Cut => lines.push(PreviewLine::Text { content: "--- cut ---".into(), align: Align::Center, style: TextStyle::Code, }), Block::Image { path, width, align } => { let path = substitute_for_preview(path, preview_params); lines.push(render_image_preview(&path, *width, *align, metadata, base_dir)); } Block::Barcode { mode, symbology, data, height, align, .. } => { let resolved = substitute_for_preview(data, preview_params); lines.push(render_barcode_preview( *mode, *symbology, data, &resolved, *height, *align, metadata, )); } Block::Qr { mode, data, size, ecc, version, align, } => { let data = substitute_for_preview(data, preview_params); lines.push(render_qr_preview( *mode, &data, *size, *ecc, *version, *align, metadata, )); } Block::Date { format, align } => { let text = datetime::format_date(format.as_deref()); let cols = text_wrap::wrap_cols(metadata, TextWrapStyle::Normal); for line in text_wrap::wrap_text(&text, cols) { lines.push(PreviewLine::Text { content: line, align: *align, style: TextStyle::Normal, }); } } Block::Time { format, align } => { let text = datetime::format_time(*format); let cols = text_wrap::wrap_cols(metadata, TextWrapStyle::Normal); for line in text_wrap::wrap_text(&text, cols) { lines.push(PreviewLine::Text { content: line, align: *align, style: TextStyle::Normal, }); } } } } PreviewModel { lines, width_dots, width_mm: metadata.page_width_mm, } } fn render_barcode_preview( mode: BarcodeMode, symbology: BarcodeSymbology, template_data: &str, resolved_data: &str, height: u8, align: Align, metadata: &PosMetadata, ) -> PreviewLine { let height_px = u32::from(height.max(20)); let resolved_data = resolved_data.trim(); match mode { BarcodeMode::Raster | BarcodeMode::Native => { match render_barcode(symbology, resolved_data, height_px) { Ok(img) => scale_graphic_to_width(img, metadata.printable_dots() as u32, align), Err(e) => { if template_data.contains("${") { if let Ok(img) = render_barcode(symbology, preview_barcode_sample(symbology), height_px) { return scale_graphic_to_width( img, metadata.printable_dots() as u32, align, ); } } PreviewLine::Error { message: format!( "barcode: {e} ({} supports alphanumeric data; URLs and punctuation often fail)", symbology.as_str() ), align, } } } } } } fn render_qr_preview( mode: QrMode, data: &str, size: u8, ecc: crate::dsl::QrEcc, version: Option, align: Align, metadata: &PosMetadata, ) -> PreviewLine { let module_pixels = u32::from(size.max(2)); match mode { QrMode::Raster | QrMode::Native => match render_qr(data, version, ecc, module_pixels) { Ok(img) => { let max_w = (metadata.printable_dots() as u32).min(img.width()); scale_graphic_to_width(img, max_w, align) } Err(e) => PreviewLine::Error { message: format!("qr: {e}"), align, }, }, } } fn render_image_preview( path: &str, width: ImageWidth, align: Align, metadata: &PosMetadata, base_dir: Option<&Path>, ) -> PreviewLine { let resolved = resolve_image_path(path, base_dir); match image::open(&resolved) { Ok(img) => { let gray = img.to_luma8(); let target = target_image_width(width, metadata); let scaled = scale_gray_to_width(gray, target); PreviewLine::Graphic { image: scaled, align, } } Err(e) => PreviewLine::Error { message: format!("image {path}: {e}"), align, }, } } fn scale_graphic_to_width(img: GrayImage, target_width: u32, align: Align) -> PreviewLine { PreviewLine::Graphic { image: scale_gray_to_width(img, target_width), align, } } fn scale_gray_to_width(gray: GrayImage, target_width: u32) -> GrayImage { let (w, h) = gray.dimensions(); if w == 0 || h == 0 { return gray; } let new_w = target_width.min(w).max(1); if new_w == w { return gray; } let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32; image::imageops::resize( &gray, new_w, new_h, image::imageops::FilterType::Nearest, ) } fn target_image_width(width: ImageWidth, metadata: &PosMetadata) -> u32 { match width { ImageWidth::Percent(pct) => { (metadata.printable_dots() as u32 * pct as u32 / 100).max(1) } ImageWidth::Dots(d) => d as u32, ImageWidth::Default => metadata.printable_dots() as u32, } } fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> PathBuf { let p = Path::new(path); if p.is_absolute() { p.to_path_buf() } else if let Some(base) = base_dir { base.join(p) } else { p.to_path_buf() } } /// Pixels per millimetre on screen (preview uses configured page width). const PREVIEW_PX_PER_MM: f32 = 3.0; pub fn preview_content_width_px(metadata: &PosMetadata) -> f32 { metadata.page_width_mm * PREVIEW_PX_PER_MM } /// User-controlled zoom factor applied on top of the mm-based layout. pub fn preview_zoom_scale(zoom: f32) -> f32 { zoom.clamp(0.25, 4.0) } #[cfg(test)] mod tests { use super::*; use crate::dsl::parse; use std::collections::HashMap; #[test] fn renders_paragraph_lines() { let doc = parse("Line1\nLine2").unwrap(); let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new()); assert!(model.lines.len() >= 2); } #[test] fn uses_placeholder_when_param_not_set() { let doc = parse("${X}").unwrap(); let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new()); let PreviewLine::Text { content, .. } = &model.lines[0] else { panic!(); }; assert_eq!(content, "1234567890"); } #[test] fn uses_dialog_params_in_preview() { let doc = parse("Hello ${Name}").unwrap(); let mut params = HashMap::new(); params.insert("Name".into(), "Ada".into()); let model = render_preview(&doc, &PosMetadata::default(), None, ¶ms); let PreviewLine::Text { content, .. } = &model.lines[0] else { panic!(); }; assert_eq!(content, "Hello Ada"); } #[test] fn renders_barcode_graphic() { let doc = parse("@barcode CODE128 TEST").unwrap(); let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new()); assert!(model .lines .iter() .any(|l| matches!(l, PreviewLine::Graphic { .. }))); } #[test] fn renders_barcode_with_unresolved_params() { let doc = parse("@barcode CODE128 ${DocumentNumber}").unwrap(); let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new()); assert!(model .lines .iter() .any(|l| matches!(l, PreviewLine::Graphic { .. }))); } #[test] fn renders_raster_code128_with_data_param() { let doc = parse( ":center:\n# Hello\n@qr ${Data}\n@barcode RASTER CODE128 ${Data}\n", ) .unwrap(); let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new()); let graphics = model .lines .iter() .filter(|l| matches!(l, PreviewLine::Graphic { .. })) .count(); let errors: Vec<_> = model .lines .iter() .filter_map(|l| match l { PreviewLine::Error { message, .. } => Some(message.as_str()), _ => None, }) .collect(); assert_eq!(graphics, 2, "expected QR and barcode graphics, errors: {errors:?}"); } #[test] fn empty_param_value_uses_barcode_placeholder() { let doc = parse("@barcode RASTER CODE128 ${Data}\n").unwrap(); let mut params = HashMap::new(); params.insert("Data".into(), String::new()); let model = render_preview(&doc, &PosMetadata::default(), None, ¶ms); assert!(model .lines .iter() .any(|l| matches!(l, PreviewLine::Graphic { .. }))); } #[test] fn shared_data_param_url_still_renders_barcode_preview() { let doc = parse("@qr ${Data}\n@barcode RASTER CODE128 ${Data}\n").unwrap(); let mut params = HashMap::new(); params.insert("Data".into(), "https://example.com".into()); let model = render_preview(&doc, &PosMetadata::default(), None, ¶ms); let graphics = model .lines .iter() .filter(|l| matches!(l, PreviewLine::Graphic { .. })) .count(); assert_eq!(graphics, 2, "QR and barcode preview should both render"); } #[test] fn persistent_center_heading_uses_center_in_preview() { let doc = parse(":center:\n# Hello").unwrap(); let model = render_preview(&doc, &PosMetadata::default(), None, &HashMap::new()); let PreviewLine::Text { align, content, .. } = &model.lines[0] else { panic!(); }; assert_eq!(content, "Hello"); assert_eq!(*align, Align::Center); } #[test] fn heading_wraps_in_preview_on_narrow_paper() { let doc = parse("# Proof of Transfer").unwrap(); let meta = PosMetadata { page_width_mm: 53.0, ..Default::default() }; let model = render_preview(&doc, &meta, None, &HashMap::new()); let text_lines: Vec<_> = model .lines .iter() .filter_map(|l| match l { PreviewLine::Text { content, style, .. } if *style == TextStyle::Heading1 => { Some(content.as_str()) } _ => None, }) .collect(); assert_eq!(text_lines, vec!["Proof of", "Transfer"]); } #[test] fn preview_width_follows_page_mm() { let meta = PosMetadata { page_width_mm: 58.0, ..Default::default() }; assert!((preview_content_width_px(&meta) - 58.0 * PREVIEW_PX_PER_MM).abs() < 0.01); } }