The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(linux): restore window geometry after GTK mapping (#619)
fuqiuluo041e72106bde
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 4cfeb1ff0..aa413b6ff 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -8,6 +8,8 @@ mod commands;#[cfg(debug_assertions)]mod dev;mod events;+#[cfg(any(target_os = "linux", test))]+mod linux_window_state;mod logging;mod menu;mod remote_dev;@@ -68,16 +70,18 @@ pub fn run() {// Single instance first: a second launch focuses this one and opens its path argument.// Debug builds have a separate identifier per worktree.let app = app.plugin(tauri_plugin_single_instance::init(windows::on_second_instance));+ let app = app.plugin(tauri_plugin_opener::init()).plugin(tauri_plugin_dialog::init());+ #[cfg(target_os = "linux")]+ let app = app.plugin(linux_window_state::plugin());+ #[cfg(not(target_os = "linux"))]+ let app = app.plugin(+ tauri_plugin_window_state::Builder::default()+ .with_state_flags(window_state_flags())+ // One remembered geometry shared by every project's settings window.+ .map_label(|l| if windows::is_settings_window(l) { "settings" } else { l })+ .build(),+ );let app = app- .plugin(tauri_plugin_opener::init())- .plugin(tauri_plugin_dialog::init())- .plugin(- tauri_plugin_window_state::Builder::default()- .with_state_flags(window_state_flags())- // One remembered geometry shared by every project's settings window.- .map_label(|l| if windows::is_settings_window(l) { "settings" } else { l })- .build(),- )// Inert until an endpoint is configured (see `commands::window::app_check_update`)..plugin(tauri_plugin_updater::Builder::new().build());// E2E automation bridge (Tauri MCP), debug builds only, localhost only.@@ -152,6 +156,8 @@ pub fn run() {Ok(())}).on_window_event(|window, event| match event {+ #[cfg(target_os = "linux")]+ tauri::WindowEvent::CloseRequested { .. } => linux_window_state::save_before_close(window.app_handle()),tauri::WindowEvent::Focused(true) => {application_focus::changed(window.app_handle(), true);if let Some(w) = window.try_state::<WindowsState>() {@@ -204,6 +210,7 @@ pub fn run() {});}+#[cfg(not(target_os = "linux"))]fn window_state_flags() -> tauri_plugin_window_state::StateFlags {use tauri_plugin_window_state::StateFlags;StateFlags::SIZE | StateFlags::POSITION | StateFlags::MAXIMIZED | StateFlags::FULLSCREENdiff --git a/src-tauri/src/linux_window_state.rs b/src-tauri/src/linux_window_state.rsnew file mode 100644index 000000000..3d9816dce--- /dev/null+++ b/src-tauri/src/linux_window_state.rs@@ -0,0 +1,483 @@+//! Restore GTK geometry after mapping, using the scale of the window's actual output.++mod geometry;+#[cfg(target_os = "linux")]+use geometry::*;+use tauri::utils::config::WindowConfig;++fn build_hidden(config: &mut WindowConfig) -> bool {+ std::mem::replace(&mut config.visible, false)+}++#[cfg(target_os = "linux")]+mod runtime {+ use super::*;+ use parking_lot::Mutex;+ use std::collections::HashMap;+ use tauri::{AppHandle, Listener, Manager, Window, WindowEvent, plugin::TauriPlugin};++ const FILE: &str = tauri_plugin_window_state::DEFAULT_FILENAME;++ #[derive(Default)]+ enum Phase {+ #[default]+ Mapping,+ Size {+ target: Size,+ scale: f64,+ request: u64,+ },+ Mode,+ Tracking,+ }++ #[derive(Default)]+ struct Pending {+ limits: Limits,+ configured: bool,+ presented: bool,+ presentation_request: u64,+ saved: Geometry,+ normal: Size,+ history: ModeHistory,+ restore_position: bool,+ phase: Phase,+ mode_requested: bool,+ mode_request: u64,+ }++ #[derive(Default)]+ struct Cache {+ saved: HashMap<String, Geometry>,+ windows: HashMap<String, Pending>,+ next_request: u64,+ }++ struct Frame {+ size: Size,+ scale: f64,+ mode: Mode,+ position: Option<tauri::PhysicalPosition<i32>>,+ monitors: Vec<tauri::Monitor>,+ work_area: Option<Size>,+ visible: bool,+ }++ fn frame(window: &Window) -> Option<Frame> {+ let size = window.inner_size().ok()?;+ Some(Frame {+ visible: window.is_visible().ok()?,+ size: Size(size.width, size.height),+ scale: window.scale_factor().ok()?,+ mode: Mode {+ maximized: window.is_maximized().ok()?,+ fullscreen: window.is_fullscreen().ok()?,+ minimized: window.is_minimized().ok()?,+ },+ position: window.outer_position().ok(),+ monitors: window.available_monitors().unwrap_or_default(),+ work_area: window+ .current_monitor()+ .ok()+ .flatten()+ .map(|m| Size(m.work_area().size.width, m.work_area().size.height)),+ })+ }++ fn key(label: &str) -> &str {+ if crate::windows::is_settings_window(label) { "settings" } else { label }+ }++ pub fn prepare(app: &AppHandle, config: &mut WindowConfig) -> bool {+ let hint_monitor = app.primary_monitor().ok().flatten();+ let hint_scale = hint_monitor.as_ref().map_or(1.0, |m| m.scale_factor());+ let hint_area = hint_monitor.map(|m| Size(m.work_area().size.width, m.work_area().size.height));+ let cache = app.state::<Mutex<Cache>>();+ let mut cache = cache.lock();+ let saved = cache.saved.get(key(&config.label)).cloned().unwrap_or_else(|| Geometry {+ maximized: config.maximized,+ fullscreen: config.fullscreen,+ ..Default::default()+ });+ cache.next_request += 1;+ let presentation_request = cache.next_request;+ let pending = Pending {+ presentation_request,+ limits: Limits {+ min: (config.min_width.unwrap_or(1.0), config.min_height.unwrap_or(1.0)),+ max: (config.max_width, config.max_height),+ },+ normal: Size(saved.width, saved.height),+ saved,+ restore_position: true,+ ..Default::default()+ };+ if pending.saved.width > 0 && pending.saved.height > 0 {+ // This only reduces the first-frame jump; mapped geometry is authoritative.+ let size = restore_size(pending.normal, hint_scale, pending.limits.in_work_area(hint_area, hint_scale));+ config.width = f64::from(size.0) / hint_scale;+ config.height = f64::from(size.1) / hint_scale;+ }+ cache.windows.insert(config.label.clone(), pending);+ // Establish a normal window before asking GTK to maximize or fullscreen it.+ config.maximized = false;+ config.fullscreen = false;+ build_hidden(config)+ }++ fn sample(window: &Window, allow_restore: bool, accept_constrained_size: bool) {+ let Some(frame) = frame(window) else { return };+ if !frame.visible {+ return;+ }+ let cache = window.state::<Mutex<Cache>>();+ let mut cache = cache.lock();+ cache.next_request += 1;+ let request = cache.next_request;+ let Some(pending) = cache.windows.get_mut(window.label()) else { return };+ if !pending.presented && pending.saved.width == 0 {+ pending.normal = remember_size(pending.normal, frame.size, false, frame.mode);+ }+ if !pending.configured || !pending.presented {+ return;+ }+ if !allow_restore && !matches!(pending.phase, Phase::Tracking) {+ return;+ }+ let transition = if matches!(pending.phase, Phase::Tracking) {+ pending.history.observe(frame.mode, allow_restore)+ } else {+ NormalTransition::Stable+ };+ if transition == NormalTransition::WaitForResize {+ let normal = pending.normal;+ let saved = cache.saved.entry(key(window.label()).to_owned()).or_default();+ (saved.width, saved.height) = (normal.0, normal.1);+ saved.maximized = frame.mode.maximized;+ saved.fullscreen = frame.mode.fullscreen;+ return;+ }+ if transition == NormalTransition::Restore {+ // The compositor may have changed output/DPI while maximized or minimized.+ pending.saved.set_normal_size(pending.normal);+ pending.phase = Phase::Mapping;+ pending.mode_requested = false;+ }+ let mut fit_settings = false;+ let mut position = None;+ if matches!(pending.phase, Phase::Mapping) {+ if pending.restore_position {+ pending.restore_position = false;+ let saved = &pending.saved;+ let (x, y) = if saved.maximized { (saved.prev_x, saved.prev_y) } else { (saved.x, saved.y) };+ if frame.monitors.iter().any(|m| {+ let p = m.position();+ let s = m.size();+ i64::from(x) < i64::from(p.x) + i64::from(s.width)+ && i64::from(x) + i64::from(saved.width) > i64::from(p.x)+ && i64::from(y) < i64::from(p.y) + i64::from(s.height)+ && i64::from(y) + i64::from(saved.height) > i64::from(p.y)+ }) {+ position = Some(tauri::PhysicalPosition::new(x, y));+ }+ }+ if pending.saved.width > 0 && pending.saved.height > 0 {+ let target = restore_size(+ Size(pending.saved.width, pending.saved.height),+ frame.scale,+ pending.limits.in_work_area(frame.work_area, frame.scale),+ );+ pending.phase = Phase::Size { target, scale: frame.scale, request: 0 };+ } else {+ pending.normal = remember_size(pending.normal, frame.size, false, frame.mode);+ pending.phase = Phase::Mode;+ }+ }+ if let Phase::Size { target, scale, request: sent } = pending.phase {+ if frame.size != target && !accept_constrained_size {+ if sent != 0 && scale == frame.scale {+ return;+ }+ // Re-evaluate after output scale changes, rather than reusing monitor 0's scale.+ let target = restore_size(+ Size(pending.saved.width, pending.saved.height),+ frame.scale,+ pending.limits.in_work_area(frame.work_area, frame.scale),+ );+ pending.phase = Phase::Size { target, scale: frame.scale, request };+ drop(cache);+ if let Some(position) = position {+ let _ = window.set_position(position);+ }+ if let Err(error) = window.set_size(tauri::PhysicalSize::new(target.0, target.1)) {+ tracing::warn!("cannot restore Linux window size: {error}");+ }+ settle_constrained_size(window, request);+ return;+ }+ if scale != frame.scale && !accept_constrained_size {+ pending.phase = Phase::Mapping;+ drop(cache);+ sample(window, true, false);+ return;+ }+ pending.normal = remember_size(pending.normal, frame.size, false, frame.mode);+ pending.phase = Phase::Mode;+ }+ if matches!(pending.phase, Phase::Mode) {+ let (maximize, fullscreen) = (pending.saved.maximized, pending.saved.fullscreen);+ let reached = if fullscreen { frame.mode.fullscreen } else { !maximize || frame.mode.maximized };+ let action = mode_action(reached, pending.mode_requested, accept_constrained_size);+ if action == ModeAction::Wait {+ return;+ }+ if action == ModeAction::Request {+ pending.mode_requested = true;+ pending.mode_request = request;+ let mut snapshot = pending.saved.clone();+ (snapshot.width, snapshot.height) = (pending.normal.0, pending.normal.1);+ cache.saved.insert(key(window.label()).to_owned(), snapshot);+ drop(cache);+ if let Some(position) = position {+ let _ = window.set_position(position);+ }+ if maximize {+ let _ = window.maximize();+ }+ if fullscreen {+ let _ = window.set_fullscreen(true);+ }+ settle_constrained_size(window, request);+ return;+ }+ pending.phase = Phase::Tracking;+ fit_settings = crate::windows::is_settings_window(window.label());+ }+ pending.history = ModeHistory(frame.mode);+ pending.normal = remember_size(pending.normal, frame.size, false, frame.mode);+ let normal = pending.normal;+ let saved = cache.saved.entry(key(window.label()).to_owned()).or_default();+ (saved.width, saved.height) = (normal.0, normal.1);+ saved.maximized = frame.mode.maximized;+ saved.fullscreen = frame.mode.fullscreen;+ if frame.mode.normal()+ && let Some(pos) = frame.position+ {+ (saved.x, saved.y, saved.prev_x, saved.prev_y) = (pos.x, pos.y, pos.x, pos.y);+ }+ drop(cache);+ if let Some(position) = position {+ let _ = window.set_position(position);+ }+ if fit_settings {+ let app = window.app_handle().clone();+ let label = window.label().to_owned();+ let _ = window.run_on_main_thread(move || {+ if let Some(parent) = crate::windows::settings_parent(&label).and_then(|p| app.get_webview_window(p))+ && let Some(settings) = app.get_webview_window(&label)+ && let Err(error) = crate::windows::place_settings_window(&settings, &parent)+ {+ tracing::warn!("cannot fit restored settings window: {error}");+ }+ });+ }+ }++ fn settle_constrained_size(window: &Window, request: u64) {+ let window = window.clone();+ tauri::async_runtime::spawn(async move {+ tokio::time::sleep(std::time::Duration::from_secs(5)).await;+ let cloned = window.clone();+ let _ = window.run_on_main_thread(move || {+ let waiting = cloned.state::<Mutex<Cache>>().lock().windows.get(cloned.label()).is_some_and(|p| {+ matches!(p.phase, Phase::Size { request: current, .. } if current == request)+ || matches!(p.phase, Phase::Mode) && p.mode_request == request+ });+ if waiting {+ // Window-manager constraints may reject a size without producing an exact match.+ sample(&cloned, true, true);+ }+ });+ });+ }++ pub fn normal_size_requested(app: &AppHandle, label: &str, size: tauri::PhysicalSize<u32>) {+ let cache = app.state::<Mutex<Cache>>();+ let mut cache = cache.lock();+ cache.next_request += 1;+ let request = cache.next_request;+ if let Some(pending) = cache.windows.get_mut(label) {+ pending.normal = Size(size.width, size.height);+ pending.saved.set_normal_size(pending.normal);+ pending.mode_requested = false;+ pending.presented = false;+ pending.presentation_request = request;+ pending.phase = Phase::Mapping;+ }+ let saved = cache.saved.entry(key(label).to_owned()).or_default();+ saved.set_normal_size(Size(size.width, size.height));+ drop(cache);+ if let Some(webview) = app.get_webview_window(label) {+ request_presentation(webview.as_ref(), request);+ }+ }++ fn request_presentation(webview: &tauri::Webview, request: u64) {+ // A configure precedes output-enter. A second animation frame follows the+ // first paint, allowing GTK to learn the scale of the assigned output.+ let script = r#"+(() => {+ const state = window.__OPENIDEA_WINDOW_GEOMETRY__ ??= { request: 0, scheduled: false };+ state.request = __REQUEST_ID__;+ state.ready ??= () => {+ if (document.hidden || state.scheduled) return;+ const request = state.request;+ state.scheduled = true;+ requestAnimationFrame(() => requestAnimationFrame(() => {+ state.scheduled = false;+ if (document.hidden) return;+ const api = window.__TAURI_INTERNALS__;+ const label = api?.metadata?.currentWindow?.label;+ if (label) api.invoke('plugin:event|emit', {+ event: 'openidea://window-state-presented', payload: { label, request }+ });+ if (request !== state.request) state.ready();+ }));+ };+ if (!state.listening) {+ state.listening = true;+ document.addEventListener('visibilitychange', state.ready);+ }+ state.ready();+})();+"#+ .replace("__REQUEST_ID__", &request.to_string());+ let _ = webview.eval(script);+ }++ pub fn save_before_close(app: &AppHandle) {+ for window in app.webview_windows().values() {+ sample(&window.as_ref().window(), false, false);+ }+ persist(app);+ }++ fn persist(app: &AppHandle) {+ let write = || -> Result<(), Box<dyn std::error::Error>> {+ let dir = app.path().app_config_dir()?;+ std::fs::create_dir_all(&dir)?;+ let cache = app.state::<Mutex<Cache>>();+ let data = serde_json::to_vec_pretty(&cache.lock().saved)?;+ let temporary = dir.join(format!("{FILE}.tmp"));+ std::fs::write(&temporary, data)?;+ std::fs::rename(temporary, dir.join(FILE))?;+ Ok(())+ };+ if let Err(error) = write() {+ tracing::warn!("cannot save Linux window state: {error}");+ }+ }++ pub fn plugin() -> TauriPlugin<tauri::Wry> {+ tauri::plugin::Builder::new("linux-window-state")+ .setup(|app, _| {+ let saved = app+ .path()+ .app_config_dir()+ .ok()+ .and_then(|dir| std::fs::read(dir.join(FILE)).ok())+ .and_then(|data| serde_json::from_slice(&data).ok())+ .unwrap_or_default();+ app.manage(Mutex::new(Cache { saved, ..Default::default() }));+ let handle = app.clone();+ app.listen("openidea://window-state-presented", move |event| {+ #[derive(serde::Deserialize)]+ struct Presented {+ label: String,+ request: u64,+ }+ let Ok(presented) = serde_json::from_str::<Presented>(event.payload()) else { return };+ let Some(webview) = handle.get_webview_window(&presented.label) else { return };+ let window = webview.as_ref().window();+ let cloned = window.clone();+ let _ = window.run_on_main_thread(move || {+ if !cloned.is_visible().unwrap_or(false) {+ return;+ }+ if let Some(pending) = cloned.state::<Mutex<Cache>>().lock().windows.get_mut(cloned.label()) {+ if pending.presentation_request != presented.request {+ return;+ }+ pending.presented = true;+ }+ sample(&cloned, true, false);+ });+ });+ Ok(())+ })+ .on_page_load(|webview, payload| {+ if payload.event() == tauri::webview::PageLoadEvent::Finished {+ let request = webview+ .state::<Mutex<Cache>>()+ .lock()+ .windows+ .get(webview.window().label())+ .map(|p| p.presentation_request);+ if let Some(request) = request {+ request_presentation(webview, request);+ }+ }+ })+ .on_window_ready(|window| {+ let cloned = window.clone();+ window.on_window_event(move |event| match event {+ WindowEvent::Resized(_) => {+ if let Some(pending) = cloned.state::<Mutex<Cache>>().lock().windows.get_mut(cloned.label()) {+ pending.configured = true;+ }+ let request = cloned+ .state::<Mutex<Cache>>()+ .lock()+ .windows+ .get(cloned.label())+ .filter(|p| !p.presented)+ .map(|p| p.presentation_request);+ if let Some(request) = request+ && let Some(webview) = cloned.app_handle().get_webview_window(cloned.label())+ {+ request_presentation(webview.as_ref(), request);+ }+ sample(&cloned, true, false);+ }+ WindowEvent::Moved(_) => sample(&cloned, false, false),+ WindowEvent::Destroyed => {+ cloned.state::<Mutex<Cache>>().lock().windows.remove(cloned.label());+ }+ _ => {}+ });+ })+ .on_event(|app, event| {+ if let tauri::RunEvent::Exit = event {+ persist(app);+ }+ })+ .build()+ }+}++#[cfg(target_os = "linux")]+pub use runtime::{normal_size_requested, plugin, prepare, save_before_close};++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn hidden_creation_preserves_geometry() {+ let mut config = WindowConfig { width: 1201.0, height: 801.0, ..Default::default() };+ assert!(build_hidden(&mut config));+ assert!(!config.visible);+ assert_eq!((config.width, config.height), (1201.0, 801.0));+ assert!(!build_hidden(&mut config));+ }+}diff --git a/src-tauri/src/linux_window_state/geometry.rs b/src-tauri/src/linux_window_state/geometry.rsnew file mode 100644index 000000000..4bd747b4f--- /dev/null+++ b/src-tauri/src/linux_window_state/geometry.rs@@ -0,0 +1,237 @@+use serde::{Deserialize, Serialize};++#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub(super) struct Size(pub(super) u32, pub(super) u32);++#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub(super) struct Mode {+ pub(super) maximized: bool,+ pub(super) fullscreen: bool,+ pub(super) minimized: bool,+}++impl Mode {+ pub(super) fn normal(self) -> bool {+ !self.maximized && !self.fullscreen && !self.minimized+ }+}++#[derive(Clone, Copy, Debug, Default)]+pub(super) struct ModeHistory(pub(super) Mode);++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(super) enum NormalTransition {+ Stable,+ WaitForResize,+ Restore,+}++impl ModeHistory {+ pub(super) fn observe(&mut self, current: Mode, can_restore: bool) -> NormalTransition {+ let returned = !self.0.normal() && current.normal();+ if returned && !can_restore {+ return NormalTransition::WaitForResize;+ }+ self.0 = current;+ if returned { NormalTransition::Restore } else { NormalTransition::Stable }+ }+}++#[derive(Clone, Copy, Debug, Default)]+pub(super) struct Limits {+ pub(super) min: (f64, f64),+ pub(super) max: (Option<f64>, Option<f64>),+}++impl Limits {+ pub(super) fn in_work_area(self, area: Option<Size>, scale: f64) -> Self {+ let Some(Size(width, height)) = area.filter(|s| s.0 > 0 && s.1 > 0) else { return self };+ Self {+ max: (+ Some(self.max.0.unwrap_or(f64::INFINITY).min((f64::from(width) / scale).floor())),+ Some(self.max.1.unwrap_or(f64::INFINITY).min((f64::from(height) / scale).floor())),+ ),+ ..self+ }+ }+}++pub(super) fn restore_size(saved: Size, scale: f64, limits: Limits) -> Size {+ let dimension = |pixels: u32, min: f64, max: Option<f64>| {+ let logical = (f64::from(pixels) / scale).max(min).max(1.0);+ // gtk_window_resize takes integer logical dimensions.+ (logical.min(max.unwrap_or(f64::INFINITY).max(min)).round() * scale).round() as u32+ };+ Size(dimension(saved.0, limits.min.0, limits.max.0), dimension(saved.1, limits.min.1, limits.max.1))+}++pub(super) fn remember_size(previous: Size, current: Size, restoring: bool, mode: Mode) -> Size {+ if restoring || !mode.normal() || current.0 == 0 || current.1 == 0 { previous } else { current }+}++#[derive(Debug, PartialEq, Eq)]+pub(super) enum ModeAction {+ Request,+ Wait,+ Track,+}++pub(super) fn mode_action(reached: bool, requested: bool, timed_out: bool) -> ModeAction {+ if reached {+ ModeAction::Track+ } else if !requested {+ ModeAction::Request+ } else if timed_out {+ ModeAction::Track+ } else {+ ModeAction::Wait+ }+}++#[derive(Clone, Debug, Deserialize, Serialize)]+#[serde(default)]+pub(super) struct Geometry {+ pub(super) width: u32,+ pub(super) height: u32,+ pub(super) x: i32,+ pub(super) y: i32,+ pub(super) prev_x: i32,+ pub(super) prev_y: i32,+ pub(super) maximized: bool,+ pub(super) fullscreen: bool,+ pub(super) visible: bool,+ pub(super) decorated: bool,+}++impl Geometry {+ pub(super) fn set_normal_size(&mut self, size: Size) {+ (self.width, self.height) = (size.0, size.1);+ self.maximized = false;+ self.fullscreen = false;+ }+}++impl Default for Geometry {+ fn default() -> Self {+ Self {+ width: 0,+ height: 0,+ x: 0,+ y: 0,+ prev_x: 0,+ prev_y: 0,+ maximized: false,+ fullscreen: false,+ visible: true,+ decorated: true,+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn constrained_size_does_not_skip_the_first_mode_request() {+ assert_eq!(mode_action(false, false, true), ModeAction::Request);+ assert_eq!(mode_action(false, false, false), ModeAction::Request);+ assert_eq!(mode_action(false, true, false), ModeAction::Wait);+ assert_eq!(mode_action(false, true, true), ModeAction::Track);+ assert_eq!(mode_action(true, false, false), ModeAction::Track);+ }++ #[test]+ fn physical_sizes_use_the_actual_output_scale() {+ for scale in [1.0, 2.0] {+ assert_eq!(restore_size(Size(2468, 1356), scale, Limits::default()), Size(2468, 1356));+ }+ // Saved at scale 1, mapped on scale 2: keep physical pixels, not twice that size.+ assert_eq!(restore_size(Size(1234, 678), 2.0, Limits::default()), Size(1234, 678));+ }++ #[test]+ fn gtk_limits_and_integer_logical_dimensions_are_applied_once() {+ let limits = Limits { min: (800.0, 500.0), max: (Some(1600.0), Some(1000.0)) };+ assert_eq!(restore_size(Size(1201, 801), 1.0, limits), Size(1201, 801));+ assert_eq!(restore_size(Size(1201, 801), 2.0, limits), Size(1600, 1000));+ assert_eq!(restore_size(Size(2001, 1401), 2.0, limits), Size(2002, 1402));+ assert_eq!(restore_size(Size(9000, 6000), 2.0, limits), Size(3200, 2000));+ }++ #[test]+ fn damaged_sizes_are_bounded_in_the_actual_outputs_units() {+ let limits = Limits { min: (800.0, 500.0), ..Default::default() };+ for scale in [1.0, 2.0] {+ let bounded = limits.in_work_area(Some(Size(3840, 2160)), scale);+ assert_eq!(restore_size(Size(45068, 30000), scale, bounded), Size(3840, 2160));+ assert_eq!(restore_size(Size(2468, 1356), scale, bounded), Size(2468, 1356));+ }+ }++ #[test]+ fn restoration_and_non_normal_events_preserve_the_normal_size() {+ let normal = Size(1234, 678);+ for current in [Size(2468, 1356), Size(2648, 1602), Size(5476, 3204)] {+ assert_eq!(remember_size(normal, current, true, Mode::default()), normal);+ for mode in [+ Mode { maximized: true, ..Default::default() },+ Mode { fullscreen: true, ..Default::default() },+ Mode { minimized: true, ..Default::default() },+ ] {+ assert_eq!(remember_size(normal, current, false, mode), normal);+ }+ }+ assert_eq!(remember_size(normal, Size(1201, 801), false, Mode::default()), Size(1201, 801));+ assert_eq!(remember_size(normal, Size(0, 678), false, Mode::default()), normal);+ }++ #[test]+ fn a_mixed_dpi_maximized_launch_does_not_compound() {+ let mut saved = Size(2468, 1356);+ for _ in 0..3 {+ saved = remember_size(saved, Size(saved.0 * 2, saved.1 * 2), true, Mode::default());+ let restored = restore_size(saved, 2.0, Limits::default());+ saved = remember_size(saved, restored, false, Mode::default());+ saved = remember_size(saved, Size(3840, 2160), false, Mode { maximized: true, ..Default::default() });+ assert_eq!(saved, Size(2468, 1356));+ }+ }++ #[test]+ fn moved_does_not_consume_the_unmaximize_resize() {+ for mode in [+ Mode { maximized: true, ..Default::default() },+ Mode { fullscreen: true, ..Default::default() },+ Mode { minimized: true, ..Default::default() },+ ] {+ let mut history = ModeHistory(mode);+ assert_eq!(history.observe(Mode::default(), false), NormalTransition::WaitForResize);+ assert_eq!(history.0, mode);+ assert_eq!(history.observe(Mode::default(), true), NormalTransition::Restore);+ assert_eq!(history.observe(Mode::default(), true), NormalTransition::Stable);+ }+ }++ #[test]+ fn an_explicit_normal_frame_overrides_old_window_modes() {+ let mut saved = Geometry { maximized: true, fullscreen: true, x: 123, y: 456, ..Default::default() };+ saved.set_normal_size(Size(1100, 700));+ assert_eq!((saved.width, saved.height), (1100, 700));+ assert!(!saved.maximized && !saved.fullscreen);+ assert_eq!((saved.x, saved.y), (123, 456));+ }++ #[test]+ fn state_files_remain_compatible_and_keep_closed_windows() {+ let saved: std::collections::HashMap<String, Geometry> = serde_json::from_str(+ r#"{"main":{"width":1234,"height":678,"maximized":true},"settings":{"width":1001,"height":701}}"#,+ )+ .unwrap();+ let copy: std::collections::HashMap<String, Geometry> =+ serde_json::from_value(serde_json::to_value(&saved).unwrap()).unwrap();+ assert_eq!(copy["settings"].height, 701);+ assert!(copy["main"].maximized);+ assert_eq!(copy["main"].width, 1234);+ }+}diff --git a/src-tauri/src/window_groups.rs b/src-tauri/src/window_groups.rsindex 4aaea46dc..66fe0c88f 100644--- a/src-tauri/src/window_groups.rs+++ b/src-tauri/src/window_groups.rs@@ -60,7 +60,10 @@ fn copy_frame(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {if !maximized {to.unmaximize().map_err(err)?;to.set_position(from.outer_position().map_err(err)?).map_err(err)?;- to.set_size(from.inner_size().map_err(err)?).map_err(err)?;+ let size = from.inner_size().map_err(err)?;+ #[cfg(target_os = "linux")]+ crate::linux_window_state::normal_size_requested(to.app_handle(), to.label(), size);+ to.set_size(size).map_err(err)?;} else {to.maximize().map_err(err)?;}diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rsindex 54b6a35ce..f905ed51f 100644--- a/src-tauri/src/windows.rs+++ b/src-tauri/src/windows.rs@@ -298,6 +298,8 @@ fn build_project_window(app: &AppHandle, mut config: WindowConfig) -> IdeResult<} else if let Some(a) = &appearance {config.background_color = Some(frame_color(a, false));}+ #[cfg(target_os = "linux")]+ let show_after_build = crate::linux_window_state::prepare(app, &mut config);let window = WebviewWindowBuilder::from_config(app, &config).and_then(|b| dev_font_preferences(b).build()).map_err(|e| IdeError::internal(format!("cannot create window: {e}")))?;@@ -310,6 +312,10 @@ fn build_project_window(app: &AppHandle, mut config: WindowConfig) -> IdeResult<{let _ = window.set_background_color(Some(frame_color(&a, true)));}+ #[cfg(target_os = "linux")]+ if show_after_build {+ window.show().map_err(|e| IdeError::internal(format!("cannot show window: {e}")))?;+ }if visible {window.show().map_err(|e| IdeError::internal(format!("cannot show window: {e}")))?;if focused {@@ -765,6 +771,8 @@ pub fn open_settings_window(config.background_color = Some(color);}windows.set_launch(&label, Launch { settings_page: page, new_projects, ..Default::default() });+ #[cfg(target_os = "linux")]+ crate::linux_window_state::prepare(app, &mut config);let builder = WebviewWindowBuilder::from_config(app, &config);// AppKit child windows can disappear when dragged to another display's Space.// The settings label already tracks ownership and parent-close cleanup.@@ -832,7 +840,7 @@ fn fit_settings_window(window: &WebviewWindow, parent: &WebviewWindow) -> tauri:/// may still be on another display with a different scale, so its size is converted with its own/// scale and its position is given in physical pixels.#[cfg(not(target_os = "macos"))]-fn place_settings_window(window: &WebviewWindow, parent: &WebviewWindow) -> tauri::Result<()> {+pub(super) fn place_settings_window(window: &WebviewWindow, parent: &WebviewWindow) -> tauri::Result<()> {let Some(monitor) = parent.current_monitor()?.or(parent.primary_monitor()?) else {return Ok(());};