EPL2 labels

use epl.qweruse epl_label, epl_job from epl      // Quillo 0.6: only these

image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }base64 = "0.22"encoding_rs = "0.8"

// A parcel desk's labels on an EPL2 printer (a Zebra LP 2844 or a GK420d in EPL mode): a// 4 × 3 inch product label with an EAN-13, a Code 128 and a QR code, and a pallet's carton labels.////   quillo run epl.qwe      then open http://localhost:8080/label//   PRINTER_HOST=192.168.1.61 quillo run epl.qwe      and http://localhost:8080/printuse "epl.qwer"let OPTIONS = { dpi: 203, width: 101.6, height: 76.2, gap: 3, speed: 3, density: 10 }fn product(p) = [    { image: "epl_sample.png", x: 4, y: 3, width: 30 },    { text: p.name, x: 38, y: 4, size: 5 },    { text: `Ref. ${p.sku} — ${p.weight}`, x: 38, y: 12, size: 3 },    { line: true, x: 3, y: 18, width: 95, thickness: 0.4 },    { barcode: "ean13", data: p.ean, x: 6, y: 22, height: 18, module: 2 },    { barcode: "code128", data: p.sku, x: 6, y: 50, height: 12, module: 2 },    { barcode: "qr", data: `https://shop.example/p/${p.sku}`, x: 72, y: 24, magnification: 5 },    { box: true, x: 2, y: 2, width: 97, height: 72, thickness: 0.5 },]let ITEM = { name: "Crème de marrons", sku: "CM-250-FR", weight: "250 g", ean: "3017620422003" }route GET /label = respond(200, epl_label(product(ITEM), OPTIONS)?, { "content-type": "text/plain; charset=utf-8" })route GET /cartons = epl_label([    { text: "CARTON 3 / 12", x: 4, y: 4, font: 4, multiply: 2 },    { text: "\"Fragile\" \\ this way up", x: 4, y: 20, font: 2, reverse: true },    { barcode: "code39", data: "PAL-0042-03", x: 4, y: 32, height: 15 },], merge(OPTIONS, { quantity: 1, copies: 2 }))route GET /saved = { bytes: epl_write(product(ITEM), OPTIONS, "data/label.epl")?, base64_start: slice(epl_job(product(ITEM), OPTIONS)?, 0, 12), setup: epl_setup({ width: 101.6, height: 76.2, media: "mark", speed: 2, density: 12 })? }route GET /print {    let host = env("PRINTER_HOST", null) ?? reply 503 "set PRINTER_HOST to the printer's address (host or host:port)"    { sent: epl_send(product(ITEM), OPTIONS, host, 5000)? }}

