Changed layout again.

src/app/data_collection/processes.rs

@@ -52,7 +52,7 @@ fn vangelis_cpu_usage_calculation(prev_idle : &mut f64, prev_non_idle : &mut f64
 	let total_delta : f64 = total - prev_total;
 	let idle_delta : f64 = idle - *prev_idle;
 
-	debug!("Vangelis function: CPU PERCENT: {}", (total_delta - idle_delta) / total_delta * 100_f64);
+	//debug!("Vangelis function: CPU PERCENT: {}", (total_delta - idle_delta) / total_delta * 100_f64);
 
 	*prev_idle = idle;
 	*prev_non_idle = non_idle;
@@ -103,7 +103,7 @@ fn get_process_cpu_stats(pid : u32) -> std::io::Result<f64> {
 	let utime = val[13].parse::<f64>().unwrap_or(0_f64);
 	let stime = val[14].parse::<f64>().unwrap_or(0_f64);
 
-	debug!("PID: {}, utime: {}, stime: {}", pid, utime, stime);
+	//debug!("PID: {}, utime: {}, stime: {}", pid, utime, stime);
 
 	Ok(utime + stime) // This seems to match top...
 }
@@ -118,14 +118,14 @@ fn linux_cpu_usage(pid : u32, cpu_usage : f64, previous_pid_stats : &mut HashMap
 	};
 	let after_proc_val = get_process_cpu_stats(pid)?;
 
-	debug!(
+	/*debug!(
 		"PID - {} - Before: {}, After: {}, CPU: {}, Percentage: {}",
 		pid,
 		before_proc_val,
 		after_proc_val,
 		cpu_usage,
 		(after_proc_val - before_proc_val) / cpu_usage * 100_f64
-	);
+	);*/
 
 	let entry = previous_pid_stats.entry(pid.to_string()).or_insert(after_proc_val);
 	*entry = after_proc_val;

src/canvas.rs

@@ -7,7 +7,7 @@ use tui::{
 };
 
 const COLOUR_LIST : [Color; 6] = [Color::LightRed, Color::LightGreen, Color::LightYellow, Color::LightBlue, Color::LightCyan, Color::LightMagenta];
-const TEXT_COLOUR : Color = Color::Green;
+const TEXT_COLOUR : Color = Color::Gray;
 
 #[derive(Default)]
 pub struct CanvasData {
@@ -22,49 +22,64 @@ pub struct CanvasData {
 // TODO: Change the error
 pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, canvas_data : &CanvasData) -> Result<(), io::Error> {
 	let temperature_rows = canvas_data.temp_sensor_data.iter().map(|sensor| Row::StyledData(sensor.iter(), Style::default().fg(TEXT_COLOUR)));
-
 	let disk_rows = canvas_data.disk_data.iter().map(|disk| Row::StyledData(disk.iter(), Style::default().fg(TEXT_COLOUR)));
-
 	let process_rows = canvas_data.process_data.iter().map(|process| Row::StyledData(process.iter(), Style::default().fg(TEXT_COLOUR)));
 
 	// TODO: Convert this into a separate func!
 	terminal.draw(|mut f| {
+		debug!("Drawing!");
 		let vertical_chunks = Layout::default()
 			.direction(Direction::Vertical)
 			.margin(1)
-			.constraints([Constraint::Percentage(35), Constraint::Percentage(30), Constraint::Percentage(35)].as_ref())
+			.constraints([Constraint::Percentage(34), Constraint::Percentage(34), Constraint::Percentage(32)].as_ref())
 			.split(f.size());
-		let top_chunks = Layout::default()
+		let _top_chunks = Layout::default()
 			.direction(Direction::Horizontal)
 			.margin(0)
 			.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
 			.split(vertical_chunks[0]);
+
 		let middle_chunks = Layout::default()
 			.direction(Direction::Horizontal)
 			.margin(0)
-			.constraints([Constraint::Percentage(40), Constraint::Percentage(60)].as_ref())
+			.constraints([Constraint::Percentage(70), Constraint::Percentage(30)].as_ref())
 			.split(vertical_chunks[1]);
-		let middle_divided_chunk_1 = Layout::default()
+		let _middle_divided_chunk_1 = Layout::default()
 			.direction(Direction::Vertical)
 			.margin(0)
 			.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
 			.split(middle_chunks[0]);
-		let middle_divided_chunk_2 = Layout::default()
+		let _middle_divided_chunk_2 = Layout::default()
 			.direction(Direction::Vertical)
 			.margin(0)
 			.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
 			.split(middle_chunks[1]);
+
 		let bottom_chunks = Layout::default()
 			.direction(Direction::Horizontal)
 			.margin(0)
 			.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
 			.split(vertical_chunks[2]);
+		let bottom_divided_chunk_1 = Layout::default()
+			.direction(Direction::Vertical)
+			.margin(0)
+			.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+			.split(bottom_chunks[0]);
+		let bottom_divided_chunk_1_1 = Layout::default()
+			.direction(Direction::Horizontal)
+			.margin(0)
+			.constraints([Constraint::Percentage(40), Constraint::Percentage(60)].as_ref())
+			.split(bottom_divided_chunk_1[0]);
+		let bottom_divided_chunk_1_2 = Layout::default()
+			.direction(Direction::Horizontal)
+			.margin(0)
+			.constraints([Constraint::Percentage(40), Constraint::Percentage(60)].as_ref())
+			.split(bottom_divided_chunk_1[1]);
 
 		// Set up blocks and their components
 
 		// CPU usage graph
 		{
-			debug!("Drawing CPU...");
 			let x_axis : Axis<String> = Axis::default().style(Style::default().fg(Color::White)).bounds([0.0, 60.0]);
 			let y_axis = Axis::default().style(Style::default().fg(Color::White)).bounds([0.0, 100.0]).labels(&["0.0", "50.0", "100.0"]);
 
@@ -84,7 +99,7 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, canvas_
 				.x_axis(x_axis)
 				.y_axis(y_axis)
 				.datasets(&dataset_vector)
-				.render(&mut f, top_chunks[0]);
+				.render(&mut f, vertical_chunks[0]);
 		}
 
 		//Memory usage graph
@@ -99,7 +114,7 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, canvas_
 					Dataset::default()
 						.name(&("MEM :".to_string() + &format!("{:3}%", (canvas_data.mem_data.last().unwrap_or(&(0_f64, 0_f64)).1.round() as u64))))
 						.marker(Marker::Braille)
-						.style(Style::default().fg(Color::Cyan))
+						.style(Style::default().fg(Color::LightRed))
 						.data(&canvas_data.mem_data),
 					Dataset::default()
 						.name(&("SWAP:".to_string() + &format!("{:3}%", (canvas_data.swap_data.last().unwrap_or(&(0_f64, 0_f64)).1.round() as u64))))
@@ -107,31 +122,31 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, canvas_
 						.style(Style::default().fg(Color::LightGreen))
 						.data(&canvas_data.swap_data),
 				])
-				.render(&mut f, top_chunks[1]);
+				.render(&mut f, middle_chunks[0]);
 		}
 
+		// Network graph
+		Block::default().title("Network").borders(Borders::ALL).render(&mut f, middle_chunks[1]);
+
 		// Temperature table
 		Table::new(["Sensor", "Temperature"].iter(), temperature_rows)
 			.block(Block::default().title("Temperatures").borders(Borders::ALL))
 			.header_style(Style::default().fg(Color::LightBlue))
 			.widths(&[15, 5])
-			.render(&mut f, middle_divided_chunk_1[0]);
+			.render(&mut f, bottom_divided_chunk_1_1[0]);
 
 		// Disk usage table
 		Table::new(["Disk", "Mount", "Used", "Total", "Free"].iter(), disk_rows)
 			.block(Block::default().title("Disk Usage").borders(Borders::ALL))
 			.header_style(Style::default().fg(Color::LightBlue))
 			.widths(&[15, 10, 5, 5, 5])
-			.render(&mut f, middle_divided_chunk_1[1]);
+			.render(&mut f, bottom_divided_chunk_1_2[0]);
 
 		// Temp graph
-		Block::default().title("Temperatures").borders(Borders::ALL).render(&mut f, middle_divided_chunk_2[0]);
+		Block::default().title("Temperatures").borders(Borders::ALL).render(&mut f, bottom_divided_chunk_1_1[1]);
 
 		// IO graph
-		Block::default().title("IO Usage").borders(Borders::ALL).render(&mut f, middle_divided_chunk_2[1]);
+		Block::default().title("IO Usage").borders(Borders::ALL).render(&mut f, bottom_divided_chunk_1_2[1]);
-
-		// Network graph
-		Block::default().title("Network").borders(Borders::ALL).render(&mut f, bottom_chunks[0]);
 
 		// Processes table
 		Table::new(["PID", "Name", "CPU%", "Mem%"].iter(), process_rows)

src/main.rs

@@ -88,17 +88,15 @@ async fn main() -> Result<(), io::Error> {
 
 					if app.to_be_resorted {
 						data_collection::processes::sort_processes(&mut app_data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse);
+						canvas_data.process_data = update_process_row(&app_data);
 						app.to_be_resorted = false;
 					}
 					try_debug(&log, "Input event complete.");
-
-					// Only update processes
 				}
 				Event::Update(data) => {
 					try_debug(&log, "Update event fired!");
 					app_data = *data;
 					data_collection::processes::sort_processes(&mut app_data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse);
-					try_debug(&log, "Update event complete.");
 
 					// Convert all data into tui components
 					canvas_data.disk_data = update_disk_row(&app_data);
@@ -107,15 +105,15 @@ async fn main() -> Result<(), io::Error> {
 					canvas_data.mem_data = update_mem_data_points(&app_data);
 					canvas_data.swap_data = update_swap_data_points(&app_data);
 					canvas_data.cpu_data = update_cpu_data_points(&app_data);
+
+					try_debug(&log, "Update event complete.");
 				}
 			}
 			if app.should_quit {
 				break;
 			}
 		}
-
 		// Draw!
-		// TODO: We should change this btw! It should not redraw everything on every tick!
 		canvas::draw_data(&mut terminal, &canvas_data)?;
 	}
 
@@ -187,30 +185,44 @@ fn update_process_row(app_data : &app::Data) -> Vec<Vec<String>> {
 }
 
 fn update_cpu_data_points(app_data : &app::Data) -> Vec<(String, Vec<(f64, f64)>)> {
-	let mut cpu_vector : Vec<(String, Vec<(f64, f64)>)> = Vec::new();
+	let mut cpu_data_vector : Vec<(String, Vec<(f64, f64)>)> = Vec::new();
-	let mut data_vector : Vec<Vec<(f64, f64)>> = Vec::new();
+	let mut cpu_collection : Vec<Vec<(f64, f64)>> = Vec::new();
 
 	if !app_data.list_of_cpu_packages.is_empty() {
-		for cpu_num in 0..app_data.list_of_cpu_packages.last().unwrap().cpu_vec.len() {
+		// Initially, populate the cpu_collection.  We want to inject elements in between if possible.
+		let current_time = std::time::Instant::now();
+
+		for cpu_num in 1..app_data.list_of_cpu_packages.last().unwrap().cpu_vec.len() {
+			// 1 to skip total cpu
 			let mut this_cpu_data : Vec<(f64, f64)> = Vec::new();
-			let current_time = std::time::Instant::now();
 
 			for cpu in &app_data.list_of_cpu_packages {
-				this_cpu_data.push((STALE_MAX_SECONDS as f64 - current_time.duration_since(cpu.instant).as_secs_f64(), cpu.cpu_vec[cpu_num].cpu_usage));
+				// To make it look better...
+				let current_cpu_usage = cpu.cpu_vec[cpu_num].cpu_usage;
+
+				if !this_cpu_data.is_empty() {
+					let previous_entry_cpu_usage = this_cpu_data.last().unwrap().1;
+					let middling_cpu_usage = (previous_entry_cpu_usage + current_cpu_usage) / 2_f64;
+
+					this_cpu_data.push((STALE_MAX_SECONDS as f64 - current_time.duration_since(cpu.instant).as_secs_f64().floor() - 0.5_f64, middling_cpu_usage));
+				}
+
+				this_cpu_data.push((STALE_MAX_SECONDS as f64 - current_time.duration_since(cpu.instant).as_secs_f64().floor(), current_cpu_usage));
 			}
 
-			data_vector.push(this_cpu_data);
+			cpu_collection.push(this_cpu_data);
 		}
 
-		for (i, data) in data_vector.iter().enumerate() {
+		// Finally, add it all onto the end
-			cpu_vector.push((
+		for (i, data) in cpu_collection.iter().enumerate() {
+			cpu_data_vector.push((
 				(&*(app_data.list_of_cpu_packages.last().unwrap().cpu_vec[i].cpu_name)).to_string() + " " + &format!("{:.2}", data.last().unwrap_or(&(0_f64, 0_f64)).1.to_string()),
 				data.clone(),
 			))
 		}
 	}
 
-	cpu_vector
+	cpu_data_vector
 }
 
 fn update_mem_data_points(app_data : &app::Data) -> Vec<(f64, f64)> {