write_press_sheet.rs

//! A sheet as it goes to the press, and what each box a page states does to it.
//!
//! A page has always had a sheet. It now also has the four boxes a printer
//! reads: what the ink runs to, where the blade falls, what is worth keeping,
//! and what reading software shows. The four pages below are the same drawing
//! four times over, and what changes is the boxes they state and where the
//! sheet sits.
//!
//! What the sheet says is written in the language `HQF_PDF_LANG` names. The
//! prices are not, and neither are the measurements: the two the note quotes
//! are read off the sheet the page is drawn on.
//!
//! Usage: `cargo run --example write_press_sheet -- tmp/press.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_press_sheet`

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

use hqf_pdf::content::Content;
use hqf_pdf::{Color, Document, Error, Font, FontHandle, Page, PageTurn, Rect, Rgb};

#[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")
}

/// How far past the blade the ink runs.
const BLEED_OVER: f64 = 9.0;
/// How much sheet is left outside the ink for the marks.
const MARK_ROOM: f64 = 27.0;
/// How long one arm of a corner mark is.
const MARK_LENGTH: f64 = 18.0;

/// How much sheet stands outside the finished page on every side.
const MARGIN: f64 = BLEED_OVER + MARK_ROOM;

/// The finished page: where the blade falls, in the sheet's own coordinates.
const TRIM: (f64, f64, f64, f64) = (MARGIN, MARGIN, 400.0, 560.0);

/// The whole sheet: the finished page, the ink that runs past it, and the room
/// the marks stand in.
const SHEET: (f64, f64) = (TRIM.2 + MARGIN + MARGIN, TRIM.3 + MARGIN + MARGIN);

/// Where the lower-left corner of the fourth sheet sits: that sheet is the
/// right half of a press sheet two pages wide, so its corner stands where the
/// first sheet ends.
const MOVED: (f64, f64) = (SHEET.0, 0.0);

/// How far inside the blade the drawing itself keeps.
const ART_INSET: f64 = 40.0;

/// The colour the band across the top is laid in.
const BAND: Rgb = Rgb {
    r: 0.11,
    g: 0.26,
    b: 0.44,
};

/// The company whose list is being printed, which no language renames.
const COMPANY: &str = "HQF Development";

/// The sizes the sheet is set in, in points.
const TITLE_SIZE: f64 = 22.0;
const BODY_SIZE: f64 = 10.0;
const FOOT_SIZE: f64 = 8.0;
const NOTE_SIZE: f64 = 7.0;
const CAPTION_SIZE: f64 = 8.0;
const TURNED_TITLE_SIZE: f64 = 18.0;

/// How far one line of body stands under the one above it, in points.
const BODY_STEP: f64 = 16.0;

/// Where the label over the arrow between the two sketches begins.
const ARROW_LABEL_LEFT: f64 = 288.0;

/// What each row of the list costs, in the order the rows are drawn. A price is
/// not language.
const PRICES: [&str; 6] = ["18.40", "6.90", "42.00", "31.50", "12.75", "9.20"];

