write_barcodes.rs

//! Draws every linear barcode a request can ask for by name, each one beside
//! what a scanner reads back from it.
//!
//! A linear code is a run of bars and spaces built out of one width — a module
//! — and a reader needs a clear margin each side. Each box on this page is
//! filled the way a request fills it: a margin of `QUIET_ZONE` modules each
//! side, and the bars taking the rest of the width at the box's full height.
//!
//! What the page says about the codes is held in `Words`, once per language,
//! and `HQF_PDF_LANG` picks which set the sheet is written in. What the codes
//! carry stands apart from them: a scanner reads it, and it is the same in
//! every language.
//!
//! Usage: `cargo run --example write_barcodes -- tmp/barcodes.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_barcodes -- tmp/barcodes_fr.pdf`

use std::env;
use std::fs;
use std::path::{Path, PathBuf};

use hqf_pdf::barcode::QUIET_ZONE;
use hqf_pdf::content::Content;
use hqf_pdf::layout::Align;
use hqf_pdf::{
    AddOn2, AddOn5, Codabar, Code39, Code93, DataBar, Document, Ean13, Error, Font, FontHandle,
    Itf14, Page, TextFlow, UpcE,
};

#[path = "shared/out.rs"]
mod out;

#[path = "shared/licence.rs"]
mod licence;

#[path = "shared/language.rs"]
mod language;

#[path = "shared/failure.rs"]
mod failure;

use language::Language;

/// The font the example draws with when none is given on the command line.
fn default_font() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("fonts")
        .join("DejaVuSans.ttf")
}

