Struct BarSpinner 

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

A Zed / Claude-style braille loading bar that bounces left and right.

Every character cell in the bar is a braille glyph. A bright arc window slides across and reverses at each end; the arc edges fade through a density ramp (⠉ ⠛ ⠿ ⣿) for a soft comet-glow look. The dim background uses ⣀ (a two-dot rail) so the full bar extent is visible without competing with the arc.

Width

Leave width at its default 0 to fill the available area automatically (most common usage). Set it to a fixed positive value if you need a predetermined size.

Examples

use ratatui::style::Color;
use ratatui::Frame;
use ratatui::layout::Rect;
use tui_spinner::{BarSpinner, BarTrack, Spin};

fn draw(frame: &mut Frame, area: Rect, tick: u64) {
    // Fills the full width of `area` — typical Zed/Claude style.
    frame.render_widget(
        BarSpinner::new(tick)
            .arc_color(Color::Cyan)
            .dim_color(Color::DarkGray),
        area,
    );
}

Field Defaults

| Field | Default | |—————–|—————————–|| | track | BarTrack::Rail | | fade_width | 3 | | arc_byte | 0xFF (⣿) | | bar_style | BarStyle::Braille | | motion | BarMotion::Bounce |

Implementations

impl<'a> BarSpinner<'a>

pub fn zed(tick: u64) -> Self

Zed-style preset — 1 row, cyan arc, subtle Rail track, clockwise.

use tui_spinner::BarSpinner;
let s = BarSpinner::zed(42);

pub fn claude(tick: u64) -> Self

Claude-style preset — 2 rows, warm-orange arc, Rail track, clockwise.

use tui_spinner::BarSpinner;
let s = BarSpinner::claude(42);

pub fn minimal(tick: u64) -> Self

Minimal preset — 1 row, white arc, Empty track (arc floats on space).

use tui_spinner::BarSpinner;
let s = BarSpinner::minimal(42);

pub fn solid(tick: u64) -> Self

Solid preset — 1 row, cyan arc, Full track, sharp zero-fade edges.

use tui_spinner::BarSpinner;
let s = BarSpinner::solid(42);

pub fn new(tick: u64) -> Self

Creates a new BarSpinner with defaults: auto-width, 1-row height, clockwise start, cyan arc, dark-gray track, 1 tick per step, auto arc width.

Examples

use tui_spinner::BarSpinner;

let spinner = BarSpinner::new(42);

pub fn width(self, w: usize) -> Self

Sets the fixed width in character columns.

Pass 0 (the default) to fill the available area width automatically.

Examples

use tui_spinner::BarSpinner;

let fixed = BarSpinner::new(0).width(24);
let auto  = BarSpinner::new(0).width(0); // fills area

pub fn height(self, h: usize) -> Self

Sets the height in character rows (minimum 1, default 1).

Use 1 for a thin Zed-style bar or 2–3 for a thicker Claude-style block.

Examples

use tui_spinner::BarSpinner;

let thick = BarSpinner::new(0).height(2);

pub fn arc_width(self, w: usize) -> Self

Sets the arc width in character columns (0 = auto ~⅓ of bar).

Examples

use tui_spinner::BarSpinner;

let narrow = BarSpinner::new(0).arc_width(6);
let wide   = BarSpinner::new(0).arc_width(20);

pub const fn spin(self, spin: Spin) -> Self

Sets the starting direction before the first bounce (default: Spin::Clockwise = starts moving right).

Examples

use tui_spinner::{BarSpinner, Spin};

let rtl = BarSpinner::new(0).spin(Spin::CounterClockwise);

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

Sets how many ticks each arc position is held (default 1; higher = slower).

Examples

use tui_spinner::BarSpinner;

let slow = BarSpinner::new(0).ticks_per_step(3);

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

Sets the colour of the bright arc glyph (default: Color::Cyan).

Examples

use ratatui::style::Color;
use tui_spinner::BarSpinner;

let spinner = BarSpinner::new(0).arc_color(Color::LightBlue);

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

