wip

Author: prokopyl

examples/open_parented/src/main.rs

@@ -1,7 +1,7 @@
 use baseview::dpi::LogicalSize;
 use baseview::{
-    Event, EventStatus, HandlerError, WindowContext, WindowHandle, WindowHandler,
-    WindowOpenOptions, WindowSize,
+    Event, EventStatus, HandlerError, Window, WindowContext, WindowHandler, WindowOpenOptions,
+    WindowSize,
 };
 use std::cell::{Cell, RefCell};
 use std::num::NonZeroU32;
@@ -10,7 +10,7 @@ struct ParentWindowHandler {
     surface: RefCell<softbuffer::Surface<WindowContext, WindowContext>>,
     damaged: Cell<bool>,
 
-    child_window: WindowHandle,
+    child_window: Window,
 }
 
 impl ParentWindowHandler {
@@ -25,7 +25,7 @@ impl ParentWindowHandler {
             .with_parent(&window)
             .with_title("baseview child");
 
-        let child_window = baseview::create_window(window_open_options, ChildWindowHandler::new)?;
+        let child_window = Window::create(window_open_options, ChildWindowHandler::new)?;
 
         Ok(Self { surface: surface.into(), damaged: true.into(), child_window })
     }
@@ -130,7 +130,7 @@ impl WindowHandler for ChildWindowHandler {
 fn main() -> Result<(), baseview::Error> {
     let window_open_options = WindowOpenOptions::new().with_size(LogicalSize::new(512.0, 512.0));
 
-    baseview::create_window(window_open_options, ParentWindowHandler::new)?.run_until_closed()?;
+    Window::create(window_open_options, ParentWindowHandler::new)?.run_until_closed()?;
 
     Ok(())
 }

examples/open_window/src/main.rs

@@ -8,8 +8,8 @@ use rtrb::{Consumer, RingBuffer};
 use baseview::copy_to_clipboard;
 use baseview::dpi::{LogicalSize, PhysicalPosition};
 use baseview::{
-    Event, EventStatus, HandlerError, MouseEvent, WindowContext, WindowHandler, WindowOpenOptions,
-    WindowSize,
+    Event, EventStatus, HandlerError, MouseEvent, Window, WindowContext, WindowHandler,
+    WindowOpenOptions, WindowSize,
 };
 
 #[derive(Debug, Clone)]
@@ -152,7 +152,7 @@ fn main() -> Result<(), baseview::Error> {
         }
     });
 
