From 67d3fd28f7ba8f788abad4b90ffd0cd968a960bb Mon Sep 17 00:00:00 2001 From: daxpedda Date: Sun, 27 Aug 2023 16:15:09 +0200 Subject: [PATCH] Move `Event::RedrawRequested` to `WindowEvent` (#3049) --- CHANGELOG.md | 1 + examples/child_window.rs | 9 +- examples/control_flow.rs | 6 +- examples/cursor.rs | 53 ++++---- examples/cursor_grab.rs | 2 +- examples/custom_events.rs | 5 +- examples/drag_window.rs | 15 ++- examples/fullscreen.rs | 11 +- examples/handling_close.rs | 111 ++++++++-------- examples/ime.rs | 100 +++++++-------- examples/key_binding.rs | 11 +- examples/mouse_wheel.rs | 11 +- examples/multiwindow.rs | 57 ++++----- examples/request_redraw.rs | 13 +- examples/request_redraw_threaded.rs | 5 +- examples/resizable.rs | 11 +- examples/startup_notification.rs | 79 ++++++------ examples/theme.rs | 71 +++++------ examples/timer.rs | 5 +- examples/touchpad_gestures.rs | 5 +- examples/transparent.rs | 15 +-- examples/window.rs | 19 +-- examples/window_buttons.rs | 61 ++++----- examples/window_debug.rs | 120 +++++++++--------- examples/window_drag_resize.rs | 7 +- examples/window_icon.rs | 10 +- examples/window_ondemand.rs | 5 +- examples/window_option_as_alt.rs | 7 +- examples/window_pump_events.rs | 5 +- examples/window_resize_increments.rs | 53 ++++---- examples/window_tabbing.rs | 117 +++++++++-------- examples/x11_embed.rs | 5 +- src/event.rs | 26 ++-- src/lib.rs | 5 +- src/platform_impl/android/mod.rs | 5 +- src/platform_impl/ios/app_state.rs | 15 ++- src/platform_impl/ios/view.rs | 7 +- .../linux/wayland/event_loop/mod.rs | 5 +- .../linux/x11/event_processor.rs | 5 +- src/platform_impl/linux/x11/mod.rs | 13 +- src/platform_impl/macos/app_state.rs | 12 +- src/platform_impl/orbital/event_loop.rs | 5 +- src/platform_impl/web/event_loop/runner.rs | 8 +- src/platform_impl/windows/event_loop.rs | 5 +- .../windows/event_loop/runner.rs | 6 +- src/window.rs | 12 +- 46 files changed, 572 insertions(+), 562 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bb638803..d6f7dec6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ And please only add new entries to the top of this list, right below the `# Unre - Fix window size sometimes being invalid when resizing on macOS. - On Web, `ControlFlow::Poll` and `ControlFlow::WaitUntil` are now using the Prioritized Task Scheduling API. `setTimeout()` with a trick to circumvent throttling to 4ms is used as a fallback. - On Web, never return a `MonitorHandle`. +- **Breaking:** Move `Event::RedrawRequested` to `WindowEvent::RedrawRequested`. # 0.29.1-beta diff --git a/examples/child_window.rs b/examples/child_window.rs index 529930e2..78defa8f 100644 --- a/examples/child_window.rs +++ b/examples/child_window.rs @@ -72,12 +72,13 @@ fn main() -> Result<(), impl std::error::Error> { } => { spawn_child_window(&parent_window, event_loop, &mut windows); } + WindowEvent::RedrawRequested => { + if let Some(window) = windows.get(&window_id) { + fill::fill_window(window); + } + } _ => (), } - } else if let Event::RedrawRequested(wid) = event { - if let Some(window) = windows.get(&wid) { - fill::fill_window(window); - } } }) } diff --git a/examples/control_flow.rs b/examples/control_flow.rs index 8ed24f4f..e9dc0a1e 100644 --- a/examples/control_flow.rs +++ b/examples/control_flow.rs @@ -93,6 +93,9 @@ fn main() -> Result<(), impl std::error::Error> { } _ => (), }, + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), }, Event::AboutToWait => { @@ -117,9 +120,6 @@ fn main() -> Result<(), impl std::error::Error> { control_flow.set_exit(); } } - Event::RedrawRequested(_window_id) => { - fill::fill_window(&window); - } _ => (), } }) diff --git a/examples/cursor.rs b/examples/cursor.rs index bba0d012..1c6bbea8 100644 --- a/examples/cursor.rs +++ b/examples/cursor.rs @@ -22,37 +22,32 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { - event: - WindowEvent::KeyboardInput { - event: - KeyEvent { - state: ElementState::Pressed, - .. - }, - .. - }, - .. - } => { - println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]); - window.set_cursor_icon(CURSORS[cursor_idx]); - if cursor_idx < CURSORS.len() - 1 { - cursor_idx += 1; - } else { - cursor_idx = 0; + if let Event::WindowEvent { event, .. } = event { + match event { + WindowEvent::KeyboardInput { + event: + KeyEvent { + state: ElementState::Pressed, + .. + }, + .. + } => { + println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]); + window.set_cursor_icon(CURSORS[cursor_idx]); + if cursor_idx < CURSORS.len() - 1 { + cursor_idx += 1; + } else { + cursor_idx = 0; + } } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } + WindowEvent::CloseRequested => { + control_flow.set_exit(); + } + _ => (), } - Event::WindowEvent { - event: WindowEvent::CloseRequested, - .. - } => { - control_flow.set_exit(); - } - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } - _ => (), } }) } diff --git a/examples/cursor_grab.rs b/examples/cursor_grab.rs index 99a42825..b6ed5161 100644 --- a/examples/cursor_grab.rs +++ b/examples/cursor_grab.rs @@ -60,6 +60,7 @@ fn main() -> Result<(), impl std::error::Error> { } } WindowEvent::ModifiersChanged(new) => modifiers = new.state(), + WindowEvent::RedrawRequested => fill::fill_window(&window), _ => (), }, Event::DeviceEvent { event, .. } => match event { @@ -70,7 +71,6 @@ fn main() -> Result<(), impl std::error::Error> { }, _ => (), }, - Event::RedrawRequested(_) => fill::fill_window(&window), _ => (), } }) diff --git a/examples/custom_events.rs b/examples/custom_events.rs index ecadebf5..21b0d82d 100644 --- a/examples/custom_events.rs +++ b/examples/custom_events.rs @@ -49,7 +49,10 @@ fn main() -> Result<(), impl std::error::Error> { event: WindowEvent::CloseRequested, .. } => control_flow.set_exit(), - Event::RedrawRequested(_) => { + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } => { fill::fill_window(&window); } _ => (), diff --git a/examples/drag_window.rs b/examples/drag_window.rs index 97ed5c8d..9b644a6e 100644 --- a/examples/drag_window.rs +++ b/examples/drag_window.rs @@ -59,15 +59,16 @@ fn main() -> Result<(), impl std::error::Error> { name_windows(entered_id, switched, &window_1, &window_2); println!("Switched!") } + WindowEvent::RedrawRequested => { + if window_id == window_1.id() { + fill::fill_window(&window_1); + } else if window_id == window_2.id() { + fill::fill_window(&window_2); + } + } _ => (), }, - Event::RedrawRequested(wid) => { - if wid == window_1.id() { - fill::fill_window(&window_1); - } else if wid == window_2.id() { - fill::fill_window(&window_2); - } - } + _ => (), }) } diff --git a/examples/fullscreen.rs b/examples/fullscreen.rs index 4ff40885..a0b3d37c 100644 --- a/examples/fullscreen.rs +++ b/examples/fullscreen.rs @@ -55,8 +55,8 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, elwt, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { event, .. } => match event { + if let Event::WindowEvent { event, .. } = event { + match event { WindowEvent::CloseRequested => control_flow.set_exit(), WindowEvent::KeyboardInput { event: @@ -155,12 +155,11 @@ fn main() -> Result<(), impl std::error::Error> { }, _ => (), }, + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), - }, - Event::RedrawRequested(_) => { - fill::fill_window(&window); } - _ => {} } }) } diff --git a/examples/handling_close.rs b/examples/handling_close.rs index 578e9539..2d6e8743 100644 --- a/examples/handling_close.rs +++ b/examples/handling_close.rs @@ -25,67 +25,64 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { event, .. } => { - match event { - WindowEvent::CloseRequested => { - // `CloseRequested` is sent when the close button on the window is pressed (or - // through whatever other mechanisms the window manager provides for closing a - // window). If you don't handle this event, the close button won't actually do - // anything. + if let Event::WindowEvent { event, .. } = event { + match event { + WindowEvent::CloseRequested => { + // `CloseRequested` is sent when the close button on the window is pressed (or + // through whatever other mechanisms the window manager provides for closing a + // window). If you don't handle this event, the close button won't actually do + // anything. - // A common thing to do here is prompt the user if they have unsaved work. - // Creating a proper dialog box for that is far beyond the scope of this - // example, so here we'll just respond to the Y and N keys. - println!("Are you ready to bid your window farewell? [Y/N]"); - close_requested = true; + // A common thing to do here is prompt the user if they have unsaved work. + // Creating a proper dialog box for that is far beyond the scope of this + // example, so here we'll just respond to the Y and N keys. + println!("Are you ready to bid your window farewell? [Y/N]"); + close_requested = true; - // In applications where you can safely close the window without further - // action from the user, this is generally where you'd handle cleanup before - // closing the window. How to close the window is detailed in the handler for - // the Y key. - } - WindowEvent::KeyboardInput { - event: - KeyEvent { - logical_key: key, - state: ElementState::Released, - .. - }, - .. - } => { - // WARNING: Consider using `key_without_modifers()` if available on your platform. - // See the `key_binding` example - match key.as_ref() { - Key::Character("y") => { - if close_requested { - // This is where you'll want to do any cleanup you need. - println!("Buh-bye!"); - - // For a single-window application like this, you'd normally just - // break out of the event loop here. If you wanted to keep running the - // 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.set_exit(); - } - } - Key::Character("n") => { - if close_requested { - println!("Your window will continue to stay by your side."); - close_requested = false; - } - } - _ => (), - } - } - _ => (), + // In applications where you can safely close the window without further + // action from the user, this is generally where you'd handle cleanup before + // closing the window. How to close the window is detailed in the handler for + // the Y key. } + WindowEvent::KeyboardInput { + event: + KeyEvent { + logical_key: key, + state: ElementState::Released, + .. + }, + .. + } => { + // WARNING: Consider using `key_without_modifers()` if available on your platform. + // See the `key_binding` example + match key.as_ref() { + Key::Character("y") => { + if close_requested { + // This is where you'll want to do any cleanup you need. + println!("Buh-bye!"); + + // For a single-window application like this, you'd normally just + // break out of the event loop here. If you wanted to keep running the + // 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.set_exit(); + } + } + Key::Character("n") => { + if close_requested { + println!("Your window will continue to stay by your side."); + close_requested = false; + } + } + _ => (), + } + } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } + _ => (), } - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } - _ => (), } }) } diff --git a/examples/ime.rs b/examples/ime.rs index fe33fa6c..a8582b66 100644 --- a/examples/ime.rs +++ b/examples/ime.rs @@ -41,69 +41,55 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { *control_flow = ControlFlow::Wait; - match event { - Event::WindowEvent { - event: WindowEvent::CloseRequested, - .. - } => *control_flow = ControlFlow::Exit, - Event::WindowEvent { - event: WindowEvent::CursorMoved { position, .. }, - .. - } => { - cursor_position = position; - } - Event::WindowEvent { - event: - WindowEvent::MouseInput { - state: ElementState::Released, - .. - }, - .. - } => { - println!( - "Setting ime position to {}, {}", - cursor_position.x, cursor_position.y - ); - ime_pos = cursor_position; - if may_show_ime { - window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10)); + if let Event::WindowEvent { event, .. } = event { + match event { + WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit, + WindowEvent::CursorMoved { position, .. } => { + cursor_position = position; } - } - Event::WindowEvent { - event: WindowEvent::Ime(event), - .. - } => { - println!("{event:?}"); - may_show_ime = event != Ime::Disabled; - if may_show_ime { - window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10)); + WindowEvent::MouseInput { + state: ElementState::Released, + .. + } => { + println!( + "Setting ime position to {}, {}", + cursor_position.x, cursor_position.y + ); + ime_pos = cursor_position; + if may_show_ime { + window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10)); + } } - } - Event::WindowEvent { - event: WindowEvent::KeyboardInput { event, .. }, - .. - } => { - println!("key: {event:?}"); + WindowEvent::Ime(event) => { + println!("{event:?}"); + may_show_ime = event != Ime::Disabled; + if may_show_ime { + window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10)); + } + } + WindowEvent::KeyboardInput { event, .. } => { + println!("key: {event:?}"); - if event.state == ElementState::Pressed && event.physical_key == KeyCode::F2 { - ime_allowed = !ime_allowed; - window.set_ime_allowed(ime_allowed); - println!("\nIME allowed: {ime_allowed}\n"); + if event.state == ElementState::Pressed && event.physical_key == KeyCode::F2 { + ime_allowed = !ime_allowed; + window.set_ime_allowed(ime_allowed); + println!("\nIME allowed: {ime_allowed}\n"); + } + if event.state == ElementState::Pressed && event.logical_key == Key::F3 { + ime_purpose = match ime_purpose { + ImePurpose::Normal => ImePurpose::Password, + ImePurpose::Password => ImePurpose::Terminal, + _ => ImePurpose::Normal, + }; + window.set_ime_purpose(ime_purpose); + println!("\nIME purpose: {ime_purpose:?}\n"); + } } - if event.state == ElementState::Pressed && event.logical_key == Key::F3 { - ime_purpose = match ime_purpose { - ImePurpose::Normal => ImePurpose::Password, - ImePurpose::Password => ImePurpose::Terminal, - _ => ImePurpose::Normal, - }; - window.set_ime_purpose(ime_purpose); - println!("\nIME purpose: {ime_purpose:?}\n"); + WindowEvent::RedrawRequested => { + fill::fill_window(&window); } + _ => (), } - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } - _ => (), } }) } diff --git a/examples/key_binding.rs b/examples/key_binding.rs index 5f438a0e..8dcb2966 100644 --- a/examples/key_binding.rs +++ b/examples/key_binding.rs @@ -34,8 +34,8 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { *control_flow = ControlFlow::Wait; - match event { - Event::WindowEvent { event, .. } => match event { + if let Event::WindowEvent { event, .. } = event { + match event { WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit, WindowEvent::ModifiersChanged(new) => { modifiers = new.state(); @@ -54,12 +54,11 @@ fn main() -> Result<(), impl std::error::Error> { } } } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), - }, - Event::RedrawRequested(_) => { - fill::fill_window(&window); } - _ => (), }; }) } diff --git a/examples/mouse_wheel.rs b/examples/mouse_wheel.rs index 9c32aa35..73e45aa6 100644 --- a/examples/mouse_wheel.rs +++ b/examples/mouse_wheel.rs @@ -37,8 +37,8 @@ In other words, the deltas indicate the direction in which to move the content ( event_loop.run(move |event, _, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { event, .. } => match event { + if let Event::WindowEvent { event, .. } = event { + match event { WindowEvent::CloseRequested => control_flow.set_exit(), WindowEvent::MouseWheel { delta, .. } => match delta { winit::event::MouseScrollDelta::LineDelta(x, y) => { @@ -57,12 +57,11 @@ In other words, the deltas indicate the direction in which to move the content ( window.set_outer_position(pos) } }, + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), - }, - Event::RedrawRequested(_) => { - fill::fill_window(&window); } - _ => (), } }) } diff --git a/examples/multiwindow.rs b/examples/multiwindow.rs index b4e82cdc..d1535802 100644 --- a/examples/multiwindow.rs +++ b/examples/multiwindow.rs @@ -29,42 +29,39 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, event_loop, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { event, window_id } => { - match event { - WindowEvent::CloseRequested => { - println!("Window {window_id:?} has received the signal to close"); + if let Event::WindowEvent { event, window_id } = event { + match event { + WindowEvent::CloseRequested => { + println!("Window {window_id:?} has received the signal to close"); - // This drops the window, causing it to close. - windows.remove(&window_id); + // This drops the window, causing it to close. + windows.remove(&window_id); - if windows.is_empty() { - control_flow.set_exit(); - } + if windows.is_empty() { + control_flow.set_exit(); } - WindowEvent::KeyboardInput { - event: - KeyEvent { - state: ElementState::Pressed, - logical_key: Key::Character(c), - .. - }, - is_synthetic: false, - .. - } if matches!(c.as_ref(), "n" | "N") => { - let window = Window::new(event_loop).unwrap(); - println!("Opened a new window: {:?}", window.id()); - windows.insert(window.id(), window); + } + WindowEvent::KeyboardInput { + event: + KeyEvent { + state: ElementState::Pressed, + logical_key: Key::Character(c), + .. + }, + is_synthetic: false, + .. + } if matches!(c.as_ref(), "n" | "N") => { + let window = Window::new(event_loop).unwrap(); + println!("Opened a new window: {:?}", window.id()); + windows.insert(window.id(), window); + } + WindowEvent::RedrawRequested => { + if let Some(window) = windows.get(&window_id) { + fill::fill_window(window); } - _ => (), } + _ => (), } - Event::RedrawRequested(window_id) => { - if let Some(window) = windows.get(&window_id) { - fill::fill_window(window); - } - } - _ => (), } }) } diff --git a/examples/request_redraw.rs b/examples/request_redraw.rs index fe3810e6..ed409f42 100644 --- a/examples/request_redraw.rs +++ b/examples/request_redraw.rs @@ -24,8 +24,8 @@ fn main() -> Result<(), impl std::error::Error> { control_flow.set_wait(); - match event { - Event::WindowEvent { event, .. } => match event { + if let Event::WindowEvent { event, .. } = event { + match event { WindowEvent::CloseRequested => control_flow.set_exit(), WindowEvent::MouseInput { state: ElementState::Released, @@ -33,13 +33,12 @@ fn main() -> Result<(), impl std::error::Error> { } => { window.request_redraw(); } + WindowEvent::RedrawRequested => { + println!("\nredrawing!\n"); + fill::fill_window(&window); + } _ => (), - }, - Event::RedrawRequested(_) => { - println!("\nredrawing!\n"); - fill::fill_window(&window); } - _ => (), } }) } diff --git a/examples/request_redraw_threaded.rs b/examples/request_redraw_threaded.rs index 173b399f..0e519a42 100644 --- a/examples/request_redraw_threaded.rs +++ b/examples/request_redraw_threaded.rs @@ -43,7 +43,10 @@ fn main() -> Result<(), impl std::error::Error> { event: WindowEvent::CloseRequested, .. } => control_flow.set_exit(), - Event::RedrawRequested(_) => { + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } => { println!("\nredrawing!\n"); fill::fill_window(&window); } diff --git a/examples/resizable.rs b/examples/resizable.rs index c6d0d095..468913e7 100644 --- a/examples/resizable.rs +++ b/examples/resizable.rs @@ -30,8 +30,8 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { event, .. } => match event { + if let Event::WindowEvent { event, .. } = event { + match event { WindowEvent::CloseRequested => control_flow.set_exit(), WindowEvent::KeyboardInput { event: @@ -46,12 +46,11 @@ fn main() -> Result<(), impl std::error::Error> { println!("Resizable: {resizable}"); window.set_resizable(resizable); } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), - }, - Event::RedrawRequested(_) => { - fill::fill_window(&window); } - _ => (), }; }) } diff --git a/examples/startup_notification.rs b/examples/startup_notification.rs index 5b684b87..2eaae311 100644 --- a/examples/startup_notification.rs +++ b/examples/startup_notification.rs @@ -36,56 +36,49 @@ mod example { match event { Event::Resumed => create_first_window = true, - Event::WindowEvent { - window_id, - event: - WindowEvent::KeyboardInput { - event: - KeyEvent { - logical_key, - state: ElementState::Pressed, - .. - }, - .. - }, - } => { - if logical_key == Key::Character("n".into()) { - if let Some(window) = windows.get(&window_id) { - // Request a new activation token on this window. - // Once we get it we will use it to create a window. - window - .request_activation_token() - .expect("Failed to request activation token."); + Event::WindowEvent { window_id, event } => match event { + WindowEvent::KeyboardInput { + event: + KeyEvent { + logical_key, + state: ElementState::Pressed, + .. + }, + .. + } => { + if logical_key == Key::Character("n".into()) { + if let Some(window) = windows.get(&window_id) { + // Request a new activation token on this window. + // Once we get it we will use it to create a window. + window + .request_activation_token() + .expect("Failed to request activation token."); + } } } - } - Event::WindowEvent { - window_id, - event: WindowEvent::CloseRequested, - } => { - // Remove the window from the map. - windows.remove(&window_id); - if windows.is_empty() { - flow.set_exit(); - return; + WindowEvent::CloseRequested => { + // Remove the window from the map. + windows.remove(&window_id); + if windows.is_empty() { + flow.set_exit(); + return; + } } - } - Event::WindowEvent { - event: WindowEvent::ActivationTokenDone { token, .. }, - .. - } => { - current_token = Some(token); - } - - Event::RedrawRequested(id) => { - if let Some(window) = windows.get(&id) { - super::fill::fill_window(window); + WindowEvent::ActivationTokenDone { token, .. } => { + current_token = Some(token); } - } - _ => {} + WindowEvent::RedrawRequested => { + if let Some(window) = windows.get(&window_id) { + super::fill::fill_window(window); + } + } + + _ => {} + }, + _ => (), } // See if we've passed the deadline. diff --git a/examples/theme.rs b/examples/theme.rs index 485d2481..17381e6e 100644 --- a/examples/theme.rs +++ b/examples/theme.rs @@ -30,50 +30,41 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { *control_flow = ControlFlow::Wait; - match event { - Event::WindowEvent { - event: WindowEvent::CloseRequested, - .. - } => *control_flow = ControlFlow::Exit, - Event::WindowEvent { - event: WindowEvent::ThemeChanged(theme), - window_id, - .. - } if window_id == window.id() => { - println!("Theme is changed: {theme:?}") - } - Event::WindowEvent { - event: - WindowEvent::KeyboardInput { - event: - KeyEvent { - logical_key: key, - state: ElementState::Pressed, - .. - }, - .. - }, - .. - } => match key.as_ref() { - Key::Character("A" | "a") => { - println!("Theme was: {:?}", window.theme()); - window.set_theme(None); + if let Event::WindowEvent { window_id, event } = event { + match event { + WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit, + WindowEvent::ThemeChanged(theme) if window_id == window.id() => { + println!("Theme is changed: {theme:?}") } - Key::Character("L" | "l") => { - println!("Theme was: {:?}", window.theme()); - window.set_theme(Some(Theme::Light)); - } - Key::Character("D" | "d") => { - println!("Theme was: {:?}", window.theme()); - window.set_theme(Some(Theme::Dark)); + WindowEvent::KeyboardInput { + event: + KeyEvent { + logical_key: key, + state: ElementState::Pressed, + .. + }, + .. + } => match key.as_ref() { + Key::Character("A" | "a") => { + println!("Theme was: {:?}", window.theme()); + window.set_theme(None); + } + Key::Character("L" | "l") => { + println!("Theme was: {:?}", window.theme()); + window.set_theme(Some(Theme::Light)); + } + Key::Character("D" | "d") => { + println!("Theme was: {:?}", window.theme()); + window.set_theme(Some(Theme::Dark)); + } + _ => (), + }, + WindowEvent::RedrawRequested => { + println!("\nredrawing!\n"); + fill::fill_window(&window); } _ => (), - }, - Event::RedrawRequested(_) => { - println!("\nredrawing!\n"); - fill::fill_window(&window); } - _ => (), } }) } diff --git a/examples/timer.rs b/examples/timer.rs index 329c36b8..1006fef4 100644 --- a/examples/timer.rs +++ b/examples/timer.rs @@ -42,7 +42,10 @@ fn main() -> Result<(), impl std::error::Error> { event: WindowEvent::CloseRequested, .. } => control_flow.set_exit(), - Event::RedrawRequested(_) => { + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } => { fill::fill_window(&window); } _ => (), diff --git a/examples/touchpad_gestures.rs b/examples/touchpad_gestures.rs index 44f2eee1..7c9d2dbd 100644 --- a/examples/touchpad_gestures.rs +++ b/examples/touchpad_gestures.rs @@ -42,10 +42,11 @@ fn main() -> Result<(), impl std::error::Error> { println!("Rotated clockwise {delta}"); } } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), } - } else if let Event::RedrawRequested(_) = event { - fill::fill_window(&window); } }) } diff --git a/examples/transparent.rs b/examples/transparent.rs index 9d3a470a..b5b05319 100644 --- a/examples/transparent.rs +++ b/examples/transparent.rs @@ -26,15 +26,14 @@ fn main() -> Result<(), impl std::error::Error> { control_flow.set_wait(); println!("{event:?}"); - match event { - Event::WindowEvent { - event: WindowEvent::CloseRequested, - .. - } => control_flow.set_exit(), - Event::RedrawRequested(_) => { - fill::fill_window(&window); + if let Event::WindowEvent { event, .. } = event { + match event { + WindowEvent::CloseRequested => control_flow.set_exit(), + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } + _ => (), } - _ => (), } }) } diff --git a/examples/window.rs b/examples/window.rs index 21be03f0..0d466f97 100644 --- a/examples/window.rs +++ b/examples/window.rs @@ -25,18 +25,19 @@ fn main() -> Result<(), impl std::error::Error> { println!("{event:?}"); match event { - Event::WindowEvent { - event: WindowEvent::CloseRequested, - window_id, - } if window_id == window.id() => control_flow.set_exit(), + Event::WindowEvent { event, window_id } if window_id == window.id() => match event { + WindowEvent::CloseRequested => control_flow.set_exit(), + WindowEvent::RedrawRequested => { + // Notify the windowing system that we'll be presenting to the window. + window.pre_present_notify(); + fill::fill_window(&window); + } + _ => (), + }, Event::AboutToWait => { window.request_redraw(); } - Event::RedrawRequested(_) => { - // Notify the windowing system that we'll be presenting to the window. - window.pre_present_notify(); - fill::fill_window(&window); - } + _ => (), } }) diff --git a/examples/window_buttons.rs b/examples/window_buttons.rs index c7f04a34..b6e01c57 100644 --- a/examples/window_buttons.rs +++ b/examples/window_buttons.rs @@ -34,42 +34,37 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, _, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { - event: - WindowEvent::KeyboardInput { - event: - KeyEvent { - logical_key: key, - state: ElementState::Pressed, - .. - }, - .. - }, - .. - } => match key.as_ref() { - Key::Character("F" | "f") => { - let buttons = window.enabled_buttons(); - window.set_enabled_buttons(buttons ^ WindowButtons::CLOSE); - } - Key::Character("G" | "g") => { - let buttons = window.enabled_buttons(); - window.set_enabled_buttons(buttons ^ WindowButtons::MAXIMIZE); - } - Key::Character("H" | "h") => { - let buttons = window.enabled_buttons(); - window.set_enabled_buttons(buttons ^ WindowButtons::MINIMIZE); + if let Event::WindowEvent { window_id, event } = event { + match event { + WindowEvent::KeyboardInput { + event: + KeyEvent { + logical_key: key, + state: ElementState::Pressed, + .. + }, + .. + } => match key.as_ref() { + Key::Character("F" | "f") => { + let buttons = window.enabled_buttons(); + window.set_enabled_buttons(buttons ^ WindowButtons::CLOSE); + } + Key::Character("G" | "g") => { + let buttons = window.enabled_buttons(); + window.set_enabled_buttons(buttons ^ WindowButtons::MAXIMIZE); + } + Key::Character("H" | "h") => { + let buttons = window.enabled_buttons(); + window.set_enabled_buttons(buttons ^ WindowButtons::MINIMIZE); + } + _ => (), + }, + WindowEvent::CloseRequested if window_id == window.id() => control_flow.set_exit(), + WindowEvent::RedrawRequested => { + fill::fill_window(&window); } _ => (), - }, - Event::WindowEvent { - event: WindowEvent::CloseRequested, - window_id, - } if window_id == window.id() => control_flow.set_exit(), - Event::RedrawRequested(_) => { - fill::fill_window(&window); } - _ => (), } }) } diff --git a/examples/window_debug.rs b/examples/window_debug.rs index e7283942..d2d39172 100644 --- a/examples/window_debug.rs +++ b/examples/window_debug.rs @@ -68,75 +68,71 @@ fn main() -> Result<(), impl std::error::Error> { } _ => (), }, - Event::WindowEvent { - event: - WindowEvent::KeyboardInput { - event: - KeyEvent { - logical_key: Key::Character(key_str), - state: ElementState::Pressed, - .. - }, - .. - }, - .. - } => match key_str.as_ref() { - // WARNING: Consider using `key_without_modifers()` if available on your platform. - // See the `key_binding` example - "e" => { - fn area(size: PhysicalSize) -> u32 { - size.width * size.height - } + Event::WindowEvent { window_id, event } => match event { + WindowEvent::KeyboardInput { + event: + KeyEvent { + logical_key: Key::Character(key_str), + state: ElementState::Pressed, + .. + }, + .. + } => match key_str.as_ref() { + // WARNING: Consider using `key_without_modifers()` if available on your platform. + // See the `key_binding` example + "e" => { + fn area(size: PhysicalSize) -> u32 { + size.width * size.height + } - let monitor = window.current_monitor().unwrap(); - if let Some(mode) = monitor - .video_modes() - .max_by(|a, b| area(a.size()).cmp(&area(b.size()))) - { - window.set_fullscreen(Some(Fullscreen::Exclusive(mode))); - } else { - eprintln!("no video modes available"); + let monitor = window.current_monitor().unwrap(); + if let Some(mode) = monitor + .video_modes() + .max_by(|a, b| area(a.size()).cmp(&area(b.size()))) + { + window.set_fullscreen(Some(Fullscreen::Exclusive(mode))); + } else { + eprintln!("no video modes available"); + } } - } - "f" => { - if window.fullscreen().is_some() { - window.set_fullscreen(None); - } else { - let monitor = window.current_monitor(); - window.set_fullscreen(Some(Fullscreen::Borderless(monitor))); + "f" => { + if window.fullscreen().is_some() { + window.set_fullscreen(None); + } else { + let monitor = window.current_monitor(); + window.set_fullscreen(Some(Fullscreen::Borderless(monitor))); + } } - } - "p" => { - if window.fullscreen().is_some() { - window.set_fullscreen(None); - } else { - window.set_fullscreen(Some(Fullscreen::Borderless(None))); + "p" => { + if window.fullscreen().is_some() { + window.set_fullscreen(None); + } else { + window.set_fullscreen(Some(Fullscreen::Borderless(None))); + } } - } - "m" => { - minimized = !minimized; - window.set_minimized(minimized); - } - "q" => { - control_flow.set_exit(); - } - "v" => { - visible = !visible; - window.set_visible(visible); - } - "x" => { - let is_maximized = window.is_maximized(); - window.set_maximized(!is_maximized); + "m" => { + minimized = !minimized; + window.set_minimized(minimized); + } + "q" => { + control_flow.set_exit(); + } + "v" => { + visible = !visible; + window.set_visible(visible); + } + "x" => { + let is_maximized = window.is_maximized(); + window.set_maximized(!is_maximized); + } + _ => (), + }, + WindowEvent::CloseRequested if window_id == window.id() => control_flow.set_exit(), + WindowEvent::RedrawRequested => { + fill::fill_window(&window); } _ => (), }, - Event::WindowEvent { - event: WindowEvent::CloseRequested, - window_id, - } if window_id == window.id() => control_flow.set_exit(), - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } _ => (), } }) diff --git a/examples/window_drag_resize.rs b/examples/window_drag_resize.rs index 73908cac..ead0b965 100644 --- a/examples/window_drag_resize.rs +++ b/examples/window_drag_resize.rs @@ -68,11 +68,12 @@ fn main() -> Result<(), impl std::error::Error> { border = !border; window.set_decorations(border); } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), }, - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } + _ => (), }) } diff --git a/examples/window_icon.rs b/examples/window_icon.rs index 1811812e..5dd4c1c6 100644 --- a/examples/window_icon.rs +++ b/examples/window_icon.rs @@ -4,7 +4,7 @@ use std::path::Path; use simple_logger::SimpleLogger; use winit::{ - event::Event, + event::{Event, WindowEvent}, event_loop::EventLoop, window::{Icon, WindowBuilder}, }; @@ -37,16 +37,14 @@ fn main() -> Result<(), impl std::error::Error> { control_flow.set_wait(); if let Event::WindowEvent { event, .. } = event { - use winit::event::WindowEvent::*; match event { - CloseRequested => control_flow.set_exit(), - DroppedFile(path) => { + WindowEvent::CloseRequested => control_flow.set_exit(), + WindowEvent::DroppedFile(path) => { window.set_window_icon(Some(load_icon(&path))); } + WindowEvent::RedrawRequested => fill::fill_window(&window), _ => (), } - } else if let Event::RedrawRequested(_) = event { - fill::fill_window(&window); } }) } diff --git a/examples/window_ondemand.rs b/examples/window_ondemand.rs index faa63e17..e90b0c87 100644 --- a/examples/window_ondemand.rs +++ b/examples/window_ondemand.rs @@ -44,7 +44,10 @@ fn main() -> Result<(), impl std::error::Error> { app.window = None; } Event::AboutToWait => window.request_redraw(), - Event::RedrawRequested(_) => { + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } => { fill::fill_window(window); } _ => (), diff --git a/examples/window_option_as_alt.rs b/examples/window_option_as_alt.rs index a28374be..c52070d3 100644 --- a/examples/window_option_as_alt.rs +++ b/examples/window_option_as_alt.rs @@ -56,14 +56,15 @@ fn main() -> Result<(), impl std::error::Error> { window.set_option_as_alt(option_as_alt); } WindowEvent::KeyboardInput { .. } => println!("KeyboardInput: {event:?}"), + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } _ => (), }, Event::AboutToWait => { window.request_redraw(); } - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } + _ => (), } }) diff --git a/examples/window_pump_events.rs b/examples/window_pump_events.rs index 0317981a..e727da41 100644 --- a/examples/window_pump_events.rs +++ b/examples/window_pump_events.rs @@ -48,7 +48,10 @@ fn main() -> std::process::ExitCode { Event::AboutToWait => { window.request_redraw(); } - Event::RedrawRequested(_) => { + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } => { fill::fill_window(&window); } _ => (), diff --git a/examples/window_resize_increments.rs b/examples/window_resize_increments.rs index 6b04072d..73b045f5 100644 --- a/examples/window_resize_increments.rs +++ b/examples/window_resize_increments.rs @@ -28,36 +28,33 @@ fn main() -> Result<(), impl std::error::Error> { control_flow.set_wait(); match event { - Event::WindowEvent { - event: WindowEvent::CloseRequested, - window_id, - } if window_id == window.id() => control_flow.set_exit(), - Event::WindowEvent { - event: - WindowEvent::KeyboardInput { - event: - KeyEvent { - logical_key: Key::Space, - state: ElementState::Released, - .. - }, - .. - }, - window_id, - } if window_id == window.id() => { - has_increments = !has_increments; + Event::WindowEvent { event, window_id } if window_id == window.id() => match event { + WindowEvent::CloseRequested => control_flow.set_exit(), + WindowEvent::KeyboardInput { + event: + KeyEvent { + logical_key: Key::Space, + state: ElementState::Released, + .. + }, + .. + } => { + has_increments = !has_increments; - let new_increments = match window.resize_increments() { - Some(_) => None, - None => Some(LogicalSize::new(25.0, 25.0)), - }; - debug!("Had increments: {}", new_increments.is_none()); - window.set_resize_increments(new_increments); - } + let new_increments = match window.resize_increments() { + Some(_) => None, + None => Some(LogicalSize::new(25.0, 25.0)), + }; + debug!("Had increments: {}", new_increments.is_none()); + window.set_resize_increments(new_increments); + } + WindowEvent::RedrawRequested => { + fill::fill_window(&window); + } + _ => (), + }, Event::AboutToWait => window.request_redraw(), - Event::RedrawRequested(_) => { - fill::fill_window(&window); - } + _ => (), } }) diff --git a/examples/window_tabbing.rs b/examples/window_tabbing.rs index 732a5b62..050fdc09 100644 --- a/examples/window_tabbing.rs +++ b/examples/window_tabbing.rs @@ -33,75 +33,72 @@ fn main() -> Result<(), impl std::error::Error> { event_loop.run(move |event, event_loop, control_flow| { control_flow.set_wait(); - match event { - Event::WindowEvent { event, window_id } => { - match event { - WindowEvent::CloseRequested => { - println!("Window {window_id:?} has received the signal to close"); + if let Event::WindowEvent { event, window_id } = event { + match event { + WindowEvent::CloseRequested => { + println!("Window {window_id:?} has received the signal to close"); - // This drops the window, causing it to close. - windows.remove(&window_id); + // This drops the window, causing it to close. + windows.remove(&window_id); - if windows.is_empty() { - control_flow.set_exit(); - } + if windows.is_empty() { + control_flow.set_exit(); } - WindowEvent::Resized(_) => { - if let Some(window) = windows.get(&window_id) { - window.request_redraw(); - } + } + WindowEvent::Resized(_) => { + if let Some(window) = windows.get(&window_id) { + window.request_redraw(); } - WindowEvent::KeyboardInput { - event: - KeyEvent { - state: ElementState::Pressed, - logical_key, - .. - }, - is_synthetic: false, - .. - } => match logical_key.as_ref() { - Key::Character("t") => { - let tabbing_id = windows.get(&window_id).unwrap().tabbing_identifier(); - let window = WindowBuilder::new() - .with_tabbing_identifier(&tabbing_id) - .build(event_loop) - .unwrap(); - println!("Added a new tab: {:?}", window.id()); - windows.insert(window.id(), window); - } - Key::Character("w") => { - let _ = windows.remove(&window_id); - } - Key::ArrowRight => { - windows.get(&window_id).unwrap().select_next_tab(); - } - Key::ArrowLeft => { - windows.get(&window_id).unwrap().select_previous_tab(); - } - Key::Character(ch) => { - if let Ok(index) = ch.parse::() { - let index = index.get(); - // Select the last tab when pressing `9`. - let window = windows.get(&window_id).unwrap(); - if index == 9 { - window.select_tab_at_index(window.num_tabs() - 1) - } else { - window.select_tab_at_index(index - 1); - } + } + WindowEvent::KeyboardInput { + event: + KeyEvent { + state: ElementState::Pressed, + logical_key, + .. + }, + is_synthetic: false, + .. + } => match logical_key.as_ref() { + Key::Character("t") => { + let tabbing_id = windows.get(&window_id).unwrap().tabbing_identifier(); + let window = WindowBuilder::new() + .with_tabbing_identifier(&tabbing_id) + .build(event_loop) + .unwrap(); + println!("Added a new tab: {:?}", window.id()); + windows.insert(window.id(), window); + } + Key::Character("w") => { + let _ = windows.remove(&window_id); + } + Key::ArrowRight => { + windows.get(&window_id).unwrap().select_next_tab(); + } + Key::ArrowLeft => { + windows.get(&window_id).unwrap().select_previous_tab(); + } + Key::Character(ch) => { + if let Ok(index) = ch.parse::() { + let index = index.get(); + // Select the last tab when pressing `9`. + let window = windows.get(&window_id).unwrap(); + if index == 9 { + window.select_tab_at_index(window.num_tabs() - 1) + } else { + window.select_tab_at_index(index - 1); } } - _ => (), - }, + } _ => (), + }, + WindowEvent::RedrawRequested => { + if let Some(window) = windows.get(&window_id) { + fill::fill_window(window); + } } + _ => (), } - Event::RedrawRequested(window_id) => { - if let Some(window) = windows.get(&window_id) { - fill::fill_window(window); - } - } - _ => (), } }) } diff --git a/examples/x11_embed.rs b/examples/x11_embed.rs index 220389be..29f84e78 100644 --- a/examples/x11_embed.rs +++ b/examples/x11_embed.rs @@ -43,7 +43,10 @@ mod imple { Event::AboutToWait => { window.request_redraw(); } - Event::RedrawRequested(_) => { + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } => { // Notify the windowing system that we'll be presenting to the window. window.pre_present_notify(); fill::fill_window(&window); diff --git a/src/event.rs b/src/event.rs index de87be7a..067e3ed0 100644 --- a/src/event.rs +++ b/src/event.rs @@ -218,20 +218,9 @@ pub enum Event { /// ups and also lots of corresponding `AboutToWait` events. /// /// This is not an ideal event to drive application rendering from and instead applications - /// should render in response to [`Event::RedrawRequested`] events. + /// should render in response to [`WindowEvent::RedrawRequested`] events. AboutToWait, - /// Emitted when a window should be redrawn. - /// - /// This gets triggered in two scenarios: - /// - The OS has performed an operation that's invalidated the window's contents (such as - /// resizing the window). - /// - The application has explicitly requested a redraw via [`Window::request_redraw`]. - /// - /// Winit will aggregate duplicate redraw requests into a single event, to - /// help avoid duplicating rendering work. - RedrawRequested(WindowId), - /// Emitted when the event loop is being shut down. /// /// This is irreversible - if this event is emitted, it is guaranteed to be the last event that @@ -249,7 +238,6 @@ impl Event { DeviceEvent { device_id, event } => Ok(DeviceEvent { device_id, event }), NewEvents(cause) => Ok(NewEvents(cause)), AboutToWait => Ok(AboutToWait), - RedrawRequested(wid) => Ok(RedrawRequested(wid)), LoopExiting => Ok(LoopExiting), Suspended => Ok(Suspended), Resumed => Ok(Resumed), @@ -553,6 +541,17 @@ pub enum WindowEvent { /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform Occluded(bool), + + /// Emitted when a window should be redrawn. + /// + /// This gets triggered in two scenarios: + /// - The OS has performed an operation that's invalidated the window's contents (such as + /// resizing the window). + /// - The application has explicitly requested a redraw via [`Window::request_redraw`]. + /// + /// Winit will aggregate duplicate redraw requests into a single event, to + /// help avoid duplicating rendering work. + RedrawRequested, } /// Identifier of an input device. @@ -1122,7 +1121,6 @@ mod tests { let wid = unsafe { WindowId::dummy() }; x(UserEvent(())); x(NewEvents(event::StartCause::Init)); - x(RedrawRequested(wid)); x(AboutToWait); x(LoopExiting); x(Suspended); diff --git a/src/lib.rs b/src/lib.rs index ae1281ce..d7f01551 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -79,7 +79,10 @@ //! // can just render here instead. //! window.request_redraw(); //! }, -//! Event::RedrawRequested(_) => { +//! Event::WindowEvent { +//! event: WindowEvent::RedrawRequested, +//! .. +//! } => { //! // Redraw the application. //! // //! // It's preferable for applications that do not render continuously to render in diff --git a/src/platform_impl/android/mod.rs b/src/platform_impl/android/mod.rs index 09c3161a..22f8cf9a 100644 --- a/src/platform_impl/android/mod.rs +++ b/src/platform_impl/android/mod.rs @@ -407,7 +407,10 @@ impl EventLoop { pending_redraw |= self.redraw_flag.get_and_reset(); if pending_redraw { pending_redraw = false; - let event = event::Event::RedrawRequested(window::WindowId(WindowId)); + let event = event::Event::WindowEvent { + window_id: window::WindowId(WindowId), + event: event::WindowEvent::RedrawRequested, + }; sticky_exit_callback(event, self.window_target(), &mut control_flow, callback); } } diff --git a/src/platform_impl/ios/app_state.rs b/src/platform_impl/ios/app_state.rs index 493e9068..9bb898d3 100644 --- a/src/platform_impl/ios/app_state.rs +++ b/src/platform_impl/ios/app_state.rs @@ -57,7 +57,13 @@ enum UserCallbackTransitionResult<'a> { impl Event { fn is_redraw(&self) -> bool { - matches!(self, Event::RedrawRequested(_)) + matches!( + self, + Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } + ) } } @@ -755,7 +761,12 @@ pub unsafe fn handle_main_events_cleared() { let redraw_events: Vec = this .main_events_cleared_transition() .into_iter() - .map(|window| EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.id())))) + .map(|window| { + EventWrapper::StaticEvent(Event::WindowEvent { + window_id: RootWindowId(window.id()), + event: WindowEvent::RedrawRequested, + }) + }) .collect(); drop(this); diff --git a/src/platform_impl/ios/view.rs b/src/platform_impl/ios/view.rs index ce66483d..f97fbeee 100644 --- a/src/platform_impl/ios/view.rs +++ b/src/platform_impl/ios/view.rs @@ -43,9 +43,10 @@ declare_class!( fn draw_rect(&self, rect: CGRect) { let window = self.window().unwrap(); unsafe { - app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested( - RootWindowId(window.id()), - ))); + app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent { + window_id: RootWindowId(window.id()), + event: WindowEvent::RedrawRequested, + })); } let _: () = unsafe { msg_send![super(self), drawRect: rect] }; } diff --git a/src/platform_impl/linux/wayland/event_loop/mod.rs b/src/platform_impl/linux/wayland/event_loop/mod.rs index 335b1bc2..74271e62 100644 --- a/src/platform_impl/linux/wayland/event_loop/mod.rs +++ b/src/platform_impl/linux/wayland/event_loop/mod.rs @@ -580,7 +580,10 @@ impl EventLoop { if request_redraw { sticky_exit_callback( - Event::RedrawRequested(crate::window::WindowId(window_id)), + Event::WindowEvent { + window_id: crate::window::WindowId(window_id), + event: WindowEvent::RedrawRequested, + }, &self.window_target, &mut control_flow, &mut callback, diff --git a/src/platform_impl/linux/x11/event_processor.rs b/src/platform_impl/linux/x11/event_processor.rs index c67827a7..fc752a2e 100644 --- a/src/platform_impl/linux/x11/event_processor.rs +++ b/src/platform_impl/linux/x11/event_processor.rs @@ -576,7 +576,10 @@ impl EventProcessor { let window = xev.window as xproto::Window; let window_id = mkwid(window); - callback(Event::RedrawRequested(window_id)); + callback(Event::WindowEvent { + window_id, + event: WindowEvent::RedrawRequested, + }); } } diff --git a/src/platform_impl/linux/x11/mod.rs b/src/platform_impl/linux/x11/mod.rs index 787f3994..0689b37b 100644 --- a/src/platform_impl/linux/x11/mod.rs +++ b/src/platform_impl/linux/x11/mod.rs @@ -65,7 +65,7 @@ use self::{ use super::{common::xkb_state::KbdState, OsError}; use crate::{ error::{EventLoopError, OsError as RootOsError}, - event::{Event, StartCause}, + event::{Event, StartCause, WindowEvent}, event_loop::{ControlFlow, DeviceEvents, EventLoopClosed, EventLoopWindowTarget as RootELW}, platform::pump_events::PumpStatus, platform_impl::{ @@ -671,7 +671,10 @@ impl EventLoop { for window_id in windows { let window_id = crate::window::WindowId(window_id); sticky_exit_callback( - Event::RedrawRequested(window_id), + Event::WindowEvent { + window_id, + event: WindowEvent::RedrawRequested, + }, &self.target, &mut control_flow, callback, @@ -708,7 +711,11 @@ impl EventLoop { target, control_flow, &mut |event, window_target, control_flow| { - if let Event::RedrawRequested(crate::window::WindowId(wid)) = event { + if let Event::WindowEvent { + window_id: crate::window::WindowId(wid), + event: WindowEvent::RedrawRequested, + } = event + { wt.redraw_sender.send(wid).unwrap(); } else { callback(event, window_target, control_flow); diff --git a/src/platform_impl/macos/app_state.rs b/src/platform_impl/macos/app_state.rs index 172a56f0..6699f508 100644 --- a/src/platform_impl/macos/app_state.rs +++ b/src/platform_impl/macos/app_state.rs @@ -564,8 +564,10 @@ impl AppState { // Redraw request might come out of order from the OS. // -> Don't go back into the callback when our callstack originates from there if !HANDLER.in_callback.swap(true, Ordering::AcqRel) { - HANDLER - .handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id))); + HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent { + window_id, + event: WindowEvent::RedrawRequested, + })); HANDLER.set_in_callback(false); // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested events @@ -616,8 +618,10 @@ impl AppState { } for window_id in HANDLER.should_redraw() { - HANDLER - .handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id))); + HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent { + window_id, + event: WindowEvent::RedrawRequested, + })); } HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::AboutToWait)); diff --git a/src/platform_impl/orbital/event_loop.rs b/src/platform_impl/orbital/event_loop.rs index 5ffe3864..1f39c8ad 100644 --- a/src/platform_impl/orbital/event_loop.rs +++ b/src/platform_impl/orbital/event_loop.rs @@ -608,7 +608,10 @@ impl EventLoop { redraws.pop_front() } { event_handler( - event::Event::RedrawRequested(RootWindowId(window_id)), + event::Event::WindowEvent { + window_id: RootWindowId(window_id), + event: event::WindowEvent::RedrawRequested, + }, &self.window_target, &mut control_flow, ); diff --git a/src/platform_impl/web/event_loop/runner.rs b/src/platform_impl/web/event_loop/runner.rs index fb40ce60..b5eeda41 100644 --- a/src/platform_impl/web/event_loop/runner.rs +++ b/src/platform_impl/web/event_loop/runner.rs @@ -567,7 +567,13 @@ impl Shared { // Collect all of the redraw events to avoid double-locking the RefCell let redraw_events: Vec = self.0.redraw_pending.borrow_mut().drain().collect(); for window_id in redraw_events { - self.handle_event(Event::RedrawRequested(window_id), &mut control); + self.handle_event( + Event::WindowEvent { + window_id, + event: WindowEvent::RedrawRequested, + }, + &mut control, + ); } self.handle_event(Event::AboutToWait, &mut control); diff --git a/src/platform_impl/windows/event_loop.rs b/src/platform_impl/windows/event_loop.rs index 791c64b4..1bf16d58 100644 --- a/src/platform_impl/windows/event_loop.rs +++ b/src/platform_impl/windows/event_loop.rs @@ -1152,7 +1152,10 @@ unsafe fn public_window_callback_inner( // redraw the window outside the normal flow of the event loop. RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT); } else { - userdata.send_event(Event::RedrawRequested(RootWindowId(WindowId(window)))); + userdata.send_event(Event::WindowEvent { + window_id: RootWindowId(WindowId(window)), + event: WindowEvent::RedrawRequested, + }); } result = ProcResult::DefWindowProc(wparam); } diff --git a/src/platform_impl/windows/event_loop/runner.rs b/src/platform_impl/windows/event_loop/runner.rs index f81055db..e8b35cf1 100644 --- a/src/platform_impl/windows/event_loop/runner.rs +++ b/src/platform_impl/windows/event_loop/runner.rs @@ -198,7 +198,11 @@ impl EventLoopRunner { } pub(crate) fn send_event(&self, event: Event) { - if let Event::RedrawRequested(_) = event { + if let Event::WindowEvent { + event: WindowEvent::RedrawRequested, + .. + } = event + { self.call_event_handler(event); // As a rule, to ensure that `pump_events` can't block an external event loop // for too long, we always guarantee that `pump_events` will return control to diff --git a/src/window.rs b/src/window.rs index dbe41cbe..e24562ff 100644 --- a/src/window.rs +++ b/src/window.rs @@ -539,7 +539,7 @@ impl Window { self.window.maybe_wait_on_main(|w| w.scale_factor()) } - /// Queues a [`Event::RedrawRequested`] event to be emitted that aligns with the windowing + /// Queues a [`WindowEvent::RedrawRequested`] event to be emitted that aligns with the windowing /// system drawing loop. /// /// This is the **strongly encouraged** method of redrawing windows, as it can integrate with @@ -562,9 +562,9 @@ impl Window { /// - **iOS:** Can only be called on the main thread. /// - **Wayland:** The events are aligned with the frame callbacks when [`Window::pre_present_notify`] /// is used. - /// - **Web:** [`Event::RedrawRequested`] will be aligned with the `requestAnimationFrame`. + /// - **Web:** [`WindowEvent::RedrawRequested`] will be aligned with the `requestAnimationFrame`. /// - /// [`Event::RedrawRequested`]: crate::event::Event::RedrawRequested + /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested #[inline] pub fn request_redraw(&self) { self.window.maybe_queue_on_main(|w| w.request_redraw()) @@ -575,7 +575,7 @@ impl Window { /// You should call this event after you've done drawing operations, but before you submit /// the buffer to the display or commit your drawings. Doing so will help winit to properly /// schedule and do assumptions about its internal state. For example, it could properly - /// throttle [`Event::RedrawRequested`]. + /// throttle [`WindowEvent::RedrawRequested`]. /// /// ## Example /// @@ -599,9 +599,9 @@ impl Window { /// /// ## Platform-specific /// - /// **Wayland:** - schedules a frame callback to throttle [`Event::RedrawRequested`]. + /// **Wayland:** - schedules a frame callback to throttle [`WindowEvent::RedrawRequested`]. /// - /// [`Event::RedrawRequested`]: crate::event::Event::RedrawRequested + /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested #[inline] pub fn pre_present_notify(&self) { self.window.maybe_queue_on_main(|w| w.pre_present_notify());