Unify behavior of resizable across platforms

This makes X11 and Wayland follow Windows and macOS, so the size of the
window could be set even though it has resizable attribute set to false.

Fixes #2242.

src/platform_impl/linux/wayland/window/mod.rs

@@ -220,6 +220,9 @@ impl Window {
             window_requests.clone(),
         );
 
+        // Set resizable state, so we can determine how to handle `Window::set_inner_size`.
+        window_handle.is_resizable.set(attributes.resizable);
+
         let mut winit_state = event_loop_window_target.state.borrow_mut();
 
         winit_state.window_map.insert(window_id, window_handle);

src/platform_impl/linux/wayland/window/shim.rs

@@ -154,6 +154,9 @@ pub struct WindowHandle {
     /// Current cursor icon.
     pub cursor_icon: Cell<CursorIcon>,
 
+    /// Whether the window is resizable.
+    pub is_resizable: Cell<bool>,
+
     /// Visible cursor or not.
     cursor_visible: Cell<bool>,
 
@@ -193,6 +196,7 @@ impl WindowHandle {
             size,
             pending_window_requests,
             cursor_icon: Cell::new(CursorIcon::Default),
+            is_resizable: Cell::new(true),
             confined: Cell::new(false),
             cursor_visible: Cell::new(true),
             pointers: Vec::new(),
@@ -443,7 +447,14 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                     window_update.redraw_requested = true;
                 }
                 WindowRequest::FrameSize(size) => {
-                    // Set new size.
+                    if !window_handle.is_resizable.get() {
+                        // On Wayland non-resizable window is achieved by setting both min and max
+                        // size of the window to the same value.
+                        let size = Some((size.width, size.height));
+                        window_handle.window.set_max_size(size);
+                        window_handle.window.set_min_size(size);
+                    }
+
                     window_handle.window.resize(size.width, size.height);
 
                     // We should refresh the frame after resize.

src/platform_impl/linux/x11/window.rs

@@ -1115,8 +1115,15 @@ impl UnownedWindow {
     #[inline]
     pub fn set_inner_size(&self, size: Size) {
         let scale_factor = self.scale_factor();
-        let (width, height) = size.to_physical::<u32>(scale_factor).into();
-        self.set_inner_size_physical(width, height);
+        let size = size.to_physical::<u32>(scale_factor).into();
+        if !self.shared_state.lock().is_resizable {
+            self.update_normal_hints(|normal_hints| {
+                normal_hints.set_min_size(Some(size));
+                normal_hints.set_max_size(Some(size));
+            })
+            .expect("Failed to call `XSetWMNormalHints`");
+        }
+        self.set_inner_size_physical(size.0, size.1);
     }
 
     fn update_normal_hints<F>(&self, callback: F) -> Result<(), XError>