/// The words the sheet is written in, one set per language.
#[derive(Debug)]
struct Words {
    /// What the file says it is, in what it says of itself.
    title: &'static str,
    /// The heading at the top of the sheet.
    heading: &'static str,
    /// What the sheet says under its heading, a line each.
    lines: [&'static str; 2],
    /// What stands under each code, in the order the page draws them: the
    /// symbology, where it is met, and what a scanner reads back from it.
    captions: [&'static str; 9],
}

impl Words {
    /// The words the sheet is written in, in `language`.
    fn of(language: Language) -> &'static Self {
        language::pick(&WORDS, language)
    }
}

/// The sheet in English.
const ENGLISH: Words = Words {
    title: "The linear barcodes a request can ask for by name",
    heading: "The barcodes a workshop, a warehouse and a till read",
    lines: [
        "Each box below is one module to the point, so every bar edge lands on a whole",
        "pixel of a printer. Under each code is what a scanner reads back from it.",
    ],
    captions: [
        "Code 39, the workshop label: BAY 12-A",
        "Code 39 carrying its modulo 43 check character: 159F",
        "Code 93, the same text in half the room: BAY 12-A",
        "ITF-14, the outer case a shop takes delivery of: 00012345678905",
        "Codabar, the blood bag and the borrower's card: A31600$D",
        "UPC-E, the small North American package: 01234565",
        "A magazine, its issue number in a two-digit add-on: 9780201379624 53",
        "A book, the price its publisher suggests in a five-digit add-on: 9781234567897 51999",
        "GS1 DataBar, the loose cut of meat and the small pack: 00012345678905",
    ],
};

/// The sheet in French.
const FRENCH: Words = Words {
    title: "Les codes-barres linéaires qu’une requête peut demander par leur nom",
    heading: "Codes-barres d’atelier, d’entrepôt et de caisse",
    lines: [
        "Ci-dessous, un module mesure un point : chaque bord de barre tombe ainsi sur un",
        "pixel entier de l’imprimante. Sous chaque code, ce qu’un lecteur y lit.",
    ],
    captions: [
        "Code 39, l’étiquette d’atelier : BAY 12-A",
        "Code 39 avec son caractère de contrôle modulo 43 : 159F",
        "Code 93, le même texte dans deux fois moins de place : BAY 12-A",
        "ITF-14, le carton livré au magasin : 00012345678905",
        "Codabar, la poche de sang et la carte de bibliothèque : A31600$D",
        "UPC-E, le petit emballage nord-américain : 01234565",
        "Un magazine et son numéro, en extension à deux chiffres : 9780201379624 53",
        "Un livre et son prix conseillé, en extension à cinq chiffres : 9781234567897 51999",
        "GS1 DataBar, la viande à la coupe et le petit conditionnement : 00012345678905",
    ],
};

/// The sheet in German.
const GERMAN: Words = Words {
    title: "Die linearen Strichcodes, die eine Anfrage namentlich verlangen kann",
    heading: "Strichcodes für Werkstatt, Lager und Kasse",
    lines: [
        "Ein Modul misst hier einen Punkt, sodass jede Balkenkante auf ein ganzes",
        "Druckerpixel fällt. Unter jedem Code steht, was ein Scanner daraus liest.",
    ],
    captions: [
        "Code 39, das Werkstattetikett: BAY 12-A",
        "Code 39 mit Prüfzeichen nach Modulo 43: 159F",
        "Code 93, derselbe Text auf halber Breite: BAY 12-A",
        "ITF-14, der Umkarton, den ein Laden geliefert bekommt: 00012345678905",
        "Codabar, der Blutbeutel und der Bibliotheksausweis: A31600$D",
        "UPC-E, die kleine nordamerikanische Packung: 01234565",
        "Eine Zeitschrift mit der Heftnummer im zweistelligen Zusatzcode: 9780201379624 53",
        "Ein Buch mit Preisempfehlung im fünfstelligen Zusatzcode: 9781234567897 51999",
        "GS1 DataBar, das Fleisch von der Theke und die kleine Packung: 00012345678905",
    ],
};

/// The sheet in Spanish.
const SPANISH: Words = Words {
    title: "Los códigos de barras lineales que una solicitud puede pedir por su nombre",
    heading: "Códigos de barras de taller, almacén y caja",
    lines: [
        "Abajo, un módulo mide un punto: así cada borde de barra cae en un píxel entero",
        "de la impresora. Bajo cada código figura lo que lee un escáner.",
    ],
    captions: [
        "Code 39, la etiqueta del taller: BAY 12-A",
        "Code 39 con su carácter de control módulo 43: 159F",
        "Code 93, el mismo texto en la mitad de espacio: BAY 12-A",
        "ITF-14, la caja de envío que recibe una tienda: 00012345678905",
        "Codabar, la bolsa de sangre y el carné de biblioteca: A31600$D",
        "UPC-E, el envase pequeño norteamericano: 01234565",
        "Una revista y su número, en un suplemento de dos cifras: 9780201379624 53",
        "Un libro y su precio recomendado, en un suplemento de cinco cifras: 9781234567897 51999",
        "GS1 DataBar, la carne al corte y el envase pequeño: 00012345678905",
    ],
};

/// The sheet in Italian.
const ITALIAN: Words = Words {
    title: "I codici a barre lineari che una richiesta può chiedere per nome",
    heading: "Codici a barre per officina, magazzino e cassa",
    lines: [
        "Qui sotto un modulo misura un punto: ogni bordo di barra cade così su un pixel",
        "intero della stampante. Sotto ogni codice, ciò che un lettore vi legge.",
    ],
    captions: [
        "Code 39, l’etichetta d’officina: BAY 12-A",
        "Code 39 con il suo carattere di controllo modulo 43: 159F",
        "Code 93, lo stesso testo in metà dello spazio: BAY 12-A",
        "ITF-14, il cartone che un negozio riceve in consegna: 00012345678905",
        "Codabar, la sacca di sangue e la tessera della biblioteca: A31600$D",
        "UPC-E, la piccola confezione nordamericana: 01234565",
        "Una rivista e il suo numero, in un codice aggiuntivo a due cifre: 9780201379624 53",
        "Un libro e il prezzo consigliato, in un codice aggiuntivo a cinque cifre: \
9781234567897 51999",
        "GS1 DataBar, la carne al taglio e la piccola confezione: 00012345678905",
    ],
};

/// The sheet in Portuguese.
const PORTUGUESE: Words = Words {
    title: "Os códigos de barras lineares que um pedido pode designar pelo nome",
    heading: "Códigos de barras de oficina, armazém e loja",
    lines: [
        "Abaixo, cada módulo mede um ponto: assim, cada bordo de barra cai num píxel",
        "inteiro da impressora. Sob cada código está o que um leitor ótico lê nele.",
    ],
    captions: [
        "Code 39, a etiqueta da oficina: BAY 12-A",
        "Code 39 com o seu carácter de controlo módulo 43: 159F",
        "Code 93, o mesmo texto em metade do espaço: BAY 12-A",
        "ITF-14, a caixa de transporte que uma loja recebe: 00012345678905",
        "Codabar, a bolsa de sangue e o cartão de leitor: A31600$D",
        "UPC-E, a pequena embalagem norte-americana: 01234565",
        "Uma revista e o número da edição, num código suplementar de dois dígitos: \
9780201379624 53",
        "Um livro e o seu preço, num código suplementar de cinco dígitos: 9781234567897 51999",
        "GS1 DataBar, a carne ao corte e a embalagem pequena: 00012345678905",
    ],
};

/// The sheet in Dutch.
const DUTCH: Words = Words {
    title: "De lineaire streepjescodes die een verzoek bij naam kan opvragen",
    heading: "Streepjescodes voor werkplaats, magazijn en kassa",
    lines: [
        "Hieronder meet één module één punt, zodat elke streeprand op een hele pixel",
        "van de printer valt. Onder elke code staat wat een scanner eruit leest.",
    ],
    captions: [
        "Code 39, het werkplaatsetiket: BAY 12-A",
        "Code 39 met modulo-43-controleteken: 159F",
        "Code 93, dezelfde tekst in half zoveel ruimte: BAY 12-A",
        "ITF-14, de omdoos die een winkel binnenkrijgt: 00012345678905",
        "Codabar, de bloedzak en de bibliotheekpas: A31600$D",
        "UPC-E, de kleine Noord-Amerikaanse verpakking: 01234565",
        "Een tijdschrift, met het nummer in een aanvullende code van twee cijfers: \
9780201379624 53",
        "Een boek, met de adviesprijs in een aanvullende code van vijf cijfers: \
9781234567897 51999",
        "GS1 DataBar, los verkocht vlees en de kleine verpakking: 00012345678905",
    ],
};

/// Every language the example is written in. A language is added by writing its
/// own set of words and naming it here.
static WORDS: [(Language, &Words); 7] = [
    (Language::English, &ENGLISH),
    (Language::French, &FRENCH),
    (Language::German, &GERMAN),
    (Language::Spanish, &SPANISH),
    (Language::Italian, &ITALIAN),
    (Language::Portuguese, &PORTUGUESE),
    (Language::Dutch, &DUTCH),
];

/// The box a block of words goes in, and how it is set.
struct Block {
    size: f64,
    left: f64,
    top: f64,
    width: f64,
    set: Option<(f64, Align)>,
}

/// The box a code goes in: its lower-left corner and how far it runs.
struct Box2 {
    left: f64,
    low: f64,
    width: f64,
    height: f64,
}

fn main() -> std::process::ExitCode {
    failure::reported(run())
}

/// Writes the file, and says where it went.
fn run() -> Result<(), Box<dyn std::error::Error>> {
    let language = Language::from_environment()?;
    let words = Words::of(language);

    let mut args = env::args().skip(1);
    // A named file is written as named; the default one carries the language,
    // so the languages do not overwrite each other in `tmp/`.
    let path = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("barcodes")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    doc.set_info(hqf_pdf::cos::Name::new("Title"), words.title);

    let font = doc.add_font(Font::parse(fs::read(&font_path)?)?);
    doc.add_page(sheet(&font, words)?)?;

    let bytes = doc.to_bytes()?;
    if let Some(parent) = Path::new(&path).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&path, &bytes)?;
    println!("wrote {path}: {} bytes", bytes.len());
    Ok(())
}

