BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

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