fix: Only re-draw the screen if data/layout has changed

Author: mrjackwills

src/app_data/mod.rs

@@ -13,7 +13,7 @@ mod container_state;
 use crate::{
     app_error::AppError,
     config::Config,
-    ui::{log_sanitizer, GuiState, Status},
+    ui::{log_sanitizer, GuiState, Redraw, Status},
     ENTRY_POINT,
 };
 pub use container_state::*;
@@ -122,7 +122,9 @@ pub struct AppData {
     error: Option<AppError>,
     filter: Filter,
     hidden_containers: Vec<ContainerItem>,
+    redraw: Arc<Redraw>,
     sorted_by: Option<(Header, SortedOrder)>,
+    current_sorted_id: Vec<ContainerId>,
     pub config: Config,
 }
 
@@ -134,18 +136,22 @@ pub struct AppData {
     pub error: Option<AppError>,
     pub filter: Filter,
     pub hidden_containers: Vec<ContainerItem>,
+    pub current_sorted_id: Vec<ContainerId>,
+    pub redraw: Arc<Redraw>,
     pub sorted_by: Option<(Header, SortedOrder)>,
 }
 
 impl AppData {
     /// Generate a default app_state
-    pub fn default(config: Config) -> Self {
+    pub fn new(config: Config, redraw: &Arc<Redraw>) -> Self {
         Self {
             config,
             containers: StatefulList::new(vec![]),
+            current_sorted_id: vec![],
             error: None,
             filter: Filter::new(),
             hidden_containers: vec![],
+            redraw: Arc::clone(redraw),
             sorted_by: None,
         }
     }
@@ -186,6 +192,7 @@ impl AppData {
     /// sets the state to start if any filtering has occurred
     /// Also search in the "hidden" vec for items and insert back into the main containers vec
     fn filter_containers(&mut self) {
+        self.redraw.set_true();
         let pre_len = self.get_container_len();
 
         if !self.hidden_containers.is_empty() {
@@ -289,6 +296,7 @@ impl AppData {
     /// Remove the sorted header & order, and sort by default - created datetime
     pub fn reset_sorted(&mut self) {
         self.set_sorted(None);
+        self.redraw.set_true();
     }
 
     /// Sort containers based on a given header, if headings match, and already ascending, remove sorting
@@ -309,10 +317,19 @@ impl AppData {
         self.sorted_by
     }
 
+    /// Get a vec of the containers ID's
+    fn get_current_ids(&self) -> Vec<ContainerId> {
+        self.containers
+            .items
+            .iter()
+            .map(|i| i.id.clone())
+            .collect::<Vec<_>>()
+    }
     /// Sort the containers vec, based on a heading (and if clash, then by name), either ascending or descending,
     /// If not sort set, then sort by created time
     pub fn sort_containers(&mut self) {
         if let Some((head, ord)) = self.sorted_by {
+            let pre_order = self.get_current_ids();
             let sort_closure = |a: &ContainerItem, b: &ContainerItem| -> std::cmp::Ordering {
                 let item_ord = match ord {
                     SortedOrder::Asc => (a, b),
@@ -372,13 +389,19 @@ impl AppData {
                         .then_with(|| item_ord.0.id.cmp(&item_ord.1.id)),
                 }
             };
+
             self.containers.items.sort_by(sort_closure);
-        } else {
+            if pre_order != self.get_current_ids() {
+                self.redraw.set_true();
+            }
+        } else if self.current_sorted_id != self.get_current_ids() {
             self.containers.items.sort_by(|a, b| {
                 a.created
                     .cmp(&b.created)
                     .then_with(|| a.name.get().cmp(b.name.get()))
             });
+            self.redraw.set_true();
+            self.current_sorted_id = self.get_current_ids();
         }
     }
 
@@ -414,21 +437,25 @@ impl AppData {
     /// Select the first container
     pub fn containers_start(&mut self) {
         self.containers.start();
+        self.redraw.set_true();
     }
 
     /// select the last container
     pub fn containers_end(&mut self) {
         self.containers.end();
+        self.redraw.set_true();
     }
 
     /// Select the next container
     pub fn containers_next(&mut self) {
         self.containers.next();
+        self.redraw.set_true();
     }
 
     /// select the previous container
     pub fn containers_previous(&mut self) {
         self.containers.previous();
+        self.redraw.set_true();
     }
 
     /// Get ListState of containers
@@ -521,6 +548,11 @@ impl AppData {
         self.get_selected_container().map(|i| i.id.clone())
     }
 
+    /// Check if a given ID matches the currently selected container
+    pub fn is_selected_container(&self, id: &ContainerId) -> bool {
+        self.get_selected_container().is_some_and(|i| &i.id == id)
+    }
+
     /// Get the Id and State for the currently selected container - used by the exec check method
     pub fn get_selected_container_id_state_name(&self) -> Option<(ContainerId, State, String)> {
         self.get_selected_container()
@@ -545,27 +577,31 @@ impl AppData {
     pub fn docker_controls_next(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.docker_controls.next();
+            self.redraw.set_true();
         }
     }
 
     /// Change selected choice of docker commands of selected container
     pub fn docker_controls_previous(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.docker_controls.previous();
+            self.redraw.set_true();
         }
     }
 
     /// Change selected choice of docker commands of selected container
     pub fn docker_controls_start(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.docker_controls.start();
+            self.redraw.set_true();
         }
     }
 
     /// Change selected choice of docker commands of selected container
     pub fn docker_controls_end(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.docker_controls.end();
+            self.redraw.set_true();
         }
     }
 
@@ -603,27 +639,31 @@ impl AppData {
     pub fn log_next(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.logs.next();
+            self.redraw.set_true();
         }
     }
 
     /// select previous selected log line
     pub fn log_previous(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.logs.previous();
+            self.redraw.set_true();
         }
     }
 
     /// select last selected log line
     pub fn log_end(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.logs.end();
+            self.redraw.set_true();
         }
     }
 
     /// select first selected log line
     pub fn log_start(&mut self) {
         if let Some(i) = self.get_mut_selected_container() {
             i.logs.start();
+            self.redraw.set_true();
         }
     }
 
@@ -664,12 +704,14 @@ impl AppData {
     /// Remove single app_state error
     pub fn remove_error(&mut self) {
         self.error = None;
+        self.redraw.set_true();
     }
 
     /// Insert single app_state error
     pub fn set_error(&mut self, error: AppError, gui_state: &Arc<Mutex<GuiState>>, status: Status) {
         gui_state.lock().status_push(status);
         self.error = Some(error);
+        self.redraw.set_true();
     }
 
     /// Check if the selected container is a dockerised version of oxker
@@ -758,6 +800,9 @@ impl AppData {
             container.tx.update(tx);
             container.mem_limit.update(mem_limit);
         }
+        if self.is_selected_container(id) {
+            self.redraw.set_true();
+        }
         self.sort_containers();
     }
 
@@ -793,6 +838,9 @@ impl AppData {
                 // Check is some, else can cause out of bounds error, if containers get removed before a docker update
                 if self.containers.items.get(index).is_some() {
                     self.containers.items.remove(index);
+                    if self.is_selected_container(id) {
+                        self.redraw.set_true();
+                    }
                 }
             }
         }
@@ -872,6 +920,7 @@ impl AppData {
                     }
                 }
             }
+            // self.redraw.set_true("update_containers");
         }
     }
 
