feat(core): add an option for preventing window overflow

.changes/prevent-window-overflow.md

@@ -0,0 +1,9 @@
+---
+"tauri": "patch:feat"
+"tauri-utils": "patch:feat"
+"tauri-runtime": "patch:feat"
+"tauri-runtime-wry": "patch:feat"
+"@tauri-apps/api": "patch:feat"
+---
+
+Add `preventOverflow` config option to prevent the window from overflowing the monitor size on creation

crates/tauri-cli/config.schema.json

@@ -317,6 +317,17 @@
           ],
           "format": "double"
         },
+        "preventOverflow": {
+          "description": "Whether or not to prevent the window from overflowing the workarea\n\n ## Platform-specific\n\n - **Linux:** Prevent overflowing the monitor instead of workarea\n - **iOS / Android:** Unsupported.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PreventOverflowConfig"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "resizable": {
           "description": "Whether the window is resizable or not. When resizable is set to false, native window's maximize button is automatically disabled.",
           "default": true,
@@ -539,6 +550,46 @@
         }
       ]
     },
+    "PreventOverflowConfig": {
+      "description": "Prevent overflow with a margin",
+      "anyOf": [
+        {
+          "description": "Enable prevent overflow or not",
+          "type": "boolean"
+        },
+        {
+          "description": "Enable prevent overflow with a margin\n so that the window's size + this margin won't overflow the workarea",
+          "allOf": [
+            {
+              "$ref": "#/definitions/PreventOverflowMargin"
+            }
+          ]
+        }
+      ]
+    },
+    "PreventOverflowMargin": {
+      "description": "Enable prevent overflow with a margin\n so that the window's size + this margin won't overflow the workarea",
+      "type": "object",
+      "required": [
+        "height",
+        "width"
+      ],
+      "properties": {
+        "width": {
+          "description": "Horizontal margin in physical unit",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "height": {
+          "description": "Vertical margin in physical unit",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false
+    },
     "Theme": {
       "description": "System theme.",
       "oneOf": [

crates/tauri-cli/schema.json

@@ -301,6 +301,17 @@
           ],
           "format": "double"
         },
+        "preventOverflow": {
+          "description": "Whether or not to prevent window overflow",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PreventOverflowMarginConfig"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "resizable": {
           "description": "Whether the window is resizable or not. When resizable is set to false, native window's maximize button is automatically disabled.",
           "default": true,
@@ -488,6 +499,46 @@
         }
       ]
     },
+    "PreventOverflowMarginConfig": {
+      "description": "Prevent overflow with a margin",
+      "anyOf": [
+        {
+          "description": "Enable prevent overflow or not",
+          "type": "boolean"
+        },
+        {
+          "description": "Enable prevent overflow with a margin",
+          "allOf": [
+            {
+              "$ref": "#/definitions/PreventOverflowMargin"
+            }
+          ]
+        }
+      ]
+    },
+    "PreventOverflowMargin": {
+      "description": "Enable prevent overflow with a margin",
+      "type": "object",
+      "required": [
+        "height",
+        "width"
+      ],
+      "properties": {
+        "width": {
+          "description": "Horizontal margin in physical unit",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "height": {
+          "description": "Vertical margin in physical unit",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false
+    },
     "Theme": {
       "description": "System theme.",
       "oneOf": [

crates/tauri-cli/tauri.config.schema.json

@@ -301,6 +301,17 @@
           ],
           "format": "double"
         },
+        "preventOverflow": {
+          "description": "Whether or not to prevent window overflow",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PreventOverflowMarginConfig"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "resizable": {
           "description": "Whether the window is resizable or not. When resizable is set to false, native window's maximize button is automatically disabled.",
           "default": true,
@@ -488,6 +499,46 @@
         }
       ]
     },
+    "PreventOverflowMarginConfig": {
+      "description": "Prevent overflow with a margin",
+      "anyOf": [
+        {
+          "description": "Enable prevent overflow or not",
+          "type": "boolean"
+        },
+        {
+          "description": "Enable prevent overflow with a margin",
+          "allOf": [
+            {
+              "$ref": "#/definitions/PreventOverflowMargin"
+            }
+          ]
+        }
+      ]
+    },
+    "PreventOverflowMargin": {
+      "description": "Enable prevent overflow with a margin",
+      "type": "object",
+      "required": [
+        "height",
+        "width"
+      ],
+      "properties": {
+        "width": {
+          "description": "Horizontal margin in physical unit",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "height": {
+          "description": "Vertical margin in physical unit",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false
+    },
     "Theme": {
       "description": "System theme.",
       "oneOf": [

crates/tauri-runtime-wry/Cargo.toml

@@ -56,6 +56,7 @@ objc2-app-kit = { version = "0.2.2", features = [
   "NSResponder",
   "NSView",
   "NSWindow",
+  "NSScreen",
   "NSGraphics",
 ] }
 

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

@@ -15,6 +15,8 @@
 )]
 
 use http::Request;
+#[cfg(desktop)]
+use monitor::MonitorExt;
 use raw_window_handle::{DisplayHandle, HasDisplayHandle, HasWindowHandle};
 
 use tauri_runtime::{
@@ -66,7 +68,7 @@ use tao::{
 #[cfg(target_os = "macos")]
 use tauri_utils::TitleBarStyle;
 use tauri_utils::{
-  config::{Color, WindowConfig},
+  config::{Color, PreventOverflowConfig, WindowConfig},
   Theme,
 };
 use url::Url;
@@ -123,6 +125,7 @@ use std::{
 pub type WebviewId = u32;
 type IpcHandler = dyn Fn(Request<String>) + 'static;
 
+mod monitor;
 #[cfg(any(
   windows,
   target_os = "linux",
@@ -728,14 +731,17 @@ impl From<ProgressBarState> for ProgressBarStateWrapper {
 pub struct WindowBuilderWrapper {
   inner: TaoWindowBuilder,
   center: bool,
+  prevent_overflow: Option<Size>,
   #[cfg(target_os = "macos")]
   tabbing_identifier: Option<String>,
 }
 
 impl std::fmt::Debug for WindowBuilderWrapper {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     let mut s = f.debug_struct("WindowBuilderWrapper");
-    s.field("inner", &self.inner).field("center", &self.center);
+    s.field("inner", &self.inner)
+      .field("center", &self.center)
+      .field("prevent_overflow", &self.prevent_overflow);
     #[cfg(target_os = "macos")]
     {
       s.field("tabbing_identifier", &self.tabbing_identifier);
@@ -861,6 +867,15 @@ impl WindowBuilder for WindowBuilderWrapper {
       if let Some(window_classname) = &config.window_classname {
         window = window.window_classname(window_classname);
       }
+
+      if let Some(prevent_overflow) = &config.prevent_overflow {
+        window = match prevent_overflow {
+          PreventOverflowConfig::Enable(true) => window.prevent_overflow(),
+          PreventOverflowConfig::Margin(margin) => window
+            .prevent_overflow_with_margin(TaoPhysicalSize::new(margin.width, margin.height).into()),
+          _ => window,
+        };
+      }
     }
 
     window
@@ -907,6 +922,33 @@ impl WindowBuilder for WindowBuilderWrapper {
     self
   }
 
+  /// Prevent the window from overflowing the working area (e.g. monitor size - taskbar size) on creation
+  ///
+  /// ## Platform-specific
+  ///
+  /// - **Linux:** Prevent overflowing the monitor instead of workarea
+  /// - **iOS / Android:** Unsupported.
+  #[must_use]
+  fn prevent_overflow(mut self) -> Self {
+    self
+      .prevent_overflow
+      .replace(PhysicalSize::new(0, 0).into());
+    self
+  }
+
+  /// Prevent the window from overflowing the working area (e.g. monitor size - taskbar size)
+  /// on creation with a margin
+  ///
+  /// ## Platform-specific
+  ///
+  /// - **Linux:** Prevent overflowing the monitor instead of workarea
+  /// - **iOS / Android:** Unsupported.
+  #[must_use]
+  fn prevent_overflow_with_margin(mut self, margin: Size) -> Self {
+    self.prevent_overflow.replace(margin);
+    self
+  }
+
   fn resizable(mut self, resizable: bool) -> Self {
     self.inner = self.inner.with_resizable(resizable);
     self
@@ -3906,7 +3948,7 @@ fn create_window<T: UserEvent, F: Fn(RawWindow) + Send + 'static>(
   }
 
   #[cfg(desktop)]
-  if window_builder.center {
+  if window_builder.prevent_overflow.is_some() || window_builder.center {
     let monitor = if let Some(window_position) = &window_builder.inner.window.position {
       event_loop.available_monitors().find(|m| {
         let monitor_pos = m.position();
@@ -3923,39 +3965,65 @@ fn create_window<T: UserEvent, F: Fn(RawWindow) + Send + 'static>(
     } else {
       event_loop.primary_monitor()
     };
-
     if let Some(monitor) = monitor {
+      let scale_factor = monitor.scale_factor();
       let desired_size = window_builder
         .inner
         .window
         .inner_size
         .unwrap_or_else(|| TaoPhysicalSize::new(800, 600).into());
-      let scale_factor = monitor.scale_factor();
-      #[allow(unused_mut)]
-      let mut window_size = window_builder
+      let mut inner_size = window_builder
         .inner
         .window
         .inner_size_constraints
         .clamp(desired_size, scale_factor)
         .to_physical::<u32>(scale_factor);
+      let mut window_size = inner_size;
+      #[allow(unused_mut)]
+      // Left and right window shadow counts as part of the window on Windows
+      // We need to include it when calculating positions, but not size
+      let mut shadow_width = 0;
       #[cfg(windows)]
-      {
-        if window_builder.inner.window.decorations {
-          use windows::Win32::UI::WindowsAndMessaging::{AdjustWindowRect, WS_OVERLAPPEDWINDOW};
-          let mut rect = windows::Win32::Foundation::RECT::default();
-          let result = unsafe { AdjustWindowRect(&mut rect, WS_OVERLAPPEDWINDOW, false) };
-          if result.is_ok() {
-            window_size.width += (rect.right - rect.left) as u32;
-            // rect.bottom is made out of shadow, and we don't care about it
-            window_size.height += -rect.top as u32;
+      if window_builder.inner.window.decorations {
+        use windows::Win32::UI::WindowsAndMessaging::{AdjustWindowRect, WS_OVERLAPPEDWINDOW};
+        let mut rect = windows::Win32::Foundation::RECT::default();
+        let result = unsafe { AdjustWindowRect(&mut rect, WS_OVERLAPPEDWINDOW, false) };
+        if result.is_ok() {
+          shadow_width = (rect.right - rect.left) as u32;
+          // rect.bottom is made out of shadow, and we don't care about it
+          window_size.height += -rect.top as u32;
+        }
+      }
+
+      if let Some(margin) = window_builder.prevent_overflow {
+        let size = monitor.get_work_area_size();
+        let margin = margin.to_physical::<u32>(scale_factor);
+        let constraint = PhysicalSize::new(size.width - margin.width, size.height - margin.height);
+        if window_size.width > constraint.width || window_size.height > constraint.height {
+          if window_size.width > constraint.width {
+            inner_size.width = inner_size
+              .width
+              .saturating_sub(window_size.width - constraint.width);
+            window_size.width = constraint.width;
           }
+          if window_size.height > constraint.height {
+            inner_size.height = inner_size
+              .height
+              .saturating_sub(window_size.height - constraint.height);
+            window_size.height = constraint.height;
+          }
+          window_builder.inner.window.inner_size = Some(inner_size.into());
         }
       }
-      let position = window::calculate_window_center_position(window_size, monitor);
-      let logical_position = position.to_logical::<f64>(scale_factor);
-      window_builder = window_builder.position(logical_position.x, logical_position.y);
+
+      if window_builder.center {
+        window_size.width += shadow_width;
+        let position = window::calculate_window_center_position(window_size, monitor);
+        let logical_position = position.to_logical::<f64>(scale_factor);
+        window_builder = window_builder.position(logical_position.x, logical_position.y);
+      }
     }
-  }
+  };
 
   let window = window_builder.inner.build(event_loop).unwrap();