Remove LoopData

The calloop Smithay update finally lets me do this.

2 files changed, 51 insertions, 56 deletions

diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index bce16ff0..c9ba9b6a 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -39,7 +39,7 @@ use smithay_drm_extras::edid::EdidInfo;
 use crate::config::Config;
 use crate::niri::{OutputRenderElements, State};
 use crate::utils::get_monotonic_time;
-use crate::{LoopData, Niri};
+use crate::Niri;
 
 const BACKGROUND_COLOR: [f32; 4] = [0.1, 0.1, 0.1, 1.];
 const SUPPORTED_COLOR_FORMATS: &[Fourcc] = &[Fourcc::Argb8888, Fourcc::Abgr8888];
@@ -47,7 +47,7 @@ const SUPPORTED_COLOR_FORMATS: &[Fourcc] = &[Fourcc::Argb8888, Fourcc::Abgr8888]
 pub struct Tty {
     config: Rc<RefCell<Config>>,
     session: LibSeatSession,
-    udev_dispatcher: Dispatcher<'static, UdevBackend, LoopData>,
+    udev_dispatcher: Dispatcher<'static, UdevBackend, State>,
     primary_gpu_path: PathBuf,
     output_device: Option<OutputDevice>,
     connectors: Arc<Mutex<HashMap<String, Output>>>,
@@ -94,45 +94,44 @@ struct Surface {
 }
 
 impl Tty {
-    pub fn new(config: Rc<RefCell<Config>>, event_loop: LoopHandle<'static, LoopData>) -> Self {
+    pub fn new(config: Rc<RefCell<Config>>, event_loop: LoopHandle<'static, State>) -> Self {
         let (session, notifier) = LibSeatSession::new().unwrap();
         let seat_name = session.seat();
 
         let udev_backend = UdevBackend::new(session.seat()).unwrap();
-        let udev_dispatcher =
-            Dispatcher::new(udev_backend, move |event, _, data: &mut LoopData| {
-                let tty = data.state.backend.tty();
-                let niri = &mut data.state.niri;
+        let udev_dispatcher = Dispatcher::new(udev_backend, move |event, _, state: &mut State| {
+            let tty = state.backend.tty();
+            let niri = &mut state.niri;
 
-                match event {
-                    UdevEvent::Added { device_id, path } => {
-                        if !tty.session.is_active() {
-                            debug!("skipping UdevEvent::Added as session is inactive");
-                            return;
-                        }
-
-                        if let Err(err) = tty.device_added(device_id, &path, niri) {
-                            warn!("error adding device: {err:?}");
-                        }
+            match event {
+                UdevEvent::Added { device_id, path } => {
+                    if !tty.session.is_active() {
+                        debug!("skipping UdevEvent::Added as session is inactive");
+                        return;
                     }
-                    UdevEvent::Changed { device_id } => {
-                        if !tty.session.is_active() {
-                            debug!("skipping UdevEvent::Changed as session is inactive");
-                            return;
-                        }
 
-                        tty.device_changed(device_id, niri)
+                    if let Err(err) = tty.device_added(device_id, &path, niri) {
+                        warn!("error adding device: {err:?}");
+                    }
+                }
+                UdevEvent::Changed { device_id } => {
+                    if !tty.session.is_active() {
+                        debug!("skipping UdevEvent::Changed as session is inactive");
+                        return;
                     }
-                    UdevEvent::Removed { device_id } => {
-                        if !tty.session.is_active() {
-                            debug!("skipping UdevEvent::Removed as session is inactive");
-                            return;
-                        }
 
-                        tty.device_removed(device_id, niri)
+                    tty.device_changed(device_id, niri)
+                }
+                UdevEvent::Removed { device_id } => {
+                    if !tty.session.is_active() {
+                        debug!("skipping UdevEvent::Removed as session is inactive");
+                        return;
                     }
+
+                    tty.device_removed(device_id, niri)
                 }
-            });
+            }
+        });
         event_loop
             .register_dispatcher(udev_dispatcher.clone())
             .unwrap();
@@ -142,17 +141,17 @@ impl Tty {
 
         let input_backend = LibinputInputBackend::new(libinput.clone());
         event_loop
-            .insert_source(input_backend, |mut event, _, data| {
-                data.state.process_libinput_event(&mut event);
-                data.state.process_input_event(event);
+            .insert_source(input_backend, |mut event, _, state| {
+                state.process_libinput_event(&mut event);
+                state.process_input_event(event);
             })
             .unwrap();
 
         let udev_dispatcher_c = udev_dispatcher.clone();
         event_loop
-            .insert_source(notifier, move |event, _, data| {
-                let tty = data.state.backend.tty();
-                let niri = &mut data.state.niri;
+            .insert_source(notifier, move |event, _, state| {
+                let tty = state.backend.tty();
+                let niri = &mut state.niri;
 
                 match event {
                     SessionEvent::PauseSession => {
@@ -303,8 +302,8 @@ impl Tty {
 
         let token = niri
             .event_loop
-            .insert_source(drm_notifier, move |event, metadata, data| {
-                let tty = data.state.backend.tty();
+            .insert_source(drm_notifier, move |event, metadata, state| {
+                let tty = state.backend.tty();
                 match event {
                     DrmEvent::VBlank(crtc) => {
                         let now = get_monotonic_time();
@@ -349,8 +348,7 @@ impl Tty {
                             .unwrap()
                             .message(&message, 0);
 
-                        let output = data
-                            .state
+                        let output = state
                             .niri
                             .global_space
                             .outputs()
@@ -360,7 +358,7 @@ impl Tty {
                             })
                             .unwrap()
                             .clone();
-                        let output_state = data.state.niri.output_state.get_mut(&output).unwrap();
+                        let output_state = state.niri.output_state.get_mut(&output).unwrap();
 
                         // Mark the last frame as submitted.
                         match surface.compositor.frame_submitted() {
@@ -398,7 +396,7 @@ impl Tty {
 
                         output_state.waiting_for_vblank = false;
                         output_state.frame_clock.presented(presentation_time);
-                        data.state.niri.queue_redraw(output);
+                        state.niri.queue_redraw(output);
                     }
                     DrmEvent::Error(error) => error!("DRM error: {error}"),
                 };
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 99cfe7db..e0fbf272 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -18,9 +18,9 @@ use smithay::utils::Transform;
 use smithay::wayland::dmabuf::DmabufFeedback;
 
 use crate::config::Config;
-use crate::niri::OutputRenderElements;
+use crate::niri::{OutputRenderElements, State};
 use crate::utils::get_monotonic_time;
-use crate::{LoopData, Niri};
+use crate::Niri;
 
 pub struct Winit {
     config: Rc<RefCell<Config>>,
@@ -31,7 +31,7 @@ pub struct Winit {
 }
 
 impl Winit {
-    pub fn new(config: Rc<RefCell<Config>>, event_loop: LoopHandle<LoopData>) -> Self {
+    pub fn new(config: Rc<RefCell<Config>>, event_loop: LoopHandle<State>) -> Self {
         let builder = WindowBuilder::new()
             .with_inner_size(LogicalSize::new(1280.0, 800.0))
             // .with_resizable(false)
@@ -79,10 +79,10 @@ impl Winit {
 
         let timer = Timer::immediate();
         event_loop
-            .insert_source(timer, move |_, _, data| {
+            .insert_source(timer, move |_, _, state| {
                 let res = winit_event_loop.dispatch_new_events(|event| match event {
                     WinitEvent::Resized { size, .. } => {
-                        let winit = data.state.backend.winit();
+                        let winit = state.backend.winit();
                         winit.output.change_current_state(
                             Some(Mode {
                                 size,
@@ -92,24 +92,21 @@ impl Winit {
                             None,
                             None,
                         );
-                        data.state.niri.output_resized(winit.output.clone());
+                        state.niri.output_resized(winit.output.clone());
                     }
-                    WinitEvent::Input(event) => data.state.process_input_event(event),
+                    WinitEvent::Input(event) => state.process_input_event(event),
                     WinitEvent::Focus(_) => (),
-                    WinitEvent::Refresh => data
-                        .state
+                    WinitEvent::Refresh => state
                         .niri
-                        .queue_redraw(data.state.backend.winit().output.clone()),
+                        .queue_redraw(state.backend.winit().output.clone()),
                 });
 
                 // I want this to stop compiling if more errors are added.
                 #[allow(clippy::single_match)]
                 match res {
                     Err(WinitError::WindowClosed) => {
-                        data.state.niri.stop_signal.stop();
-                        data.state
-                            .niri
-                            .remove_output(&data.state.backend.winit().output);
+                        state.niri.stop_signal.stop();
+                        state.niri.remove_output(&state.backend.winit().output);
                     }
                     Ok(()) => (),
                 }