BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

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