@@ -919,6 +968,9 @@ impl AppData {
                     container.logs.end();
                 }
             }
+            if self.is_selected_container(id) {
+                self.redraw.set_true();
+            }
         }
     }
 }

src/config/mod.rs

@@ -18,7 +18,7 @@ mod parse_config_file;
 pub struct Config {
     pub app_colors: AppColors,
     pub color_logs: bool,
-    pub docker_interval: u32,
+    pub docker_interval_ms: u32,
     pub gui: bool,
     pub host: Option<String>,
     pub in_container: bool,
@@ -38,7 +38,7 @@ impl From<&Args> for Config {
         Self {
             app_colors: AppColors::new(),
             color_logs: args.color,
-            docker_interval: args.docker_interval,
+            docker_interval_ms: args.docker_interval,
             gui: !args.gui,
             host: args.host.clone(),
             in_container: Self::check_if_in_container(),
@@ -60,7 +60,7 @@ impl From<ConfigFile> for Config {
         Self {
             app_colors: AppColors::from(config_file.colors),
             color_logs: config_file.color_logs.unwrap_or(false),
-            docker_interval: config_file.docker_interval.unwrap_or(1000),
+            docker_interval_ms: config_file.docker_interval.unwrap_or(1000),
             gui: config_file.gui.unwrap_or(true),
             host: config_file.host,
             in_container: Self::check_if_in_container(),
@@ -129,16 +129,16 @@ impl Config {
     /// make sure color_logs and raw_logs can't clash
     fn merge_args(mut self, config_from_cli: Self) -> Self {
         self.color_logs = config_from_cli.color_logs;
-        self.docker_interval = config_from_cli.docker_interval;
+        self.docker_interval_ms = config_from_cli.docker_interval_ms;
         self.gui = config_from_cli.gui;
         self.raw_logs = config_from_cli.raw_logs;
         self.show_self = config_from_cli.show_self;
         self.show_std_err = config_from_cli.show_std_err;
         self.show_timestamp = config_from_cli.show_timestamp;
         self.use_cli = config_from_cli.use_cli;
 
-        if config_from_cli.docker_interval < 1000 {
-            self.docker_interval = 1000;
+        if config_from_cli.docker_interval_ms < 1000 {
+            self.docker_interval_ms = 1000;
         }
 
         if let Some(host) = config_from_cli.host {

src/docker_data/mod.rs

@@ -400,7 +400,8 @@ impl DockerData {
 
     /// Send an update message every x ms, where x is the args.docker_interval
     fn heartbeat(config: &Config, docker_tx: Sender<DockerMessage>) {
-        let update_duration = std::time::Duration::from_millis(u64::from(config.docker_interval));
+        let update_duration =
+            std::time::Duration::from_millis(u64::from(config.docker_interval_ms));
         let mut now = std::time::Instant::now();
         tokio::spawn(async move {
             loop {

src/input_handler/mod.rs

@@ -625,7 +625,7 @@ impl InputHandler {
                         self.gui_state.lock().status_push(Status::Help);
                     }
 
-                    self.gui_state.lock().get_intersect_panel(mouse_point);
+                    self.gui_state.lock().check_panel_intersect(mouse_point);
                 }
                 _ => (),
             }

src/main.rs

@@ -23,7 +23,7 @@ mod exec;
 mod input_handler;
 mod ui;
 
-use ui::{GuiState, Status, Ui};
+use ui::{GuiState, Redraw, Status, Ui};
 
 use crate::docker_data::DockerMessage;
 
@@ -98,9 +98,10 @@ fn handler_init(
 async fn main() {
     setup_tracing();
     let config = config::Config::new();
+    let redraw = Arc::new(Redraw::new());
 
-    let app_data = Arc::new(Mutex::new(AppData::default(config.clone())));
-    let gui_state = Arc::new(Mutex::new(GuiState::default()));
+    let app_data = Arc::new(Mutex::new(AppData::new(config.clone(), &redraw)));
+    let gui_state = Arc::new(Mutex::new(GuiState::new(&redraw)));
     let is_running = Arc::new(AtomicBool::new(true));
     let (docker_tx, docker_rx) = tokio::sync::mpsc::channel(32);
 
@@ -109,7 +110,7 @@ async fn main() {
     if config.gui {
         let (input_tx, input_rx) = tokio::sync::mpsc::channel(32);
         handler_init(&app_data, &docker_tx, &gui_state, input_rx, &is_running);
-        Ui::start(app_data, gui_state, input_tx, is_running).await;
+        Ui::start(app_data, gui_state, input_tx, is_running, redraw).await;
     } else {
         info!("in debug mode\n");
         let mut now = std::time::Instant::now();
@@ -120,7 +121,7 @@ async fn main() {
                 error!("{}", err);
                 process::exit(1);
             }
-            if let Some(Ok(to_sleep)) = u128::from(config.docker_interval)
+            if let Some(Ok(to_sleep)) = u128::from(config.docker_interval_ms)
                 .checked_sub(now.elapsed().as_millis())
                 .map(u64::try_from)
             {
@@ -148,6 +149,8 @@ async fn main() {
 #[allow(clippy::unwrap_used)]
 mod tests {
 
+    use std::sync::Arc;
+
     use bollard::service::{ContainerSummary, Port};
 
     use crate::{
@@ -156,13 +159,14 @@ mod tests {
             RunningState, State, StatefulList,
         },
         config::{AppColors, Config, Keymap},
+        ui::Redraw,
     };
 
     /// Default test config, has timestamps turned off
     pub fn gen_config() -> Config {
         Config {
             color_logs: false,
-            docker_interval: 1000,
+            docker_interval_ms: 1000,
             gui: true,
             host: None,
             show_std_err: false,
@@ -200,8 +204,10 @@ mod tests {
         AppData {
             containers: StatefulList::new(containers.to_vec()),
             hidden_containers: vec![],
+            current_sorted_id: vec![],
             error: None,
             sorted_by: None,
+            redraw: Arc::new(Redraw::new()),
             filter: Filter::new(),
             config: gen_config(),
         }