/// The one page: every code, each under the words that name it.
fn sheet(font: &FontHandle, words: &Words) -> Result<Page, Error> {
    let mut c = Content::new();

    run_1(&mut c, font, words)?;
    run_2(&mut c, font, words)?;
    run_3(&mut c, font, words)?;
    run_4(&mut c, font, words)?;
    run_5(&mut c, font, words)?;

    let mut page = Page::a4();
    page.content = c.into_bytes();
    Ok(page)
}

/// The 1ᵗʰ run of what the page draws, in order.
fn run_1(c: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    block(
        c,
        font,
        &Block {
            size: 16.0,
            left: 72.000,
            top: 813.200,
            width: 451.276,
            set: None,
        },
        words.heading,
    )?;
    block(
        c,
        font,
        &Block {
            size: 10.5,
            left: 72.000,
            top: 782.600,
            width: 451.276,
            set: None,
        },
        words.lines[0],
    )?;
    block(
        c,
        font,
        &Block {
            size: 10.5,
            left: 72.000,
            top: 767.600,
            width: 451.276,
            set: None,
        },
        words.lines[1],
    )?;
    bars(
        c,
        &Code39::new("BAY 12-A")?,
        Content::draw_code39,
        &Box2 {
            left: 72.000,
            low: 690.000,
            width: 179.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 684.000,
            width: 451.276,
            set: None,
        },
        words.captions[0],
    )?;
    Ok(())
}

