Move all traits one layer up

3 files changed, 132 insertions, 132 deletions

diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index 5c0f62a5..d70ee2aa 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -1,6 +1,7 @@
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::output::Output;
 
+use crate::input::CompositorMod;
 use crate::niri::OutputRenderElements;
 use crate::Niri;
 
@@ -49,19 +50,47 @@ impl Backend {
         }
     }
 
-    pub fn tty(&mut self) -> Option<&mut Tty> {
+    pub fn mod_key(&self) -> CompositorMod {
+        match self {
+            Backend::Tty(_) => CompositorMod::Super,
+            Backend::Winit(_) => CompositorMod::Alt,
+        }
+    }
+
+    pub fn change_vt(&mut self, vt: i32) {
+        match self {
+            Backend::Tty(tty) => tty.change_vt(vt),
+            Backend::Winit(_) => (),
+        }
+    }
+
+    pub fn suspend(&mut self) {
+        match self {
+            Backend::Tty(tty) => tty.suspend(),
+            Backend::Winit(_) => (),
+        }
+    }
+
+    pub fn toggle_debug_tint(&mut self) {
+        match self {
+            Backend::Tty(tty) => tty.toggle_debug_tint(),
+            Backend::Winit(winit) => winit.toggle_debug_tint(),
+        }
+    }
+
+    pub fn tty(&mut self) -> &mut Tty {
         if let Self::Tty(v) = self {
-            Some(v)
+            v
         } else {
-            None
+            panic!("backend is not Tty");
         }
     }
 
-    pub fn winit(&mut self) -> Option<&mut Winit> {
+    pub fn winit(&mut self) -> &mut Winit {
         if let Self::Winit(v) = self {
-            Some(v)
+            v
         } else {
-            None
+            panic!("backend is not Winit")
         }
     }
 }
diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index e5ee4551..eec796f1 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -30,16 +30,15 @@ use smithay::utils::DeviceFd;
 use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
 use smithay_drm_extras::edid::EdidInfo;
 
-use crate::input::{BackendAction, CompositorMod};
-use crate::niri::{Data, OutputRenderElements};
-use crate::Niri;
+use crate::niri::OutputRenderElements;
+use crate::{LoopData, 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, Data>,
+    udev_dispatcher: Dispatcher<'static, UdevBackend, LoopData>,
     primary_gpu_path: PathBuf,
     output_device: Option<OutputDevice>,
 }
@@ -69,44 +68,45 @@ struct TtyOutputState {
 }
 
 impl Tty {
-    pub fn new(event_loop: LoopHandle<'static, Data>) -> Self {
+    pub fn new(event_loop: LoopHandle<'static, LoopData>) -> 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 Data| {
-            let tty = data.backend.tty().unwrap();
-            let niri = &mut data.niri;
+        let udev_dispatcher =
+            Dispatcher::new(udev_backend, move |event, _, data: &mut LoopData| {
+                let tty = data.state.backend.tty();
+                let niri = &mut data.state.niri;
 
-            match event {
-                UdevEvent::Added { device_id, path } => {
-                    if !tty.session.is_active() {
-                        debug!("skipping UdevEvent::Added as session is inactive");
-                        return;
-                    }
+                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:?}");
-                    }
-                }
-                UdevEvent::Changed { device_id } => {
-                    if !tty.session.is_active() {
-                        debug!("skipping UdevEvent::Changed as session is inactive");
-                        return;
+                        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;
+                        }
 
-                    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_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)
+                        tty.device_removed(device_id, niri)
+                    }
                 }
-            }
-        });
+            });
         event_loop
             .register_dispatcher(udev_dispatcher.clone())
             .unwrap();
