feat: add granular size constraints APIs (#10242)

Author: amrbashir

.changes/split-min-max-constraints-apis-runtime-js.md

@@ -0,0 +1,7 @@
+---
+"@tauri-apps/api": patch:feat
+---
+
+Add APIs to enable setting window size constraints separately:
+- Added `WindowSizeConstraints` interface in `window` and `webviewWindow` modules.
+- Added `Window.setSizeConstraints` and `WebviewWindow.setSizeConstraints`

.changes/split-min-max-constraints-apis-runtime.md

@@ -0,0 +1,8 @@
+---
+"tauri": patch:feat
+---
+
+Add APIs to enable setting window size constraints separately:
+- Added `WindowBuilder::inner_size_constraints` and `WebviewWindowBuilder::inner_size_constraints` which can be used for setting granular constraints.
+- Added `WindowSizeConstraints` struct
+- Added `Window::set_size_constraints` and `WebviewWindow::set_size_constraints`

.changes/split-min-max-constraints-apis.md

@@ -0,0 +1,6 @@
+---
+"tauri-runtime": "patch"
+"tauri-runtime-wry": "patch"
+---
+
+Add `inner_size_constraints` method on `WindowBuilder` trait and `set_size_constraints` method on `WindowDispatch` trait.

.changes/split-min-max-constraints.md

@@ -0,0 +1,6 @@
+---
+"tauri": "patch:bug"
+"@tauri-apps/api": "patch:bug"
+---
+
+Apply `minWidth`, `minHieght`, `maxWidth` and `maxHeight` constraints separately, which fixes a long standing bug where these constraints were never applied unless width and height were constrained together.

core/tauri-runtime-wry/src/lib.rs

@@ -20,7 +20,7 @@ use tauri_runtime::{
   webview::{DetachedWebview, DownloadEvent, PendingWebview, WebviewIpcHandler},
   window::{
     CursorIcon, DetachedWindow, DragDropEvent, PendingWindow, RawWindow, WebviewEvent,
-    WindowBuilder, WindowBuilderBase, WindowEvent, WindowId,
+    WindowBuilder, WindowBuilderBase, WindowEvent, WindowId, WindowSizeConstraints,
   },
   DeviceEventFilter, Error, EventLoopProxy, ExitRequestedEventAction, Icon, ProgressBarState,
   ProgressBarStatus, Result, RunEvent, Runtime, RuntimeHandle, RuntimeInitArgs, UserAttentionType,
@@ -43,8 +43,8 @@ use wry::WebViewBuilderExtWindows;
 use tao::{
   dpi::{
     LogicalPosition as TaoLogicalPosition, LogicalSize as TaoLogicalSize,
-    PhysicalPosition as TaoPhysicalPosition, PhysicalSize as TaoPhysicalSize,
-    Position as TaoPosition, Size as TaoSize,
+    LogicalUnit as ToaLogicalUnit, PhysicalPosition as TaoPhysicalPosition,
+    PhysicalSize as TaoPhysicalSize, Position as TaoPosition, Size as TaoSize,
   },
   event::{Event, StartCause, WindowEvent as TaoWindowEvent},
   event_loop::{
@@ -774,12 +774,22 @@ impl WindowBuilder for WindowBuilderWrapper {
         .minimizable(config.minimizable)
         .shadow(config.shadow);
 
-      if let (Some(min_width), Some(min_height)) = (config.min_width, config.min_height) {
-        window = window.min_inner_size(min_width, min_height);
+      let mut constraints = WindowSizeConstraints::default();
+
+      if let Some(min_width) = config.min_width {
+        constraints.min_width = Some(ToaLogicalUnit::new(min_width).into());
+      }
+      if let Some(min_height) = config.min_height {
+        constraints.min_height = Some(ToaLogicalUnit::new(min_height).into());
+      }
+      if let Some(max_width) = config.max_width {
+        constraints.max_width = Some(ToaLogicalUnit::new(max_width).into());
       }
-      if let (Some(max_width), Some(max_height)) = (config.max_width, config.max_height) {
-        window = window.max_inner_size(max_width, max_height);
+      if let Some(max_height) = config.max_height {
+        constraints.max_height = Some(ToaLogicalUnit::new(max_height).into());
       }
+      window = window.inner_size_constraints(constraints);
+
       if let (Some(x), Some(y)) = (config.x, config.y) {
         window = window.position(x, y);
       }
@@ -823,6 +833,16 @@ impl WindowBuilder for WindowBuilderWrapper {
     self
   }
 
+  fn inner_size_constraints(mut self, constraints: WindowSizeConstraints) -> Self {
+    self.inner.window.inner_size_constraints = tao::window::WindowSizeConstraints {
+      min_width: constraints.min_width,
+      min_height: constraints.min_height,
+      max_width: constraints.max_width,
+      max_height: constraints.max_height,
+    };
+    self
+  }
+
   fn resizable(mut self, resizable: bool) -> Self {
     self.inner = self.inner.with_resizable(resizable);
     self
@@ -1144,6 +1164,7 @@ pub enum WindowMessage {
   SetSize(Size),
   SetMinSize(Option<Size>),
   SetMaxSize(Option<Size>),
+  SetSizeConstraints(WindowSizeConstraints),
   SetPosition(Position),
   SetFullscreen(bool),
   SetFocus,
@@ -1850,6 +1871,16 @@ impl<T: UserEvent> WindowDispatch<T> for WryWindowDispatcher<T> {
     )
   }
 
+  fn set_size_constraints(&self, constraints: WindowSizeConstraints) -> Result<()> {
+    send_user_message(
+      &self.context,
+      Message::Window(
+        self.window_id,
+        WindowMessage::SetSizeConstraints(constraints),
+      ),
+    )
+  }
+
   fn set_position(&self, position: Position) -> Result<()> {
     send_user_message(
       &self.context,
@@ -2831,6 +2862,14 @@ fn handle_user_message<T: UserEvent>(
           WindowMessage::SetMaxSize(size) => {
             window.set_max_inner_size(size.map(|s| SizeWrapper::from(s).0));
           }
+          WindowMessage::SetSizeConstraints(constraints) => {
+            window.set_inner_size_constraints(tao::window::WindowSizeConstraints {
+              min_width: constraints.min_width,
+              min_height: constraints.min_height,
+              max_width: constraints.max_width,
+              max_height: constraints.max_height,
+            });
+          }
           WindowMessage::SetPosition(position) => {
             window.set_outer_position(PositionWrapper::from(position).0)
           }

core/tauri-runtime/src/lib.rs

@@ -26,7 +26,10 @@ pub mod window;
 
 use dpi::{PhysicalPosition, PhysicalSize, Position, Size};
 use monitor::Monitor;
-use window::{CursorIcon, DetachedWindow, PendingWindow, RawWindow, WebviewEvent, WindowEvent};
+use window::{
+  CursorIcon, DetachedWindow, PendingWindow, RawWindow, WebviewEvent, WindowEvent,
+  WindowSizeConstraints,
+};
 use window::{WindowBuilder, WindowId};
 
 use http::{
@@ -735,6 +738,9 @@ pub trait WindowDispatch<T: UserEvent>: Debug + Clone + Send + Sync + Sized + 's
   /// Updates the window max inner size.
   fn set_max_size(&self, size: Option<Size>) -> Result<()>;
 
+  /// Sets this window's minimum inner width.
+  fn set_size_constraints(&self, constraints: WindowSizeConstraints) -> Result<()>;
+
   /// Updates the window position.
   fn set_position(&self, position: Position) -> Result<()>;
 

core/tauri-runtime/src/window.rs

@@ -9,7 +9,8 @@ use crate::{
   Icon, Runtime, UserEvent, WindowDispatch,
 };
 
-use serde::{Deserialize, Deserializer};
+use dpi::PixelUnit;
+use serde::{Deserialize, Deserializer, Serialize};
 use tauri_utils::{config::WindowConfig, Theme};
 #[cfg(windows)]
 use windows::Win32::Foundation::HWND;
@@ -201,6 +202,28 @@ impl<'de> Deserialize<'de> for CursorIcon {
   }
 }
 
+/// Window size constraints
+#[derive(Clone, Copy, PartialEq, Debug, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WindowSizeConstraints {
+  /// The minimum width a window can be, If this is `None`, the window will have no minimum width.
+  ///
+  /// The default is `None`.
+  pub min_width: Option<PixelUnit>,
+  /// The minimum height a window can be, If this is `None`, the window will have no minimum height.
+  ///
+  /// The default is `None`.
+  pub min_height: Option<PixelUnit>,
+  /// The maximum width a window can be, If this is `None`, the window will have no maximum width.
+  ///
+  /// The default is `None`.
+  pub max_width: Option<PixelUnit>,
+  /// The maximum height a window can be, If this is `None`, the window will have no maximum height.
+  ///
+  /// The default is `None`.
+  pub max_height: Option<PixelUnit>,
+}
+
 /// Do **NOT** implement this trait except for use in a custom [`Runtime`]
 ///
 /// This trait is separate from [`WindowBuilder`] to prevent "accidental" implementation.
@@ -237,6 +260,10 @@ pub trait WindowBuilder: WindowBuilderBase {
   #[must_use]
   fn max_inner_size(self, max_width: f64, max_height: f64) -> Self;
 
+  /// Window inner size constraints.
+  #[must_use]
+  fn inner_size_constraints(self, constraints: WindowSizeConstraints) -> Self;
+
   /// Whether the window is resizable or not.
   /// When resizable is set to false, native window's maximize button is automatically disabled.
   #[must_use]

core/tauri/build.rs

@@ -92,6 +92,7 @@ const PLUGINS: &[(&str, &[(&str, bool)])] = &[
       ("set_content_protected", false),
       ("set_size", false),
       ("set_min_size", false),
+      ("set_size_constraints", false),
       ("set_max_size", false),
       ("set_position", false),
       ("set_fullscreen", false),

core/tauri/permissions/window/autogenerated/reference.md

@@ -1390,6 +1390,32 @@ Denies the set_size command without any pre-configured scope.
 <tr>
 <td>
 
+`window:allow-set-size-constraints`
+
+</td>
+<td>
+
+Enables the set_size_constraints command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`window:deny-set-size-constraints`
+
+</td>
+<td>
+
+Denies the set_size_constraints command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
 `window:allow-set-skip-taskbar`
 
 </td>