BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

escpos.rs 22.6 KiB Download Raw
1use std::path::Path;
2
3use image::GrayImage;
4
5use crate::align_row::{columns_from_parts, layout_aligned_row_or_lines};
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 let line = inlines_to_plain(inlines);
65 for part in text_wrap::wrap_text(&line, cols) {
66 self.writeln(&part);
67 }
68 }
69 Block::AlignedRow { parts } => {
70 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
71 let plain_parts: Vec<(Align, String)> = parts
72 .iter()
73 .map(|(align, inlines)| (*align, inlines_to_plain(inlines)))
74 .collect();
75 let columns = columns_from_parts(&plain_parts);
76 for (align, line) in layout_aligned_row_or_lines(&columns, cols) {
77 self.set_align(align);
78 for part in text_wrap::wrap_text(&line, cols) {
79 self.writeln(&part);
80 }
81 }
82 }
83 Block::List { align, items } => {
84 self.set_align(*align);
85 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
86 for item in items {
87 let line = inlines_to_plain(&item.inlines);
88 for part in text_wrap::wrap_bullet_item_at_depth(&line, cols, item.depth) {
89 self.writeln(&part);
90 }
91 }
92 }
93 Block::Heading { level, align, inlines } => {
94 self.set_align(*align);
95 let wrap_style = if *level == 1 {
96 TextWrapStyle::Heading1
97 } else {
98 TextWrapStyle::Heading2
99 };
100 let cols = text_wrap::wrap_cols(&self.metadata, wrap_style);
101 let wrapped = text_wrap::wrap_text(&inlines_to_plain(inlines), cols);
102 if *level == 1 {
103 self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
104 } else {
105 self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
106 }
107 for part in &wrapped {
108 self.writeln(part);
109 }
110 if *level == 1 {
111 self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
112 } else {
113 self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
114 }
115 }
116 Block::Rule => {
117 let width = self.metadata.chars_per_line() as usize;
118 self.writeln(&"-".repeat(width));
119 }
120 Block::Feed(n) => self.feed(*n),
121 Block::Cut => self.cut(),
122 Block::Image { path, width, align } => {
123 self.set_align(*align);
124 self.encode_image(path, *width)?;
125 }
126 Block::Barcode {
127 mode,
128 symbology,
129 data,
130 height,
131 align,
132 show_text,
133 } => {
134 self.set_align(*align);
135 match mode {
136 BarcodeMode::Native => {
137 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
138 }
139 BarcodeMode::Raster => {
140 let img = raster::render_barcode(*symbology, data, *height as u32)
141 .map_err(EscPosError::Raster)?;
142 let target = self.metadata.printable_dots() as u32;
143 let img = raster::scale_gray_to_print_width(img, target);
144 self.encode_gray_raster(&img, ImageWidth::Default)?;
145 }
146 }
147 }
148 Block::Qr {
149 mode,
150 data,
151 size,
152 ecc,
153 version,
154 align,
155 } => {
156 self.set_align(*align);
157 match mode {
158 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
159 QrMode::Raster => {
160 let img = raster::render_qr(data, *version, *ecc, *size as u32)
161 .map_err(EscPosError::Raster)?;
162 self.encode_gray_raster(&img, ImageWidth::Default)?;
163 }
164 }
165 }
166 Block::Date { format, align } => {
167 self.set_align(*align);
168 let text = crate::datetime::format_date(format.as_deref());
169 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
170 for part in text_wrap::wrap_text(&text, cols) {
171 self.writeln(&part);
172 }
173 }
174 Block::Time { format, align } => {
175 self.set_align(*align);
176 let text = crate::datetime::format_time(*format);
177 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
178 for part in text_wrap::wrap_text(&text, cols) {
179 self.writeln(&part);
180 }
181 }
182 }
183 Ok(())
184 }
185
186 fn set_align(&mut self, align: Align) {
187 let n = match align {
188 Align::Left => 0,
189 Align::Center => 1,
190 Align::Right => 2,
191 };
192 self.buffer.extend_from_slice(&[0x1B, b'a', n]);
193 }
194
195 fn writeln(&mut self, text: &str) {
196 // ESC/POS text path is CP437; keep output to ASCII bytes.
197 for ch in text.chars() {
198 if ch.is_ascii() {
199 self.buffer.push(ch as u8);
200 } else {
201 self.buffer.push(b'?');
202 }
203 }
204 self.buffer.push(b'\n');
205 }
206
207 fn feed(&mut self, lines: u8) {
208 if lines == 0 {
209 return;
210 }
211 // ESC d — reliable paper feed after raster graphics (print-bridge uses this too).
212 self.buffer.extend_from_slice(&[0x1B, b'd', lines]);
213 }
214
215 fn cut(&mut self) {
216 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
217 }
218
219 fn encode_barcode_native(
220 &mut self,
221 symbology: BarcodeSymbology,
222 data: &str,
223 height: u8,
224 show_text: bool,
225 ) -> Result<(), EscPosError> {
226 self.buffer.extend_from_slice(&[0x1D, b'h', height]);
227 self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]);
228 // Widest module width (GS w 6) for easier scanning.
229 self.buffer.extend_from_slice(&[0x1D, b'w', 6]);
230 match symbology {
231 BarcodeSymbology::Code128 => {
232 let bytes = data.as_bytes();
233 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
234 self.buffer.extend_from_slice(bytes);
235 }
236 BarcodeSymbology::UpcA => {
237 if data.len() != 11 && data.len() != 12 {
238 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
239 }
240 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
241 self.buffer.extend_from_slice(data.as_bytes());
242 }
243 BarcodeSymbology::UpcE => {
244 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
245 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
246 }
247 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
248 self.buffer.extend_from_slice(data.as_bytes());
249 }
250 BarcodeSymbology::Ean13 => {
251 if data.len() != 12 && data.len() != 13 {
252 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
253 }
254 self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]);
255 self.buffer.extend_from_slice(data.as_bytes());
256 }
257 BarcodeSymbology::Ean8 => {
258 if data.len() != 7 && data.len() != 8 {
259 return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into()));
260 }
261 self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]);
262 self.buffer.extend_from_slice(data.as_bytes());
263 }
264 BarcodeSymbology::Code39 => {
265 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
266 self.buffer.extend_from_slice(data.as_bytes());
267 }
268 BarcodeSymbology::Itf => {
269 if data.len() % 2 != 0 {
270 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
271 }
272 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
273 self.buffer.extend_from_slice(data.as_bytes());
274 }
275 BarcodeSymbology::Codabar => {
276 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
277 self.buffer.extend_from_slice(data.as_bytes());
278 }
279 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
280 return Err(EscPosError::Barcode(format!(
281 "{} requires RASTER mode",
282 symbology.as_str()
283 )));
284 }
285 }
286 self.buffer.push(b'\n');
287 Ok(())
288 }
289
290 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
291 let ecc_level = match ecc {
292 QrEcc::L => 48,
293 QrEcc::M => 49,
294 QrEcc::Q => 50,
295 QrEcc::H => 51,
296 };
297 let store = data.as_bytes();
298 let len = store.len() + 3;
299 let p_l = (len & 0xFF) as u8;
300 let p_h = ((len >> 8) & 0xFF) as u8;
301
302 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
303 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
304 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
305 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
306 self.buffer.extend_from_slice(store);
307 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
308 self.buffer.push(b'\n');
309 Ok(())
310 }
311
312 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
313 let img = crate::image_load::load_image(path, self.base_dir.as_deref())
314 .map_err(|e| EscPosError::Image(e.to_string()))?;
315 self.encode_gray_raster(&img.to_luma8(), width)
316 }
317
318 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
319 let (w, h) = gray.dimensions();
320 let target_width = match width {
321 ImageWidth::Percent(pct) => {
322 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
323 }
324 ImageWidth::Dots(d) => d as u32,
325 ImageWidth::Default => self.metadata.printable_dots() as u32,
326 };
327 let new_w = target_width.min(w).max(1);
328 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
329 let resized = image::imageops::resize(
330 gray,
331 new_w,
332 new_h,
333 image::imageops::FilterType::Nearest,
334 );
335 let bytes_per_row = ((new_w + 7) / 8) as usize;
336 let mut raster = vec![0u8; bytes_per_row * new_h as usize];
337 for y in 0..new_h {
338 for x in 0..new_w {
339 let pixel = resized.get_pixel(x, y).0[0];
340 if pixel < 128 {
341 let byte_index = (y as usize * bytes_per_row) + (x as usize / 8);
342 let bit = 7 - (x % 8);
343 raster[byte_index] |= 1 << bit;
344 }
345 }
346 }
347 let x_l = (bytes_per_row & 0xFF) as u8;
348 let x_h = ((bytes_per_row >> 8) & 0xFF) as u8;
349 let y_l = (new_h & 0xFF) as u8;
350 let y_h = ((new_h >> 8) & 0xFF) as u8;
351 // GS v 0 normal raster — same header as print-bridge / node-escpos:
352 // 1D 76 30 00, xL xH (bytes/row), yL yH (dots), then bitmap bytes.
353 self.buffer
354 .extend_from_slice(&[0x1D, b'v', 0x30, 0x00, x_l, x_h, y_l, y_h]);
355 self.buffer.extend_from_slice(&raster);
356 // LF prints/flushes the raster; without it the next graphic can butt against this one.
357 self.buffer.push(b'\n');
358 Ok(())
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_nested_bullet_list() {
414 let doc = parse("- outer\n - inner").unwrap();
415 let mut enc = EscPosEncoder::new(PosMetadata::default());
416 let bytes = enc.encode_document(&doc).unwrap();
417 let text = String::from_utf8_lossy(bytes);
418 assert!(text.contains("* outer\n"));
419 assert!(text.contains(" - inner\n"));
420 }
421
422 #[test]
423 fn encodes_inline_checkboxes_as_ascii() {
424 let doc = parse("[] hello [x]").unwrap();
425 let mut enc = EscPosEncoder::new(PosMetadata::default());
426 let bytes = enc.encode_document(&doc).unwrap();
427 let text = String::from_utf8_lossy(bytes);
428 assert!(
429 text.contains("[ ] hello [x]\n"),
430 "expected ASCII checkbox glyphs, got: {text:?}"
431 );
432 }
433
434 #[test]
435 fn encodes_init_and_text() {
436 let doc = parse("Hello").unwrap();
437 let mut enc = EscPosEncoder::new(PosMetadata::default());
438 let bytes = enc.encode_document(&doc).unwrap();
439 assert_eq!(&bytes[0..2], &[0x1B, b'@']);
440 assert!(bytes.windows(5).any(|w| w == b"Hello"));
441 }
442
443 #[test]
444 fn encodes_raster_barcode() {
445 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
446 let mut enc = EscPosEncoder::new(PosMetadata::default());
447 let bytes = enc.encode_document(&doc).unwrap();
448 assert!(
449 bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
450 "expected GS v 0 raster header"
451 );
452 }
453
454 #[test]
455 fn raster_header_matches_print_bridge_format() {
456 let doc = parse("@barcode RASTER CODE128 X").unwrap();
457 let meta = PosMetadata {
458 page_width_mm: 58.0,
459 ..Default::default()
460 };
461 let mut enc = EscPosEncoder::new(meta.clone());
462 let bytes = enc.encode_document(&doc).unwrap();
463 let pos = bytes
464 .windows(4)
465 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
466 .expect("raster header");
467 assert_eq!(&bytes[pos..pos + 4], &[0x1D, b'v', 0x30, 0x00]);
468 let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]);
469 let expected_bytes = ((meta.printable_dots() as u32 + 7) / 8) as u16;
470 assert_eq!(
471 x_bytes, expected_bytes,
472 "barcode raster should span full printable width"
473 );
474 let y_dots = u16::from_le_bytes([bytes[pos + 6], bytes[pos + 7]]);
475 assert!(y_dots > 0);
476 }
477
478 #[test]
479 fn encodes_centered_heading() {
480 let doc = parse(":center:\n# Hello").unwrap();
481 let mut enc = EscPosEncoder::new(PosMetadata::default());
482 let bytes = enc.encode_document(&doc).unwrap();
483 assert!(bytes.windows(3).any(|w| w == [0x1B, b'a', 1]));
484 assert!(bytes.windows(5).any(|w| w == b"Hello"));
485 }
486
487 #[test]
488 fn encodes_inline_left_right_as_one_padded_line() {
489 let doc = parse(":left:appel:right:10").unwrap();
490 let mut enc = EscPosEncoder::new(PosMetadata {
491 chars_per_line: Some(32),
492 ..Default::default()
493 });
494 let bytes = enc.encode_document(&doc).unwrap();
495 let text = String::from_utf8_lossy(bytes);
496 let expected = format!("appel{}10\n", " ".repeat(25));
497 assert!(
498 text.contains(&expected),
499 "expected one padded line, got: {text:?}"
500 );
501 assert!(
502 !text.contains("appel\n"),
503 "left segment must not be its own line: {text:?}"
504 );
505 }
506
507 #[test]
508 fn encodes_right_before_left_reordered() {
509 let doc = parse(":right:10:left:appel").unwrap();
510 let mut enc = EscPosEncoder::new(PosMetadata {
511 chars_per_line: Some(32),
512 ..Default::default()
513 });
514 let bytes = enc.encode_document(&doc).unwrap();
515 let text = String::from_utf8_lossy(bytes);
516 assert!(text.contains(&format!("appel{}10\n", " ".repeat(25))));
517 }
518
519 #[test]
520 fn encodes_date_directive() {
521 let doc = parse("@date DD-YYYY-MM").unwrap();
522 let mut enc = EscPosEncoder::new(PosMetadata::default());
523 let bytes = enc.encode_document(&doc).unwrap();
524 let text = String::from_utf8_lossy(bytes);
525 assert!(text.contains('-'));
526 }
527
528 #[test]
529 fn encodes_cut_directive() {
530 let doc = parse("@cut").unwrap();
531 let mut enc = EscPosEncoder::new(PosMetadata::default());
532 let bytes = enc.encode_document(&doc).unwrap();
533 assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
534 }
535
536 #[test]
537 fn feed_uses_esc_d_for_blank_lines() {
538 let doc = parse("A\n\nB").unwrap();
539 let mut enc = EscPosEncoder::new(PosMetadata::default());
540 let bytes = enc.encode_document(&doc).unwrap();
541 assert!(bytes.windows(3).any(|w| w == [0x1B, b'd', 1]));
542 }
543
544 #[test]
545 fn blank_line_between_barcode_and_qr_is_ordered_feed() {
546 let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap();
547 assert!(matches!(
548 doc.blocks.as_slice(),
549 [
550 Block::Barcode { .. },
551 Block::Feed(1),
552 Block::Qr { .. },
553 ]
554 ));
555 }
556
557 #[test]
558 fn blank_line_between_graphics_feeds_on_print() {
559 let doc = parse("@barcode RASTER CODE128 X\n\n@qr RASTER Y scale=4").unwrap();
560 let mut enc = EscPosEncoder::new(PosMetadata {
561 page_width_mm: 53.0,
562 ..Default::default()
563 });
564 let bytes = enc.encode_document(&doc).unwrap();
565 let raster_positions: Vec<_> = bytes
566 .windows(4)
567 .enumerate()
568 .filter(|(_, w)| *w == [0x1D, b'v', 0x30, 0x00])
569 .map(|(i, _)| i)
570 .collect();
571 assert_eq!(raster_positions.len(), 2);
572 let between = &bytes[raster_positions[0]..raster_positions[1]];
573 assert!(
574 between.windows(3).any(|w| w == [0x1B, b'd', 1]),
575 "expected ESC d feed between raster graphics, got {} bytes",
576 between.len()
577 );
578 }
579
580 #[test]
581 fn raster_graphic_ends_with_line_feed() {
582 let doc = parse("@barcode RASTER CODE128 X").unwrap();
583 let mut enc = EscPosEncoder::new(PosMetadata::default());
584 let bytes = enc.encode_document(&doc).unwrap();
585 let raster_start = bytes
586 .windows(4)
587 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
588 .expect("raster header");
589 assert!(
590 bytes[raster_start..].contains(&b'\n'),
591 "expected LF after raster data"
592 );
593 }
594
595 #[test]
596 fn does_not_auto_cut_without_directive() {
597 let doc = parse("x").unwrap();
598 let mut enc = EscPosEncoder::new(PosMetadata::default());
599 let bytes = enc.encode_document(&doc).unwrap();
600 assert!(!bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
601 }
602}