-    baseview::create_window(window_open_options, |window| {
+    Window::create(window_open_options, |window| {
         let ctx = softbuffer::Context::new(window.clone())?;
         let mut surface = softbuffer::Surface::new(&ctx, window.clone())?;
         let size = window.size().physical;

examples/plugin_clack/src/gui.rs

@@ -3,7 +3,7 @@ use crate::ExamplePluginMainThread;
 use baseview::dpi::*;
 use baseview::gl::GlConfig;
 use baseview::host::{Host, HostCallbacks, HostMainThreadCaller};
-use baseview::{HandlerError, WindowHandle, WindowOpenOptions, WindowSize};
+use baseview::{HandlerError, Window, WindowOpenOptions, WindowSize};
 use clack_extensions::gui::{
     AspectRatioStrategy, GuiApiType, GuiConfiguration, GuiResizeHints, GuiSize, HostGui,
     PluginGuiImpl, Window as ClapWindow,
@@ -14,7 +14,7 @@ use clack_plugin::prelude::{HostMainThreadHandle, HostSharedHandle};
 use raw_window_handle::HasRawWindowHandle;
 
 pub struct ExamplePluginGui {
-    pub handle: WindowHandle,
+    pub handle: Window,
 }
 
 impl PluginGuiImpl for ExamplePluginMainThread<'_> {
@@ -45,7 +45,7 @@ impl PluginGuiImpl for ExamplePluginMainThread<'_> {
             });
         }
 
-        let window = baseview::create_window_with_host(options, OpenWindowExample::new, host)?;
+        let window = Window::create_with_host(options, OpenWindowExample::new, host)?;
 
         self.gui = Some(ExamplePluginGui { handle: window });
         Ok(())

examples/render_femtovg/src/main.rs

@@ -1,8 +1,8 @@
 use baseview::dpi::{LogicalSize, PhysicalPosition};
 use baseview::gl::{GlConfig, GlContext};
 use baseview::{
-    Event, EventStatus, HandlerError, MouseEvent, WindowContext, WindowHandler, WindowOpenOptions,
-    WindowSize,
+    Event, EventStatus, HandlerError, MouseEvent, Window, WindowContext, WindowHandler,
+    WindowOpenOptions, WindowSize,
 };
 use femtovg::renderer::OpenGl;
 use femtovg::{Canvas, Color};
@@ -123,7 +123,7 @@ fn main() -> Result<(), baseview::Error> {
         .with_size(LogicalSize::new(512, 512))
         .with_gl_config(GlConfig { alpha_bits: 8, ..GlConfig::default() });
 
-    baseview::create_window(window_open_options, FemtovgExample::new)?.run_until_closed()?;
+    Window::create(window_open_options, FemtovgExample::new)?.run_until_closed()?;
     Ok(())
 }
 

examples/render_wgpu/src/main.rs

@@ -1,6 +1,7 @@
 use baseview::dpi::{LogicalSize, PhysicalSize};
 use baseview::{
-    Event, EventStatus, HandlerError, WindowContext, WindowHandler, WindowOpenOptions, WindowSize,
+    Event, EventStatus, HandlerError, Window, WindowContext, WindowHandler, WindowOpenOptions,
+    WindowSize,
 };
 
 use log::LevelFilter;
@@ -214,7 +215,7 @@ fn main() -> Result<(), baseview::Error> {
         .with_title("WGPU on Baseview")
         .with_size(LogicalSize::new(512, 512));
 
-    baseview::create_window(window_open_options, |c| pollster::block_on(WgpuExample::new(c)))?
+    Window::create(window_open_options, |c| pollster::block_on(WgpuExample::new(c)))?
         .run_until_closed()?;
 
     Ok(())

src/host.rs

@@ -3,7 +3,7 @@ use std::cell::RefCell;
 
 /// A special handler for the Window thread to wake up and call methods on the main thread.
 ///
-/// [`WindowHandle::host_main_thread_callback`](crate::WindowHandle::host_main_thread_callback)
+/// [`WindowHandle::host_main_thread_callback`](crate::Window::host_main_thread_callback)
 /// should be called as a response to this.
 ///
 /// # Platform compatibility notes
@@ -12,7 +12,7 @@ use std::cell::RefCell;
 pub trait HostMainThreadCaller: Send + 'static {
     /// Schedules a callback on the main thread.
     ///
-    /// [`WindowHandle::host_main_thread_callback`](crate::WindowHandle::host_main_thread_callback)
+    /// [`WindowHandle::host_main_thread_callback`](crate::Window::host_main_thread_callback)
     /// should be called as a response to this.
     ///
     /// # Platform compatibility notes
@@ -50,7 +50,7 @@ pub trait HostCallbacks: 'static {
 ///
 /// It also brings the additional safety guarantee that all handlers given to this types will be
 /// destroyed alongside with the window, guaranteeing callbacks cannot be fired after the
-/// [`WindowHandle`](crate::WindowHandle) is dropped. (or after this [`Host`] object is dropped, if
+/// [`WindowHandle`](crate::Window) is dropped. (or after this [`Host`] object is dropped, if
 /// it never made it to a [`create_window_with_host`](crate::create_window_with_host) call).
 pub struct Host {
     #[cfg(target_os = "linux")]

src/window.rs

@@ -5,39 +5,57 @@ use crate::*;
 use dpi::{LogicalSize, PhysicalSize, Pixel, Size};
 use std::marker::PhantomData;
 
-pub struct WindowHandle {
-    window_handle: platform::WindowHandle,
+pub struct Window {
+    inner: platform::WindowHandle,
     // so that WindowHandle is !Send on all platforms
     phantom: PhantomData<*mut ()>,
 }
 
-impl WindowHandle {
+impl Window {
     #[inline]
-    fn new(window_handle: platform::WindowHandle) -> Self {
-        Self { window_handle, phantom: PhantomData }
+    pub fn create<H: WindowHandler>(
+        builder: WindowOpenOptions,
+        handler: impl FnOnce(WindowContext) -> Result<H, HandlerError> + Send + 'static,
+    ) -> Result<Window, Error> {
+        Self::create_with_host(builder, handler, None)
+    }
+
+    pub fn create_with_host<H: WindowHandler>(
+        builder: WindowOpenOptions,
+        handler: impl FnOnce(WindowContext) -> Result<H, HandlerError> + Send + 'static,
+        host: impl Into<Option<Host>>,
+    ) -> Result<Window, Error> {
+        Ok(Self {
+            inner: platform::WindowHandle::create_window(
+                builder,
+                WindowHandlerBuilder::new(handler),
+                host.into().unwrap_or_else(Host::default),
+            )?,
+            phantom: PhantomData,
+        })
     }
 
     /// Blocks the thread and runs an event loop until the window is closed.
     ///
     /// The window is shown automatically if it wasn't already.
     #[inline]
     pub fn run_until_closed(self) -> Result<(), Error> {
-        self.window_handle.run_until_closed()?;
+        self.inner.run_until_closed()?;
         Ok(())
     }
 
     /// The current size of the window.
     #[inline]
     pub fn size(&self) -> WindowSize {
-        self.window_handle.size()
+        self.inner.size()
     }
 
     /// Resizes the window to the given [`Size`].
     ///
     /// The `size` can be provided in either physical or logical pixels.
     #[inline]
     pub fn resize(&self, size: Size) -> Result<(), Error> {
-        self.window_handle.resize(size)?;
+        self.inner.resize(size)?;
         Ok(())
     }
 
@@ -57,7 +75,7 @@ impl WindowHandle {
     /// On macOS, this function is always a no-op.
     #[inline]
     pub fn suggest_fallback_scale_factor(&self, scale_factor: f64) -> Result<(), Error> {
-        self.window_handle.suggest_scale_factor(scale_factor)?;
+        self.inner.suggest_scale_factor(scale_factor)?;
         Ok(())
     }
 
@@ -68,7 +86,7 @@ impl WindowHandle {
     /// It is guaranteed that no other objects (e.g. the parent window) are used by this window after
     /// this call.
     ///
-    /// Calling this method is more explicit, but otherwise identical to just dropping this [`WindowHandle`].
+    /// Calling this method is more explicit, but otherwise identical to just dropping this [`Window`].
     #[inline]
     pub fn close(self) {
         drop(self)
@@ -78,7 +96,7 @@ impl WindowHandle {
     /// if the window was closed/dropped.
     #[inline]
     pub fn is_open(&self) -> bool {
-        self.window_handle.is_open()
+        self.inner.is_open()
     }
 
     /// Performs the work the window thread had scheduled for the main thread.
@@ -92,22 +110,22 @@ impl WindowHandle {
     /// On Windows and macOS, this is always a no-op.
     #[inline]
     pub fn host_main_thread_callback(&mut self) {
-        self.window_handle.handle_main_thread_callback()
+        self.inner.handle_main_thread_callback()
     }
 
     /// Reparents this window using the given `parent`.
     ///
     /// If the window was a floating window, it will become parented.
     #[inline]
     pub fn set_parent(&self, parent: impl Into<ParentWindowHandle>) -> Result<(), Error> {
-        self.window_handle.set_parent(parent.into().inner)?;
+        self.inner.set_parent(parent.into().inner)?;
         Ok(())
     }
 
     /// Shows the window to the screen.
     #[inline]
     pub fn show(&self) -> Result<(), Error> {
-        self.window_handle.show()?;
+        self.inner.show()?;
         Ok(())
     }
 
@@ -117,31 +135,11 @@ impl WindowHandle {
     /// paused and the user will not be able to see or interact with it.
     #[inline]
     pub fn hide(&self) -> Result<(), Error> {
-        self.window_handle.hide()?;
+        self.inner.hide()?;
         Ok(())
     }
 }
 
-#[inline]
-pub fn create_window<H: WindowHandler>(
-    builder: WindowOpenOptions,
-    handler: impl FnOnce(WindowContext) -> Result<H, HandlerError> + Send + 'static,
-) -> Result<WindowHandle, Error> {
-    create_window_with_host(builder, handler, None)
-}
-
-pub fn create_window_with_host<H: WindowHandler>(
-    builder: WindowOpenOptions,
-    handler: impl FnOnce(WindowContext) -> Result<H, HandlerError> + Send + 'static,
-    host: impl Into<Option<Host>>,
-) -> Result<WindowHandle, Error> {
-    Ok(WindowHandle::new(platform::WindowHandle::create_window(
-        builder,
-        WindowHandlerBuilder::new(handler),
-        host.into().unwrap_or_else(Host::default),
-    )?))
-}
-
 /// A window's size, which can be read in either logical or physical pixels.
 ///
 /// Methods that produce this type in baseview guarantee that either the physical or the logical