Cells merged down the rows

//! Draws a specification sheet whose cells are merged down the rows.
//!
//! Each group of properties names itself once, in a cell covering all the rows
//! of the group, and carries one note beside them in another: the rows beneath
//! hand their cells to the columns those two leave free, and the hairlines
//! between the rows stop at their edges. The last group shows what a merged
//! cell does when it needs more room than its rows give it: every row it covers
//! grows by the same share of what is missing.
//!
//! Usage: `cargo run --example write_merged_cells -- tmp/merged_cells.pdf
//! [font.ttf]`

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

use hqf_pdf::content::Content;
use hqf_pdf::layout::{Cell, ColumnWidth, Columns, Padding, Row, Rule, Stroke, Table, VAlign};
use hqf_pdf::{Align, Document, Font, Page, Rgb};

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

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

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

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 margin around the table, in points.
const MARGIN: f64 = 56.0;
/// The top of the table on the page.
const TOP: f64 = 760.0;
/// The lowest the table may reach.
const BOTTOM: f64 = 64.0;

/// A4's width, which the table is fitted across.
const PAGE_WIDTH: f64 = 595.276;

/// The width left to the table between the margins.
const TABLE_WIDTH: f64 = PAGE_WIDTH - 2.0 * MARGIN;

/// The colour a group's name and its note are painted on.
const GROUP_FILL: Rgb = Rgb::new(0.90, 0.91, 0.94);

/// How many groups the sheet prints, and how many properties in all.
const GROUP_COUNT: usize = 4;
const PROPERTY_COUNT: usize = 11;

/// How many properties each group holds, in the order they are printed.
const GROUP_ROWS: [usize; GROUP_COUNT] = [4, 3, 2, 2];