/// The 2ᵗʰ run of what the page draws, in order.
fn run_2(c: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    bars(
        c,
        &Code39::with_check_digit("159")?,
        Content::draw_code39,
        &Box2 {
            left: 72.000,
            low: 618.000,
            width: 115.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 612.000,
            width: 451.276,
            set: None,
        },
        words.captions[1],
    )?;
    bars(
        c,
        &Code93::new("BAY 12-A")?,
        Content::draw_code93,
        &Box2 {
            left: 72.000,
            low: 546.000,
            width: 129.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 540.000,
            width: 451.276,
            set: None,
        },
        words.captions[2],
    )?;
    bars(
        c,
        &Itf14::new("00012345678905")?,
        Content::draw_itf14,
        &Box2 {
            left: 72.000,
            low: 474.000,
            width: 155.000,
            height: 40.000,
        },
    )?;
    Ok(())
}

/// The 3ᵗʰ run of what the page draws, in order.
fn run_3(c: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 468.000,
            width: 451.276,
            set: None,
        },
        words.captions[3],
    )?;
    bars(
        c,
        &Codabar::new("A31600$D")?,
        Content::draw_codabar,
        &Box2 {
            left: 72.000,
            low: 402.000,
            width: 119.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 396.000,
            width: 451.276,
            set: None,
        },
        words.captions[4],
    )?;
    bars(
        c,
        &UpcE::new("01234565")?,
        Content::draw_upc_e,
        &Box2 {
            left: 72.000,
            low: 330.000,
            width: 71.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 324.000,
            width: 451.276,
            set: None,
        },
        words.captions[5],
    )?;
    Ok(())
}

/// The 4ᵗʰ run of what the page draws, in order.
fn run_4(c: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    bars(
        c,
        &Ean13::new("9780201379624")?,
        Content::draw_ean13,
        &Box2 {
            left: 72.000,
            low: 258.000,
            width: 115.000,
            height: 40.000,
        },
    )?;
    bars(
        c,
        &AddOn2::new("53")?,
        Content::draw_add_on2,
        &Box2 {
            left: 176.000,
            low: 258.000,
            width: 40.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 252.000,
            width: 451.276,
            set: None,
        },
        words.captions[6],
    )?;
    bars(
        c,
        &Ean13::new("9781234567897")?,
        Content::draw_ean13,
        &Box2 {
            left: 72.000,
            low: 186.000,
            width: 115.000,
            height: 40.000,
        },
    )?;
    bars(
        c,
        &AddOn5::new("51999")?,
        Content::draw_add_on5,
        &Box2 {
            left: 176.000,
            low: 186.000,
            width: 67.000,
            height: 40.000,
        },
    )?;
    Ok(())
}

