write_drawing.rs

//! Draws one badge, and places it eight times.
//!
//! The badge — its frame, its coloured head, its mark — is built once as a
//! drawing, and the file holds its operators once however many times it is
//! placed. Each placing costs a name and a matrix. The names on the badges are
//! drawn by the page, over the drawing, because they are what differs.
//!
//! A second page places the badge once more, built this time with a matrix of
//! its own that turns it a quarter wherever it is placed, a packet of metadata
//! saying what it is, and the guest list carried as a file of its own; the page
//! states each from what the drawing says of itself. A file tied to a drawing
//! is PDF 2.0, so the file says so on its first line.
//!
//! Every position is measured from the top-left corner, `y` growing down the
//! page the way a screen measures: the badge in axes laid on its own box, each
//! page in axes laid on its sheet. The axes hand back the numbers PDF writes,
//! so the text stays upright and nothing is mirrored.
//!
//! What the page reads is held in `Words`, once per language, and
//! `HQF_PDF_LANG` picks which set is drawn. The guests' names are not language,
//! and neither is the company's: a name is written the way its owner writes it.
//!
//! Usage: `cargo run --example write_drawing -- tmp/drawing.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_drawing -- tmp/badges.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::metadata::attachment::{Attachment, Relationship};
use hqf_pdf::metadata::xmp::{Metadata, Xmp};
use hqf_pdf::{Axes, Document, Drawing, Font, FontHandle, Page, Rect, Rgb, Version};

#[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 size of one badge, in points.
const BADGE: (f64, f64) = (220.0, 96.0);

/// The left edge of everything the page draws.
const LEFT: f64 = 70.0;

/// The baseline of each page's title, down from the top edge of the sheet.
const TITLE: f64 = 61.89;

/// The baseline of the line under the first page's title.
const INTRO: f64 = 79.89;

/// The top edge of the first row of badges.
const FIRST_ROW: f64 = 145.89;

/// How far down from a badge's top edge the guest's name and trade sit.
const NAME: f64 = 48.0;
/// See [`NAME`].
const ROLE: f64 = 64.0;

/// The top edge of the badge placed at half size, and the baseline of the line
/// under it.
const HALF: f64 = 643.89;
/// See [`HALF`].
const HALF_CAPTION: f64 = 707.89;

/// The top edge of the second page's turned badge, and the baseline of the
/// first line beside it.
const TURNED_TOP: f64 = 101.89;
/// See [`TURNED_TOP`].
const TURNED_LINES: f64 = 121.89;

/// How many badges the page places.
const BADGES: usize = 8;

/// Who the badges are for. A name is not language.
const GUESTS: [&str; BADGES] = [
    "Amélie Roussel",
    "Bertrand Colin",
    "Chloé Marchand",
    "Damien Leclerc",
    "Élise Fontaine",
    "Fabien Deschamps",
    "Gabrielle Vidal",
    "Hugo Mercier",
];

/// The company the badges are issued by, drawn in the badge itself. A company
/// writes its name one way.
const COMPANY: &str = "HQF Development";

