fix: child webview positioning use logical CSS coords and offscreen parking

src-tauri/src/browser/layout.rs

@@ -1,75 +1,61 @@
-use tauri::{AppHandle, LogicalPosition, LogicalSize, Manager, PhysicalPosition, PhysicalSize};
+use tauri::{AppHandle, LogicalPosition, LogicalSize, Manager};
 
 use super::tab_manager::{tab_label, ViewportLayout};
 use crate::state::AppState;
 
-/// Hidden position — far offscreen. WebView2 stays "visible" (avoids deferred init bug)
-/// but is not renderable. This is the correct pattern for WebView2 on Windows.
-const OFFSCREEN_X: i32 = -32000;
-const OFFSCREEN_Y: i32 = -32000;
+const OFFSCREEN_X: f64 = -32000.0;
+const OFFSCREEN_Y: f64 = -32000.0;
 
-/// Calculate child WebView bounds from measured React host rect.
-/// React sends getBoundingClientRect() values in CSS/logical pixels.
 pub fn bounds(layout: &ViewportLayout) -> (f64, f64, f64, f64) {
-    let x = layout.x.max(0.0);
-    let y = layout.y.max(0.0);
-    let w = layout.width.max(1.0);
-    let h = layout.height.max(1.0);
-    (x, y, w, h)
+    (
+        layout.x.max(0.0),
+        layout.y.max(0.0),
+        layout.width.max(1.0),
+        layout.height.max(1.0),
+    )
 }
 
-/// Show a tab webview at the specified layout position.
-/// Uses PhysicalPosition with scale factor for correct HiDPI positioning.
+/// Child webviews added with `window.add_child` are positioned in the parent
+/// window client-area logical coordinate space. DOM getBoundingClientRect()
+/// from the main webview also reports CSS/logical pixels relative to that same
+/// client area (because our main webview fills the undecorated window).
+///
+/// So: use LogicalPosition/LogicalSize directly. Do NOT multiply by DPI here.
+/// Passing PhysicalPosition can push the child webview out of the intended
+/// panel on scaled displays and was the main reason it appeared invisible.
 pub fn show_tab(app: &AppHandle, tab_id: &str, layout: &ViewportLayout) -> Result<(), String> {
     let label = tab_label(app, tab_id)?;
     let (x, y, w, h) = bounds(layout);
-
     if let Some(webview) = app.get_webview(&label) {
-        // Get scale factor for coordinate conversion
-        let scale = app.get_window("main")
-            .and_then(|win| win.scale_factor().ok())
-            .unwrap_or(1.0);
-
-        // Convert CSS logical pixels to physical pixels
-        let px = (x * scale) as i32;
-        let py = (y * scale) as i32;
-        let pw = (w * scale).max(1.0) as u32;
-        let ph = (h * scale).max(1.0) as u32;
-
-        // CRITICAL ORDER: position + size FIRST, then show
-        // This avoids the WebView2 "bounds before visible" requirement
-        webview.set_position(PhysicalPosition::new(px, py)).map_err(|e| e.to_string())?;
-        webview.set_size(PhysicalSize::new(pw, ph)).map_err(|e| e.to_string())?;
-
-        // show() is needed on first display after add_child
-        // Subsequent calls are safe (idempotent)
+        // Bounds first, then visible/focus. Idempotent and cross-platform.
+        webview.set_position(LogicalPosition::new(x, y)).map_err(|e| e.to_string())?;
+        webview.set_size(LogicalSize::new(w, h)).map_err(|e| e.to_string())?;
         let _ = webview.show();
         let _ = webview.set_focus();
     }
     Ok(())
 }
 
-/// Hide a tab webview by parking it offscreen.
-/// We do NOT call webview.hide() because WebView2's hide/show is unreliable.
-/// Instead we move it far offscreen and shrink to 1x1. The webview stays "alive"
-/// and continues processing JS (beneficial for maintaining session state).
+/// Park offscreen instead of relying on hide/show lifecycle. This keeps WebView2
+/// initialized and avoids stale rendering after panel close/open.
 pub fn hide_tab(app: &AppHandle, tab_id: &str) -> Result<(), String> {
     let label = tab_label(app, tab_id)?;
     if let Some(webview) = app.get_webview(&label) {
-        // Park offscreen — don't call hide()
-        webview.set_position(PhysicalPosition::new(OFFSCREEN_X, OFFSCREEN_Y)).map_err(|e| e.to_string())?;
-        webview.set_size(PhysicalSize::new(1u32, 1u32)).map_err(|e| e.to_string())?;
+        webview.set_position(LogicalPosition::new(OFFSCREEN_X, OFFSCREEN_Y)).map_err(|e| e.to_string())?;
+        webview.set_size(LogicalSize::new(1.0, 1.0)).map_err(|e| e.to_string())?;
+        // Do not call hide(); parking is more reliable with child WebView2.
     }
     Ok(())
 }
 
-/// Resize the active tab to match current layout.
 pub fn resize_active(app: &AppHandle, layout: &ViewportLayout) -> Result<(), String> {
     let active = {
         let state = app.state::<AppState>();
         let tabs = state.tabs.lock().map_err(|_| "lock")?;
         tabs.active.clone()
     };
-    if let Some(active_id) = active { show_tab(app, &active_id, layout)?; }
+    if let Some(active_id) = active {
+        show_tab(app, &active_id, layout)?;
+    }
     Ok(())
 }