write_tiling.rs

//! Fills six panels with patterns, each a cell drawn once and repeated.
//!
//! A tiling pattern is a small drawing and a step. The file holds the cell's
//! operators once, whatever the area filled with it, and the cell leaves alone
//! everything it does not paint — which is what lets two patterns cross. The
//! plane is tiled in the page's own space, so the panels below share one grid
//! rather than each starting its own.
//!
//! Each pattern also says how a reader may trade its step against its cell: the
//! dots are never stretched to fit the device's grid, the bricks keep an exact
//! step, and the rules may be tiled fast at the cost of either.
//!
//! The name at the foot of the page is filled with a pattern whose cell is a
//! page brought in from another PDF: a small seal, tiled inside the letters.
//!
//! The page is held in `Words`, once per language, and `HQF_PDF_LANG` picks
//! which set is drawn. What the panels are filled with is not language: the
//! cells, the steps and the matrix are the same drawing whoever reads the page.
//!
//! Usage: `cargo run --example write_tiling -- tmp/tiling.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_tiling -- tmp/motifs.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::read::Reader;
use hqf_pdf::{Document, Font, FontHandle, Page, PatternHandle, Rect, Rgb, Spacing, TilingPattern};

#[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 panel, in points.
const PANEL: (f64, f64) = (215.0, 150.0);

/// The bottom-left corner of each panel.
const CORNERS: &[(f64, f64)] = &[
    (70.0, 560.0),
    (305.0, 560.0),
    (70.0, 380.0),
    (305.0, 380.0),
    (70.0, 200.0),
    (305.0, 200.0),
];

/// How many panels the page holds.
const PANELS: usize = 6;

/// The name set in pattern-filled type at the foot of the page. A name is not
/// language.
const PRODUCT: &str = "hqf-pdf";

