wip

Author: prokopyl

examples/open_parented/src/main.rs

@@ -5,8 +5,6 @@ use baseview::{
 };
 use std::cell::{Cell, RefCell};
 use std::num::NonZeroU32;
-use std::thread;
-use std::time::Duration;
 
 struct ParentWindowHandler {
     surface: RefCell<softbuffer::Surface<WindowContext, WindowContext>>,

src/platform/win/error.rs

@@ -6,6 +6,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 #[derive(Debug)]
 pub enum Error {
     Win32(windows_core::Error),
+    ResizeFailed,
     Handler(HandlerError),
 }
 
@@ -26,6 +27,7 @@ impl Display for Error {
         match self {
             Error::Win32(e) => Display::fmt(e, f),
             Error::Handler(e) => Display::fmt(e, f),
+            Error::ResizeFailed => f.write_str("Window resize request failed."),
         }
     }
 }
@@ -35,6 +37,7 @@ impl std::error::Error for Error {
         match self {
             Error::Win32(e) => Some(e),
             Error::Handler(e) => Some(e.source()),
+            _ => None,
         }
     }
 }

src/platform/win/window.rs

@@ -32,8 +32,7 @@ use crate::wrappers::win32::{
     WindowStyle,
 };
 use crate::{
-    Event, MouseButton, MouseEvent, ScrollDelta, WindowEvent, WindowOpenOptions, WindowScalePolicy,
-    WindowSize,
+    Event, MouseButton, MouseEvent, ScrollDelta, WindowEvent, WindowOpenOptions, WindowSize,
 };
 
 #[allow(non_snake_case)]