/// The words the sheet is written in, one set per language.
///
/// What is not language stays out of it: the model's number, the figures and
/// the units they are given in read the same in every language.
#[derive(Debug)]
struct Words {
    /// The heading across the four columns.
    title: &'static str,
    /// What each group is called, written once beside all of its rows.
    groups: [&'static str; GROUP_COUNT],
    /// What is said about each group as a whole, once beside all of its rows.
    /// The last is far longer than the two rows it covers, which is what makes
    /// the sheet's last row grow.
    notes: [&'static str; GROUP_COUNT],
    /// What each property is called, group after group.
    properties: [&'static str; PROPERTY_COUNT],
    /// What each of them is worth, in the same order.
    values: [&'static str; PROPERTY_COUNT],
}

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: "Model HQF-220 — technical data",
    groups: ["Body", "Optics", "Mounting", "Power"],
    notes: [
        "Measured without the mounting plate.",
        "Figures hold across the whole of the zoom range.",
        "Plate sold with the instrument.",
        "Twelve volts, from the adapter supplied or from any regulated bench \
         supply. The instrument draws its full current for the first two \
         seconds after it is switched on, so a supply rated at the working \
         figure alone will trip.",
    ],
    properties: [
        "Material",
        "Mass",
        "Finish",
        "Sealing",
        "Focal length",
        "Widest aperture",
        "Coating",
        "Thread",
        "Plate",
        "Supply",
        "Draw",
    ],
    values: [
        "Anodised aluminium",
        "1.84 kg",
        "Matt black, bead blasted",
        "IP65",
        "24 to 70 mm",
        "f/2.8",
        "Multi-layer, both faces",
        "M6, four points",
        "Quick release",
        "12 V DC",
        "9 W at full output",
    ],
};

/// The sheet in French.
const FRENCH: Words = Words {
    title: "Modèle HQF-220 — caractéristiques techniques",
    groups: ["Boîtier", "Optique", "Fixation", "Alimentation"],
    notes: [
        "Mesuré sans la platine de fixation.",
        "Valeurs valables sur toute la plage de zoom.",
        "Platine livrée avec l'appareil.",
        "Douze volts, par l'adaptateur fourni ou par toute alimentation de \
         laboratoire régulée. L'appareil appelle son courant maximal pendant \
         les deux premières secondes après la mise sous tension : une \
         alimentation calibrée sur la seule valeur nominale déclenchera.",
    ],
    properties: [
        "Matériau",
        "Masse",
        "Finition",
        "Étanchéité",
        "Focale",
        "Ouverture maximale",
        "Traitement",
        "Filetage",
        "Platine",
        "Source",
        "Consommation",
    ],
    values: [
        "Aluminium anodisé",
        "1.84 kg",
        "Noir mat, microbillé",
        "IP65",
        "24 à 70 mm",
        "f/2.8",
        "Multicouche, deux faces",
        "M6, quatre points",
        "Attache rapide",
        "12 V continu",
        "9 W à pleine puissance",
    ],
};

/// 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); 2] =
    [(Language::English, &ENGLISH), (Language::French, &FRENCH)];

/// The specification sheet: a heading across the table, then two merged cells
/// per group of properties.
fn sheet<'a>(
    text: &'a hqf_pdf::FontHandle,
    words: &'static Words,
) -> Result<Table<'a>, hqf_pdf::Error> {
    // The property column takes whatever the other three leave it.
    let columns = Columns::new(
        vec![
            ColumnWidth::Points(76.0),
            ColumnWidth::Fraction(1.0),
            ColumnWidth::Points(120.0),
            ColumnWidth::Points(150.0),
        ],
        TABLE_WIDTH,
    )?;

    let mut table = Table::new(columns);
    table.header(1);
    table
        .rule(Rule::Frame, Stroke::black(0.8))
        .rule(Rule::HorizontalOther, Stroke::new(0.25, Rgb::gray(0.75)))
        .rule(Rule::VerticalOther, Stroke::new(0.25, Rgb::gray(0.75)))
        .rule(Rule::Horizontal(1), Stroke::black(0.8));

    let pad = Padding::symmetric(6.0, 5.0);

    // The heading covers the four columns, the way a cell covers four rows
    // further down: one span across, one down.
    table.push(
        Row::new()
            .cell(
                Cell::new(text, 11.0, words.title)
                    .span(4)
                    .align(Align::Center)
                    .valign(VAlign::Middle)
                    .padding(pad)
                    .fill(Rgb::gray(0.86)),
            )
            .min_height(24.0),
    );

    let mut first = 0;
    for (group, &rows) in GROUP_ROWS.iter().enumerate() {
        for index in 0..rows {
            let property = words.properties[first + index];
            let value = words.values[first + index];
            let mut row = Row::new();
            // The group names itself on its first row only, and so does its
            // note. The rows under them hold two cells, not four: the first
            // column and the last are taken.
            if index == 0 {
                row = row.cell(
                    Cell::new(text, 10.0, words.groups[group])
                        .span_rows(rows)
                        .align(Align::Center)
                        .valign(VAlign::Middle)
                        .padding(pad)
                        .fill(GROUP_FILL),
                );
            }
            row = row
                .cell(Cell::new(text, 9.0, property).padding(pad))
                .cell(Cell::new(text, 9.0, value).padding(pad));
            if index == 0 {
                row = row.cell(
                    Cell::new(text, 8.0, words.notes[group])
                        .span_rows(rows)
                        .align(Align::Justify)
                        .padding(pad)
                        .fill(GROUP_FILL),
                );
            }
            table.push(row.min_height(18.0));
        }
        first += rows;
    }

    Ok(table)
}

fn main() -> 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("merged_cells")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

    let font = Font::parse(fs::read(&font_path)?)?;
    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    let text = doc.add_font(font);

    let table = sheet(&text, words)?;
    let placed = table.fit(MARGIN, TOP, TOP - BOTTOM, 0)?;

    let mut content = Content::new();
    placed.draw(&mut content)?;

    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, {} rows",
        bytes.len(),
        table.row_count()
    );
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::{WORDS, language};

    /// The lines two languages are allowed to write the same way, each with
    /// what makes the two the same word.
    const SPARED: [&str; 3] = ["\"1.84 kg\"", "\"IP65\"", "\"f/2.8\""];

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