use mutex instead of msg passing between input and render threads

src/engine.rs

@@ -25,111 +25,109 @@ pub enum Event {
 }
 
 pub struct Engine {
-    stdout:       Stdout,
     exited:       Arc<AtomicBool>,
     sender:       Sender<Event>,
     receiver:     Receiver<Event>,
-    input_thread: JoinHandle<()>,
     pub jack_client: Jack<Notifications>,
 }
 
+pub fn jack_client <N: NotificationHandler + Sync + 'static> (
+    name: &str,
+    notifications: N,
+    handler: BoxedProcessHandler
+) -> Result<Jack<N>, Box<dyn Error>> {
+    let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
+    Ok(client.activate_async(notifications, ClosureProcessHandler::new(handler))?)
+}
+
 impl Engine {
 
     pub fn new (name: Option<&str>) -> Result<Self, Box<dyn Error>> {
         let (sender, receiver) = mpsc::channel::<self::Event>();
         let exited = Arc::new(AtomicBool::new(false));
-
-        let jack_client = {
-            let sender = sender.clone();
-            let exited = exited.clone();
-            let (client, _status) = Client::new(
+        Ok(Self {
+            jack_client: jack_client(
                 name.unwrap_or("blinkenlive"),
-                ClientOptions::NO_START_SERVER
-            )?;
-            let handler = ClosureProcessHandler::new(
-                Box::new(move |_client: &Client, _ps: &ProcessScope| -> Control {
-                    if exited.fetch_and(true, Ordering::Relaxed) {
-                        Control::Quit
-                    } else {
-                        sender.send(Event::Update).unwrap();
-                        Control::Continue
-                    }
-                }) as BoxedProcessHandler
-            );
+                Notifications(sender.clone()),
+                Box::new({
+                    let sender = sender.clone();
+                    let exited = exited.clone();
+                    move |_client: &Client, _ps: &ProcessScope| -> Control {
+                        if exited.fetch_and(true, Ordering::Relaxed) {
+                            Control::Quit
+                        } else {
+                            sender.send(Event::Update).unwrap();
+                            Control::Continue
+                        }
+                    }}))?,
+            exited,
+            sender,
+            receiver,
+        })
+    }
 
-            client.activate_async(Notifications, handler)?
-        };
+    pub fn run <T: Exitable + WidgetRef + HandleInput + Send + 'static> (
+        &mut self, mut state: T,
+    ) -> Result<(), Box<dyn Error>> {
+
+        let state = Arc::new(Mutex::new(state));
 
         let input_thread = {
-            let sender = sender.clone();
-            let exited = exited.clone();
+            let state  = state.clone();
+            let sender = self.sender.clone();
+            let exited = self.exited.clone();
             let poll = std::time::Duration::from_millis(100);
-            spawn(move || {
-                loop {
-                    // Exit if flag is set
-                    if exited.fetch_and(true, Ordering::Relaxed) {
+            spawn(move || loop {
+                // Exit if flag is set
+                if exited.fetch_and(true, Ordering::Relaxed) {
+                    break
+                }
+                // Listen for events and send them to the main thread
+                if event::poll(poll).is_ok() {
+                    let event = event::read().unwrap();
+                    let mut state = state.lock().unwrap();
+                    if state.handle(&Event::Input(event)).is_err() {
                         break
                     }
-                    // Listen for events and send them to the main thread
-                    if event::poll(poll).is_ok() {
-                        let event = event::read().unwrap();
-                        if sender.send(Event::Input(event)).is_err() {
-                            break
-                        }
-                    }
                 }
             })
         };
 
-        Ok(Self {
-            stdout: stdout(),
-            exited,
-            sender,
-            receiver,
-            jack_client,
-            input_thread,
-        })
-    }
+        let render_thread = {
+            stdout().queue(EnterAlternateScreen)?.flush()?;
+            enable_raw_mode()?;
+            let mut terminal = ratatui::Terminal::new(CrosstermBackend::new(stdout()))?;
+            let sleep = std::time::Duration::from_millis(16);
+            let exited = self.exited.clone();
+            spawn(move || loop {
+                terminal.draw(|frame|{
+                    let area = frame.size();
+                    frame.render_widget(
+                        &*state.lock().unwrap(),
+                        area
+                    );
+                });
+                if state.lock().unwrap().exited() {
+                    exited.store(true, Ordering::Relaxed);
+                    break
+                }
+                std::thread::sleep(sleep);
+            })
+        };
+
+        render_thread.join();
+
+        stdout()
+            .queue(crossterm::terminal::LeaveAlternateScreen)?
+            .flush()?;
+        crossterm::terminal::disable_raw_mode()?;
 
-    pub fn run <T: Exitable + WidgetRef + HandleInput> (
-        &mut self, mut state: T,
-    ) -> Result<(), Box<dyn Error>> {
-        stdout().queue(EnterAlternateScreen)?.flush();
-        enable_raw_mode()?;
-        let mut terminal = ratatui::Terminal::new(CrosstermBackend::new(stdout()))?;
-        let sleep = std::time::Duration::from_millis(20);
-        loop {
-            //stdout()
-                //.queue(crossterm::terminal::BeginSynchronizedUpdate)?
-                //.queue(Clear(ClearType::All))?;
-            terminal.draw(|frame|{
-                let area = frame.size();
-                frame.render_widget(&state, area);
-            });
-            //render(state, stdout, (0, 0))?;
-            //stdout()
-                //.queue(crossterm::terminal::EndSynchronizedUpdate)?
-                //.flush()?;
-            // Handle event if present (`None` redraws)
-            if let event = self.receiver.recv()? {
-                state.handle(&event)?;
-            }
-            if state.exited() {
-                self.exited.store(true, Ordering::Relaxed);
-                stdout()
-                    .queue(crossterm::terminal::LeaveAlternateScreen)?
-                    .flush()?;
-                crossterm::terminal::disable_raw_mode()?;
-                break
-            }
-            //std::thread::sleep(sleep);
-        }
         Ok(())
     }
 
 }
 
-pub struct Notifications;
+pub struct Notifications(mpsc::Sender<self::Event>);
 
 impl NotificationHandler for Notifications {
     fn thread_init (&self, _: &Client) {