BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

c3fd0b10 History
escpos.rs 22.4 KiB Download Raw
1use std::path::Path;
2
3use image::GrayImage;
4
5use crate::bitmap_font::{self, MixedSeg};
6use crate::dsl::{
7 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode,
8};
9use crate::io::PosMetadata;
10use crate::raster::{self, RasterError};
11use crate::text_wrap::{self, TextWrapStyle};
12
13#[derive(Debug)]
14pub enum EscPosError {
15 Image(String),
16 Barcode(String),
17 Raster(RasterError),
18 Io(String),
19}
20
21pub struct EscPosEncoder {
22 buffer: Vec<u8>,
23 metadata: PosMetadata,
24 base_dir: Option<std::path::PathBuf>,
25}
26
27impl EscPosEncoder {
28 pub fn new(metadata: PosMetadata) -> Self {
29 Self {
30 buffer: Vec::new(),
31 metadata,
32 base_dir: None,
33 }
34 }
35
36 pub fn with_base_dir(mut self, base_dir: impl AsRef<Path>) -> Self {
37 self.base_dir = Some(base_dir.as_ref().to_path_buf());
38 self
39 }
40
41 pub fn encode_document(&mut self, document: &Document) -> Result<&[u8], EscPosError> {
42 self.buffer.clear();
43 self.init();
44 for block in &document.blocks {
45 self.encode_block(block)?;
46 }
47 Ok(&self.buffer)
48 }
49
50 pub fn into_bytes(self) -> Vec<u8> {
51 self.buffer
52 }
53
54 fn init(&mut self) {
55 self.buffer.extend_from_slice(&[0x1B, b'@']);
56 self.buffer.extend_from_slice(&[0x1B, b't', 0]);
57 }
58
59 fn encode_block(&mut self, block: &Block) -> Result<(), EscPosError> {
60 match block {
61 Block::Paragraph { align, inlines } => {
62 self.set_align(*align);
63 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
64 if bitmap_font::inlines_have_checkbox(inlines) {
65 self.encode_mixed_inlines(inlines, cols, "", "")?;
66 } else {
67 let line = inlines_to_plain(inlines);
68 for part in text_wrap::wrap_text(&line, cols) {
69 self.writeln(&part);
70 }
71 }
72 }
73 Block::List { align, items } => {
74 self.set_align(*align);
75 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
76 for item in items {
77 if bitmap_font::inlines_have_checkbox(item) {
78 self.encode_mixed_inlines(
79 item,
80 cols,
81 text_wrap::BULLET_FIRST_PREFIX,
82 text_wrap::BULLET_NEXT_PREFIX,
83 )?;
84 } else {
85 let line = inlines_to_plain(item);
86 for part in text_wrap::wrap_bullet_item(&line, cols) {
87 self.writeln(&part);
88 }
89 }
90 }
91 }
92 Block::Heading { level, align, inlines } => {
93 self.set_align(*align);
94 let wrap_style = if *level == 1 {
95 TextWrapStyle::Heading1
96 } else {
97 TextWrapStyle::Heading2
98 };
99 let cols = text_wrap::wrap_cols(&self.metadata, wrap_style);
100 if bitmap_font::inlines_have_checkbox(inlines) {
101 // Raster path already draws glyphs; skip size/bold toggles.
102 self.encode_mixed_inlines(inlines, cols, "", "")?;
103 } else {
104 let wrapped = text_wrap::wrap_text(&inlines_to_plain(inlines), cols);
105 if *level == 1 {
106 self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
107 } else {
108 self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
109 }
110 for part in &wrapped {
111 self.writeln(part);
112 }
113 if *level == 1 {
114 self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
115 } else {
116 self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
117 }
118 }
119 }
120 Block::Rule => {
121 let width = self.metadata.chars_per_line() as usize;
122 self.writeln(&"-".repeat(width));
123 }
124 Block::Feed(n) => self.feed(*n),
125 Block::Cut => self.cut(),
126 Block::Image { path, width, align } => {
127 self.set_align(*align);
128 self.encode_image(path, *width)?;
129 }
130 Block::Barcode {
131 mode,
132 symbology,
133 data,
134 height,
135 align,
136 show_text,
137 } => {
138 self.set_align(*align);
139 match mode {
140 BarcodeMode::Native => {
141 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
142 }
143 BarcodeMode::Raster => {
144 let img = raster::render_barcode(*symbology, data, *height as u32)
145 .map_err(EscPosError::Raster)?;
146 let target = self.metadata.printable_dots() as u32;
147 let img = raster::scale_gray_to_print_width(img, target);
148 self.encode_gray_raster(&img, ImageWidth::Default)?;
149 }
150 }
151 }
152 Block::Qr {
153 mode,
154 data,
155 size,
156 ecc,
157 version,
158 align,
159 } => {
160 self.set_align(*align);
161 match mode {
162 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
163 QrMode::Raster => {
164 let img = raster::render_qr(data, *version, *ecc, *size as u32)
165 .map_err(EscPosError::Raster)?;
166 self.encode_gray_raster(&img, ImageWidth::Default)?;
167 }
168 }
169 }
170 Block::Date { format, align } => {
171 self.set_align(*align);
172 let text = crate::datetime::format_date(format.as_deref());
173 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
174 for part in text_wrap::wrap_text(&text, cols) {
175 self.writeln(&part);
176 }
177 }
178 Block::Time { format, align } => {
179 self.set_align(*align);
180 let text = crate::datetime::format_time(*format);
181 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
182 for part in text_wrap::wrap_text(&text, cols) {
183 self.writeln(&part);
184 }
185 }
186 }
187 Ok(())
188 }
189
190 fn set_align(&mut self, align: Align) {
191 let n = match align {
192 Align::Left => 0,
193 Align::Center => 1,
194 Align::Right => 2,
195 };
196 self.buffer.extend_from_slice(&[0x1B, b'a', n]);
197 }
198
199 fn writeln(&mut self, text: &str) {
200 self.buffer.extend_from_slice(text.as_bytes());
201 self.buffer.push(b'\n');
202 }
203
204 fn encode_mixed_inlines(
205 &mut self,
206 inlines: &[Inline],
207 cols: usize,
208 first_prefix: &str,
209 next_prefix: &str,
210 ) -> Result<(), EscPosError> {
211 let segs = bitmap_font::segments_from_inlines(inlines);
212 let lines = if first_prefix.is_empty() && next_prefix.is_empty() {
213 bitmap_font::wrap_segments(&segs, cols)
214 } else {
215 bitmap_font::wrap_segments_hanging(&segs, cols, first_prefix, next_prefix)
216 };
217 for line in lines {
218 self.encode_mixed_line(&line)?;
219 }
220 Ok(())
221 }
222
223 fn encode_mixed_line(&mut self, segs: &[MixedSeg]) -> Result<(), EscPosError> {
224 let img = bitmap_font::render_mixed_line(segs);
225 let w = img.width().max(1) as u16;
226 self.encode_gray_raster(&img, ImageWidth::Dots(w))
227 }
228
229 fn feed(&mut self, lines: u8) {
230 if lines == 0 {
231 return;
232 }
233 // ESC d — reliable paper feed after raster graphics (print-bridge uses this too).
234 self.buffer.extend_from_slice(&[0x1B, b'd', lines]);
235 }
236
237 fn cut(&mut self) {
238 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
239 }
240
241 fn encode_barcode_native(
242 &mut self,
243 symbology: BarcodeSymbology,
244 data: &str,
245 height: u8,
246 show_text: bool,
247 ) -> Result<(), EscPosError> {
248 self.buffer.extend_from_slice(&[0x1D, b'h', height]);
249 self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]);
250 // Widest module width (GS w 6) for easier scanning.
251 self.buffer.extend_from_slice(&[0x1D, b'w', 6]);
252 match symbology {
253 BarcodeSymbology::Code128 => {
254 let bytes = data.as_bytes();
255 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
256 self.buffer.extend_from_slice(bytes);
257 }
258 BarcodeSymbology::UpcA => {
259 if data.len() != 11 && data.len() != 12 {
260 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
261 }
262 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
263 self.buffer.extend_from_slice(data.as_bytes());
264 }
265 BarcodeSymbology::UpcE => {
266 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
267 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
268 }
269 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
270 self.buffer.extend_from_slice(data.as_bytes());
271 }
272 BarcodeSymbology::Ean13 => {
273 if data.len() != 12 && data.len() != 13 {
274 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
275 }
276 self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]);
277 self.buffer.extend_from_slice(data.as_bytes());
278 }
279 BarcodeSymbology::Ean8 => {
280 if data.len() != 7 && data.len() != 8 {
281 return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into()));
282 }
283 self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]);
284 self.buffer.extend_from_slice(data.as_bytes());
285 }
286 BarcodeSymbology::Code39 => {
287 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
288 self.buffer.extend_from_slice(data.as_bytes());
289 }
290 BarcodeSymbology::Itf => {
291 if data.len() % 2 != 0 {
292 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
293 }
294 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
295 self.buffer.extend_from_slice(data.as_bytes());
296 }
297 BarcodeSymbology::Codabar => {
298 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
299 self.buffer.extend_from_slice(data.as_bytes());
300 }
301 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
302 return Err(EscPosError::Barcode(format!(
303 "{} requires RASTER mode",
304 symbology.as_str()
305 )));
306 }
307 }
308 self.buffer.push(b'\n');
309 Ok(())
310 }
311
312 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
313 let ecc_level = match ecc {
314 QrEcc::L => 48,
315 QrEcc::M => 49,
316 QrEcc::Q => 50,
317 QrEcc::H => 51,
318 };
319 let store = data.as_bytes();
320 let len = store.len() + 3;
321 let p_l = (len & 0xFF) as u8;
322 let p_h = ((len >> 8) & 0xFF) as u8;
323
324 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
325 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
326 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
327 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
328 self.buffer.extend_from_slice(store);
329 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
330 self.buffer.push(b'\n');
331 Ok(())
332 }
333
334 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
335 let resolved = resolve_image_path(path, self.base_dir.as_deref());
336 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
337 self.encode_gray_raster(&img.to_luma8(), width)
338 }
339
340 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
341 let (w, h) = gray.dimensions();
342 let target_width = match width {
343 ImageWidth::Percent(pct) => {
344 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
345 }
346 ImageWidth::Dots(d) => d as u32,
347 ImageWidth::Default => self.metadata.printable_dots() as u32,
348 };
349 let new_w = target_width.min(w).max(1);
350 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
351 let resized = image::imageops::resize(
352 gray,
353 new_w,
354 new_h,
355 image::imageops::FilterType::Nearest,
356 );
357 let bytes_per_row = ((new_w + 7) / 8) as usize;
358 let mut raster = vec![0u8; bytes_per_row * new_h as usize];
359 for y in 0..new_h {
360 for x in 0..new_w {
361 let pixel = resized.get_pixel(x, y).0[0];
362 if pixel < 128 {
363 let byte_index = (y as usize * bytes_per_row) + (x as usize / 8);
364 let bit = 7 - (x % 8);
365 raster[byte_index] |= 1 << bit;
366 }
367 }
368 }
369 let x_l = (bytes_per_row & 0xFF) as u8;
370 let x_h = ((bytes_per_row >> 8) & 0xFF) as u8;
371 let y_l = (new_h & 0xFF) as u8;
372 let y_h = ((new_h >> 8) & 0xFF) as u8;
373 // GS v 0 normal raster — same header as print-bridge / node-escpos:
374 // 1D 76 30 00, xL xH (bytes/row), yL yH (dots), then bitmap bytes.
375 self.buffer
376 .extend_from_slice(&[0x1D, b'v', 0x30, 0x00, x_l, x_h, y_l, y_h]);
377 self.buffer.extend_from_slice(&raster);
378 // LF prints/flushes the raster; without it the next graphic can butt against this one.
379 self.buffer.push(b'\n');
380 Ok(())
381 }
382}
383
384fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> std::path::PathBuf {
385 let p = Path::new(path);
386 if p.is_absolute() {
387 p.to_path_buf()
388 } else if let Some(base) = base_dir {
389 base.join(p)
390 } else {
391 p.to_path_buf()
392 }
393}
394
395fn inlines_to_plain(inlines: &[Inline]) -> String {
396 let mut out = String::new();
397 for inline in inlines {
398 match inline {
399 Inline::Text(t) => out.push_str(t),
400 Inline::Param(t) => out.push_str(t),
401 Inline::Checkbox { checked } => out.push_str(crate::dsl::checkbox_glyph(*checked)),
402 }
403 }
404 out
405}
406
407#[cfg(test)]
408mod tests {
409 use super::*;
410 use crate::dsl::{parse, Block};
411
412 #[test]
413 fn heading_wraps_like_preview_on_narrow_paper() {
414 let doc = parse("# Proof of Transfer").unwrap();
415 let mut enc = EscPosEncoder::new(PosMetadata {
416 page_width_mm: 53.0,
417 ..Default::default()
418 });
419 let bytes = enc.encode_document(&doc).unwrap();
420 let text = String::from_utf8_lossy(bytes);
421 assert!(
422 text.contains("Proof of\n"),
423 "expected word wrap before Transfer, got: {text}"
424 );
425 assert!(
426 text.contains("Transfer\n"),
427 "expected wrapped second line, got: {text}"
428 );
429 }
430
431 #[test]
432 fn encodes_bullet_list_with_hanging_indent() {
433 let doc = parse("- this is a long line").unwrap();
434 let meta = PosMetadata {
435 chars_per_line: Some(15),
436 ..Default::default()
437 };
438 let mut enc = EscPosEncoder::new(meta);
439 let bytes = enc.encode_document(&doc).unwrap();
440 let text = String::from_utf8_lossy(bytes);
441 assert!(text.contains("* this is a\n"));
442 assert!(text.contains(" long line\n"));
443 }
444
445 #[test]
446 fn encodes_inline_checkboxes_as_raster() {
447 let doc = parse("[] [ ] [x]").unwrap();
448 let mut enc = EscPosEncoder::new(PosMetadata::default());
449 let bytes = enc.encode_document(&doc).unwrap();
450 assert!(
451 bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
452 "checkbox lines should be GS v 0 rasters, got {} bytes",
453 bytes.len()
454 );
455 let text = String::from_utf8_lossy(bytes);
456 assert!(
457 !text.contains("[ ]") && !text.contains("[x]"),
458 "should not fall back to ASCII checkbox glyphs"
459 );
460 }
461
462 #[test]
463 fn encodes_init_and_text() {
464 let doc = parse("Hello").unwrap();
465 let mut enc = EscPosEncoder::new(PosMetadata::default());
466 let bytes = enc.encode_document(&doc).unwrap();
467 assert_eq!(&bytes[0..2], &[0x1B, b'@']);
468 assert!(bytes.windows(5).any(|w| w == b"Hello"));
469 }
470
471 #[test]
472 fn encodes_raster_barcode() {
473 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
474 let mut enc = EscPosEncoder::new(PosMetadata::default());
475 let bytes = enc.encode_document(&doc).unwrap();
476 assert!(
477 bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
478 "expected GS v 0 raster header"
479 );
480 }
481
482 #[test]
483 fn raster_header_matches_print_bridge_format() {
484 let doc = parse("@barcode RASTER CODE128 X").unwrap();
485 let meta = PosMetadata {
486 page_width_mm: 58.0,
487 ..Default::default()
488 };
489 let mut enc = EscPosEncoder::new(meta.clone());
490 let bytes = enc.encode_document(&doc).unwrap();
491 let pos = bytes
492 .windows(4)
493 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
494 .expect("raster header");
495 assert_eq!(&bytes[pos..pos + 4], &[0x1D, b'v', 0x30, 0x00]);
496 let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]);
497 let expected_bytes = ((meta.printable_dots() as u32 + 7) / 8) as u16;
498 assert_eq!(
499 x_bytes, expected_bytes,
500 "barcode raster should span full printable width"
501 );
502 let y_dots = u16::from_le_bytes([bytes[pos + 6], bytes[pos + 7]]);
503 assert!(y_dots > 0);
504 }
505
506 #[test]
507 fn encodes_centered_heading() {
508 let doc = parse(":center:\n# Hello").unwrap();
509 let mut enc = EscPosEncoder::new(PosMetadata::default());
510 let bytes = enc.encode_document(&doc).unwrap();
511 assert!(bytes.windows(3).any(|w| w == [0x1B, b'a', 1]));
512 assert!(bytes.windows(5).any(|w| w == b"Hello"));
513 }
514
515 #[test]
516 fn encodes_date_directive() {
517 let doc = parse("@date DD-YYYY-MM").unwrap();
518 let mut enc = EscPosEncoder::new(PosMetadata::default());
519 let bytes = enc.encode_document(&doc).unwrap();
520 let text = String::from_utf8_lossy(bytes);
521 assert!(text.contains('-'));
522 }
523
524 #[test]
525 fn encodes_cut_directive() {
526 let doc = parse("@cut").unwrap();
527 let mut enc = EscPosEncoder::new(PosMetadata::default());
528 let bytes = enc.encode_document(&doc).unwrap();
529 assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
530 }
531
532 #[test]
533 fn feed_uses_esc_d_for_blank_lines() {
534 let doc = parse("A\n\nB").unwrap();
535 let mut enc = EscPosEncoder::new(PosMetadata::default());
536 let bytes = enc.encode_document(&doc).unwrap();
537 assert!(bytes.windows(3).any(|w| w == [0x1B, b'd', 1]));
538 }
539
540 #[test]
541 fn blank_line_between_barcode_and_qr_is_ordered_feed() {
542 let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap();
543 assert!(matches!(
544 doc.blocks.as_slice(),
545 [
546 Block::Barcode { .. },
547 Block::Feed(1),
548 Block::Qr { .. },
549 ]
550 ));
551 }
552
553 #[test]
554 fn blank_line_between_graphics_feeds_on_print() {
555 let doc = parse("@barcode RASTER CODE128 X\n\n@qr RASTER Y scale=4").unwrap();
556 let mut enc = EscPosEncoder::new(PosMetadata {
557 page_width_mm: 53.0,
558 ..Default::default()
559 });
560 let bytes = enc.encode_document(&doc).unwrap();
561 let raster_positions: Vec<_> = bytes
562 .windows(4)
563 .enumerate()
564 .filter(|(_, w)| *w == [0x1D, b'v', 0x30, 0x00])
565 .map(|(i, _)| i)
566 .collect();
567 assert_eq!(raster_positions.len(), 2);
568 let between = &bytes[raster_positions[0]..raster_positions[1]];
569 assert!(
570 between.windows(3).any(|w| w == [0x1B, b'd', 1]),
571 "expected ESC d feed between raster graphics, got {} bytes",
572 between.len()
573 );
574 }
575
576 #[test]
577 fn raster_graphic_ends_with_line_feed() {
578 let doc = parse("@barcode RASTER CODE128 X").unwrap();
579 let mut enc = EscPosEncoder::new(PosMetadata::default());
580 let bytes = enc.encode_document(&doc).unwrap();
581 let raster_start = bytes
582 .windows(4)
583 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
584 .expect("raster header");
585 assert!(
586 bytes[raster_start..].contains(&b'\n'),
587 "expected LF after raster data"
588 );
589 }
590
591 #[test]
592 fn does_not_auto_cut_without_directive() {
593 let doc = parse("x").unwrap();
594 let mut enc = EscPosEncoder::new(PosMetadata::default());
595 let bytes = enc.encode_document(&doc).unwrap();
596 assert!(!bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
597 }
598}