BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

escpos.rs 12.9 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};
10
11#[derive(Debug)]
12pub enum EscPosError {
13 Image(String),
14 Barcode(String),
15 Raster(RasterError),
16 Io(String),
17}
18
19pub struct EscPosEncoder {
20 buffer: Vec<u8>,
21 metadata: PosMetadata,
22 base_dir: Option<std::path::PathBuf>,
23}
24
25impl EscPosEncoder {
26 pub fn new(metadata: PosMetadata) -> Self {
27 Self {
28 buffer: Vec::new(),
29 metadata,
30 base_dir: None,
31 }
32 }
33
34 pub fn with_base_dir(mut self, base_dir: impl AsRef<Path>) -> Self {
35 self.base_dir = Some(base_dir.as_ref().to_path_buf());
36 self
37 }
38
39 pub fn encode_document(&mut self, document: &Document) -> Result<&[u8], EscPosError> {
40 self.buffer.clear();
41 self.init();
42 for block in &document.blocks {
43 self.encode_block(block)?;
44 }
45 if self.metadata.cut_after_print && !document.blocks.iter().any(|b| matches!(b, Block::Cut)) {
46 self.feed(self.metadata.default_feed_before_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 for part in line.split('\n') {
67 self.writeln(part);
68 }
69 }
70 Block::Heading { level, inlines } => {
71 self.set_align(Align::Left);
72 if *level == 1 {
73 self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
74 } else {
75 self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
76 }
77 self.writeln(&inlines_to_plain(inlines));
78 if *level == 1 {
79 self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
80 } else {
81 self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
82 }
83 }
84 Block::Rule => {
85 let width = self.metadata.chars_per_line() as usize;
86 self.writeln(&"-".repeat(width));
87 }
88 Block::Feed(n) => self.feed(*n),
89 Block::Cut => self.cut(),
90 Block::Image { path, width, align } => {
91 self.set_align(*align);
92 self.encode_image(path, *width)?;
93 }
94 Block::Barcode {
95 mode,
96 symbology,
97 data,
98 height,
99 align,
100 show_text,
101 } => {
102 self.set_align(*align);
103 match mode {
104 BarcodeMode::Native => {
105 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
106 }
107 BarcodeMode::Raster => {
108 let img = raster::render_barcode(*symbology, data, *height as u32)
109 .map_err(EscPosError::Raster)?;
110 self.encode_gray_raster(&img, ImageWidth::Default)?;
111 }
112 }
113 }
114 Block::Qr {
115 mode,
116 data,
117 size,
118 ecc,
119 version,
120 align,
121 } => {
122 self.set_align(*align);
123 match mode {
124 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
125 QrMode::Raster => {
126 let img = raster::render_qr(data, *version, *ecc, *size as u32)
127 .map_err(EscPosError::Raster)?;
128 self.encode_gray_raster(&img, ImageWidth::Default)?;
129 }
130 }
131 }
132 }
133 Ok(())
134 }
135
136 fn set_align(&mut self, align: Align) {
137 let n = match align {
138 Align::Left => 0,
139 Align::Center => 1,
140 Align::Right => 2,
141 };
142 self.buffer.extend_from_slice(&[0x1B, b'a', n]);
143 }
144
145 fn writeln(&mut self, text: &str) {
146 self.buffer.extend_from_slice(text.as_bytes());
147 self.buffer.push(b'\n');
148 }
149
150 fn feed(&mut self, lines: u8) {
151 self.buffer.extend_from_slice(&[0x1B, b'd', lines]);
152 }
153
154 fn cut(&mut self) {
155 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
156 }
157
158 fn encode_barcode_native(
159 &mut self,
160 symbology: BarcodeSymbology,
161 data: &str,
162 height: u8,
163 show_text: bool,
164 ) -> Result<(), EscPosError> {
165 self.buffer.extend_from_slice(&[0x1D, b'h', height]);
166 self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]);
167 match symbology {
168 BarcodeSymbology::Code128 => {
169 let bytes = data.as_bytes();
170 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
171 self.buffer.extend_from_slice(bytes);
172 }
173 BarcodeSymbology::UpcA => {
174 if data.len() != 11 && data.len() != 12 {
175 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
176 }
177 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
178 self.buffer.extend_from_slice(data.as_bytes());
179 }
180 BarcodeSymbology::UpcE => {
181 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
182 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
183 }
184 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
185 self.buffer.extend_from_slice(data.as_bytes());
186 }
187 BarcodeSymbology::Ean13 => {
188 if data.len() != 12 && data.len() != 13 {
189 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
190 }
191 self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]);
192 self.buffer.extend_from_slice(data.as_bytes());
193 }
194 BarcodeSymbology::Ean8 => {
195 if data.len() != 7 && data.len() != 8 {
196 return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into()));
197 }
198 self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]);
199 self.buffer.extend_from_slice(data.as_bytes());
200 }
201 BarcodeSymbology::Code39 => {
202 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
203 self.buffer.extend_from_slice(data.as_bytes());
204 }
205 BarcodeSymbology::Itf => {
206 if data.len() % 2 != 0 {
207 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
208 }
209 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
210 self.buffer.extend_from_slice(data.as_bytes());
211 }
212 BarcodeSymbology::Codabar => {
213 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
214 self.buffer.extend_from_slice(data.as_bytes());
215 }
216 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
217 return Err(EscPosError::Barcode(format!(
218 "{} requires RASTER mode",
219 symbology.as_str()
220 )));
221 }
222 }
223 self.buffer.push(b'\n');
224 Ok(())
225 }
226
227 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
228 let ecc_level = match ecc {
229 QrEcc::L => 48,
230 QrEcc::M => 49,
231 QrEcc::Q => 50,
232 QrEcc::H => 51,
233 };
234 let store = data.as_bytes();
235 let len = store.len() + 3;
236 let p_l = (len & 0xFF) as u8;
237 let p_h = ((len >> 8) & 0xFF) as u8;
238
239 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
240 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
241 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
242 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
243 self.buffer.extend_from_slice(store);
244 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
245 self.buffer.push(b'\n');
246 Ok(())
247 }
248
249 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
250 let resolved = resolve_image_path(path, self.base_dir.as_deref());
251 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
252 self.encode_gray_raster(&img.to_luma8(), width)
253 }
254
255 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
256 let (w, h) = gray.dimensions();
257 let target_width = match width {
258 ImageWidth::Percent(pct) => {
259 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
260 }
261 ImageWidth::Dots(d) => d as u32,
262 ImageWidth::Default => self.metadata.printable_dots() as u32,
263 };
264 let new_w = target_width.min(w).max(1);
265 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
266 let resized = image::imageops::resize(
267 gray,
268 new_w,
269 new_h,
270 image::imageops::FilterType::Nearest,
271 );
272 let bytes_per_row = ((new_w + 7) / 8) as usize;
273 let mut raster = vec![0u8; bytes_per_row * new_h as usize];
274 for y in 0..new_h {
275 for x in 0..new_w {
276 let pixel = resized.get_pixel(x, y).0[0];
277 if pixel < 128 {
278 let byte_index = (y as usize * bytes_per_row) + (x as usize / 8);
279 let bit = 7 - (x % 8);
280 raster[byte_index] |= 1 << bit;
281 }
282 }
283 }
284 let x_l = (bytes_per_row & 0xFF) as u8;
285 let x_h = ((bytes_per_row >> 8) & 0xFF) as u8;
286 let y_l = (new_h & 0xFF) as u8;
287 let y_h = ((new_h >> 8) & 0xFF) as u8;
288 self.buffer.extend_from_slice(&[0x1D, b'v', 0, 0, x_l, x_h, y_l, y_h]);
289 self.buffer.extend_from_slice(&raster);
290 self.buffer.push(b'\n');
291 Ok(())
292 }
293}
294
295fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> std::path::PathBuf {
296 let p = Path::new(path);
297 if p.is_absolute() {
298 p.to_path_buf()
299 } else if let Some(base) = base_dir {
300 base.join(p)
301 } else {
302 p.to_path_buf()
303 }
304}
305
306fn inlines_to_plain(inlines: &[Inline]) -> String {
307 let mut out = String::new();
308 for inline in inlines {
309 match inline {
310 Inline::Text(t) | Inline::Code(t) => out.push_str(t),
311 Inline::Param(t) => out.push_str(t),
312 Inline::Bold(inner) | Inline::Italic(inner) => out.push_str(&inlines_to_plain(inner)),
313 }
314 }
315 out
316}
317
318#[cfg(test)]
319mod tests {
320 use super::*;
321 use crate::dsl::parse;
322
323 #[test]
324 fn encodes_init_and_text() {
325 let doc = parse("Hello").unwrap();
326 let mut enc = EscPosEncoder::new(PosMetadata::default());
327 let bytes = enc.encode_document(&doc).unwrap();
328 assert_eq!(&bytes[0..2], &[0x1B, b'@']);
329 assert!(bytes.windows(5).any(|w| w == b"Hello"));
330 }
331
332 #[test]
333 fn encodes_raster_barcode() {
334 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
335 let mut enc = EscPosEncoder::new(PosMetadata::default());
336 let bytes = enc.encode_document(&doc).unwrap();
337 assert!(bytes.windows(4).any(|w| w == [0x1D, b'v', 0, 0]));
338 }
339
340 #[test]
341 fn encodes_cut_directive() {
342 let doc = parse("@cut").unwrap();
343 let mut enc = EscPosEncoder::new(PosMetadata {
344 cut_after_print: false,
345 ..Default::default()
346 });
347 let bytes = enc.encode_document(&doc).unwrap();
348 assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
349 }
350
351 #[test]
352 fn auto_cut_when_enabled() {
353 let doc = parse("x").unwrap();
354 let mut enc = EscPosEncoder::new(PosMetadata::default());
355 let bytes = enc.encode_document(&doc).unwrap();
356 assert!(bytes.ends_with(&[0x1D, b'V', 66, 0]));
357 }
358}