Add timeout argument to pump_events

rib · kchibisov · commit ae9b02e09756 · 2023-07-28T03:04:32.000+04:00
This renames all internal implementations of pump_events_with_timeout
to pump_events and makes them public.

Since all platforms that support pump_events support timeouts there's
no need to have a separate API.
diff --git a/examples/window_pump_events.rs b/examples/window_pump_events.rs
@@ -14,7 +14,7 @@ fn main() -> std::process::ExitCode {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::EventLoop,
+        event_loop::{ControlFlow, EventLoop},
         platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
         window::WindowBuilder,
     };
@@ -31,7 +31,10 @@ fn main() -> std::process::ExitCode {
         .unwrap();
 
     'main: loop {
-        let status = event_loop.pump_events(|event, _, control_flow| {
+        let timeout = Some(Duration::ZERO);
+        let status = event_loop.pump_events(timeout, |event, _, control_flow| {
+            *control_flow = ControlFlow::Wait;
+
             if let Event::WindowEvent { event, .. } = &event {
                 // Print only Window events to reduce noise
                 println!("{event:?}");
diff --git a/src/platform/pump_events.rs b/src/platform/pump_events.rs
@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use crate::{
     event::Event,
     event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
@@ -60,7 +62,8 @@ pub trait EventLoopExtPumpEvents {
     ///         .unwrap();
     ///
     ///     'main: loop {
-    ///         let status = event_loop.pump_events(|event, _, control_flow| {
+    ///         let timeout = Some(Duration::ZERO);
+    ///         let status = event_loop.pump_events(timeout, |event, _, control_flow| {
     /// #            if let Event::WindowEvent { event, .. } = &event {
     /// #                // Print only Window events to reduce noise
     /// #                println!("{event:?}");
@@ -169,7 +172,7 @@ pub trait EventLoopExtPumpEvents {
     ///   If you render outside of Winit you are likely to see window resizing artifacts
     ///   since MacOS expects applications to render synchronously during any `drawRect`
     ///   callback.
-    fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus
+    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
     where
         F: FnMut(
             Event<'_, Self::UserEvent>,
@@ -181,14 +184,14 @@ pub trait EventLoopExtPumpEvents {
 impl<T> EventLoopExtPumpEvents for EventLoop<T> {
     type UserEvent = T;
 
-    fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus
+    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
     where
         F: FnMut(
             Event<'_, Self::UserEvent>,
             &EventLoopWindowTarget<Self::UserEvent>,
             &mut ControlFlow,
         ),
     {
-        self.event_loop.pump_events(event_handler)
+        self.event_loop.pump_events(timeout, event_handler)
     }
 }
diff --git a/src/platform_impl/android/mod.rs b/src/platform_impl/android/mod.rs
@@ -543,7 +543,7 @@ impl<T: 'static> EventLoop<T> {
         }
 
         loop {
-            match self.pump_events_with_timeout(None, &mut event_handler) {
+            match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
                 }
@@ -557,18 +557,7 @@ impl<T: 'static> EventLoop<T> {
         }
     }
 
-    pub fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
-    {
-        self.pump_events_with_timeout(Some(Duration::ZERO), event_handler)
-    }
-
-    fn pump_events_with_timeout<F>(
-        &mut self,
-        timeout: Option<Duration>,
-        mut callback: F,
-    ) -> PumpStatus
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
     where
         F: FnMut(event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {
diff --git a/src/platform_impl/linux/mod.rs b/src/platform_impl/linux/mod.rs
@@ -844,11 +844,11 @@ impl<T: 'static> EventLoop<T> {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_ondemand(callback))
     }
 
-    pub fn pump_events<F>(&mut self, callback: F) -> PumpStatus
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
     where
         F: FnMut(crate::event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(callback))
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))
     }
 
     pub fn window_target(&self) -> &crate::event_loop::EventLoopWindowTarget<T> {
diff --git a/src/platform_impl/linux/wayland/event_loop/mod.rs b/src/platform_impl/linux/wayland/event_loop/mod.rs
@@ -154,7 +154,7 @@ impl<T: 'static> EventLoop<T> {
         }
 
         let exit = loop {
-            match self.pump_events_with_timeout(None, &mut event_handler) {
+            match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
                 }
@@ -176,18 +176,7 @@ impl<T: 'static> EventLoop<T> {
         exit
     }
 
-    pub fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
-    {
-        self.pump_events_with_timeout(Some(Duration::ZERO), event_handler)
-    }
-
-    fn pump_events_with_timeout<F>(
-        &mut self,
-        timeout: Option<Duration>,
-        mut callback: F,
-    ) -> PumpStatus
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
     where
         F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
diff --git a/src/platform_impl/linux/x11/mod.rs b/src/platform_impl/linux/x11/mod.rs
@@ -441,7 +441,7 @@ impl<T: 'static> EventLoop<T> {
         }
 
         let exit = loop {
-            match self.pump_events_with_timeout(None, &mut event_handler) {
+            match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
                 }
@@ -466,18 +466,7 @@ impl<T: 'static> EventLoop<T> {
         exit
     }
 
-    pub fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
-    {
-        self.pump_events_with_timeout(Some(Duration::ZERO), event_handler)
-    }
-
-    fn pump_events_with_timeout<F>(
-        &mut self,
-        timeout: Option<Duration>,
-        mut callback: F,
-    ) -> PumpStatus
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
     where
         F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {
diff --git a/src/platform_impl/macos/app_state.rs b/src/platform_impl/macos/app_state.rs
@@ -632,7 +632,7 @@ impl AppState {
             Self::stop();
         }
         HANDLER.update_start_time();
-        let wait_timeout = HANDLER.wait_timeout(); // configured by pump_events_with_timeout
+        let wait_timeout = HANDLER.wait_timeout(); // configured by pump_events
         let app_timeout = match HANDLER.control_flow() {
             ControlFlow::Wait => None,
             ControlFlow::Poll | ControlFlow::ExitWithCode(_) => Some(Instant::now()),
diff --git a/src/platform_impl/macos/event_loop.rs b/src/platform_impl/macos/event_loop.rs
@@ -291,14 +291,7 @@ impl<T> EventLoop<T> {
         }
     }
 
-    pub fn pump_events<F>(&mut self, callback: F) -> PumpStatus
-    where
-        F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
-    {
-        self.pump_events_with_timeout(Some(Duration::ZERO), callback)
-    }
-
-    fn pump_events_with_timeout<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
     where
         F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
     {
diff --git a/src/platform_impl/windows/event_loop.rs b/src/platform_impl/windows/event_loop.rs
@@ -296,18 +296,7 @@ impl<T: 'static> EventLoop<T> {
         }
     }
 
-    pub fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
-    {
-        self.pump_events_with_timeout(Some(Duration::ZERO), event_handler)
-    }
-
-    fn pump_events_with_timeout<F>(
-        &mut self,
-        timeout: Option<Duration>,
-        mut event_handler: F,
-    ) -> PumpStatus
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut event_handler: F) -> PumpStatus
     where
         F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {

Original file line number	Diff line number	Diff line change
`@@ -543,7 +543,7 @@ impl<T: 'static> EventLoop<T> {`
`543`	`543`	`}`
`544`	`544`
`545`	`545`	`loop {`
`546`		`- match self.pump_events_with_timeout(None, &mut event_handler) {`
	`546`	`+ match self.pump_events(None, &mut event_handler) {`
`547`	`547`	`PumpStatus::Exit(0) => {`
`548`	`548`	`break Ok(());`
`549`	`549`	`}`
`@@ -557,18 +557,7 @@ impl<T: 'static> EventLoop<T> {`
`557`	`557`	`}`
`558`	`558`	`}`
`559`	`559`
`560`		`- pub fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus`
`561`		`- where`
`562`		`- F: FnMut(event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),`
`563`		`- {`
`564`		`- self.pump_events_with_timeout(Some(Duration::ZERO), event_handler)`
`565`		`- }`
`566`		`-`
`567`		`- fn pump_events_with_timeout<F>(`
`568`		`- &mut self,`
`569`		`- timeout: Option<Duration>,`
`570`		`- mut callback: F,`
`571`		`- ) -> PumpStatus`
	`560`	`+ pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus`
`572`	`561`	`where`
`573`	`562`	`F: FnMut(event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),`
`574`	`563`	`{`
Original file line number	Diff line number	Diff line change
`@@ -844,11 +844,11 @@ impl<T: 'static> EventLoop<T> {`
`844`	`844`	`x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_ondemand(callback))`
`845`	`845`	`}`
`846`	`846`
`847`		`- pub fn pump_events<F>(&mut self, callback: F) -> PumpStatus`
	`847`	`+ pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus`
`848`	`848`	`where`
`849`	`849`	`F: FnMut(crate::event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),`
`850`	`850`	`{`
`851`		`- x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(callback))`
	`851`	`+ x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))`
`852`	`852`	`}`
`853`	`853`
`854`	`854`	`pub fn window_target(&self) -> &crate::event_loop::EventLoopWindowTarget<T> {`
Original file line number	Diff line number	Diff line change
`@@ -632,7 +632,7 @@ impl AppState {`
`632`	`632`	`Self::stop();`
`633`	`633`	`}`
`634`	`634`	`HANDLER.update_start_time();`
`635`		`- let wait_timeout = HANDLER.wait_timeout(); // configured by pump_events_with_timeout`
	`635`	`+ let wait_timeout = HANDLER.wait_timeout(); // configured by pump_events`
`636`	`636`	`let app_timeout = match HANDLER.control_flow() {`
`637`	`637`	`ControlFlow::Wait => None,`
`638`	`638`	`ControlFlow::Poll \| ControlFlow::ExitWithCode(_) => Some(Instant::now()),`
Original file line number	Diff line number	Diff line change
`@@ -291,14 +291,7 @@ impl<T> EventLoop<T> {`
`291`	`291`	`}`
`292`	`292`	`}`
`293`	`293`
`294`		`- pub fn pump_events<F>(&mut self, callback: F) -> PumpStatus`
`295`		`- where`
`296`		`- F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),`
`297`		`- {`
`298`		`- self.pump_events_with_timeout(Some(Duration::ZERO), callback)`
`299`		`- }`
`300`		`-`
`301`		`- fn pump_events_with_timeout<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus`
	`294`	`+ pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus`
`302`	`295`	`where`
`303`	`296`	`F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),`
`304`	`297`	`{`
Original file line number	Diff line number	Diff line change
`@@ -296,18 +296,7 @@ impl<T: 'static> EventLoop<T> {`
`296`	`296`	`}`
`297`	`297`	`}`
`298`	`298`
`299`		`- pub fn pump_events<F>(&mut self, event_handler: F) -> PumpStatus`
`300`		`- where`
`301`		`- F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),`
`302`		`- {`
`303`		`- self.pump_events_with_timeout(Some(Duration::ZERO), event_handler)`
`304`		`- }`
`305`		`-`
`306`		`- fn pump_events_with_timeout<F>(`
`307`		`- &mut self,`
`308`		`- timeout: Option<Duration>,`
`309`		`- mut event_handler: F,`
`310`		`- ) -> PumpStatus`
	`299`	`+ pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut event_handler: F) -> PumpStatus`
`311`	`300`	`where`
`312`	`301`	`F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),`
`313`	`302`	`{`