Add initial implementation of run_embedded

Osspial · Osspial · commit c04ace538cbe · 2020-05-15T19:06:41.000-04:00
diff --git a/src/platform/windows.rs b/src/platform/windows.rs
@@ -9,15 +9,20 @@ use winapi::shared::windef::HWND;
 
 use crate::{
     dpi::PhysicalSize,
-    event::DeviceId,
-    event_loop::{EventLoop, EventLoopWindowTarget},
+    event::{DeviceId, Event},
+    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
     monitor::MonitorHandle,
-    platform_impl::{EventLoop as WindowsEventLoop, WinIcon},
+    platform_impl::{EventLoop as WindowsEventLoop, WinIcon, EventLoopEmbedded as WindowsEventLoopEmbedded},
     window::{BadIcon, Icon, Window, WindowBuilder},
 };
 
+pub struct EventLoopEmbedded<'a, T: 'static> {
+    p: WindowsEventLoopEmbedded<'a, T>,
+}
+
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopExtWindows {
+    type UserEvent;
     /// Creates an event loop off of the main thread.
     ///
     /// # `Window` caveats
@@ -41,9 +46,24 @@ pub trait EventLoopExtWindows {
     fn new_dpi_unaware_any_thread() -> Self
     where
         Self: Sized;
+
+    /// Initialize an event loop that can run through somebody else's event pump.
+    ///
+    /// This does *not* dispatch events without external assistance! Other code must be running a
+    /// [Win32 message loop](https://docs.microsoft.com/en-us/windows/win32/learnwin32/window-messages),
+    /// and the `event_handler` closure will be called while the `EventLoopEmbedded` is in scope.
+    /// The loop can come from any code that calls the native Win32 message loop functions - for
+    /// example, this could be used to embed a Winit message loop in an SDL or GLFW application, or
+    /// create a DAW plugin.
+    ///
+    /// TODO: REWRITE `exit_requested` and `resume_panic_if_necessary` as trait functions.
+    fn run_embedded<'a, F>(self, event_handler: F) -> EventLoopEmbedded<'a, Self::UserEvent>
+    where
+        F: 'a + FnMut(Event<'_, Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
 }
 
 impl<T> EventLoopExtWindows for EventLoop<T> {
+    type UserEvent = T;
     #[inline]
     fn new_any_thread() -> Self {
         EventLoop {
@@ -67,6 +87,25 @@ impl<T> EventLoopExtWindows for EventLoop<T> {
             _marker: ::std::marker::PhantomData,
         }
     }
+
+    fn run_embedded<'a, F>(self, event_handler: F) -> EventLoopEmbedded<'a, Self::UserEvent>
+    where
+        F: 'a + FnMut(Event<'_, Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow)
+    {
+        EventLoopEmbedded {
+            p: self.event_loop.run_embedded(event_handler)
+        }
+    }
+}
+
+impl<T> EventLoopEmbedded<'_, T> {
+    pub fn exit_requested(&self) -> bool {
+        self.p.exit_requested()
+    }
+
+    pub fn resume_panic_if_necessary(&self) {
+        self.p.resume_panic_if_necessary()
+    }
 }
 
 /// Additional methods on `EventLoopWindowTarget` that are specific to Windows.
diff --git a/src/platform_impl/windows/event_loop.rs b/src/platform_impl/windows/event_loop.rs
@@ -104,7 +104,7 @@ impl<T> ThreadMsgTargetSubclassInput<T> {
 
 pub struct EventLoop<T: 'static> {
     thread_msg_sender: Sender<T>,
-    window_target: RootELW<T>,
+    window_target: Rc<RootELW<T>>,
 }
 
 pub struct EventLoopWindowTarget<T: 'static> {
@@ -113,6 +113,11 @@ pub struct EventLoopWindowTarget<T: 'static> {
     pub(crate) runner_shared: EventLoopRunnerShared<T>,
 }
 
