wip

Author: prokopyl

examples/open_parented/src/main.rs

@@ -5,6 +5,8 @@ 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>>,
@@ -56,6 +58,7 @@ impl WindowHandler for ParentWindowHandler {
 
         let child_size =
             PhysicalSize::new(new_size.physical.width / 2, new_size.physical.height / 2);
+        self.child_window.suggest_scale_factor(new_size.scale_factor)?;
         self.child_window.resize(child_size.into())?;
         Ok(())
     }

examples/plugin_clack/src/gui.rs

@@ -1,6 +1,6 @@
 use crate::window_handler::OpenWindowExample;
 use crate::ExamplePluginMainThread;
-use baseview::dpi::{LogicalSize, PhysicalSize, Size};
+use baseview::dpi::{PhysicalSize, Size};
 use baseview::gl::GlConfig;
 use baseview::{WindowHandle, WindowOpenOptions, WindowSize};
 use clack_extensions::gui::{

src/platform/win/window.rs

@@ -23,7 +23,7 @@ pub(crate) const BV_WINDOW_MUST_CLOSE: u32 = WM_USER + 1;
 use super::drop_target::DropTarget;
 use super::*;
 use crate::handler::WindowHandlerBuilder;
-use crate::platform::win::window_state::WindowState;
+use crate::platform::win::window_state::{WindowSharedState, WindowState};
 use crate::platform::Error;
 use crate::wrappers::win32::cursor::SystemCursor;
 use crate::wrappers::win32::window::*;
@@ -53,7 +53,7 @@ const WIN_FRAME_TIMER: NonZeroUsize = match NonZeroUsize::new(4242) {
 
 pub struct WindowHandle {
     hwnd: Cell<Option<HWnd>>,
-    is_open: Rc<Cell<bool>>,
+    state: Rc<WindowSharedState>,
 }
 
 impl WindowHandle {
@@ -63,7 +63,7 @@ impl WindowHandle {
     }
 
     pub fn is_open(&self) -> bool {
-        self.is_open.get()
+        self.state.is_alive.get()
     }
 }
 
@@ -75,31 +75,27 @@ impl Drop for WindowHandle {
     }
 }
 
-struct ParentHandle {
-    is_open: Rc<Cell<bool>>,
-}
-
-impl Drop for ParentHandle {
-    fn drop(&mut self) {
-        self.is_open.set(false);
-    }
-}
-
 pub struct BaseviewWindow {
     window_state: Rc<WindowState>,
+    shared_state: Rc<WindowSharedState>,
     initial_size: Size,
 
     handler_builder: Cell<Option<WindowHandlerBuilder>>,
 
     // Things not directly used, but kept so their Drop impl runs when the window is destroyed
-    _parent_handle: ParentHandle,
     _keyboard_hook: Cell<Option<hook::KeyboardHookHandle>>,
     _drop_target: Cell<Option<ComObject<DropTarget>>>,
 
     #[cfg(feature = "opengl")]
     pub gl_config: Option<crate::gl::GlConfig>,
 }
 
+impl Drop for BaseviewWindow {
+    fn drop(&mut self) {
+        self.shared_state.is_alive.set(false);
+    }
+}
+
 impl WindowImpl for BaseviewWindow {
     fn after_create(&self, window: HWnd) -> core::result::Result<(), Error> {
         let hwnd = window.as_raw();
@@ -442,10 +438,7 @@ impl WindowHandle {
 
         let rect = dpi_ctx.client_area_to_nc_area(window_size.into(), style, Dpi::default())?;
 
-        let is_open = Rc::new(Cell::new(true));
-
         let initializer = {
-            let parent_handle = ParentHandle { is_open: is_open.clone() };
             let extended_user_32 = extended_user_32.clone();
 
             move |hwnd: HWnd| {
@@ -457,7 +450,6 @@ impl WindowHandle {
                     initial_size: options.size,
                     handler_builder: Cell::new(Some(build)),
 
-                    _parent_handle: parent_handle,
                     _drop_target: None.into(),
                     _keyboard_hook: None.into(),
 

src/platform/win/window_state.rs

@@ -10,14 +10,13 @@ use dpi::{PhysicalSize, Size};
 use raw_window_handle::{DisplayHandle, Win32WindowHandle};
 use std::cell::{Cell, OnceCell, Ref, RefCell};
 use std::num::NonZeroIsize;
+use std::rc::Rc;
 use windows_sys::Win32::UI::WindowsAndMessaging::PostMessageW;
 
 /// All data associated with the window.
 pub(crate) struct WindowState {
     /// The HWND belonging to this window.
     pub hwnd: HWnd,
-    pub current_size: Cell<PhysicalSize<u32>>,
-    pub current_dpi: Cell<Dpi>, // None if in non-system scale policy
     pub keyboard_state: RefCell<KeyboardState>,
     pub mouse_button_counter: Cell<usize>,
     pub mouse_was_outside_window: Cell<bool>,
@@ -39,8 +38,6 @@ impl WindowState {
     ) -> Self {
         Self {
             hwnd,
-            current_dpi: Dpi::default().into(),
-            current_size: current_size.into(),
             keyboard_state: RefCell::new(KeyboardState::new()),
             mouse_button_counter: Cell::new(0),
             mouse_was_outside_window: true.into(),
@@ -127,7 +124,6 @@ impl WindowState {
 
     #[cfg(feature = "opengl")]
     pub fn gl_context(&self) -> Option<crate::gl::GlContext> {
-        use std::rc::Rc;
         Some(crate::gl::GlContext::new(Rc::clone(self.gl_context.get()?)))
     }
 
@@ -148,3 +144,20 @@ impl WindowState {
         PlatformHandle { hwnd }
     }
 }
+
+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
+}
+
+impl WindowSharedState {
+    pub fn new(current_size: PhysicalSize<u32>) -> Rc<Self> {
+        Self {
+            is_alive: true.into(),
+            current_dpi: Dpi::default().into(),
+            current_size: current_size.into(),
+        }
+        .into()
+    }
+}

src/platform/x11/event_loop.rs

@@ -137,21 +137,23 @@ impl EventLoop {
                 let scale_factor = self.window.scaling_factor.get();
                 let new_size = new_size.to_physical(scale_factor);
 
-                // Handle everything directly, so we can return a handler error immediately.
-                let previous = self.window.store_size(new_size);
-                self.window.xcb_window.resize(new_size.cast())?; // Will not call handler, as size is the same as above.
-
-                if let Err(e) =
-                    self.handler.resized(WindowSize::from_physical(new_size.cast(), scale_factor))
-                {
-                    warn!("Window Handler failed to resize: {}. Reverting to previous size", &e);
-                    self.window.store_size(previous);
-                    return Err(e.into());
-                }
+                self.window.resize_immediately(new_size, &*self.handler)?;
+
+                Ok(())
+            }
+            WindowThreadRequest::SuggestScaleFactor(scale) => {
+                // If the scaling factor is already provided by the system, do nothing
+                if !self.window.scaling_factor.suggest(scale) {
+                    return Ok(());
+                };
+
+                let current_logical_size = self.window.get_size().to_logical::<f64>(1.0);
+                let new_physical_size = current_logical_size.to_physical(scale);
+
+                self.window.resize_immediately(new_physical_size, &*self.handler)?;
 
                 Ok(())
             }
-            _ => todo!(),
         }
     }
 

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::{MouseCursor, WindowOpenOptions, WindowScalePolicy, WindowSize};
+use crate::{warn, MouseCursor, WindowHandler, WindowOpenOptions, WindowScalePolicy, WindowSize};
 use calloop::LoopSignal;
 use dpi::{PhysicalSize, Size};
 use raw_window_handle::{DisplayHandle, XlibWindowHandle};
@@ -13,14 +13,48 @@ use std::sync::Arc;
 use x11rb::protocol::xproto::{ChangeWindowAttributesAux, ConnectionExt, InputFocus, Visualid};
 use x11rb::CURRENT_TIME;
 
+pub struct ScalingFactor {
+    system: Cell<Option<f64>>,
+    suggested: Cell<Option<f64>>,
+}
+
+impl ScalingFactor {
+    pub fn get(&self) -> f64 {
+        if let Some(factor) = self.system.get() {
+            return factor;
+        };
+
+        if let Some(factor) = self.suggested.get() {
+            return factor;
+        }
+
+        1.0
+    }
+
+    pub fn suggest(&self, value: f64) -> bool {
+        self.suggested.set(Some(value));
+
+        self.system.get().is_none()
+    }
+}
+
+impl From<Option<f64>> for ScalingFactor {
+    fn from(value: Option<f64>) -> Self {
+        // FIXME
+        Self { system: None.into(), suggested: None.into() }
+    }
+}
+
 pub(crate) struct WindowInner {
     // GlContext should be dropped **before** XcbConnection is dropped
     #[cfg(feature = "opengl")]
     gl_context: Option<super::gl::GlContext>,
 
     pub(crate) xcb_window: XcbWindow,
     pub(crate) connection: Rc<X11Connection>,
-    pub(crate) scaling_factor: Cell<f64>,
+
+    pub(crate) scaling_factor: ScalingFactor,
+
     window_size: Cell<PhysicalSize<u16>>,
     mouse_cursor: Cell<MouseCursor>,
     pub(crate) visual_id: Visualid,
@@ -41,11 +75,13 @@ impl WindowInner {
 
         let scaling = match options.scale {
             WindowScalePolicy::SystemScaleFactor => xcb_connection.get_scaling(),
-            WindowScalePolicy::ScaleFactor(scale) => scale,
+            WindowScalePolicy::ScaleFactor(scale) => Some(scale),
         };
 
-        shared.set_scaling_factor(scaling);
-        let physical_size = options.size.to_physical(scaling);
+        let initial_scale_factor = scaling.unwrap_or(1.0);
+        shared.set_scaling_factor(initial_scale_factor);
+
+        let physical_size = options.size.to_physical(initial_scale_factor);
 
         #[cfg(feature = "opengl")]
         let visual_info =
@@ -164,6 +200,28 @@ impl WindowInner {
         Ok(())
     }
 
+    pub fn resize_immediately(
+        &self, new_size: PhysicalSize<u16>, handler: &dyn WindowHandler,
+    ) -> Result<()> {
+        let previous = self.store_size(new_size);
+
+        if previous == new_size {
+            return Ok(());
+        };
+
+        self.xcb_window.resize(new_size.cast())?; // Will not call handler, as size is the same as above.
+
+        if let Err(e) =
+            handler.resized(WindowSize::from_physical(new_size.cast(), self.scaling_factor.get()))
+        {
+            warn!("Window Handler failed to resize: {}. Reverting to previous size", &e);
+            self.store_size(previous);
+            return Err(e.into());
+        }
+
+        Ok(())
+    }
+
     pub fn window_handle(&self) -> Option<raw_window_handle::WindowHandle<'_>> {
         let mut handle = XlibWindowHandle::new(self.xcb_window.id().get() as _);
         handle.visual_id = self.visual_id.into();

src/platform/x11/xcb_connection.rs

@@ -69,12 +69,11 @@ impl X11Connection {
         })
     }
 
-    pub fn get_scaling(&self) -> f64 {
-        // If the WM didn't set any display scaling, assume a scaling factor of 1.0 (i.e. don't do any scaling)
+    pub fn get_scaling(&self) -> Option<f64> {
         if let Ok(Some(dpi)) = self.resources.get_value::<u32>("Xft.dpi", "") {
-            dpi as f64 / 96.0
+            Some(dpi as f64 / 96.0)
         } else {
-            1.0
+            None
         }
     }