/// The words the page is written in, one set per language.
#[derive(Debug)]
struct Words {
    /// The line at the head of the page.
    title: &'static str,
    /// The line under it, saying what a drawing costs.
    intro: &'static str,
    /// What the badge itself says under the company's name, drawn once for all
    /// eight.
    occasion: &'static str,
    /// What each guest does, in the order the badges are placed.
    roles: [&'static str; BADGES],
    /// The line under the badge placed at half size.
    half: &'static str,
    /// The line at the head of the second page.
    turned_title: &'static str,
    /// What the second page says of the turned badge's matrix.
    turned: &'static str,
    /// What it says of its metadata; `{title}` stands for the title the
    /// metadata gives.
    says: &'static str,
    /// What it says of the files it carries; `{count}` stands for how many.
    carries: &'static str,
    /// The title the turned badge's metadata gives it.
    badge_title: &'static str,
    /// What the carried guest list is.
    list: &'static str,
}

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

/// The page in English.
const ENGLISH: Words = Words {
    title: "One badge, placed eight times",
    intro: "The badge is drawn once; the file holds its operators once, whatever it costs to place.",
    occasion: "Open house — visitor",
    roles: [
        "Bindery",
        "Typesetting",
        "Prepress",
        "Colour",
        "Plates",
        "Press",
        "Finishing",
        "Despatch",
    ],
    half: "The same drawing, placed at half size.",
    turned_title: "The badge, turned by a matrix of its own",
    turned: "Its own matrix turns it a quarter wherever it is placed.",
    says: "It says what it is in a packet of its own: {title}.",
    carries: "It carries {count} file of its own: the guest list.",
    badge_title: "Visitor badge",
    list: "The guests the badges are made for",
};

/// The page in French.
const FRENCH: Words = Words {
    title: "Un badge, posé huit fois",
    intro: "Dessiné une fois, le badge n’a qu’un jeu d’instructions, même posé huit fois.",
    occasion: "Portes ouvertes — visiteur",
    roles: [
        "Reliure",
        "Composition",
        "Prépresse",
        "Couleur",
        "Plaques",
        "Impression",
        "Façonnage",
        "Expédition",
    ],
    half: "Le même dessin, posé à la moitié de sa taille.",
    turned_title: "Le badge, tourné par sa propre matrice",
    turned: "Sa propre matrice le tourne d’un quart de tour où qu’on le pose.",
    says: "Il dit ce qu’il est dans son propre paquet : {title}.",
    carries: "Il contient {count} fichier bien à lui : la liste des invités.",
    badge_title: "Badge visiteur",
    list: "Les invités à qui les badges sont destinés",
};

/// The page in Dutch.
const DUTCH: Words = Words {
    title: "Eén badge, acht keer geplaatst",
    intro: "De badge wordt één keer getekend; zijn operatoren staan één keer in het bestand.",
    occasion: "Open dag — bezoeker",
    roles: [
        "Binderij",
        "Zetterij",
        "Prepress",
        "Kleur",
        "Platen",
        "Pers",
        "Afwerking",
        "Verzending",
    ],
    half: "Dezelfde tekening, op halve grootte geplaatst.",
    turned_title: "De badge, gedraaid door een eigen matrix",
    turned: "Zijn eigen matrix draait hem een kwartslag waar hij ook staat.",
    says: "Hij vermeldt in een eigen pakket wat hij is: {title}.",
    carries: "Hij bevat {count} eigen bestand: de gastenlijst.",
    badge_title: "Bezoekersbadge",
    list: "De gasten voor wie de badges gemaakt worden",
};

/// The page in Portuguese.
const PORTUGUESE: Words = Words {
    title: "Um crachá, colocado oito vezes",
    intro: "O crachá é desenhado uma vez; os seus operadores ficam uma só vez no ficheiro.",
    occasion: "Dia aberto — visitante",
    roles: [
        "Encadernação",
        "Composição",
        "Pré-impressão",
        "Cor",
        "Chapas",
        "Impressão",
        "Acabamento",
        "Expedição",
    ],
    half: "O mesmo desenho, colocado a meia escala.",
    turned_title: "O crachá, rodado por uma matriz própria",
    turned: "A sua matriz roda-o um quarto de volta onde quer que esteja.",
    says: "Diz o que é num pacote próprio: {title}.",
    carries: "Leva {count} ficheiro próprio: a lista de convidados.",
    badge_title: "Crachá de visitante",
    list: "Os convidados para quem se fazem os crachás",
};

/// The page in Italian.
const ITALIAN: Words = Words {
    title: "Un distintivo, collocato otto volte",
    intro: "Il distintivo è disegnato una volta; i suoi operatori stanno una sola volta nel file.",
    occasion: "Porte aperte — visitatore",
    roles: [
        "Legatoria",
        "Composizione",
        "Prestampa",
        "Colore",
        "Lastre",
        "Stampa",
        "Finitura",
        "Spedizione",
    ],
    half: "Lo stesso disegno, collocato a metà scala.",
    turned_title: "Il distintivo, ruotato da una matrice propria",
    turned: "La sua matrice lo ruota di un quarto ovunque sia collocato.",
    says: "Dice cosa è in un pacchetto proprio: {title}.",
    carries: "Porta {count} file proprio: l’elenco degli ospiti.",
    badge_title: "Distintivo visitatore",
    list: "Gli ospiti per cui si fanno i distintivi",
};

/// The page in Spanish.
const SPANISH: Words = Words {
    title: "Una insignia, colocada ocho veces",
    intro: "La insignia se dibuja una vez; sus operadores están una sola vez en el archivo.",
    occasion: "Puertas abiertas — visitante",
    roles: [
        "Encuadernación",
        "Composición",
        "Preimpresión",
        "Color",
        "Planchas",
        "Prensa",
        "Acabado",
        "Expedición",
    ],
    half: "El mismo dibujo, colocado a media escala.",
    turned_title: "La insignia, girada por una matriz propia",
    turned: "Su propia matriz la gira un cuarto dondequiera que se coloque.",
    says: "Dice lo que es en un paquete propio: {title}.",
    carries: "Lleva {count} archivo propio: la lista de invitados.",
    badge_title: "Insignia de visitante",
    list: "Los invitados para los que se hacen las insignias",
};

/// The page in German.
const GERMAN: Words = Words {
    title: "Ein Abzeichen, achtmal platziert",
    intro: "Einmal gezeichnet; die Datei enthält seine Operatoren einmal, wie oft es erscheint.",
    occasion: "Tag der offenen Tür — Besucher",
    roles: [
        "Buchbinderei",
        "Satz",
        "Druckvorstufe",
        "Farbe",
        "Platten",
        "Druck",
        "Weiterverarbeitung",
        "Versand",
    ],
    half: "Dieselbe Zeichnung, in halber Größe platziert.",
    turned_title: "Das Abzeichen, durch eine eigene Matrix gedreht",
    turned: "Seine Matrix dreht es um ein Viertel, wo immer es steht.",
    says: "Es sagt in einem eigenen Paket, was es ist: {title}.",
    carries: "Es trägt {count} eigene Datei: die Gästeliste.",
    badge_title: "Besucherabzeichen",
    list: "Die Gäste, für die die Abzeichen gemacht sind",
};

/// 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),
];