/// The words the page is written in, one set per language.
///
/// What each panel is filled with is not here: a cell, a step and a matrix are
/// the same drawing in every language.
#[derive(Debug)]
struct Words {
    /// The line at the head of the page.
    title: &'static str,
    /// The two lines under it, saying what a cell is and where it is tiled.
    intro: [&'static str; 2],
    /// What each panel shows, in the order the panels are drawn.
    captions: [&'static str; PANELS],
    /// The line under the pattern-filled name.
    filled: &'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 cell, tiled across whatever it fills",
    intro: [
        "Each panel holds one cell's operators, however wide the panel. The plane is tiled in the",
        "page's own space, so every panel below is a window onto the same grid.",
    ],
    captions: [
        "Bars, stepping their own width",
        "One dot, stepping wider, never stretched",
        "The same bars, slanted by the pattern's matrix",
        "Bricks: what leaves the cell's box is cut off",
        "Two patterns, the rules tiled fast",
        "The same bars again, at three times the step",
    ],
    filled: "A seal from a page of another PDF, tiled as the colour the word above is filled with.",
};

/// The page in French.
const FRENCH: Words = Words {
    title: "Une cellule, répétée sur tout ce qu’elle remplit",
    intro: [
        "Chaque panneau ne contient qu’une fois les opérateurs de sa cellule, quelle \
que soit sa largeur.",
        "Le plan est pavé dans l’espace de la page : tous les panneaux donnent sur la même grille.",
    ],
    captions: [
        "Des barres, au pas de leur propre largeur",
        "Un point, au pas plus large, jamais déformé",
        "Les mêmes barres, penchées par la matrice",
        "Briques : ce qui sort de la cellule est coupé",
        "Deux motifs, filets pavés au plus vite",
        "Les mêmes barres, au triple du pas",
    ],
    filled: "Un sceau pris sur une page d’un autre PDF, répété en motif pour remplir le mot ci-dessus.",
};

/// The page in Dutch.
const DUTCH: Words = Words {
    title: "Eén cel, herhaald over alles wat ze vult",
    intro: [
        "Elk paneel bevat de operatoren van één cel, hoe breed het paneel ook is. Het vlak wordt betegeld in de",
        "eigen ruimte van de pagina, dus elk paneel hieronder is een venster op hetzelfde raster.",
    ],
    captions: [
        "Staven, die hun eigen breedte opschuiven",
        "Eén punt, dat verder opschuift, nooit uitgerekt",
        "Staven, schuin gezet door de patroonmatrix",
        "Bakstenen: wat buiten de cel valt, valt weg",
        "Twee patronen, de lijnen dicht betegeld",
        "Weer dezelfde staven, met drie keer de stap",
    ],
    filled: "Een zegel van een pagina uit een andere pdf, herhaald als vulkleur van het woord hierboven.",
};

/// The page in Portuguese.
const PORTUGUESE: Words = Words {
    title: "Uma célula, repetida por tudo o que preenche",
    intro: [
        "Cada painel guarda os operadores de uma célula, seja qual for a largura do painel. O plano é ladrilhado no",
        "espaço próprio da página, por isso cada painel abaixo é uma janela para a mesma grelha.",
    ],
    captions: [
        "Barras, a avançar a sua própria largura",
        "Um ponto, a avançar mais, nunca esticado",
        "As barras, inclinadas pela matriz do padrão",
        "Tijolos: o que sai da caixa da célula é cortado",
        "Dois padrões, os filetes ladrilhados apertados",
        "As mesmas barras, com o triplo do passo",
    ],
    filled: "Um selo de uma página de outro PDF, em mosaico, como a cor que preenche a palavra acima.",
};

/// The page in Italian.
const ITALIAN: Words = Words {
    title: "Una cella, ripetuta su tutto ciò che riempie",
    intro: [
        "Ogni pannello tiene gli operatori di una cella, qualunque sia la sua larghezza. Il piano è piastrellato nello",
        "spazio proprio della pagina, così ogni pannello qui sotto è una finestra sulla stessa griglia.",
    ],
    captions: [
        "Barre, che avanzano della propria larghezza",
        "Un punto, che avanza di più, mai stirato",
        "Le barre, inclinate dalla matrice del motivo",
        "Mattoni: ciò che esce dalla cella è tagliato",
        "Due motivi, i filetti piastrellati fitti",
        "Di nuovo le stesse barre, a passo triplo",
    ],
    filled: "Un sigillo preso da una pagina di un altro PDF, ripetuto come colore della parola qui sopra.",
};

/// The page in Spanish.
const SPANISH: Words = Words {
    title: "Una celda, repetida en todo lo que llena",
    intro: [
        "Cada panel tiene los operadores de una celda, sea cual sea su ancho. El plano se tesela en el",
        "espacio propio de la página, así que cada panel de abajo es una ventana a la misma rejilla.",
    ],
    captions: [
        "Barras, avanzando su propio ancho",
        "Un punto, avanzando más, nunca estirado",
        "Las barras, inclinadas por la matriz del patrón",
        "Ladrillos: lo que sale de la celda se corta",
        "Dos patrones, las rayas teseladas deprisa",
        "Las mismas barras otra vez, al triple de paso",
    ],
    filled: "Un sello de una página de otro PDF, repetido como el color que rellena la palabra de arriba.",
};

/// The page in German.
const GERMAN: Words = Words {
    title: "Eine Zelle, über alles gekachelt, was sie füllt",
    intro: [
        "Jedes Feld nutzt die Operatoren einer einzigen Zelle, wie breit das Feld auch ist. Die Ebene wird im",
        "eigenen Raum der Seite gekachelt: Jedes Feld unten ist ein Fenster auf dasselbe Raster.",
    ],
    captions: [
        "Balken, um ihre Breite gerückt",
        "Ein Punkt, weiter rückend, nie gestreckt",
        "Dieselben Balken, schräg gestellt",
        "Ziegel: Was die Zelle verlässt, fällt weg",
        "Zwei Muster, Linien dicht gekachelt",
        "Dieselben Balken, dreifacher Schritt",
    ],
    filled: "Ein Siegel aus der Seite eines anderen PDF, gekachelt als Farbe, die das Wort darüber füllt.",
};

/// 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)`.
fn text(
    content: &mut Content,
    font: &FontHandle,
    size: f64,
    x: f64,
    y: f64,
    line: &str,
) -> Result<(), hqf_pdf::Error> {
    content.begin_text();
    content.set_font(font, size)?;
    content.text_origin(x, y)?;
    content.show_glyphs(&font.glyphs(line));
    content.end_text();
    Ok(())
}

/// A cell holding one bar `bar` points wide, repeated every `step` across.
fn bars(bar: f64, step: f64, color: Rgb) -> Result<TilingPattern, hqf_pdf::Error> {
    let mut cell = Content::new();
    cell.set_fill(color)?;
    cell.rect(0.0, 0.0, bar, 8.0)?.fill();
    TilingPattern::new(cell, Rect::new(0.0, 0.0, 8.0, 8.0), (step, 8.0))
}

/// A cell holding one square, repeated on a grid three times as wide as it is.
fn dots(color: Rgb) -> Result<TilingPattern, hqf_pdf::Error> {
    let mut cell = Content::new();
    cell.set_fill(color)?;
    cell.rect(0.0, 0.0, 3.0, 3.0)?.fill();
    TilingPattern::new(cell, Rect::new(0.0, 0.0, 12.0, 12.0), (12.0, 12.0))
}

/// A cell holding one bar lying flat, repeated every eight points up.
fn rules(color: Rgb) -> Result<TilingPattern, hqf_pdf::Error> {
    let mut cell = Content::new();
    cell.set_fill(color)?;
    cell.rect(0.0, 0.0, 8.0, 2.0)?.fill();
    TilingPattern::new(cell, Rect::new(0.0, 0.0, 8.0, 8.0), (8.0, 8.0))
}

/// Two courses of brick, the upper one offset by half a brick.
///
/// The bricks that run off the side of the cell are drawn all the same: the box
/// cuts them, and what the next cell along draws is their other half.
fn bricks() -> Result<TilingPattern, hqf_pdf::Error> {
    let mortar = Rgb::new(0.88, 0.86, 0.83);
    let brick = Rgb::new(0.70, 0.35, 0.26);

    let mut cell = Content::new();
    cell.set_fill(mortar)?;
    cell.rect(0.0, 0.0, 24.0, 24.0)?.fill();
    cell.set_fill(brick)?;
    for (x, y) in [
        (0.5, 0.5),
        (12.5, 0.5),
        (-5.5, 12.5),
        (6.5, 12.5),
        (18.5, 12.5),
    ] {
        cell.rect(x, y, 11.0, 11.0)?.fill();
    }

    TilingPattern::new(cell, Rect::new(0.0, 0.0, 24.0, 24.0), (24.0, 24.0))
}

/// The side of the page the motif is cut from, in points.
const SEAL: f64 = 6.0;

/// A PDF of one small page holding a seal: an orange square with a pale one set
/// inside it. The name at the foot of the page is filled with this page,
/// brought in from the file and tiled.
fn seal_document() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let mut seal = Document::new();
    seal.set_license(licence::licensed());
    let mut drawn = Content::new();
    drawn.set_fill(Rgb::new(0.85, 0.45, 0.12))?;
    drawn.rect(0.5, 0.5, 5.0, 5.0)?.fill();
    drawn.set_fill(Rgb::new(0.99, 0.93, 0.80))?;
    drawn.rect(2.0, 2.0, 2.0, 2.0)?.fill();
    let mut page = Page::new(SEAL, SEAL);
    page.content = drawn.into_bytes();
    seal.add_page(page)?;
    Ok(seal.to_bytes()?)
}

/// Fills one panel with each of `fills` in turn, and frames it.
fn panel(
    content: &mut Content,
    corner: (f64, f64),
    fills: &[&PatternHandle],
) -> Result<(), hqf_pdf::Error> {
    let (width, height) = PANEL;
    let (x, y) = corner;

    content.save_state();
    content.set_fill(Rgb::new(0.98, 0.98, 0.98))?;
    content.rect(x, y, width, height)?.fill();
    for fill in fills {
        content.set_fill_pattern(fill);
        content.rect(x, y, width, height)?.fill();
    }
    content.restore_state();

    content.save_state();
    content.set_stroke(Rgb::gray(0.55))?;
    content.set_line_width(0.6)?;
    content.rect(x, y, width, height)?.stroke();
    content.restore_state();
    Ok(())
}

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("tiling")));
    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 ink = Rgb::new(0.12, 0.28, 0.52);
    let upright = doc.add_tiling_pattern(bars(3.0, 8.0, ink)?);
    let scattered =
        doc.add_tiling_pattern(dots(Rgb::new(0.16, 0.45, 0.35))?.spacing(Spacing::Undistorted));
    let slanted =
        doc.add_tiling_pattern(bars(3.0, 8.0, ink)?.matrix([1.0, 0.0, 0.5, 1.0, 0.0, 0.0]));
    let wall = doc.add_tiling_pattern(bricks()?.spacing(Spacing::Constant));
    let flat = doc
        .add_tiling_pattern(rules(Rgb::new(0.78, 0.30, 0.24))?.spacing(Spacing::ConstantAndFast));
    let sparse = doc.add_tiling_pattern(bars(3.0, 24.0, ink)?);
    let motif = doc.import_page(&Reader::new(seal_document()?)?, 0)?;
    let mut cell = Content::new();
    cell.draw_form(motif.name(), 0.0, 0.0, 1.0)?;
    let mut seals = TilingPattern::new(cell, Rect::new(0.0, 0.0, SEAL, SEAL), (SEAL, SEAL))?;
    motif.add_to_pattern(&mut seals);
    let seals = doc.add_tiling_pattern(seals);

    let mut content = Content::new();
    text(&mut content, &font, 15.0, 70.0, 780.0, words.title)?;
    content.save_state();
    content.set_fill(Rgb::gray(0.35))?;
    text(&mut content, &font, 10.0, 70.0, 762.0, words.intro[0])?;
    text(&mut content, &font, 10.0, 70.0, 748.0, words.intro[1])?;
    content.restore_state();

    let fills: [&[&PatternHandle]; 6] = [
        &[&upright],
        &[&scattered],
        &[&slanted],
        &[&wall],
        &[&upright, &flat],
        &[&sparse],
    ];
    for ((corner, caption), fill) in CORNERS.iter().zip(words.captions).zip(fills) {
        panel(&mut content, *corner, fill)?;
        content.save_state();
        content.set_fill(Rgb::gray(0.35))?;
        text(&mut content, &font, 9.0, corner.0, corner.1 - 14.0, caption)?;
        content.restore_state();
    }

    // Text filled with a pattern: the letters are windows onto the tiled plane,
    // not a hundred little copies of the cell.
    content.save_state();
    content.set_fill_pattern(&seals);
    text(&mut content, &font, 58.0, 70.0, 100.0, PRODUCT)?;
    content.restore_state();

    content.save_state();
    content.set_fill(Rgb::gray(0.35))?;
    text(&mut content, &font, 10.0, 70.0, 80.0, words.filled)?;
    content.restore_state();

    let mut page = Page::a4();
    page.content = content.into_bytes();
    doc.add_page(page)?;

    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, {} panels from 6 cells",
        bytes.len(),
        CORNERS.len()
    );
    Ok(())
}

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

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

    /// The lines two languages are allowed to write the same way. Every line
    /// here is a sentence or a caption, and no two languages write one alike.
    const SPARED: [&str; 0] = [];

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

    /// A caption set under a panel of the left column that ran past the panel
    /// would run into the caption of the panel beside it.
    #[test]
    fn every_caption_stays_as_wide_as_its_panel() {
        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 (_, words) in WORDS {
            for caption in words.captions {
                let width = font.measure(caption, 9.0);
                assert!(width <= PANEL.0, "{caption:?} needs {width} of {}", PANEL.0);
            }
        }
    }
}