| 1 | use std::path::Path;
|
| 2 |
|
| 3 | use crate::dsl::{
|
| 4 | Align, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc,
|
| 5 | };
|
| 6 | use crate::io::PosMetadata;
|
| 7 |
|
| 8 | #[derive(Debug)]
|
| 9 | pub enum EscPosError {
|
| 10 | Image(String),
|
| 11 | Barcode(String),
|
| 12 | Io(String),
|
| 13 | }
|
| 14 |
|
| 15 | pub struct EscPosEncoder {
|
| 16 | buffer: Vec<u8>,
|
| 17 | metadata: PosMetadata,
|
| 18 | base_dir: Option<std::path::PathBuf>,
|
| 19 | }
|
| 20 |
|
| 21 | impl 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 |
|
| 244 | fn 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 |
|
| 255 | fn 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)]
|
| 268 | mod 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 | }
|