Enum Gap 

pub enum Gap {
    Bound,
    Peer,
    Group,
    Section,
    Pane,
    Page,
}

A named separation between two things.

Pick by relationship. The size is a consequence of the name, not the other way round, and callers should never care what it is.

Variants

Bound

A control and the thing it belongs to: an edit field and its pop-up, a checkbox and its label, an icon and the text it labels. Reads as one object.

Peer

Items of the same kind in a list: stacked checkboxes, radio buttons, rows, chips in a row. Reads as a set.

Group

A container’s inner margin, and the distance between sibling groups side by side. Reads as “inside this box”.

Section

Separated groups, and rows of actions. The first gap that reads as a deliberate break rather than as breathing room.

Pane

Panel padding and content shells. Layout, not controls.

Page

The outermost shell margin. One per screen, usually.

Implementations

impl Gap

pub const fn step_at(self, density: Density) -> Step

The step this relationship resolves to at a given density.

Density::Pointer’s values are the HIG’s own. Density::Touch opens the three gaps that separate distinct tap targets and holds the rest, per the crate-level “Density presets” section.

pub const fn step(self) -> Step

The step this relationship resolves to at the default density.

pub const fn px_at(self, density: Density) -> u16

Size in CSS pixels at the default base, at a given density.

pub const fn px(self) -> u16

Size in CSS pixels at the default base and density.

pub const fn token(self) -> &'static str

The CSS custom-property name, without the leading --.

Examples found in repository

examples/dump.rs (line 16)

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 const fn all() -> [Self; 6]

Every relationship, tightest first.

Examples found in repository

examples/dump.rs (line 13)

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 Gap

fn clone(&self) -> Gap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Gap

impl Debug for Gap

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

Formats the value using the given formatter.

impl Eq for Gap

impl Hash for Gap

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Gap

fn cmp(&self, other: &Gap) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Gap

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Gap

fn partial_cmp(&self, other: &Gap) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Gap