Gradients in a line and in a circle

//! Paints axial and radial gradients, each into a clipped box.
//!
//! Four panels: a horizontal two-colour gradient, a diagonal one, a radial one
//! whose outer colour is extended to fill the corners, and a three-stop
//! gradient built from a stitched function. Each is added to the document once,
//! then painted into a rectangle the page clips to.
//!
//! The title and the four labels are held in `Words`, once per language, and
//! `HQF_PDF_LANG` picks which set is drawn.
//!
//! Usage: `cargo run --example write_gradient -- tmp/gradient.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_gradient -- tmp/degrade.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::{
    Axial, DeviceSpace, Document, Exponential, Font, FontHandle, Page, Radial, Rgb, Shading,
    ShadingHandle, Stitching,
};

#[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 words the page is written in, one set per language.
#[derive(Debug)]
struct Words {
    /// The title across the top of the page.
    title: &'static str,
    /// The label under each of the four panels.
    horizontal: &'static str,
    diagonal: &'static str,
    radial: &'static str,
    three_stops: &'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: "Axial and radial gradients",
    horizontal: "Axial, two colours",
    diagonal: "Axial, on the diagonal",
    radial: "Radial, outer extended",
    three_stops: "Axial, three stops",
};

/// The page in French.
const FRENCH: Words = Words {
    title: "Dégradés en ligne droite et en cercle",
    horizontal: "En ligne droite, deux couleurs",
    diagonal: "En ligne droite, en diagonale",
    radial: "En cercle, couleur extérieure prolongée",
    three_stops: "En ligne droite, trois couleurs",
};

/// 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 width and height of every panel, in points.
const BOX: (f64, f64) = (210.0, 170.0);

/// Paints a gradient into the box at `(x, y)`, sized [`BOX`], and writes a
/// label under it.
fn panel(
    content: &mut Content,
    font: &FontHandle,
    shading: &ShadingHandle,
    x: f64,
    y: f64,
    label: &str,
) -> Result<(), hqf_pdf::Error> {
    content.save_state();
    content.rect(x, y, BOX.0, BOX.1)?.clip().end_path();
    content.draw_shading(shading);
    content.restore_state();

    content.begin_text();
    content.set_font(font.name(), 10.0)?;
    content.text_origin(x, y - 15.0)?;
    content.show_glyphs(&font.glyphs(label));
    content.end_text();
    Ok(())
}

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("gradient")));
    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 handle = doc.add_font(font);

    // Left column x, right column x, top row foot, bottom row foot.
    let (left, right, top, bottom) = (70.0, 315.0, 560.0, 320.0);

    // A horizontal two-colour gradient across the top-left box.
    let horizontal = doc.add_shading(&Shading::from(Axial::rgb(
        (left, top),
        (left + BOX.0, top),
        Rgb::new(0.85, 0.12, 0.12),
        Rgb::new(0.12, 0.2, 0.8),
    )))?;

    // A diagonal two-colour gradient across the top-right box.
    let diagonal = doc.add_shading(&Shading::from(Axial::rgb(
        (right, bottom + BOX.1),
        (right + BOX.0, top + BOX.1),
        Rgb::new(0.95, 0.8, 0.1),
        Rgb::new(0.1, 0.55, 0.2),
    )))?;

    // A radial gradient in the bottom-left box, its outer colour extended so it
    // reaches the corners.
    let radial = doc.add_shading(&Shading::from(
        Radial::rgb(
            (left + BOX.0 / 2.0, bottom + BOX.1 / 2.0, 0.0),
            (left + BOX.0 / 2.0, bottom + BOX.1 / 2.0, BOX.0 / 2.0),
            Rgb::new(1.0, 1.0, 1.0),
            Rgb::new(0.1, 0.15, 0.45),
        )
        .extend(false, true),
    ))?;

    // A three-stop gradient in the bottom-right box, from a stitched function:
    // red to green over the first half, green to blue over the second.
    let rainbow_function = Stitching::new(
        [0.0, 1.0],
        vec![
            Exponential::new([0.0, 1.0], 1.0)
                .endpoints(vec![0.85, 0.12, 0.12], vec![0.12, 0.6, 0.2])
                .into(),
            Exponential::new([0.0, 1.0], 1.0)
                .endpoints(vec![0.12, 0.6, 0.2], vec![0.12, 0.2, 0.8])
                .into(),
        ],
        vec![0.5],
        vec![[0.0, 1.0], [0.0, 1.0]],
    );
    let rainbow = doc.add_shading(&Shading::from(Axial::new(
        (right, bottom),
        (right + BOX.0, bottom),
        DeviceSpace::Rgb,
        rainbow_function,
    )))?;

    let mut content = Content::new();

    content.begin_text();
    content.set_font(handle.name(), 18.0)?;
    content.text_origin(left, 770.0)?;
    content.show_glyphs(&handle.glyphs(words.title));
    content.end_text();

    panel(
        &mut content,
        &handle,
        &horizontal,
        left,
        top,
        words.horizontal,
    )?;
    panel(&mut content, &handle, &diagonal, right, top, words.diagonal)?;
    panel(&mut content, &handle, &radial, left, bottom, words.radial)?;
    panel(
        &mut content,
        &handle,
        &rainbow,
        right,
        bottom,
        words.three_stops,
    )?;

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

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

    /// The lines two languages are allowed to write the same way. There are
    /// none: every word is a word of the language it is written in.
    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:?}"
        );
    }
}