824 lines
30 KiB
Rust
824 lines
30 KiB
Rust
#![warn(rust_2018_idioms)]
|
|
|
|
#[allow(unused_imports)]
|
|
#[macro_use]
|
|
extern crate log;
|
|
|
|
use std::{
|
|
boxed::Box,
|
|
io::{stdout, Write},
|
|
panic::{self, PanicInfo},
|
|
sync::mpsc,
|
|
thread,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
use clap::*;
|
|
|
|
use crossterm::{
|
|
event::{
|
|
poll, read, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent,
|
|
KeyModifiers, MouseEvent,
|
|
},
|
|
execute,
|
|
style::Print,
|
|
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
use tui::{backend::CrosstermBackend, Terminal};
|
|
|
|
use app::{
|
|
data_harvester::{self, processes::ProcessSorting},
|
|
layout_manager::{UsedWidgets, WidgetDirection},
|
|
App,
|
|
};
|
|
use constants::*;
|
|
use data_conversion::*;
|
|
use options::*;
|
|
use utils::error;
|
|
|
|
pub mod app;
|
|
|
|
mod utils {
|
|
pub mod error;
|
|
pub mod gen_util;
|
|
pub mod logging;
|
|
}
|
|
|
|
mod canvas;
|
|
mod constants;
|
|
mod data_conversion;
|
|
|
|
pub mod options;
|
|
|
|
enum BottomEvent<I, J> {
|
|
KeyInput(I),
|
|
MouseInput(J),
|
|
Update(Box<data_harvester::Data>),
|
|
Clean,
|
|
}
|
|
|
|
enum ResetEvent {
|
|
Reset,
|
|
}
|
|
|
|
fn get_matches() -> clap::ArgMatches<'static> {
|
|
clap_app!(app =>
|
|
(name: crate_name!())
|
|
(version: crate_version!())
|
|
(author: crate_authors!())
|
|
(about: crate_description!())
|
|
(@arg HIDE_AVG_CPU: -a --hide_avg_cpu "Hides the average CPU usage.")
|
|
(@arg DOT_MARKER: -m --dot_marker "Use a dot marker instead of the default braille marker.")
|
|
(@group TEMPERATURE_TYPE =>
|
|
(@arg KELVIN : -k --kelvin "Sets the temperature type to Kelvin.")
|
|
(@arg FAHRENHEIT : -f --fahrenheit "Sets the temperature type to Fahrenheit.")
|
|
(@arg CELSIUS : -c --celsius "Sets the temperature type to Celsius. This is the default option.")
|
|
)
|
|
(@arg RATE_MILLIS: -r --rate +takes_value "Sets a refresh rate in milliseconds; the minimum is 250ms, defaults to 1000ms. Smaller values may take more resources.")
|
|
(@arg LEFT_LEGEND: -l --left_legend "Puts external chart legends on the left side rather than the default right side.")
|
|
(@arg USE_CURR_USAGE: -u --current_usage "Within Linux, sets a process' CPU usage to be based on the total current CPU usage, rather than assuming 100% usage.")
|
|
(@arg CONFIG_LOCATION: -C --config +takes_value "Sets the location of the config file. Expects a config file in the TOML format. If it doesn't exist, one is created.")
|
|
(@arg BASIC_MODE: -b --basic "Hides graphs and uses a more basic look")
|
|
(@arg GROUP_PROCESSES: -g --group "Groups processes with the same name together on launch.")
|
|
(@arg CASE_SENSITIVE: -S --case_sensitive "Match case when searching by default.")
|
|
(@arg WHOLE_WORD: -W --whole_word "Match whole word when searching by default.")
|
|
(@arg REGEX_DEFAULT: -R --regex "Use regex in searching by default.")
|
|
(@arg DEFAULT_TIME_VALUE: -t --default_time_value +takes_value "Default time value for graphs in milliseconds; minimum is 30s, defaults to 60s.")
|
|
(@arg TIME_DELTA: -d --time_delta +takes_value "The amount changed upon zooming in/out in milliseconds; minimum is 1s, defaults to 15s.")
|
|
(@arg HIDE_TIME: --hide_time "Completely hide the time scaling")
|
|
(@arg AUTOHIDE_TIME: --autohide_time "Automatically hide the time scaling in graphs after being shown for a brief moment when zoomed in/out. If time is disabled via --hide_time then this will have no effect.")
|
|
(@arg DEFAULT_WIDGET_TYPE: --default_widget_type +takes_value "The default widget type to select by default.")
|
|
(@arg DEFAULT_WIDGET_COUNT: --default_widget_count +takes_value "Which number of the selected widget type to select, from left to right, top to bottom. Defaults to 1.")
|
|
(@arg USE_OLD_NETWORK_LEGEND: --use_old_network_legend "Use the older (pre-0.4) network widget legend.")
|
|
(@arg HIDE_TABLE_GAP: --hide_table_gap "Hides the spacing between the table headers and entries.")
|
|
(@arg BATTERY: --battery "Shows the battery widget in default or basic mode. No effect on custom layouts.")
|
|
)
|
|
.get_matches()
|
|
}
|
|
|
|
fn main() -> error::Result<()> {
|
|
#[cfg(debug_assertions)]
|
|
{
|
|
utils::logging::init_logger()?;
|
|
}
|
|
let matches = get_matches();
|
|
|
|
let config: Config = create_config(matches.value_of("CONFIG_LOCATION"))?;
|
|
|
|
// Get widget layout separately
|
|
let (widget_layout, default_widget_id) = get_widget_layout(&matches, &config)?;
|
|
|
|
// Create "app" struct, which will control most of the program and store settings/state
|
|
let mut app = build_app(&matches, &config, &widget_layout, default_widget_id)?;
|
|
|
|
// Create painter and set colours.
|
|
let mut painter = canvas::Painter::init(widget_layout, app.app_config_fields.table_gap);
|
|
generate_config_colours(&config, &mut painter)?;
|
|
painter.colours.generate_remaining_cpu_colours();
|
|
painter.complete_painter_init();
|
|
|
|
// Set up input handling
|
|
let (sender, receiver) = mpsc::channel();
|
|
create_input_thread(sender.clone());
|
|
|
|
// Cleaning loop
|
|
{
|
|
let cleaning_sender = sender.clone();
|
|
thread::spawn(move || loop {
|
|
thread::sleep(Duration::from_millis(
|
|
constants::STALE_MAX_MILLISECONDS + 5000,
|
|
));
|
|
if cleaning_sender.send(BottomEvent::Clean).is_err() {
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Event loop
|
|
let (reset_sender, reset_receiver) = mpsc::channel();
|
|
create_event_thread(
|
|
sender,
|
|
reset_receiver,
|
|
app.app_config_fields.use_current_cpu_total,
|
|
app.app_config_fields.update_rate_in_milliseconds,
|
|
app.app_config_fields.temperature_type.clone(),
|
|
app.app_config_fields.show_average_cpu,
|
|
app.used_widgets.clone(),
|
|
);
|
|
|
|
// Set up up tui and crossterm
|
|
let mut stdout_val = stdout();
|
|
execute!(stdout_val, EnterAlternateScreen, EnableMouseCapture)?;
|
|
enable_raw_mode()?;
|
|
|
|
let mut terminal = Terminal::new(CrosstermBackend::new(stdout_val))?;
|
|
terminal.hide_cursor()?;
|
|
|
|
// Set panic hook
|
|
panic::set_hook(Box::new(|info| panic_hook(info)));
|
|
|
|
loop {
|
|
if let Ok(recv) = receiver.recv_timeout(Duration::from_millis(TICK_RATE_IN_MILLISECONDS)) {
|
|
match recv {
|
|
BottomEvent::KeyInput(event) => {
|
|
if handle_key_event_or_break(event, &mut app, &reset_sender) {
|
|
break;
|
|
}
|
|
handle_force_redraws(&mut app);
|
|
}
|
|
BottomEvent::MouseInput(event) => {
|
|
handle_mouse_event(event, &mut app);
|
|
handle_force_redraws(&mut app);
|
|
}
|
|
BottomEvent::Update(data) => {
|
|
app.data_collection.eat_data(&data);
|
|
|
|
if !app.is_frozen {
|
|
// Convert all data into tui-compliant components
|
|
|
|
// Network
|
|
if app.used_widgets.use_net {
|
|
let network_data = convert_network_data_points(
|
|
&app.data_collection,
|
|
false,
|
|
app.app_config_fields.use_basic_mode
|
|
|| app.app_config_fields.use_old_network_legend,
|
|
);
|
|
app.canvas_data.network_data_rx = network_data.rx;
|
|
app.canvas_data.network_data_tx = network_data.tx;
|
|
app.canvas_data.rx_display = network_data.rx_display;
|
|
app.canvas_data.tx_display = network_data.tx_display;
|
|
if let Some(total_rx_display) = network_data.total_rx_display {
|
|
app.canvas_data.total_rx_display = total_rx_display;
|
|
}
|
|
if let Some(total_tx_display) = network_data.total_tx_display {
|
|
app.canvas_data.total_tx_display = total_tx_display;
|
|
}
|
|
}
|
|
|
|
// Disk
|
|
if app.used_widgets.use_disk {
|
|
app.canvas_data.disk_data = convert_disk_row(&app.data_collection);
|
|
}
|
|
|
|
// Temperatures
|
|
if app.used_widgets.use_temp {
|
|
app.canvas_data.temp_sensor_data = convert_temp_row(&app);
|
|
}
|
|
|
|
// Memory
|
|
if app.used_widgets.use_mem {
|
|
app.canvas_data.mem_data =
|
|
convert_mem_data_points(&app.data_collection, false);
|
|
app.canvas_data.swap_data =
|
|
convert_swap_data_points(&app.data_collection, false);
|
|
let memory_and_swap_labels = convert_mem_labels(&app.data_collection);
|
|
app.canvas_data.mem_label = memory_and_swap_labels.0;
|
|
app.canvas_data.swap_label = memory_and_swap_labels.1;
|
|
}
|
|
|
|
if app.used_widgets.use_cpu {
|
|
// CPU
|
|
app.canvas_data.cpu_data =
|
|
convert_cpu_data_points(&app.data_collection, false);
|
|
}
|
|
|
|
// Processes
|
|
if app.used_widgets.use_proc {
|
|
update_all_process_lists(&mut app);
|
|
}
|
|
|
|
// Battery
|
|
if app.used_widgets.use_battery {
|
|
app.canvas_data.battery_data =
|
|
convert_battery_harvest(&app.data_collection);
|
|
}
|
|
}
|
|
}
|
|
BottomEvent::Clean => {
|
|
app.data_collection
|
|
.clean_data(constants::STALE_MAX_MILLISECONDS);
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: [OPT] Should not draw if no change (ie: scroll max)
|
|
try_drawing(&mut terminal, &mut app, &mut painter)?;
|
|
}
|
|
|
|
cleanup_terminal(&mut terminal)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_mouse_event(event: MouseEvent, app: &mut App) {
|
|
match event {
|
|
MouseEvent::ScrollUp(_x, _y, _modifiers) => app.handle_scroll_up(),
|
|
MouseEvent::ScrollDown(_x, _y, _modifiers) => app.handle_scroll_down(),
|
|
_ => {}
|
|
};
|
|
}
|
|
|
|
fn handle_key_event_or_break(
|
|
event: KeyEvent, app: &mut App, reset_sender: &std::sync::mpsc::Sender<ResetEvent>,
|
|
) -> bool {
|
|
// debug!("KeyEvent: {:?}", event);
|
|
|
|
// TODO: [PASTE] Note that this does NOT support some emojis like flags. This is due to us
|
|
// catching PER CHARACTER right now WITH A forced throttle! This means multi-char will not work.
|
|
// We can solve this (when we do paste probably) while keeping the throttle (mainly meant for movement)
|
|
// by throttling after *bulk+singular* actions, not just singular ones.
|
|
|
|
if event.modifiers.is_empty() {
|
|
// Required catch for searching - otherwise you couldn't search with q.
|
|
if event.code == KeyCode::Char('q') && !app.is_in_search_widget() {
|
|
return true;
|
|
}
|
|
match event.code {
|
|
KeyCode::End => app.skip_to_last(),
|
|
KeyCode::Home => app.skip_to_first(),
|
|
KeyCode::Up => app.on_up_key(),
|
|
KeyCode::Down => app.on_down_key(),
|
|
KeyCode::Left => app.on_left_key(),
|
|
KeyCode::Right => app.on_right_key(),
|
|
KeyCode::Char(caught_char) => app.on_char_key(caught_char),
|
|
KeyCode::Esc => app.on_esc(),
|
|
KeyCode::Enter => app.on_enter(),
|
|
KeyCode::Tab => app.on_tab(),
|
|
KeyCode::Backspace => app.on_backspace(),
|
|
KeyCode::Delete => app.on_delete(),
|
|
KeyCode::F(1) => app.toggle_ignore_case(),
|
|
KeyCode::F(2) => app.toggle_search_whole_word(),
|
|
KeyCode::F(3) => app.toggle_search_regex(),
|
|
KeyCode::F(6) => app.toggle_sort(),
|
|
_ => {}
|
|
}
|
|
} else {
|
|
// Otherwise, track the modifier as well...
|
|
if let KeyModifiers::ALT = event.modifiers {
|
|
match event.code {
|
|
KeyCode::Char('c') | KeyCode::Char('C') => app.toggle_ignore_case(),
|
|
KeyCode::Char('w') | KeyCode::Char('W') => app.toggle_search_whole_word(),
|
|
KeyCode::Char('r') | KeyCode::Char('R') => app.toggle_search_regex(),
|
|
KeyCode::Char('h') => app.on_left_key(),
|
|
KeyCode::Char('l') => app.on_right_key(),
|
|
_ => {}
|
|
}
|
|
} else if let KeyModifiers::CONTROL = event.modifiers {
|
|
if event.code == KeyCode::Char('c') {
|
|
return true;
|
|
}
|
|
|
|
match event.code {
|
|
KeyCode::Char('f') => app.on_slash(),
|
|
KeyCode::Left => app.move_widget_selection(&WidgetDirection::Left),
|
|
KeyCode::Right => app.move_widget_selection(&WidgetDirection::Right),
|
|
KeyCode::Up => app.move_widget_selection(&WidgetDirection::Up),
|
|
KeyCode::Down => app.move_widget_selection(&WidgetDirection::Down),
|
|
KeyCode::Char('r') => {
|
|
if reset_sender.send(ResetEvent::Reset).is_ok() {
|
|
app.reset();
|
|
}
|
|
}
|
|
KeyCode::Char('a') => app.skip_cursor_beginning(),
|
|
KeyCode::Char('e') => app.skip_cursor_end(),
|
|
KeyCode::Char('u') => app.clear_search(),
|
|
// KeyCode::Char('j') => {}, // Move down
|
|
// KeyCode::Char('k') => {}, // Move up
|
|
// KeyCode::Char('h') => {}, // Move right
|
|
// KeyCode::Char('l') => {}, // Move left
|
|
// Can't do now, CTRL+BACKSPACE doesn't work and graphemes
|
|
// are hard to iter while truncating last (eloquently).
|
|
// KeyCode::Backspace => app.skip_word_backspace(),
|
|
_ => {}
|
|
}
|
|
} else if let KeyModifiers::SHIFT = event.modifiers {
|
|
match event.code {
|
|
KeyCode::Left => app.move_widget_selection(&WidgetDirection::Left),
|
|
KeyCode::Right => app.move_widget_selection(&WidgetDirection::Right),
|
|
KeyCode::Up => app.move_widget_selection(&WidgetDirection::Up),
|
|
KeyCode::Down => app.move_widget_selection(&WidgetDirection::Down),
|
|
KeyCode::Char(caught_char) => app.on_char_key(caught_char),
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
fn create_config(flag_config_location: Option<&str>) -> error::Result<Config> {
|
|
use std::{ffi::OsString, fs};
|
|
let config_path = if let Some(conf_loc) = flag_config_location {
|
|
Some(OsString::from(conf_loc))
|
|
} else if cfg!(target_os = "windows") {
|
|
if let Some(home_path) = dirs::config_dir() {
|
|
let mut path = home_path;
|
|
path.push(DEFAULT_CONFIG_FILE_PATH);
|
|
Some(path.into_os_string())
|
|
} else {
|
|
None
|
|
}
|
|
} else if let Some(home_path) = dirs::home_dir() {
|
|
let mut path = home_path;
|
|
path.push(".config/");
|
|
path.push(DEFAULT_CONFIG_FILE_PATH);
|
|
if path.exists() {
|
|
// If it already exists, use the old one.
|
|
Some(path.into_os_string())
|
|
} else {
|
|
// If it does not, use the new one!
|
|
if let Some(config_path) = dirs::config_dir() {
|
|
let mut path = config_path;
|
|
path.push(DEFAULT_CONFIG_FILE_PATH);
|
|
Some(path.into_os_string())
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
if let Some(config_path) = config_path {
|
|
let path = std::path::Path::new(&config_path);
|
|
|
|
if let Ok(config_string) = fs::read_to_string(path) {
|
|
Ok(toml::from_str(config_string.as_str())?)
|
|
} else {
|
|
if let Some(parent_path) = path.parent() {
|
|
fs::create_dir_all(parent_path)?;
|
|
}
|
|
fs::File::create(path)?.write_all(DEFAULT_CONFIG_CONTENT.as_bytes())?;
|
|
Ok(toml::from_str(DEFAULT_CONFIG_CONTENT)?)
|
|
}
|
|
} else {
|
|
// Don't write otherwise...
|
|
Ok(toml::from_str(DEFAULT_CONFIG_CONTENT)?)
|
|
}
|
|
}
|
|
|
|
fn try_drawing(
|
|
terminal: &mut tui::terminal::Terminal<tui::backend::CrosstermBackend<std::io::Stdout>>,
|
|
app: &mut App, painter: &mut canvas::Painter,
|
|
) -> error::Result<()> {
|
|
if let Err(err) = painter.draw_data(terminal, app) {
|
|
cleanup_terminal(terminal)?;
|
|
return Err(err);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn cleanup_terminal(
|
|
terminal: &mut tui::terminal::Terminal<tui::backend::CrosstermBackend<std::io::Stdout>>,
|
|
) -> error::Result<()> {
|
|
disable_raw_mode()?;
|
|
execute!(
|
|
terminal.backend_mut(),
|
|
DisableMouseCapture,
|
|
LeaveAlternateScreen
|
|
)?;
|
|
terminal.show_cursor()?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn generate_config_colours(config: &Config, painter: &mut canvas::Painter) -> error::Result<()> {
|
|
if let Some(colours) = &config.colors {
|
|
if let Some(border_color) = &colours.border_color {
|
|
painter.colours.set_border_colour(border_color)?;
|
|
}
|
|
|
|
if let Some(highlighted_border_color) = &colours.highlighted_border_color {
|
|
painter
|
|
.colours
|
|
.set_highlighted_border_colour(highlighted_border_color)?;
|
|
}
|
|
|
|
if let Some(text_color) = &colours.text_color {
|
|
painter.colours.set_text_colour(text_color)?;
|
|
}
|
|
|
|
if let Some(avg_cpu_color) = &colours.avg_cpu_color {
|
|
painter.colours.set_avg_cpu_colour(avg_cpu_color)?;
|
|
}
|
|
|
|
if let Some(all_cpu_color) = &colours.all_cpu_color {
|
|
painter.colours.set_all_cpu_colour(all_cpu_color)?;
|
|
}
|
|
|
|
if let Some(cpu_core_colors) = &colours.cpu_core_colors {
|
|
painter.colours.set_cpu_colours(cpu_core_colors)?;
|
|
}
|
|
|
|
if let Some(ram_color) = &colours.ram_color {
|
|
painter.colours.set_ram_colour(ram_color)?;
|
|
}
|
|
|
|
if let Some(swap_color) = &colours.swap_color {
|
|
painter.colours.set_swap_colour(swap_color)?;
|
|
}
|
|
|
|
if let Some(rx_color) = &colours.rx_color {
|
|
painter.colours.set_rx_colour(rx_color)?;
|
|
}
|
|
|
|
if let Some(tx_color) = &colours.tx_color {
|
|
painter.colours.set_tx_colour(tx_color)?;
|
|
}
|
|
|
|
// if let Some(rx_total_color) = &colours.rx_total_color {
|
|
// painter.colours.set_rx_total_colour(rx_total_color)?;
|
|
// }
|
|
|
|
// if let Some(tx_total_color) = &colours.tx_total_color {
|
|
// painter.colours.set_tx_total_colour(tx_total_color)?;
|
|
// }
|
|
|
|
if let Some(table_header_color) = &colours.table_header_color {
|
|
painter
|
|
.colours
|
|
.set_table_header_colour(table_header_color)?;
|
|
}
|
|
|
|
if let Some(scroll_entry_text_color) = &colours.selected_text_color {
|
|
painter
|
|
.colours
|
|
.set_scroll_entry_text_color(scroll_entry_text_color)?;
|
|
}
|
|
|
|
if let Some(scroll_entry_bg_color) = &colours.selected_bg_color {
|
|
painter
|
|
.colours
|
|
.set_scroll_entry_bg_color(scroll_entry_bg_color)?;
|
|
}
|
|
|
|
if let Some(widget_title_color) = &colours.widget_title_color {
|
|
painter
|
|
.colours
|
|
.set_widget_title_colour(widget_title_color)?;
|
|
}
|
|
|
|
if let Some(graph_color) = &colours.graph_color {
|
|
painter.colours.set_graph_colour(graph_color)?;
|
|
}
|
|
|
|
if let Some(battery_colors) = &colours.battery_colors {
|
|
painter.colours.set_battery_colours(battery_colors)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Based on https://github.com/Rigellute/spotify-tui/blob/master/src/main.rs
|
|
fn panic_hook(panic_info: &PanicInfo<'_>) {
|
|
let mut stdout = stdout();
|
|
|
|
let msg = match panic_info.payload().downcast_ref::<&'static str>() {
|
|
Some(s) => *s,
|
|
None => match panic_info.payload().downcast_ref::<String>() {
|
|
Some(s) => &s[..],
|
|
None => "Box<Any>",
|
|
},
|
|
};
|
|
|
|
let stacktrace: String = format!("{:?}", backtrace::Backtrace::new());
|
|
|
|
disable_raw_mode().unwrap();
|
|
execute!(stdout, LeaveAlternateScreen, DisableMouseCapture).unwrap();
|
|
|
|
// Print stack trace. Must be done after!
|
|
execute!(
|
|
stdout,
|
|
Print(format!(
|
|
"thread '<unnamed>' panicked at '{}', {}\n\r{}",
|
|
msg,
|
|
panic_info.location().unwrap(),
|
|
stacktrace
|
|
)),
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
fn handle_force_redraws(app: &mut App) {
|
|
// Currently we use an Option... because we might want to future-proof this
|
|
// if we eventually get widget-specific redrawing!
|
|
if app.proc_state.force_update_all {
|
|
update_all_process_lists(app);
|
|
app.proc_state.force_update_all = false;
|
|
} else if let Some(widget_id) = app.proc_state.force_update {
|
|
update_final_process_list(app, widget_id);
|
|
app.proc_state.force_update = None;
|
|
}
|
|
|
|
if app.cpu_state.force_update.is_some() {
|
|
app.canvas_data.cpu_data = convert_cpu_data_points(&app.data_collection, app.is_frozen);
|
|
app.cpu_state.force_update = None;
|
|
}
|
|
|
|
if app.mem_state.force_update.is_some() {
|
|
app.canvas_data.mem_data = convert_mem_data_points(&app.data_collection, app.is_frozen);
|
|
app.canvas_data.swap_data = convert_swap_data_points(&app.data_collection, app.is_frozen);
|
|
app.mem_state.force_update = None;
|
|
}
|
|
|
|
if app.net_state.force_update.is_some() {
|
|
let (rx, tx) = get_rx_tx_data_points(&app.data_collection, app.is_frozen);
|
|
app.canvas_data.network_data_rx = rx;
|
|
app.canvas_data.network_data_tx = tx;
|
|
app.net_state.force_update = None;
|
|
}
|
|
}
|
|
|
|
fn update_all_process_lists(app: &mut App) {
|
|
let widget_ids = app
|
|
.proc_state
|
|
.widget_states
|
|
.keys()
|
|
.cloned()
|
|
.collect::<Vec<_>>();
|
|
|
|
widget_ids.into_iter().for_each(|widget_id| {
|
|
update_final_process_list(app, widget_id);
|
|
});
|
|
}
|
|
|
|
fn update_final_process_list(app: &mut App, widget_id: u64) {
|
|
let is_invalid_or_blank = match app.proc_state.widget_states.get(&widget_id) {
|
|
Some(process_state) => process_state
|
|
.process_search_state
|
|
.search_state
|
|
.is_invalid_or_blank_search(),
|
|
None => false,
|
|
};
|
|
let is_grouped = app.is_grouped(widget_id);
|
|
|
|
if let Some(proc_widget_state) = app.proc_state.get_mut_widget_state(widget_id) {
|
|
app.canvas_data.process_data = convert_process_data(
|
|
&app.data_collection,
|
|
if is_grouped {
|
|
ProcessGroupingType::Grouped
|
|
} else {
|
|
ProcessGroupingType::Ungrouped
|
|
},
|
|
if proc_widget_state.is_using_command {
|
|
ProcessNamingType::Path
|
|
} else {
|
|
ProcessNamingType::Name
|
|
},
|
|
);
|
|
}
|
|
|
|
let process_filter = app.get_process_filter(widget_id);
|
|
let filtered_process_data: Vec<ConvertedProcessData> = app
|
|
.canvas_data
|
|
.process_data
|
|
.iter()
|
|
.filter(|process| {
|
|
if !is_invalid_or_blank {
|
|
if let Some(process_filter) = process_filter {
|
|
process_filter.check(&process)
|
|
} else {
|
|
true
|
|
}
|
|
} else {
|
|
true
|
|
}
|
|
})
|
|
.cloned()
|
|
.collect::<Vec<_>>();
|
|
|
|
// Quick fix for tab updating the table headers
|
|
if let Some(proc_widget_state) = app.proc_state.get_mut_widget_state(widget_id) {
|
|
if let data_harvester::processes::ProcessSorting::Pid =
|
|
proc_widget_state.process_sorting_type
|
|
{
|
|
if proc_widget_state.is_grouped {
|
|
proc_widget_state.process_sorting_type =
|
|
data_harvester::processes::ProcessSorting::CpuPercent; // Go back to default, negate PID for group
|
|
proc_widget_state.process_sorting_reverse = true;
|
|
}
|
|
}
|
|
|
|
let mut resulting_processes = filtered_process_data;
|
|
sort_process_data(&mut resulting_processes, proc_widget_state);
|
|
|
|
if proc_widget_state.scroll_state.current_scroll_position >= resulting_processes.len() {
|
|
proc_widget_state.scroll_state.current_scroll_position =
|
|
resulting_processes.len().saturating_sub(1);
|
|
proc_widget_state.scroll_state.previous_scroll_position = 0;
|
|
proc_widget_state.scroll_state.scroll_direction = app::ScrollDirection::Down;
|
|
}
|
|
|
|
app.canvas_data
|
|
.finalized_process_data_map
|
|
.insert(widget_id, resulting_processes);
|
|
}
|
|
}
|
|
|
|
fn sort_process_data(
|
|
to_sort_vec: &mut Vec<ConvertedProcessData>, proc_widget_state: &app::ProcWidgetState,
|
|
) {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(&a.name.to_lowercase(), &b.name.to_lowercase(), false)
|
|
});
|
|
|
|
match proc_widget_state.process_sorting_type {
|
|
ProcessSorting::CpuPercent => {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.cpu_usage,
|
|
b.cpu_usage,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
ProcessSorting::Mem => {
|
|
// TODO: Do when I do mem values in processes
|
|
}
|
|
ProcessSorting::MemPercent => {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.mem_usage,
|
|
b.mem_usage,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
ProcessSorting::ProcessName | ProcessSorting::Command => {
|
|
// Don't repeat if false... it sorts by name by default anyways.
|
|
if proc_widget_state.process_sorting_reverse {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
&a.name.to_lowercase(),
|
|
&b.name.to_lowercase(),
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
})
|
|
}
|
|
}
|
|
ProcessSorting::Pid => {
|
|
if !proc_widget_state.is_grouped {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.pid,
|
|
b.pid,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
}
|
|
ProcessSorting::ReadPerSecond => {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.rps_f64,
|
|
b.rps_f64,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
ProcessSorting::WritePerSecond => {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.wps_f64,
|
|
b.wps_f64,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
ProcessSorting::TotalRead => {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.tr_f64,
|
|
b.tr_f64,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
ProcessSorting::TotalWrite => {
|
|
to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
a.tw_f64,
|
|
b.tw_f64,
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
});
|
|
}
|
|
ProcessSorting::State => to_sort_vec.sort_by(|a, b| {
|
|
utils::gen_util::get_ordering(
|
|
&a.process_state.to_lowercase(),
|
|
&b.process_state.to_lowercase(),
|
|
proc_widget_state.process_sorting_reverse,
|
|
)
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn create_input_thread(
|
|
sender: std::sync::mpsc::Sender<
|
|
BottomEvent<crossterm::event::KeyEvent, crossterm::event::MouseEvent>,
|
|
>,
|
|
) {
|
|
thread::spawn(move || {
|
|
let mut mouse_timer = Instant::now();
|
|
let mut keyboard_timer = Instant::now();
|
|
|
|
loop {
|
|
if poll(Duration::from_millis(20)).is_ok() {
|
|
if let Ok(event) = read() {
|
|
if let Event::Key(key) = event {
|
|
if Instant::now().duration_since(keyboard_timer).as_millis() >= 20 {
|
|
if sender.send(BottomEvent::KeyInput(key)).is_err() {
|
|
return;
|
|
}
|
|
keyboard_timer = Instant::now();
|
|
}
|
|
} else if let Event::Mouse(mouse) = event {
|
|
if Instant::now().duration_since(mouse_timer).as_millis() >= 20 {
|
|
if sender.send(BottomEvent::MouseInput(mouse)).is_err() {
|
|
return;
|
|
}
|
|
mouse_timer = Instant::now();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
fn create_event_thread(
|
|
sender: std::sync::mpsc::Sender<
|
|
BottomEvent<crossterm::event::KeyEvent, crossterm::event::MouseEvent>,
|
|
>,
|
|
reset_receiver: std::sync::mpsc::Receiver<ResetEvent>, use_current_cpu_total: bool,
|
|
update_rate_in_milliseconds: u64, temp_type: data_harvester::temperature::TemperatureType,
|
|
show_average_cpu: bool, used_widget_set: UsedWidgets,
|
|
) {
|
|
thread::spawn(move || {
|
|
let mut data_state = data_harvester::DataCollector::default();
|
|
data_state.set_collected_data(used_widget_set);
|
|
data_state.set_temperature_type(temp_type);
|
|
data_state.set_use_current_cpu_total(use_current_cpu_total);
|
|
data_state.set_show_average_cpu(show_average_cpu);
|
|
data_state.init();
|
|
loop {
|
|
if let Ok(message) = reset_receiver.try_recv() {
|
|
match message {
|
|
ResetEvent::Reset => {
|
|
data_state.data.first_run_cleanup();
|
|
}
|
|
}
|
|
}
|
|
futures::executor::block_on(data_state.update_data());
|
|
let event = BottomEvent::Update(Box::from(data_state.data));
|
|
data_state.data = data_harvester::Data::default();
|
|
if sender.send(event).is_err() {
|
|
break;
|
|
}
|
|
thread::sleep(Duration::from_millis(update_rate_in_milliseconds));
|
|
}
|
|
});
|
|
}
|