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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
use crate::config::CONFIG;
use crate::types::*;
use crate::utils::*;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn spawn_thread_loop<F>(tx: std::sync::mpsc::Sender<ThreadsData>, data: F, delay: f64)
where
F: Fn() -> ThreadsData + Send + 'static,
{
thread::spawn(move || loop {
tx.send(data()).unwrap();
thread::sleep(Duration::from_secs_f64(delay));
});
}
pub fn run(mut blocks: Blocks) {
let (tx, rx) = mpsc::channel();
// loadavrage thread
if CONFIG.loadavg.enabled {
spawn_thread_loop(tx.clone(), load_average::get_load_avg, CONFIG.loadavg.delay);
}
// public ip thread
if CONFIG.pub_ip.enabled {
spawn_thread_loop(tx.clone(), pub_ip::get_pub_ip, CONFIG.pub_ip.delay);
}
// spotify thread
if CONFIG.spotify.enabled {
spawn_thread_loop(tx.clone(), spotify::get_spotify, CONFIG.spotify.delay);
}
// mpd thread
if CONFIG.mpd.enabled {
spawn_thread_loop(tx.clone(), mpd::get_mpd_current, CONFIG.mpd.delay);
}
// volume thread
if CONFIG.volume.enabled {
spawn_thread_loop(tx.clone(), volume::get_volume, CONFIG.volume.delay);
}
// Disk thread
if CONFIG.disk.enabled {
spawn_thread_loop(tx.clone(), disk::get_disk, CONFIG.disk.delay);
}
// Memory thread
if CONFIG.memory.enabled {
spawn_thread_loop(tx.clone(), memory::get_memory, CONFIG.memory.delay);
}
// Weather thread
if CONFIG.weather.enabled {
spawn_thread_loop(tx.clone(), weather::get_weather, CONFIG.weather.delay);
}
// Battery thread
if CONFIG.battery.enabled {
spawn_thread_loop(tx.clone(), battery::get_battery, CONFIG.battery.delay);
}
// Cpu temperature thread
if CONFIG.cpu_temperature.enabled {
spawn_thread_loop(tx.clone(), cpu::get_cpu_temp, CONFIG.cpu_temperature.delay);
}
// Uptime thread
if CONFIG.uptime.enabled {
spawn_thread_loop(tx.clone(), uptime::get_uptime, CONFIG.uptime.delay);
}
// BTC thread
if CONFIG.bitcoins.enabled {
spawn_thread_loop(tx.clone(), bitcoins::get_price, CONFIG.bitcoins.delay);
}
// net speed thread
// get_netspeed will sleep inside the function
if CONFIG.netspeed.enabled {
let net_tx = tx.clone();
thread::spawn(move || loop {
let net_data = netspeed::get_netspeed();
net_tx.send(net_data).unwrap();
});
}
// Time thread
{
spawn_thread_loop(tx, time::get_time, CONFIG.time.delay);
}
//Main
{
// NOTE: order matters to the final format
let mut bar: Vec<String> = vec![String::from(""); 14];
//iterating the values recieved from the threads
for data in rx {
match data {
ThreadsData::Spotify(x) => bar[0] = x,
ThreadsData::Mpd(x) => bar[1] = x,
ThreadsData::Sound(x) => bar[2] = x,
ThreadsData::Weather(x) => bar[3] = x,
ThreadsData::NetSpeed(x) => bar[4] = x,
ThreadsData::BitCoins(x) => bar[5] = x,
ThreadsData::PubIp(x) => bar[6] = x,
ThreadsData::Disk(x) => bar[7] = x,
ThreadsData::Memory(x) => bar[8] = x,
ThreadsData::CpuTemp(x) => bar[9] = x,
ThreadsData::LoadAvg(x) => bar[10] = x,
ThreadsData::Battery(x) => bar[11] = x,
ThreadsData::Uptime(x) => bar[12] = x,
ThreadsData::Time(x) => bar[13] = x,
}
// match ends here
update(&bar, &mut blocks);
}
}
}
fn update(bar: &[String], blocks: &mut Blocks) {
let mut x = String::new();
for i in bar.iter() {
x.push_str(i.as_str());
}
blocks
.root
.set_title(&mut blocks.disp, &x)
.expect("Failed to set title of root");
}
|
