Update to work with winit 0.29.15.

Author: tepperson2

Cargo.toml

@@ -20,7 +20,7 @@ pin-project-lite = "0.2.9"
 raw-window-handle = "0.5.2"
 slab = "0.4.8"
 unsend = { version = "0.2.1", default-features = false, features = ["alloc"] }
-winit = { version = "0.28.3", default-features = false }
+winit = { version = "0.29.15", default-features = false, features = ["rwh_05"] }
 
 [build-dependencies]
 cfg_aliases = "0.1.1"
@@ -29,7 +29,7 @@ cfg_aliases = "0.1.1"
 async-channel = "1.8.0"
 futures-lite = { version = "1.13.0", features = ["std"], default-features = false }
 softbuffer = { version = "0.2.0", default-features = false, features = ["x11"] }
-winit = { version = "0.28.3", default-features = false, features = ["x11"] }
+winit = { version = "0.29.15", default-features = false, features = ["rwh_05", "x11"] }
 
 [features]
 default = ["wayland", "wayland-dlopen", "x11"]

smol_example/src/main.rs

@@ -177,7 +177,7 @@ fn main2(event_loop: EventLoop<ThreadUnsafe>) {
                 target.exit().await;
             }
         }
-    });
+    }).unwrap();
 }
 
 async fn make_url_queries<'a>(

src/event_loop.rs

@@ -62,7 +62,7 @@ use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
 use winit::event_loop::EventLoopProxy;
 
 #[doc(inline)]
-pub use winit::event_loop::{ControlFlow, DeviceEventFilter, EventLoopClosed};
+pub use winit::event_loop::{ControlFlow, EventLoopClosed};
 
 /// Used to indicate that we need to wake up the event loop.
 ///
