//! TSPL/TSPL2 output for label printers (first version: whole page as bitmap). //! //! The document is first encoded by the unchanged [`crate::escpos::EscPosEncoder`] //! and that ESC/POS byte stream is rendered into a bitmap by a small emulator //! (Font A 12×24 cells, ESC a alignment, GS ! size, ESC E bold, GS v 0 raster, //! GS k barcodes, GS ( k QR codes, ESC d feeds, GS V cut = next label). This keeps //! the label layout identical to the receipt layout, then //! [`encode_labels`] wraps it in TSPL: //! //! ```text //! SIZE w mm,h mm / GAP g mm,0 mm (BLINE for black marks, GAP 0,0 continuous) //! DIRECTION d,0 / REFERENCE 0,0 / CLS / BITMAP x,y,wbytes,h,0, / PRINT 1,1 //! ``` //! //! References: Altec TSPL/TSPL2 programming manual (2023-1-9): SIZE p.1, GAP p.2, //! GAPDETECT p.4, BLINEDETECT p.5, BLINE p.7, DIRECTION p.12, REFERENCE p.13, //! CLS, BITMAP p.44 (bit 0 = black dot), PRINT; GETSETTING$ p.211; `!?` p.82. use ab_glyph::{Font, FontRef, PxScale, ScaleFont}; use image::{GrayImage, Luma}; use crate::dsl::{BarcodeSymbology, QrEcc}; use crate::label_format::{LabelFormat, MediaKind}; use crate::raster; /// ESC/POS source resolution assumed by Posprint's column model (8 dots/mm). pub const SOURCE_DOTS_PER_MM: f32 = 8.0; const CELL_W: f32 = 12.0; const CELL_H: f32 = 24.0; const LINE_ADVANCE: f32 = 30.0; /// Render an ESC/POS stream (as produced by `EscPosEncoder`) to bitmaps. /// `source_width` is the printable width in source dots, `scale` the output /// pixels per source dot. Each `GS V` cut starts a new page. pub fn render_escpos(bytes: &[u8], source_width: u32, scale: f32) -> Vec { let mut r = Renderer::new(source_width, scale); r.run(bytes); r.finish() } struct Renderer { font: FontRef<'static>, scale: f32, width: u32, rows: Vec, y: u32, pages: Vec, align: u8, bold: bool, size_w: u8, size_h: u8, line: Vec, after_graphic: bool, bc_height: u8, bc_hri: bool, bc_module: u8, qr_size: u8, qr_ecc: QrEcc, qr_data: Vec, } impl Renderer { fn new(source_width: u32, scale: f32) -> Self { let font = FontRef::try_from_slice(epaint_default_fonts::HACK_REGULAR).expect("bundled font"); Self { font, scale, width: ((source_width.max(1) as f32) * scale).round().max(1.0) as u32, rows: Vec::new(), y: 0, pages: Vec::new(), align: 0, bold: false, size_w: 1, size_h: 1, line: Vec::new(), after_graphic: false, bc_height: 162, bc_hri: false, bc_module: 3, qr_size: 3, qr_ecc: QrEcc::L, qr_data: Vec::new(), } } fn px(&self, v: f32) -> u32 { (v * self.scale).round().max(0.0) as u32 } fn ensure_rows(&mut self, bottom: u32) { let need = bottom as usize * self.width as usize; if self.rows.len() < need { self.rows.resize(need, 255); } } fn set_dark(&mut self, x: u32, y: u32) { if x < self.width { self.ensure_rows(y + 1); self.rows[y as usize * self.width as usize + x as usize] = 0; } } fn align_x(&self, w: u32) -> u32 { let free = self.width.saturating_sub(w); match self.align { 1 => free / 2, 2 => free, _ => 0, } } fn blit(&mut self, img: &GrayImage) { let x0 = self.align_x(img.width()); let y0 = self.y; for (x, y, p) in img.enumerate_pixels() { if p.0[0] < 128 { self.set_dark(x0 + x, y0 + y); } } self.y += img.height(); self.ensure_rows(self.y); self.after_graphic = true; } fn flush_line(&mut self) { let text = std::mem::take(&mut self.line); if text.is_empty() { if self.after_graphic { // LF after a graphic flushes it; keep a small gap (1 mm at // 8 dots/mm) instead of a full blank line to save label space. self.after_graphic = false; self.y += self.px(8.0); self.ensure_rows(self.y); return; } self.y += self.px(LINE_ADVANCE * self.size_h as f32); self.ensure_rows(self.y); return; } self.after_graphic = false; let cw = CELL_W * self.scale * self.size_w as f32; let ch = CELL_H * self.scale * self.size_h as f32; let line_w = (cw * text.len() as f32).round() as u32; let x0 = self.align_x(line_w) as f32; let y0 = self.y as f32; // Hack: advance ≈ 0.602 em; fit the advance to the cell width. let gid = self.font.glyph_id('M'); let unscaled_adv = self.font.h_advance_unscaled(gid); let upem = self.font.units_per_em().unwrap_or(2048.0); let sx = cw * upem / unscaled_adv; let sy = ch * 0.85 / ((self.font.ascent_unscaled() - self.font.descent_unscaled()) / upem); let pxs = PxScale { x: sx / upem * upem, y: sy }; let scaled = self.font.as_scaled(pxs); let baseline = y0 + (ch - (scaled.ascent() - scaled.descent())) / 2.0 + scaled.ascent(); let mut dots: Vec<(u32, u32)> = Vec::new(); for (i, b) in text.iter().enumerate() { let c = *b as char; if c == ' ' { continue; } let glyph = scaled.scaled_glyph(c); let mut glyph = glyph; glyph.position = ab_glyph::point(x0 + cw * i as f32, baseline); if let Some(outlined) = self.font.outline_glyph(glyph) { let bounds = outlined.px_bounds(); outlined.draw(|gx, gy, cov| { if cov >= 0.5 { let x = bounds.min.x + gx as f32; let y = bounds.min.y + gy as f32; if x >= 0.0 && y >= 0.0 { dots.push((x as u32, y as u32)); } } }); } } let bold_px = if self.bold || self.size_w > 1 { (self.scale.round() as u32).max(1) } else { 0 }; for (x, y) in dots { self.set_dark(x, y); for d in 1..=bold_px { self.set_dark(x + d, y); } } self.y += self.px(LINE_ADVANCE * self.size_h as f32).max(ch.ceil() as u32); self.ensure_rows(self.y); } fn cut(&mut self) { if !self.line.is_empty() { self.flush_line(); } let rows = std::mem::take(&mut self.rows); let h = (rows.len() / self.width as usize) as u32; if h > 0 { if let Some(img) = GrayImage::from_raw(self.width, h, rows) { self.pages.push(img); } } self.y = 0; self.after_graphic = false; } fn finish(mut self) -> Vec { self.cut(); self.pages .into_iter() .filter_map(trim_bottom) .collect() } fn barcode(&mut self, m: u8, data: &[u8]) { let sym = match m { 65 | 0 => Some(BarcodeSymbology::UpcA), 66 | 1 => Some(BarcodeSymbology::UpcE), 67 | 2 => Some(BarcodeSymbology::Ean13), 68 | 3 => Some(BarcodeSymbology::Ean8), 69 | 4 => Some(BarcodeSymbology::Code39), 70 | 5 => Some(BarcodeSymbology::Itf), 71 | 6 => Some(BarcodeSymbology::Codabar), 73 => Some(BarcodeSymbology::Code128), _ => None, }; let text = String::from_utf8_lossy(data).to_string(); let Some(sym) = sym else { return }; let height = self.px(self.bc_height as f32).max(1); let Ok(img) = raster::render_barcode(sym, &text, height) else { return; }; // Integer module width so bars stay scannable after scaling. let mut k = ((self.bc_module as f32) * self.scale).round().max(1.0) as u32; while k > 1 && img.width() * k > self.width { k -= 1; } let scaled = image::imageops::resize(&img, img.width() * k, img.height(), image::imageops::FilterType::Nearest); let scaled = if scaled.width() > self.width { raster::scale_gray_to_print_width(scaled, self.width) } else { scaled }; self.blit(&scaled); if self.bc_hri { let saved = self.align; self.line = text.into_bytes(); self.after_graphic = false; self.align = 1; self.flush_line(); self.align = saved; self.after_graphic = true; } } fn qr(&mut self) { let data = String::from_utf8_lossy(&self.qr_data).to_string(); let module = ((self.qr_size.max(1) as f32) * self.scale).round().max(1.0) as u32; if let Ok(img) = raster::render_qr(&data, None, self.qr_ecc, module) { // Quiet zone of 2 modules so the code scans next to label edges/text. let pad = module * 2; let mut framed = GrayImage::from_pixel(img.width() + 2 * pad, img.height() + 2 * pad, Luma([255])); image::imageops::overlay(&mut framed, &img, i64::from(pad), i64::from(pad)); self.blit(&framed); } } fn raster(&mut self, wbytes: usize, h: usize, data: &[u8]) { let w = (wbytes * 8) as u32; let mut img = GrayImage::from_pixel(w.max(1), (h as u32).max(1), Luma([255])); for y in 0..h { for x in 0..w as usize { let byte = data.get(y * wbytes + x / 8).copied().unwrap_or(0); if byte & (0x80 >> (x % 8)) != 0 { img.put_pixel(x as u32, y as u32, Luma([0])); } } } let nw = self.px(w as f32).max(1); let nh = self.px(h as f32).max(1); let img = if (self.scale - 1.0).abs() < f32::EPSILON { img } else { image::imageops::resize(&img, nw, nh, image::imageops::FilterType::Triangle) }; let img = threshold(&img); self.blit(&img); } fn run(&mut self, b: &[u8]) { let mut i = 0; let get = |i: usize| b.get(i).copied().unwrap_or(0); while i < b.len() { let c = b[i]; match c { 0x1B => { let cmd = get(i + 1); match cmd { b'@' => { self.align = 0; self.bold = false; self.size_w = 1; self.size_h = 1; i += 2; } b'a' => { self.align = get(i + 2) % 48 % 3; i += 3; } b'E' => { self.bold = get(i + 2) & 1 == 1; i += 3; } b'd' => { if !self.line.is_empty() { self.flush_line(); } self.after_graphic = false; self.y += self.px(LINE_ADVANCE) * get(i + 2) as u32; self.ensure_rows(self.y); i += 3; } b't' | b'M' | b'-' | b'!' | b'2' => { i += if cmd == b'2' { 2 } else { 3 }; } _ => i += 2, } } 0x1D => { let cmd = get(i + 1); match cmd { b'!' => { let n = get(i + 2); self.size_w = ((n >> 4) & 7) + 1; self.size_h = (n & 7) + 1; i += 3; } b'V' => { let m = get(i + 2); i += if m == 65 || m == 66 { 4 } else { 3 }; self.cut(); } b'h' => { self.bc_height = get(i + 2).max(1); i += 3; } b'H' => { self.bc_hri = get(i + 2) % 48 != 0; i += 3; } b'w' => { self.bc_module = get(i + 2).clamp(1, 6); i += 3; } b'k' => { let m = get(i + 2); if m >= 65 { let n = get(i + 3) as usize; let start = (i + 4).min(b.len()); let end = (start + n).min(b.len()); let data = b[start..end].to_vec(); self.barcode(m, &data); i = end; } else { let start = (i + 3).min(b.len()); let end = b[start..].iter().position(|&x| x == 0).map(|p| start + p).unwrap_or(b.len()); let data = b[start..end].to_vec(); self.barcode(m, &data); i = (end + 1).min(b.len()); } } b'(' if get(i + 2) == b'k' => { let len = get(i + 3) as usize | (get(i + 4) as usize) << 8; let start = (i + 5).min(b.len()); let end = (start + len).min(b.len()); let p = &b[start..end]; if p.len() >= 3 && p[0] == 49 { match p[1] { 67 => self.qr_size = p[2].clamp(1, 16), 69 => { self.qr_ecc = match p[2] { 49 => QrEcc::M, 50 => QrEcc::Q, 51 => QrEcc::H, _ => QrEcc::L, } } 80 => self.qr_data = p[3..].to_vec(), 81 => self.qr(), _ => {} } } i = end; } b'v' if get(i + 2) == 0x30 => { let wb = get(i + 4) as usize | (get(i + 5) as usize) << 8; let h = get(i + 6) as usize | (get(i + 7) as usize) << 8; let start = (i + 8).min(b.len()); let end = (start + wb * h).min(b.len()); let data = b[start..end].to_vec(); if !self.line.is_empty() { self.flush_line(); } self.raster(wb, h, &data); i = end; } _ => i += 2, } } b'\n' => { self.flush_line(); i += 1; } b'\r' => i += 1, 0x20..=0x7E => { self.line.push(c); i += 1; } _ => { self.line.push(b'?'); i += 1; } } } } } fn threshold(img: &GrayImage) -> GrayImage { let mut out = img.clone(); for p in out.pixels_mut() { p.0[0] = if p.0[0] < 128 { 0 } else { 255 }; } out } /// Drop trailing white rows (receipt feeds before a cut); `None` if blank. fn trim_bottom(img: GrayImage) -> Option { let (w, h) = img.dimensions(); let mut last = None; for y in (0..h).rev() { if (0..w).any(|x| img.get_pixel(x, y).0[0] < 128) { last = Some(y); break; } } let last = last?; Some(image::imageops::crop_imm(&img, 0, 0, w, last + 1).to_image()) } /// Scale (output dots per source dot) so the page fits the label width. pub fn page_scale(source_width: u32, format: &LabelFormat) -> f32 { let dpmm = format.dots_per_mm() as f32; let natural = dpmm / SOURCE_DOTS_PER_MM; let label_w = format.width_mm * dpmm; let fit = label_w / source_width.max(1) as f32; natural.min(fit) } fn fmt_mm(v: f32) -> String { let s = format!("{:.2}", v); let s = s.trim_end_matches('0').trim_end_matches('.'); s.to_string() } #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct TsplOptions { /// Send GAPDETECT/BLINEDETECT with the label size first (sensor calibration; /// the printer feeds a few labels). pub calibrate: bool, } /// TSPL header lines for a label format (CRLF terminated). pub fn setup_commands(format: &LabelFormat, label_height_mm: f32, opts: TsplOptions) -> String { let mut s = String::new(); s.push_str(&format!("SIZE {} mm,{} mm\r\n", fmt_mm(format.width_mm), fmt_mm(label_height_mm))); match format.media { MediaKind::Gap => s.push_str(&format!("GAP {} mm,0 mm\r\n", fmt_mm(format.gap_mm))), MediaKind::BlackMark => s.push_str(&format!("BLINE {} mm,0 mm\r\n", fmt_mm(format.gap_mm))), MediaKind::Continuous => s.push_str("GAP 0,0\r\n"), } if opts.calibrate { let dpmm = format.dots_per_mm() as f32; let x = (label_height_mm * dpmm).round() as u32; let y = (format.gap_mm * dpmm).round() as u32; match format.media { MediaKind::Gap => s.push_str(&format!("GAPDETECT {x},{y}\r\n")), MediaKind::BlackMark => s.push_str(&format!("BLINEDETECT {x},{y}\r\n")), MediaKind::Continuous => {} } } s.push_str(&format!("DIRECTION {},0\r\n", if format.rotate_180 { 1 } else { 0 })); s.push_str("REFERENCE 0,0\r\n"); s } /// TSPL `BITMAP` data: 1 bit per dot, MSB first, **0 = black** (manual p.44). pub fn bitmap_bytes(img: &GrayImage) -> (usize, Vec) { let (w, h) = img.dimensions(); let wb = (w as usize).div_ceil(8); let mut out = vec![0xFFu8; wb * h as usize]; for (x, y, p) in img.enumerate_pixels() { if p.0[0] < 128 { out[y as usize * wb + x as usize / 8] &= !(0x80 >> (x % 8)); } } (wb, out) } /// Build a complete TSPL job for already-rendered pages. Pages taller than the /// label are split over several labels; each page is centred horizontally. pub fn encode_pages(pages: &[GrayImage], format: &LabelFormat, opts: TsplOptions) -> Vec { let dpmm = format.dots_per_mm(); let label_w = (format.width_mm * dpmm as f32).round() as u32; let mut chunks: Vec = Vec::new(); let continuous = format.media == MediaKind::Continuous; let label_h = (format.height_mm * dpmm as f32).round().max(1.0) as u32; for page in pages { if continuous { chunks.push(page.clone()); continue; } let mut y = 0; while y < page.height() { let h = label_h.min(page.height() - y); chunks.push(image::imageops::crop_imm(page, 0, y, page.width(), h).to_image()); y += h; } } let mut out = Vec::new(); let height_mm = |c: &GrayImage| { if continuous { (c.height() as f32 / dpmm as f32).max(5.0) } else { format.height_mm } }; let first_h = chunks.first().map(height_mm).unwrap_or(format.height_mm); out.extend_from_slice(setup_commands(format, first_h, opts).as_bytes()); let mut current_h = first_h; for c in &chunks { let h_mm = height_mm(c); if (h_mm - current_h).abs() > f32::EPSILON { out.extend_from_slice(format!("SIZE {} mm,{} mm\r\n", fmt_mm(format.width_mm), fmt_mm(h_mm)).as_bytes()); current_h = h_mm; } let (wb, data) = bitmap_bytes(c); let x = label_w.saturating_sub(c.width()) / 2; out.extend_from_slice(b"CLS\r\n"); out.extend_from_slice(format!("BITMAP {x},0,{wb},{},0,", c.height()).as_bytes()); out.extend_from_slice(&data); out.extend_from_slice(b"\r\nPRINT 1,1\r\n"); } out } /// ESC/POS bytes (from `EscPosEncoder`) → TSPL job for `format`. pub fn escpos_to_tspl(escpos: &[u8], source_width: u32, format: &LabelFormat, opts: TsplOptions) -> Vec { let scale = page_scale(source_width, format); let pages = render_escpos(escpos, source_width, scale); encode_pages(&pages, format, opts) } /// TSPL status query `!?` (manual p.82). pub const STATUS_QUERY: &[u8] = &[0x1B, b'!', b'?']; /// Settings that can be read back over a bidirectional link (manual p.211). pub const QUERY_PAPER_WIDTH: &str = "OUT GETSETTING$(\"CONFIG\",\"TSPL\",\"PAPER WIDTH\")\r\n"; pub const QUERY_PAPER_SIZE: &str = "OUT GETSETTING$(\"CONFIG\",\"TSPL\",\"PAPER SIZE\")\r\n"; pub const QUERY_GAP_SIZE: &str = "OUT GETSETTING$(\"CONFIG\",\"TSPL\",\"GAP SIZE\")\r\n"; pub const QUERY_DPI: &str = "OUT GETSETTING$(\"SYSTEM\",\"INFORMATION\",\"DPI\")\r\n"; /// Status byte meaning (manual p.82), `None` = ready. pub fn status_problem(byte: u8) -> Option { if byte == 0 || byte == 0x20 { return None; } Some(if byte & 0x01 != 0 { StatusProblem::HeadOpen } else if byte & 0x04 != 0 { StatusProblem::OutOfPaper } else if byte & 0x08 != 0 { StatusProblem::OutOfRibbon } else if byte & 0x02 != 0 { StatusProblem::PaperJam } else if byte & 0x10 != 0 { StatusProblem::Paused } else { StatusProblem::Other }) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum StatusProblem { HeadOpen, PaperJam, OutOfPaper, OutOfRibbon, Paused, Other, } /// Parse a length reply from GETSETTING$ into mm. Units are only trusted when /// explicit (`mm`, `inch`/`"`, `dot`); a bare number is assumed to be dots only /// when `dpmm` is known and the value is clearly in dots range. Returns `None` /// when unsure, so the dialog asks the user instead. pub fn parse_length_mm(reply: &str, dpmm: Option) -> Option { let r = reply.trim().trim_matches(char::from(0)).trim().to_ascii_lowercase(); let num: String = r .chars() .skip_while(|c| !c.is_ascii_digit()) .take_while(|c| c.is_ascii_digit() || *c == '.') .collect(); let v: f32 = num.parse().ok()?; if !v.is_finite() || v <= 0.0 { return None; } let mm = if r.contains("mm") { v } else if r.contains("inch") || r.contains('"') { v * 25.4 } else if r.contains("dot") { v / dpmm? as f32 } else { return None; }; Some(mm) } pub fn parse_dpi(reply: &str) -> Option { let n: String = reply.chars().filter(|c| c.is_ascii_digit()).collect(); match n.parse::().ok()? { 200 | 203 => Some(203), 300 => Some(300), 600 => Some(600), _ => None, } } #[cfg(test)] mod tests { use super::*; use crate::escpos::EscPosEncoder; use crate::io::PosMetadata; fn fmt(w: f32, h: f32) -> LabelFormat { LabelFormat { width_mm: w, height_mm: h, gap_mm: 3.0, media: MediaKind::Gap, dpi: 300, rotate_180: false } } fn split_cmds(job: &[u8]) -> Vec { // Text lines only (BITMAP data is binary): keep the line prefix up to data. let mut out = Vec::new(); let mut i = 0; while i < job.len() { let end = job[i..].windows(2).position(|w| w == b"\r\n").map(|p| i + p).unwrap_or(job.len()); let line = &job[i..end]; if line.starts_with(b"BITMAP ") { let hdr: Vec = line.iter().take_while(|_| true).copied().collect(); // header = first 5 commas let mut commas = 0; let mut k = 0; while k < hdr.len() && commas < 5 { if hdr[k] == b',' { commas += 1; } k += 1; } let head = String::from_utf8_lossy(&hdr[..k]).to_string(); let parts: Vec = head.trim_start_matches("BITMAP ").trim_end_matches(',').split(',').map(|s| s.parse().unwrap()).collect(); let data_len = parts[2] * parts[3]; out.push(head); i = i + k + data_len; assert_eq!(&job[i..i + 2], b"\r\n", "bitmap data length must match header"); i += 2; continue; } out.push(String::from_utf8_lossy(line).to_string()); i = end + 2; } out } #[test] fn header_matches_spec_syntax() { let s = setup_commands(&fmt(50.0, 30.0), 30.0, TsplOptions::default()); assert_eq!(s, "SIZE 50 mm,30 mm\r\nGAP 3 mm,0 mm\r\nDIRECTION 0,0\r\nREFERENCE 0,0\r\n"); let mut f = fmt(101.6, 25.4); f.media = MediaKind::BlackMark; f.gap_mm = 2.5; f.rotate_180 = true; let s = setup_commands(&f, 25.4, TsplOptions { calibrate: true }); assert_eq!( s, "SIZE 101.6 mm,25.4 mm\r\nBLINE 2.5 mm,0 mm\r\nBLINEDETECT 305,30\r\nDIRECTION 1,0\r\nREFERENCE 0,0\r\n" ); f.media = MediaKind::Continuous; let s = setup_commands(&f, 40.0, TsplOptions { calibrate: true }); assert!(s.contains("GAP 0,0\r\n") && !s.contains("DETECT")); let g = setup_commands(&fmt(50.0, 30.0), 30.0, TsplOptions { calibrate: true }); assert!(g.contains("GAPDETECT 360,36\r\n")); } #[test] fn bitmap_zero_is_black() { let mut img = GrayImage::from_pixel(10, 2, Luma([255])); img.put_pixel(0, 0, Luma([0])); img.put_pixel(9, 1, Luma([0])); let (wb, data) = bitmap_bytes(&img); assert_eq!(wb, 2); assert_eq!(data, vec![0x7F, 0xFF, 0xFF, 0xBF]); } #[test] fn full_job_structure() { let doc = crate::dsl::parse("# Hello\nWorld\n@barcode CODE128 ABC123\n@qr hi\n@cut\n").unwrap(); let md = PosMetadata { page_width_mm: 58.0, ..Default::default() }; let mut enc = EscPosEncoder::new(md.clone()); let esc = enc.encode_document(&doc).unwrap().to_vec(); let job = escpos_to_tspl(&esc, md.printable_dots() as u32, &fmt(100.0, 150.0), TsplOptions::default()); let cmds = split_cmds(&job); assert_eq!(cmds[0], "SIZE 100 mm,150 mm"); assert_eq!(cmds[1], "GAP 3 mm,0 mm"); assert_eq!(cmds[2], "DIRECTION 0,0"); assert_eq!(cmds[3], "REFERENCE 0,0"); assert_eq!(cmds[4], "CLS"); assert!(cmds[5].starts_with("BITMAP ")); assert_eq!(cmds[6], "PRINT 1,1"); assert_eq!(cmds.len(), 7); // 58 mm doc (384 source dots) at 300 dpi → 576 dots = 72 bytes, centred on 1200 dots. let parts: Vec = cmds[5][7..].trim_end_matches(',').split(',').map(|s| s.parse().unwrap()).collect(); assert_eq!(parts[2], 72); assert_eq!(parts[0], (1200 - 576) / 2); assert_eq!(parts[1], 0); assert_eq!(parts[4], 0); assert!(parts[3] > 100); } #[test] fn content_is_drawn() { let doc = crate::dsl::parse("HELLO\n").unwrap(); let md = PosMetadata { page_width_mm: 80.0, ..Default::default() }; let esc = EscPosEncoder::new(md.clone()).encode_document(&doc).unwrap().to_vec(); let pages = render_escpos(&esc, md.printable_dots() as u32, 1.0); assert_eq!(pages.len(), 1); let p = &pages[0]; assert_eq!(p.width(), 576); let dark = p.pixels().filter(|px| px.0[0] == 0).count(); assert!(dark > 100, "text must produce dots, got {dark}"); // Left aligned: nothing right of the 5 chars (60 dots). assert!(p.enumerate_pixels().all(|(x, _, px)| x < 64 || px.0[0] == 255)); } #[test] fn center_and_right_alignment() { for (dsl, check) in [(":center:\nX\n", 1u8), (":right:\nX\n", 2u8)] { let doc = crate::dsl::parse(dsl).unwrap(); let md = PosMetadata { page_width_mm: 80.0, ..Default::default() }; let esc = EscPosEncoder::new(md.clone()).encode_document(&doc).unwrap().to_vec(); let p = &render_escpos(&esc, 576, 1.0)[0]; let xs: Vec = p.enumerate_pixels().filter(|(_, _, px)| px.0[0] == 0).map(|(x, _, _)| x).collect(); let min = *xs.iter().min().unwrap(); if check == 1 { assert!((276..300).contains(&min), "center min {min}"); } else { assert!(min >= 560, "right min {min}"); } } } #[test] fn cut_starts_new_label_and_trailing_feed_is_trimmed() { let doc = crate::dsl::parse("A\n@feed 5\n@cut\nB\n@cut\n@feed 3\n@cut\n").unwrap(); let md = PosMetadata { page_width_mm: 58.0, ..Default::default() }; let esc = EscPosEncoder::new(md.clone()).encode_document(&doc).unwrap().to_vec(); let pages = render_escpos(&esc, 384, 1.5); assert_eq!(pages.len(), 2, "blank page after last cut is skipped"); assert!(pages[0].height() < 40, "feed before cut trimmed: {}", pages[0].height()); let job = encode_pages(&pages, &fmt(60.0, 40.0), TsplOptions::default()); assert_eq!(split_cmds(&job).iter().filter(|c| *c == "PRINT 1,1").count(), 2); } #[test] fn tall_page_splits_over_labels() { let img = GrayImage::from_pixel(100, 250, Luma([0])); let f = LabelFormat { width_mm: 20.0, height_mm: 10.0, gap_mm: 2.0, media: MediaKind::Gap, dpi: 203, rotate_180: false }; // 10 mm @ 8 dots/mm = 80 dots → 4 labels (80+80+80+10). let job = encode_pages(&[img], &f, TsplOptions::default()); let cmds = split_cmds(&job); let bitmaps: Vec<&String> = cmds.iter().filter(|c| c.starts_with("BITMAP")).collect(); assert_eq!(bitmaps.len(), 4); assert_eq!(bitmaps[0].as_str(), "BITMAP 30,0,13,80,0,"); assert_eq!(bitmaps[3].as_str(), "BITMAP 30,0,13,10,0,"); } #[test] fn continuous_uses_content_height() { let img = GrayImage::from_pixel(80, 400, Luma([0])); let f = LabelFormat { width_mm: 10.0, height_mm: 10.0, gap_mm: 0.0, media: MediaKind::Continuous, dpi: 203, rotate_180: false }; let cmds = split_cmds(&encode_pages(&[img], &f, TsplOptions::default())); assert_eq!(cmds[0], "SIZE 10 mm,50 mm"); assert_eq!(cmds[1], "GAP 0,0"); } #[test] fn wide_doc_shrinks_to_label() { let f = fmt(40.0, 30.0); let s = page_scale(576, &f); assert!((576.0 * s - 480.0).abs() < 0.5); assert!((page_scale(384, &fmt(100.0, 50.0)) - 1.5).abs() < 1e-6); } #[test] fn barcodes_and_raster_render() { let doc = crate::dsl::parse("@barcode CODE128 ABC\n@barcode RASTER CODE128 ABC\n@qr RASTER hi scale=4\n").unwrap(); let md = PosMetadata { page_width_mm: 58.0, ..Default::default() }; let esc = EscPosEncoder::new(md.clone()).encode_document(&doc).unwrap().to_vec(); let pages = render_escpos(&esc, 384, 1.5); assert_eq!(pages.len(), 1); assert!(pages[0].height() > 200); assert_eq!(pages[0].width(), 576); } #[test] fn parses_replies_conservatively() { assert_eq!(parse_length_mm("50.00 mm", None), Some(50.0)); assert_eq!(parse_length_mm("2.00 inch", None), Some(50.8)); assert_eq!(parse_length_mm("600 dot", Some(12)), Some(50.0)); assert_eq!(parse_length_mm("600 dot", None), None); assert_eq!(parse_length_mm("600", Some(12)), None); assert_eq!(parse_length_mm("", None), None); assert_eq!(parse_dpi("300\r\n"), Some(300)); assert_eq!(parse_dpi("203"), Some(203)); assert_eq!(parse_dpi("x"), None); assert_eq!(status_problem(0), None); assert_eq!(status_problem(0x04), Some(StatusProblem::OutOfPaper)); assert_eq!(status_problem(0x05), Some(StatusProblem::HeadOpen)); } }