/// Draws one line of text with its baseline at `(x, y)` in `axes`.
fn text(
    content: &mut Content,
    font: &FontHandle,
    size: f64,
    (axes, x, y): (&Axes, f64, f64),
    line: &str,
) -> Result<(), hqf_pdf::Error> {
    let (x, y) = axes.point_to_page(x, y);
    content.begin_text();
    content.set_font(font, size)?;
    content.text_origin(x, y)?;
    content.show_glyphs(&font.glyphs(line));
    content.end_text();
    Ok(())
}

/// Draws `rect`, stated in `axes`, as a rectangle path.
fn rect<'a>(
    content: &'a mut Content,
    axes: &Axes,
    rect: Rect,
) -> Result<&'a mut Content, hqf_pdf::Error> {
    let placed = axes.rect_to_page(&rect);
    content.rect(placed.x(), placed.y(), placed.width(), placed.height())
}

/// The badge itself: everything every badge has, measured from the top-left
/// corner of its box.
fn badge(font: &FontHandle, words: &Words) -> Result<Drawing, hqf_pdf::Error> {
    let (width, height) = BADGE;
    let room = Rect::new(0.0, 0.0, width, height);
    let axes = Axes::top_left(room);
    let mut content = Content::new();

    content.set_fill(Rgb::new(0.96, 0.97, 0.99))?;
    rect(&mut content, &axes, Rect::new(0.0, 0.0, width, height))?.fill();

    content.set_fill(Rgb::new(0.12, 0.28, 0.52))?;
    rect(&mut content, &axes, Rect::new(0.0, 0.0, width, 24.0))?.fill();

    content.set_stroke(Rgb::new(0.12, 0.28, 0.52))?;
    content.set_line_width(1.0)?;
    rect(&mut content, &axes, Rect::new(0.0, 0.0, width, height))?.stroke();

    content.set_fill(Rgb::new(1.0, 1.0, 1.0))?;
    text(&mut content, font, 11.0, (&axes, 12.0, 17.0), COMPANY)?;

    content.set_fill(Rgb::gray(0.45))?;
    text(&mut content, font, 8.0, (&axes, 12.0, 84.0), words.occasion)?;

    Ok(Drawing::new(content, room))
}

