Struct AsyncProgressView

pub struct AsyncProgressView<T: View> { /* private fields */ }

An AsyncProgressView is a wrapper view that displays a progress bar, until the child view is successfully created or an error in the creation progress occured.

To achieve this a poll_ready callback is passed in the creation of AsyncProgressView which returns an AsyncProgressState that can indicate that the process is still Pending (this contains a float between 0 and 1, communicating the progress, this information is displayed in the bar), has been successfully completed Available containing the view to be displayed, or if the creation has thrown an Error containing a message to be shown to the user.

The poll_ready callback should only check for data to be available and create the child view when the data got available. It must never block until the data is available or do heavy calculations! Otherwise cursive cannot proceed displaying and your application will have a blocking loading process!

If you have troubles and need some more in-depth examples have a look at the provided examples in the project.

Example usage

use cursive::{views::TextView, Cursive, CursiveExt};
use cursive_async_view::{AsyncProgressView, AsyncProgressState};

let mut siv = Cursive::default();
let start = std::time::Instant::now();
let async_view = AsyncProgressView::new(&mut siv, move || {
    if start.elapsed().as_secs() < 3 {
        AsyncProgressState::Pending(start.elapsed().as_secs() as f32 / 3f32)
    } else {
        AsyncProgressState::Available(TextView::new("Finally it loaded!"))
    }
});

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

Implementations

impl<T: View> AsyncProgressView<T>

pub fn new<F>(siv: &mut Cursive, creator: F) -> Self

where F: FnMut() -> AsyncProgressState<T> + '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, usize, usize) -> AnimationProgressFrame + Send + Sync + '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 with_error_fn<F>(self, error_fn: F) -> Self

where F: Fn(String, usize, usize, f32, usize, usize) -> AnimationProgressFrame + Send + Sync + 'static,

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, usize, usize) -> AnimationProgressFrame + Send + Sync + '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 set_error_fn<F>(&mut self, error_fn: F)

where F: Fn(String, usize, usize, f32, usize, usize) -> AnimationProgressFrame + Send + Sync + 'static,

Set a custom error function for this view, indicating that an error occured during the wrapped view creation. See the default_progress_error function reference for an example on how to create a custom error 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> Drop for AsyncProgressView<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: View + 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<EventResult, ViewNotFound>

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

fn take_focus(&mut self, source: Direction) -> Result<EventResult, CannotFocus>

Attempt to give this view the focus.

fn important_area(&self, view_size: Vec2) -> Rect

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

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

Returns the type of this view.