Functional xml parser and sed integration

src/escpos.rs

@@ -0,0 +1,305 @@
+use std::{error::Error, fmt::Display};
+
+use image::{
+    DynamicImage, GrayImage,
+    imageops::{self, FilterType, colorops},
+};
+use serde::Deserialize;
+
+// TYPES
+#[derive(Debug)]
+pub enum EscPosError {
+    InvalidBarcodeLength(String),
+}
+
+#[repr(u8)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum QREcc {
+    Low = 48,
+    Medium = 49,
+    Quartile = 50,
+    High = 51,
+}
+#[repr(u8)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum BARTextPosition {
+    Hidden = 0,
+    Above = 1,
+    Below = 2,
+    Both = 3,
+}
+#[repr(u8)]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum BARType {
+    Code128 = 0x49,
+    Ean13 = 0x43,
+    Upca = 0x41,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ImageOrientation {
+    Preserve,
+    Largest,
+    LargestOrientation,
+}
+
+#[repr(u8)]
+#[derive(Debug, Deserialize, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum JustifyOrientation {
+    #[default]
+    Left = 0,
+    Center = 1,
+    Right = 2,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum TextEffect {
+    Bold,
+    DoubleHeight,
+    DoubleWidth,
+    // InvertColor,
+    Justify(JustifyOrientation),
+}
+
+pub struct EscPosBuilder {
+    pub content: Vec<u8>,
+    max_width: u16,
+}
+
+fn is_numeric(s: &[u8]) -> bool {
+    s.iter().all(|&b| b.is_ascii_digit())
+}
+fn bitmap_auto_brighten(gray: &mut GrayImage) {
+    let avg = gray.pixels().map(|p| p.0[0] as u32).sum::<u32>() / gray.len() as u32;
+
+    if avg < 100 {
+        colorops::brighten_in_place(gray, 40);
+        colorops::contrast_in_place(gray, 25.0);
+    } else if avg > 180 {
+        colorops::brighten_in_place(gray, -15);
+    }
+}
+fn bitmap_pack_bits(w: usize, h: usize, gray: &GrayImage) -> Vec<u8> {
+    let pitch = (w + 7) >> 3; // pixels per row
+    let mut bits = vec![0u8; pitch * h];
+
+    for y in 0..h {
+        for x in 0..w {
+            let byte = y * pitch + (x >> 3); // get index of byte that contains bit for the current pixel
+            let bit = 7 - (x & 7); // get bit position in byte
+            if gray[(x as u32, y as u32)].0[0] == 0 {
+                // if the pixel is black, set it to one
+                bits[byte] |= 1 << bit;
+            }
+        }
+    }
+
+    bits
+}
+
+impl Copy for JustifyOrientation {}
+impl Clone for JustifyOrientation {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Error for EscPosError {}
+impl Display for EscPosError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        todo!()
+    }
+}
+
+impl EscPosBuilder {
+    fn extend(&mut self, slice: &[u8]) {
+        self.content.extend([0x1B, b'@']);
+        self.content.extend(slice);
+    }
+
+    pub fn new(max_width: u16) -> Self {
+        EscPosBuilder {
+            content: vec![0x1B, b'@'],
+            max_width,
+        }
+    }
+
+    pub fn write_feed(&mut self, amount: Option<u8>) {
+        let amount = amount.unwrap_or(1);
+        self.extend(&[0x1B, b'd', amount])
+    }
+
+    pub fn write_justify(&mut self, justify: JustifyOrientation) {
+        self.extend(&[0x1B, b'a', justify as u8]);
+    }
+
+    pub fn write_text(&mut self, text: &str, text_effect: Option<&[TextEffect]>) -> () {
+        let mut buf: Vec<u8> = vec![];
+        buf.reserve(12 + text.len());
+
+        for i in text_effect.unwrap_or(&[]) {
+            match i {
+                TextEffect::Bold => buf.extend(&[0x1B, b'!', 8]),
+                TextEffect::DoubleWidth => buf.extend(&[0x1B, b'!', 0x10]),
+                TextEffect::DoubleHeight => buf.extend(&[0x1B, b'!', 0x20]),
+                TextEffect::Justify(orientation) => buf.extend(&[0x1B, b'a', *orientation as u8]),
+            }
+        }
+
+        buf.extend(text.as_bytes());
+        self.extend(&buf);
+    }
+
+    pub fn write_bitmap(
+        &mut self,
+        img: &DynamicImage,
+        orientation: Option<ImageOrientation>,
+    ) -> () {
+        let orientation = orientation.unwrap_or(ImageOrientation::Preserve);
+        let mw = self.max_width as u32;
+
+        let mut image = img.clone();
+
+        if matches!(orientation, ImageOrientation::LargestOrientation)
+            && image.width() > image.height()
+        {
+            image = image.rotate90();
+        }
+
+        let iw = image.width();
+        let ih = image.height();
+
+        let w = if iw > mw || !matches!(orientation, ImageOrientation::Preserve) {
+            mw
+        } else {
+            iw
+        };
+
+        let h = (ih * w) / iw;
+        let img = image.resize(w, h, FilterType::Triangle);
+
+        let mut gray = img.to_luma8();
+        imageops::dither(&mut gray, &imageops::colorops::BiLevel);
+        bitmap_auto_brighten(&mut gray);
+
+        let w = img.width();
+        let h = img.height();
+
+        let bits = bitmap_pack_bits(w as usize, h as usize, &gray);
+        let mut buf: Vec<u8> = vec![];
+
+        let width_bytes = ((w + 7) >> 3) as u16;
+        let height_u16 = h as u16;
+
+        buf.extend(&[
+            0x1D,
+            b'v',
+            b'0',
+            0,
+            (width_bytes & 0xFF) as u8,
+            ((width_bytes >> 8) & 0xFF) as u8,
+            (height_u16 & 0xFF) as u8,
+            ((height_u16 >> 8) & 0xFF) as u8,
+        ]);
+        buf.extend(bits);
+        self.extend(&buf);
+    }
+
+    pub fn write_qr(&mut self, text: &str, size: Option<u8>, ecc: Option<QREcc>) -> () {
+        let mut buf: Vec<u8> = vec![];
+        let ecc = ecc.unwrap_or(QREcc::Medium);
+        let size = match size {
+            Some(v) => v.clamp(6, 15),
+            None => 10,
+        };
+
+        let text = text.as_bytes();
+        let len = text.len() + 3;
+        buf.extend(&[
+            // Size
+            0x1D,
+            0x28,
+            0x6B,
+            0x03,
+            0x00,
+            0x31,
+            0x43,
+            size,
+            // Error correction level
+            0x1D,
+            0x28,
+            0x6B,
+            0x03,
+            0x00,
+            0x31,
+            0x45,
+            ecc as u8,
+            // Storing data...
+            0x1D,
+            0x28,
+            0x6B,
+            (len & 0xFF) as u8,
+            ((len >> 8) & 0xFF) as u8,
+            0x31,
+            0x50,
+            0x30,
+        ]);
+        buf.extend(text);
+        buf.extend(&[0x1D, 0x28, 0x6B, 0x03, 0x00, 0x31, 0x51, 0x30, 0x0A]); // Print!
+
+        self.extend(&buf);
+    }
+    pub fn write_barcode(
+        &mut self,
+        text: &str,
+        height: Option<u8>,
+        mod_width: Option<u8>,
+        text_position: Option<BARTextPosition>,
+        bar_type: Option<BARType>,
+    ) -> Result<(), EscPosError> {
+        let height: u8 = height.unwrap_or(80);
+        let mod_width: u8 = mod_width.unwrap_or(2);
+        let text_position = text_position.unwrap_or(BARTextPosition::Below) as u8;
+        let bar_type = bar_type.unwrap_or(BARType::Code128);
+
+        let text = text.as_bytes();
+        let len = text.len() as u8;
+        let is_num = is_numeric(text);
+        match bar_type {
+            BARType::Upca if len != 11 || !is_num => Err(EscPosError::InvalidBarcodeLength(
+                "UCPA Requires 11 numbers.".to_string(),
+            )),
+
+            BARType::Ean13 if len != 12 || !is_num => Err(EscPosError::InvalidBarcodeLength(
+                "EAN13 Requires 12 numbers.".to_string(),
+            )),
+            _ => Ok(()),
+        }?;
+
+        let mut buf: Vec<u8> = vec![];
+        buf.extend([
+            0x1D,
+            0x68,
+            height,
+            0x1D,
+            0x77,
+            mod_width,
+            0x1d,
+            0x48,
+            text_position,
+            0x1D,
+            0x6B,
+            bar_type as u8,
+            len,
+        ]);
+        buf.extend(text);
+        self.extend(&buf);
+
+        Ok(())
+    }
+}