Windows & X11: Window::set_resizable

CHANGELOG.md

@@ -3,6 +3,7 @@
 - On X11, the `Moved` event is no longer sent when the window is resized without changing position.
 - `MouseCursor` and `CursorState` now implement `Default`.
 - `WindowBuilder::with_resizable` implemented for Windows, X11, and macOS.
+- `Window::set_resizable` implemented for MacOS, X11, and Windows.
 - On X11, if the monitor's width or height in millimeters is reported as 0, the DPI is now 1.0 instead of +inf.
 - On X11, the environment variable `WINIT_HIDPI_FACTOR` has been added for overriding DPI factor.
 - On X11, enabling transparency no longer causes the window contents to flicker when resizing.

examples/resizable.rs

@@ -0,0 +1,36 @@
+extern crate winit;
+
+fn main() {
+    let mut events_loop = winit::EventsLoop::new();
+
+    let window = winit::WindowBuilder::new()
+        .with_title("Hit space to toggle resizability.")
+        .with_dimensions(400, 200)
+        .with_resizable(false)
+        .build(&events_loop)
+        .unwrap();
+
+    let mut resizable = false;
+
+    events_loop.run_forever(|event| match event {
+        winit::Event::WindowEvent { event, .. } => match event {
+            winit::WindowEvent::CloseRequested => winit::ControlFlow::Break,
+            winit::WindowEvent::KeyboardInput {
+                input:
+                    winit::KeyboardInput {
+                        virtual_keycode: Some(winit::VirtualKeyCode::Space),
+                        state: winit::ElementState::Released,
+                        ..
+                    },
+                ..
+            } => {
+                resizable = !resizable;
+                println!("Resizable: {}", resizable);
+                window.set_resizable(resizable);
+                winit::ControlFlow::Continue
+            }
+            _ => winit::ControlFlow::Continue,
+        },
+        _ => winit::ControlFlow::Continue,
+    });
+}

src/lib.rs

@@ -422,7 +422,7 @@ pub struct WindowAttributes {
     /// The default is `None`.
     pub max_dimensions: Option<(u32, u32)>,
 
-    /// [Windows & X11 only] Whether the window is resizable or not
+    /// [Windows, MacOS, and X11 only] Whether the window is resizable or not
     ///
     /// The default is `true`.
     pub resizable: bool,

src/platform/linux/mod.rs

@@ -232,6 +232,15 @@ impl Window {
             &Window::Wayland(ref w) => w.set_max_dimensions(dimensions)
         }
     }
+
+    #[inline]
+    pub fn set_resizable(&self, resizable: bool) {
+        match self {
+            &Window::X(ref w) => w.set_resizable(resizable),
+            // &Window::Wayland(ref w) => w.set_resizable(resizable),
+            _ => {}
+        }
+    }
 
     #[inline]
     pub fn set_cursor(&self, cursor: MouseCursor) {

src/platform/linux/x11/window.rs

@@ -726,6 +726,26 @@ impl UnownedWindow {
         }.expect("Failed to call XSetWMNormalHints");
     }
 
+    pub fn set_resizable(&self, resizable: bool) {
+        unsafe {
+            self.update_normal_hints(|size_hints| {
+                if resizable {
+                    (*size_hints).flags &= !ffi::PMinSize;
+                    (*size_hints).flags &= !ffi::PMaxSize;
+                } else {
+                    (*size_hints).flags |= ffi::PMinSize;
+                    (*size_hints).flags |= ffi::PMaxSize;
+                    if let Some((width, height)) = self.get_inner_size() {
+                        (*size_hints).min_width = width as c_int;
+                        (*size_hints).min_height = height as c_int;
+                        (*size_hints).max_width = width as c_int;
+                        (*size_hints).max_height = height as c_int;
+                    }
+                }
+            })
+        }.expect("Failed to call XSetWMNormalHints");
+    }
+
     #[inline]
     pub fn get_xlib_display(&self) -> *mut c_void {
         self.xconn.display as _

src/platform/windows/window.rs

@@ -239,6 +239,33 @@ impl Window {
             }
         }
     }
+
+    /// See the docs in the crate root file.
+    #[inline]
+    pub fn set_resizable(&self, resizable: bool) {
+        if let Ok(mut window_state) = self.window_state.lock() {
+            if window_state.attributes.resizable == resizable {
+                return;
+            }
+            let window = self.window.clone();
+            let mut style = unsafe {
+                winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE)
+            };
+            if resizable {
+                style |= winuser::WS_SIZEBOX as i32;
+            } else {
+                style &= !winuser::WS_SIZEBOX as i32;
+            }
+            unsafe {
+                winuser::SetWindowLongW(
+                    window.0,
+                    winuser::GWL_STYLE,
+                    style as _,
+                );
+            };
+            window_state.attributes.resizable = resizable;
+        }
+    }
 
     // TODO: remove
     pub fn platform_display(&self) -> *mut ::libc::c_void {

src/window.rs

@@ -316,6 +316,16 @@ impl Window {
     pub fn set_max_dimensions(&self, dimensions: Option<(u32, u32)>) {
         self.window.set_max_dimensions(dimensions)
     }
+
+    /// Sets whether the window is resizable or not.
+    ///
+    /// ## Platform-specific
+    ///
+    /// This only has an effect on Windows, X11, and MacOS.
+    #[inline]
+    pub fn set_resizable(&self, resizable: bool) {
+        self.window.set_resizable(resizable)
+    }
 
     /// DEPRECATED. Gets the native platform specific display for this window.
     /// This is typically only required when integrating with