@@ -117,43 +117,16 @@ impl Tty {
         let input_backend = LibinputInputBackend::new(libinput.clone());
         event_loop
             .insert_source(input_backend, |mut event, _, data| {
-                let tty = data.backend.tty().unwrap();
-                let niri = &mut data.niri;
-
-                niri.process_libinput_event(&mut event);
-                match niri.process_input_event(CompositorMod::Super, event) {
-                    BackendAction::None => (),
-                    BackendAction::ChangeVt(vt) => tty.change_vt(vt),
-                    BackendAction::Suspend => {
-                        if let Err(err) = suspend() {
-                            warn!("error suspending: {err:?}");
-                        }
-                    }
-                    BackendAction::Screenshot => {
-                        let active = niri.monitor_set.active_output().cloned();
-                        if let Some(active) = active {
-                            if let Err(err) = niri.screenshot(tty.renderer(), &active) {
-                                warn!("error taking screenshot: {err:?}");
-                            }
-                        }
-                    }
-                    BackendAction::ToggleDebugTint => {
-                        if let Some(device) = tty.output_device.as_mut() {
-                            for (_, compositor) in &mut device.surfaces {
-                                compositor
-                                    .set_debug_flags(compositor.debug_flags() ^ DebugFlags::TINT);
-                            }
-                        }
-                    }
-                };
+                data.state.process_libinput_event(&mut event);
+                data.state.process_input_event(event);
             })
             .unwrap();
 
         let udev_dispatcher_c = udev_dispatcher.clone();
         event_loop
             .insert_source(notifier, move |event, _, data| {
-                let tty = data.backend.tty().unwrap();
-                let niri = &mut data.niri;
+                let tty = data.state.backend.tty();
+                let niri = &mut data.state.niri;
 
                 match event {
                     SessionEvent::PauseSession => {
@@ -289,7 +262,7 @@ impl Tty {
         let token = niri
             .event_loop
             .insert_source(drm_notifier, move |event, metadata, data| {
-                let tty = data.backend.tty().unwrap();
+                let tty = data.state.backend.tty();
                 match event {
                     DrmEvent::VBlank(crtc) => {
                         tracy_client::Client::running()
@@ -336,6 +309,7 @@ impl Tty {
                         }
 
                         let output = data
+                            .state
                             .niri
                             .global_space
                             .outputs()
@@ -345,10 +319,10 @@ impl Tty {
                             })
                             .unwrap()
                             .clone();
-                        let output_state = data.niri.output_state.get_mut(&output).unwrap();
+                        let output_state = data.state.niri.output_state.get_mut(&output).unwrap();
                         output_state.waiting_for_vblank = false;
                         output_state.frame_clock.presented(presentation_time);
-                        data.niri.queue_redraw(output);
+                        data.state.niri.queue_redraw(output);
                     }
                     DrmEvent::Error(error) => error!("DRM error: {error}"),
                 };
@@ -589,11 +563,25 @@ impl Tty {
         }
     }
 
-    fn change_vt(&mut self, vt: i32) {
+    pub fn change_vt(&mut self, vt: i32) {
         if let Err(err) = self.session.change_vt(vt) {
             error!("error changing VT: {err}");
         }
     }
+
+    pub fn suspend(&self) {
+        if let Err(err) = suspend() {
+            warn!("error suspending: {err:?}");
+        }
+    }
+
+    pub fn toggle_debug_tint(&mut self) {
+        if let Some(device) = self.output_device.as_mut() {
+            for (_, compositor) in &mut device.surfaces {
+                compositor.set_debug_flags(compositor.debug_flags() ^ DebugFlags::TINT);
+            }
+        }
+    }
 }
 
 fn refresh_interval(mode: DrmMode) -> Duration {
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 74485469..767bf7f4 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -3,7 +3,7 @@ use std::time::Duration;
 use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::backend::renderer::{DebugFlags, Renderer};
-use smithay::backend::winit::{self, WinitError, WinitEvent, WinitEventLoop, WinitGraphicsBackend};
+use smithay::backend::winit::{self, WinitError, WinitEvent, WinitGraphicsBackend};
 use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
 use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
 use smithay::reexports::calloop::LoopHandle;
@@ -12,25 +12,23 @@ use smithay::reexports::winit::dpi::LogicalSize;
 use smithay::reexports::winit::window::WindowBuilder;
 use smithay::utils::Transform;
 
-use crate::input::{BackendAction, CompositorMod};
-use crate::niri::{Data, OutputRenderElements};
+use crate::niri::OutputRenderElements;
 use crate::utils::get_monotonic_time;
-use crate::Niri;
+use crate::{LoopData, Niri};
 
 pub struct Winit {
     output: Output,
     backend: WinitGraphicsBackend<GlesRenderer>,
-    winit_event_loop: WinitEventLoop,
     damage_tracker: OutputDamageTracker,
 }
 
 impl Winit {
-    pub fn new(event_loop: LoopHandle<Data>) -> Self {
+    pub fn new(event_loop: LoopHandle<LoopData>) -> Self {
         let builder = WindowBuilder::new()
             .with_inner_size(LogicalSize::new(1280.0, 800.0))
             // .with_resizable(false)
             .with_title("niri");
-        let (backend, winit_event_loop) = winit::init_from_builder(builder).unwrap();
+        let (backend, mut winit_event_loop) = winit::init_from_builder(builder).unwrap();
 
         let mode = Mode {
             size: backend.window_size().physical_size,
@@ -59,8 +57,39 @@ impl Winit {
         let timer = Timer::immediate();
         event_loop
             .insert_source(timer, move |_, _, data| {
-                let winit = data.backend.winit().unwrap();
-                winit.dispatch(&mut data.niri);
+                let res = winit_event_loop.dispatch_new_events(|event| match event {
+                    WinitEvent::Resized { size, .. } => {
+                        let winit = data.state.backend.winit();
+                        winit.output.change_current_state(
+                            Some(Mode {
+                                size,
+                                refresh: 60_000,
+                            }),
+                            None,
+                            None,
+                            None,
+                        );
+                        data.state.niri.output_resized(winit.output.clone());
+                    }
+                    WinitEvent::Input(event) => data.state.process_input_event(event),
+                    WinitEvent::Focus(_) => (),
+                    WinitEvent::Refresh => data
+                        .state
+                        .niri
+                        .queue_redraw(data.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);
+                    }
+                    Ok(()) => (),
+                }
                 TimeoutAction::ToDuration(Duration::from_micros(16667))
             })
             .unwrap();
@@ -68,7 +97,6 @@ impl Winit {
         Self {
             output,
             backend,
-            winit_event_loop,
             damage_tracker,
         }
     }
@@ -88,56 +116,6 @@ impl Winit {
         niri.add_output(self.output.clone(), None);
     }
 
-    fn dispatch(&mut self, niri: &mut Niri) {
-        let renderer = self.backend.renderer();
-        let res = self
-            .winit_event_loop
-            .dispatch_new_events(|event| match event {
-                WinitEvent::Resized { size, .. } => {
-                    self.output.change_current_state(
-                        Some(Mode {
-                            size,
-                            refresh: 60_000,
-                        }),
-                        None,
-                        None,
-                        None,
-                    );
-                    niri.output_resized(self.output.clone());
-                }
-                WinitEvent::Input(event) => {
-                    match niri.process_input_event(CompositorMod::Alt, event) {
-                        BackendAction::None => (),
-                        BackendAction::ChangeVt(_) => (),
-                        BackendAction::Suspend => (),
-                        BackendAction::Screenshot => {
-                            let active = niri.monitor_set.active_output().cloned();
-                            if let Some(active) = active {
-                                if let Err(err) = niri.screenshot(renderer, &active) {
-                                    warn!("error taking screenshot: {err:?}");
-                                }
-                            }
-                        }
-                        BackendAction::ToggleDebugTint => {
-                            renderer.set_debug_flags(renderer.debug_flags() ^ DebugFlags::TINT);
-                        }
-                    }
-                }
-                WinitEvent::Focus(_) => (),
-                WinitEvent::Refresh => niri.queue_redraw(self.output.clone()),
-            });
-
-        // I want this to stop compiling if more errors are added.
-        #[allow(clippy::single_match)]
-        match res {
-            Err(WinitError::WindowClosed) => {
-                niri.stop_signal.stop();
-                niri.remove_output(&self.output);
-            }
-            Ok(()) => (),
-        }
-    }
-
     pub fn seat_name(&self) -> String {
         "winit".to_owned()
     }
@@ -175,4 +153,9 @@ impl Winit {
             self.backend.window().request_redraw();
         }
     }
+
+    pub fn toggle_debug_tint(&mut self) {
+        let renderer = self.backend.renderer();
+        renderer.set_debug_flags(renderer.debug_flags() ^ DebugFlags::TINT);
+    }
 }