Updated memory labels to be more straightforward in generation.

src/app/data_janitor.rs

@@ -85,16 +85,18 @@ impl DataCollection {
 		new_entry.mem_data = mem_pt;
 
 		// Swap
-		let swap_percent = harvested_data.swap.mem_used_in_mb as f64
+		if harvested_data.swap.mem_total_in_mb > 0 {
-			/ harvested_data.swap.mem_total_in_mb as f64
+			let swap_percent = harvested_data.swap.mem_used_in_mb as f64
-			* 100.0;
+				/ harvested_data.swap.mem_total_in_mb as f64
-		let swap_joining_pt = if let Some((time, last_pt)) = self.timed_data_vec.last() {
+				* 100.0;
-			generate_joining_points(&time, last_pt.swap_data.0, &harvested_time, swap_percent)
+			let swap_joining_pt = if let Some((time, last_pt)) = self.timed_data_vec.last() {
-		} else {
+				generate_joining_points(&time, last_pt.swap_data.0, &harvested_time, swap_percent)
-			Vec::new()
+			} else {
-		};
+				Vec::new()
-		let swap_pt = (swap_percent, swap_joining_pt);
+			};
-		new_entry.swap_data = swap_pt;
+			let swap_pt = (swap_percent, swap_joining_pt);
+			new_entry.swap_data = swap_pt;
+		}
 
 		// In addition copy over latest data for easy reference
 		self.memory_harvest = harvested_data.memory.clone();

src/canvas.rs

@@ -96,7 +96,8 @@ pub struct CanvasData {
 	pub temp_sensor_data: Vec<Vec<String>>,
 	pub process_data: Vec<ConvertedProcessData>,
 	pub grouped_process_data: Vec<ConvertedProcessData>,
-	pub memory_labels: Vec<(u64, u64)>,
+	pub mem_label: String,
+	pub swap_label: String,
 	pub mem_data: Vec<(f64, f64)>,
 	pub swap_data: Vec<(f64, f64)>,
 	pub cpu_data: Vec<ConvertedCpuData>,
@@ -581,7 +582,6 @@ fn draw_memory_table<B: backend::Backend>(
 fn draw_memory_graph<B: backend::Backend>(f: &mut Frame<B>, app_state: &app::App, draw_loc: Rect) {
 	let mem_data: &[(f64, f64)] = &(app_state.canvas_data.mem_data);
 	let swap_data: &[(f64, f64)] = &(app_state.canvas_data.swap_data);
-	let memory_labels: &[(u64, u64)] = &(app_state.canvas_data.memory_labels);
 
 	let x_axis: Axis<String> = Axis::default()
 		.style(Style::default().fg(GRAPH_COLOUR))
@@ -591,20 +591,8 @@ fn draw_memory_graph<B: backend::Backend>(f: &mut Frame<B>, app_state: &app::App
 		.bounds([-0.5, 100.5]) // Offset as the zero value isn't drawn otherwise...
 		.labels(&["0%", "100%"]);
 
-	// TODO: [OPT] Move this
-	let mem_name = "RAM:".to_string()
-		+ &format!(
-			"{:3}%",
-			(mem_data.last().unwrap_or(&(0_f64, 0_f64)).1.round() as u64)
-		) + &format!(
-		"   {:.1}GB/{:.1}GB",
-		memory_labels.first().unwrap_or(&(0, 0)).0 as f64 / 1024.0,
-		memory_labels.first().unwrap_or(&(0, 0)).1 as f64 / 1024.0
-	);
-	let swap_name: String;
-
 	let mut mem_canvas_vec: Vec<Dataset> = vec![Dataset::default()
-		.name(&mem_name)
+		.name(&app_state.canvas_data.mem_label)
 		.marker(if app_state.use_dot {
 			Marker::Dot
 		} else {
@@ -614,35 +602,19 @@ fn draw_memory_graph<B: backend::Backend>(f: &mut Frame<B>, app_state: &app::App
 		.data(&mem_data)];
 
 	if !(&swap_data).is_empty() {
-		if let Some(last_canvas_result) = (&swap_data).last() {
+		mem_canvas_vec.push(
-			if last_canvas_result.1 >= 0.0 {
+			Dataset::default()
-				swap_name = "SWP:".to_string()
+				.name(&app_state.canvas_data.swap_label)
-					+ &format!(
+				.marker(if app_state.use_dot {
-						"{:3}%",
+					Marker::Dot
-						(swap_data.last().unwrap_or(&(0_f64, 0_f64)).1.round() as u64)
+				} else {
-					) + &format!(
+					Marker::Braille
-					"   {:.1}GB/{:.1}GB",
+				})
-					memory_labels[1].0 as f64 / 1024.0,
+				.style(Style::default().fg(COLOUR_LIST[1]))
-					memory_labels[1].1 as f64 / 1024.0
+				.data(&swap_data),
-				);
+		);
-				mem_canvas_vec.push(
-					Dataset::default()
-						.name(&swap_name)
-						.marker(if app_state.use_dot {
-							Marker::Dot
-						} else {
-							Marker::Braille
-						})
-						.style(Style::default().fg(COLOUR_LIST[1]))
-						.data(&swap_data),
-				);
-			}
-		}
 	}
 
-	// Memory usage table
-	// draw_memory_table(f, &app_state, mem_labels, swap_labels, label_loc);
-
 	Chart::default()
 		.block(
 			Block::default()

src/data_conversion.rs

@@ -358,21 +358,42 @@ pub fn update_swap_data_points(current_data: &data_janitor::DataCollection) -> V
 	result
 }
 
-pub fn update_mem_labels(current_data: &data_janitor::DataCollection) -> Vec<(u64, u64)> {
+pub fn update_mem_labels(current_data: &data_janitor::DataCollection) -> (String, String) {
-	let mut result: Vec<(u64, u64)> = Vec::new();
+	let mem_label = if current_data.memory_harvest.mem_total_in_mb == 0 {
+		"".to_string()
+	} else {
+		"RAM:".to_string()
+			+ &format!(
+				"{:3.0}%",
+				(current_data.memory_harvest.mem_used_in_mb as f64 * 100.0
+					/ current_data.memory_harvest.mem_total_in_mb as f64)
+					.round()
+			) + &format!(
+			"   {:.1}GB/{:.1}GB",
+			current_data.memory_harvest.mem_used_in_mb as f64 / 1024.0,
+			current_data.memory_harvest.mem_total_in_mb as f64 / 1024.0
+		)
+	};
 
-	// This wants (u64, u64) values - left is usage in MB, right is total in MB
+	let swap_label = if current_data.swap_harvest.mem_total_in_mb == 0 {
-	result.push((
+		"".to_string()
-		current_data.memory_harvest.mem_used_in_mb,
+	} else {
-		current_data.memory_harvest.mem_total_in_mb,
+		"SWP:".to_string()
-	));
+			+ &format!(
+				"{:3.0}%",
+				(current_data.swap_harvest.mem_used_in_mb as f64 * 100.0
+					/ current_data.swap_harvest.mem_total_in_mb as f64)
+					.round()
+			) + &format!(
+			"   {:.1}GB/{:.1}GB",
+			current_data.swap_harvest.mem_used_in_mb as f64 / 1024.0,
+			current_data.swap_harvest.mem_total_in_mb as f64 / 1024.0
+		)
+	};
 
-	result.push((
+	debug!("{:?}", mem_label);
-		current_data.swap_harvest.mem_used_in_mb,
-		current_data.swap_harvest.mem_total_in_mb,
-	));
 
-	result
+	(mem_label, swap_label)
 }
 
 pub fn convert_network_data_points(

src/main.rs

@@ -286,7 +286,9 @@ fn main() -> error::Result<()> {
 							update_temp_row(&app.data, &app.temperature_type);
 						app.canvas_data.mem_data = update_mem_data_points(&app.data_collection);
 						app.canvas_data.swap_data = update_swap_data_points(&app.data_collection);
-						app.canvas_data.memory_labels = update_mem_labels(&app.data_collection);
+						let memory_and_swap_labels = update_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;
 						app.canvas_data.cpu_data =
 							update_cpu_data_points(app.show_average_cpu, &app.data);
 					}