wip: gui_status, should use a hashset?

src/app_data/mod.rs

@@ -15,8 +15,8 @@ pub struct AppData {
     error: Option<AppError>,
     logs_parsed: bool,
     pub containers: StatefulList<ContainerItem>,
-    pub init: bool,
-    pub show_error: bool,
+    // pub init: bool,
+    // pub show_error: bool,
     sorted_by: Option<(Header, SortedOrder)>,
 }
 
@@ -79,9 +79,7 @@ impl AppData {
             args,
             containers: StatefulList::new(vec![]),
             error: None,
-            init: false,
             logs_parsed: false,
-            show_error: false,
             sorted_by: None,
         }
     }

src/docker_data/mod.rs

@@ -19,7 +19,7 @@ use crate::{
     app_data::{AppData, ContainerId, DockerControls},
     app_error::AppError,
     parse_args::CliArgs,
-    ui::GuiState,
+    ui::{GuiState, Status},
 };
 mod message;
 pub use message::DockerMessage;
@@ -336,32 +336,40 @@ impl DockerData {
             tokio::time::sleep(std::time::Duration::from_millis(100)).await;
             self.initialised = self.app_data.lock().initialised(&all_ids);
         }
-        self.app_data.lock().init = true;
+        // self.app_data.lock().init = true;
+        self.gui_state.lock().set_status(Status::Normal);
         self.stop_loading_spin(&loading_spin, loading_uuid);
     }
 
