Struct cursive_async_view::AsyncProgressView

pub struct AsyncProgressView<T: View + Send> { /* fields omitted */ }

An AsyncProgressView is a wrapper view that displays a progress bar, until the child view is successfully created. The creation of the inner view is done on a dedicated thread. Therefore, it is necessary for the creation function to always return, otherwise the thread will get stuck.

Example usage

use crossbeam::Sender;
use cursive::{views::TextView, Cursive};
use cursive_async_view::AsyncProgressView;

let mut siv = Cursive::default();
let async_view = AsyncProgressView::new(&siv, |s: Sender<f32>| {
    std::thread::sleep(std::time::Duration::from_secs(1));
    s.send(0.2).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    s.send(0.4).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    s.send(0.6).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    s.send(0.8).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    s.send(1.0).unwrap();
    TextView::new("Yay, the content has loaded!")
});

siv.add_layer(async_view);
// siv.run();

Threads

The new(siv, creator) method will spawn 2 threads:

1. cursive-async-view::creator The creation thread for the wrapped view. This thread will stop running as soon as the creation function returned.
2. cursive-async-view::updater The update thread waits for the creation function to signal progress and will be stopped by AsyncProgressView when the creation function returned and the new view is available for layouting.

The threads are labeled as indicated above.

TODO

• make creation function return a result to mark an unsuccessful creation

Methods

impl<T: View + Send + Sized> AsyncProgressView<T>

pub fn new<F>(siv: &Cursive, creator: F) -> Self where
    F: FnOnce(Sender<f32>) -> T + Send + 'static, 

Create a new AsyncProgressView instance. The cursive reference is only used to update the screen when a progress update is received. In order to show the view, it has to be directly or indirectly added to a cursive layer like any other view.

The creator function will be executed on a dedicated thread in the background. Make sure that this function will never block indefinitely. Otherwise, the creation thread will get stuck.

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

Mark the maximum allowed width in characters, the progress bar may consume. By default, the width will be inherited by the parent view.

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

Mark the maximum allowed height in characters, the progress bar may consume. By default, the height will be inherited by the parent view.

pub fn with_progress_fn<F>(self, progress_fn: F) -> Self where
    F: Fn(usize, usize, f32) -> StyledString + 'static, 

Set a custom progress function for this view, indicating the progress of the wrapped view creation. See the default_progress function reference for an example on how to create a custom progress function.

pub fn set_width(&mut self, width: usize)

Set the maximum allowed width in characters, the progress bar may consume.

pub fn set_height(&mut self, height: usize)

Set the maximum allowed height in characters, the progress bar may consume.

pub fn set_progress_fn<F>(&mut self, progress_fn: F) where
    F: Fn(usize, usize, f32) -> StyledString + 'static, 

Set a custom progress function for this view, indicating the progress of the wrapped view creation. See the default_progress function reference for an example on how to create a custom progress function.

The function may be set at any time. The progress bar can be changed even if the previous progress bar has already be drawn.

pub fn inherit_width(&mut self)

Make the progress bar inherit its width from the parent view. This is the default.

pub fn inherit_height(&mut self)

Make the progress bar inherit its height from the parent view. This is the default.

Trait Implementations

impl<T: View + Send + Sized> View for AsyncProgressView<T>

fn draw(&self, printer: &Printer)

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

fn layout(&mut self, vec: Vec2)

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: Vec2) -> Vec2

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

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

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

fn call_on_any<'a>(&mut self, sel: &Selector, cb: AnyCb<'a>)

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

fn focus_view(&mut self, sel: &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: Vec2) -> Rect

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