BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

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