Struct cursive_async_view::AsyncView

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

An AsyncView is a wrapper view that displays a loading screen, 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 cursive::{views::TextView, Cursive};
use cursive_async_view::AsyncView;

let mut siv = Cursive::default();
let async_view = AsyncView::new(&siv, move || {
    std::thread::sleep(std::time::Duration::from_secs(10));
    TextView::new("Yay!\n\nThe content has loaded!")
});

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

The content will be displayed after 10 seconds.

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 for ensuring 30fps during the loading animation. This thread will be stopped by AsyncView 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> AsyncView<T>

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

Create a new AsyncView instance. The cursive reference is only used to control the refresh rate of the terminal when the loading animation is running. 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 loading animation 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 loading animation may consume. By default, the height will be inherited by the parent view.

pub fn with_animation_fn<F>(self, animation_fn: F) -> Self where
    F: Fn(usize, usize, usize) -> AnimationFrame + 'static, 

Set a custom animation function for this view, indicating that the wrapped view is not available yet. See the default_animation function reference for an example on how to create a custom animation function.

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

Set the maximum allowed width in characters, the loading animation may consume.

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

Set the maximum allowed height in characters, the loading animation may consume.

pub fn set_animation_fn<F>(&mut self, animation_fn: F) where
    F: Fn(usize, usize, usize) -> AnimationFrame + 'static, 

Set a custom animation function for this view, indicating that the wrapped view is not available yet. See the default_animation function reference for an example on how to create a custom animation function.

This function may be set at any time. The loading animation can be changed even if the previous loading animation has already started.

The frame_idx of the loading animation is reset to 0 when setting a new animation function

pub fn inherit_width(&mut self)

Make the loading animation inherit its width from the parent view. This is the default.

pub fn inherit_height(&mut self)

Make the loading animation inherit its height from the parent view. This is the default.

Trait Implementations

impl<T: View + Send + Sized> View for AsyncView<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?