Window: fit the screen the window reopens on; the header bar is inside on Wayland

Review of 1.0.1 found three gaps in the first-size fit:

- On X11 the window was fitted to the primary monitor, but the
  window-state plugin then moved it back to its saved place, which can be
  on a smaller screen (a docked laptop closed on its 1366x768 panel), so
  the composer sat under the panel again. The fit now reads the plugin's
  saved record and picks the monitor the plugin restores to, with the
  plugin's own rule (a corner of the saved rectangle on a monitor, the
  place before maximizing for a maximized window); without one, the
  primary monitor. A window left low or far right is then moved inside
  that screen's work area right after the plugin's move.
- On Wayland the smallest screen forced a maximized window on every
  screen, which the user could not undo (the plugin only ever maximizes).
  The window now fits every screen and opens maximized only when none of
  them holds the 520x640 minimum.
- GTK's header bar is inside the size the window asks for on Wayland
  (1.0.0's 1380x920 window measured 920 px with it on Plasma; Weston
  reports 1380x920 geometry with 873 px of content), so the 48 px title
  bar room was taken twice: 1229x643 on 1366x768 left about 596 px of
  content. The room now applies only on X11, where the window manager's
  frame is outside; Wayland gets 1229x691.

The Wayland or X11 display comes from GDK, as tao decides on its header
bar (the AppImage runs on X11). 16 window_size tests, including the docked
laptop, a 200% screen beside a large one, the 1.0.0 grown record and the
work-area move.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: ShadowfetchStudio

Cargo.lock

@@ -18,6 +18,7 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 shadowcode-core = { path = "../native/core" }
 anyhow = "1"
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = ["signal"] }
 tauri = { version = "2", features = [] }
@@ -31,6 +32,9 @@ tauri-plugin-window-state = "2"
 # a click on desktop); the same crate the plugin already uses.
 [target.'cfg(target_os = "linux")'.dependencies]
 notify-rust = "4"
+# Whether GTK opened a Wayland or an X11 display (the window's first size);
+# the same crate tao already uses.
+gdk = "0.18"
 
 [features]
 default = ["custom-protocol"]

src-tauri/Cargo.toml

@@ -419,8 +419,8 @@ fn run() -> Result<()> {
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_notification::init());
     if !isolated {
-        // Remembers where the window was and whether it was maximized, not its
-        // size (see `window_size::REMEMBERED`).
+        // Remembers whether the window was maximized or full screen and, on
+        // X11, where it was, but not its size (see `window_size::REMEMBERED`).
         builder = builder.plugin(window_size::state_plugin());
     }
     let preview_ports = PreviewPorts::default();
@@ -478,11 +478,14 @@ fn run() -> Result<()> {
                 .context("Window configuration missing")?
                 .clone();
             // A screen smaller than the configured window (1366x768) gets a
-            // window that fits it, title bar and panel included.
-            if let Some(screen) = window_size::opening_screen(app) {
-                window_size::fit_config(&mut config, screen);
+            // window that fits it, title bar and panel included: the screen
+            // the window-state plugin moves it back to on X11, every screen
+            // on Wayland.
+            let opening = window_size::opening_on(app, !isolated);
+            if let Some(opening) = &opening {
+                window_size::fit_config(&mut config, opening);
             }
-            tauri::WebviewWindowBuilder::from_config(app, &config)?
+            let window = tauri::WebviewWindowBuilder::from_config(app, &config)?
                 .data_directory(webview_data)
                 .on_navigation(move |url| {
                     // WebKitGTK asks for every frame, so this also admits the
@@ -497,6 +500,17 @@ fn run() -> Result<()> {
                             && url.port() == Some(5174))
                 })
                 .build()?;
+            // Building the window queued the plugin's move back to where it
+            // was (X11); this move follows it and keeps the fitted window
+            // inside that screen's work area.
+            let inside = opening
+                .filter(|_| !config.maximized)
+                .and_then(|opening| opening.inside_work_area((config.width, config.height)));
+            if let Some((x, y)) = inside {
+                if let (Ok(x), Ok(y)) = (i32::try_from(x), i32::try_from(y)) {
+                    let _ = window.set_position(tauri::PhysicalPosition::new(x, y));
+                }
+            }
             let handle = app.handle().clone();
             tauri::async_runtime::spawn(async move {
                 loop {