Make ControlFlow::Wait the default (#3106)

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
 

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,

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 => {

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 {

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,10 +22,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let mut modifiers = ModifiersState::default();
 
-    event_loop.run(move |event, elwt| {
+    event_loop.run(move |event, elwt| match event {
-        elwt.set_control_flow(ControlFlow::Wait);
-
-        match event {
         Event::WindowEvent { event, .. } => match event {
             WindowEvent::CloseRequested => elwt.exit(),
             WindowEvent::KeyboardInput {
@@ -72,6 +69,5 @@ fn main() -> Result<(), impl std::error::Error> {
             _ => (),
         },
         _ => (),
-        }
     })
 }

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,10 +40,7 @@ fn main() -> Result<(), impl std::error::Error> {
         }
     });
 
-    event_loop.run(move |event, elwt| {
+    event_loop.run(move |event, elwt| match event {
-        elwt.set_control_flow(ControlFlow::Wait);
-
-        match event {
         Event::UserEvent(event) => println!("user event: {event:?}"),
         Event::WindowEvent {
             event: WindowEvent::CloseRequested,
@@ -56,7 +53,6 @@ fn main() -> Result<(), impl std::error::Error> {
             fill::fill_window(&window);
         }
         _ => (),
-        }
     })
 }
 

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(),

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 => {

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(),

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(),

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(),

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() {
+        if window_senders.is_empty() {
-            true => elwt.set_control_flow(ControlFlow::Wait),
+            elwt.exit()
-            false => elwt.exit(),
+        }
-        };
         match event {
             Event::WindowEvent { event, window_id } => match event {
                 WindowEvent::CloseRequested

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 => {

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(),

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,

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(),

examples/startup_notification.rs

@@ -10,7 +10,7 @@ mod example {
     use std::rc::Rc;
 
     use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
-    use winit::event_loop::{ControlFlow, EventLoop};
+    use winit::event_loop::EventLoop;
     use winit::keyboard::Key;
     use winit::platform::startup_notify::{
         EventLoopExtStartupNotify, WindowBuilderExtStartupNotify, WindowExtStartupNotify,
@@ -102,8 +102,6 @@ mod example {
                 counter += 1;
                 create_first_window = false;
             }
-
-            elwt.set_control_flow(ControlFlow::Wait);
         })
     }
 }

examples/theme.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::{Theme, WindowBuilder},
 };
@@ -28,8 +28,6 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("  (D) Dark theme");
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { window_id, event } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

examples/touchpad_gestures.rs

@@ -1,7 +1,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -20,8 +20,6 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("Only supported on macOS at the moment.");
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),

examples/transparent.rs

@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -23,7 +23,6 @@ fn main() -> Result<(), impl std::error::Error> {
     window.set_title("A fantastic window!");
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
         println!("{event:?}");
 
         if let Event::WindowEvent { event, .. } = event {

examples/web.rs

@@ -2,7 +2,7 @@
 
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::KeyCode,
     window::{Fullscreen, WindowBuilder},
 };
@@ -22,8 +22,6 @@ pub fn main() -> Result<(), impl std::error::Error> {
     let log_list = wasm::insert_canvas_and_create_log_list(&window);
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         #[cfg(wasm_platform)]
         wasm::log_event(&log_list, &event);
 

examples/web_aspect_ratio.rs

@@ -12,7 +12,7 @@ mod wasm {
     use winit::{
         dpi::PhysicalSize,
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         platform::web::WindowBuilderExtWebSys,
         window::{Window, WindowBuilder},
     };
@@ -47,10 +47,7 @@ This example demonstrates the desired future functionality which will possibly b
         // Render once with the size info we currently have
         render_circle(&canvas, window.inner_size());
 
-        let _ = event_loop.run(move |event, elwt| {
+        let _ = event_loop.run(move |event, _| match event {
-            elwt.set_control_flow(ControlFlow::Wait);
-
-            match event {
             Event::WindowEvent {
                 event: WindowEvent::Resized(resize),
                 window_id,
@@ -58,7 +55,6 @@ This example demonstrates the desired future functionality which will possibly b
                 render_circle(&canvas, resize);
             }
             _ => (),
-            }
         });
     }
 

examples/window.rs

@@ -3,7 +3,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -21,7 +21,6 @@ fn main() -> Result<(), impl std::error::Error> {
         .unwrap();
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
         println!("{event:?}");
 
         match event {

examples/window_buttons.rs

@@ -6,7 +6,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, DeviceEvents, EventLoop},
+    event_loop::{DeviceEvents, EventLoop},
     keyboard::Key,
     window::{WindowBuilder, WindowButtons},
 };
@@ -32,8 +32,6 @@ fn main() -> Result<(), impl std::error::Error> {
     event_loop.listen_device_events(DeviceEvents::Always);
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         if let Event::WindowEvent { window_id, event } = event {
             match event {
                 WindowEvent::KeyboardInput {

examples/window_debug.rs

@@ -6,7 +6,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     dpi::{LogicalSize, PhysicalSize},
     event::{DeviceEvent, ElementState, Event, KeyEvent, RawKeyEvent, WindowEvent},
-    event_loop::{ControlFlow, DeviceEvents, EventLoop},
+    event_loop::{DeviceEvents, EventLoop},
     keyboard::{Key, KeyCode},
     window::{Fullscreen, WindowBuilder},
 };
@@ -39,8 +39,6 @@ fn main() -> Result<(), impl std::error::Error> {
     event_loop.listen_device_events(DeviceEvents::Always);
 
     event_loop.run(move |event, elwt| {
-        elwt.set_control_flow(ControlFlow::Wait);
-
         match event {
             // This used to use the virtual key, but the new API
             // only provides the `physical_key` (`Code`).

examples/window_icon.rs

@@ -5,7 +5,7 @@ use std::path::Path;
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::{Icon, WindowBuilder},
 };
 
@@ -34,8 +34,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(),

examples/window_ondemand.rs

@@ -10,7 +10,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use winit::{
         error::EventLoopError,
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         platform::run_ondemand::EventLoopExtRunOnDemand,
         window::{Window, WindowBuilder, WindowId},
     };
@@ -31,7 +31,6 @@ fn main() -> Result<(), impl std::error::Error> {
         let mut app = App::default();
 
         event_loop.run_ondemand(move |event, elwt| {
-            elwt.set_control_flow(ControlFlow::Wait);
             println!("Run {idx}: {:?}", event);
 
             if let Some(window) = &app.window {

examples/window_option_as_alt.rs

@@ -7,7 +7,7 @@ use winit::platform::macos::{OptionAsAlt, WindowExtMacOS};
 use winit::{
     event::ElementState,
     event::{Event, MouseButton, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -31,10 +31,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let mut option_as_alt = window.option_as_alt();
 
-    event_loop.run(move |event, elwt| {
+    event_loop.run(move |event, elwt| match event {
-        elwt.set_control_flow(ControlFlow::Wait);
-
-        match event {
         Event::WindowEvent {
             event: WindowEvent::CloseRequested,
             window_id,
@@ -66,7 +63,6 @@ fn main() -> Result<(), impl std::error::Error> {
         }
 
         _ => (),
-        }
     })
 }
 

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::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
         window::WindowBuilder,
     };
@@ -33,8 +33,6 @@ fn main() -> std::process::ExitCode {
     'main: loop {
         let timeout = Some(Duration::ZERO);
         let status = event_loop.pump_events(timeout, |event, elwt| {
-            elwt.set_control_flow(ControlFlow::Wait);
-
             if let Event::WindowEvent { event, .. } = &event {
                 // Print only Window events to reduce noise
                 println!("{event:?}");

examples/window_resize_increments.rs

@@ -3,7 +3,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::Key,
     window::WindowBuilder,
 };
@@ -24,10 +24,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let mut has_increments = true;
 
-    event_loop.run(move |event, elwt| {
+    event_loop.run(move |event, elwt| match event {
-        elwt.set_control_flow(ControlFlow::Wait);
-
-        match event {
         Event::WindowEvent { event, window_id } if window_id == window.id() => match event {
             WindowEvent::CloseRequested => elwt.exit(),
             WindowEvent::KeyboardInput {
@@ -56,6 +53,5 @@ fn main() -> Result<(), impl std::error::Error> {
         Event::AboutToWait => window.request_redraw(),
 
         _ => (),
-        }
     })
 }

examples/window_tabbing.rs

@@ -8,7 +8,7 @@ use simple_logger::SimpleLogger;
 #[cfg(target_os = "macos")]
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     keyboard::Key,
     platform::macos::{WindowBuilderExtMacOS, WindowExtMacOS},
     window::{Window, WindowBuilder},
@@ -31,8 +31,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 => {

examples/x11_embed.rs

@@ -10,7 +10,7 @@ mod imple {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         platform::x11::WindowBuilderExtX11,
         window::WindowBuilder,
     };
@@ -33,8 +33,6 @@ mod imple {
             .unwrap();
 
         event_loop.run(move |event, elwt| {
-            elwt.set_control_flow(ControlFlow::Wait);
-
             match event {
                 Event::WindowEvent {
                     event: WindowEvent::CloseRequested,

src/event_loop.rs

@@ -151,16 +151,17 @@ impl<T> fmt::Debug for EventLoopWindowTarget<T> {
 ///
 /// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted.
 ///
-/// Defaults to [`Poll`].
+/// Defaults to [`Wait`].
 ///
-/// [`Poll`]: Self::Poll
+/// [`Wait`]: Self::Wait
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub enum ControlFlow {
     /// When the current loop iteration finishes, immediately begin a new iteration regardless of
     /// whether or not new events are available to process.
     Poll,
 
     /// When the current loop iteration finishes, suspend the thread until another event arrives.
+    #[default]
     Wait,
 
     /// When the current loop iteration finishes, suspend the thread until either another event
@@ -190,13 +191,6 @@ impl ControlFlow {
     }
 }
 
-impl Default for ControlFlow {
-    #[inline(always)]
-    fn default() -> Self {
-        Self::Poll
-    }
-}
-
 impl EventLoop<()> {
     /// Alias for [`EventLoopBuilder::new().build()`].
     ///

src/window.rs

@@ -40,7 +40,7 @@ pub use raw_window_handle;
 /// ```no_run
 /// use winit::{
 ///     event::{Event, WindowEvent},
-///     event_loop::{ControlFlow, EventLoop},
+///     event_loop::EventLoop,
 ///     window::Window,
 /// };
 ///
@@ -48,8 +48,6 @@ pub use raw_window_handle;
 /// let window = Window::new(&event_loop).unwrap();
 ///
 /// event_loop.run(move |event, elwt| {
-///     elwt.set_control_flow(ControlFlow::Wait);
-///
 ///     match event {
 ///         Event::WindowEvent {
 ///             event: WindowEvent::CloseRequested,