Crate cursive_async_view
source · [−]Expand description
This project provides a wrapper view with a loading screen for gyscos/cursive views. The loading screen will disappear once the wrapped view is fully loaded. This is useful for displaying views which need data that takes long to construct or depend on e.g. the network.
Asynchronous view loading without progress information
If you can’t tell the progress during a long taking preparation of data for
a view, you may wrap the creation of this view in an AsyncView
. This will
display a loading animation until the inner view is ready to be drawn.
use std::time::{Instant, Duration};
use cursive::{views::TextView, Cursive, CursiveExt};
use cursive_async_view::{AsyncView, AsyncState};
let mut siv = Cursive::default();
let instant = Instant::now();
let async_view = AsyncView::new(&mut siv, move || {
if instant.elapsed() > Duration::from_secs(10) {
AsyncState::Available(
TextView::new("Yay!\n\nThe content has loaded!")
)
} else {
AsyncState::Pending
}
});
siv.add_layer(async_view);
// siv.run();
Refer to the AsyncView
struct level documentation for a detailed
explanation or to the simple
example located in the source code
repository.
If you need to do a blocking operation during the construction of the child
view, you may have a look at the alternate new_with_bg_task
constructor.
use std::thread;
use std::time::Duration;
use cursive::views::TextView;
use cursive::{Cursive, CursiveExt};
use cursive_async_view::AsyncView;
let mut siv = Cursive::default();
let async_view = AsyncView::new_with_bg_creator(&mut siv, move || {
// this function is executed in a background thread, so we can block
// here as long as we like
thread::sleep(Duration::from_secs(10));
// enough blocking, let's show the content
Ok("Yeet! It worked 🖖")
}, TextView::new); // create a text view from the string
siv.add_layer(async_view);
// siv.run();
Refer to the AsyncView
struct level documentation for a detailed
explanation or to the bg_task
example located in the source code
repository.
Asynchronous view loading with a progress bar
If you have information about the progress a long taking view creation has made,
you can wrap the creation in an AsyncProgressView
. This will display a progress
bar until the inner view is ready to be drawn.
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();
Structs
This struct represents the content of a single loading or error animation frame,
produced by a animation function of the AsyncView
. Read the documentation
of the default_animation
or default_error
to see how to implement your own
animation functions.
This struct contains the content of a single frame for AsyncProgressView
with some metadata about the current frame.
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.
An AsyncView
is a wrapper view that displays a loading screen, until the
child view is ready to be created. The view can be used in two different
ways.
Enums
An enum to be returned by the poll_ready
callback, with additional information about the creation progress.
This enum is used in the ready_poll callback to tell the async view whether the view is already available, an error occured, or is still pending.
Functions
The default loading animation for a AsyncView
.
The default error animation for a AsyncView
.
The default progress animation for a AsyncProgressView
.
The default error animation for a AsyncProgressView
.