Struct Bound 

pub struct Bound {
    pub w: Option<Extent>,
    pub h: Option<Extent>,
}

Size bounds {w?, h?} for min and max.

Fields

w: Option<Extent>

The width bound.

h: Option<Extent>

The height bound.

Implementations

impl Bound

pub const fn w(w: Extent) -> Self

A width bound.

pub const fn h(h: Extent) -> Self

A height bound.

Examples found in repository

examples/progress.rs (line 79)

fn view(build: &Build) -> View {
	let fraction = build.done as f64 / STEPS.len() as f64;
	let running = build.took.is_none();
	let activity: ui::Node = if running {
		ui::spinner()
			.style("dots")
			.label(STEPS[build.done.min(STEPS.len() - 1)])
			.into()
	} else {
		ui::icon(if build.status == Status::Done {
			"check"
		} else {
			"x"
		})
		.tone(if build.status == Status::Done {
			"success"
		} else {
			"error"
		})
		.into()
	};
	let mut timer = ui::elapsed().age(0);
	if let Some(took) = build.took {
		timer = timer.stopped(took);
	}
	View::new().main([ui::card()
		.key("build")
		.head("Building demo")
		.status(build.status.clone())
		.child(
			ui::row()
				.key("head")
				.gap("sm")
				.children(nodes![activity.key("a"), timer.key("t")]),
		)
		.child(
			ui::ansi(&build.log)
				.key("log")
				.follow(true)
				.max(Bound::h(Extent::Lines(8.0))),
		)
		.child(ui::progress().key("bar").value(fraction).label(format!(
			"{}/{}",
			build.done,
			STEPS.len()
		)))])
}

pub const fn wh(w: Extent, h: Extent) -> Self

Both bounds.

Trait Implementations

impl Clone for Bound

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Bound

impl Debug for Bound

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

Formats the value using the given formatter.

impl Default for Bound

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Bound

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Bound

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Bound