//! Zebra and Eltron EPL2 labels (LP 2844, TLP 2844, GK420 in EPL mode and other desktop printers) built from fields in millimetres: text in the built-in fonts (Windows-1252), Code 128, Code 39, EAN-13, UPC-A, Interleaved 2 of 5 and QR barcodes, lines, boxes and pictures (GW), label size, gap or black mark, speed, density and copies; sent to port 9100 or written to a USB printer.//! version: 1.0.0//!//! [dependencies]//! image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }//! base64 = "0.22"//! encoding_rs = "0.8"use serde_json::{json, Value};/// Text in Windows-1252 (EPL's `I8,A`), characters it lacks as `?`.fn cp1252(s: &str) -> Vec<u8> {    let mut out = vec![];    for c in s.chars() {        let mut buf = [0u8; 4];        let (bytes, _, bad) = encoding_rs::WINDOWS_1252.encode(c.encode_utf8(&mut buf));        if bad || bytes.len() != 1 { out.push(b'?') } else { out.push(bytes[0]) }    }    out}/// A quoted EPL string: `"` as `\"` and `\` as `\\`.fn quoted(s: &str) -> String {    let clean: String = s.chars().filter(|c| *c != '\n' && *c != '\r').collect();    format!("\"{}\"", clean.replace('\\', "\\\\").replace('"', "\\\""))}/// The resident font and multipliers nearest to `target` dots high: (font, horizontal, vertical).fn font_for(target: i64, dpi: i64) -> (i64, i64, i64) {    let heights: [i64; 5] = if dpi >= 250 { [20, 28, 36, 44, 80] } else { [12, 16, 20, 24, 48] };    let mut best = (2, 1, 1, i64::MAX);    for (i, h) in heights.iter().enumerate() {        for m in 1..=6 {            let d = (h * m - target).abs();            if d < best.3 {                best = (i as i64 + 1, m, m, d);            }        }    }    (best.0, best.1, best.2)}fn rotation(v: &Value) -> i64 {    match v.as_i64().unwrap_or(0).rem_euclid(360) {        90 => 1,        180 => 2,        270 => 3,        _ => 0,    }}fn build(fields: &[Value], options: &Value) -> Result<Out, String> {    if fields.len() > 2000 {        return Err("at most 2,000 fields on a label".into());    }    let dpi = options["dpi"].as_i64().unwrap_or(203);    let dpmm = if dpi >= 250 { 12.0 } else { 8.0 };    let units = options["units"].as_str().unwrap_or("mm").to_string();    let d = |v: &Value, def: f64| to_dots(v, def, dpmm, &units);    let mut o = Out::new();    // A line feed first ends anything half sent before; N clears the image buffer.    o.s("\nN\n");    o.s("I8,A,001\n");    if !options["width"].is_null() {        o.s(&format!("q{}\n", d(&options["width"], 100.0)));    }    let height = d(&options["height"], 50.0);    match options["media"].as_str().unwrap_or("gap") {        "gap" => o.s(&format!("Q{},{}\n", height, d(&options["gap"], 3.0))),        "mark" | "black_mark" => o.s(&format!("Q{},B{},{}\n", height, d(&options["gap"], 3.0), d(&options["mark_offset"], 0.0))),        "continuous" => o.s(&format!("Q{},0\n", height)),        other => return Err(format!("media {:?}: gap, mark or continuous", other)),    }    if let Some(s) = options["speed"].as_i64() {        o.s(&format!("S{}\n", s.clamp(1, 6)));    }    if let Some(dn) = options["density"].as_i64() {        o.s(&format!("D{}\n", dn.clamp(0, 15)));    }    o.s(if options["upside_down"] == true { "ZB\n" } else { "ZT\n" });    if let Some(r) = options["reference"].as_array() {        o.s(&format!("R{},{}\n", d(&r.first().cloned().unwrap_or(json!(0)), 0.0), d(&r.get(1).cloned().unwrap_or(json!(0)), 0.0)));    }    for f in fields {        if let Some(raw) = f["raw"].as_str() {            o.s(raw);            o.s("\n");            continue;        }        let x = d(&f["x"], 0.0);        let y = d(&f["y"], 0.0);        let rot = rotation(&f["rotate"]);        if !f["text"].is_null() {            let text = text_of(&f["text"]);            let (font, hm, vm) = match f["font"].as_i64() {                Some(n) => (n.clamp(1, 5), f["multiply"].as_i64().unwrap_or(1).clamp(1, 6), f["multiply"].as_i64().unwrap_or(1).clamp(1, 9)),                None => font_for(d(&f["size"], 3.0).max(1), dpi),            };            let rev = if f["reverse"] == true { 'R' } else { 'N' };            let q = quoted(&text);            o.s(&format!("A{},{},{},{},{},{},{},", x, y, rot, font, hm, vm, rev));            o.t(&q, &cp1252(&q));            o.s("\n");        } else if let Some(kind) = f["barcode"].as_str() {            let data = text_of(&f["data"]);            if data.is_empty() {                return Err("a barcode needs its `data`".into());            }            let h = d(&f["height"], 15.0).max(1);            let narrow = f["module"].as_i64().unwrap_or(2).clamp(1, 10);            let wide = f["wide"].as_i64().unwrap_or(narrow * 3).clamp(2, 30);            let readable = if f["readable"] == false { 'N' } else { 'B' };            let digits = data.chars().all(|c| c.is_ascii_digit());            let code = match kind {                "code128" => {                    if !data.chars().all(|c| (' '..='~').contains(&c)) {                        return Err("Code 128 takes printable ASCII".into());                    }                    "1"                }                "code39" => {                    if !data.chars().all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || " -.$/+%".contains(c)) {                        return Err("Code 39 takes A-Z, 0-9, space and - . $ / + %".into());                    }                    "3"                }                "ean13" if digits && (data.len() == 12 || data.len() == 13) => "E30",                "upca" if digits && (data.len() == 11 || data.len() == 12) => "UA0",                "itf" if digits && data.len() % 2 == 0 => "2",                "ean13" | "upca" | "itf" => return Err(format!("{}: {:?} has the wrong digits (EAN-13 12, UPC-A 11, ITF an even count)", kind, data)),                "qr" => {                    let ecc = match f["ecc"].as_str().unwrap_or("M") {                        "L" => "L",                        "Q" => "Q",                        "H" => "H",                        _ => "M",                    };                    let scale = f["magnification"].as_i64().unwrap_or(4).clamp(1, 99);                    let q = quoted(&data);                    o.s(&format!("b{},{},Q,m2,s{},e{},iA,", x, y, scale, ecc));                    o.t(&q, &cp1252(&q));                    o.s("\n");                    continue;                }                other => return Err(format!("unknown barcode {:?}: code128, code39, ean13, upca, itf or qr", other)),            };            // EAN and UPC take the digits without their check digit; the printer adds it.            let data = match code {                "E30" if data.len() == 13 => data[..12].to_string(),                "UA0" if data.len() == 12 => data[..11].to_string(),                _ => data,            };            o.s(&format!("B{},{},{},{},{},{},{},{},{}\n", x, y, rot, code, narrow, wide, h, readable, quoted(&data)));        } else if f["box"] == true {            let t = d(&f["thickness"], 0.3).max(1);            o.s(&format!("X{},{},{},{},{}\n", x, y, t, x + d(&f["width"], 10.0), y + d(&f["height"], 10.0)));        } else if f["line"] == true {            let t = d(&f["thickness"], 0.3).max(1);            let (w, h) = if f["vertical"] == true { (t, d(&f["height"], 10.0).max(1)) } else { (d(&f["width"], 10.0).max(1), t) };            o.s(&format!("{}{},{},{},{}\n", if f["white"] == true { "LW" } else { "LO" }, x, y, w, h));        } else if let Some(path) = f["image"].as_str() {            let w = if f["width"].is_null() { None } else { Some(d(&f["width"], 0.0) as u32) };            let (pw, ph, rows) = bitmap(path, w, f["threshold"].as_u64().unwrap_or(128).clamp(1, 255) as u8, f["dither"] == true)?;            // EPL's GW: a 0 bit prints, a 1 bit is white.            let (bpr, data) = pack_rows(pw, &rows, false);            o.s(&format!("GW{},{},{},{},", x, y, bpr, ph));            o.blob(&data);            o.s("\n");        } else {            return Err(format!("a field is text, barcode, box, line, image or raw: {}", f));        }    }    let copies = options["copies"].as_i64().unwrap_or(1).clamp(1, 65535);    let sets = options["quantity"].as_i64().unwrap_or(1).clamp(1, 65535);    o.s(&format!("P{},{}\n", sets, copies));    Ok(o)}/// A label as EPL2, written for people: control bytes and pictures shown by name and size. Each field is a map at `x`, `y` (millimetres, or `units: "dots"`):/// `{ text, size: 3 (mm, the nearest resident font is taken) or font: 1-5 with multiply, rotate: 90, reverse }`, `{ barcode: "code128" | "code39" | "ean13" | "upca" | "itf" | "qr", data, height, module, readable, ecc, magnification }`,/// `{ box: true, width, height, thickness }`, `{ line: true, width, thickness, vertical, white }`, `{ image: "logo.png", width, dither }` or `{ raw: "..." }`./// `options`: `{ dpi: 203, width, height, media: "gap" | "mark" | "continuous", gap: 3, speed: 1-6, density: 0-15, quantity, copies, upside_down }`.pub fn epl_label(fields: Vec<serde_json::Value>, options: serde_json::Value) -> Result<String, String> {    Ok(build(&fields, &options)?.view())}/// The label's bytes in base64, to store or send another way.pub fn epl_job(fields: Vec<serde_json::Value>, options: serde_json::Value) -> Result<String, String> {    Ok(b64(&build(&fields, &options)?.bytes))}/// Writes the label to a file or a USB printer's device (`/dev/usb/lp0`). Gives the bytes written.pub fn epl_write(fields: Vec<serde_json::Value>, options: serde_json::Value, path: &str) -> Result<i64, String> {    write_bytes(&build(&fields, &options)?.bytes, path)}/// Sends the label to a printer's raw port (`host` or `host:port`, 9100 when not given). Gives the bytes sent.pub fn epl_send(fields: Vec<serde_json::Value>, options: serde_json::Value, host: &str, timeout_ms: i64) -> Result<i64, String> {    send_bytes(&build(&fields, &options)?.bytes, host, timeout_ms)}/// Settings that stay in the printer: `{ width, height, gap, media, speed, density, dpi }` as q, Q, S and D, without printing; `autosense: true` adds xa to measure the labels.pub fn epl_setup(options: serde_json::Value) -> Result<String, String> {    let o = build(&[], &options)?;    let mut t = o.text.replace("\nP1,1\n", "\n");    if options["autosense"] == true {        t.push_str("xa\n");    }    Ok(t)}/// Sends EPL commands written as text (from `epl_setup` or by hand) to a printer. Gives the bytes sent.pub fn epl_send_commands(commands: &str, host: &str, timeout_ms: i64) -> Result<i64, String> {    send_bytes(&cp1252(commands), host, timeout_ms)}// ---- Shared by the printer plugins: the job's bytes and a readable copy, pictures as bits, the network./// A job's bytes, and the same job written for people: control bytes as `<ESC>`, graphics as `<N bytes>`.struct Out {    bytes: Vec<u8>,    text: String,}fn control_name(c: u8) -> String {    match c {        0x00 => "<NUL>".into(),        0x02 => "<STX>".into(),        0x03 => "<ETX>".into(),        0x0a => "\n".into(),        0x0c => "<FF>".into(),        0x0d => "<CR>".into(),        0x17 => "<ETB>".into(),        0x18 => "<CAN>".into(),        0x1b => "<ESC>".into(),        0x1e => "<RS>".into(),        c if c < 0x20 || c == 0x7f => format!("<{:02X}>", c),        c => (c as char).to_string(),    }}impl Out {    fn new() -> Out {        Out { bytes: vec![], text: String::new() }    }    /// Command bytes, shown as they are with control bytes named.    fn b(&mut self, data: &[u8]) {        self.bytes.extend_from_slice(data);        for c in data {            self.text.push_str(&control_name(*c));        }    }    /// ASCII command text.    fn s(&mut self, s: &str) {        self.b(s.as_bytes());    }    /// Text already encoded for the printer (`enc`), shown as written.    fn t(&mut self, shown: &str, enc: &[u8]) {        self.bytes.extend_from_slice(enc);        for c in shown.chars() {            if (c as u32) < 0x20 {                self.text.push_str(&control_name(c as u8));            } else {                self.text.push(c);            }        }    }    /// Text for the readable copy only (a line break between commands), not sent.    fn note(&mut self, s: &str) {        self.text.push_str(s);    }    /// The job for people: CR LF line ends shown as plain line breaks.    fn view(&self) -> String {        self.text.replace("<CR>\n", "\n")    }    /// Binary data (a picture), shown by its size.    fn blob(&mut self, data: &[u8]) {        self.bytes.extend_from_slice(data);        self.text.push_str(&format!("<{} bytes>", data.len()));    }}/// Dots per millimetre for a resolution in dpi.fn dots_per_mm(dpi: i64) -> f64 {    dpi.clamp(100, 1200) as f64 / 25.4}/// A length given in `units` ("mm", the default, "in" or "dots") as dots.fn to_dots(v: &Value, default: f64, dpmm: f64, units: &str) -> i64 {    let x = v.as_f64().unwrap_or(default);    let d = match units {        "dots" => x,        "in" | "inch" | "inches" => x * 25.4 * dpmm,        _ => x * dpmm,    };    d.round().max(0.0) as i64}/// A picture as rows of bits, true for black: scaled to `width` dots when given, dithered or cut at a threshold, transparency as white.fn bitmap(path: &str, width: Option<u32>, threshold: u8, dither: bool) -> Result<(usize, usize, Vec<Vec<bool>>), String> {    let img = image::open(path).map_err(|e| format!("{}: {}", path, e))?;    let img = match width {        Some(w) if w > 0 && w != img.width() => {            let h = ((img.height() as f64) * (w as f64) / (img.width() as f64)).round().max(1.0) as u32;            img.resize_exact(w, h, image::imageops::FilterType::Triangle)        }        _ => img,    };    let rgba = img.to_rgba8();    let (w, h) = (rgba.width() as usize, rgba.height() as usize);    if w * h > 8_000_000 {        return Err("the picture is over 8 million dots: give a width".into());    }    let mut lum: Vec<f32> = rgba        .pixels()        .map(|p| {            let a = p[3] as f32 / 255.0;            (0.299 * p[0] as f32 + 0.587 * p[1] as f32 + 0.114 * p[2] as f32) * a + 255.0 * (1.0 - a)        })        .collect();    let mut rows = vec![vec![false; w]; h];    for y in 0..h {        for x in 0..w {            let old = lum[y * w + x];            let black = old < threshold as f32;            rows[y][x] = black;            if dither {                let err = old - if black { 0.0 } else { 255.0 };                for (dx, dy, f) in [(1isize, 0usize, 7.0f32 / 16.0), (-1, 1, 3.0 / 16.0), (0, 1, 5.0 / 16.0), (1, 1, 1.0 / 16.0)] {                    let nx = x as isize + dx;                    if nx >= 0 && (nx as usize) < w && y + dy < h {                        lum[(y + dy) * w + nx as usize] += err * f;                    }                }            }        }    }    Ok((w, h, rows))}/// Rows of bits packed 8 dots to a byte, the first dot in the high bit; `black_is_one` false for printers where 0 prints.fn pack_rows(w: usize, rows: &[Vec<bool>], black_is_one: bool) -> (usize, Vec<u8>) {    let bpr = (w + 7) / 8;    let mut out = Vec::with_capacity(bpr * rows.len());    for r in rows {        for b in 0..bpr {            let mut byte = 0u8;            for bit in 0..8 {                let x = b * 8 + bit;                let black = x < w && r[x];                if black == black_is_one {                    byte |= 0x80 >> bit;                }            }            out.push(byte);        }    }    (bpr, out)}/// `host`, `host:port` or `[v6]:port` as an address; `port` when none is written.fn printer_addr(host: &str, port: u16) -> Result<std::net::SocketAddr, String> {    use std::net::ToSocketAddrs;    let h = host.trim();    let with_port = if h.starts_with('[') {        if h.contains("]:") { h.to_string() } else { format!("{}:{}", h, port) }    } else if h.matches(':').count() == 1 {        h.to_string()    } else if h.contains(':') {        format!("[{}]:{}", h, port)    } else {        format!("{}:{}", h, port)    };    with_port.to_socket_addrs().map_err(|e| format!("{}: {}", host, e))?.next().ok_or(format!("{} has no address", host))}fn connect(host: &str, timeout_ms: i64) -> Result<std::net::TcpStream, String> {    let t = std::time::Duration::from_millis(timeout_ms.clamp(100, 120_000) as u64);    let addr = printer_addr(host, 9100)?;    let s = std::net::TcpStream::connect_timeout(&addr, t).map_err(|e| format!("cannot reach the printer at {}: {}", addr, e))?;    s.set_write_timeout(Some(t)).map_err(|e| e.to_string())?;    s.set_read_timeout(Some(t)).map_err(|e| e.to_string())?;    Ok(s)}/// Sends bytes to a printer's raw port and closes it.fn send_bytes(bytes: &[u8], host: &str, timeout_ms: i64) -> Result<i64, String> {    use std::io::Write;    let mut s = connect(host, timeout_ms)?;    s.write_all(bytes).map_err(|e| format!("sending to the printer: {}", e))?;    s.flush().map_err(|e| e.to_string())?;    Ok(bytes.len() as i64)}/// Writes bytes to a file or a device (`/dev/usb/lp0`), folders made for a file.fn write_bytes(bytes: &[u8], path: &str) -> Result<i64, String> {    use std::io::Write;    let p = std::path::Path::new(path);    let device = path.starts_with("/dev/");    if !device {        if let Some(dir) = p.parent() {            if !dir.as_os_str().is_empty() {                std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;            }        }    }    let mut f = std::fs::OpenOptions::new().write(true).create(!device).truncate(!device).open(p).map_err(|e| format!("{}: {}", path, e))?;    f.write_all(bytes).map_err(|e| format!("{}: {}", path, e))?;    Ok(bytes.len() as i64)}fn b64(bytes: &[u8]) -> String {    use base64::Engine;    base64::engine::general_purpose::STANDARD.encode(bytes)}fn text_of(v: &Value) -> String {    match v {        Value::String(s) => s.clone(),        Value::Null => String::new(),        other => other.to_string(),    }}