/// The words the sheet is written in, one set per language.
///
/// The prices are not among them, nor the two measurements the last page
/// quotes: those are read off the sheet.
#[derive(Debug)]
struct Words {
    /// What the list being printed is called, in the band at the head.
    title: &'static str,
    /// The line under it, which says what the band does at the blade.
    band: &'static str,
    /// The paragraph that says why a sheet allows for the blade twice over.
    blade: [&'static str; 4],
    /// The paragraph that says what the boxes spare the reader.
    boxes: [&'static str; 3],
    /// What each row of the list is, in the order they are drawn.
    rows: [&'static str; 6],
    /// What stands after the name of the company at the foot.
    foot: &'static str,
    /// What names each guide, in the order they are drawn: the ink, the blade,
    /// then what is worth keeping.
    guides: [&'static str; 3],
    /// The note in the margin of the first sheet, which shows whole.
    first_note: [&'static str; 2],
    /// The note in the margin of the second, which is cropped to the blade.
    second_note: [&'static str; 2],
    /// The note in the margin of the fourth, whose sheet is moved off the
    /// origin.
    moved_note: [&'static str; 2],
    /// What the turned page is called.
    turned_title: &'static str,
    /// What stands before the width of the sheet in the first line of the
    /// turned page.
    across_before: &'static str,
    /// What stands between the width and the height.
    across_between: &'static str,
    /// What stands after the height.
    across_after: &'static str,
    /// The rest of that first paragraph, which says what the page adds.
    quarter: &'static str,
    /// The paragraph that says what reading software does with the turn.
    reading_software: [&'static str; 3],
    /// What the sheet drawn as the file holds it is called.
    in_file: &'static str,
    /// What the sheet drawn as reading software shows it is called.
    on_screen: &'static str,
    /// What the arrow between the two sketches says.
    turn: &'static str,
}

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: "Autumn list",
    band: "The band above runs off the blade: no white edge is left.",
    blade: [
        "The blade never falls exactly where it is",
        "aimed. A sheet allows for that twice over:",
        "the ink runs past the cut, and nothing that",
        "matters stands within a few points of it.",
    ],
    boxes: [
        "The boxes say all three distances, so nobody",
        "has to measure the file to find out where the",
        "page really ends.",
    ],
    rows: [
        "Linen paper, ream",
        "Bookbinder's thread",
        "Corner mark punch",
        "Trim gauge, steel",
        "Bleed guide, acrylic",
        "Press blanket wash",
    ],
    foot: " — one sheet, four boxes",
    guides: ["bleed", "trim", "art"],
    first_note: [
        "Page 1 states the bleed, the trim and the art, and no crop: reading software shows the whole",
        "sheet, marks and all, which is what the press wants to see.",
    ],
    second_note: [
        "Page 2 is the same drawing and the same boxes, plus a crop set to the trim: reading software",
        "shows the finished page alone. Nothing was removed — what is outside is still here.",
    ],
    moved_note: [
        "Page 4 is the right half of a press sheet two pages wide: its lower-left corner stands where",
        "page 1 ends, and its drawing and boxes are stated from there. It shows just as page 1 does.",
    ],
    turned_title: "A landscape page inside an upright document",
    across_before: "This page is the same upright sheet as the two before it: ",
    across_between: " points across, ",
    across_after: " up. What",
    quarter: "it adds is one number saying that reading software turns it a quarter clockwise before showing it.",
    reading_software: [
        "So the words are wider than the sheet they are written on, and nobody has to be handed a",
        "second page size to say so. Reading software printing the file turns the paper rather than the",
        "drawing, and reading software showing it hands you the page the way round it was meant.",
    ],
    in_file: "as it sits in the file",
    on_screen: "as reading software shows it",
    turn: "a quarter clockwise",
};

/// The sheet in French.
const FRENCH: Words = Words {
    title: "Catalogue d’automne",
    band: "Le bandeau déborde la coupe : aucun liseré blanc ne reste.",
    blade: [
        "La lame ne tombe jamais exactement là où l’on",
        "la vise. La feuille s’en prémunit deux fois :",
        "l’encre déborde la coupe, et rien de ce qui",
        "compte n’est à moins de quelques points.",
    ],
    boxes: [
        "Les boîtes donnent les trois distances, donc",
        "personne n’a à mesurer le fichier pour savoir",
        "où la page finit vraiment.",
    ],
    rows: [
        "Papier de lin, rame",
        "Fil de relieur",
        "Emporte-pièce à repères",
        "Calibre de coupe, acier",
        "Guide de fond perdu, acrylique",
        "Lavant pour blanchet",
    ],
    foot: " — une feuille, quatre boîtes",
    guides: ["fond perdu", "coupe", "zone utile"],
    first_note: [
        "La page 1 donne le fond perdu, la coupe et la zone utile, sans recadrage : le \
logiciel de lecture montre",
        "toute la feuille, repères compris, ce que l’imprimeur veut voir.",
    ],
    second_note: [
        "La page 2 reprend le même contenu et les mêmes boîtes, plus un recadrage sur \
la coupe : le logiciel de lecture",
        "montre la page finie seule. Rien n’a été retiré : ce qui dépasse est toujours là.",
    ],
    moved_note: [
        "La page 4 est la moitié droite d’une feuille large de deux pages : son coin \
inférieur gauche est là où",
        "finit la page 1, et son contenu et ses boîtes sont repérés depuis ce point. \
Elle s’affiche comme la page 1.",
    ],
    turned_title: "Une page à l’italienne dans un document à la française",
    across_before: "Cette page est la même feuille à la française que les deux précédentes : ",
    across_between: " points de large, ",
    across_after: " de haut. Ce",
    quarter: "qu’elle ajoute est un nombre : le logiciel de lecture la tourne d’un quart de \
tour horaire avant de l’afficher.",
    reading_software: [
        "Les mots sont donc plus larges que la feuille sur laquelle ils sont écrits, et \
personne n’a",
        "besoin d’un second format de page pour le dire. Un logiciel de lecture qui \
imprime le fichier tourne le",
        "papier plutôt que le contenu, et un logiciel de lecture qui l’affiche vous \
présente la page dans le bon sens.",
    ],
    in_file: "telle qu’elle est dans le fichier",
    on_screen: "telle qu’un logiciel de lecture la montre",
    turn: "un quart de tour horaire",
};

/// The sheet in Dutch.
const DUTCH: Words = Words {
    title: "Najaarsaanbieding",
    band: "De band loopt voorbij het mes: er blijft geen witte rand over.",
    blade: [
        "Het mes valt nooit precies waar het op",
        "gericht is. Een blad houdt daar twee keer rekening mee:",
        "de inkt loopt voorbij de snede, en niets wat",
        "ertoe doet staat binnen een paar punten ervan.",
    ],
    boxes: [
        "De kaders noemen alle drie de afstanden, dus niemand",
        "hoeft het bestand op te meten om te weten waar de",
        "pagina echt eindigt.",
    ],
    rows: [
        "Linnenpapier, riem",
        "Boekbindersgaren",
        "Hoekstans",
        "Snijmal, staal",
        "Aflooprichtlijn, acryl",
        "Rubberdoekreiniger",
    ],
    foot: " — één blad, vier kaders",
    guides: ["afloop", "snijlijn", "beeld"],
    first_note: [
        "Pagina 1 noemt de afloop, de snijlijn en het beeld, en geen uitsnede: leessoftware toont het hele",
        "blad, met tekens en al, wat de pers wil zien.",
    ],
    second_note: [
        "Pagina 2 is dezelfde tekening met dezelfde kaders, plus een uitsnede op de snijlijn: leessoftware",
        "toont alleen de afgewerkte pagina. Niets is weggehaald: wat erbuiten staat, is er nog.",
    ],
    moved_note: [
        "Pagina 4 is de rechterhelft van een drukvel van twee pagina’s breed: de linkeronderhoek staat waar",
        "pagina 1 eindigt, en de tekening en kaders worden van daaruit vermeld. Ze wordt getoond zoals pagina 1.",
    ],
    turned_title: "Een liggende pagina in een staand document",
    across_before: "Deze pagina is hetzelfde staande blad als de twee ervoor:",
    across_between: " punten breed,",
    across_after: " hoog. Wat ze",
    quarter: "toevoegt, is één getal dat zegt dat leessoftware haar een kwartslag met de klok mee draait voordat ze haar toont.",
    reading_software: [
        "Zo zijn de woorden breder dan het blad waarop ze staan, en hoeft niemand een tweede",
        "paginaformaat te krijgen om dat te zeggen. Leessoftware die het bestand afdrukt, draait het papier in plaats van de",
        "tekening, en leessoftware die het toont, geeft u de pagina zoals ze bedoeld is.",
    ],
    in_file: "zoals ze in het bestand staat",
    on_screen: "zoals leessoftware haar toont",
    turn: "een kwartslag met de klok mee",
};

/// The sheet in Portuguese.
const PORTUGUESE: Words = Words {
    title: "Catálogo de outono",
    band: "A faixa acima sai para lá da lâmina: não fica margem branca.",
    blade: [
        "A lâmina nunca cai exatamente onde se",
        "aponta. Uma folha prevê isso duas vezes:",
        "a tinta passa do corte, e nada que",
        "importe fica a poucos pontos dele.",
    ],
    boxes: [
        "As caixas dizem as três distâncias, por isso ninguém",
        "tem de medir o ficheiro para saber onde",
        "acaba de facto a página.",
    ],
    rows: [
        "Papel de linho, resma",
        "Linha de encadernador",
        "Furador de cantos",
        "Calibre de corte, aço",
        "Guia de sangria, acrílico",
        "Lavagem da borracha",
    ],
    foot: " — uma folha, quatro caixas",
    guides: ["sangria", "corte", "arte"],
    first_note: [
        "A página 1 indica a sangria, o corte e a arte, e nenhum recorte: o programa de leitura mostra a folha",
        "toda, marcas incluídas, que é o que a gráfica quer ver.",
    ],
    second_note: [
        "A página 2 é o mesmo desenho com as mesmas caixas e um recorte ajustado ao corte: o programa de leitura",
        "mostra só a página acabada. Nada foi retirado: o que está fora continua aqui.",
    ],
    moved_note: [
        "A página 4 é a metade direita de uma folha com duas páginas de largura: o canto inferior esquerdo fica onde",
        "acaba a página 1, e o seu desenho e as suas caixas são indicados a partir daí. Vê-se tal como a página 1.",
    ],
    turned_title: "Uma página ao baixo dentro de um documento ao alto",
    across_before: "Esta página é a mesma folha ao alto que as duas anteriores:",
    across_between: " pontos de largura,",
    across_after: " de altura. O que",
    quarter: "acrescenta é um número: o programa de leitura roda-a um quarto de volta no sentido dos ponteiros do relógio antes de a mostrar.",
    reading_software: [
        "Assim as palavras são mais largas do que a folha em que estão escritas, e ninguém precisa de receber um",
        "segundo tamanho de página para o dizer. Ao imprimir o ficheiro, o programa de leitura roda o papel e não o",
        "desenho, e ao mostrá-lo dá-lhe a página no sentido em que foi pensada.",
    ],
    in_file: "tal como está no ficheiro",
    on_screen: "tal como o programa de leitura a mostra",
    turn: "um quarto de volta no sentido dos ponteiros do relógio",
};

/// The sheet in Italian.
const ITALIAN: Words = Words {
    title: "Catalogo d’autunno",
    band: "La fascia in alto supera il taglio: niente bordo bianco.",
    blade: [
        "La lama non cade mai esattamente dove è",
        "puntata. Un foglio ne tiene conto due volte:",
        "l’inchiostro passa oltre il taglio, e niente di",
        "importante sta a pochi punti da esso.",
    ],
    boxes: [
        "I riquadri dicono le tre distanze, così nessuno",
        "deve misurare il file per scoprire dove",
        "finisce davvero la pagina.",
    ],
    rows: [
        "Carta di lino, risma",
        "Filo da legatoria",
        "Fustella per angoli",
        "Calibro di taglio, acciaio",
        "Guida di abbondanza, acrilico",
        "Detergente per caucciù",
    ],
    foot: " — un foglio, quattro riquadri",
    guides: ["abbondanza", "rifilo", "grafica"],
    first_note: [
        "La pagina 1 indica l’abbondanza, il rifilo e la grafica, e nessun ritaglio: il programma di lettura mostra",
        "tutto il foglio, segni compresi, ed è ciò che la stampa vuole vedere.",
    ],
    second_note: [
        "La pagina 2 è lo stesso disegno con gli stessi riquadri, più un ritaglio sul rifilo: il programma di lettura",
        "mostra solo la pagina finita. Non si è tolto nulla: ciò che sta fuori è ancora qui.",
    ],
    moved_note: [
        "La pagina 4 è la metà destra di un foglio macchina largo due pagine: il suo angolo in basso a sinistra sta dove",
        "finisce la pagina 1, e il suo disegno e i suoi riquadri sono indicati da lì. Si vede come la pagina 1.",
    ],
    turned_title: "Una pagina orizzontale in un documento verticale",
    across_before: "Questa pagina è lo stesso foglio verticale delle due precedenti:",
    across_between: " punti di larghezza,",
    across_after: " di altezza. Ciò che",
    quarter: "aggiunge è un numero che dice che il programma di lettura la ruota di un quarto in senso orario prima di mostrarla.",
    reading_software: [
        "Così le parole sono più larghe del foglio su cui sono scritte, e a nessuno va dato un",
        "secondo formato di pagina per dirlo. Stampando il file, il programma di lettura ruota la carta e non il",
        "disegno, e mostrandolo vi dà la pagina nel verso in cui è stata pensata.",
    ],
    in_file: "come sta nel file",
    on_screen: "come la mostra il programma di lettura",
    turn: "un quarto in senso orario",
};

/// The sheet in Spanish.
const SPANISH: Words = Words {
    title: "Catálogo de otoño",
    band: "La banda de arriba rebasa la cuchilla: no queda borde blanco.",
    blade: [
        "La cuchilla nunca cae exactamente donde se",
        "apunta. Una hoja lo prevé dos veces:",
        "la tinta pasa del corte, y nada que",
        "importe está a pocos puntos de él.",
    ],
    boxes: [
        "Las cajas dicen las tres distancias, así que nadie",
        "tiene que medir el archivo para saber dónde",
        "acaba de verdad la página.",
    ],
    rows: [
        "Papel de lino, resma",
        "Hilo de encuadernar",
        "Troqueladora de esquinas",
        "Galga de corte, acero",
        "Guía de sangrado, acrílico",
        "Limpiador de mantilla",
    ],
    foot: " — una hoja, cuatro cajas",
    guides: ["sangrado", "corte", "arte"],
    first_note: [
        "La página 1 indica el sangrado, el corte y el arte, y ningún recorte: el programa de lectura muestra toda",
        "la hoja, marcas incluidas, que es lo que quiere ver la imprenta.",
    ],
    second_note: [
        "La página 2 es el mismo dibujo con las mismas cajas, más un recorte fijado al corte: el programa de lectura",
        "muestra solo la página acabada. No se quitó nada: lo de fuera sigue aquí.",
    ],
    moved_note: [
        "La página 4 es la mitad derecha de un pliego de dos páginas: su esquina inferior izquierda está donde",
        "acaba la página 1, y su dibujo y sus cajas se indican desde ahí. Se ve igual que la página 1.",
    ],
    turned_title: "Una página apaisada dentro de un documento vertical",
    across_before: "Esta página es la misma hoja vertical que las dos anteriores: ",
    across_between: " puntos de ancho, ",
    across_after: " de alto. Lo que",
    quarter: "añade es un número que dice que el programa de lectura la gira un cuarto a la derecha antes de mostrarla.",
    reading_software: [
        "Así las palabras son más anchas que la hoja en que están escritas, y a nadie hay que darle un",
        "segundo tamaño de página para decirlo. Al imprimir el archivo, el programa de lectura gira el papel y no el",
        "dibujo, y al mostrarlo le da la página en el sentido en que se pensó.",
    ],
    in_file: "tal como está en el archivo",
    on_screen: "tal como lo muestra el programa de lectura",
    turn: "un cuarto a la derecha",
};

/// The sheet in German.
const GERMAN: Words = Words {
    title: "Herbstprogramm",
    band: "Das Band läuft über die Kante: Kein weißer Rand bleibt.",
    blade: [
        "Das Messer fällt nie genau dorthin, wo es",
        "hinzielt. Ein Bogen rechnet doppelt damit:",
        "Die Farbe läuft über den Schnitt, und nichts",
        "Wichtiges steht wenige Punkt davon entfernt.",
    ],
    boxes: [
        "Die Rahmen nennen alle drei Abstände, also",
        "muss niemand die Datei vermessen, um zu",
        "wissen, wo die Seite wirklich endet.",
    ],
    rows: [
        "Leinenpapier, Ries",
        "Buchbinderzwirn",
        "Eckenstanze",
        "Schneidlehre, Stahl",
        "Anschnittschablone, Acryl",
        "Gummituchwaschmittel",
    ],
    foot: " — ein Bogen, vier Rahmen",
    guides: ["Anschnitt", "Endformat", "Motiv"],
    first_note: [
        "Seite 1 nennt Anschnitt, Endformat und Motiv, keinen Zuschnitt: Die Lesesoftware zeigt den",
        "ganzen Bogen samt Marken, und genau das will die Druckmaschine sehen.",
    ],
    second_note: [
        "Seite 2 ist dieselbe Zeichnung mit denselben Rahmen, dazu ein Zuschnitt aufs Endformat: Die",
        "Lesesoftware zeigt nur die fertige Seite. Nichts wurde entfernt — was außen ist, ist noch da.",
    ],
    moved_note: [
        "Seite 4 ist die rechte Hälfte eines zwei Seiten breiten Druckbogens: Ihre linke untere Ecke",
        "liegt, wo Seite 1 endet, und Zeichnung und Rahmen gelten ab dort. Sie erscheint wie Seite 1.",
    ],
    turned_title: "Eine Querformatseite in einem Hochformatdokument",
    across_before: "Diese Seite ist derselbe hochformatige Bogen wie die beiden davor: ",
    across_between: " Punkt breit, ",
    across_after: " hoch. Was",
    quarter: "sie hinzufügt, ist eine Zahl: Die Lesesoftware dreht sie vor der Anzeige um eine Vierteldrehung.",
    reading_software: [
        "Also sind die Wörter breiter als der Bogen, auf dem sie stehen, und niemand muss dafür ein",
        "zweites Seitenformat bekommen. Eine Lesesoftware, die die Datei druckt, dreht das Papier statt",
        "der Zeichnung, und eine, die sie anzeigt, stellt die Seite so hin, wie sie gemeint war.",
    ],
    in_file: "wie sie in der Datei steht",
    on_screen: "wie die Lesesoftware sie zeigt",
    turn: "eine Vierteldrehung im Uhrzeigersinn",
};

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

/// Where the blade falls.
const fn trim() -> Rect {
    Rect::new(TRIM.0, TRIM.1, TRIM.2, TRIM.3)
}

/// What the ink runs to.
const fn bleed() -> Rect {
    Rect::new(
        TRIM.0 - BLEED_OVER,
        TRIM.1 - BLEED_OVER,
        TRIM.2 + BLEED_OVER + BLEED_OVER,
        TRIM.3 + BLEED_OVER + BLEED_OVER,
    )
}

/// `rect` on the fourth sheet, whose corner sits at [`MOVED`].
const fn moved(rect: Rect) -> Rect {
    Rect::new(
        rect.x() + MOVED.0,
        rect.y() + MOVED.1,
        rect.width(),
        rect.height(),
    )
}

/// What is worth keeping of the page.
const fn art() -> Rect {
    Rect::new(
        TRIM.0 + ART_INSET,
        TRIM.1 + ART_INSET,
        TRIM.2 - ART_INSET - ART_INSET,
        TRIM.3 - ART_INSET - ART_INSET,
    )
}

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

/// Draws the four corner marks, each pair of arms standing outside the ink and
/// pointing at a corner of the finished page.
fn corner_marks(content: &mut Content) -> Result<(), Error> {
    let (left, bottom, width, height) = TRIM;
    let right = left + width;
    let top = bottom + height;
    let near = BLEED_OVER;
    let far = BLEED_OVER + MARK_LENGTH;

    content.save_state();
    content.set_stroke(Color::Gray(0.0))?;
    content.set_line_width(0.4)?;
    for (x, from_x, to_x) in [
        (left, left - near, left - far),
        (right, right + near, right + far),
    ] {
        for (y, from_y, to_y) in [
            (bottom, bottom - near, bottom - far),
            (top, top + near, top + far),
        ] {
            content.move_to(from_x, y)?;
            content.line_to(to_x, y)?;
            content.move_to(x, from_y)?;
            content.line_to(x, to_y)?;
        }
    }
    content.stroke();
    content.restore_state();
    Ok(())
}

/// The line of a page's foot, which names the company and what the page shows.
fn foot(words: &Words) -> String {
    format!("{COMPANY}{}", words.foot)
}

/// Draws the artwork itself: a band that runs off the blade, a title, a few
/// lines of body and a footer, all inside what is worth keeping.
fn artwork(content: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    let ink = bleed();
    let keep = art();

    content.save_state();
    content.set_fill(Color::Gray(0.96))?;
    content
        .rect(ink.x(), ink.y(), ink.width(), ink.height())?
        .fill();
    content.set_fill(BAND)?;
    content
        .rect(ink.x(), ink.y() + ink.height() - 150.0, ink.width(), 150.0)?
        .fill();
    content.restore_state();

    content.save_state();
    content.set_fill(Rgb::new(1.0, 1.0, 1.0))?;
    text(
        content,
        font,
        TITLE_SIZE,
        keep.x(),
        keep.y() + keep.height() - 30.0,
        words.title,
    )?;
    content.set_fill(Rgb::new(0.82, 0.86, 0.92))?;
    text(
        content,
        font,
        BODY_SIZE,
        keep.x(),
        keep.y() + keep.height() - 50.0,
        words.band,
    )?;
    content.restore_state();

    content.save_state();
    content.set_fill(Color::Gray(0.25))?;
    let mut y = keep.y() + keep.height() - 130.0;
    for line in words.blade {
        text(content, font, BODY_SIZE, keep.x(), y, line)?;
        y -= BODY_STEP;
    }
    // The blank between the two paragraphs is a step of the loop, not a line of
    // the words.
    y -= BODY_STEP;
    for line in words.boxes {
        text(content, font, BODY_SIZE, keep.x(), y, line)?;
        y -= BODY_STEP;
    }
    content.restore_state();

    listing(content, font, words, keep.y() + keep.height() - 290.0, keep)?;

    content.save_state();
    content.set_fill(Color::Gray(0.5))?;
    text(content, font, FOOT_SIZE, keep.x(), keep.y(), &foot(words))?;
    content.restore_state();
    Ok(())
}

/// How far in from the right of what is worth keeping a price stands.
const PRICE_INSET: f64 = 30.0;

/// Draws the list itself, one row a line, each under a hairline that runs the
/// width of what is worth keeping.
fn listing(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    top: f64,
    keep: Rect,
) -> Result<(), Error> {
    let right = keep.x() + keep.width();
    let mut y = top;
    for (item, price) in words.rows.iter().zip(PRICES) {
        content.save_state();
        content.set_fill(Color::Gray(0.25))?;
        text(content, font, BODY_SIZE, keep.x(), y, item)?;
        text(content, font, BODY_SIZE, right - PRICE_INSET, y, price)?;
        content.set_stroke(Color::Gray(0.8))?;
        content.set_line_width(0.4)?;
        content.move_to(keep.x(), y - 8.0)?;
        content.line_to(right, y - 8.0)?;
        content.stroke();
        content.restore_state();
        y -= 26.0;
    }
    Ok(())
}

/// The box each guide is drawn around, and the colour it is drawn in, in the
/// order they are named.
const fn guide_boxes() -> [(Rect, Rgb); 3] {
    [
        (bleed(), Rgb::new(0.85, 0.35, 0.20)),
        (trim(), Rgb::new(0.20, 0.55, 0.35)),
        (art(), Rgb::new(0.45, 0.35, 0.65)),
    ]
}

/// How far in from the right of its box a guide's name stands.
const GUIDE_INSET: f64 = 30.0;

/// Draws the guide showing where each box falls, and names it.
fn guides(content: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    content.save_state();
    content.set_line_width(0.4)?;
    for ((box_, color), label) in guide_boxes().into_iter().zip(words.guides) {
        content.set_stroke(color)?;
        content
            .rect(box_.x(), box_.y(), box_.width(), box_.height())?
            .stroke();
        content.set_fill(color)?;
        text(
            content,
            font,
            NOTE_SIZE,
            box_.x() + box_.width() - GUIDE_INSET,
            box_.y() - 8.0,
            label,
        )?;
    }
    content.restore_state();
    Ok(())
}

/// Where the lowest line of the note in the margin sits, and how far the one
/// above it stands.
const NOTE_BASELINE: f64 = 8.0;
const NOTE_STEP: f64 = 9.0;

/// The whole sheet: artwork, marks, the guides that name the boxes, and the
/// note in the margin saying what this page states.
fn sheet(font: &FontHandle, words: &Words, note: &[&str; 2]) -> Result<Vec<u8>, Error> {
    let mut content = Content::new();
    draw_sheet(&mut content, font, words, note)?;
    Ok(content.into_bytes())
}

/// The same sheet drawn on the fourth page, whose corner sits at [`MOVED`]: one
/// transform at the head of the stream carries the whole drawing there.
fn moved_sheet(font: &FontHandle, words: &Words) -> Result<Vec<u8>, Error> {
    let mut content = Content::new();
    content.transform([1.0, 0.0, 0.0, 1.0, MOVED.0, MOVED.1])?;
    draw_sheet(&mut content, font, words, &words.moved_note)?;
    Ok(content.into_bytes())
}

/// Draws the artwork, the marks, the guides and the note in the margin, in the
/// sheet's own coordinates.
fn draw_sheet(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    note: &[&str; 2],
) -> Result<(), Error> {
    artwork(content, font, words)?;
    corner_marks(content)?;
    guides(content, font, words)?;

    content.save_state();
    content.set_fill(Color::Gray(0.35))?;
    let mut y = NOTE_BASELINE;
    for line in note.iter().rev() {
        text(content, font, NOTE_SIZE, TRIM.0, y, line)?;
        y += NOTE_STEP;
    }
    content.restore_state();
    Ok(())
}

/// A4, in points.
const A4: (f64, f64) = (595.276, 841.890);

/// Draws one sheet of the little diagram: an outline, the band that marks the
/// head of the drawing, and a caption under it.
///
/// A sheet taller than it is wide is one reading software has not turned yet,
/// so the head of the drawing runs down its left edge; a wide one has been
/// turned, and the head is along its top.
fn sketch(
    content: &mut Content,
    font: &FontHandle,
    corner: (f64, f64, f64, f64),
    caption: &str,
) -> Result<(), Error> {
    let (x, y, width, height) = corner;
    let head = if height > width {
        (x + 8.0, y + 8.0, 12.0, height - 16.0)
    } else {
        (x + 8.0, y + height - 20.0, width - 16.0, 12.0)
    };

    content.save_state();
    content.set_stroke(Color::Gray(0.55))?;
    content.set_line_width(0.8)?;
    content.rect(x, y, width, height)?.stroke();
    content.set_fill(BAND)?;
    content.rect(head.0, head.1, head.2, head.3)?.fill();
    content.set_fill(Color::Gray(0.45))?;
    text(content, font, CAPTION_SIZE, x, y - 14.0, caption)?;
    content.restore_state();
    Ok(())
}

/// The two sketches: where each stands on the turned page, and how much room
/// the caption under it has before it reaches the next one.
const SKETCHES: [(f64, f64, f64, f64); 2] =
    [(150.0, 140.0, 110.0, 155.0), (400.0, 165.0, 155.0, 110.0)];

/// Where the turned page sets every line from, and the room it leaves on the
/// far side.
const TURNED_LEFT: f64 = 70.0;

/// The first line of the turned page, which quotes the two measurements of the
/// sheet it is drawn on rather than repeating them.
fn how_wide(words: &Words) -> String {
    format!(
        "{}{:.0}{}{:.0}{}",
        words.across_before, A4.0, words.across_between, A4.1, words.across_after
    )
}

/// The third page: a landscape page inside an upright document.
///
/// Everything is laid out in a space as wide as the sheet is tall, and the one
/// transform at the head of the stream puts that space onto the upright sheet.
/// The page then states a quarter turn clockwise, and reading software undoes
/// the transform by turning the paper.
fn turned(font: &FontHandle, words: &Words) -> Result<Vec<u8>, Error> {
    let (across, up) = (A4.1, A4.0);
    let mut content = Content::new();
    content.transform([0.0, 1.0, -1.0, 0.0, A4.0, 0.0])?;

    content.save_state();
    content.set_fill(Color::Gray(0.96))?;
    content.rect(0.0, 0.0, across, up)?.fill();
    content.set_fill(BAND)?;
    content.rect(0.0, up - 90.0, across, 90.0)?.fill();
    content.restore_state();

    content.save_state();
    content.set_fill(Rgb::new(1.0, 1.0, 1.0))?;
    text(
        &mut content,
        font,
        TURNED_TITLE_SIZE,
        TURNED_LEFT,
        up - 55.0,
        words.turned_title,
    )?;
    content.restore_state();

    content.save_state();
    content.set_fill(Color::Gray(0.3))?;
    let mut y = up - 130.0;
    for line in [how_wide(words), words.quarter.to_owned()] {
        text(&mut content, font, BODY_SIZE, TURNED_LEFT, y, &line)?;
        y -= BODY_STEP;
    }
    // The blank between the two paragraphs is a step of the loop, not a line of
    // the words.
    y -= BODY_STEP;
    for line in words.reading_software {
        text(&mut content, font, BODY_SIZE, TURNED_LEFT, y, line)?;
        y -= BODY_STEP;
    }
    content.restore_state();

    for (corner, caption) in SKETCHES.into_iter().zip([words.in_file, words.on_screen]) {
        sketch(&mut content, font, corner, caption)?;
    }

    content.save_state();
    content.set_stroke(Color::Gray(0.55))?;
    content.set_line_width(1.2)?;
    content.move_to(295.0, 218.0)?;
    content.line_to(360.0, 218.0)?;
    content.line_to(348.0, 226.0)?;
    content.move_to(360.0, 218.0)?;
    content.line_to(348.0, 210.0)?;
    content.stroke();
    content.set_fill(Color::Gray(0.45))?;
    text(
        &mut content,
        font,
        CAPTION_SIZE,
        ARROW_LABEL_LEFT,
        234.0,
        words.turn,
    )?;
    content.restore_state();
    Ok(content.into_bytes())
}

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("press")));
    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 mut first = Page::new(SHEET.0, SHEET.1);
    first.content = sheet(&font, words, &words.first_note)?;
    first.bleed = Some(bleed());
    first.trim = Some(trim());
    first.art = Some(art());
    doc.add_page(first)?;

    let mut second = Page::new(SHEET.0, SHEET.1);
    second.content = sheet(&font, words, &words.second_note)?;
    second.crop = Some(trim());
    second.bleed = Some(bleed());
    second.trim = Some(trim());
    second.art = Some(art());
    doc.add_page(second)?;

    let mut third = Page::a4();
    third.content = turned(&font, words)?;
    third.turn = PageTurn::Right;
    doc.add_page(third)?;

    let mut fourth = Page::new(SHEET.0, SHEET.1);
    fourth.origin = MOVED;
    fourth.content = moved_sheet(&font, words)?;
    fourth.bleed = Some(moved(bleed()));
    fourth.trim = Some(moved(trim()));
    fourth.art = Some(moved(art()));
    doc.add_page(fourth)?;

    let written = doc.to_bytes()?;
    if let Some(parent) = Path::new(&out).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&out, &written)?;
    println!(
        "wrote {out}: {} bytes, one drawing on {} pages, each stating its own boxes",
        written.len(),
        doc.page_count()
    );
    Ok(())
}

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

    use super::{
        A4, ARROW_LABEL_LEFT, BODY_SIZE, CAPTION_SIZE, FOOT_SIZE, GUIDE_INSET, MOVED,
        NOTE_BASELINE, NOTE_SIZE, NOTE_STEP, PRICE_INSET, SHEET, SKETCHES, TITLE_SIZE, TRIM,
        TURNED_LEFT, TURNED_TITLE_SIZE, WORDS, Words, art, bleed, default_font, foot, guide_boxes,
        how_wide, language, moved,
    };

    /// The lines two languages are allowed to write the same way, where two
    /// languages spell a word alike. The prices and the two measurements are
    /// held outside the words.
    const SPARED: [&str; 2] = [
        // Written the same way in Portuguese.
        r#""arte""#,
        r#""corte""#,
    ];

    /// The font every measurement here is taken in, which is the one the
    /// example draws with when the command line says nothing.
    fn font(document: &mut Document) -> FontHandle {
        document.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        )
    }

    /// Every line the sheet draws, each with the size it is set at and the room
    /// it has before it reaches whatever stands to its right.
    fn lines(words: &Words) -> Vec<(String, f64, f64)> {
        let keep = art();
        let keep_room = keep.width();
        let row_room = keep.width() - PRICE_INSET - BODY_SIZE;
        let note_room = SHEET.0 - TRIM.0 - TRIM.0;
        let turned_room = A4.1 - TURNED_LEFT - TURNED_LEFT;

        let mut measured = vec![
            (words.title.to_owned(), TITLE_SIZE, keep_room),
            (words.band.to_owned(), BODY_SIZE, keep_room),
            (foot(words), FOOT_SIZE, keep_room),
            (
                words.turned_title.to_owned(),
                TURNED_TITLE_SIZE,
                turned_room,
            ),
            (how_wide(words), BODY_SIZE, turned_room),
            (words.quarter.to_owned(), BODY_SIZE, turned_room),
            (
                words.turn.to_owned(),
                CAPTION_SIZE,
                A4.1 - ARROW_LABEL_LEFT - TURNED_LEFT,
            ),
        ];
        for line in words.blade.iter().chain(&words.boxes) {
            measured.push(((*line).to_owned(), BODY_SIZE, keep_room));
        }
        for row in words.rows {
            measured.push((row.to_owned(), BODY_SIZE, row_room));
        }
        for line in words
            .first_note
            .iter()
            .chain(&words.second_note)
            .chain(&words.moved_note)
        {
            measured.push(((*line).to_owned(), NOTE_SIZE, note_room));
        }
        // A guide's name stands inside its own box and runs to the edge of the
        // sheet.
        for ((box_, _), label) in guide_boxes().into_iter().zip(words.guides) {
            let from = box_.x() + box_.width() - GUIDE_INSET;
            measured.push((label.to_owned(), NOTE_SIZE, SHEET.0 - from));
        }
        // The caption of the first sketch runs until the second one begins; the
        // second runs to the edge of the sheet the turned page is drawn on.
        let captions = [
            (words.in_file, SKETCHES[1].0 - SKETCHES[0].0),
            (words.on_screen, A4.1 - SKETCHES[1].0),
        ];
        for (caption, room) in captions {
            measured.push((caption.to_owned(), CAPTION_SIZE, room));
        }
        measured
    }

    #[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:?}"
        );
    }

    /// Nothing on this sheet is broken to a width: every line is drawn where it
    /// is asked for, so a line longer than its room runs over what stands
    /// beside it or off the sheet altogether.
    #[test]
    fn every_language_writes_lines_that_fit_the_room_they_have() {
        let mut document = Document::new();
        let font = font(&mut document);

        for (named, words) in WORDS {
            for (line, size, room) in lines(words) {
                let measured = font.measure(&line, size);

                assert!(
                    measured <= room,
                    "the {} sheet draws {line:?} over {measured:.1} points, and \
                     it has {room:.1}",
                    named.code()
                );
            }
        }
    }

    /// The note in the margin is drawn upwards from the foot of the sheet, and
    /// the ink begins where the bleed box does: a note one line taller writes
    /// over the printed sheet instead of standing beside it.
    #[test]
    fn the_note_in_the_margin_stays_under_the_ink() {
        let mut document = Document::new();
        let font = font(&mut document);
        let ink: Rect = bleed();

        let top = NOTE_STEP.mul_add(count(WORDS[0].1.first_note.len() - 1), NOTE_BASELINE)
            + font.ascent(NOTE_SIZE);

        assert!(
            top <= ink.y(),
            "the note reaches {top:.1} points up the sheet, and the ink begins \
             at {:.1}",
            ink.y()
        );
    }

    /// The fourth page states its boxes where its sheet sits: each one lies
    /// inside the sheet moved to [`MOVED`], and none inside the sheet at the
    /// origin.
    #[test]
    fn the_moved_sheet_states_its_boxes_on_itself() {
        let sheet = Rect::new(MOVED.0, MOVED.1, SHEET.0, SHEET.1);

        for (stated, _) in guide_boxes() {
            let box_ = moved(stated);

            assert!(
                box_.x() >= sheet.x()
                    && box_.y() >= sheet.y()
                    && box_.x() + box_.width() <= sheet.x() + sheet.width()
                    && box_.y() + box_.height() <= sheet.y() + sheet.height(),
                "{box_:?} leaves the sheet at {MOVED:?}"
            );
            assert!(
                box_.x() >= SHEET.0,
                "{box_:?} still stands on the sheet at the origin"
            );
        }
    }

    /// Converts a count of lines to a float. A note is never long enough for a
    /// `usize` to lose precision as an `f64`.
    #[expect(
        clippy::cast_precision_loss,
        reason = "a count of lines is far below f64's exact-integer range"
    )]
    fn count(n: usize) -> f64 {
        n as f64
    }
}