Struct cursive::views::ProgressBar

pub struct ProgressBar { /* fields omitted */ }

Animated bar showing a progress value.

This bar has an internal counter, and adapts the length of the displayed bar to the relative position of the counter between a minimum and maximum values.

It also prints a customizable text in the center of the bar, which defaults to the progression percentage.

The bar defaults to the current theme's highlight color, but that can be customized.

Example

let bar = ProgressBar::new()
                      .with_task(|counter| {
                          // This closure is called in parallel.
                          for _ in 0..100 {
                              // Here we can communicate some
                              // advancement back to the bar.
                              counter.tick(1);
                          }
                      });

Implementations

impl ProgressBar

pub fn new() -> ProgressBar

Creates a new progress bar.

Default values:

• min: 0
• max: 100
• value: 0

pub fn with_value(self, value: Counter) -> ProgressBar

Sets the value to follow.

Use this to manually control the progress to display by directly modifying the value pointed to by value.

pub fn start<F>(&mut self, f: F) where
    F: 'static + Send + FnOnce(Counter), 

Starts a function in a separate thread, and monitor the progress.

f will be given a Counter to increment the bar's progress.

This does not reset the value, so it can be called several times to advance the progress in multiple sessions.

pub fn with_task<F>(self, task: F) -> ProgressBar where
    F: 'static + Send + FnOnce(Counter), 

Starts a function in a separate thread, and monitor the progress.

Chainable variant.

pub fn with_label<F>(self, label_maker: F) -> ProgressBar where
    F: 'static + Fn(usize, (usize, usize)) -> String, 

Sets the label generator.

The given function will be called with (value, (min, max)). Its output will be used as the label to print inside the progress bar.

The default one shows a percentage progress:

fn make_progress(value: usize, (min, max): (usize, usize)) -> String {
    let percent = 101 * (value - min) / (1 + max - min);
    format!("{} %", percent)
}

pub fn min(self, min: usize) -> ProgressBar

Sets the minimum value.

When value equals min, the bar is at the minimum level.

If self.min > max, self.min is set to max.

pub fn max(self, max: usize) -> ProgressBar

Sets the maximum value.

When value equals max, the bar is at the maximum level.

If min > self.max, self.max is set to min.

pub fn range(self, min: usize, max: usize) -> ProgressBar

Sets the min and max range for the value.

If min > max, swap the two values.

pub fn set_value(&mut self, value: usize)

Sets the current value.

Value is clamped between min and max.

pub fn set_color<C>(&mut self, color: C) where
    C: Into<ColorType>, 

Sets the color style.

The default color is PaletteColor::Highlight.

pub fn with_color<C>(self, color: C) -> ProgressBar where
    C: Into<ColorType>, 

Sets the color style.

Chainable variant of set_color.

Trait Implementations

impl Default for ProgressBar

fn default() -> ProgressBar

Returns the "default value" for a type.

impl View for ProgressBar

fn draw(&self, printer: &Printer)

Draws the view with the given printer (includes bounds) and focus.

fn layout(&mut self, XY<usize>)

Called once the size for this view has been decided.

fn needs_relayout(&self) -> bool

Should return true if the view content changed since the last call to layout().

fn required_size(&mut self, constraint: XY<usize>) -> XY<usize>

Returns the minimum size the view requires with the given restrictions.

fn on_event(&mut self, Event) -> EventResult

Called when an event is received (key press, mouse event, ...).

fn call_on_any(
    &mut self,
    &Selector,
    &'a mut (dyn FnMut(&mut (dyn View + 'static)) + 'a)
)

Runs a closure on the view identified by the given selector.

fn focus_view(&mut self, &Selector) -> Result<(), ()>

Moves the focus to the view identified by the given selector.

fn take_focus(&mut self, source: Direction) -> bool

This view is offered focus. Will it take it?

fn important_area(&self, view_size: XY<usize>) -> Rect

What part of the view is important and should be visible?

fn type_name(&self) -> &'static str

Returns the type of this view.