/// The 5ᵗʰ run of what the page draws, in order.
fn run_5(c: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 180.000,
            width: 451.276,
            set: None,
        },
        words.captions[7],
    )?;
    bars(
        c,
        &DataBar::new("00012345678905")?,
        Content::draw_data_bar,
        &Box2 {
            left: 72.000,
            low: 114.000,
            width: 116.000,
            height: 40.000,
        },
    )?;
    block(
        c,
        font,
        &Block {
            size: 9.0,
            left: 72.000,
            top: 108.000,
            width: 451.276,
            set: None,
        },
        words.captions[8],
    )?;
    Ok(())
}

/// Draws one block of words in the box it is given.
fn block(c: &mut Content, font: &FontHandle, at: &Block, text: &str) -> Result<(), Error> {
    let mut flow = TextFlow::new(font, at.size);
    if let Some((leading, align)) = at.set {
        flow = flow.leading(leading).align(align);
    }
    let lines = flow.break_lines(text, at.width);
    c.begin_text();
    flow.draw(c, &lines, at.left, at.top, at.width)?;
    c.end_text();
    Ok(())
}

/// What one symbology's drawing method looks like: the content it draws into,
/// the code, where it goes and how big.
type Drawn<T> =
    for<'a> fn(&'a mut Content, &T, f64, f64, f64, f64) -> Result<&'a mut Content, Error>;

/// Draws one code in the box it is given, with a margin of `QUIET_ZONE` modules
/// each side and the bars taking the rest of the width.
fn bars<T>(c: &mut Content, code: &T, drawn: Drawn<T>, at: &Box2) -> Result<(), Error>
where
    T: Modules,
{
    let modules = f64::from(u32::try_from(code.count()).unwrap_or(u32::MAX));
    let quiet = f64::from(u32::try_from(QUIET_ZONE).unwrap_or(u32::MAX));
    let unit = at.width / modules.mul_add(1.0, 2.0 * quiet);
    c.save_state();
    c.set_fill_rgb(0.0, 0.0, 0.0)?;
    drawn(
        c,
        code,
        quiet.mul_add(unit, at.left),
        at.low,
        modules * unit,
        at.height,
    )?;
    let _ = c;
    c.restore_state();
    Ok(())
}

/// How many modules a code is made of, whatever its symbology.
trait Modules {
    fn count(&self) -> usize;
}

impl Modules for AddOn2 {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for AddOn5 {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for Codabar {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for Code39 {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for Code93 {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for DataBar {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for Ean13 {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for Itf14 {
    fn count(&self) -> usize {
        self.module_count()
    }
}

impl Modules for UpcE {
    fn count(&self) -> usize {
        self.module_count()
    }
}

#[cfg(test)]
mod tests {
    use hqf_pdf::{Document, Font, TextFlow};

    use super::{WORDS, default_font, language};

    /// The width every block of words on the sheet is set in.
    const WIDTH: f64 = 451.276;

    /// The lines two languages are allowed to write the same way. What the
    /// codes carry is read by a scanner and stands apart from `Words`, and no
    /// two languages say the rest alike.
    const SPARED: [&str; 0] = [];

    #[test]
    fn every_language_writes_the_sheet_in_its_own_words() {
        let untranslated = language::untranslated_lines(&WORDS, &SPARED);

        assert!(
            untranslated.is_empty(),
            "the sheet says these in more than one language: {untranslated:?}"
        );
    }

    /// Each block is set on one line, a code standing a fixed step under it. A
    /// block broken onto a second line is drawn over the code below it.
    #[test]
    fn every_block_of_every_language_stays_on_one_line() {
        let mut doc = Document::new();
        let font = doc.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        );

        for (named, words) in WORDS {
            let blocks = std::iter::once((16.0, words.heading))
                .chain(words.lines.map(|line| (10.5, line)))
                .chain(words.captions.map(|caption| (9.0, caption)));
            for (size, text) in blocks {
                let lines = TextFlow::new(&font, size).break_lines(text, WIDTH).len();
                assert_eq!(
                    lines,
                    1,
                    "the {} sheet breaks {text:?} onto {lines} lines",
                    named.code()
                );
            }
        }
    }
}