BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

escpos.rs 25.1 KiB Download Raw
1use std::path::Path;
2
3use image::GrayImage;
4
5use crate::bitmap_font::{self, MixedSeg};
6use crate::dsl::{
7 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode,
8};
9use crate::io::PosMetadata;
10use crate::raster::{self, RasterError};
11use crate::text_wrap::{self, TextWrapStyle};
12
13#[derive(Debug)]
14pub enum EscPosError {
15 Image(String),
16 Barcode(String),
17 Raster(RasterError),
18 Io(String),
19}
20
21pub struct EscPosEncoder {
22 buffer: Vec<u8>,
23 metadata: PosMetadata,
24 base_dir: Option<std::path::PathBuf>,
25}
26
27impl 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
439fn 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
450fn 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)]
463mod 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}