| 1 | use std::path::Path;
|
| 2 |
|
| 3 | use image::GrayImage;
|
| 4 |
|
| 5 | use crate::bitmap_font::{self, MixedSeg};
|
| 6 | use crate::dsl::{
|
| 7 | Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode,
|
| 8 | };
|
| 9 | use crate::io::PosMetadata;
|
| 10 | use crate::raster::{self, RasterError};
|
| 11 | use crate::text_wrap::{self, TextWrapStyle};
|
| 12 |
|
| 13 | #[derive(Debug)]
|
| 14 | pub enum EscPosError {
|
| 15 | Image(String),
|
| 16 | Barcode(String),
|
| 17 | Raster(RasterError),
|
| 18 | Io(String),
|
| 19 | }
|
| 20 |
|
| 21 | pub struct EscPosEncoder {
|
| 22 | buffer: Vec<u8>,
|
| 23 | metadata: PosMetadata,
|
| 24 | base_dir: Option<std::path::PathBuf>,
|
| 25 | }
|
| 26 |
|
| 27 | impl EscPosEncoder {
|
| 28 | pub fn new(metadata: PosMetadata) -> Self {
|
| 29 | Self {
|
| 30 | buffer: Vec::new(),
|
| 31 | metadata,
|
| 32 | base_dir: None,
|
| 33 | }
|
| 34 | }
|
| 35 |
|
| 36 | pub fn with_base_dir(mut self, base_dir: impl AsRef<Path>) -> Self {
|
| 37 | self.base_dir = Some(base_dir.as_ref().to_path_buf());
|
| 38 | self
|
| 39 | }
|
| 40 |
|
| 41 | pub fn encode_document(&mut self, document: &Document) -> Result<&[u8], EscPosError> {
|
| 42 | self.buffer.clear();
|
| 43 | self.init();
|
| 44 | for block in &document.blocks {
|
| 45 | self.encode_block(block)?;
|
| 46 | }
|
| 47 | Ok(&self.buffer)
|
| 48 | }
|
| 49 |
|
| 50 | pub fn into_bytes(self) -> Vec<u8> {
|
| 51 | self.buffer
|
| 52 | }
|
| 53 |
|
| 54 | fn init(&mut self) {
|
| 55 | self.buffer.extend_from_slice(&[0x1B, b'@']);
|
| 56 | self.buffer.extend_from_slice(&[0x1B, b't', 0]);
|
| 57 | // Checkbox glyphs as Font A user-defined characters so they stay inline
|
| 58 | // with the native text font (ESC * is not buffered on many micro-printers).
|
| 59 | self.define_checkbox_user_chars();
|
| 60 | }
|
| 61 |
|
| 62 | fn define_checkbox_user_chars(&mut self) {
|
| 63 | let (el, er) = bitmap_font::checkbox_font_a_halves(false);
|
| 64 | let (cl, cr) = bitmap_font::checkbox_font_a_halves(true);
|
| 65 | self.define_font_a_char(bitmap_font::CHAR_EMPTY_L, &el);
|
| 66 | self.define_font_a_char(bitmap_font::CHAR_EMPTY_R, &er);
|
| 67 | self.define_font_a_char(bitmap_font::CHAR_CHECKED_L, &cl);
|
| 68 | self.define_font_a_char(bitmap_font::CHAR_CHECKED_R, &cr);
|
| 69 | // Select user-defined character set; undefined codes use the resident font.
|
| 70 | self.buffer.extend_from_slice(&[0x1B, b'%', 1]);
|
| 71 | }
|
| 72 |
|
| 73 | /// ESC & y=3 — define one Font A (12×24) user character from column data.
|
| 74 | fn define_font_a_char(&mut self, code: u8, columns: &[[u8; 3]]) {
|
| 75 | let x = columns.len().min(12) as u8;
|
| 76 | if x == 0 {
|
| 77 | return;
|
| 78 | }
|
| 79 | self.buffer
|
| 80 | .extend_from_slice(&[0x1B, b'&', 3, code, code, x]);
|
| 81 | for col in columns.iter().take(x as usize) {
|
| 82 | self.buffer.extend_from_slice(col);
|
| 83 | }
|
| 84 | }
|
| 85 |
|
| 86 | fn encode_block(&mut self, block: &Block) -> Result<(), EscPosError> {
|
| 87 | match block {
|
| 88 | Block::Paragraph { align, inlines } => {
|
| 89 | self.set_align(*align);
|
| 90 | let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
|
| 91 | if bitmap_font::inlines_have_checkbox(inlines) {
|
| 92 | self.encode_mixed_inlines(inlines, cols, "", "")?;
|
| 93 | } else {
|
| 94 | let line = inlines_to_plain(inlines);
|
| 95 | for part in text_wrap::wrap_text(&line, cols) {
|
| 96 | self.writeln(&part);
|
| 97 | }
|
| 98 | }
|
| 99 | }
|
| 100 | Block::List { align, items } => {
|
| 101 | self.set_align(*align);
|
| 102 | let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
|
| 103 | for item in items {
|
| 104 | if bitmap_font::inlines_have_checkbox(item) {
|
| 105 | self.encode_mixed_inlines(
|
| 106 | item,
|
| 107 | cols,
|
| 108 | text_wrap::BULLET_FIRST_PREFIX,
|
| 109 | text_wrap::BULLET_NEXT_PREFIX,
|
| 110 | )?;
|
| 111 | } else {
|
| 112 | let line = inlines_to_plain(item);
|
| 113 | for part in text_wrap::wrap_bullet_item(&line, cols) {
|
| 114 | self.writeln(&part);
|
| 115 | }
|
| 116 | }
|
| 117 | }
|
| 118 | }
|
| 119 | Block::Heading { level, align, inlines } => {
|
| 120 | self.set_align(*align);
|
| 121 | let wrap_style = if *level == 1 {
|
| 122 | TextWrapStyle::Heading1
|
| 123 | } else {
|
| 124 | TextWrapStyle::Heading2
|
| 125 | };
|
| 126 | let cols = text_wrap::wrap_cols(&self.metadata, wrap_style);
|
| 127 | if bitmap_font::inlines_have_checkbox(inlines) {
|
| 128 | if *level == 1 {
|
| 129 | self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
|
| 130 | } else {
|
| 131 | self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
|
| 132 | }
|
| 133 | self.encode_mixed_inlines(inlines, cols, "", "")?;
|
| 134 | if *level == 1 {
|
| 135 | self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
|
| 136 | } else {
|
| 137 | self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
|
| 138 | }
|
| 139 | } else {
|
| 140 | let wrapped = text_wrap::wrap_text(&inlines_to_plain(inlines), cols);
|
| 141 | if *level == 1 {
|
| 142 | self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
|
| 143 | } else {
|
| 144 | self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
|
| 145 | }
|
| 146 | for part in &wrapped {
|
| 147 | self.writeln(part);
|
| 148 | }
|
| 149 | if *level == 1 {
|
| 150 | self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
|
| 151 | } else {
|
| 152 | self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
|
| 153 | }
|
| 154 | }
|
| 155 | }
|
| 156 | Block::Rule => {
|
| 157 | let width = self.metadata.chars_per_line() as usize;
|
| 158 | self.writeln(&"-".repeat(width));
|
| 159 | }
|
| 160 | Block::Feed(n) => self.feed(*n),
|
| 161 | Block::Cut => self.cut(),
|
| 162 | Block::Image { path, width, align } => {
|
| 163 | self.set_align(*align);
|
| 164 | self.encode_image(path, *width)?;
|
| 165 | }
|
| 166 | Block::Barcode {
|
| 167 | mode,
|
| 168 | symbology,
|
| 169 | data,
|
| 170 | height,
|
| 171 | align,
|
| 172 | show_text,
|
| 173 | } => {
|
| 174 | self.set_align(*align);
|
| 175 | match mode {
|
| 176 | BarcodeMode::Native => {
|
| 177 | self.encode_barcode_native(*symbology, data, *height, *show_text)?;
|
| 178 | }
|
| 179 | BarcodeMode::Raster => {
|
| 180 | let img = raster::render_barcode(*symbology, data, *height as u32)
|
| 181 | .map_err(EscPosError::Raster)?;
|
| 182 | let target = self.metadata.printable_dots() as u32;
|
| 183 | let img = raster::scale_gray_to_print_width(img, target);
|
| 184 | self.encode_gray_raster(&img, ImageWidth::Default)?;
|
| 185 | }
|
| 186 | }
|
| 187 | }
|
| 188 | Block::Qr {
|
| 189 | mode,
|
| 190 | data,
|
| 191 | size,
|
| 192 | ecc,
|
| 193 | version,
|
| 194 | align,
|
| 195 | } => {
|
| 196 | self.set_align(*align);
|
| 197 | match mode {
|
| 198 | QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
|
| 199 | QrMode::Raster => {
|
| 200 | let img = raster::render_qr(data, *version, *ecc, *size as u32)
|
| 201 | .map_err(EscPosError::Raster)?;
|
| 202 | self.encode_gray_raster(&img, ImageWidth::Default)?;
|
| 203 | }
|
| 204 | }
|
| 205 | }
|
| 206 | Block::Date { format, align } => {
|
| 207 | self.set_align(*align);
|
| 208 | let text = crate::datetime::format_date(format.as_deref());
|
| 209 | let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
|
| 210 | for part in text_wrap::wrap_text(&text, cols) {
|
| 211 | self.writeln(&part);
|
| 212 | }
|
| 213 | }
|
| 214 | Block::Time { format, align } => {
|
| 215 | self.set_align(*align);
|
| 216 | let text = crate::datetime::format_time(*format);
|
| 217 | let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
|
| 218 | for part in text_wrap::wrap_text(&text, cols) {
|
| 219 | self.writeln(&part);
|
| 220 | }
|
| 221 | }
|
| 222 | }
|
| 223 | Ok(())
|
| 224 | }
|
| 225 |
|
| 226 | fn set_align(&mut self, align: Align) {
|
| 227 | let n = match align {
|
| 228 | Align::Left => 0,
|
| 229 | Align::Center => 1,
|
| 230 | Align::Right => 2,
|
| 231 | };
|
| 232 | self.buffer.extend_from_slice(&[0x1B, b'a', n]);
|
| 233 | }
|
| 234 |
|
| 235 | fn writeln(&mut self, text: &str) {
|
| 236 | self.buffer.extend_from_slice(text.as_bytes());
|
| 237 | self.buffer.push(b'\n');
|
| 238 | }
|
| 239 |
|
| 240 | fn encode_mixed_inlines(
|
| 241 | &mut self,
|
| 242 | inlines: &[Inline],
|
| 243 | cols: usize,
|
| 244 | first_prefix: &str,
|
| 245 | next_prefix: &str,
|
| 246 | ) -> Result<(), EscPosError> {
|
| 247 | let segs = bitmap_font::segments_from_inlines(inlines);
|
| 248 | let lines = if first_prefix.is_empty() && next_prefix.is_empty() {
|
| 249 | bitmap_font::wrap_segments(&segs, cols)
|
| 250 | } else {
|
| 251 | bitmap_font::wrap_segments_hanging(&segs, cols, first_prefix, next_prefix)
|
| 252 | };
|
| 253 | for line in lines {
|
| 254 | self.encode_mixed_line(&line)?;
|
| 255 | }
|
| 256 | Ok(())
|
| 257 | }
|
| 258 |
|
| 259 | fn encode_mixed_line(&mut self, segs: &[MixedSeg]) -> Result<(), EscPosError> {
|
| 260 | for seg in segs {
|
| 261 | match seg {
|
| 262 | MixedSeg::Text(t) => self.buffer.extend_from_slice(t.as_bytes()),
|
| 263 | MixedSeg::Checkbox { checked } => self.write_checkbox_chars(*checked),
|
| 264 | }
|
| 265 | }
|
| 266 | self.buffer.push(b'\n');
|
| 267 | Ok(())
|
| 268 | }
|
| 269 |
|
| 270 | fn write_checkbox_chars(&mut self, checked: bool) {
|
| 271 | if checked {
|
| 272 | self.buffer.extend_from_slice(&[
|
| 273 | bitmap_font::CHAR_CHECKED_L,
|
| 274 | bitmap_font::CHAR_CHECKED_R,
|
| 275 | ]);
|
| 276 | } else {
|
| 277 | self.buffer.extend_from_slice(&[
|
| 278 | bitmap_font::CHAR_EMPTY_L,
|
| 279 | bitmap_font::CHAR_EMPTY_R,
|
| 280 | ]);
|
| 281 | }
|
| 282 | }
|
| 283 |
|
| 284 | fn feed(&mut self, lines: u8) {
|
| 285 | if lines == 0 {
|
| 286 | return;
|
| 287 | }
|
| 288 | // ESC d — reliable paper feed after raster graphics (print-bridge uses this too).
|
| 289 | self.buffer.extend_from_slice(&[0x1B, b'd', lines]);
|
| 290 | }
|
| 291 |
|
| 292 | fn cut(&mut self) {
|
| 293 | self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
|
| 294 | }
|
| 295 |
|
| 296 | fn encode_barcode_native(
|
| 297 | &mut self,
|
| 298 | symbology: BarcodeSymbology,
|
| 299 | data: &str,
|
| 300 | height: u8,
|
| 301 | show_text: bool,
|
| 302 | ) -> Result<(), EscPosError> {
|
| 303 | self.buffer.extend_from_slice(&[0x1D, b'h', height]);
|
| 304 | self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]);
|
| 305 | // Widest module width (GS w 6) for easier scanning.
|
| 306 | self.buffer.extend_from_slice(&[0x1D, b'w', 6]);
|
| 307 | match symbology {
|
| 308 | BarcodeSymbology::Code128 => {
|
| 309 | let bytes = data.as_bytes();
|
| 310 | self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
|
| 311 | self.buffer.extend_from_slice(bytes);
|
| 312 | }
|
| 313 | BarcodeSymbology::UpcA => {
|
| 314 | if data.len() != 11 && data.len() != 12 {
|
| 315 | return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
|
| 316 | }
|
| 317 | self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
|
| 318 | self.buffer.extend_from_slice(data.as_bytes());
|
| 319 | }
|
| 320 | BarcodeSymbology::UpcE => {
|
| 321 | if data.len() != 6 && data.len() != 7 && data.len() != 8 {
|
| 322 | return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
|
| 323 | }
|
| 324 | self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
|
| 325 | self.buffer.extend_from_slice(data.as_bytes());
|
| 326 | }
|
| 327 | BarcodeSymbology::Ean13 => {
|
| 328 | if data.len() != 12 && data.len() != 13 {
|
| 329 | return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
|
| 330 | }
|
| 331 | self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]);
|
| 332 | self.buffer.extend_from_slice(data.as_bytes());
|
| 333 | }
|
| 334 | BarcodeSymbology::Ean8 => {
|
| 335 | if data.len() != 7 && data.len() != 8 {
|
| 336 | return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into()));
|
| 337 | }
|
| 338 | self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]);
|
| 339 | self.buffer.extend_from_slice(data.as_bytes());
|
| 340 | }
|
| 341 | BarcodeSymbology::Code39 => {
|
| 342 | self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
|
| 343 | self.buffer.extend_from_slice(data.as_bytes());
|
| 344 | }
|
| 345 | BarcodeSymbology::Itf => {
|
| 346 | if data.len() % 2 != 0 {
|
| 347 | return Err(EscPosError::Barcode("ITF requires even digit count".into()));
|
| 348 | }
|
| 349 | self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
|
| 350 | self.buffer.extend_from_slice(data.as_bytes());
|
| 351 | }
|
| 352 | BarcodeSymbology::Codabar => {
|
| 353 | self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
|
| 354 | self.buffer.extend_from_slice(data.as_bytes());
|
| 355 | }
|
| 356 | BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
|
| 357 | return Err(EscPosError::Barcode(format!(
|
| 358 | "{} requires RASTER mode",
|
| 359 | symbology.as_str()
|
| 360 | )));
|
| 361 | }
|
| 362 | }
|
| 363 | self.buffer.push(b'\n');
|
| 364 | Ok(())
|
| 365 | }
|
| 366 |
|
| 367 | fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
|
| 368 | let ecc_level = match ecc {
|
| 369 | QrEcc::L => 48,
|
| 370 | QrEcc::M => 49,
|
| 371 | QrEcc::Q => 50,
|
| 372 | QrEcc::H => 51,
|
| 373 | };
|
| 374 | let store = data.as_bytes();
|
| 375 | let len = store.len() + 3;
|
| 376 | let p_l = (len & 0xFF) as u8;
|
| 377 | let p_h = ((len >> 8) & 0xFF) as u8;
|
| 378 |
|
| 379 | self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
|
| 380 | self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
|
| 381 | self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
|
| 382 | self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
|
| 383 | self.buffer.extend_from_slice(store);
|
| 384 | self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
|
| 385 | self.buffer.push(b'\n');
|
| 386 | Ok(())
|
| 387 | }
|
| 388 |
|
| 389 | fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
|
| 390 | let resolved = resolve_image_path(path, self.base_dir.as_deref());
|
| 391 | let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
|
| 392 | self.encode_gray_raster(&img.to_luma8(), width)
|
| 393 | }
|
| 394 |
|
| 395 | fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
|
| 396 | let (w, h) = gray.dimensions();
|
| 397 | let target_width = match width {
|
| 398 | ImageWidth::Percent(pct) => {
|
| 399 | (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
|
| 400 | }
|
| 401 | ImageWidth::Dots(d) => d as u32,
|
| 402 | ImageWidth::Default => self.metadata.printable_dots() as u32,
|
| 403 | };
|
| 404 | let new_w = target_width.min(w).max(1);
|
| 405 | let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
|
| 406 | let resized = image::imageops::resize(
|
| 407 | gray,
|
| 408 | new_w,
|
| 409 | new_h,
|
| 410 | image::imageops::FilterType::Nearest,
|
| 411 | );
|
| 412 | let bytes_per_row = ((new_w + 7) / 8) as usize;
|
| 413 | let mut raster = vec![0u8; bytes_per_row * new_h as usize];
|
| 414 | for y in 0..new_h {
|
| 415 | for x in 0..new_w {
|
| 416 | let pixel = resized.get_pixel(x, y).0[0];
|
| 417 | if pixel < 128 {
|
| 418 | let byte_index = (y as usize * bytes_per_row) + (x as usize / 8);
|
| 419 | let bit = 7 - (x % 8);
|
| 420 | raster[byte_index] |= 1 << bit;
|
| 421 | }
|
| 422 | }
|
| 423 | }
|
| 424 | let x_l = (bytes_per_row & 0xFF) as u8;
|
| 425 | let x_h = ((bytes_per_row >> 8) & 0xFF) as u8;
|
| 426 | let y_l = (new_h & 0xFF) as u8;
|
| 427 | let y_h = ((new_h >> 8) & 0xFF) as u8;
|
| 428 | // GS v 0 normal raster — same header as print-bridge / node-escpos:
|
| 429 | // 1D 76 30 00, xL xH (bytes/row), yL yH (dots), then bitmap bytes.
|
| 430 | self.buffer
|
| 431 | .extend_from_slice(&[0x1D, b'v', 0x30, 0x00, x_l, x_h, y_l, y_h]);
|
| 432 | self.buffer.extend_from_slice(&raster);
|
| 433 | // LF prints/flushes the raster; without it the next graphic can butt against this one.
|
| 434 | self.buffer.push(b'\n');
|
| 435 | Ok(())
|
| 436 | }
|
| 437 | }
|
| 438 |
|
| 439 | fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> std::path::PathBuf {
|
| 440 | let p = Path::new(path);
|
| 441 | if p.is_absolute() {
|
| 442 | p.to_path_buf()
|
| 443 | } else if let Some(base) = base_dir {
|
| 444 | base.join(p)
|
| 445 | } else {
|
| 446 | p.to_path_buf()
|
| 447 | }
|
| 448 | }
|
| 449 |
|
| 450 | fn inlines_to_plain(inlines: &[Inline]) -> String {
|
| 451 | let mut out = String::new();
|
| 452 | for inline in inlines {
|
| 453 | match inline {
|
| 454 | Inline::Text(t) => out.push_str(t),
|
| 455 | Inline::Param(t) => out.push_str(t),
|
| 456 | Inline::Checkbox { checked } => out.push_str(crate::dsl::checkbox_glyph(*checked)),
|
| 457 | }
|
| 458 | }
|
| 459 | out
|
| 460 | }
|
| 461 |
|
| 462 | #[cfg(test)]
|
| 463 | mod tests {
|
| 464 | use super::*;
|
| 465 | use crate::dsl::{parse, Block};
|
| 466 |
|
| 467 | #[test]
|
| 468 | fn heading_wraps_like_preview_on_narrow_paper() {
|
| 469 | let doc = parse("# Proof of Transfer").unwrap();
|
| 470 | let mut enc = EscPosEncoder::new(PosMetadata {
|
| 471 | page_width_mm: 53.0,
|
| 472 | ..Default::default()
|
| 473 | });
|
| 474 | let bytes = enc.encode_document(&doc).unwrap();
|
| 475 | let text = String::from_utf8_lossy(bytes);
|
| 476 | assert!(
|
| 477 | text.contains("Proof of\n"),
|
| 478 | "expected word wrap before Transfer, got: {text}"
|
| 479 | );
|
| 480 | assert!(
|
| 481 | text.contains("Transfer\n"),
|
| 482 | "expected wrapped second line, got: {text}"
|
| 483 | );
|
| 484 | }
|
| 485 |
|
| 486 | #[test]
|
| 487 | fn encodes_bullet_list_with_hanging_indent() {
|
| 488 | let doc = parse("- this is a long line").unwrap();
|
| 489 | let meta = PosMetadata {
|
| 490 | chars_per_line: Some(15),
|
| 491 | ..Default::default()
|
| 492 | };
|
| 493 | let mut enc = EscPosEncoder::new(meta);
|
| 494 | let bytes = enc.encode_document(&doc).unwrap();
|
| 495 | let text = String::from_utf8_lossy(bytes);
|
| 496 | assert!(text.contains("* this is a\n"));
|
| 497 | assert!(text.contains(" long line\n"));
|
| 498 | }
|
| 499 |
|
| 500 | #[test]
|
| 501 | fn encodes_inline_checkboxes_as_user_chars() {
|
| 502 | let doc = parse("[] hello [x]").unwrap();
|
| 503 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 504 | let bytes = enc.encode_document(&doc).unwrap();
|
| 505 | assert!(
|
| 506 | bytes.windows(2).any(|w| w == [0x1B, b'&']),
|
| 507 | "should define user-defined checkbox characters with ESC &"
|
| 508 | );
|
| 509 | assert!(
|
| 510 | bytes.windows(2).any(|w| w == [0x1B, b'%']),
|
| 511 | "should select user-defined character set"
|
| 512 | );
|
| 513 | assert!(
|
| 514 | bytes.windows(5).any(|w| w == b"hello"),
|
| 515 | "surrounding text should stay as native font bytes"
|
| 516 | );
|
| 517 | assert!(
|
| 518 | !bytes.windows(3).any(|w| w == [0x1B, b'*', 33]),
|
| 519 | "should not use ESC * bit images for checkboxes"
|
| 520 | );
|
| 521 | // `[] hello` → empty chars, space, then "hello"
|
| 522 | let hello = bytes.windows(5).position(|w| w == b"hello").unwrap();
|
| 523 | assert_eq!(bytes[hello - 1], b' ');
|
| 524 | assert_eq!(bytes[hello - 2], bitmap_font::CHAR_EMPTY_R);
|
| 525 | assert_eq!(bytes[hello - 3], bitmap_font::CHAR_EMPTY_L);
|
| 526 | }
|
| 527 |
|
| 528 | #[test]
|
| 529 | fn encodes_init_and_text() {
|
| 530 | let doc = parse("Hello").unwrap();
|
| 531 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 532 | let bytes = enc.encode_document(&doc).unwrap();
|
| 533 | assert_eq!(&bytes[0..2], &[0x1B, b'@']);
|
| 534 | assert!(bytes.windows(5).any(|w| w == b"Hello"));
|
| 535 | }
|
| 536 |
|
| 537 | #[test]
|
| 538 | fn encodes_raster_barcode() {
|
| 539 | let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
|
| 540 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 541 | let bytes = enc.encode_document(&doc).unwrap();
|
| 542 | assert!(
|
| 543 | bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
|
| 544 | "expected GS v 0 raster header"
|
| 545 | );
|
| 546 | }
|
| 547 |
|
| 548 | #[test]
|
| 549 | fn raster_header_matches_print_bridge_format() {
|
| 550 | let doc = parse("@barcode RASTER CODE128 X").unwrap();
|
| 551 | let meta = PosMetadata {
|
| 552 | page_width_mm: 58.0,
|
| 553 | ..Default::default()
|
| 554 | };
|
| 555 | let mut enc = EscPosEncoder::new(meta.clone());
|
| 556 | let bytes = enc.encode_document(&doc).unwrap();
|
| 557 | let pos = bytes
|
| 558 | .windows(4)
|
| 559 | .position(|w| w == [0x1D, b'v', 0x30, 0x00])
|
| 560 | .expect("raster header");
|
| 561 | assert_eq!(&bytes[pos..pos + 4], &[0x1D, b'v', 0x30, 0x00]);
|
| 562 | let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]);
|
| 563 | let expected_bytes = ((meta.printable_dots() as u32 + 7) / 8) as u16;
|
| 564 | assert_eq!(
|
| 565 | x_bytes, expected_bytes,
|
| 566 | "barcode raster should span full printable width"
|
| 567 | );
|
| 568 | let y_dots = u16::from_le_bytes([bytes[pos + 6], bytes[pos + 7]]);
|
| 569 | assert!(y_dots > 0);
|
| 570 | }
|
| 571 |
|
| 572 | #[test]
|
| 573 | fn encodes_centered_heading() {
|
| 574 | let doc = parse(":center:\n# Hello").unwrap();
|
| 575 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 576 | let bytes = enc.encode_document(&doc).unwrap();
|
| 577 | assert!(bytes.windows(3).any(|w| w == [0x1B, b'a', 1]));
|
| 578 | assert!(bytes.windows(5).any(|w| w == b"Hello"));
|
| 579 | }
|
| 580 |
|
| 581 | #[test]
|
| 582 | fn encodes_date_directive() {
|
| 583 | let doc = parse("@date DD-YYYY-MM").unwrap();
|
| 584 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 585 | let bytes = enc.encode_document(&doc).unwrap();
|
| 586 | let text = String::from_utf8_lossy(bytes);
|
| 587 | assert!(text.contains('-'));
|
| 588 | }
|
| 589 |
|
| 590 | #[test]
|
| 591 | fn encodes_cut_directive() {
|
| 592 | let doc = parse("@cut").unwrap();
|
| 593 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 594 | let bytes = enc.encode_document(&doc).unwrap();
|
| 595 | assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
|
| 596 | }
|
| 597 |
|
| 598 | #[test]
|
| 599 | fn feed_uses_esc_d_for_blank_lines() {
|
| 600 | let doc = parse("A\n\nB").unwrap();
|
| 601 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 602 | let bytes = enc.encode_document(&doc).unwrap();
|
| 603 | assert!(bytes.windows(3).any(|w| w == [0x1B, b'd', 1]));
|
| 604 | }
|
| 605 |
|
| 606 | #[test]
|
| 607 | fn blank_line_between_barcode_and_qr_is_ordered_feed() {
|
| 608 | let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap();
|
| 609 | assert!(matches!(
|
| 610 | doc.blocks.as_slice(),
|
| 611 | [
|
| 612 | Block::Barcode { .. },
|
| 613 | Block::Feed(1),
|
| 614 | Block::Qr { .. },
|
| 615 | ]
|
| 616 | ));
|
| 617 | }
|
| 618 |
|
| 619 | #[test]
|
| 620 | fn blank_line_between_graphics_feeds_on_print() {
|
| 621 | let doc = parse("@barcode RASTER CODE128 X\n\n@qr RASTER Y scale=4").unwrap();
|
| 622 | let mut enc = EscPosEncoder::new(PosMetadata {
|
| 623 | page_width_mm: 53.0,
|
| 624 | ..Default::default()
|
| 625 | });
|
| 626 | let bytes = enc.encode_document(&doc).unwrap();
|
| 627 | let raster_positions: Vec<_> = bytes
|
| 628 | .windows(4)
|
| 629 | .enumerate()
|
| 630 | .filter(|(_, w)| *w == [0x1D, b'v', 0x30, 0x00])
|
| 631 | .map(|(i, _)| i)
|
| 632 | .collect();
|
| 633 | assert_eq!(raster_positions.len(), 2);
|
| 634 | let between = &bytes[raster_positions[0]..raster_positions[1]];
|
| 635 | assert!(
|
| 636 | between.windows(3).any(|w| w == [0x1B, b'd', 1]),
|
| 637 | "expected ESC d feed between raster graphics, got {} bytes",
|
| 638 | between.len()
|
| 639 | );
|
| 640 | }
|
| 641 |
|
| 642 | #[test]
|
| 643 | fn raster_graphic_ends_with_line_feed() {
|
| 644 | let doc = parse("@barcode RASTER CODE128 X").unwrap();
|
| 645 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 646 | let bytes = enc.encode_document(&doc).unwrap();
|
| 647 | let raster_start = bytes
|
| 648 | .windows(4)
|
| 649 | .position(|w| w == [0x1D, b'v', 0x30, 0x00])
|
| 650 | .expect("raster header");
|
| 651 | assert!(
|
| 652 | bytes[raster_start..].contains(&b'\n'),
|
| 653 | "expected LF after raster data"
|
| 654 | );
|
| 655 | }
|
| 656 |
|
| 657 | #[test]
|
| 658 | fn does_not_auto_cut_without_directive() {
|
| 659 | let doc = parse("x").unwrap();
|
| 660 | let mut enc = EscPosEncoder::new(PosMetadata::default());
|
| 661 | let bytes = enc.encode_document(&doc).unwrap();
|
| 662 | assert!(!bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
|
| 663 | }
|
| 664 | }
|