separate Window::open() into three functions (parented, as_if_parented, and blocking)

Author: micahrj

examples/open_window.rs

@@ -34,16 +34,10 @@ fn main() {
         title: "baseview".into(),
         size: baseview::Size::new(512.0, 512.0),
         scale: WindowScalePolicy::SystemScaleFactor,
-        parent: baseview::Parent::None,
     };
 
     let (mut tx, rx) = RingBuffer::new(128).split();
 
-    let opt_app_runner = Window::open(
-        window_open_options,
-        |_| OpenWindowExample { rx }
-    );
-
     ::std::thread::spawn(move || {
         loop {
             ::std::thread::sleep(Duration::from_secs(5));
@@ -54,5 +48,8 @@ fn main() {
         }
     });
 
-    opt_app_runner.unwrap().app_run_blocking();
+    Window::open_blocking(
+        window_open_options,
+        |_| OpenWindowExample { rx }
+    );
 }

src/lib.rs

@@ -1,5 +1,3 @@
-use raw_window_handle::RawWindowHandle;
-
 #[cfg(target_os = "windows")]
 mod win;
 #[cfg(target_os = "linux")]
@@ -19,17 +17,3 @@ pub use mouse_cursor::MouseCursor;
 pub use window::*;
 pub use window_info::*;
 pub use window_open_options::*;
-
-#[derive(Debug)]
-pub enum Parent {
-    None,
-    AsIfParented,
-    WithParent(RawWindowHandle),
-}
-
-unsafe impl Send for Parent {}
-
-pub trait WindowHandler {
-    fn on_frame(&mut self);
-    fn on_event(&mut self, window: &mut Window, event: Event);
-}

src/macos/window.rs

@@ -17,27 +17,13 @@ use objc::{msg_send, runtime::Object, sel, sel_impl};
 use raw_window_handle::{macos::MacOSHandle, HasRawWindowHandle, RawWindowHandle};
 
 use crate::{
-    Event, Parent, WindowHandler, WindowOpenOptions,
-    WindowScalePolicy, WindowInfo
+    Event, WindowHandler, WindowOpenOptions, WindowScalePolicy, WindowInfo,
 };
 
 use super::view::{create_view, BASEVIEW_STATE_IVAR};
 use super::keyboard::KeyboardState;
 
 
