1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
//! This project provides a wrapper view with a loading screen for
//! [gyscos/cursive](https://github.com/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();
//! ```
pub use ;
pub use ;
doctest!;