Move all traits one layer up

1 files changed, 43 insertions, 60 deletions

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);
+    }
 }