Implement revamped RedrawRequested on Windows (#1050)

* Move event loop runner to runner module

* Implement new redraw API

src/platform_impl/windows/event_loop/runner.rs

@@ -0,0 +1,415 @@
+use std::{
+    any::Any,
+    cell::RefCell,
+    collections::VecDeque,
+    mem, panic, ptr,
+    rc::Rc,
+    time::Instant,
+};
+
+use winapi::{
+    shared::{
+        windef::HWND,
+    },
+    um::winuser,
+};
+
+use crate::{
+    event::{Event, StartCause},
+    event_loop::ControlFlow,
+    platform_impl::platform::{
+        event_loop::EventLoop,
+    },
+    window::WindowId,
+};
+
+pub(crate) type EventLoopRunnerShared<T> = Rc<ELRShared<T>>;
+pub(crate) struct ELRShared<T> {
+    runner: RefCell<Option<EventLoopRunner<T>>>,
+    buffer: RefCell<VecDeque<Event<T>>>,
+    redraw_buffer: Rc<RefCell<VecDeque<WindowId>>>,
+}
+struct EventLoopRunner<T> {
+    control_flow: ControlFlow,
+    runner_state: RunnerState,
+    modal_redraw_window: HWND,
+    in_modal_loop: bool,
+    event_handler: Box<dyn FnMut(Event<T>, &mut ControlFlow)>,
+    panic_error: Option<PanicError>,
+    redraw_buffer: Rc<RefCell<VecDeque<WindowId>>>,
+}
+pub type PanicError = Box<dyn Any + Send + 'static>;
+
+impl<T> ELRShared<T> {
+    pub(crate) fn new() -> ELRShared<T> {
+        ELRShared {
+            runner: RefCell::new(None),
+            buffer: RefCell::new(VecDeque::new()),
+            redraw_buffer: Default::default(),
+        }
+    }
+
+    pub(crate) unsafe fn set_runner<F>(&self, event_loop: &EventLoop<T>, f: F)
+    where
+        F: FnMut(Event<T>, &mut ControlFlow),
+    {
+        let mut runner = EventLoopRunner::new(event_loop, self.redraw_buffer.clone(), f);
+        {
+            let mut runner_ref = self.runner.borrow_mut();
+            loop {
+                let event = self.buffer.borrow_mut().pop_front();
+                match event {
+                    Some(e) => {
+                        runner.process_event(e);
+                    }
+                    None => break,
+                }
+            }
+            *runner_ref = Some(runner);
+        }
+    }
+
+    pub(crate) fn destroy_runner(&self) {
+        *self.runner.borrow_mut() = None;
+    }
+
+    pub(crate) fn new_events(&self) {
+        let mut runner_ref = self.runner.borrow_mut();
+        if let Some(ref mut runner) = *runner_ref {
+            runner.new_events();
+        }
+    }
+
+    pub(crate) unsafe fn send_event(&self, event: Event<T>) {
+        if let Ok(mut runner_ref) = self.runner.try_borrow_mut() {
+            if let Some(ref mut runner) = *runner_ref {
+                runner.process_event(event);
+
+                // Dispatch any events that were buffered during the call to `process_event`.
+                loop {
+                    // We do this instead of using a `while let` loop because if we use a `while let`
+                    // loop the reference returned `borrow_mut()` doesn't get dropped until the end
+                    // of the loop's body and attempts to add events to the event buffer while in
+                    // `process_event` will fail.
+                    let buffered_event_opt = self.buffer.borrow_mut().pop_front();
+                    match buffered_event_opt {
+                        Some(event) => runner.process_event(event),
+                        None => break,
+                    }
+                }
+
+                return;
+            }
+        }
+
+        // If the runner is already borrowed, we're in the middle of an event loop invocation. Add
+        // the event to a buffer to be processed later.
+        self.buffer_event(event);
+    }
+
+    pub(crate) unsafe fn call_event_handler(&self, event: Event<T>) {
+        if let Ok(mut runner_ref) = self.runner.try_borrow_mut() {
+            if let Some(ref mut runner) = *runner_ref {
+                runner.call_event_handler(event);
+                return;
+            }
+        }
+    }
+
+    pub(crate) fn events_cleared(&self) {
+        let mut runner_ref = self.runner.borrow_mut();
+        if let Some(ref mut runner) = *runner_ref {
+            runner.events_cleared();
+        }
+    }
+
+    pub(crate) fn take_panic_error(&self) -> Result<(), PanicError> {
+        let mut runner_ref = self.runner.borrow_mut();
+        if let Some(ref mut runner) = *runner_ref {
+            runner.take_panic_error()
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(crate) fn set_modal_loop(&self, in_modal_loop: bool) {
+        let mut runner_ref = self.runner.borrow_mut();
+        if let Some(ref mut runner) = *runner_ref {
+            runner.in_modal_loop = in_modal_loop;
+        }
+    }
+
+    pub(crate) fn in_modal_loop(&self) -> bool {
+        let runner = self.runner.borrow();
+        if let Some(ref runner) = *runner {
+            runner.in_modal_loop
+        } else {
+            false
+        }
+    }
+
+    pub fn control_flow(&self) -> ControlFlow {
+        let runner_ref = self.runner.borrow();
+        if let Some(ref runner) = *runner_ref {
+            runner.control_flow
+        } else {
+            ControlFlow::Exit
+        }
+    }
+
+    fn buffer_event(&self, event: Event<T>) {
+        match event {
+            Event::RedrawRequested(window_id) => self.redraw_buffer.borrow_mut().push_back(window_id),
+            _ => self.buffer.borrow_mut().push_back(event),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum RunnerState {
+    /// The event loop has just been created, and an `Init` event must be sent.
+    New,
+    /// The event loop is idling, and began idling at the given instant.
+    Idle(Instant),
+    /// The event loop has received a signal from the OS that the loop may resume, but no winit
+    /// events have been generated yet. We're waiting for an event to be processed or the events
+    /// to be marked as cleared to send `NewEvents`, depending on the current `ControlFlow`.
+    DeferredNewEvents(Instant),
+    /// The event loop is handling the OS's events and sending them to the user's callback.
+    /// `NewEvents` has been sent, and `EventsCleared` hasn't.
+    HandlingEvents,
+    HandlingRedraw,
+}
+
+impl<T> EventLoopRunner<T> {
+    unsafe fn new<F>(event_loop: &EventLoop<T>, redraw_buffer: Rc<RefCell<VecDeque<WindowId>>>, f: F) -> EventLoopRunner<T>
+    where
+        F: FnMut(Event<T>, &mut ControlFlow),
+    {
+        EventLoopRunner {
+            control_flow: ControlFlow::default(),
+            runner_state: RunnerState::New,
+            in_modal_loop: false,
+            modal_redraw_window: event_loop.window_target.p.thread_msg_target,
+            event_handler: mem::transmute::<
+                Box<dyn FnMut(Event<T>, &mut ControlFlow)>,
+                Box<dyn FnMut(Event<T>, &mut ControlFlow)>,
+            >(Box::new(f)),
+            panic_error: None,
+            redraw_buffer,
+        }
+    }
+
+    fn take_panic_error(&mut self) -> Result<(), PanicError> {
+        match self.panic_error.take() {
+            Some(err) => Err(err),
+            None => Ok(()),
+        }
+    }
+
+    fn new_events(&mut self) {
+        self.runner_state = match self.runner_state {
+            // If we're already handling events or have deferred `NewEvents`, we don't need to do
+            // do any processing.
+            RunnerState::HandlingEvents | RunnerState::HandlingRedraw | RunnerState::DeferredNewEvents(..) => self.runner_state,
+
+            // Send the `Init` `NewEvents` and immediately move into event processing.
+            RunnerState::New => {
+                self.call_event_handler(Event::NewEvents(StartCause::Init));
+                RunnerState::HandlingEvents
+            }
+
+            // When `NewEvents` gets sent after an idle depends on the control flow...
+            RunnerState::Idle(wait_start) => {
+                match self.control_flow {
+                    // If we're polling, send `NewEvents` and immediately move into event processing.
+                    ControlFlow::Poll => {
+                        self.call_event_handler(Event::NewEvents(StartCause::Poll));
+                        RunnerState::HandlingEvents
+                    },
+                    // If the user was waiting until a specific time, the `NewEvents` call gets sent
+                    // at varying times depending on the current time.
+                    ControlFlow::WaitUntil(resume_time) => {
+                        match Instant::now() >= resume_time {
+                            // If the current time is later than the requested resume time, we can tell the
+                            // user that the resume time has been reached with `NewEvents` and immdiately move
+                            // into event processing.
+                            true => {
+                                self.call_event_handler(Event::NewEvents(StartCause::ResumeTimeReached {
+                                    start: wait_start,
+                                    requested_resume: resume_time,
+                                }));
+                                RunnerState::HandlingEvents
+                            },
+                            // However, if the current time is EARLIER than the requested resume time, we
+                            // don't want to send the `WaitCancelled` event until we know an event is being
+                            // sent. Defer.
+                            false => RunnerState::DeferredNewEvents(wait_start)
+                        }
+                    },
+                    // If we're waiting, `NewEvents` doesn't get sent until winit gets an event, so
+                    // we defer.
+                    ControlFlow::Wait |
+                    // `Exit` shouldn't really ever get sent here, but if it does do something somewhat sane.
+                    ControlFlow::Exit => RunnerState::DeferredNewEvents(wait_start),
+                }
+            }
+        };
+    }
+
+    fn process_event(&mut self, event: Event<T>) {
+        // If we're in the modal loop, we need to have some mechanism for finding when the event
+        // queue has been cleared so we can call `events_cleared`. Windows doesn't give any utilities
+        // for doing this, but it DOES guarantee that WM_PAINT will only occur after input events have
+        // been processed. So, we send WM_PAINT to a dummy window which calls `events_cleared` when
+        // the events queue has been emptied.
+        if self.in_modal_loop {
+            unsafe {
+                winuser::RedrawWindow(
+                    self.modal_redraw_window,
+                    ptr::null(),
+                    ptr::null_mut(),
+                    winuser::RDW_INTERNALPAINT,
+                );
+            }
+        }
+
+        // If new event processing has to be done (i.e. call NewEvents or defer), do it. If we're
+        // already in processing nothing happens with this call.
+        self.new_events();
+
+        // Now that an event has been received, we have to send any `NewEvents` calls that were
+        // deferred.
+        if let RunnerState::DeferredNewEvents(wait_start) = self.runner_state {
+            match self.control_flow {
+                ControlFlow::Exit | ControlFlow::Wait => {
+                    self.call_event_handler(Event::NewEvents(StartCause::WaitCancelled {
+                        start: wait_start,
+                        requested_resume: None,
+                    }))
+                }
+                ControlFlow::WaitUntil(resume_time) => {
+                    let start_cause = match Instant::now() >= resume_time {
+                        // If the current time is later than the requested resume time, the resume time
+                        // has been reached.
+                        true => StartCause::ResumeTimeReached {
+                            start: wait_start,
+                            requested_resume: resume_time,
+                        },
+                        // Otherwise, the requested resume time HASN'T been reached and we send a WaitCancelled.
+                        false => StartCause::WaitCancelled {
+                            start: wait_start,
+                            requested_resume: Some(resume_time),
+                        },
+                    };
+                    self.call_event_handler(Event::NewEvents(start_cause));
+                }
+                // This can be reached if the control flow is changed to poll during a `RedrawRequested`
+                // that was sent after `EventsCleared`.
+                ControlFlow::Poll => self.call_event_handler(Event::NewEvents(StartCause::Poll)),
+            }
+        }
+
+        match (self.runner_state, &event) {
+            (RunnerState::HandlingRedraw, Event::RedrawRequested(_)) => self.call_event_handler(event),
+            (_, Event::RedrawRequested(_)) => {
+                self.call_event_handler(Event::MainEventsCleared);
+                self.runner_state = RunnerState::HandlingRedraw;
+                self.call_event_handler(event);
+            },
+            (RunnerState::HandlingRedraw, _) => {
+                warn!("Non-redraw event dispatched durning redraw phase");
+                self.events_cleared();
+                self.new_events();
+                self.call_event_handler(event);
+            }
+            (_, _) => {
+                self.runner_state = RunnerState::HandlingEvents;
+                self.call_event_handler(event);
+            }
+        }
+    }
+
+    fn flush_redraws(&mut self) {
+        loop {
+            let redraw_window_opt = self.redraw_buffer.borrow_mut().pop_front();
+            match redraw_window_opt {
+                Some(window_id) => self.process_event(Event::RedrawRequested(window_id)),
+                None => break,
+            }
+        }
+    }
+
+    fn events_cleared(&mut self) {
+        match self.runner_state {
+            // If we were handling events, send the EventsCleared message.
+            RunnerState::HandlingEvents => {
+                self.call_event_handler(Event::MainEventsCleared);
+                self.flush_redraws();
+                self.call_event_handler(Event::RedrawEventsCleared);
+                self.runner_state = RunnerState::Idle(Instant::now());
+            }
+
+            RunnerState::HandlingRedraw => {
+                self.call_event_handler(Event::RedrawEventsCleared);
+                self.runner_state = RunnerState::Idle(Instant::now());
+            }
+
+            // If we *weren't* handling events, we don't have to do anything.
+            RunnerState::New | RunnerState::Idle(..) => (),
+
+            // Some control flows require a NewEvents call even if no events were received. This
+            // branch handles those.
+            RunnerState::DeferredNewEvents(wait_start) => {
+                match self.control_flow {
+                    // If we had deferred a Poll, send the Poll NewEvents and EventsCleared.
+                    ControlFlow::Poll => {
+                        self.call_event_handler(Event::NewEvents(StartCause::Poll));
+                        self.call_event_handler(Event::MainEventsCleared);
+                        self.flush_redraws();
+                        self.call_event_handler(Event::RedrawEventsCleared);
+                    }
+                    // If we had deferred a WaitUntil and the resume time has since been reached,
+                    // send the resume notification and EventsCleared event.
+                    ControlFlow::WaitUntil(resume_time) => {
+                        if Instant::now() >= resume_time {
+                            self.call_event_handler(Event::NewEvents(
+                                StartCause::ResumeTimeReached {
+                                    start: wait_start,
+                                    requested_resume: resume_time,
+                                },
+                            ));
+                            self.call_event_handler(Event::MainEventsCleared);
+                            self.flush_redraws();
+                            self.call_event_handler(Event::RedrawEventsCleared);
+                        }
+                    }
+                    // If we deferred a wait and no events were received, the user doesn't have to
+                    // get an event.
+                    ControlFlow::Wait | ControlFlow::Exit => (),
+                }
+                // Mark that we've entered an idle state.
+                self.runner_state = RunnerState::Idle(wait_start)
+            }
+        }
+    }
+
+    fn call_event_handler(&mut self, event: Event<T>) {
+        if self.panic_error.is_none() {
+            let EventLoopRunner {
+                ref mut panic_error,
+                ref mut event_handler,
+                ref mut control_flow,
+                ..
+            } = self;
+            *panic_error = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+                if *control_flow != ControlFlow::Exit {
+                    (*event_handler)(event, control_flow);
+                } else {
+                    (*event_handler)(event, &mut ControlFlow::Exit);
+                }
+            }))
+            .err();
+        }
+    }
+}