use std::path::Path; use image::GrayImage; 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)?; } if self.metadata.cut_after_print && !document.blocks.iter().any(|b| matches!(b, Block::Cut)) { self.cut(); } 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 line = inlines_to_plain(inlines); let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal); for part in text_wrap::wrap_text(&line, cols) { 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)?; 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) { self.buffer.extend_from_slice(text.as_bytes()); self.buffer.push(b'\n'); } fn feed(&mut self, lines: u8) { 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 }]); 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 resolved = resolve_image_path(path, self.base_dir.as_deref()); let img = image::open(&resolved).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); Ok(()) } } fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> std::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() } } fn inlines_to_plain(inlines: &[Inline]) -> String { let mut out = String::new(); for inline in inlines { match inline { Inline::Text(t) | Inline::Code(t) => out.push_str(t), Inline::Param(t) => out.push_str(t), Inline::Bold(inner) | Inline::Italic(inner) => out.push_str(&inlines_to_plain(inner)), } } out } #[cfg(test)] mod tests { use super::*; use crate::dsl::parse; #[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_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 mut enc = EscPosEncoder::new(PosMetadata { page_width_mm: 58.0, ..Default::default() }); 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]); // x = bytes per row (u16 LE), y = height in dots (u16 LE) let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]); assert!(x_bytes > 0); 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_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 { cut_after_print: false, ..Default::default() }); let bytes = enc.encode_document(&doc).unwrap(); assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66])); } #[test] fn auto_cut_when_enabled() { let doc = parse("x").unwrap(); let mut enc = EscPosEncoder::new(PosMetadata::default()); let bytes = enc.encode_document(&doc).unwrap(); assert!(bytes.ends_with(&[0x1D, b'V', 66, 0])); } }