Move LoopData into niri file

4 files changed, 68 insertions, 76 deletions

diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index 63256821..e5ee4551 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -31,15 +31,15 @@ use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
 use smithay_drm_extras::edid::EdidInfo;
 
 use crate::input::{BackendAction, CompositorMod};
-use crate::niri::OutputRenderElements;
-use crate::{LoopData, Niri};
+use crate::niri::{Data, OutputRenderElements};
+use crate::Niri;
 
 const BACKGROUND_COLOR: [f32; 4] = [0.1, 0.1, 0.1, 1.];
 const SUPPORTED_COLOR_FORMATS: &[Fourcc] = &[Fourcc::Argb8888, Fourcc::Abgr8888];
 
 pub struct Tty {
     session: LibSeatSession,
-    udev_dispatcher: Dispatcher<'static, UdevBackend, LoopData>,
+    udev_dispatcher: Dispatcher<'static, UdevBackend, Data>,
     primary_gpu_path: PathBuf,
     output_device: Option<OutputDevice>,
 }
@@ -69,45 +69,44 @@ struct TtyOutputState {
 }
 
 impl Tty {
-    pub fn new(event_loop: LoopHandle<'static, LoopData>) -> Self {
+    pub fn new(event_loop: LoopHandle<'static, Data>) -> 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.backend.tty().unwrap();
-                let niri = &mut data.niri;
-
-                match event {
-                    UdevEvent::Added { device_id, path } => {
-                        if !tty.session.is_active() {
-                            debug!("skipping UdevEvent::Added as session is inactive");
-                            return;
-                        }
+        let udev_dispatcher = Dispatcher::new(udev_backend, move |event, _, data: &mut Data| {
+            let tty = data.backend.tty().unwrap();
+            let niri = &mut data.niri;
 
-                        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();
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 35bf3407..74485469 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -13,9 +13,9 @@ use smithay::reexports::winit::window::WindowBuilder;
 use smithay::utils::Transform;
 
 use crate::input::{BackendAction, CompositorMod};
-use crate::niri::OutputRenderElements;
+use crate::niri::{Data, OutputRenderElements};
 use crate::utils::get_monotonic_time;
-use crate::{LoopData, Niri};
+use crate::Niri;
 
 pub struct Winit {
     output: Output,
@@ -25,7 +25,7 @@ pub struct Winit {
 }
 
 impl Winit {
-    pub fn new(event_loop: LoopHandle<LoopData>) -> Self {
+    pub fn new(event_loop: LoopHandle<Data>) -> Self {
         let builder = WindowBuilder::new()
             .with_inner_size(LogicalSize::new(1280.0, 800.0))
             // .with_resizable(false)
diff --git a/src/main.rs b/src/main.rs
index 2e77fd42..c5912c6f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -15,11 +15,9 @@ mod utils;
 use std::env;
 use std::ffi::OsString;
 
-use backend::{Backend, Tty, Winit};
 use clap::Parser;
-use niri::Niri;
+use niri::{Data, Niri};
 use smithay::reexports::calloop::EventLoop;
-use smithay::reexports::wayland_server::Display;
 use tracing_subscriber::EnvFilter;
 
 #[derive(Parser)]
@@ -30,15 +28,6 @@ struct Cli {
     command: Vec<OsString>,
 }
 
-pub struct LoopData {
-    niri: Niri,
-    backend: Backend,
-
-    // Last so that it's dropped after the Smithay state in Niri and related state in Tty.
-    // Otherwise it will segfault on quit.
-    display: Display<Niri>,
-}
-
 fn main() {
     env::set_var("RUST_BACKTRACE", "1");
 
@@ -54,31 +43,7 @@ fn main() {
     let _client = tracy_client::Client::start();
 
     let mut event_loop = EventLoop::try_new().unwrap();
-
-    let has_display = env::var_os("WAYLAND_DISPLAY").is_some() || env::var_os("DISPLAY").is_some();
-
-    let backend = if has_display {
-        Backend::Winit(Winit::new(event_loop.handle()))
-    } else {
-        Backend::Tty(Tty::new(event_loop.handle()))
-    };
-
-    let mut display = Display::new().unwrap();
-    let niri = Niri::new(
-        event_loop.handle(),
-        event_loop.get_signal(),
-        &mut display,
-        backend.seat_name(),
-    );
-
-    let mut data = LoopData {
-        niri,
-        display,
-
-        backend,
-    };
-
-    data.backend.init(&mut data.niri);
+    let mut data = Data::new(event_loop.handle(), event_loop.get_signal());
 
     if let Some((command, args)) = cli.command.split_first() {
         if let Err(err) = std::process::Command::new(command).args(args).spawn() {
diff --git a/src/niri.rs b/src/niri.rs
index 25fd3bc9..adc97b1e 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -2,8 +2,8 @@ use std::collections::HashMap;
 use std::os::unix::io::AsRawFd;
 use std::process::Command;
 use std::sync::{Arc, Mutex};
-use std::thread;
 use std::time::Duration;
+use std::{env, thread};
 
 use anyhow::Context;
 use directories::UserDirs;
@@ -53,16 +53,15 @@ use smithay::wayland::socket::ListeningSocketSource;
 use smithay::wayland::tablet_manager::TabletManagerState;
 use time::OffsetDateTime;
 
-use crate::backend::Backend;
+use crate::backend::{Backend, Tty, Winit};
 use crate::dbus::mutter_service_channel::ServiceChannel;
 use crate::frame_clock::FrameClock;
 use crate::layout::{MonitorRenderElement, MonitorSet};
 use crate::utils::{center, get_monotonic_time, load_default_cursor};
-use crate::LoopData;
 
 pub struct Niri {
     pub start_time: std::time::Instant,
-    pub event_loop: LoopHandle<'static, LoopData>,
+    pub event_loop: LoopHandle<'static, Data>,
     pub stop_signal: LoopSignal,
     pub display_handle: DisplayHandle,
 
@@ -113,9 +112,38 @@ pub struct OutputState {
     pub frame_clock: FrameClock,
 }
 
+pub struct Data {
+    pub display: Display<Niri>,
+    pub backend: Backend,
+    pub niri: Niri,
+}
+
+impl Data {
+    pub fn new(event_loop: LoopHandle<'static, Self>, stop_signal: LoopSignal) -> Self {
+        let has_display =
+            env::var_os("WAYLAND_DISPLAY").is_some() || env::var_os("DISPLAY").is_some();
+
+        let mut backend = if has_display {
+            Backend::Winit(Winit::new(event_loop.clone()))
+        } else {
+            Backend::Tty(Tty::new(event_loop.clone()))
+        };
+
+        let mut display = Display::new().unwrap();
+        let mut niri = Niri::new(event_loop, stop_signal, &mut display, backend.seat_name());
+        backend.init(&mut niri);
+
+        Self {
+            display,
+            backend,
+            niri,
+        }
+    }
+}
+
 impl Niri {
     pub fn new(
-        event_loop: LoopHandle<'static, LoopData>,
+        event_loop: LoopHandle<'static, Data>,
         stop_signal: LoopSignal,
         display: &mut Display<Self>,
         seat_name: String,