use std::path::Path; use image::GrayImage; use crate::align_row::{columns_from_parts, layout_aligned_row_or_lines}; use crate::dsl::{ Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode, }; use crate::io::PosMetadata; use crate::raster::{self, RasterError}; use crate::text_wrap::{self, TextWrapStyle}; #[derive(Debug)] pub enum EscPosError { Image(String), Barcode(String), Raster(RasterError), Io(String), } pub struct EscPosEncoder { buffer: Vec, metadata: PosMetadata, base_dir: Option, } impl EscPosEncoder { pub fn new(metadata: PosMetadata) -> Self { Self { buffer: Vec::new(), metadata, base_dir: None, } } pub fn with_base_dir(mut self, base_dir: impl AsRef) -> Self { self.base_dir = Some(base_dir.as_ref().to_path_buf()); self } pub fn encode_document(&mut self, document: &Document) -> Result<&[u8], EscPosError> { self.buffer.clear(); self.init(); for block in &document.blocks { self.encode_block(block)?; } Ok(&self.buffer) } pub fn into_bytes(self) -> Vec { self.buffer } fn init(&mut self) { self.buffer.extend_from_slice(&[0x1B, b'@']); self.buffer.extend_from_slice(&[0x1B, b't', 0]); } fn encode_block(&mut self, block: &Block) -> Result<(), EscPosError> { match block { Block::Paragraph { align, inlines } => { self.set_align(*align); let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal); let line = inlines_to_plain(inlines); for part in text_wrap::wrap_text(&line, cols) { self.writeln(&part); } } Block::AlignedRow { parts } => { let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal); let plain_parts: Vec<(Align, String)> = parts .iter() .map(|(align, inlines)| (*align, inlines_to_plain(inlines))) .collect(); let columns = columns_from_parts(&plain_parts); for (align, line) in layout_aligned_row_or_lines(&columns, cols) { self.set_align(align); for part in text_wrap::wrap_text(&line, cols) { self.writeln(&part); } } } Block::List { align, items } => { self.set_align(*align); let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal); for item in items { let line = inlines_to_plain(&item.inlines); for part in text_wrap::wrap_bullet_item_at_depth(&line, cols, item.depth) { self.writeln(&part); } } } Block::Heading { level, align, inlines } => { self.set_align(*align); let wrap_style = if *level == 1 { TextWrapStyle::Heading1 } else { TextWrapStyle::Heading2 }; let cols = text_wrap::wrap_cols(&self.metadata, wrap_style); let wrapped = text_wrap::wrap_text(&inlines_to_plain(inlines), cols); if *level == 1 { self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]); } else { self.buffer.extend_from_slice(&[0x1B, b'E', 1]); } for part in &wrapped { self.writeln(part); } if *level == 1 { self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]); } else { self.buffer.extend_from_slice(&[0x1B, b'E', 0]); } } Block::Rule => { let width = self.metadata.chars_per_line() as usize; self.writeln(&"-".repeat(width)); } Block::Feed(n) => self.feed(*n), Block::Cut => self.cut(), Block::Image { path, width, align } => { self.set_align(*align); self.encode_image(path, *width)?; } Block::Barcode { mode, symbology, data, height, align, show_text, } => { self.set_align(*align); match mode { BarcodeMode::Native => { self.encode_barcode_native(*symbology, data, *height, *show_text)?; } BarcodeMode::Raster => { let img = raster::render_barcode(*symbology, data, *height as u32) .map_err(EscPosError::Raster)?; let target = self.metadata.printable_dots() as u32; let img = raster::scale_gray_to_print_width(img, target); self.encode_gray_raster(&img, ImageWidth::Default)?; } } } Block::Qr { mode, data, size, ecc, version, align, } => { self.set_align(*align); match mode { QrMode::Native => self.encode_qr_native(data, *size, *ecc)?, QrMode::Raster => { let img = raster::render_qr(data, *version, *ecc, *size as u32) .map_err(EscPosError::Raster)?; self.encode_gray_raster(&img, ImageWidth::Default)?; } } } Block::Date { format, align } => { self.set_align(*align); let text = crate::datetime::format_date(format.as_deref()); let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal); for part in text_wrap::wrap_text(&text, cols) { self.writeln(&part); } } Block::Time { format, align } => { self.set_align(*align); let text = crate::datetime::format_time(*format); let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal); for part in text_wrap::wrap_text(&text, cols) { self.writeln(&part); } } } Ok(()) } fn set_align(&mut self, align: Align) { let n = match align { Align::Left => 0, Align::Center => 1, Align::Right => 2, }; self.buffer.extend_from_slice(&[0x1B, b'a', n]); } fn writeln(&mut self, text: &str) { // ESC/POS text path is CP437; keep output to ASCII bytes. for ch in text.chars() { if ch.is_ascii() { self.buffer.push(ch as u8); } else { self.buffer.push(b'?'); } } self.buffer.push(b'\n'); } fn feed(&mut self, lines: u8) { if lines == 0 { return; } // ESC d — reliable paper feed after raster graphics (print-bridge uses this too). self.buffer.extend_from_slice(&[0x1B, b'd', lines]); } fn cut(&mut self) { self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]); } fn encode_barcode_native( &mut self, symbology: BarcodeSymbology, data: &str, height: u8, show_text: bool, ) -> Result<(), EscPosError> { self.buffer.extend_from_slice(&[0x1D, b'h', height]); self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]); // Widest module width (GS w 6) for easier scanning. self.buffer.extend_from_slice(&[0x1D, b'w', 6]); match symbology { BarcodeSymbology::Code128 => { let bytes = data.as_bytes(); self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]); self.buffer.extend_from_slice(bytes); } BarcodeSymbology::UpcA => { if data.len() != 11 && data.len() != 12 { return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into())); } self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::UpcE => { if data.len() != 6 && data.len() != 7 && data.len() != 8 { return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into())); } self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::Ean13 => { if data.len() != 12 && data.len() != 13 { return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into())); } self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::Ean8 => { if data.len() != 7 && data.len() != 8 { return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into())); } self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::Code39 => { self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::Itf => { if data.len() % 2 != 0 { return Err(EscPosError::Barcode("ITF requires even digit count".into())); } self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::Codabar => { self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]); self.buffer.extend_from_slice(data.as_bytes()); } BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => { return Err(EscPosError::Barcode(format!( "{} requires RASTER mode", symbology.as_str() ))); } } self.buffer.push(b'\n'); Ok(()) } fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> { let ecc_level = match ecc { QrEcc::L => 48, QrEcc::M => 49, QrEcc::Q => 50, QrEcc::H => 51, }; let store = data.as_bytes(); let len = store.len() + 3; let p_l = (len & 0xFF) as u8; let p_h = ((len >> 8) & 0xFF) as u8; self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]); self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]); self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]); self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]); self.buffer.extend_from_slice(store); self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]); self.buffer.push(b'\n'); Ok(()) } fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> { let img = crate::image_load::load_image(path, self.base_dir.as_deref()) .map_err(|e| EscPosError::Image(e.to_string()))?; self.encode_gray_raster(&img.to_luma8(), width) } fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> { let (w, h) = gray.dimensions(); let target_width = match width { ImageWidth::Percent(pct) => { (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32 } ImageWidth::Dots(d) => d as u32, ImageWidth::Default => self.metadata.printable_dots() as u32, }; let new_w = target_width.min(w).max(1); let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32; let resized = image::imageops::resize( gray, new_w, new_h, image::imageops::FilterType::Nearest, ); let bytes_per_row = ((new_w + 7) / 8) as usize; let mut raster = vec![0u8; bytes_per_row * new_h as usize]; for y in 0..new_h { for x in 0..new_w { let pixel = resized.get_pixel(x, y).0[0]; if pixel < 128 { let byte_index = (y as usize * bytes_per_row) + (x as usize / 8); let bit = 7 - (x % 8); raster[byte_index] |= 1 << bit; } } } let x_l = (bytes_per_row & 0xFF) as u8; let x_h = ((bytes_per_row >> 8) & 0xFF) as u8; let y_l = (new_h & 0xFF) as u8; let y_h = ((new_h >> 8) & 0xFF) as u8; // GS v 0 normal raster — same header as print-bridge / node-escpos: // 1D 76 30 00, xL xH (bytes/row), yL yH (dots), then bitmap bytes. self.buffer .extend_from_slice(&[0x1D, b'v', 0x30, 0x00, x_l, x_h, y_l, y_h]); self.buffer.extend_from_slice(&raster); // LF prints/flushes the raster; without it the next graphic can butt against this one. self.buffer.push(b'\n'); Ok(()) } } fn inlines_to_plain(inlines: &[Inline]) -> String { let mut out = String::new(); for inline in inlines { match inline { Inline::Text(t) => out.push_str(t), Inline::Param(t) | Inline::CheckboxParam(t) => out.push_str(t), Inline::Checkbox { checked } => out.push_str(crate::dsl::checkbox_glyph(*checked)), } } out } #[cfg(test)] mod tests { use super::*; use crate::dsl::{parse, Block}; #[test] fn heading_wraps_like_preview_on_narrow_paper() { let doc = parse("# Proof of Transfer").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata { page_width_mm: 53.0, ..Default::default() }); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); assert!( text.contains("Proof of\n"), "expected word wrap before Transfer, got: {text}" ); assert!( text.contains("Transfer\n"), "expected wrapped second line, got: {text}" ); } #[test] fn encodes_bullet_list_with_hanging_indent() { let doc = parse("- this is a long line").unwrap(); let meta = PosMetadata { chars_per_line: Some(15), ..Default::default() }; let mut enc = EscPosEncoder::new(meta); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); assert!(text.contains("* this is a\n")); assert!(text.contains(" long line\n")); } #[test] fn encodes_nested_bullet_list() { let doc = parse("- outer\n - inner").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); assert!(text.contains("* outer\n")); assert!(text.contains(" - inner\n")); } #[test] fn encodes_inline_checkboxes_as_ascii() { let doc = parse("[] hello [x]").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); assert!( text.contains("[ ] hello [x]\n"), "expected ASCII checkbox glyphs, got: {text:?}" ); } #[test] fn encodes_init_and_text() { let doc = parse("Hello").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert_eq!(&bytes[0..2], &[0x1B, b'@']); assert!(bytes.windows(5).any(|w| w == b"Hello")); } #[test] fn encodes_raster_barcode() { let doc = parse("@barcode RASTER CODE128 TEST").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert!( bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]), "expected GS v 0 raster header" ); } #[test] fn raster_header_matches_print_bridge_format() { let doc = parse("@barcode RASTER CODE128 X").unwrap(); let meta = PosMetadata { page_width_mm: 58.0, ..Default::default() }; let mut enc = EscPosEncoder::new(meta.clone()); let bytes = enc.encode_document(&doc).unwrap(); let pos = bytes .windows(4) .position(|w| w == [0x1D, b'v', 0x30, 0x00]) .expect("raster header"); assert_eq!(&bytes[pos..pos + 4], &[0x1D, b'v', 0x30, 0x00]); let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]); let expected_bytes = ((meta.printable_dots() as u32 + 7) / 8) as u16; assert_eq!( x_bytes, expected_bytes, "barcode raster should span full printable width" ); let y_dots = u16::from_le_bytes([bytes[pos + 6], bytes[pos + 7]]); assert!(y_dots > 0); } #[test] fn encodes_centered_heading() { let doc = parse(":center:\n# Hello").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert!(bytes.windows(3).any(|w| w == [0x1B, b'a', 1])); assert!(bytes.windows(5).any(|w| w == b"Hello")); } #[test] fn encodes_inline_left_right_as_one_padded_line() { let doc = parse(":left:appel:right:10").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata { chars_per_line: Some(32), ..Default::default() }); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); let expected = format!("appel{}10\n", " ".repeat(25)); assert!( text.contains(&expected), "expected one padded line, got: {text:?}" ); assert!( !text.contains("appel\n"), "left segment must not be its own line: {text:?}" ); } #[test] fn encodes_right_before_left_reordered() { let doc = parse(":right:10:left:appel").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata { chars_per_line: Some(32), ..Default::default() }); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); assert!(text.contains(&format!("appel{}10\n", " ".repeat(25)))); } #[test] fn encodes_date_directive() { let doc = parse("@date DD-YYYY-MM").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); let text = String::from_utf8_lossy(bytes); assert!(text.contains('-')); } #[test] fn encodes_cut_directive() { let doc = parse("@cut").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66])); } #[test] fn feed_uses_esc_d_for_blank_lines() { let doc = parse("A\n\nB").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert!(bytes.windows(3).any(|w| w == [0x1B, b'd', 1])); } #[test] fn blank_line_between_barcode_and_qr_is_ordered_feed() { let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap(); assert!(matches!( doc.blocks.as_slice(), [ Block::Barcode { .. }, Block::Feed(1), Block::Qr { .. }, ] )); } #[test] fn blank_line_between_graphics_feeds_on_print() { let doc = parse("@barcode RASTER CODE128 X\n\n@qr RASTER Y scale=4").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata { page_width_mm: 53.0, ..Default::default() }); let bytes = enc.encode_document(&doc).unwrap(); let raster_positions: Vec<_> = bytes .windows(4) .enumerate() .filter(|(_, w)| *w == [0x1D, b'v', 0x30, 0x00]) .map(|(i, _)| i) .collect(); assert_eq!(raster_positions.len(), 2); let between = &bytes[raster_positions[0]..raster_positions[1]]; assert!( between.windows(3).any(|w| w == [0x1B, b'd', 1]), "expected ESC d feed between raster graphics, got {} bytes", between.len() ); } #[test] fn raster_graphic_ends_with_line_feed() { let doc = parse("@barcode RASTER CODE128 X").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); let raster_start = bytes .windows(4) .position(|w| w == [0x1D, b'v', 0x30, 0x00]) .expect("raster header"); assert!( bytes[raster_start..].contains(&b'\n'), "expected LF after raster data" ); } #[test] fn does_not_auto_cut_without_directive() { let doc = parse("x").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert!(!bytes.windows(3).any(|w| w == [0x1D, b'V', 66])); } }