Make ControlFlow::Wait the default (rust-windowing#3106)

kchibisov · Sep 22, 2023 · 878d832 · 878d832
1 parent e2e01e1
commit 878d832
Show file tree

Hide file tree

Showing 34 changed files with 155 additions and 229 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -25,6 +25,7 @@ And please only add new entries to the top of this list, right below the `# Unre
 - On Web, add `EventLoopWindowTargetExtWebSys` and `PollStrategy`, which allows to set different strategies for `ControlFlow::Poll`. By default the Prioritized Task Scheduling API is used, but an option to use `Window.requestIdleCallback` is available as well. Both use `setTimeout()`, with a trick to circumvent throttling to 4ms, as a fallback.
 - Implement `PartialOrd` and `Ord` for `MouseButton`.
 - On X11, fix event loop not waking up on `ControlFlow::Poll` and `ControlFlow::WaitUntil`.
+- **Breaking:** Change default `ControlFlow` from `Poll` to `Wait`.
 
 # 0.29.1-beta
 

diff --git a/README.md b/README.md
@@ -35,7 +35,7 @@ another library.
 ```rust
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -44,8 +44,6 @@ fn main() {
     let window = WindowBuilder::new().build(&event_loop).unwrap();
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,

diff --git a/examples/child_window.rs b/examples/child_window.rs
@@ -9,7 +9,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use winit::{
         dpi::{LogicalPosition, LogicalSize, Position},
         event::{ElementState, Event, KeyEvent, WindowEvent},
-        event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+        event_loop::{EventLoop, EventLoopWindowTarget},
         window::raw_window_handle::HasRawWindowHandle,
         window::{Window, WindowBuilder, WindowId},
     };
@@ -47,8 +47,6 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("parent window: {parent_window:?})");
 
     event_loop.run(move |event: Event<()>, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, window_id } = event {
             match event {
                 WindowEvent::CloseRequested => {

diff --git a/examples/cursor.rs b/examples/cursor.rs
@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::{CursorIcon, WindowBuilder},
 };
 
@@ -20,8 +20,6 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut cursor_idx = 0;
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::KeyboardInput {

diff --git a/examples/cursor_grab.rs b/examples/cursor_grab.rs
@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{DeviceEvent, ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::{Key, ModifiersState},
     window::{CursorGrabMode, WindowBuilder},
 };
@@ -22,56 +22,52 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let mut modifiers = ModifiersState::default();
 
-    event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => elwt.exit(),
-                WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
-                            logical_key: key,
-                            state: ElementState::Released,
-                            ..
-                        },
-                    ..
-                } => {
-                    let result = match key {
-                        Key::Escape => {
-                            elwt.exit();
+    event_loop.run(move |event, elwt| match event {
+        Event::WindowEvent { event, .. } => match event {
+            WindowEvent::CloseRequested => elwt.exit(),
+            WindowEvent::KeyboardInput {
+                event:
+                    KeyEvent {
+                        logical_key: key,
+                        state: ElementState::Released,
+                        ..
+                    },
+                ..
+            } => {
+                let result = match key {
+                    Key::Escape => {
+                        elwt.exit();
+                        Ok(())
+                    }
+                    Key::Character(ch) => match ch.to_lowercase().as_str() {
+                        "g" => window.set_cursor_grab(CursorGrabMode::Confined),
+                        "l" => window.set_cursor_grab(CursorGrabMode::Locked),
+                        "a" => window.set_cursor_grab(CursorGrabMode::None),
+                        "h" => {
+                            window.set_cursor_visible(modifiers.shift_key());
                             Ok(())
                         }
-                        Key::Character(ch) => match ch.to_lowercase().as_str() {
-                            "g" => window.set_cursor_grab(CursorGrabMode::Confined),
-                            "l" => window.set_cursor_grab(CursorGrabMode::Locked),
-                            "a" => window.set_cursor_grab(CursorGrabMode::None),
-                            "h" => {
-                                window.set_cursor_visible(modifiers.shift_key());
-                                Ok(())
-                            }
-                            _ => Ok(()),
-                        },
                         _ => Ok(()),
-                    };
+                    },
+                    _ => Ok(()),
+                };
 
-                    if let Err(err) = result {
-                        println!("error: {err}");
-                    }
+                if let Err(err) = result {
+                    println!("error: {err}");
                 }
-                WindowEvent::ModifiersChanged(new) => modifiers = new.state(),
-                WindowEvent::RedrawRequested => fill::fill_window(&window),
-                _ => (),
-            },
-            Event::DeviceEvent { event, .. } => match event {
-                DeviceEvent::MouseMotion { delta } => println!("mouse moved: {delta:?}"),
-                DeviceEvent::Button { button, state } => match state {
-                    ElementState::Pressed => println!("mouse button {button} pressed"),
-                    ElementState::Released => println!("mouse button {button} released"),
-                },
-                _ => (),
+            }
+            WindowEvent::ModifiersChanged(new) => modifiers = new.state(),
+            WindowEvent::RedrawRequested => fill::fill_window(&window),
+            _ => (),
+        },
+        Event::DeviceEvent { event, .. } => match event {
+            DeviceEvent::MouseMotion { delta } => println!("mouse moved: {delta:?}"),
+            DeviceEvent::Button { button, state } => match state {
+                ElementState::Pressed => println!("mouse button {button} pressed"),
+                ElementState::Released => println!("mouse button {button} released"),
             },
             _ => (),
-        }
+        },
+        _ => (),
     })
 }
diff --git a/examples/custom_events.rs b/examples/custom_events.rs
@@ -5,7 +5,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoopBuilder},
+        event_loop::EventLoopBuilder,
         window::WindowBuilder,
     };
 
@@ -40,23 +40,19 @@ fn main() -> Result<(), impl std::error::Error> {
         }
     });
 
