Add methods to set ControlFlow operation

This allows downstream users to avoid importing `ControlFlow` from winit.
rib · Apr 10, 2022 · d624a3e · d624a3e
1 parent c57294b
commit d624a3e
Show file tree

Hide file tree

Showing 27 changed files with 120 additions and 86 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -32,6 +32,7 @@ And please only add new entries to the top of this list, right below the `# Unre
 - On Wayland, fix polling during consecutive `EventLoop::run_return` invocations.
 - On Windows, fix race issue creating fullscreen windows with `WindowBuilder::with_fullscreen`
 - On Android, `virtual_keycode` for `KeyboardInput` events is now filled in where a suitable match is found.
+- Added helper methods on `ControlFlow` to set its value.
 
 # 0.26.1 (2022-01-05)
 

diff --git a/examples/control_flow.rs b/examples/control_flow.rs
@@ -3,7 +3,7 @@ use std::{thread, time};
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -88,23 +88,21 @@ fn main() {
                     window.request_redraw();
                 }
                 if close_requested {
-                    *control_flow = ControlFlow::Exit;
+                    control_flow.set_exit();
                 }
             }
             Event::RedrawRequested(_window_id) => {}
             Event::RedrawEventsCleared => {
-                *control_flow = match mode {
-                    Mode::Wait => ControlFlow::Wait,
+                match mode {
+                    Mode::Wait => control_flow.set_wait(),
                     Mode::WaitUntil => {
-                        if wait_cancelled {
-                            *control_flow
-                        } else {
-                            ControlFlow::WaitUntil(instant::Instant::now() + WAIT_TIME)
+                        if !wait_cancelled {
+                            control_flow.set_wait_until(instant::Instant::now() + WAIT_TIME);
                         }
                     }
                     Mode::Poll => {
                         thread::sleep(POLL_SLEEP_TIME);
-                        ControlFlow::Poll
+                        control_flow.set_poll();
                     }
                 };
             }

diff --git a/examples/cursor.rs b/examples/cursor.rs
@@ -1,7 +1,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::{CursorIcon, WindowBuilder},
 };
 
@@ -15,7 +15,7 @@ fn main() {
     let mut cursor_idx = 0;
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent {
@@ -42,7 +42,7 @@ fn main() {
                 event: WindowEvent::CloseRequested,
                 ..
             } => {
-                *control_flow = ControlFlow::Exit;
+                control_flow.set_exit();
             }
             _ => (),
         }

diff --git a/examples/cursor_grab.rs b/examples/cursor_grab.rs
@@ -1,7 +1,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -17,11 +17,11 @@ fn main() {
     let mut modifiers = ModifiersState::default();
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
                         KeyboardInput {
@@ -33,7 +33,7 @@ fn main() {
                 } => {
                     use winit::event::VirtualKeyCode::*;
                     match key {
-                        Escape => *control_flow = ControlFlow::Exit,
+                        Escape => control_flow.set_exit(),
                         G => window.set_cursor_grab(!modifiers.shift()).unwrap(),
                         H => window.set_cursor_visible(modifiers.shift()),
                         _ => (),

diff --git a/examples/custom_events.rs b/examples/custom_events.rs
@@ -3,7 +3,7 @@ fn main() {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoopBuilder},
+        event_loop::EventLoopBuilder,
         window::WindowBuilder,
     };
 
@@ -34,14 +34,14 @@ fn main() {
     });
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::UserEvent(event) => println!("user event: {:?}", event),
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
-            } => *control_flow = ControlFlow::Exit,
+            } => control_flow.set_exit(),
             _ => (),
         }
     });

diff --git a/examples/drag_window.rs b/examples/drag_window.rs
@@ -3,7 +3,7 @@ use winit::{
     event::{
         ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
     },
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::{Window, WindowBuilder, WindowId},
 };
 
@@ -22,7 +22,7 @@ fn main() {
             eprintln!("Switch which window is to be dragged by pressing \"x\".")
         }
         Event::WindowEvent { event, window_id } => match event {
-            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+            WindowEvent::CloseRequested => control_flow.set_exit(),
             WindowEvent::MouseInput {
                 state: ElementState::Pressed,
                 button: MouseButton::Left,

diff --git a/examples/fullscreen.rs b/examples/fullscreen.rs
@@ -2,7 +2,7 @@ use std::io::{stdin, stdout, Write};
 
 use simple_logger::SimpleLogger;
 use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
+use winit::event_loop::EventLoop;
 use winit::monitor::{MonitorHandle, VideoMode};
 use winit::window::{Fullscreen, WindowBuilder};
 
@@ -32,11 +32,11 @@ fn main() {
         .unwrap();
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
                         KeyboardInput {
@@ -46,7 +46,7 @@ fn main() {
                         },
                     ..
                 } => match (virtual_code, state) {
-                    (VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
+                    (VirtualKeyCode::Escape, _) => control_flow.set_exit(),
                     (VirtualKeyCode::F, ElementState::Pressed) => {
                         if window.fullscreen().is_some() {
                             window.set_fullscreen(None);

diff --git a/examples/handling_close.rs b/examples/handling_close.rs
@@ -1,7 +1,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -21,7 +21,7 @@ fn main() {
             ElementState::Released,
             VirtualKeyCode::{N, Y},
         };
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => {
@@ -63,7 +63,7 @@ fn main() {
                                     // event loop (i.e. if it's a multi-window application), you need to
                                     // drop the window. That closes it, and results in `Destroyed` being
                                     // sent.
-                                    *control_flow = ControlFlow::Exit;
+                                    control_flow.set_exit();
                                 }
                             }
                             N => {

diff --git a/examples/min_max_size.rs b/examples/min_max_size.rs
@@ -2,7 +2,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -16,14 +16,14 @@ fn main() {
     window.set_max_inner_size(Some(LogicalSize::new(800.0, 400.0)));
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
         println!("{:?}", event);
 
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
-            } => *control_flow = ControlFlow::Exit,
+            } => control_flow.set_exit(),
             _ => (),
         }
     });

diff --git a/examples/minimize.rs b/examples/minimize.rs
@@ -2,7 +2,7 @@ extern crate winit;
 
 use simple_logger::SimpleLogger;
 use winit::event::{Event, VirtualKeyCode, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
+use winit::event_loop::EventLoop;
 use winit::window::WindowBuilder;
 
 fn main() {
@@ -15,13 +15,13 @@ fn main() {
         .unwrap();
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
-            } => *control_flow = ControlFlow::Exit,
+            } => control_flow.set_exit(),
 
             // Keyboard input event to handle minimize via a hotkey
             Event::WindowEvent {

diff --git a/examples/mouse_wheel.rs b/examples/mouse_wheel.rs
@@ -1,7 +1,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -30,11 +30,11 @@ In other words, the deltas indicate the direction in which to move the content (
     );
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::MouseWheel { delta, .. } => match delta {
                     winit::event::MouseScrollDelta::LineDelta(x, y) => {
                         println!("mouse wheel Line Delta: ({},{})", x, y);

diff --git a/examples/multithreaded.rs b/examples/multithreaded.rs
@@ -6,7 +6,7 @@ fn main() {
     use winit::{
         dpi::{PhysicalPosition, PhysicalSize, Position, Size},
         event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         window::{CursorIcon, Fullscreen, WindowBuilder},
     };
 
@@ -143,9 +143,9 @@ fn main() {
         });
     }
     event_loop.run(move |event, _event_loop, control_flow| {
-        *control_flow = match !window_senders.is_empty() {
-            true => ControlFlow::Wait,
-            false => ControlFlow::Exit,
+        match !window_senders.is_empty() {
+            true => control_flow.set_wait(),
+            false => control_flow.set_exit(),
         };
         match event {
             Event::WindowEvent { event, window_id } => match event {

diff --git a/examples/multiwindow.rs b/examples/multiwindow.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::Window,
 };
 
@@ -18,7 +18,7 @@ fn main() {
     }
 
     event_loop.run(move |event, event_loop, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, window_id } => {
@@ -30,7 +30,7 @@ fn main() {
                         windows.remove(&window_id);
 
                         if windows.is_empty() {
-                            *control_flow = ControlFlow::Exit;
+                            control_flow.set_exit();
                         }
                     }
                     WindowEvent::KeyboardInput {

diff --git a/examples/request_redraw.rs b/examples/request_redraw.rs
@@ -1,7 +1,7 @@
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
@@ -17,11 +17,11 @@ fn main() {
     event_loop.run(move |event, _, control_flow| {
         println!("{:?}", event);
 
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::MouseInput {
                     state: ElementState::Released,
                     ..

diff --git a/examples/request_redraw_threaded.rs b/examples/request_redraw_threaded.rs
@@ -5,7 +5,7 @@ fn main() {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoop,
         window::WindowBuilder,
     };
 
@@ -25,11 +25,11 @@ fn main() {
     event_loop.run(move |event, _, control_flow| {
         println!("{:?}", event);
 
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 _ => (),
             },
             Event::RedrawRequested(_) => {