Skip to content

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.

fix(linux): restore window geometry after GTK mapping (#619)

fuqiuluo041e72106bde
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 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::FULLSCREEN
diff --git a/src-tauri/src/linux_window_state.rs b/src-tauri/src/linux_window_state.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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(());
};