Chatgippity was wrong

Author: suchmememanyskill

moonraker-rs/src/moonraker_connection.rs

@@ -469,10 +469,10 @@ impl MoonrakerConnection
             .unwrap();
 
         // Moonraker -> us. TX = ws event bus, RX = misc listeners
-        let (inbound_event_sender, inbound_event_listener) = broadcast::channel::<Arc<GeneralEvent>>(256);
+        let (inbound_event_sender, inbound_event_listener) = broadcast::channel::<Arc<GeneralEvent>>(20);
 
         // Us -> Moonraker. TX = send requests, RX = ws writer
-        let (outbound_event_sender, outbound_event_listener) = broadcast::channel::<Arc<SendingEvent>>(256);
+        let (outbound_event_sender, outbound_event_listener) = broadcast::channel::<Arc<SendingEvent>>(20);
 
         MoonrakerConnection {
             host: host,

src/hardware/framebuffer_platform.rs

@@ -3,7 +3,7 @@
 use std::{cell::RefCell, rc::Rc, sync::{Arc, Mutex}, time::{Duration, Instant}, collections::VecDeque};
 use evdev::Device;
 use linuxfb::{double::Buffer, Framebuffer};
-use slint::{platform::{software_renderer::{MinimalSoftwareWindow, PremultipliedRgbaColor, RepaintBufferType, Rgb565Pixel, TargetPixel}, Platform, WindowEvent}, PhysicalSize, Rgb8Pixel};
+use slint::{platform::{software_renderer::{MinimalSoftwareWindow, PremultipliedRgbaColor, RepaintBufferType, Rgb565Pixel, TargetPixel}, EventLoopProxy, Platform, WindowEvent}, EventLoopError, PhysicalSize, PlatformError, Rgb8Pixel};
 
 use crate::hardware::EvdevMtTouchPlatform;
 
@@ -20,8 +20,7 @@ pub struct FramebufferPlatform {
     stride: usize,
     bytes_per_pixel: usize,
     touch_device: Option<Box<dyn TouchPlatform>>,
-    event_queue: Arc<Mutex<VecDeque<Box<dyn FnOnce() + Send>>>>,
-    quit_requested: Arc<Mutex<bool>>,
+    queue: Option<Queue>,
 }
 
 impl FramebufferPlatform {
@@ -58,8 +57,7 @@ impl FramebufferPlatform {
             stride: size.0 as usize,
             bytes_per_pixel: bytes_per_pixel as usize,
             touch_device: mutex_touch_device,
-            event_queue: Arc::new(Mutex::new(VecDeque::new())),
-            quit_requested: Arc::new(Mutex::new(false)),
+            queue: Some(Queue(Default::default(), std::thread::current())),
         }
     }
 }
@@ -91,71 +89,36 @@ impl TargetPixel for PremultipliedAbgrColor {
     }
 }
 
-struct FramebufferEventLoopProxy {
-    event_queue: Arc<Mutex<VecDeque<Box<dyn FnOnce() + Send>>>>,
-    quit_requested: Arc<Mutex<bool>>,
-}
-
-impl FramebufferEventLoopProxy {
-    fn new(event_queue: Arc<Mutex<VecDeque<Box<dyn FnOnce() + Send>>>>, quit_requested: Arc<Mutex<bool>>) -> Self {
-        Self { event_queue, quit_requested }
-    }
-}
-
-impl slint::platform::EventLoopProxy for FramebufferEventLoopProxy {
-    fn quit_event_loop(&self) -> Result<(), slint::EventLoopError> {
-        if let Ok(mut quit_flag) = self.quit_requested.lock() {
-            *quit_flag = true;
-            Ok(())
-        } else {
-            Err(slint::EventLoopError::EventLoopTerminated)
-        }
-    }
-
-    fn invoke_from_event_loop(
-        &self,
-        event: Box<dyn FnOnce() + Send>,
-    ) -> Result<(), slint::EventLoopError> {
-        if let Ok(mut queue) = self.event_queue.lock() {
-            queue.push_back(event);
-            Ok(())
-        } else {
-            Err(slint::EventLoopError::EventLoopTerminated)
-        }
-    }
-}
-
 impl Platform for FramebufferPlatform {
     fn create_window_adapter(&self) -> Result<Rc<dyn slint::platform::WindowAdapter>, slint::PlatformError> {
         Ok(self.window.clone())
     }
 
     fn new_event_loop_proxy(&self) -> Option<Box<dyn slint::platform::EventLoopProxy>> {
-        Some(Box::new(FramebufferEventLoopProxy::new(
-            self.event_queue.clone(),
-            self.quit_requested.clone()
-        )))
+        self.queue
+            .as_ref()
+            .map(|q| Box::new(q.clone()) as Box<dyn EventLoopProxy>)
     }
 
     fn run_event_loop(&self) -> Result<(), slint::PlatformError> {
         let mut fb = self.fb.borrow_mut();
-        loop {
-            // Check for quit request
-            if let Ok(quit_flag) = self.quit_requested.lock() {
-                if *quit_flag {
-                    break;
-                }
-            }
 
-            // Process queued events from other threads
-            if let Ok(mut queue) = self.event_queue.lock() {
-                while let Some(event) = queue.pop_front() {
-                    event();
-                }
-            }
+        let queue = match self.queue.as_ref() {
+            Some(queue) => queue.clone(),
+            None => return Err(PlatformError::NoEventLoopProvider),
+        };
 
+        loop {
             slint::platform::update_timers_and_animations();
 
+            let e = queue.0.lock().unwrap().pop_front();
+
+            match e {
+                Some(Event::Quit) => break,
+                Some(Event::Event(event)) => event(),
+                None => {}
+            }
+
             if let Some(touch_device) = &self.touch_device
             {
                 let now = Instant::now();
@@ -164,8 +127,8 @@ impl Platform for FramebufferPlatform {
 
                 for event in events
                 {
-                    println!("Got event {:?}", event);
-                    println!("Elapsed: {:.2?}", elapsed);
+                    //println!("Got event {:?}", event);
+                    //println!("Elapsed: {:.2?}", elapsed);
                     self.window.try_dispatch_event(event).unwrap();
                 }
             }
@@ -190,9 +153,37 @@ impl Platform for FramebufferPlatform {
             });
 
             if !self.window.has_active_animations() {
-                std::thread::sleep(slint::platform::duration_until_next_timer_update().unwrap_or(Duration::from_millis(100)));
+                std::thread::park_timeout(slint::platform::duration_until_next_timer_update().unwrap_or(Duration::from_millis(20)));
             }
         }
         Ok(())
     }
+}
+
+enum Event {
+    Quit,
+    Event(Box<dyn FnOnce() + Send>),
+}
+
+#[derive(Clone)]
+struct Queue(
+    std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<Event>>>,
+    std::thread::Thread,
+);
+
+impl EventLoopProxy for Queue {
+    fn quit_event_loop(&self) -> Result<(), EventLoopError> {
+        self.0.lock().unwrap().push_back(Event::Quit);
+        self.1.unpark();
+        Ok(())
+    }
+
+    fn invoke_from_event_loop(
+        &self,
+        event: Box<dyn FnOnce() + Send>,
+    ) -> Result<(), EventLoopError> {
+        self.0.lock().unwrap().push_back(Event::Event(event));
+        self.1.unpark();
+        Ok(())
+    }
 }