examples: Make utils/winit_app.rs a path-referenced module again to fix autoformatting

README.md

@@ -69,7 +69,8 @@ use winit::event::{Event, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::window::Window;
 
-include!("../examples/utils/winit_app.rs");
+#[path = "../examples/utils/winit_app.rs"]
+mod winit_app;
 
 fn main() {
     let event_loop = EventLoop::new().unwrap();

examples/animation.rs

@@ -7,7 +7,8 @@ use winit::event::{Event, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 
-include!("./utils/winit_app.rs");
+#[path = "utils/winit_app.rs"]
+mod winit_app;
 
 fn main() {
     let event_loop = EventLoop::new().unwrap();

examples/fruit.rs

@@ -4,7 +4,8 @@ use winit::event::{Event, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 
-include!("utils/winit_app.rs");
+#[path = "utils/winit_app.rs"]
+mod winit_app;
 
 fn main() {
     //see fruit.jpg.license for the license of fruit.jpg

examples/rectangle.rs

@@ -3,7 +3,8 @@ use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 
-include!("utils/winit_app.rs");
+#[path = "utils/winit_app.rs"]
+mod winit_app;
 
 fn redraw(buffer: &mut [u32], width: usize, height: usize, flag: bool) {
     for y in 0..height {

examples/utils/winit_app.rs

@@ -1,122 +1,121 @@
 /// Common boilerplate for setting up a winit application.
-mod winit_app {
-    use std::marker::PhantomData;
-    use std::rc::Rc;
-
-    use winit::application::ApplicationHandler;
-    use winit::event::{Event, WindowEvent};
-    use winit::event_loop::{EventLoop, ActiveEventLoop};
-    use winit::window::{WindowAttributes, WindowId, Window};
-
-    /// Run a Winit application.
-    #[allow(unused_mut)]
-    pub(crate) fn run_app(event_loop: EventLoop<()>, mut app: impl ApplicationHandler<()> + 'static) {
-        #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))]
-        event_loop.run_app(&mut app).unwrap();
-
-        #[cfg(any(target_arch = "wasm32", target_arch = "wasm64"))]
-        winit::platform::web::EventLoopExtWebSys::spawn_app(event_loop, app);
-    }
-
-    /// Create a window from a set of window attributes.
-    #[allow(dead_code)]
-    pub(crate) fn make_window(elwt: &ActiveEventLoop, f: impl FnOnce(WindowAttributes) -> WindowAttributes) -> Rc<Window> {
-        let attributes = f(WindowAttributes::default());
-        #[cfg(target_arch = "wasm32")]
-        let attributes = winit::platform::web::WindowAttributesExtWebSys::with_append(
-            attributes,
-            true
-        );
-        let window = elwt.create_window(attributes);
-        Rc::new(window.unwrap())
-    }
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use winit::application::ApplicationHandler;
+use winit::event::{Event, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::window::{Window, WindowAttributes, WindowId};
+
+/// Run a Winit application.
+#[allow(unused_mut)]
+pub(crate) fn run_app(event_loop: EventLoop<()>, mut app: impl ApplicationHandler<()> + 'static) {
+    #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))]
+    event_loop.run_app(&mut app).unwrap();
+
+    #[cfg(any(target_arch = "wasm32", target_arch = "wasm64"))]
+    winit::platform::web::EventLoopExtWebSys::spawn_app(event_loop, app);
+}
 
-    /// Easily constructable winit application.
-    pub(crate) struct WinitApp<T, Init, Handler> {
-        /// Closure to initialize state.
-        init: Init,
+/// Create a window from a set of window attributes.
+#[allow(dead_code)]
+pub(crate) fn make_window(
+    elwt: &ActiveEventLoop,
+    f: impl FnOnce(WindowAttributes) -> WindowAttributes,
+) -> Rc<Window> {
+    let attributes = f(WindowAttributes::default());
+    #[cfg(target_arch = "wasm32")]
+    let attributes = winit::platform::web::WindowAttributesExtWebSys::with_append(attributes, true);
+    let window = elwt.create_window(attributes);
+    Rc::new(window.unwrap())
+}
 
-        /// Closure to run on window events.
-        event: Handler,
+/// Easily constructable winit application.
+pub(crate) struct WinitApp<T, Init, Handler> {
+    /// Closure to initialize state.
+    init: Init,
 
-        /// Contained state.
-        state: Option<T>
-    }
+    /// Closure to run on window events.
+    event: Handler,
 
-    /// Builder that makes it so we don't have to name `T`.
-    pub(crate) struct WinitAppBuilder<T, Init> {
-        /// Closure to initialize state.
-        init: Init,
+    /// Contained state.
+    state: Option<T>,
+}
 
-        /// Eat the type parameter.
-        _marker: PhantomData<Option<T>>,
-    }
+/// Builder that makes it so we don't have to name `T`.
+pub(crate) struct WinitAppBuilder<T, Init> {
+    /// Closure to initialize state.
+    init: Init,
 
-    impl<T, Init> WinitAppBuilder<T, Init>
-    where Init: FnMut(&ActiveEventLoop) -> T,
-    {
-        /// Create with an "init" closure.
-        pub(crate) fn with_init(init: Init) -> Self {
-            Self {
-                init,
-                _marker: PhantomData
-            }
-        }
+    /// Eat the type parameter.
+    _marker: PhantomData<Option<T>>,
+}
 
-        /// Build a new application.
-        pub(crate) fn with_event_handler<F>(self, handler: F) -> WinitApp<T, Init, F>
-        where F: FnMut(&mut T, Event<()>, &ActiveEventLoop)
-        {
-            WinitApp::new(self.init, handler)
+impl<T, Init> WinitAppBuilder<T, Init>
+where
+    Init: FnMut(&ActiveEventLoop) -> T,
+{
+    /// Create with an "init" closure.
+    pub(crate) fn with_init(init: Init) -> Self {
+        Self {
+            init,
+            _marker: PhantomData,
         }
     }
 
-    impl<T, Init, Handler> WinitApp<T, Init, Handler>
-    where Init: FnMut(&ActiveEventLoop) -> T,
-          Handler: FnMut(&mut T, Event<()>, &ActiveEventLoop)
+    /// Build a new application.
+    pub(crate) fn with_event_handler<F>(self, handler: F) -> WinitApp<T, Init, F>
+    where
+        F: FnMut(&mut T, Event<()>, &ActiveEventLoop),
     {
-        /// Create a new application.
-        pub(crate) fn new(init: Init, event: Handler) -> Self {
-            Self {
-                init,
-                event,
-                state: None
-            }
-        }
+        WinitApp::new(self.init, handler)
     }
+}
 
-    impl<T, Init, Handler> ApplicationHandler for WinitApp<T, Init, Handler>
-    where Init: FnMut(&ActiveEventLoop) -> T,
-          Handler: FnMut(&mut T, Event<()>, &ActiveEventLoop) {
-
-        fn resumed(&mut self, el: &ActiveEventLoop) {
-            debug_assert!(self.state.is_none());
-            self.state = Some((self.init)(el));
+impl<T, Init, Handler> WinitApp<T, Init, Handler>
+where
+    Init: FnMut(&ActiveEventLoop) -> T,
+    Handler: FnMut(&mut T, Event<()>, &ActiveEventLoop),
+{
+    /// Create a new application.
+    pub(crate) fn new(init: Init, event: Handler) -> Self {
+        Self {
+            init,
+            event,
+            state: None,
         }
+    }
+}
 
-        fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
-            let state = self.state.take();
-            debug_assert!(state.is_some());
-            drop(state);
-        }
+impl<T, Init, Handler> ApplicationHandler for WinitApp<T, Init, Handler>
+where
+    Init: FnMut(&ActiveEventLoop) -> T,
+    Handler: FnMut(&mut T, Event<()>, &ActiveEventLoop),
+{
+    fn resumed(&mut self, el: &ActiveEventLoop) {
+        debug_assert!(self.state.is_none());
+        self.state = Some((self.init)(el));
+    }
 
-        fn window_event(
-            &mut self,
-            event_loop: &ActiveEventLoop,
-            window_id: WindowId,
-            event: WindowEvent,
-        ) {
-            let state = self.state.as_mut().unwrap();
-            (self.event)(state, Event::WindowEvent {
-                window_id,
-                event
-            }, event_loop);
-        }
+    fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
+        let state = self.state.take();
+        debug_assert!(state.is_some());
+        drop(state);
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        let state = self.state.as_mut().unwrap();
+        (self.event)(state, Event::WindowEvent { window_id, event }, event_loop);
+    }
 
-        fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
-            if let Some(state) = self.state.as_mut() {
-                (self.event)(state, Event::AboutToWait, event_loop);
-            }
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if let Some(state) = self.state.as_mut() {
+            (self.event)(state, Event::AboutToWait, event_loop);
         }
     }
 }

examples/winit.rs

@@ -3,7 +3,8 @@ use winit::event::{Event, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 
-include!("utils/winit_app.rs");
+#[path = "utils/winit_app.rs"]
+mod winit_app;
 
 fn main() {
     let event_loop = EventLoop::new().unwrap();

examples/winit_multithread.rs

@@ -1,5 +1,9 @@
 //! `Surface` implements `Send`. This makes sure that multithreading can work here.
 
+#[cfg(not(target_family = "wasm"))]
+#[path = "utils/winit_app.rs"]
+mod winit_app;
+
 #[cfg(not(target_family = "wasm"))]
 mod ex {
     use std::num::NonZeroU32;
@@ -9,7 +13,7 @@ mod ex {
     use winit::keyboard::{Key, NamedKey};
     use winit::window::Window;
 
-    include!("utils/winit_app.rs");
+    use super::winit_app;
 
     type Surface = softbuffer::Surface<Arc<Window>, Arc<Window>>;
 

examples/winit_wrong_sized_buffer.rs

@@ -3,7 +3,8 @@ use winit::event::{Event, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 
-include!("utils/winit_app.rs");
+#[path = "utils/winit_app.rs"]
+mod winit_app;
 
 const BUFFER_WIDTH: usize = 256;
 const BUFFER_HEIGHT: usize = 128;