+    /// Set the global error as the dockererror, and set gui_state to errro
+    fn set_error(&mut self, error: DockerControls) {
+        self.app_data
+            .lock()
+            .set_error(AppError::DockerCommand(error));
+        self.gui_state.lock().set_status(Status::Error);
+    }
+
     /// Handle incoming messages, container controls & all container information update
     async fn message_handler(&mut self) {
         while let Some(message) = self.receiver.recv().await {
             let docker = Arc::clone(&self.docker);
-            let app_data = Arc::clone(&self.app_data);
             let loading_uuid = Uuid::new_v4();
             match message {
                 DockerMessage::Pause(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
                     if docker.pause_container(id.get()).await.is_err() {
-                        app_data
-                            .lock()
-                            .set_error(AppError::DockerCommand(DockerControls::Pause));
+                        self.set_error(DockerControls::Pause);
                     };
                     self.stop_loading_spin(&loading_spin, loading_uuid);
                 }
                 DockerMessage::Restart(id) => {
+                    // DEBUG	
+                    // self.set_error(DockerControls::Restart);
+                    // DEBUG
+
                     let loading_spin = self.loading_spin(loading_uuid).await;
                     if docker.restart_container(id.get(), None).await.is_err() {
-                        app_data
-                            .lock()
-                            .set_error(AppError::DockerCommand(DockerControls::Restart));
+                        self.set_error(DockerControls::Restart);
                     };
                     self.stop_loading_spin(&loading_spin, loading_uuid);
                 }
@@ -372,27 +380,21 @@ impl DockerData {
                         .await
                         .is_err()
                     {
-                        app_data
-                            .lock()
-                            .set_error(AppError::DockerCommand(DockerControls::Start));
+                        self.set_error(DockerControls::Start);
                     };
                     self.stop_loading_spin(&loading_spin, loading_uuid);
                 }
                 DockerMessage::Stop(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
                     if docker.stop_container(id.get(), None).await.is_err() {
-                        app_data
-                            .lock()
-                            .set_error(AppError::DockerCommand(DockerControls::Stop));
+                        self.set_error(DockerControls::Stop);
                     };
                     self.stop_loading_spin(&loading_spin, loading_uuid);
                 }
                 DockerMessage::Unpause(id) => {
                     let loading_spin = self.loading_spin(loading_uuid).await;
                     if docker.unpause_container(id.get()).await.is_err() {
-                        app_data
-                            .lock()
-                            .set_error(AppError::DockerCommand(DockerControls::Unpause));
+                        self.set_error(DockerControls::Unpause);
                     };
                     self.stop_loading_spin(&loading_spin, loading_uuid);
                     self.update_everything().await;

src/input_handler/mod.rs

@@ -21,7 +21,7 @@ use crate::{
     app_data::{AppData, DockerControls, Header, SortedOrder},
     app_error::AppError,
     docker_data::DockerMessage,
-    ui::{GuiState, SelectablePanel},
+    ui::{GuiState, SelectablePanel, Status},
 };
 pub use message::InputMessages;
 
@@ -64,10 +64,11 @@ impl InputHandler {
             match message {
                 InputMessages::ButtonPress(key_code) => self.button_press(key_code).await,
                 InputMessages::MouseEvent(mouse_event) => {
-                    let show_error = self.app_data.lock().show_error;
-                    let show_info = self.gui_state.lock().show_help;
-                    if !show_error && !show_info {
-                        self.mouse_press(mouse_event);
+                    // let show_error = self.app_data.lock().show_error;
+                    let status = self.gui_state.lock().get_status();
+                    match status {
+                        Status::Error | Status::Help => (),
+                        _ => self.mouse_press(mouse_event),
                     }
                 }
             }
@@ -85,10 +86,11 @@ impl InputHandler {
                     .gui_state
                     .lock()
                     .set_info_box("✖ mouse capture disabled".to_owned()),
-                Err(_) => self
-                    .app_data
+                Err(_) => {
+                    self.app_data
                         .lock()
-                    .set_error(AppError::MouseCapture(false)),
+                        .set_error(AppError::MouseCapture(false));
+                }
             }
         } else {
             match execute!(std::io::stdout(), EnableMouseCapture) {
@@ -96,7 +98,9 @@ impl InputHandler {
                     .gui_state
                     .lock()
                     .set_info_box("✓ mouse capture enabled".to_owned()),
-                Err(_) => self.app_data.lock().set_error(AppError::MouseCapture(true)),
+                Err(_) => {
+                    self.app_data.lock().set_error(AppError::MouseCapture(true));
+                }
             }
         };
 
@@ -129,36 +133,43 @@ impl InputHandler {
     }
 
     /// Send a quit message to docker, to abort all spawns, if an error is return, set is_running to false here instead
-    async fn quit(&self) {
-        match self.docker_sender.send(DockerMessage::Quit).await {
-            Ok(_) => (),
-            Err(_) => self.is_running.store(false, Ordering::SeqCst),
+    async fn quit(&self, status: Status) {
+        match status {
+            Status::Error | Status::Init => self.is_running.store(false, Ordering::SeqCst),
+            _ => {
+                if self.docker_sender.send(DockerMessage::Quit).await.is_err() {
+                    self.is_running.store(false, Ordering::SeqCst)
                 }
             }
+        }
+
+        // match self.docker_sender.send(DockerMessage::Quit).await {
+        //     Ok(_) => (),
+        //     Err(_) => self.is_running.store(false, Ordering::SeqCst),
+        // }
+    }
 
     /// Handle any keyboard button events
     #[allow(clippy::too_many_lines)]
     async fn button_press(&mut self, key_code: KeyCode) {
-        let show_error = self.app_data.lock().show_error;
-        let show_info = self.gui_state.lock().show_help;
+        let status = self.gui_state.lock().get_status();
 
-        if show_error {
-            match key_code {
-                KeyCode::Char('q' | 'Q') => self.quit().await,
+        match status {
+            Status::Error => match key_code {
+                KeyCode::Char('q' | 'Q') => self.quit(status).await,
                 KeyCode::Char('c' | 'C') => {
-                    self.app_data.lock().show_error = false;
                     self.app_data.lock().remove_error();
+                    self.gui_state.lock().set_status(Status::Normal);
                 }
                 _ => (),
-            }
-        } else if show_info {
-            match key_code {
-                KeyCode::Char('q' | 'Q') => self.quit().await,
-                KeyCode::Char('h' | 'H') => self.gui_state.lock().show_help = false,
+            },
+            Status::Help => match key_code {
+                KeyCode::Char('q' | 'Q') => self.quit(status).await,
+                KeyCode::Char('h' | 'H') => self.gui_state.lock().set_status(Status::Help),
                 KeyCode::Char('m' | 'M') => self.m_key(),
                 _ => (),
-            }
-        } else {
+            },
+            _ => {
                 match key_code {
                     KeyCode::Char('0') => self.app_data.lock().set_sorted(None),
                     KeyCode::Char('1') => self.sort(Header::State),
@@ -170,8 +181,8 @@ impl InputHandler {
                     KeyCode::Char('7') => self.sort(Header::Image),
                     KeyCode::Char('8') => self.sort(Header::Rx),
                     KeyCode::Char('9') => self.sort(Header::Tx),
-                KeyCode::Char('q' | 'Q') => self.quit().await,
-                KeyCode::Char('h' | 'H') => self.gui_state.lock().show_help = true,
+                    KeyCode::Char('q' | 'Q') => self.quit(status).await,
+                    KeyCode::Char('h' | 'H') => self.gui_state.lock().set_status(Status::Help),
                     KeyCode::Char('m' | 'M') => self.m_key(),
                     KeyCode::Tab => {
                         // Skip control panel if no containers, could be refactored
@@ -273,6 +284,7 @@ impl InputHandler {
                 }
             }
         }
+    }
 
     /// Handle mouse button events
     fn mouse_press(&mut self, mouse_event: MouseEvent) {

src/main.rs

@@ -24,7 +24,7 @@ mod input_handler;
 mod parse_args;
 mod ui;
 
-use ui::{create_ui, GuiState};
+use ui::{create_ui, GuiState, Status};
 
 fn setup_tracing() {
     tracing_subscriber::fmt().with_max_level(Level::INFO).init();
@@ -59,9 +59,15 @@ async fn main() {
                     is_running,
                 ));
             }
-            Err(_) => app_data.lock().set_error(AppError::DockerConnect),
+            Err(_) => {
+                app_data.lock().set_error(AppError::DockerConnect);
+                docker_gui_state.lock().set_status(Status::DockerConnect)
+            }
         },
-        Err(_) => app_data.lock().set_error(AppError::DockerConnect),
+        Err(_) => {
+            app_data.lock().set_error(AppError::DockerConnect);
+            docker_gui_state.lock().set_status(Status::DockerConnect)
+        }
     }
     let input_app_data = Arc::clone(&app_data);
 

src/ui/draw_blocks.rs

@@ -15,6 +15,7 @@ use tui::{
 };
 
 use crate::app_data::{Header, SortedOrder};
+use crate::ui::Status;
 use crate::{
     app_data::{AppData, ByteStats, Columns, CpuStats, State, Stats},
     app_error::AppError,
@@ -215,15 +216,18 @@ pub fn logs<B: Backend>(
     loading_icon: &str,
 ) {
     let block = generate_block(app_data, area, gui_state, SelectablePanel::Logs);
-
-    let init = app_data.lock().init;
-    if !init {
+    let status = gui_state.lock().get_status();
+    match status {
+        Status::Init => {
             let paragraph = Paragraph::new(format!("parsing logs {}", loading_icon))
                 .style(Style::default())
                 .block(block)
                 .alignment(Alignment::Center);
             f.render_widget(paragraph, area);
-    } else if let Some(index) = index {
+        }
+
+        _ => {
+            if let Some(index) = index {
                 let items = app_data.lock().containers.items[index]
                     .logs
                     .items
@@ -246,6 +250,9 @@ pub fn logs<B: Backend>(
                     .block(block)
                     .alignment(Alignment::Center);
                 f.render_widget(paragraph, area);
+                // }
+            }
+        }
     }
 }
 
@@ -349,7 +356,7 @@ pub fn heading_bar<B: Backend>(
     gui_state: &Arc<Mutex<GuiState>>,
 ) {
     let block = |fg: Color| Block::default().style(Style::default().bg(Color::Magenta).fg(fg));
-    let info_visible = gui_state.lock().show_help;
+    let info_visible = gui_state.lock().get_status() == Status::Help;
 
     f.render_widget(block(Color::Black), area);
 
@@ -430,7 +437,12 @@ pub fn heading_bar<B: Backend>(
         .collect::<Vec<_>>();
 
     let suffix = if info_visible { "exit" } else { "show" };
-    let info_text = format!("( h ) {} help {}", suffix, MARGIN);
+    let info_text = format!(
+        "( h ) {} help {} {:?}",
+        suffix,
+        MARGIN,
+        gui_state.lock().get_status()
+    );
     let info_width = info_text.chars().count();
 
     let column_width = usize::from(area.width) - info_width;
@@ -457,8 +469,6 @@ pub fn heading_bar<B: Backend>(
             .alignment(Alignment::Center);
         f.render_widget(loading_paragraph, split_bar[0]);
 
-
-
         let container_splits = header_data.iter().map(|i| i.2).collect::<Vec<_>>();
         let headers_section = Layout::default()
             .direction(Direction::Horizontal)

src/ui/gui_state.rs

@@ -173,6 +173,17 @@ impl fmt::Display for Loading {
     }
 }
 
+/// The application can be in these four states
+/// Various functions (e.g input handler), operate differently depending upon current Status
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub enum Status {
+    Init,
+    Help,
+    DockerConnect,
+    Error,
+    Normal,
+}
+
 /// Global gui_state, stored in an Arc<Mutex>
 #[derive(Debug, Clone)]
 pub struct GuiState {
@@ -180,8 +191,8 @@ pub struct GuiState {
     heading_map: HashMap<Header, Rect>,
     loading_icon: Loading,
     is_loading: HashSet<Uuid>,
+    status: Status,
     pub selected_panel: SelectablePanel,
-    pub show_help: bool,
     pub info_box_text: Option<String>,
 }
 impl GuiState {
@@ -192,9 +203,9 @@ impl GuiState {
             heading_map: HashMap::new(),
             loading_icon: Loading::One,
             selected_panel: SelectablePanel::Containers,
-            show_help: false,
             is_loading: HashSet::new(),
             info_box_text: None,
+            status: Status::Init,
         }
     }
 
@@ -242,6 +253,14 @@ impl GuiState {
         };
     }
 
+    pub fn set_status(&mut self, status: Status) {
+        self.status = status
+    }
+
+    pub fn get_status(&self) -> Status {
+        self.status
+    }
+
     /// Change to next selectable panel
     pub fn next_panel(&mut self) {
         self.selected_panel = self.selected_panel.next();

src/ui/mod.rs

@@ -25,7 +25,7 @@ mod draw_blocks;
 mod gui_state;
 
 pub use self::color_match::*;
-pub use self::gui_state::{GuiState, SelectablePanel};
+pub use self::gui_state::{GuiState, SelectablePanel, Status};
 use crate::{
     app_data::AppData, app_error::AppError, docker_data::DockerMessage,
     input_handler::InputMessages,
@@ -85,8 +85,9 @@ async fn run_app<B: Backend + Send>(
     let input_poll_rate = std::time::Duration::from_millis(75);
 
     // Check for docker connect errors before attempting to draw the gui
-    let e = app_data.lock().get_error();
-    if let Some(AppError::DockerConnect) = e {
+    let status = gui_state.lock().get_status();
+
+    if status == Status::DockerConnect {
         let mut seconds = 5;
         loop {
             if seconds < 1 {
@@ -138,6 +139,7 @@ async fn run_app<B: Backend + Send>(
                 break;
             }
         }
+        // }
     }
     Ok(())
 }
@@ -157,7 +159,7 @@ fn ui<B: Backend>(
     let log_index = app_data.lock().get_selected_log_index();
     let sorted_by = app_data.lock().get_sorted();
 
-    let show_help = gui_state.lock().show_help;
+    let show_help = gui_state.lock().get_status() == Status::Help;
     let info_text = gui_state.lock().info_box_text.clone();
     let loading_icon = gui_state.lock().get_loading();
 
@@ -241,7 +243,6 @@ fn ui<B: Backend>(
     }
 
     if let Some(error) = has_error {
-        app_data.lock().show_error = true;
         draw_blocks::error(f, error, None);
     }
 }