@@ -178,7 +178,7 @@ impl EventLoopBuilder {
     ///
     /// [`platform`]: crate::platform
     pub fn build<TS: ThreadSafety>(&mut self) -> EventLoop<TS> {
-        let inner = self.inner.build();
+        let inner = self.inner.build().unwrap();
         EventLoop {
             window_target: EventLoopWindowTarget {
                 reactor: Reactor::<TS>::get(),
@@ -291,18 +291,6 @@ impl<TS: ThreadSafety> EventLoopWindowTarget<TS> {
             .await;
         rx.recv().await.into_iter()
     }
-
-    /// Set the device event filter.
-    #[inline]
-    pub async fn set_device_event_filter(&self, filter: DeviceEventFilter) {
-        let (tx, rx) = crate::oneoff::oneoff();
-        self.reactor
-            .push_event_loop_op(EventLoopOp::SetDeviceFilter { filter, waker: tx })
-            .await;
-
-        // Wait for the filter to be set.
-        rx.recv().await;
-    }
 }
 
 unsafe impl<TS: ThreadSafety> HasRawDisplayHandle for EventLoopWindowTarget<TS> {
@@ -320,14 +308,14 @@ impl<TS: ThreadSafety + 'static> EventLoop<TS> {
 
     /// Block on a future forever.
     #[inline]
-    pub fn block_on(self, future: impl Future<Output = Infallible> + 'static) -> ! {
+    pub fn block_on(self, future: impl Future<Output = Infallible> + 'static) -> Result<(), winit::error::EventLoopError> {
         let inner = self.inner;
 
         let mut future = Box::pin(future);
         let mut filter = crate::filter::Filter::<TS>::new(&inner);
 
-        inner.run(move |event, elwt, flow| {
-            filter.handle_event(future.as_mut(), event, elwt, flow);
+        inner.run(move |event, elwt| {
+            filter.handle_event(future.as_mut(), event, elwt);
         })
     }
 }

src/filter.rs

@@ -126,9 +126,8 @@ impl<TS: ThreadSafety> Filter<TS> {
     pub fn handle_event<F>(
         &mut self,
         future: Pin<&mut F>,
-        event: Event<'_, Wakeup>,
+        event: Event<Wakeup>,
         elwt: &EventLoopWindowTarget<Wakeup>,
-        flow: &mut ControlFlow,
     ) -> ReturnOrFinish<(), F::Output>
     where
         F: Future,
@@ -159,14 +158,6 @@ impl<TS: ThreadSafety> Filter<TS> {
                 false
             }
 
-            Event::RedrawEventsCleared => {
-                // We are about to fall asleep, so make sure that the future knows it.
-                self.notifier.awake.store(false, Ordering::SeqCst);
-
-                // We are about to fall asleep.
-                true
-            }
-
             _ => {
                 // We are not about to fall asleep.
                 false
@@ -250,18 +241,18 @@ impl<TS: ThreadSafety> Filter<TS> {
         }
 
         // Set the control flow.
-        if let Some(code) = self.reactor.exit_requested() {
+        if let Some(_code) = self.reactor.exit_requested() {
             // The user wants to exit.
-            flow.set_exit_with_code(code);
+            elwt.exit();
         } else if self.yielding {
             // The future wants to be polled again as soon as possible.
-            flow.set_poll();
+            elwt.set_control_flow(ControlFlow::Poll);
         } else if let Some(deadline) = self.deadline {
             // The future wants to be polled again when the deadline is reached.
-            flow.set_wait_until(deadline);
+            elwt.set_control_flow(ControlFlow::WaitUntil(deadline));
         } else {
             // The future wants to poll.
-            flow.set_wait();
+            elwt.set_control_flow(ControlFlow::Wait);
         }
 
         // Return the output if any.

src/handler.rs

@@ -537,10 +537,12 @@ impl<T: Clone + 'static> Event for T {
     }
 }
 
+/*
 struct CallOnDrop<F: FnMut()>(F);
 
 impl<F: FnMut()> Drop for CallOnDrop<F> {
     fn drop(&mut self) {
         (self.0)();
     }
 }
+*/

src/lib.rs

@@ -31,6 +31,11 @@ pub mod filter;
 pub mod platform;
 pub mod window;
 
+pub mod keyboard {
+    #[doc(inline)]
+    pub use winit::keyboard::*;
+}
+
 pub mod event {
     #[doc(inline)]
     pub use winit::event::*;

src/platform.rs

@@ -68,7 +68,7 @@ cfg_if::cfg_if! {
 }
 
 mod __private {
-    use crate::event_loop::{EventLoop, EventLoopBuilder, EventLoopWindowTarget};
+    use crate::event_loop::{EventLoopBuilder, EventLoopWindowTarget};
     use crate::window::{Window, WindowBuilder};
 
     #[doc(hidden)]
@@ -107,7 +107,7 @@ mod __private {
 
     sealed_trait_with_gen! {
         EventLoopWindowTarget EventLoopWindowTargetPrivate
-        EventLoop EventLoopPrivate
+        //EventLoop EventLoopPrivate
         Window WindowPrivate
     }
 }

src/platform/run_return.rs

@@ -28,24 +28,24 @@ use futures_lite::pin;
 use std::future::Future;
 
 /// Additional methods on [`EventLoop`] to return control flow to the caller.
-pub trait EventLoopExtRunReturn {
+pub trait EventLoopExtRunOnDemand {
     /// Initializes the `winit` event loop.
     ///
     /// Unlike [`EventLoop::block_on`], this function accepts non-`'static` (i.e. non-`move`) closures
     /// and returns control flow to the caller when `control_flow` is set to [`ControlFlow::Exit`].
     ///
     /// [`ControlFlow::Exit`]: crate::event_loop::ControlFlow::Exit
-    fn block_on_return<F>(&mut self, future: F) -> ReturnOrFinish<i32, F::Output>
+    fn block_on_demand<F>(&mut self, future: F) -> ReturnOrFinish<Result<(), winit::error::EventLoopError>, F::Output>
     where
         F: Future;
 }
 
-impl<TS: ThreadSafety> EventLoopExtRunReturn for EventLoop<TS> {
-    fn block_on_return<F>(&mut self, fut: F) -> ReturnOrFinish<i32, F::Output>
+impl<TS: ThreadSafety> EventLoopExtRunOnDemand for EventLoop<TS> {
+    fn block_on_demand<F>(&mut self, fut: F) -> ReturnOrFinish<Result<(), winit::error::EventLoopError>, F::Output>
     where
         F: Future,
     {
-        use winit::platform::run_return::EventLoopExtRunReturn as _;
+        use winit::platform::run_on_demand::EventLoopExtRunOnDemand as _;
 
         let inner = &mut self.inner;
 
@@ -54,12 +54,12 @@ impl<TS: ThreadSafety> EventLoopExtRunReturn for EventLoop<TS> {
         let mut filter = Filter::<TS>::new(inner);
 
         let mut output = None;
-        let exit = inner.run_return({
+        let exit = inner.run_on_demand({
             let output = &mut output;
-            move |event, elwt, flow| match filter.handle_event(fut.as_mut(), event, elwt, flow) {
+            move |event, elwt| match filter.handle_event(fut.as_mut(), event, elwt) {
                 ReturnOrFinish::FutureReturned(out) => {
                     *output = Some(out);
-                    flow.set_exit()
+                    elwt.exit();
                 }
 
                 ReturnOrFinish::Output(()) => {}

src/platform/wayland.rs

@@ -29,7 +29,7 @@ use crate::window::{Window, WindowBuilder};
 use std::os::raw;
 
 use winit::platform::wayland::{
-    EventLoopBuilderExtWayland as _, WindowBuilderExtWayland as _, WindowExtWayland as _,
+    EventLoopBuilderExtWayland as _, WindowBuilderExtWayland as _,
 };
 
 #[doc(inline)]
@@ -95,31 +95,9 @@ impl EventLoopBuilderExtWayland for EventLoopBuilder {
 ///
 /// [`Window`]: crate::window::Window
 pub trait WindowExtWayland: sealed::WindowPrivate {
-    /// Returns a pointer to the `wl_surface` object of wayland that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    fn wayland_surface(&self) -> Option<*mut raw::c_void>;
-
-    /// Returns a pointer to the `wl_display` object of wayland that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    fn wayland_display(&self) -> Option<*mut raw::c_void>;
 }
 
 impl<TS: ThreadSafety> WindowExtWayland for Window<TS> {
-    #[inline]
-    fn wayland_surface(&self) -> Option<*mut raw::c_void> {
-        self.window().wayland_surface()
-    }
-
-    #[inline]
-    fn wayland_display(&self) -> Option<*mut raw::c_void> {
-        self.window().wayland_display()
-    }
 }
 
 /// Additional methods on [`WindowBuilder`] that are specific to Wayland.

src/platform/x11.rs

@@ -26,10 +26,8 @@ use crate::event_loop::{EventLoopBuilder, EventLoopWindowTarget};
 use crate::sync::ThreadSafety;
 use crate::window::{Window, WindowBuilder};
 
-use std::os::raw;
-
 use winit::dpi::Size;
-use winit::platform::x11::{EventLoopBuilderExtX11 as _, WindowExtX11 as _};
+use winit::platform::x11::EventLoopBuilderExtX11 as _;
 
 #[doc(inline)]
 pub use winit::platform::x11::{register_xlib_error_hook, XWindowType, XlibErrorHook};
@@ -81,44 +79,9 @@ impl EventLoopBuilderExtX11 for EventLoopBuilder {
 ///
 /// [`Window`]: crate::window::Window
 pub trait WindowExtX11: sealed::WindowPrivate {
-    /// Returns the ID of the [`Window`] xlib object that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    fn xlib_window(&self) -> Option<raw::c_ulong>;
-
-    /// Returns a pointer to the `Display` object of xlib that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    fn xlib_display(&self) -> Option<*mut raw::c_void>;
-
-    fn xlib_screen_id(&self) -> Option<raw::c_int>;
-
-    /// This function returns the underlying `xcb_connection_t` of an xlib `Display`.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    fn xcb_connection(&self) -> Option<*mut raw::c_void>;
 }
 
 impl<TS: ThreadSafety> WindowExtX11 for Window<TS> {
-    fn xcb_connection(&self) -> Option<*mut raw::c_void> {
-        self.window().xcb_connection()
-    }
-
-    fn xlib_display(&self) -> Option<*mut raw::c_void> {
-        self.window().xlib_display()
-    }
-
-    fn xlib_screen_id(&self) -> Option<raw::c_int> {
-        self.window().xlib_screen_id()
-    }
-
-    fn xlib_window(&self) -> Option<raw::c_ulong> {
-        self.window().xlib_window()
-    }
 }
 
 /// Additional methods on [`WindowBuilder`] that are specific to X11.