implement labels of loaded files

Author: hacknus

src/data.rs

@@ -48,6 +48,7 @@ pub struct DataContainer {
     pub absolute_time: Vec<f64>,
     pub dataset: Vec<Vec<f32>>,
     pub raw_traffic: Vec<Packet>,
+    pub loaded_from_file: bool,
 }
 
 impl Default for DataContainer {
@@ -57,6 +58,7 @@ impl Default for DataContainer {
             absolute_time: vec![],
             dataset: vec![vec![]],
             raw_traffic: vec![],
+            loaded_from_file: false,
         }
     }
 }

src/gui.rs

@@ -2,7 +2,7 @@ use core::f32;
 use std::cmp::max;
 use std::ops::RangeInclusive;
 use std::path::PathBuf;
-use std::sync::mpsc::Sender;
+use std::sync::mpsc::{Receiver, Sender};
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
@@ -128,6 +128,7 @@ pub struct MyApp {
     data_lock: Arc<RwLock<DataContainer>>,
     save_tx: Sender<FileOptions>,
     load_tx: Sender<PathBuf>,
+    load_names_rx: Receiver<Vec<String>>,
     send_tx: Sender<String>,
     clear_tx: Sender<bool>,
     history: Vec<String>,
@@ -157,6 +158,7 @@ impl MyApp {
         gui_conf: GuiSettingsContainer,
         save_tx: Sender<FileOptions>,
         load_tx: Sender<PathBuf>,
+        load_names_rx: Receiver<Vec<String>>,
         send_tx: Sender<String>,
         clear_tx: Sender<bool>,
     ) -> Self {
@@ -217,6 +219,7 @@ impl MyApp {
             data_lock,
             save_tx,
             load_tx,
+            load_names_rx,
             send_tx,
             clear_tx,
             plotting_range: usize::MAX,
@@ -317,8 +320,20 @@ impl MyApp {
                     if let Ok(read_guard) = self.data_lock.read() {
                         self.data = read_guard.clone();
                     }
+
+                    if self.data.loaded_from_file && self.file_opened {
+                        if let Ok(labels) =
+                            self.load_names_rx.recv_timeout(Duration::from_millis(10))
+                        {
+                            self.labels = labels;
+                            self.colors = (0..max(self.labels.len(), 1))
+                                .map(|i| COLORS[i % COLORS.len()])
+                                .collect();
+                            self.color_vals = (0..max(self.labels.len(), 1)).map(|_| 0.0).collect();
+                        }
+                    }
                     if self.serial_devices.number_of_plots[self.device_idx] > 0 {
-                        if self.data.dataset.len() != self.labels.len() {
+                        if self.data.dataset.len() != self.labels.len() && !self.file_opened {
                             self.labels = (0..max(self.data.dataset.len(), 1))
                                 .map(|i| format!("Column {i}"))
                                 .collect();

src/io.rs

@@ -62,6 +62,8 @@ pub fn open_from_csv(
         }
     }
 
+    data.loaded_from_file = true;
+
     Ok(())
 }
 

src/main.rs

@@ -53,6 +53,7 @@ fn main_thread(
     raw_data_rx: Receiver<Packet>,
     save_rx: Receiver<FileOptions>,
     load_rx: Receiver<PathBuf>,
+    load_names_tx: Sender<Vec<String>>,
     clear_rx: Receiver<bool>,
 ) {
     // reads data from mutex, samples and saves if needed
@@ -70,6 +71,7 @@ fn main_thread(
         }
         if !file_opened {
             if let Ok(packet) = raw_data_rx.recv_timeout(Duration::from_millis(1)) {
+                data.loaded_from_file = false;
                 if !packet.payload.is_empty() {
                     sync_tx.send(true).expect("unable to send sync tx");
                     data.raw_traffic.push(packet.clone());
@@ -114,6 +116,9 @@ fn main_thread(
                         match open_from_csv(&mut data, &mut file_options) {
                             Ok(_) => {
                                 log::info!("opened {:?}", fp);
+                                load_names_tx
+                                    .send(file_options.names)
+                                    .expect("unable to send names on channel after loading");
                             }
                             Err(err) => {
                                 file_opened = false;
@@ -170,6 +175,8 @@ fn main() {
 
     let (save_tx, save_rx): (Sender<FileOptions>, Receiver<FileOptions>) = mpsc::channel();
     let (load_tx, load_rx): (Sender<PathBuf>, Receiver<PathBuf>) = mpsc::channel();
+    let (loaded_names_tx, loaded_names_rx): (Sender<Vec<String>>, Receiver<Vec<String>>) =
+        mpsc::channel();
     let (send_tx, send_rx): (Sender<String>, Receiver<String>) = mpsc::channel();
     let (clear_tx, clear_rx): (Sender<bool>, Receiver<bool>) = mpsc::channel();
     let (raw_data_tx, raw_data_rx): (Sender<Packet>, Receiver<Packet>) = mpsc::channel();
@@ -198,6 +205,7 @@ fn main() {
             raw_data_rx,
             save_rx,
             load_rx,
+            loaded_names_tx,
             clear_rx,
         );
     });
@@ -245,6 +253,7 @@ fn main() {
                 gui_settings,
                 save_tx,
                 load_tx,
+                loaded_names_rx,
                 send_tx,
                 clear_tx,
             )))