X11: implement non-resizable window

Author: prokopyl

examples/plugin_clack/src/gui.rs

@@ -77,16 +77,19 @@ impl PluginGuiImpl for ExamplePluginMainThread<'_> {
     }
 
     fn can_resize(&mut self) -> bool {
-        true // Non-resizeable windows not supported yet
+        let Some(gui) = &self.gui else { return false };
+
+        gui.handle.is_resizable()
     }
 
     fn get_resize_hints(&mut self) -> Option<GuiResizeHints> {
+        let can_resize = self.can_resize();
+
         Some(GuiResizeHints {
             strategy: AspectRatioStrategy::Disregard, // Not supported
 
-            // Non-resizeable windows not supported yet
-            can_resize_vertically: true,
-            can_resize_horizontally: true,
+            can_resize_vertically: can_resize,
+            can_resize_horizontally: can_resize,
         })
     }
 

src/platform/x11/window_shared.rs

@@ -1,6 +1,7 @@
 use crate::platform::x11::event_loop::EventLoop;
 use crate::platform::x11::visual_info::WindowVisualConfig;
 use crate::platform::x11::window_thread::WindowThreadShared;
+use crate::platform::x11::xcb_connection::{get_size_hints, WmSizeHintsExt};
 use crate::platform::x11::xcb_window::XcbWindow;
 use crate::platform::*;
 use crate::{warn, MouseCursor, WindowHandler, WindowSettings, WindowSize};
@@ -10,6 +11,7 @@ use raw_window_handle::{DisplayHandle, XlibWindowHandle};
 use std::cell::Cell;
 use std::rc::Rc;
 use std::sync::Arc;
+use x11rb::properties::WmSizeHints;
 use x11rb::protocol::xproto::{ChangeWindowAttributesAux, ConnectionExt, InputFocus, Visualid};
 use x11rb::CURRENT_TIME;
 