-pub struct AppRunner;
-
-impl AppRunner {
-    pub fn app_run_blocking(self) {
-        unsafe {
-            // Get reference to already created shared NSApplication object
-            // and run the main loop
-            NSApp().run();
-        }
-    }
-}
-
-
 pub struct Window {
     /// Only set if we created the parent window, i.e. we are running in
     /// parentless mode
@@ -47,102 +33,147 @@ pub struct Window {
 }
 
 impl Window {
-    pub fn open<H, B>(
-        options: WindowOpenOptions,
-        build: B
-    ) -> Option<crate::AppRunner>
-        where H: WindowHandler + 'static,
-              B: FnOnce(&mut crate::Window) -> H,
-              B: Send + 'static
+    pub fn open_parented<P, H, B>(parent: &P, options: WindowOpenOptions, build: B)
+    where
+        P: HasRawWindowHandle,
+        H: WindowHandler + 'static,
+        B: FnOnce(&mut crate::Window) -> H,
+        B: Send + 'static,
     {
         let _pool = unsafe { NSAutoreleasePool::new(nil) };
 
-        let mut window = unsafe {
-            Window {
-                ns_window: None,
-                ns_view: create_view(&options),
-            }
+        let handle = if let RawWindowHandle::MacOS(handle) = parent.raw_window_handle() {
+            handle
+        } else {
+            panic!("Not a macOS window");
         };
 
-        let window_handler = Box::new(build(&mut crate::Window::new(&mut window)));
+        let ns_view = unsafe { create_view(&options) };
 
-        let retain_count_after_build: usize = unsafe {
-            msg_send![window.ns_view, retainCount]
+        let window = Window {
+            ns_window: None,
+            ns_view,
+        };
+
+        Self::init(window, build);
+
+        unsafe {
+            let _: id = msg_send![handle.ns_view as *mut Object, addSubview: ns_view];
+        }
+    }
+
+    pub fn open_as_if_parented<H, B>(options: WindowOpenOptions, build: B) -> RawWindowHandle
+    where
+        H: WindowHandler + 'static,
+        B: FnOnce(&mut crate::Window) -> H,
+        B: Send + 'static,
+    {
+        let _pool = unsafe { NSAutoreleasePool::new(nil) };
+
+        let ns_view = unsafe { create_view(&options) };
+
+        let window = Window {
+            ns_window: None,
+            ns_view,
         };
 
-        let opt_app_runner = match options.parent {
-            Parent::WithParent(RawWindowHandle::MacOS(handle)) => {
-                unsafe {
-                    let () = msg_send![
-                        handle.ns_view as *mut Object,
-                        addSubview: window.ns_view
-                    ];
-                }
-
-                None
-            },
-            Parent::WithParent(_) => {
-                panic!("Not a macOS window");
-            },
-            Parent::AsIfParented => {
-                None
-            },
-            Parent::None => {
-                // It seems prudent to run NSApp() here before doing other
-                // work. It runs [NSApplication sharedApplication], which is
-                // what is run at the very start of the Xcode-generated main
-                // function of a cocoa app according to:
-                // https://developer.apple.com/documentation/appkit/nsapplication
-                unsafe {
-                    let app = NSApp();
-                    app.setActivationPolicy_(
-                        NSApplicationActivationPolicyRegular
-                    );
-                }
-
-                let scaling = match options.scale {
-                    WindowScalePolicy::ScaleFactor(scale) => scale,
-                    WindowScalePolicy::SystemScaleFactor => 1.0,
-                };
+        let raw_window_handle = window.raw_window_handle();
+
+        Self::init(window, build);
+
+        raw_window_handle
+    }
+
+    pub fn open_blocking<H, B>(options: WindowOpenOptions, build: B)
+    where
+        H: WindowHandler + 'static,
+        B: FnOnce(&mut crate::Window) -> H,
+        B: Send + 'static,
+    {
+        let _pool = unsafe { NSAutoreleasePool::new(nil) };
+
+        // It seems prudent to run NSApp() here before doing other
+        // work. It runs [NSApplication sharedApplication], which is
+        // what is run at the very start of the Xcode-generated main
+        // function of a cocoa app according to:
+        // https://developer.apple.com/documentation/appkit/nsapplication
+        let app = unsafe { NSApp() };
+
+        unsafe {
+            app.setActivationPolicy_(
+                NSApplicationActivationPolicyRegular
+            );
+        }
+
+        let scaling = match options.scale {
+            WindowScalePolicy::ScaleFactor(scale) => scale,
+            WindowScalePolicy::SystemScaleFactor => 1.0,
+        };
 
-                let window_info = WindowInfo::from_logical_size(
-                    options.size,
-                    scaling
-                );
+        let window_info = WindowInfo::from_logical_size(
+            options.size,
+            scaling
+        );
 
-                let rect = NSRect::new(
-                    NSPoint::new(0.0, 0.0),
-                    NSSize::new(
-                        window_info.logical_size().width as f64,
-                        window_info.logical_size().height as f64
-                    ),
-                );
+        let rect = NSRect::new(
+            NSPoint::new(0.0, 0.0),
+            NSSize::new(
+                window_info.logical_size().width as f64,
+                window_info.logical_size().height as f64
+            ),
+        );
 
-                unsafe {
-                    let ns_window = NSWindow::alloc(nil)
-                        .initWithContentRect_styleMask_backing_defer_(
-                            rect,
-                            NSWindowStyleMask::NSTitledWindowMask,
-                            NSBackingStoreBuffered,
-                            NO,
-                        )
-                        .autorelease();
-                    ns_window.center();
+        let ns_window = unsafe {
+            let ns_window = NSWindow::alloc(nil)
+                .initWithContentRect_styleMask_backing_defer_(
+                    rect,
+                    NSWindowStyleMask::NSTitledWindowMask,
+                    NSBackingStoreBuffered,
+                    NO,
+                )
+                .autorelease();
+            ns_window.center();
+
+            let title = NSString::alloc(nil)
+                .init_str(&options.title)
+                .autorelease();
+            ns_window.setTitle_(title);
+
+            ns_window.makeKeyAndOrderFront_(nil);
+
+            ns_window
+        };
 
-                    let title = NSString::alloc(nil)
-                        .init_str(&options.title)
-                        .autorelease();
-                    ns_window.setTitle_(title);
+        let ns_view = unsafe { create_view(&options) };
 
-                    ns_window.makeKeyAndOrderFront_(nil);
+        let window = Window {
+            ns_window: Some(ns_window),
+            ns_view,
+        };
 
-                    ns_window.setContentView_(window.ns_view);
+        Self::init(window, build);
 
-                    window.ns_window = Some(ns_window);
+        unsafe {
+            ns_window.setContentView_(ns_view);
+        }
 
-                    Some(crate::AppRunner(AppRunner))
-                }
-            },
+        unsafe {
+            app.run();
+        }
+    }
+
+    fn init<H, B>(
+        mut window: Window,
+        build: B
+    )
+    where H: WindowHandler + 'static,
+          B: FnOnce(&mut crate::Window) -> H,
+          B: Send + 'static,
+    {
+        let window_handler = Box::new(build(&mut crate::Window::new(&mut window)));
+
+        let retain_count_after_build: usize = unsafe {
+            msg_send![window.ns_view, retainCount]
         };
 
         let window_state_ptr = Box::into_raw(Box::new(WindowState {
@@ -161,8 +192,6 @@ impl Window {
 
             WindowState::setup_timer(window_state_ptr);
         }
-
-        opt_app_runner
     }
 }