-    event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
-        match event {
-            Event::UserEvent(event) => println!("user event: {event:?}"),
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => elwt.exit(),
-            Event::WindowEvent {
-                event: WindowEvent::RedrawRequested,
-                ..
-            } => {
-                fill::fill_window(&window);
-            }
-            _ => (),
+    event_loop.run(move |event, elwt| match event {
+        Event::UserEvent(event) => println!("user event: {event:?}"),
+        Event::WindowEvent {
+            event: WindowEvent::CloseRequested,
+            ..
+        } => elwt.exit(),
+        Event::WindowEvent {
+            event: WindowEvent::RedrawRequested,
+            ..
+        } => {
+            fill::fill_window(&window);
         }
+        _ => (),
     })
 }
 

diff --git a/examples/fullscreen.rs b/examples/fullscreen.rs
@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::dpi::PhysicalSize;
 use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
+use winit::event_loop::EventLoop;
 use winit::keyboard::Key;
 use winit::window::{Fullscreen, WindowBuilder};
 
@@ -53,8 +53,6 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("- A\tToggle mAx size limit");
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

diff --git a/examples/handling_close.rs b/examples/handling_close.rs
@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::Key,
     window::WindowBuilder,
 };
@@ -23,8 +23,6 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut close_requested = false;
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => {

diff --git a/examples/ime.rs b/examples/ime.rs
@@ -5,7 +5,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     dpi::{PhysicalPosition, PhysicalSize},
     event::{ElementState, Event, Ime, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::{Key, KeyCode},
     window::{ImePurpose, WindowBuilder},
 };
@@ -40,7 +40,6 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut ime_pos = PhysicalPosition::new(0.0, 0.0);
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

diff --git a/examples/key_binding.rs b/examples/key_binding.rs
@@ -4,7 +4,7 @@
 use winit::{
     dpi::LogicalSize,
     event::{ElementState, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::{Key, ModifiersState},
     // WARNING: This is not available on all platforms (for example on the web).
     platform::modifier_supplement::KeyEventExtModifierSupplement,
@@ -32,8 +32,6 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut modifiers = ModifiersState::default();
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

diff --git a/examples/mouse_wheel.rs b/examples/mouse_wheel.rs
@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -35,8 +35,6 @@ In other words, the deltas indicate the direction in which to move the content (
     );
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

diff --git a/examples/multithreaded.rs b/examples/multithreaded.rs
@@ -8,7 +8,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use winit::{
         dpi::{PhysicalPosition, PhysicalSize, Position, Size},
         event::{ElementState, Event, KeyEvent, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         keyboard::{Key, ModifiersState},
         window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
     };
@@ -174,10 +174,9 @@ fn main() -> Result<(), impl std::error::Error> {
         });
     }
     event_loop.run(move |event, elwt| {
-        match !window_senders.is_empty() {
-            true => elwt.set_control_flow(ControlFlow::Wait),
-            false => elwt.exit(),
-        };
+        if window_senders.is_empty() {
+            elwt.exit()
+        }
         match event {
             Event::WindowEvent { event, window_id } => match event {
                 WindowEvent::CloseRequested

diff --git a/examples/multiwindow.rs b/examples/multiwindow.rs
@@ -5,7 +5,7 @@ use std::collections::HashMap;
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::Key,
     window::Window,
 };
@@ -27,8 +27,6 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("Press N to open a new window.");
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, window_id } = event {
             match event {
                 WindowEvent::CloseRequested => {

diff --git a/examples/request_redraw.rs b/examples/request_redraw.rs
@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -22,8 +22,6 @@ fn main() -> Result<(), impl std::error::Error> {
     event_loop.run(move |event, elwt| {
         println!("{event:?}");
 
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

diff --git a/examples/request_redraw_threaded.rs b/examples/request_redraw_threaded.rs
@@ -7,7 +7,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         window::WindowBuilder,
     };
 
@@ -36,8 +36,6 @@ fn main() -> Result<(), impl std::error::Error> {
     event_loop.run(move |event, elwt| {
         println!("{event:?}");
 
-        elwt.set_control_flow(ControlFlow::Wait);
-
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,

diff --git a/examples/resizable.rs b/examples/resizable.rs
@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::KeyCode,
     window::WindowBuilder,
 };
@@ -28,8 +28,6 @@ fn main() -> Result<(), impl std::error::Error> {
         .unwrap();
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),