@@ -49,6 +51,7 @@ pub(crate) struct WindowInner {
     pub(crate) scaling_factor: ScalingFactor,
 
     window_size: Cell<PhysicalSize<u16>>,
+    pub(crate) is_resizable: bool,
     mouse_cursor: Cell<MouseCursor>,
     pub(crate) visual_id: Visualid,
 
@@ -73,6 +76,8 @@ impl WindowInner {
 
         let physical_size = options.size.to_physical(initial_scale_factor);
 
+        let size_hints = get_size_hints(&options, initial_scale_factor);
+
         #[cfg(feature = "opengl")]
         let visual_info =
             WindowVisualConfig::find_best_visual_config_for_gl(&xcb_connection, options.gl_config)?;
@@ -93,6 +98,7 @@ impl WindowInner {
             xcb_window.set_title(&options.title)?,
             xcb_window.enable_wm_protocols()?,
             xcb_window.enable_dnd_protocols()?,
+            xcb_window.set_size_hints(size_hints)?,
         ];
 
         for cookie in cookies {
@@ -121,6 +127,7 @@ impl WindowInner {
                 system: scaling.into(),
                 suggested: options.fallback_scale_factor.into(),
             },
+            is_resizable: options.resizable,
             mouse_cursor: MouseCursor::default().into(),
             loop_signal: ev_loop.get_signal(),
 
@@ -186,6 +193,11 @@ impl WindowInner {
         let new_physical_size = size.to_physical(self.scaling_factor.get());
         self.xcb_window.resize(new_physical_size)?.check()?;
 
+        if !self.is_resizable {
+            let size_hints = WmSizeHints::new().with_fixed_size(new_physical_size.cast());
+            self.xcb_window.set_size_hints(size_hints)?.check()?;
+        }
+
         // This will trigger a `ConfigureNotify` event which will in turn change `self.window_info`
         // and notify the window handler about it
 
@@ -210,6 +222,10 @@ impl WindowInner {
         }
 
         self.xcb_window.resize(new_size.cast())?.check()?; // Will not call handler, as size is the same as above.
+        if !self.is_resizable {
+            let size_hints = WmSizeHints::new().with_fixed_size(new_size.cast());
+            self.xcb_window.set_size_hints(size_hints)?.check()?;
+        }
 
         // These come from the Host, no need to notify it about the new size
 

src/platform/x11/window_thread.rs

@@ -22,6 +22,7 @@ pub(crate) struct WindowThreadShared {
     size: AtomicU32,
     final_error: Mutex<Option<String>>,
     stopped_requested_from_host: AtomicBool,
+    is_resizable: AtomicBool,
 }
 
 impl WindowThreadShared {
@@ -32,12 +33,14 @@ impl WindowThreadShared {
             size: 0.into(),
             scaling_factor: 0.into(),
             stopped_requested_from_host: false.into(),
+            is_resizable: true.into(),
         }
     }
 
     fn init(&self, window: &WindowInner) {
         self.set_size(window.get_size());
         self.set_scaling_factor(window.scale_factor());
+        self.set_resizable(window.is_resizable);
     }
 
     pub fn get_size(&self) -> PhysicalSize<u16> {
@@ -53,6 +56,14 @@ impl WindowThreadShared {
         self.size.store(bytes, Ordering::Relaxed);
     }
 
+    pub fn set_resizable(&self, resizable: bool) {
+        self.is_resizable.store(resizable, Ordering::Relaxed);
+    }
+
+    pub fn is_resizable(&self) -> bool {
+        self.is_resizable.load(Ordering::Relaxed)
+    }
+
     pub fn get_scaling_factor(&self) -> f64 {
         f64::from_be_bytes(self.scaling_factor.load(Ordering::Relaxed).to_ne_bytes())
     }
@@ -201,6 +212,10 @@ impl WindowThreadHandle {
         !self.shared.stopped.load(Ordering::Relaxed)
     }
 
+    pub fn is_resizable(&self) -> bool {
+        self.shared.is_resizable()
+    }
+
     pub fn handle_main_thread_callback(&mut self) {
         loop {
             let Some(receiver) = self.callback_receiver.as_mut() else { return };

src/platform/x11/xcb_connection.rs

@@ -13,6 +13,8 @@ use crate::MouseCursor;
 
 mod get_property;
 pub use get_property::GetPropertyError;
+mod size_hints;
+pub use size_hints::{get_size_hints, WmSizeHintsExt};
 
 x11rb::atom_manager! {
     pub Atoms: AtomsCookie {

src/platform/x11/xcb_connection/size_hints.rs

@@ -0,0 +1,24 @@
+use crate::WindowSettings;
+use dpi::PhysicalSize;
+use x11rb::properties::WmSizeHints;
+
+pub fn get_size_hints(settings: &WindowSettings, scale_factor: f64) -> WmSizeHints {
+    let mut size_hints = WmSizeHints::default();
+
+    if !settings.resizable {
+        size_hints = size_hints.with_fixed_size(settings.size.to_physical(scale_factor));
+    }
+
+    size_hints
+}
+
+pub trait WmSizeHintsExt: Sized {
+    fn with_fixed_size(self, size: PhysicalSize<i32>) -> Self;
+}
+
+impl WmSizeHintsExt for WmSizeHints {
+    fn with_fixed_size(mut self, size: PhysicalSize<i32>) -> Self {
+        self.max_size = Some((size.width, size.height));
+        self
+    }
+}

src/platform/x11/xcb_window.rs

@@ -7,6 +7,7 @@ use std::rc::Rc;
 use x11rb::connection::Connection;
 use x11rb::cookie::VoidCookie;
 use x11rb::errors::{ConnectionError, ReplyOrIdError};
+use x11rb::properties::WmSizeHints;
 use x11rb::protocol::xproto::{
     AtomEnum, ConfigureWindowAux, ConnectionExt as _, CreateWindowAux, EventMask, PropMode,
     WindowClass,
@@ -119,6 +120,13 @@ impl XcbWindow {
         )?)
     }
 
+    pub fn set_size_hints(
+        &self, size_hints: WmSizeHints,
+    ) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
+        Ok(size_hints
+            .set_normal_hints(&self.connection.conn as &XCBConnection, self.window_id.get())?)
+    }
+
     #[inline]
     pub fn id(&self) -> NonZeroU32 {
         self.window_id

src/settings.rs

@@ -27,6 +27,9 @@ pub struct WindowSettings {
     /// If the `parent` field is already set, this does nothing and is ignored.
     pub wait_for_parent: bool,
 
+    /// Whether the window can be resized.
+    pub resizable: bool,
+
     /// A fallback scale factor, if Baseview couldn't get one from the platform.
     ///
     /// If the platform does already provide an accurate scaling factor, this doesn't do anything.
@@ -101,6 +104,13 @@ impl WindowSettings {
         self
     }
 
+    /// Sets [`resizable`](Self::resizable) to the given value.
+    #[inline]
+    pub fn with_resizable(mut self, resizable: bool) -> Self {
+        self.resizable = resizable;
+        self
+    }
+
     /// Sets [`gl_config`](Self::gl_config) to the given value.
     #[cfg(feature = "opengl")]
     #[inline]
@@ -118,6 +128,7 @@ impl Default for WindowSettings {
             parent: None,
             wait_for_parent: false,
             fallback_scale_factor: None,
+            resizable: true,
             #[cfg(feature = "opengl")]
             gl_config: None,
         }

src/window.rs

@@ -151,6 +151,14 @@ impl Window {
         self.inner.is_open()
     }
 
+    /// Returns `true` if the window can be resized by the user, `false` otherwise.
+    ///
+    /// This is set by the [`WindowSettings::resizable`] field.
+    #[inline]
+    pub fn is_resizable(&self) -> bool {
+        self.inner.is_resizable()
+    }
+
     /// Performs the work the window thread had scheduled for the main thread.
     ///
     /// This must be called back on the main thread, as a response to [`HostMainThreadCaller::call_main_thread`](host::HostMainThreadCaller::call_main_thread).