Struct Frames 

pub struct Frames { /* private fields */ }

A periodic glyph cycle on a caller-supplied clock.

Pure phase arithmetic: the frame at now and the instant of the next change derive from now mod interval, so cycles stay aligned no matter when or how often they are sampled.

Implementations

impl Frames

pub const SPINNER: Self

Braille spinner for Unicode-capable terminals.

pub const SPINNER_ASCII: Self

Four-spoke spinner safe for 7-bit ASCII terminals.

pub const fn new(frames: &'static [&'static str], interval: Duration) -> Self

Creates a cycle stepping through frames every interval.

Panics

When frames is empty or interval is zero.

pub const fn at(&self, now: Duration) -> &'static str

The glyph on screen at time now.

Examples found in repository

examples/footers.rs (line 133)

	const fn spinner(&self) -> &'static str {
		self.charset.spinner().at(self.elapsed)
	}

examples/chat/demo.rs (line 581)

	fn brand_segment(&self, now: Duration) -> Segment {
		let work = self.work.borrow();
		let brand = if work.working {
			fmts!(
				"{} {}",
				self.charset.spinner().at(now),
				elapsed_label(now.saturating_sub(work.since))
			)
		} else {
			fmts!("{} omp", self.charset.icon(Icon::Omp))
		};
		Segment::new()
			.label(brand)
			.with(Prop::Fg, work.fade.sample(now))
	}

pub const fn next_change(&self, now: Duration) -> Duration

When the glyph after now appears — the deadline to pass to crate::PaintCtx::wake.

Examples found in repository

examples/chat/demo.rs (line 687)

	fn paint(&mut self, pc: &mut PaintCtx<'_>, rect: Rect) {
		let mut left = self.left_group(pc.now);
		let (_, left_width) = left.measure(pc.ctx);
		let (_, right_width) = self.right.measure(pc.ctx);
		if left_width.saturating_add(2).saturating_add(right_width) <= rect.width {
			left.paint(pc, Rect::new(rect.x, rect.y, left_width, 1));
			let dock = rect
				.x
				.saturating_add(rect.width)
				.saturating_sub(right_width);
			self
				.right
				.paint(pc, Rect::new(dock, rect.y, right_width, 1));
		} else {
			let mut combined = self.combined(pc.now);
			combined.paint(pc, rect);
		}
		let work = self.work.borrow();
		let fade_frame = work
			.fade
			.settles_at()
			.min(pc.now.saturating_add(FADE_FRAME));
		let deadline = match (work.working, work.fade.is_settled(pc.now)) {
			(true, true) => Some(pc.ctx.charset.spinner().next_change(pc.now)),
			(true, false) => Some(pc.ctx.charset.spinner().next_change(pc.now).min(fade_frame)),
			(false, false) => Some(fade_frame),
			(false, true) => None,
		};
		if let Some(at) = deadline {
			pc.wake(self.slot, at);
		}
	}

Trait Implementations

impl Clone for Frames

fn clone(&self) -> Frames

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Frames

impl Debug for Frames

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

Formats the value using the given formatter.