Struct LinearSpinner 

pub struct LinearSpinner<'a> { /* private fields */ }

A linear spinner that animates either horizontally or vertically.

Pass a monotonically increasing tick counter (typically incremented once per render frame) and call .direction(), .linear_style(), and colour methods to customise the appearance.

Horizontal (default)

tick  0–2 : ●●·
tick  3–5 : ·●●
tick  6–8 : ··●   (window wraps)
tick  9–11: ●··

Vertical (bounce)

tick  0–2 : ●      ← slot 0 lit
            ·
            ·
tick  3–5 : ·
            ●      ← slot 1 lit
            ·
tick  6–8 : ·
            ·
            ●      ← slot 2 lit
tick  9–11: ·
            ●      ← slot 1 lit (bouncing back)
            ·

Examples

use ratatui::Frame;
use ratatui::layout::Rect;
use tui_spinner::{Direction, LinearStyle, LinearSpinner};

fn draw(frame: &mut Frame, area: Rect, tick: u64) {
    // Horizontal ellipsis
    frame.render_widget(LinearSpinner::new(tick), area);

    // Vertical bounce with diamond symbols
    frame.render_widget(
        LinearSpinner::new(tick)
            .direction(Direction::Vertical)
            .linear_style(LinearStyle::Diamond),
        area,
    );
}

Implementations

impl<'a> LinearSpinner<'a>

pub fn new(tick: u64) -> Self

Creates a new LinearSpinner at the given animation tick with all defaults: 3 slots, 2 lit, horizontal, classic style, 3 ticks/step.

Examples

use tui_spinner::LinearSpinner;

let spinner = LinearSpinner::new(0);

pub const fn direction(self, direction: Direction) -> Self

Sets the animation direction (default: Direction::Horizontal).

• Direction::Horizontal — scrolling window across a row.
• Direction::Vertical — bouncing symbol down a column.

Examples

use tui_spinner::{Direction, LinearSpinner};

let vertical = LinearSpinner::new(0).direction(Direction::Vertical);

pub const fn flow(self, flow: Flow) -> Self

Sets the animation flow direction (default: Flow::Forwards).

• Flow::Forwards — normal playback (left-to-right / upward-first bounce).
• Flow::Backwards — reversed playback (right-to-left / downward-first bounce).

Examples

use tui_spinner::{Flow, LinearSpinner};

let backwards = LinearSpinner::new(0).flow(Flow::Backwards);

pub const fn linear_style(self, style: LinearStyle) -> Self

Sets the symbol pair used to draw active and inactive slots (default: LinearStyle::Classic).

Examples

use tui_spinner::{LinearStyle, LinearSpinner};

let spinner = LinearSpinner::new(0).linear_style(LinearStyle::Square);

pub fn total_slots(self, n: usize) -> Self

Sets the total number of slots (default: 3, minimum: 1).

For Direction::Vertical this is the column height. For Direction::Horizontal this is the row width.

Examples

use tui_spinner::LinearSpinner;

let spinner = LinearSpinner::new(0).total_slots(5);

pub fn lit_slots(self, n: usize) -> Self

Sets the number of consecutive slots lit at once (default: 2).

Only meaningful for Direction::Horizontal; ignored in vertical mode where exactly one slot is always lit. Values are clamped at render time to [1, total_slots].

Examples

use tui_spinner::LinearSpinner;

let spinner = LinearSpinner::new(0).lit_slots(1);

pub fn ticks_per_step(self, n: u64) -> Self

Sets how many ticks each animation step is held (default: 3).

Higher values slow the animation; lower values speed it up. Zero is silently clamped to 1.

Examples

use tui_spinner::LinearSpinner;

let fast = LinearSpinner::new(0).ticks_per_step(1);

pub const fn active_color(self, color: Color) -> Self

Sets the colour of active (lit) symbols (default: Color::White).

Examples

use ratatui::style::Color;
use tui_spinner::LinearSpinner;

let spinner = LinearSpinner::new(0).active_color(Color::Cyan);

pub const fn inactive_color(self, color: Color) -> Self

Sets the colour of inactive (dim) symbols (default: Color::DarkGray).

Examples

use ratatui::style::Color;
use tui_spinner::LinearSpinner;

let spinner = LinearSpinner::new(0).inactive_color(Color::DarkGray);

pub fn block(self, block: Block<'a>) -> Self

Wraps the spinner in a Block.

Examples

use ratatui::widgets::Block;
use tui_spinner::LinearSpinner;

let spinner = LinearSpinner::new(0).block(Block::bordered().title("Loading"));

pub fn style<S: Into<Style>>(self, style: S) -> Self

Sets the base style applied to the widget area.

Trait Implementations

impl<'a> Clone for LinearSpinner<'a>

fn clone(&self) -> LinearSpinner<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LinearSpinner<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for LinearSpinner<'a>

fn eq(&self, other: &LinearSpinner<'a>) -> 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 Styled for LinearSpinner<'_>

type Item = LinearSpinner<'_>

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S: Into<Style>>(self, style: S) -> Self

Sets the style of the object.

impl Widget for &LinearSpinner<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

impl Widget for LinearSpinner<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

impl<'a> StructuralPartialEq for LinearSpinner<'a>