BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

escpos.rs 18.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 line = inlines_to_plain(inlines);
63 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
64 for part in text_wrap::wrap_text(&line, cols) {
65 self.writeln(&part);
66 }
67 }
68 Block::Heading { level, align, inlines } => {
69 self.set_align(*align);
70 let wrap_style = if *level == 1 {
71 TextWrapStyle::Heading1
72 } else {
73 TextWrapStyle::Heading2
74 };
75 let cols = text_wrap::wrap_cols(&self.metadata, wrap_style);
76 let wrapped = text_wrap::wrap_text(&inlines_to_plain(inlines), cols);
77 if *level == 1 {
78 self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
79 } else {
80 self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
81 }
82 for part in &wrapped {
83 self.writeln(part);
84 }
85 if *level == 1 {
86 self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
87 } else {
88 self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
89 }
90 }
91 Block::Rule => {
92 let width = self.metadata.chars_per_line() as usize;
93 self.writeln(&"-".repeat(width));
94 }
95 Block::Feed(n) => self.feed(*n),
96 Block::Cut => self.cut(),
97 Block::Image { path, width, align } => {
98 self.set_align(*align);
99 self.encode_image(path, *width)?;
100 }
101 Block::Barcode {
102 mode,
103 symbology,
104 data,
105 height,
106 align,
107 show_text,
108 } => {
109 self.set_align(*align);
110 match mode {
111 BarcodeMode::Native => {
112 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
113 }
114 BarcodeMode::Raster => {
115 let img = raster::render_barcode(*symbology, data, *height as u32)
116 .map_err(EscPosError::Raster)?;
117 let target = self.metadata.printable_dots() as u32;
118 let img = raster::scale_gray_to_print_width(img, target);
119 self.encode_gray_raster(&img, ImageWidth::Default)?;
120 }
121 }
122 }
123 Block::Qr {
124 mode,
125 data,
126 size,
127 ecc,
128 version,
129 align,
130 } => {
131 self.set_align(*align);
132 match mode {
133 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
134 QrMode::Raster => {
135 let img = raster::render_qr(data, *version, *ecc, *size as u32)
136 .map_err(EscPosError::Raster)?;
137 self.encode_gray_raster(&img, ImageWidth::Default)?;
138 }
139 }
140 }
141 Block::Date { format, align } => {
142 self.set_align(*align);
143 let text = crate::datetime::format_date(format.as_deref());
144 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
145 for part in text_wrap::wrap_text(&text, cols) {
146 self.writeln(&part);
147 }
148 }
149 Block::Time { format, align } => {
150 self.set_align(*align);
151 let text = crate::datetime::format_time(*format);
152 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
153 for part in text_wrap::wrap_text(&text, cols) {
154 self.writeln(&part);
155 }
156 }
157 }
158 Ok(())
159 }
160
161 fn set_align(&mut self, align: Align) {
162 let n = match align {
163 Align::Left => 0,
164 Align::Center => 1,
165 Align::Right => 2,
166 };
167 self.buffer.extend_from_slice(&[0x1B, b'a', n]);
168 }
169
170 fn writeln(&mut self, text: &str) {
171 self.buffer.extend_from_slice(text.as_bytes());
172 self.buffer.push(b'\n');
173 }
174
175 fn feed(&mut self, lines: u8) {
176 // LF feeds match print-bridge / node-escpos; ESC d is unreliable after raster graphics.
177 for _ in 0..lines {
178 self.buffer.push(b'\n');
179 }
180 }
181
182 fn cut(&mut self) {
183 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
184 }
185
186 fn encode_barcode_native(
187 &mut self,
188 symbology: BarcodeSymbology,
189 data: &str,
190 height: u8,
191 show_text: bool,
192 ) -> Result<(), EscPosError> {
193 self.buffer.extend_from_slice(&[0x1D, b'h', height]);
194 self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]);
195 // Widest module width (GS w 6) for easier scanning.
196 self.buffer.extend_from_slice(&[0x1D, b'w', 6]);
197 match symbology {
198 BarcodeSymbology::Code128 => {
199 let bytes = data.as_bytes();
200 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
201 self.buffer.extend_from_slice(bytes);
202 }
203 BarcodeSymbology::UpcA => {
204 if data.len() != 11 && data.len() != 12 {
205 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
206 }
207 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
208 self.buffer.extend_from_slice(data.as_bytes());
209 }
210 BarcodeSymbology::UpcE => {
211 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
212 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
213 }
214 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
215 self.buffer.extend_from_slice(data.as_bytes());
216 }
217 BarcodeSymbology::Ean13 => {
218 if data.len() != 12 && data.len() != 13 {
219 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
220 }
221 self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]);
222 self.buffer.extend_from_slice(data.as_bytes());
223 }
224 BarcodeSymbology::Ean8 => {
225 if data.len() != 7 && data.len() != 8 {
226 return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into()));
227 }
228 self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]);
229 self.buffer.extend_from_slice(data.as_bytes());
230 }
231 BarcodeSymbology::Code39 => {
232 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
233 self.buffer.extend_from_slice(data.as_bytes());
234 }
235 BarcodeSymbology::Itf => {
236 if data.len() % 2 != 0 {
237 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
238 }
239 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
240 self.buffer.extend_from_slice(data.as_bytes());
241 }
242 BarcodeSymbology::Codabar => {
243 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
244 self.buffer.extend_from_slice(data.as_bytes());
245 }
246 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
247 return Err(EscPosError::Barcode(format!(
248 "{} requires RASTER mode",
249 symbology.as_str()
250 )));
251 }
252 }
253 self.buffer.push(b'\n');
254 Ok(())
255 }
256
257 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
258 let ecc_level = match ecc {
259 QrEcc::L => 48,
260 QrEcc::M => 49,
261 QrEcc::Q => 50,
262 QrEcc::H => 51,
263 };
264 let store = data.as_bytes();
265 let len = store.len() + 3;
266 let p_l = (len & 0xFF) as u8;
267 let p_h = ((len >> 8) & 0xFF) as u8;
268
269 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
270 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
271 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
272 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
273 self.buffer.extend_from_slice(store);
274 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
275 self.buffer.push(b'\n');
276 Ok(())
277 }
278
279 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
280 let resolved = resolve_image_path(path, self.base_dir.as_deref());
281 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
282 self.encode_gray_raster(&img.to_luma8(), width)
283 }
284
285 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
286 let (w, h) = gray.dimensions();
287 let target_width = match width {
288 ImageWidth::Percent(pct) => {
289 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
290 }
291 ImageWidth::Dots(d) => d as u32,
292 ImageWidth::Default => self.metadata.printable_dots() as u32,
293 };
294 let new_w = target_width.min(w).max(1);
295 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
296 let resized = image::imageops::resize(
297 gray,
298 new_w,
299 new_h,
300 image::imageops::FilterType::Nearest,
301 );
302 let bytes_per_row = ((new_w + 7) / 8) as usize;
303 let mut raster = vec![0u8; bytes_per_row * new_h as usize];
304 for y in 0..new_h {
305 for x in 0..new_w {
306 let pixel = resized.get_pixel(x, y).0[0];
307 if pixel < 128 {
308 let byte_index = (y as usize * bytes_per_row) + (x as usize / 8);
309 let bit = 7 - (x % 8);
310 raster[byte_index] |= 1 << bit;
311 }
312 }
313 }
314 let x_l = (bytes_per_row & 0xFF) as u8;
315 let x_h = ((bytes_per_row >> 8) & 0xFF) as u8;
316 let y_l = (new_h & 0xFF) as u8;
317 let y_h = ((new_h >> 8) & 0xFF) as u8;
318 // GS v 0 normal raster — same header as print-bridge / node-escpos:
319 // 1D 76 30 00, xL xH (bytes/row), yL yH (dots), then bitmap bytes.
320 self.buffer
321 .extend_from_slice(&[0x1D, b'v', 0x30, 0x00, x_l, x_h, y_l, y_h]);
322 self.buffer.extend_from_slice(&raster);
323 Ok(())
324 }
325}
326
327fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> std::path::PathBuf {
328 let p = Path::new(path);
329 if p.is_absolute() {
330 p.to_path_buf()
331 } else if let Some(base) = base_dir {
332 base.join(p)
333 } else {
334 p.to_path_buf()
335 }
336}
337
338fn inlines_to_plain(inlines: &[Inline]) -> String {
339 let mut out = String::new();
340 for inline in inlines {
341 match inline {
342 Inline::Text(t) | Inline::Code(t) => out.push_str(t),
343 Inline::Param(t) => out.push_str(t),
344 Inline::Bold(inner) | Inline::Italic(inner) => out.push_str(&inlines_to_plain(inner)),
345 }
346 }
347 out
348}
349
350#[cfg(test)]
351mod tests {
352 use super::*;
353 use crate::dsl::parse;
354
355 #[test]
356 fn heading_wraps_like_preview_on_narrow_paper() {
357 let doc = parse("# Proof of Transfer").unwrap();
358 let mut enc = EscPosEncoder::new(PosMetadata {
359 page_width_mm: 53.0,
360 ..Default::default()
361 });
362 let bytes = enc.encode_document(&doc).unwrap();
363 let text = String::from_utf8_lossy(bytes);
364 assert!(
365 text.contains("Proof of\n"),
366 "expected word wrap before Transfer, got: {text}"
367 );
368 assert!(
369 text.contains("Transfer\n"),
370 "expected wrapped second line, got: {text}"
371 );
372 }
373
374 #[test]
375 fn encodes_init_and_text() {
376 let doc = parse("Hello").unwrap();
377 let mut enc = EscPosEncoder::new(PosMetadata::default());
378 let bytes = enc.encode_document(&doc).unwrap();
379 assert_eq!(&bytes[0..2], &[0x1B, b'@']);
380 assert!(bytes.windows(5).any(|w| w == b"Hello"));
381 }
382
383 #[test]
384 fn encodes_raster_barcode() {
385 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
386 let mut enc = EscPosEncoder::new(PosMetadata::default());
387 let bytes = enc.encode_document(&doc).unwrap();
388 assert!(
389 bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
390 "expected GS v 0 raster header"
391 );
392 }
393
394 #[test]
395 fn raster_header_matches_print_bridge_format() {
396 let doc = parse("@barcode RASTER CODE128 X").unwrap();
397 let meta = PosMetadata {
398 page_width_mm: 58.0,
399 ..Default::default()
400 };
401 let mut enc = EscPosEncoder::new(meta.clone());
402 let bytes = enc.encode_document(&doc).unwrap();
403 let pos = bytes
404 .windows(4)
405 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
406 .expect("raster header");
407 assert_eq!(&bytes[pos..pos + 4], &[0x1D, b'v', 0x30, 0x00]);
408 let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]);
409 let expected_bytes = ((meta.printable_dots() as u32 + 7) / 8) as u16;
410 assert_eq!(
411 x_bytes, expected_bytes,
412 "barcode raster should span full printable width"
413 );
414 let y_dots = u16::from_le_bytes([bytes[pos + 6], bytes[pos + 7]]);
415 assert!(y_dots > 0);
416 }
417
418 #[test]
419 fn encodes_centered_heading() {
420 let doc = parse(":center:\n# Hello").unwrap();
421 let mut enc = EscPosEncoder::new(PosMetadata::default());
422 let bytes = enc.encode_document(&doc).unwrap();
423 assert!(bytes.windows(3).any(|w| w == [0x1B, b'a', 1]));
424 assert!(bytes.windows(5).any(|w| w == b"Hello"));
425 }
426
427 #[test]
428 fn encodes_date_directive() {
429 let doc = parse("@date DD-YYYY-MM").unwrap();
430 let mut enc = EscPosEncoder::new(PosMetadata::default());
431 let bytes = enc.encode_document(&doc).unwrap();
432 let text = String::from_utf8_lossy(bytes);
433 assert!(text.contains('-'));
434 }
435
436 #[test]
437 fn encodes_cut_directive() {
438 let doc = parse("@cut").unwrap();
439 let mut enc = EscPosEncoder::new(PosMetadata::default());
440 let bytes = enc.encode_document(&doc).unwrap();
441 assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
442 }
443
444 #[test]
445 fn feed_uses_line_feed_not_esc_d() {
446 let doc = parse("A\n\nB").unwrap();
447 let mut enc = EscPosEncoder::new(PosMetadata::default());
448 let bytes = enc.encode_document(&doc).unwrap();
449 assert!(bytes.contains(&b'\n'));
450 assert!(!bytes.windows(2).any(|w| w == [0x1B, b'd']));
451 }
452
453 #[test]
454 fn blank_line_between_graphics_feeds_on_print() {
455 let doc = parse("@barcode RASTER CODE128 X\n\n@qr RASTER Y scale=4").unwrap();
456 assert!(doc.blocks.iter().any(|b| matches!(b, Block::Feed(1))));
457 let mut enc = EscPosEncoder::new(PosMetadata {
458 page_width_mm: 53.0,
459 ..Default::default()
460 });
461 let bytes = enc.encode_document(&doc).unwrap();
462 let raster_positions: Vec<_> = bytes
463 .windows(4)
464 .enumerate()
465 .filter(|(_, w)| *w == [0x1D, b'v', 0x30, 0x00])
466 .map(|(i, _)| i)
467 .collect();
468 assert_eq!(raster_positions.len(), 2);
469 let between = &bytes[raster_positions[0]..raster_positions[1]];
470 assert!(
471 between.contains(&b'\n'),
472 "expected line feed between raster graphics"
473 );
474 }
475
476 #[test]
477 fn does_not_auto_cut_without_directive() {
478 let doc = parse("x").unwrap();
479 let mut enc = EscPosEncoder::new(PosMetadata::default());
480 let bytes = enc.encode_document(&doc).unwrap();
481 assert!(!bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
482 }
483}