Implement new redraw API

Author: Osspial

examples/request_redraw.rs

@@ -22,7 +22,7 @@ fn main() {
                 event: WindowEvent::CloseRequested,
                 ..
             } => *control_flow = ControlFlow::Exit,
-            Event::EventsCleared => {
+            Event::MainEventsCleared => {
                 window.request_redraw();
                 *control_flow = ControlFlow::WaitUntil(Instant::now() + Duration::new(1, 0))
             }

examples/window.rs

@@ -20,7 +20,10 @@ fn main() {
                 event: WindowEvent::CloseRequested,
                 window_id,
             } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-            _ => *control_flow = ControlFlow::Wait,
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+            _ => *control_flow = ControlFlow::Poll,
         }
     });
 }

src/event.rs

@@ -29,9 +29,16 @@ pub enum Event<T> {
     UserEvent(T),
     /// Emitted when new events arrive from the OS to be processed.
     NewEvents(StartCause),
-    /// Emitted when all of the event loop's events have been processed and control flow is about
-    /// to be taken away from the program.
-    EventsCleared,
+    /// Emitted when all of the event loop's standard events have been processed and redraw event
+    /// processing is about to begin.
+    MainEventsCleared,
+
+    /// The OS or application has requested that the window be redrawn. This gets emitted after
+    /// `MainEventsCleared`.
+    RedrawRequested(WindowId),
+    /// Emitted when all the redraw events have been processed. Also signals that control flow is
+    /// about to be taken away from the program.
+    RedrawEventsCleared,
 
     /// Emitted when the event loop is being shut down. This is irreversable - if this event is
     /// emitted, it is guaranteed to be the last event emitted.
@@ -52,7 +59,9 @@ impl<T> Event<T> {
             WindowEvent { window_id, event } => Ok(WindowEvent { window_id, event }),
             DeviceEvent { device_id, event } => Ok(DeviceEvent { device_id, event }),
             NewEvents(cause) => Ok(NewEvents(cause)),
-            EventsCleared => Ok(EventsCleared),
+            MainEventsCleared => Ok(MainEventsCleared),
+            RedrawRequested(window_id) => Ok(RedrawRequested(window_id)),
+            RedrawEventsCleared => Ok(RedrawEventsCleared),
             LoopDestroyed => Ok(LoopDestroyed),
             Suspended => Ok(Suspended),
             Resumed => Ok(Resumed),
@@ -184,9 +193,6 @@ pub enum WindowEvent {
         value: f64,
     },
 
-    /// The OS or application has requested that the window be redrawn.
-    RedrawRequested,
-
     /// Touch event has been received
     Touch(Touch),
 

src/lib.rs

@@ -48,16 +48,13 @@
 //!
 //! event_loop.run(move |event, _, control_flow| {
 //!     match event {
-//!         Event::EventsCleared => {
+//!         Event::MainEventsCleared => {
 //!             // Application update code.
-//!     
+//!
 //!             // Queue a RedrawRequested event.
 //!             window.request_redraw();
 //!         },
-//!         Event::WindowEvent {
-//!             event: WindowEvent::RedrawRequested,
-//!             ..
-//!         } => {
+//!         Event::RedrawRequested(_window_id) => {
 //!             // Redraw the application.
 //!             //
 //!             // It's preferrable to render in this event rather than in EventsCleared, since

src/platform_impl/windows/event_loop.rs

@@ -20,7 +20,6 @@ use std::{
     mem, panic, ptr,
     rc::Rc,
     sync::{
-        atomic::{AtomicBool, Ordering},
         mpsc::{self, Receiver, Sender},
         Arc,
     },
@@ -92,7 +91,6 @@ pub struct EventLoop<T: 'static> {
 
 pub struct EventLoopWindowTarget<T> {
     thread_id: DWORD,
-    trigger_newevents_on_redraw: Arc<AtomicBool>,
     thread_msg_target: HWND,
     pub(crate) runner_shared: EventLoopRunnerShared<T>,
 }
@@ -119,7 +117,6 @@ impl<T: 'static> EventLoop<T> {
             window_target: RootELW {
                 p: EventLoopWindowTarget {
                     thread_id,
-                    trigger_newevents_on_redraw: Arc::new(AtomicBool::new(true)),
                     thread_msg_target,
                     runner_shared,
                 },
@@ -218,7 +215,6 @@ impl<T> EventLoopWindowTarget<T> {
     pub(crate) fn create_thread_executor(&self) -> EventLoopThreadExecutor {
         EventLoopThreadExecutor {
             thread_id: self.thread_id,
-            trigger_newevents_on_redraw: self.trigger_newevents_on_redraw.clone(),
             target_window: self.thread_msg_target,
         }
     }
@@ -289,7 +285,6 @@ impl<T> Drop for EventLoop<T> {
 
 pub(crate) struct EventLoopThreadExecutor {
     thread_id: DWORD,
-    trigger_newevents_on_redraw: Arc<AtomicBool>,
     target_window: HWND,
 }
 
@@ -303,10 +298,6 @@ impl EventLoopThreadExecutor {
         self.thread_id == cur_thread_id
     }
 
-    pub(super) fn trigger_newevents_on_redraw(&self) -> bool {
-        !self.in_event_loop_thread() || self.trigger_newevents_on_redraw.load(Ordering::Relaxed)
-    }
-
     /// Executes a function in the event loop thread. If we're already in the event loop thread,
     /// we just call the function directly.
     ///
@@ -398,12 +389,6 @@ lazy_static! {
             winuser::RegisterWindowMessageA("Winit::InitialDpiMsg\0".as_ptr() as LPCSTR)
         }
     };
-    // Message sent by a `Window` if it's requesting a redraw without sending a NewEvents.
-    pub static ref REQUEST_REDRAW_NO_NEWEVENTS_MSG_ID: u32 = {
-        unsafe {
-            winuser::RegisterWindowMessageA("Winit::RequestRedrawNoNewevents\0".as_ptr() as LPCSTR)
-        }
-    };
     // WPARAM is a bool specifying the `WindowFlags::MARKER_RETAIN_STATE_ON_SIZE` flag. See the
     // documentation in the `window_state` module for more information.
     pub static ref SET_RETAIN_STATE_ON_SIZE_MSG_ID: u32 = unsafe {
@@ -581,41 +566,8 @@ unsafe extern "system" fn public_window_callback<T>(
             0
         }
 
-        _ if msg == *REQUEST_REDRAW_NO_NEWEVENTS_MSG_ID => {
-            use crate::event::WindowEvent::RedrawRequested;
-            subclass_input.window_state.lock().queued_out_of_band_redraw = false;
-
-            // This check makes sure that requesting a redraw during `EventsCleared`
-            // handling dispatch `RedrawRequested` immediately after `EventsCleared`, without
-            // spinning up a new event loop iteration. We do this because that's what the API
-            // says to do.
-            match subclass_input.event_loop_runner.handling_events() {
-                true => {
-                    winuser::RedrawWindow(
-                        window,
-                        ptr::null(),
-                        ptr::null_mut(),
-                        winuser::RDW_INTERNALPAINT,
-                    );
-                }
-                false => {
-                    subclass_input
-                        .event_loop_runner
-                        .call_event_handler(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
-                            event: RedrawRequested,
-                        });
-                }
-            }
-
-            0
-        }
         winuser::WM_PAINT => {
-            use crate::event::WindowEvent::RedrawRequested;
-            subclass_input.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
-                event: RedrawRequested,
-            });
+            subclass_input.send_event(Event::RedrawRequested(RootWindowId(WindowId(window))));
             commctrl::DefSubclassProc(window, msg, wparam, lparam)
         }