+pub struct EventLoopEmbedded<'a, T: 'static> {
+    window_target: Rc<RootELW<T>>,
+    _function_lifetime: PhantomData<&'a ()>,
+}
+
 macro_rules! main_thread_check {
     ($fn_name:literal) => {{
         let thread_id = unsafe { processthreadsapi::GetCurrentThreadId() };
@@ -163,14 +168,14 @@ impl<T: 'static> EventLoop<T> {
 
         EventLoop {
             thread_msg_sender,
-            window_target: RootELW {
+            window_target: Rc::new(RootELW {
                 p: EventLoopWindowTarget {
                     thread_id,
                     thread_msg_target,
                     runner_shared,
                 },
                 _marker: PhantomData,
-            },
+            }),
         }
     }
 
@@ -186,49 +191,62 @@ impl<T: 'static> EventLoop<T> {
         ::std::process::exit(0);
     }
 
-    pub fn run_return<F>(&mut self, mut event_handler: F)
+    pub fn run_return<F>(&mut self, event_handler: F)
     where
         F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {
-        let event_loop_windows_ref = &self.window_target;
-
-        unsafe {
-            self.window_target
-                .p
-                .runner_shared
-                .set_event_handler(move |event, control_flow| {
-                    event_handler(event, event_loop_windows_ref, control_flow)
-                });
-        }
-
-        let runner = &self.window_target.p.runner_shared;
-
         unsafe {
+            let runner = self.embedded_runner(event_handler);
             let mut msg = mem::zeroed();
 
-            runner.poll();
             'main: loop {
                 if 0 == winuser::GetMessageW(&mut msg, ptr::null_mut(), 0, 0) {
                     break 'main;
                 }
                 winuser::TranslateMessage(&mut msg);
                 winuser::DispatchMessageW(&mut msg);
 
-                if let Err(payload) = runner.take_panic_error() {
-                    runner.reset_runner();
-                    panic::resume_unwind(payload);
-                }
+                runner.resume_panic_if_necessary();
 
-                if runner.control_flow() == ControlFlow::Exit && !runner.handling_events() {
+                if runner.exit_requested() {
                     break 'main;
                 }
             }
         }
+    }
 
+    pub fn run_embedded<'a, F>(mut self, event_handler: F) -> EventLoopEmbedded<'a, T>
+    where
+        F: 'a + FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow)
+    {
         unsafe {
-            runner.call_event_handler(Event::LoopDestroyed);
+            self.embedded_runner(event_handler)
+        }
+    }
+
+    unsafe fn embedded_runner<'a, F>(
+        &mut self,
+        mut event_handler: F
+    ) -> EventLoopEmbedded<'a, T>
+    where
+        F: 'a + FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow)
+    {
+        let window_target = self.window_target.clone();
+        let event_loop_windows_ptr = &*window_target as *const RootELW<T>;
+
+        window_target
+            .p
+            .runner_shared
+            .set_event_handler(move |event, control_flow| {
+                event_handler(event, &*event_loop_windows_ptr, control_flow)
+            });
+
+        window_target.p.runner_shared.poll();
+
+        EventLoopEmbedded {
+            window_target,
+            _function_lifetime: PhantomData,
         }
-        runner.reset_runner();
     }
 
     pub fn create_proxy(&self) -> EventLoopProxy<T> {
@@ -239,6 +257,39 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
+impl<T> EventLoopEmbedded<'_, T> {
+    pub fn exit_requested(&self) -> bool {
+        let runner = &self.window_target.p.runner_shared;
+        runner.control_flow() == ControlFlow::Exit && !runner.handling_events()
+    }
+
+    pub fn resume_panic_if_necessary(&self) {
+        let runner = &self.window_target.p.runner_shared;
+
+        if let Err(payload) = runner.take_panic_error() {
+            runner.reset_runner();
+            panic::resume_unwind(payload);
+        }
+    }
+}
+
+impl<T> Drop for EventLoopEmbedded<'_, T> {
+    fn drop(&mut self) {
+        unsafe {
+            self.window_target.p.runner_shared.call_event_handler(Event::LoopDestroyed);
+            self.window_target.p.runner_shared.reset_runner();
+        }
+    }
+}
+
+impl<T> Drop for EventLoopWindowTarget<T> {
+    fn drop(&mut self) {
+        unsafe {
+            winuser::DestroyWindow(self.thread_msg_target);
+        }
+    }
+}
+
 impl<T> EventLoopWindowTarget<T> {
     #[inline(always)]
     pub(crate) fn create_thread_executor(&self) -> EventLoopThreadExecutor {
@@ -380,14 +431,6 @@ fn dur2timeout(dur: Duration) -> DWORD {
         .unwrap_or(winbase::INFINITE)
 }
 
-impl<T> Drop for EventLoop<T> {
-    fn drop(&mut self) {
-        unsafe {
-            winuser::DestroyWindow(self.window_target.p.thread_msg_target);
-        }
-    }
-}
-
 pub(crate) struct EventLoopThreadExecutor {
     thread_id: DWORD,
     target_window: HWND,
diff --git a/src/platform_impl/windows/mod.rs b/src/platform_impl/windows/mod.rs
@@ -3,7 +3,7 @@
 use winapi::{self, shared::windef::HWND};
 
 pub use self::{
-    event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
+    event_loop::{EventLoop, EventLoopEmbedded, EventLoopProxy, EventLoopWindowTarget},
     icon::WinIcon,
     monitor::{MonitorHandle, VideoMode},
     window::Window,
