1 use std::error;
2 
3 use rand::{distributions::Uniform, prelude::Distribution, rngs::ThreadRng};
4 use ratatui::widgets::ListState;
5 
6 /// Application result type.
7 pub type AppResult<T> = std::result::Result<T, Box<dyn error::Error>>;
8 
9 /// Application.
10 #[derive(Debug)]
11 pub struct App<'a> {
12     /// APP的标题
13     pub title: &'a str,
14     /// Is the application running?
15     pub running: bool,
16 
17     pub enhanced_graphics: bool,
18 
19     /// counter
20     pub counter: u8,
21 
22     pub tabs: TabsState<'a>,
23 
24     pub memory_log_sparkline: Signal<RandomSignal>,
25 
26     logs: Vec<String>,
27     pub stateful_logs: StatefulList<(&'a str, &'a str)>,
28 
29     backend_log_receiver: Option<std::sync::mpsc::Receiver<String>>,
30 }
31 
32 impl<'a> App<'a> {
33     /// Constructs a new instance of [`App`].
new(title: &'a str) -> Self34     pub fn new(title: &'a str) -> Self {
35         let mut rand_signal = RandomSignal::new(0, 100);
36         let sparkline_points = rand_signal.by_ref().take(300).collect();
37         let sparkline = Signal {
38             source: rand_signal,
39             points: sparkline_points,
40             tick_rate: 1,
41         };
42 
43         Self {
44             title,
45             running: true,
46             enhanced_graphics: true,
47             counter: 0,
48             tabs: TabsState::new(vec!["Tab0", "Tab1", "Tab2"]),
49             memory_log_sparkline: sparkline,
50             logs: Vec::new(),
51             stateful_logs: StatefulList::with_items(vec![]),
52             backend_log_receiver: None,
53         }
54     }
55 
set_backend_log_receiver(&mut self, receiver: std::sync::mpsc::Receiver<String>)56     pub fn set_backend_log_receiver(&mut self, receiver: std::sync::mpsc::Receiver<String>) {
57         self.backend_log_receiver = Some(receiver);
58     }
59 
60     /// Handles the tick event of the terminal.
tick(&mut self)61     pub fn tick(&mut self) {
62         self.memory_log_sparkline.on_tick();
63         self.handle_logs_on_tick();
64     }
65 
66     /// 当到达tick时，处理日志
handle_logs_on_tick(&mut self)67     fn handle_logs_on_tick(&mut self) {
68         let logs_to_push = self
69             .backend_log_receiver
70             .as_ref()
71             .map(|rv| rv.try_iter().collect::<Vec<String>>());
72 
73         if let Some(logs) = logs_to_push {
74             for log in logs {
75                 self.push_log(log);
76             }
77         }
78     }
79 
80     /// Set running to false to quit the application.
quit(&mut self)81     pub fn quit(&mut self) {
82         self.running = false;
83     }
84 
increment_counter(&mut self)85     pub fn increment_counter(&mut self) {
86         if let Some(res) = self.counter.checked_add(1) {
87             self.counter = res;
88         }
89     }
90 
decrement_counter(&mut self)91     pub fn decrement_counter(&mut self) {
92         if let Some(res) = self.counter.checked_sub(1) {
93             self.counter = res;
94         }
95     }
96 
push_log(&mut self, log: String)97     pub fn push_log(&mut self, log: String) {
98         self.logs.push(log);
99     }
100 
logs(&self) -> &Vec<String>101     pub fn logs(&self) -> &Vec<String> {
102         &self.logs
103     }
104 }
105 
106 #[derive(Debug)]
107 pub struct TabsState<'a> {
108     pub titles: Vec<&'a str>,
109     pub index: usize,
110 }
111 
112 impl<'a> TabsState<'a> {
new(titles: Vec<&'a str>) -> TabsState113     pub fn new(titles: Vec<&'a str>) -> TabsState {
114         TabsState { titles, index: 0 }
115     }
next(&mut self)116     pub fn next(&mut self) {
117         self.index = (self.index + 1) % self.titles.len();
118     }
119 
previous(&mut self)120     pub fn previous(&mut self) {
121         if self.index > 0 {
122             self.index -= 1;
123         } else {
124             self.index = self.titles.len() - 1;
125         }
126     }
127 }
128 
129 #[derive(Clone, Debug)]
130 pub struct Signal<S: Iterator> {
131     source: S,
132     pub points: Vec<S::Item>,
133     tick_rate: usize,
134 }
135 
136 impl<S> Signal<S>
137 where
138     S: Iterator,
139 {
on_tick(&mut self)140     fn on_tick(&mut self) {
141         for _ in 0..self.tick_rate {
142             self.points.remove(0);
143         }
144         self.points
145             .extend(self.source.by_ref().take(self.tick_rate));
146     }
147 }
148 
149 #[derive(Clone, Debug)]
150 pub struct RandomSignal {
151     distribution: Uniform<u64>,
152     rng: ThreadRng,
153 }
154 
155 impl RandomSignal {
new(lower: u64, upper: u64) -> RandomSignal156     pub fn new(lower: u64, upper: u64) -> RandomSignal {
157         RandomSignal {
158             distribution: Uniform::new(lower, upper),
159             rng: rand::thread_rng(),
160         }
161     }
162 }
163 
164 impl Iterator for RandomSignal {
165     type Item = u64;
next(&mut self) -> Option<u64>166     fn next(&mut self) -> Option<u64> {
167         Some(self.distribution.sample(&mut self.rng))
168     }
169 }
170 
171 #[derive(Debug)]
172 pub struct StatefulList<T> {
173     pub state: ListState,
174     pub items: Vec<T>,
175 }
176 
177 impl<T> StatefulList<T> {
with_items(items: Vec<T>) -> StatefulList<T>178     pub fn with_items(items: Vec<T>) -> StatefulList<T> {
179         StatefulList {
180             state: ListState::default(),
181             items,
182         }
183     }
184 
next(&mut self)185     pub fn next(&mut self) {
186         let i = match self.state.selected() {
187             Some(i) => {
188                 if i >= self.items.len() - 1 {
189                     0
190                 } else {
191                     i + 1
192                 }
193             }
194             None => 0,
195         };
196         self.state.select(Some(i));
197     }
198 
previous(&mut self)199     pub fn previous(&mut self) {
200         let i = match self.state.selected() {
201             Some(i) => {
202                 if i == 0 {
203                     self.items.len() - 1
204                 } else {
205                     i - 1
206                 }
207             }
208             None => 0,
209         };
210         self.state.select(Some(i));
211     }
212 }
213