wip

Author: prokopyl

examples/plugin_clack/src/gui.rs

@@ -71,7 +71,9 @@ impl PluginGuiImpl for ExamplePluginMainThread<'_> {
             return None;
         };
 
-        Some(window_size_to_gui_size(gui.handle.size()))
+        let size = gui.handle.size().to_native_size();
+
+        Some(GuiSize { width: size.width, height: size.height })
     }
 
     fn can_resize(&mut self) -> bool {
@@ -96,13 +98,13 @@ impl PluginGuiImpl for ExamplePluginMainThread<'_> {
         let scale_factor = gui.handle.size().scale_factor;
 
         if let Some(max_size) = gui.handle.max_size() {
-            let max_size = size_to_gui_size(max_size, scale_factor);
+            let max_size = NativeSize::from_size(max_size, scale_factor);
             size.width = size.width.min(max_size.width);
             size.height = size.height.min(max_size.height);
         }
 
         if let Some(min_size) = gui.handle.min_size() {
-            let min_size = size_to_gui_size(min_size, scale_factor);
+            let min_size = NativeSize::from_size(min_size, scale_factor);
             size.width = size.width.max(min_size.width);
             size.height = size.height.max(min_size.height);
         }
@@ -115,8 +117,7 @@ impl PluginGuiImpl for ExamplePluginMainThread<'_> {
             return Err(PluginError::Message("set_size called without a GUI active"));
         };
 
-        let size = gui_size_to_window_size(size);
-        gui.handle.resize(size)?;
+        gui.handle.resize(NativeSize { width: size.width, height: size.height })?;
 
         Ok(())
     }
@@ -162,45 +163,6 @@ impl PluginGuiImpl for ExamplePluginMainThread<'_> {
     }
 }
 
-fn size_to_gui_size(size: Size, scale_factor: f64) -> GuiSize {
-    #[cfg(target_os = "macos")]
-    {
-        let size = size.to_logical(scale_factor);
-        GuiSize { width: size.width, height: size.height }
-    }
-
-    #[cfg(not(target_os = "macos"))]
-    {
-        let size = size.to_physical(scale_factor);
-        GuiSize { width: size.width, height: size.height }
-    }
-}
-
-fn window_size_to_gui_size(size: WindowSize) -> GuiSize {
-    #[cfg(target_os = "macos")]
-    {
-        let size = size.logical.cast();
-        GuiSize { width: size.width, height: size.height }
-    }
-
-    #[cfg(not(target_os = "macos"))]
-    {
-        let size = size.physical.cast();
-        GuiSize { width: size.width, height: size.height }
-    }
-}
-
-fn gui_size_to_window_size(size: GuiSize) -> Size {
-    #[cfg(target_os = "macos")]
-    {
-        Size::Logical(LogicalSize::new(size.width, size.height).cast())
-    }
-    #[cfg(not(target_os = "macos"))]
-    {
-        Size::Physical(PhysicalSize::new(size.width, size.height))
-    }
-}
-
 struct MainThreadHandler {
     host: HostSharedHandle<'static>,
 }
@@ -218,8 +180,8 @@ struct HostGuiCallbacks {
 
 impl HostCallbacks for HostGuiCallbacks {
     fn request_resize(&mut self, new_size: WindowSize) -> Result<(), HandlerError> {
-        let size = window_size_to_gui_size(new_size);
-        self.ext.request_resize(&self.host, size.width, size.height)?;
+        let new_size = new_size.to_native_size();
+        self.ext.request_resize(&self.host, new_size.width, new_size.height)?;
         Ok(())
     }
 

src/context.rs

@@ -1,6 +1,6 @@
 use super::*;
+use crate::dpi::Size;
 use crate::{platform, MouseCursor, WindowSize};
-use dpi::Size;
 use raw_window_handle::{
     DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, WindowHandle,
 };

src/dpi.rs

@@ -0,0 +1,96 @@
+use crate::WindowSize;
+pub use dpi::*;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct NativeSize<P> {
+    pub width: P,
+    pub height: P,
+}
+
+impl<P> NativeSize<P> {
+    #[inline]
+    pub const fn new(width: P, height: P) -> Self {
+        NativeSize { width, height }
+    }
+}
+
+impl<P: Pixel> NativeSize<P> {
+    #[inline]
+    pub fn from_size(size: Size, scale_factor: f64) -> Self {
+        #[cfg(target_os = "macos")]
+        {
+            let size = size.to_logical(scale_factor);
+            Self { width: size.width, height: size.height }
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        {
+            let size = size.to_physical(scale_factor);
+            Self { width: size.width, height: size.height }
+        }
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> NativeSize<X> {
+        NativeSize { width: self.width.cast(), height: self.height.cast() }
+    }
+
+    #[inline]
+    pub fn to_physical(self, scale_factor: f64) -> PhysicalSize<P> {
+        #[cfg(target_os = "macos")]
+        {
+            let size = LogicalSize { width: self.width, height: self.height };
+            size.to_physical(scale_factor)
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            let _ = scale_factor;
+            PhysicalSize { width: self.width, height: self.height }
+        }
+    }
+
+    #[inline]
+    pub fn to_logical(self, scale_factor: f64) -> LogicalSize<P> {
+        #[cfg(target_os = "macos")]
+        {
+            let _ = scale_factor;
+            LogicalSize { width: self.width, height: self.height }
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            let size = PhysicalSize { width: self.width, height: self.height };
+            size.to_logical(scale_factor)
+        }
+    }
+}
+
+impl<P: Pixel> From<WindowSize> for NativeSize<P> {
+    #[inline]
+    fn from(size: WindowSize) -> Self {
+        #[cfg(target_os = "macos")]
+        {
+            let size = size.logical.cast();
+            Self { width: size.width, height: size.height }
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        {
+            let size = size.physical.cast();
+            Self { width: size.width, height: size.height }
+        }
+    }
+}
+
+impl<P: Pixel> From<NativeSize<P>> for Size {
+    #[inline]
+    fn from(size: NativeSize<P>) -> Self {
+        #[cfg(target_os = "macos")]
+        {
+            Size::Logical(LogicalSize::new(size.width, size.height).cast())
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            Size::Physical(PhysicalSize::new(size.width, size.height).cast())
+        }
+    }
+}

src/lib.rs

@@ -1,5 +1,6 @@
 mod clipboard;
 mod context;
+pub mod dpi;
 mod error;
 mod event;
 mod handler;
@@ -17,7 +18,6 @@ pub mod gl;
 
 pub use clipboard::*;
 pub use context::{PlatformHandle, WindowContext};
-pub use dpi;
 pub use error::*;
 pub use event::*;
 pub use handler::WindowHandler;

src/window.rs

@@ -1,8 +1,8 @@
+use crate::dpi::*;
 use crate::handler::WindowHandlerBuilder;
 use crate::host::Host;
 use crate::platform;
 use crate::*;
-use dpi::{LogicalSize, PhysicalSize, Pixel, Size};
 use std::marker::PhantomData;
 
 /// A handle to a Window created by baseview.
@@ -262,6 +262,11 @@ impl WindowSize {
     pub fn from_logical(logical: LogicalSize<f64>, scale_factor: f64) -> Self {
         Self { physical: logical.to_physical(scale_factor), logical, scale_factor }
     }
+
+    #[inline]
+    pub fn to_native_size<P: Pixel>(&self) -> NativeSize<P> {
+        (*self).into()
+    }
 }
 
 impl<P: Pixel> From<WindowSize> for PhysicalSize<P> {