@@ -65,6 +64,26 @@ impl WindowHandle {
     pub fn is_open(&self) -> bool {
         self.state.is_alive.get()
     }
+
+    pub fn size(&self) -> WindowSize {
+        self.state.size()
+    }
+
+    pub fn resize(&self, new_size: Size) -> Result<()> {
+        let Some(hwnd) = self.hwnd.get() else { return Ok(()) };
+        let new_size = new_size.to_physical(self.state.scale_factor());
+        hwnd.resize_and_activate(new_size, self.state.current_dpi.get(), &self.state.user32)?;
+
+        if self.state.current_size.get() == new_size {
+            Ok(())
+        } else {
+            Err(Error::ResizeFailed)
+        }
+    }
+
+    pub fn suggest_scale_factor(&self, _scale_factor: f64) -> Result<()> {
+        todo!()
+    }
 }
 
 impl Drop for WindowHandle {
@@ -106,22 +125,19 @@ impl WindowImpl for BaseviewWindow {
         // Now we can get the actual dpi of the window.
         let dpi = window.get_dpi(&self.window_state.user32)?;
 
-        if dpi != window_state.current_dpi.get() {
-            window_state.current_dpi.set(dpi);
-
-            // If the user's requested initial size was in system-scaled logical pixels
-            if let WindowScalePolicy::SystemScaleFactor = self.window_state.scale_policy {
-                // We cannot create a window in "logical" pixels, and we can't DPI-scale to physical pixels because we
-                // have no way to know where the window will end up.
-                // So, at window creation, we assume a DPI=96, and if it ends up wrong, we resize the window
-                // to the actual logical size the user desired.
-                let new_size = self.initial_size.to_physical(dpi.scale_factor());
-
-                // Preemptively update so a synchronous WM_SIZE from SetWindowPos below
-                // doesn't also emit Resized.
-                window_state.current_size.set(new_size);
-                window.resize_and_activate(new_size, dpi, &window_state.user32)?;
-            }
+        if dpi != window_state.shared.current_dpi.get() {
+            window_state.shared.current_dpi.set(dpi);
+
+            // We cannot create a window in "logical" pixels, and we can't DPI-scale to physical pixels because we
+            // have no way to know where the window will end up.
+            // So, at window creation, we assume a DPI=96, and if it ends up wrong, we resize the window
+            // to the actual logical size the user desired.
+            let new_size = self.initial_size.to_physical(dpi.scale_factor());
+
+            // Preemptively update so a synchronous WM_SIZE from SetWindowPos below
+            // doesn't also emit Resized.
+            window_state.shared.current_size.set(new_size);
+            window.resize_and_activate(new_size, dpi, &window_state.user32)?;
         }
 
         let drop_target = ComObject::new(DropTarget::new(Rc::downgrade(window_state), window));
@@ -330,24 +346,26 @@ unsafe fn wnd_proc_inner(
             let height = ((lparam >> 16) & 0xFFFF) as u16 as u32;
 
             let new_size = PhysicalSize { width, height };
-            let current_size = window_state.current_size.get();
+            let current_size = window_state.shared.current_size.get();
 
             // Only send the event if anything changed
             if current_size == new_size {
                 return None;
             }
 
-            let previous = window_state.current_size.replace(new_size);
-            let new_size = WindowSize::from_physical(new_size, window_state.scale_factor());
+            let previous = window_state.shared.current_size.replace(new_size);
+            let new_size = WindowSize::from_physical(new_size, window_state.shared.scale_factor());
 
             let handler = window_state.handler.get()?;
             if let Err(e) = handler.resized(new_size) {
                 warn!("Window Handler failed to resize: {}", e);
-                window_state.current_size.set(previous);
+                window_state.shared.current_size.set(previous);
 
                 if let Err(e) = window_state.resize(previous.into()) {
                     warn!("Failed to resize back to previous window size: {}", e);
                 }
+
+                return Some(-1);
             }
 
             None
@@ -363,11 +381,11 @@ unsafe fn wnd_proc_inner(
 
             let new_size = suggested_rect.size();
 
-            let changed = window_state.current_size.get() != new_size
-                || window_state.current_dpi.get() != dpi;
+            let changed = window_state.shared.current_size.get() != new_size
+                || window_state.shared.current_dpi.get() != dpi;
 
-            window_state.current_dpi.replace(dpi);
-            let previous_size = window_state.current_size.replace(new_size);
+            window_state.shared.current_dpi.replace(dpi);
+            let previous_size = window_state.shared.current_size.replace(new_size);
 
             // Windows makes us resize the window manually. This however will not send a WM_SIZE event,
             // hence why we are notifying the window handler manually below.
@@ -379,7 +397,7 @@ unsafe fn wnd_proc_inner(
 
                 if let Err(e) = handler.resized(new_size) {
                     warn!("Window Handler failed to resize: {}", e);
-                    window_state.current_size.set(previous_size);
+                    window_state.shared.current_size.set(previous_size);
 
                     if let Err(e) = window_state.resize(previous_size.into()) {
                         warn!("Failed to resize back to previous window size: {}", e);
@@ -422,10 +440,7 @@ impl WindowHandle {
         let extended_user_32 = ExtendedUser32::load()?;
         let title = HSTRING::from(options.title);
 
-        let scaling_factor = match options.scale {
-            WindowScalePolicy::SystemScaleFactor => 1.0,
-            WindowScalePolicy::ScaleFactor(scale) => scale,
-        };
+        let scaling_factor = 1.0;
 
         let window_size = options.size.to_physical(scaling_factor);
 
@@ -435,20 +450,21 @@ impl WindowHandle {
             WindowStyle::embedded()
         };
         let dpi_ctx = DpiAwarenessContext::new(&extended_user_32)?;
-
-        let rect = dpi_ctx.client_area_to_nc_area(window_size.into(), style, Dpi::default())?;
+        let shared_state = WindowSharedState::new(window_size, extended_user_32.clone());
 
         let initializer = {
             let extended_user_32 = extended_user_32.clone();
+            let shared_state = shared_state.clone();
 
             move |hwnd: HWnd| {
                 let window_state =
-                    Rc::new(WindowState::new(hwnd, window_size, options.scale, extended_user_32));
+                    Rc::new(WindowState::new(hwnd, extended_user_32, shared_state.clone()));
 
                 BaseviewWindow {
                     window_state,
                     initial_size: options.size,
                     handler_builder: Cell::new(Some(build)),
+                    shared_state,
 
                     _drop_target: None.into(),
                     _keyboard_hook: None.into(),
@@ -460,6 +476,7 @@ impl WindowHandle {
         };
 
         let parent = options.parent.map(|p| p.handle);
+        let rect = dpi_ctx.client_area_to_nc_area(window_size.into(), style, Dpi::default())?;
 
         let window = create_window(&title, style, rect.size(), parent, &dpi_ctx, initializer)?;
 
@@ -472,7 +489,7 @@ impl WindowHandle {
 
         window.show_and_activate();
 
-        Ok(WindowHandle { hwnd: Some(window).into(), is_open: Rc::clone(&is_open) })
+        Ok(WindowHandle { hwnd: Some(window).into(), state: shared_state })
     }
 }
 

src/platform/win/window_state.rs

@@ -5,7 +5,7 @@ use crate::wrappers::win32::cursor::SystemCursor;
 use crate::wrappers::win32::h_instance::HInstance;
 use crate::wrappers::win32::window::HWnd;
 use crate::wrappers::win32::{Dpi, ExtendedUser32};
-use crate::{Event, EventStatus, MouseCursor, WindowHandler, WindowScalePolicy, WindowSize};
+use crate::{Event, EventStatus, MouseCursor, WindowHandler, WindowSize};
 use dpi::{PhysicalSize, Size};
 use raw_window_handle::{DisplayHandle, Win32WindowHandle};
 use std::cell::{Cell, OnceCell, Ref, RefCell};
@@ -23,28 +23,25 @@ pub(crate) struct WindowState {
     pub cursor_icon: Cell<MouseCursor>,
     // Initialized late so the `Window` can hold a reference to this `WindowState`
     pub handler: OnceCell<Box<dyn WindowHandler>>,
-    pub scale_policy: WindowScalePolicy,
 
     pub user32: ExtendedUser32,
+    pub shared: Rc<WindowSharedState>,
 
     #[cfg(feature = "opengl")]
     pub gl_context: OnceCell<super::gl::GlContext>,
 }
 
 impl WindowState {
-    pub fn new(
-        hwnd: HWnd, current_size: PhysicalSize<u32>, scale_policy: WindowScalePolicy,
-        user32: ExtendedUser32,
-    ) -> Self {
+    pub fn new(hwnd: HWnd, user32: ExtendedUser32, shared: Rc<WindowSharedState>) -> Self {
         Self {
             hwnd,
             keyboard_state: RefCell::new(KeyboardState::new()),
             mouse_button_counter: Cell::new(0),
             mouse_was_outside_window: true.into(),
             cursor_icon: Cell::new(MouseCursor::Default),
             handler: OnceCell::new(),
-            scale_policy,
             user32,
+            shared,
 
             #[cfg(feature = "opengl")]
             gl_context: OnceCell::new(),
@@ -68,15 +65,14 @@ impl WindowState {
         handler.on_event(event)
     }
 
+    /// Returns the current size of this window.
     pub fn size(&self) -> WindowSize {
-        WindowSize::from_physical(self.current_size.get(), self.scale_factor())
+        self.shared.size()
     }
 
+    /// Returns the current scale factor of this window.
     pub fn scale_factor(&self) -> f64 {
-        match self.scale_policy {
-            WindowScalePolicy::ScaleFactor(scale) => scale,
-            WindowScalePolicy::SystemScaleFactor => self.current_dpi.get().scale_factor(),
-        }
+        self.shared.scale_factor()
     }
 
     pub(crate) fn keyboard_state(&self) -> Ref<'_, KeyboardState> {
@@ -106,7 +102,7 @@ impl WindowState {
     pub fn resize(&self, size: Size) -> Result<(), super::Error> {
         // `self.window_info` will be modified in response to the `WM_SIZE` event that
         // follows the `SetWindowPos()` call
-        let dpi = self.current_dpi.get();
+        let dpi = self.shared.current_dpi.get();
         let new_size = size.to_physical(dpi.scale_factor());
 
         self.hwnd.resize_and_activate(new_size, dpi, &self.user32)?;
@@ -149,15 +145,26 @@ pub struct WindowSharedState {
     pub is_alive: Cell<bool>,
     pub current_size: Cell<PhysicalSize<u32>>,
     pub current_dpi: Cell<Dpi>, // None if in non-system scale policy
+
+    pub user32: ExtendedUser32,
 }
 
 impl WindowSharedState {
-    pub fn new(current_size: PhysicalSize<u32>) -> Rc<Self> {
+    pub fn new(current_size: PhysicalSize<u32>, user32: ExtendedUser32) -> Rc<Self> {
         Self {
             is_alive: true.into(),
             current_dpi: Dpi::default().into(),
             current_size: current_size.into(),
+            user32,
         }
         .into()
     }
+
+    pub fn size(&self) -> WindowSize {
+        WindowSize::from_physical(self.current_size.get(), self.scale_factor())
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.current_dpi.get().scale_factor()
+    }
 }

src/platform/x11/window_shared.rs

@@ -3,7 +3,7 @@ use crate::platform::x11::visual_info::WindowVisualConfig;
 use crate::platform::x11::window_thread::WindowThreadShared;
 use crate::platform::x11::xcb_window::XcbWindow;
 use crate::platform::*;
-use crate::{warn, MouseCursor, WindowHandler, WindowOpenOptions, WindowScalePolicy, WindowSize};
+use crate::{warn, MouseCursor, WindowHandler, WindowOpenOptions, WindowSize};
 use calloop::LoopSignal;
 use dpi::{PhysicalSize, Size};
 use raw_window_handle::{DisplayHandle, XlibWindowHandle};
@@ -40,8 +40,7 @@ impl ScalingFactor {
 
 impl From<Option<f64>> for ScalingFactor {
     fn from(value: Option<f64>) -> Self {
-        // FIXME
-        Self { system: None.into(), suggested: None.into() }
+        Self { system: value.into(), suggested: None.into() }
     }
 }
 
@@ -73,10 +72,7 @@ impl WindowInner {
         // Connect to the X server
         let xcb_connection = X11Connection::new()?;
 
-        let scaling = match options.scale {
-            WindowScalePolicy::SystemScaleFactor => xcb_connection.get_scaling(),
-            WindowScalePolicy::ScaleFactor(scale) => Some(scale),
-        };
+        let scaling = xcb_connection.get_scaling();
 
         let initial_scale_factor = scaling.unwrap_or(1.0);
         shared.set_scaling_factor(initial_scale_factor);

src/window_open_options.rs

@@ -4,16 +4,6 @@ use crate::platform::ParentWindowHandle;
 use dpi::{LogicalSize, Size};
 use raw_window_handle::HasWindowHandle;
 
-/// The dpi scaling policy of the window
-#[derive(Default, Debug, Clone, Copy, PartialEq)]
-pub enum WindowScalePolicy {
-    /// Use the system's dpi scale factor
-    #[default]
-    SystemScaleFactor,
-    /// Use the given dpi scale factor (e.g. `1.0` = 96 dpi)
-    ScaleFactor(f64),
-}
-
 /// The options for opening a new window
 #[derive(Debug, Clone, PartialEq)]
 pub struct WindowOpenOptions {
@@ -22,9 +12,6 @@ pub struct WindowOpenOptions {
     /// The size of the window, either in physical or logical coordinates
     pub size: Size,
 
-    /// The dpi scaling policy
-    pub scale: WindowScalePolicy,
-
     pub(crate) parent: Option<ParentWindowHandle>,
 
     /// If provided, then an OpenGL context will be created for this window. You'll be able to
@@ -53,12 +40,6 @@ impl WindowOpenOptions {
         self
     }
 
-    #[inline]
-    pub fn with_scale_policy(mut self, scale: WindowScalePolicy) -> Self {
-        self.scale = scale;
-        self
-    }
-
     #[inline]
     pub fn with_parent(mut self, parent: &impl HasWindowHandle) -> Self {
         let parent = match ParentWindowHandle::extract(parent) {
@@ -85,7 +66,6 @@ impl Default for WindowOpenOptions {
         Self {
             title: String::from("baseview window"),
             size: LogicalSize { width: 500.0, height: 400.0 }.into(),
-            scale: WindowScalePolicy::default(),
             parent: None,
             #[cfg(feature = "opengl")]
             gl_config: None,