Sets the colour of the dim background track (default: Color::DarkGray).

Set to the terminal background colour (e.g. Color::Black) to hide the track so only the glowing arc is visible.

Examples

use ratatui::style::Color;
use tui_spinner::BarSpinner;

// Visible track
let with_track    = BarSpinner::new(0).dim_color(Color::DarkGray);
// Arc floats on empty space
let no_track      = BarSpinner::new(0).dim_color(Color::Black);

pub fn with_colors(self, arc_color: Color, dim_color: Color) -> Self

Sets both arc_color and dim_color in one call.

Equivalent to .arc_color(arc).dim_color(dim).

Examples

use ratatui::style::Color;
use tui_spinner::BarSpinner;

let s = BarSpinner::new(0).with_colors(Color::Cyan, Color::DarkGray);

pub fn track(self, track: BarTrack) -> Self

Sets the background track style (default BarTrack::Rail).

Examples

use tui_spinner::{BarSpinner, BarTrack};

let solid = BarSpinner::new(0).track(BarTrack::Full);
let float = BarSpinner::new(0).track(BarTrack::Empty);

pub fn fade_width(self, w: usize) -> Self

Sets the arc fade-ramp width in character columns (default 3).

0 = sharp cutoff — the arc edge is a hard boundary. 1–3 = progressively softer gradient (default 3 gives ⠉ ⠛ ⠿ ⣿).

Examples

use tui_spinner::BarSpinner;

let sharp = BarSpinner::new(0).fade_width(0);
let soft  = BarSpinner::new(0).fade_width(3); // default

pub fn arc_char(self, byte: u8) -> Self

Sets the braille byte for the fully-lit arc centre cells (default 0xFF = ⣿).

Use any braille byte to change the arc density. The fade ramp always starts from ⠉ and tapers up to this value.

Example byte	Glyph	Dots
0xFF	⣿	8 — full (default)
0x7F	⡿	7
0x3F	⠿	6
0x1B	⠛	4

Examples

use tui_spinner::BarSpinner;

let light = BarSpinner::new(0).arc_char(0x3F); // ⠿ lighter arc

pub fn bar_style(self, style: BarStyle) -> Self

Sets the glyph style for the arc and background track (default BarStyle::Braille).

Symbol styles (Block, Shade, Dot, Diamond, Square) use a single Unicode character for the arc and one for the track. They ignore arc_char, track, and fade_width.

Examples

use tui_spinner::{BarSpinner, BarStyle};

let block = BarSpinner::new(0).bar_style(BarStyle::Block);
let dot   = BarSpinner::new(0).bar_style(BarStyle::Dot);

pub fn motion(self, motion: BarMotion) -> Self

Sets the arc motion mode (default BarMotion::Bounce).

• BarMotion::Bounce — reverses at each edge (ping-pong).
• BarMotion::Loop — wraps around; use with Spin to set the sweep direction.

Examples

use tui_spinner::{BarSpinner, BarMotion, Spin};

// Continuous left-to-right sweep
let sweep = BarSpinner::new(0)
    .spin(Spin::Clockwise)
    .motion(BarMotion::Loop);

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

Wraps the spinner in a Block.

Examples

use ratatui::widgets::Block;
use tui_spinner::BarSpinner;

let spinner = BarSpinner::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.

pub const fn alignment(self, alignment: Alignment) -> Self

Sets the horizontal alignment of the rendered output (default: left).

pub fn char_size(&self) -> Option<(usize, usize)>

Returns the explicit rendered size (cols, rows), or None when the width is set to auto (0).

Examples

use tui_spinner::BarSpinner;

assert_eq!(
    BarSpinner::new(0).width(20).height(2).char_size(),
    Some((20, 2))
);
assert_eq!(BarSpinner::new(0).char_size(), None);

Trait Implementations

impl<'a> Clone for BarSpinner<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BarSpinner<'a>

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

Formats the value using the given formatter.

impl Styled for BarSpinner<'_>

type Item = BarSpinner<'_>

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 &BarSpinner<'_>

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 BarSpinner<'_>

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.