/// What turns the second page's badge a quarter anticlockwise: its box, from
/// the origin, then stands to the left of the point it is placed at.
const QUARTER: [f64; 6] = [0.0, 1.0, -1.0, 0.0, 0.0, 0.0];

/// Where the second page's lines start, in points from the left edge.
const TURNED_TEXT: f64 = LEFT + 130.0;

/// The second page: the badge built with a matrix, metadata and a carried file
/// of its own, placed once, and what it says of each.
fn turned_page(
    doc: &mut Document,
    font: &FontHandle,
    words: &Words,
) -> Result<Page, hqf_pdf::Error> {
    let guests = doc.attach(Attachment::new(
        "guests.txt",
        words.list,
        "text/plain",
        Relationship::Data,
        "2026-09-17T09:00:00+02:00",
        GUESTS.join("\n").into_bytes(),
    ));
    let mut said = Metadata::default();
    said.title = Some(words.badge_title.to_owned());
    let turned = badge(font, words)?
        .matrix(QUARTER)
        .with_metadata(Some(Xmp::facts(said)))
        .associated_with(&[guests]);
    let mut lines = vec![words.turned.to_owned()];
    if turned.metadata().is_some() {
        lines.push(words.says.replace("{title}", words.badge_title));
    }
    lines.push(
        words
            .carries
            .replace("{count}", &turned.associated_files().len().to_string()),
    );
    let handle = doc.add_drawing(turned);

    let (width, height) = BADGE;
    let mut page = Page::a4();
    let axes = page.top_left_axes();
    let mut content = Content::new();
    text(
        &mut content,
        font,
        15.0,
        (&axes, LEFT, TITLE),
        words.turned_title,
    )?;
    // Turned a quarter, the badge stands `height` wide and `width` tall, and
    // its own matrix puts its box to the left of the point it is placed at.
    let seen = axes.rect_to_page(&Rect::new(LEFT, TURNED_TOP, height, width));
    content.draw_form(handle.name(), seen.x() + height, seen.y(), 1.0)?;
    let mut y = TURNED_LINES;
    for line in lines {
        text(&mut content, font, 10.0, (&axes, TURNED_TEXT, y), &line)?;
        y += 16.0;
    }
    page.content = content.into_bytes();
    Ok(page)
}

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

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 two languages do not overwrite each other in `tmp/`.
    let out = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("drawing")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    let font = doc.add_font(Font::parse(fs::read(&font_path)?)?);
    let handle = doc.add_drawing(badge(&font, words)?);

    let (width, height) = BADGE;
    let mut page = Page::a4();
    let axes = page.top_left_axes();
    let mut content = Content::new();
    text(&mut content, &font, 15.0, (&axes, LEFT, TITLE), words.title)?;
    content.save_state();
    content.set_fill(Rgb::gray(0.35))?;
    text(&mut content, &font, 10.0, (&axes, LEFT, INTRO), words.intro)?;
    content.restore_state();

    let badges: [(&str, &str); BADGES] =
        std::array::from_fn(|badge| (GUESTS[badge], words.roles[badge]));
    let mut top = FIRST_ROW;
    for pair in badges.chunks(2) {
        let mut x = LEFT;
        for (name, role) in pair {
            let placed = axes.rect_to_page(&Rect::new(x, top, width, height));
            content.draw_form(handle.name(), placed.x(), placed.y(), 1.0)?;
            text(
                &mut content,
                &font,
                14.0,
                (&axes, x + 12.0, top + NAME),
                name,
            )?;
            content.save_state();
            content.set_fill(Rgb::gray(0.4))?;
            text(
                &mut content,
                &font,
                10.0,
                (&axes, x + 12.0, top + ROLE),
                role,
            )?;
            content.restore_state();
            x += width + 20.0;
        }
        top += height + 20.0;
    }

    // The same drawing again, at half size: a placing carries its own scale.
    let half = axes.rect_to_page(&Rect::new(LEFT, HALF, width / 2.0, height / 2.0));
    content.draw_form(handle.name(), half.x(), half.y(), 0.5)?;
    content.save_state();
    content.set_fill(Rgb::gray(0.35))?;
    text(
        &mut content,
        &font,
        10.0,
        (&axes, LEFT, HALF_CAPTION),
        words.half,
    )?;
    content.restore_state();

    page.content = content.into_bytes();
    doc.add_page(page)?;
    let turned = turned_page(&mut doc, &font, words)?;
    doc.add_page(turned)?;
    doc.set_version(Version::V2_0);

    let bytes = doc.to_bytes()?;
    if let Some(parent) = Path::new(&out).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&out, &bytes)?;
    println!(
        "wrote {out}: {} bytes, {} placings of one drawing",
        bytes.len(),
        GUESTS.len() + 2
    );
    Ok(())
}

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

    use super::{BADGE, COMPANY, LEFT, TURNED_TEXT, WORDS, default_font, language};

    /// The lines two languages are allowed to write the same way. Every line
    /// here is a heading, a caption or a trade, and two languages write one
    /// alike only where they spell it alike.
    const SPARED: [&str; 1] = [
        // Written the same way in Dutch.
        r#""Prepress""#,
    ];

    /// How far in from the badge's left edge everything inside it is drawn.
    const INSET: f64 = 12.0;

    /// A4's width, and the room a line of the page has between the margins.
    const PAGE_WIDTH: f64 = 595.276;
    /// See [`PAGE_WIDTH`].
    const MEASURE: f64 = PAGE_WIDTH - 2.0 * LEFT;

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

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

    /// Nothing on the page is broken to a width: a line longer than the room it
    /// is drawn in runs off the badge and over the one beside it, or off the
    /// margin and towards the edge of the paper.
    #[test]
    fn every_language_writes_lines_that_stay_in_the_room_they_are_drawn_in() {
        let mut doc = Document::new();
        let font = Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
            .expect("the committed font parses");
        let text = doc.add_font(font);
        let card = BADGE.0 - INSET - INSET;

        for (named, words) in WORDS {
            let code = named.code();
            let lines = [
                (15.0, words.title, MEASURE),
                (10.0, words.intro, MEASURE),
                (10.0, words.half, MEASURE),
                (11.0, COMPANY, card),
                (8.0, words.occasion, card),
            ]
            .into_iter()
            .chain(words.roles.map(|role| (10.0, role, card)))
            .chain([
                (15.0, words.turned_title, MEASURE),
                (10.0, words.turned, PAGE_WIDTH - LEFT - TURNED_TEXT),
                (10.0, words.says, PAGE_WIDTH - LEFT - TURNED_TEXT),
                (10.0, words.carries, PAGE_WIDTH - LEFT - TURNED_TEXT),
            ]);

            for (size, line, room) in lines {
                let measured = text.measure(line, size);
                assert!(
                    measured <= room,
                    "the {code} page draws {line:?} over {measured:.1} points, \
                     and it is given {room:.1}"
                );
            }
        }
    }
}