wip: mouse capture errors

src/main.rs

@@ -1,20 +1,20 @@
 #![forbid(unsafe_code)]
-#![warn(
-	clippy::nursery,
-	clippy::pedantic,
-    clippy::expect_used,
-    clippy::todo,
-    clippy::unused_async,
-    clippy::unwrap_used
-)]
-// Warning - These are indeed pedantic
-#![allow(
-    clippy::module_name_repetitions,
-    clippy::doc_markdown,
-    clippy::similar_names
-)]
+// #![warn(
+//     clippy::nursery,
+//     clippy::pedantic,
+//     clippy::expect_used,
+//     clippy::todo,
+//     clippy::unused_async,
+//     clippy::unwrap_used
+// )]
+// // Warning - These are indeed pedantic
+// #![allow(
+//     clippy::module_name_repetitions,
+//     clippy::doc_markdown,
+//     clippy::similar_names
+// )]
 // Only allow when debugging
-// #![allow(unused)]
+#![allow(unused)]
 
 use app_data::AppData;
 use app_error::AppError;
@@ -23,7 +23,10 @@ use docker_data::DockerData;
 use input_handler::InputMessages;
 use parking_lot::Mutex;
 use parse_args::CliArgs;
-use std::{sync::{atomic::AtomicBool, Arc}, io::Write};
+use std::{
+    io::Write,
+    sync::{atomic::AtomicBool, Arc},
+};
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::{info, Level};
 
@@ -146,6 +149,7 @@ async fn main() {
             .await;
         }
     }
-	// Clear screen
-	std::io::stdout().flush().unwrap_or(());
+    // Clear screen
+    // std::io::stdout().lock().flush().unwrap_or(());
+    // std::io::stdout().lock().write(b"").unwrap_or_default();
 }

src/ui/mod.rs

@@ -6,7 +6,7 @@ use crossterm::{
 };
 use parking_lot::Mutex;
 use std::{
-    io,
+    io::{self, Write},
     sync::{atomic::Ordering, Arc},
 };
 use std::{sync::atomic::AtomicBool, time::Instant};
@@ -38,11 +38,12 @@ pub async fn create_ui(
 ) -> Result<()> {
     enable_raw_mode()?;
     let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    // EnableMouseCapture
+    execute!(stdout, EnableMouseCapture, EnterAlternateScreen)?;
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
-    let res = run_app(
+    run_app(
         app_data,
         docker_sx,
         gui_state,
@@ -50,7 +51,8 @@ pub async fn create_ui(
         sender,
         &mut terminal,
     )
-    .await;
+    .await
+    .unwrap_or(());
     disable_raw_mode()?;
     execute!(
         terminal.backend_mut(),
@@ -59,8 +61,39 @@ pub async fn create_ui(
     )?;
     terminal.show_cursor()?;
 
-    if let Err(err) = res {
-        println!("error: {err}");
+    // if let Err(err) = res {
+        // println!("error: {err}");
+    // }
+    std::io::stdout().flush().unwrap_or(());
+    Ok(())
+}
+
+/// Display error message for 5 seconds, with countdown
+fn err_loop<B: Backend + Send>(
+    now: &mut Instant,
+    terminal: &mut Terminal<B>,
+) -> Result<(), AppError> {
+    let mut seconds = 5;
+    loop {
+        if seconds < 1 {
+            // terminal.clear().unwrap_or(());
+            break;
+        }
+
+        if now.elapsed() >= std::time::Duration::from_secs(1) {
+            seconds -= 1;
+            *now = Instant::now();
+        }
+
+        terminal
+            .draw(|f| draw_blocks::error(f, AppError::DockerConnect, Some(seconds)))
+            .unwrap();
+        // {
+        // return Err(AppError::Terminal);
+        // }
+        // terminal
+        // .draw(|f| draw_blocks::error(f, AppError::DockerConnect, Some(seconds)))
+        // .unwrap();
     }
     Ok(())
 }
@@ -79,23 +112,9 @@ async fn run_app<B: Backend + Send>(
     let input_poll_rate = std::time::Duration::from_millis(75);
     let status_dockerconnect = gui_state.lock().status_contains(&[Status::DockerConnect]);
     let mut now = Instant::now();
-    if status_dockerconnect {
-        let mut seconds = 5;
-        loop {
-            if seconds < 1 {
-                break;
-            }
-            if now.elapsed() >= std::time::Duration::from_secs(1) {
-                seconds -= 1;
-                now = Instant::now();
-            }
-            if terminal
-                .draw(|f| draw_blocks::error(f, AppError::DockerConnect, Some(seconds)))
-                .is_err()
-            {
-                return Err(AppError::Terminal);
-            }
-        }
+
+    if !status_dockerconnect {
+        err_loop(&mut now, terminal).unwrap_or(());
     } else {
         while is_running.load(Ordering::SeqCst) {
             if crossterm::event::poll(input_poll_rate).unwrap_or(false) {
@@ -126,7 +145,7 @@ async fn run_app<B: Backend + Send>(
             }
         }
     }
-    terminal.clear().unwrap_or(());
+
     Ok(())
 }