Struct Surface 

pub struct Surface {
    pub base: f32,
    pub quantum: f32,
}

What the layout is being drawn on: a base unit, and the smallest step the surface can actually represent.

Both are in the surface’s own units, and the crate never assumes those are pixels. A display measures in pixels and can represent one of them; a terminal measures in cells and cannot represent less than one. That single difference is the whole of the terminal story — a TUI is not a density, it is a surface with a coarse quantum, and the relational vocabulary above crosses over untouched.

Quantising is not a terminal special case. A display does it too; it is just that rounding 6.0 to the nearest pixel is uninteresting, whereas rounding three eighths of a cell to the nearest cell is a design decision the surface makes for you.

Fields

base: f32

The base unit, in this surface’s units.

quantum: f32

The smallest step this surface can represent, in the same units.

Implementations

impl Surface

pub fn web() -> Self

A display measuring in CSS pixels: a 16px base, one-pixel quantum.

pub fn terminal() -> Self

A terminal measuring in cells: a one-cell base, one-cell quantum.

The coarsest surface in the family, and the one that proves the vocabulary. bound and peer collapse to no cells at all, which is correct — in a grid this dense, “belongs to” and “is a peer of” are both expressed by adjacency, not by a gap.

Examples found in repository

examples/dump.rs (line 12)

fn main() {
    print!("{}", geometry_css_vars(Density::Pointer));
    println!();
    print!("{}", gap_css_overrides(".ui-mode-mobile", Density::Touch));

    println!("\n/* the same relationships on a terminal, in cells */");
    let t = Surface::terminal();
    for gap in Gap::all() {
        println!(
            "/*   {:<8} {} */",
            gap.token().trim_start_matches("gap-"),
            t.gap(gap, Density::Pointer)
        );
    }
}

pub fn resolve(self, ratio: Ratio) -> f32

Resolve a ratio on this surface, snapped to its quantum.

pub fn quanta(self, ratio: Ratio) -> u32

How many whole quanta a ratio is worth here.

What a cell-addressed layout actually wants: the count, not the size.

pub fn gap(self, gap: Gap, density: Density) -> u32

Resolve a relationship on this surface at a given density, in quanta.

The whole model in one call: what is being separated, who is operating it, what it is drawn on.

Examples found in repository

examples/dump.rs (line 17)

fn main() {
    print!("{}", geometry_css_vars(Density::Pointer));
    println!();
    print!("{}", gap_css_overrides(".ui-mode-mobile", Density::Touch));

    println!("\n/* the same relationships on a terminal, in cells */");
    let t = Surface::terminal();
    for gap in Gap::all() {
        println!(
            "/*   {:<8} {} */",
            gap.token().trim_start_matches("gap-"),
            t.gap(gap, Density::Pointer)
        );
    }
}

Trait Implementations

impl Clone for Surface

fn clone(&self) -> Surface

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Surface

impl Debug for Surface

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Surface

fn eq(&self, other: &Surface) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Surface