leyoda/winit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move Event::RedrawRequested to WindowEvent (#3049)

Browse source
This commit is contained in:
daxpedda 2023-08-27 16:15:09 +02:00 • committed by GitHub
parent a3cba838ea
commit 67d3fd28f7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
46 changed files with 572 additions and 562 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/event.rs
View file

@ -218,20 +218,9 @@ pub enum Event<T: 'static> {
/// 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<T> Event<T> {
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);

5
src/lib.rs
View file

@ -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

5
src/platform_impl/android/mod.rs
View file

@ -407,7 +407,10 @@ impl<T: 'static> EventLoop<T> {
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);
}
}

15
src/platform_impl/ios/app_state.rs
View file

@ -57,7 +57,13 @@ enum UserCallbackTransitionResult<'a> {
impl Event<Never> {
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<EventWrapper> = 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);

7
src/platform_impl/ios/view.rs
View file

@ -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] };
}

5
src/platform_impl/linux/wayland/event_loop/mod.rs
View file

@ -580,7 +580,10 @@ impl<T: 'static> EventLoop<T> {
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,

5
src/platform_impl/linux/x11/event_processor.rs
View file

@ -576,7 +576,10 @@ impl<T: 'static> EventProcessor<T> {
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,
});
}
}

13
src/platform_impl/linux/x11/mod.rs
View file

@ -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<T: 'static> EventLoop<T> {
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<T: 'static> EventLoop<T> {
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);

12
src/platform_impl/macos/app_state.rs
View file

@ -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));

5
src/platform_impl/orbital/event_loop.rs
View file

@ -608,7 +608,10 @@ impl<T: 'static> EventLoop<T> {
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,
);

8
src/platform_impl/web/event_loop/runner.rs
View file

@ -567,7 +567,13 @@ impl<T: 'static> Shared<T> {
// Collect all of the redraw events to avoid double-locking the RefCell
let redraw_events: Vec<WindowId> = 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);

5
src/platform_impl/windows/event_loop.rs
View file

@ -1152,7 +1152,10 @@ unsafe fn public_window_callback_inner<T: 'static>(
// 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);
}

6
src/platform_impl/windows/event_loop/runner.rs
View file

@ -198,7 +198,11 @@ impl<T> EventLoopRunner<T> {
}
pub(crate) fn send_event(&self, event: Event<T>) {
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

12
src/window.rs
View file

@ -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());