Enum Density 

#[non_exhaustive]
pub enum Density {
    Touch,
    Mouse,
}

How much room an interactive widget’s hit target should claim.

It exists so an app choosing between a phone-sized and a desktop-sized layout has one place to ask “how big should this button/row/slider be”, rather than inventing its own ad hoc breakpoint constants per widget. An InteractiveWidget reads min_target_size the same way it reads sense; for_width is the other half, turning a terminal width into a Density in the first place.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Touch

Larger interactive targets, for a fingertip on a phone-width terminal or other touch input, at the cost of showing fewer rows at once.

Mouse

Dense, single-line interactive targets, for a mouse on a normal desktop-sized terminal, where precise clicking doesn’t need extra height.

Implementations

impl Density

pub const DEFAULT_BREAKPOINT_WIDTH: u16 = 64

Below this width, in cells, for_width picks Density::Touch; at or above it, Density::Mouse. An app that wants a different breakpoint states it relative to this default (e.g. if width < Density::DEFAULT_BREAKPOINT_WIDTH - 4 { .. }) rather than inventing an unrelated constant from scratch.

64 sits between a phone-width terminal (roughly 40 to 50 columns, where fingertip sizing wins) and the classic 80-column desktop width (where a mouse and dense rows win). Lower keeps touch sizing only on very narrow terminals; higher applies it to wider ones that a mouse user would rather see packed densely. Picked by feel for that split, not measured.

pub const fn min_target_size(self) -> Size

The minimum size, in cells, an interactive target should claim at this density.

Both densities are 6 cells wide: enough for a short bracketed label like [ OK ] plus a cell of breathing room, the narrowest a tappable/clickable control stays legible. Height is where they differ. Density::Mouse is a single row, since a mouse can land on one line precisely. Density::Touch is 3 rows so a fingertip has vertical slack to hit (and so a bordered one-line control fits: top border, content, bottom border), at the cost of showing fewer rows on screen. The exact 6/3/1 were picked by feel for readable terminal controls, not measured against touch-target studies.

pub const fn for_width(width: u16) -> Self

Picks a density from a terminal (or pane) width, in cells, against DEFAULT_BREAKPOINT_WIDTH.

A one-line replacement for the ad hoc if width < N { .. } every consumer of this crate has otherwise had to write for itself, with a different N each time.

Trait Implementations

impl Clone for Density

fn clone(&self) -> Density

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Density

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Density

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Density

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 PartialEq for Density

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Density

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Density

impl Eq for Density

impl StructuralPartialEq for Density