BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

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