From 57f8bdefad18bfa22768ec6e378eea009955c6f0 Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Mon, 23 Feb 2026 16:58:35 -0600 Subject: [PATCH] feat: persist window size and maximized state across sessions - Add window_width, window_height, is_maximized columns to window_settings DB with automatic migration for existing installs - Restore saved size on startup; restore maximized state after window creation - Save non-maximized size on every Resize event - Save maximized flag on CloseRequested - Default remains 1280x800 for first launch --- src-tauri/src/config/window_settings.rs | 67 ++++++++++++++++++++++++- src-tauri/src/lib.rs | 58 +++++++++++++++++++-- 2 files changed, 119 insertions(+), 6 deletions(-) diff --git a/src-tauri/src/config/window_settings.rs b/src-tauri/src/config/window_settings.rs index f246e4bb3..f6ee9dbf0 100644 --- a/src-tauri/src/config/window_settings.rs +++ b/src-tauri/src/config/window_settings.rs @@ -13,12 +13,21 @@ use std::sync::{Arc, Mutex}; pub struct WindowSettings { /// Use OS native window decorations instead of custom title bar pub use_system_titlebar: bool, + /// Last saved window width (logical pixels, non-maximized) + pub window_width: f64, + /// Last saved window height (logical pixels, non-maximized) + pub window_height: f64, + /// Whether the window was maximized when last closed + pub is_maximized: bool, } impl Default for WindowSettings { fn default() -> Self { Self { use_system_titlebar: false, + window_width: 1280.0, + window_height: 800.0, + is_maximized: false, } } } @@ -54,6 +63,11 @@ impl WindowSettingsStore { ) .map_err(|e| format!("Failed to insert default window settings: {}", e))?; + // Migrations: add window size columns on existing DBs (errors ignored when column exists) + let _ = conn.execute("ALTER TABLE window_settings ADD COLUMN window_width REAL NOT NULL DEFAULT 1280.0", []); + let _ = conn.execute("ALTER TABLE window_settings ADD COLUMN window_height REAL NOT NULL DEFAULT 800.0", []); + let _ = conn.execute("ALTER TABLE window_settings ADD COLUMN is_maximized INTEGER NOT NULL DEFAULT 0", []); + info!("[WindowSettings] Database initialized"); Ok(Self { conn }) @@ -73,12 +87,19 @@ impl WindowSettingsStore { pub fn get_settings(&self) -> Result { self.conn .query_row( - "SELECT use_system_titlebar FROM window_settings WHERE id = 1", + "SELECT use_system_titlebar, window_width, window_height, is_maximized + FROM window_settings WHERE id = 1", [], |row| { let use_system_titlebar: i32 = row.get(0)?; + let window_width: f64 = row.get(1)?; + let window_height: f64 = row.get(2)?; + let is_maximized: i32 = row.get(3)?; Ok(WindowSettings { use_system_titlebar: use_system_titlebar != 0, + window_width, + window_height, + is_maximized: is_maximized != 0, }) }, ) @@ -94,6 +115,28 @@ impl WindowSettingsStore { .map_err(|e| format!("Failed to set use_system_titlebar: {}", e))?; Ok(()) } + + /// Save the non-maximized window dimensions (called on resize while not maximized). + pub fn set_window_size(&self, width: f64, height: f64) -> Result<(), String> { + self.conn + .execute( + "UPDATE window_settings SET window_width = ?1, window_height = ?2 WHERE id = 1", + params![width, height], + ) + .map_err(|e| format!("Failed to save window size: {}", e))?; + Ok(()) + } + + /// Save the maximized state (called on window close). + pub fn set_is_maximized(&self, value: bool) -> Result<(), String> { + self.conn + .execute( + "UPDATE window_settings SET is_maximized = ?1 WHERE id = 1", + params![if value { 1 } else { 0 }], + ) + .map_err(|e| format!("Failed to save maximized state: {}", e))?; + Ok(()) + } } /// Global state wrapper for thread-safe access @@ -136,6 +179,28 @@ impl WindowSettingsState { .ok_or("Window settings store not initialized")?; store.set_use_system_titlebar(value) } + + pub fn set_window_size(&self, width: f64, height: f64) -> Result<(), String> { + let guard = self + .store + .lock() + .map_err(|_| "Failed to lock window settings store".to_string())?; + let store = guard + .as_ref() + .ok_or("Window settings store not initialized")?; + store.set_window_size(width, height) + } + + pub fn set_is_maximized(&self, value: bool) -> Result<(), String> { + let guard = self + .store + .lock() + .map_err(|_| "Failed to lock window settings store".to_string())?; + let store = guard + .as_ref() + .ok_or("Window settings store not initialized")?; + store.set_is_maximized(value) + } } // Tauri commands diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 8d22b0ed1..f61d9ab63 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -406,15 +406,21 @@ pub fn run() { tray_settings.close_to_tray ); - // Read window settings for decoration configuration before window creation. + // Read window settings for decoration and size configuration before window creation. let window_settings = config::window_settings::WindowSettingsStore::new() .and_then(|store| store.get_settings()) .unwrap_or_default(); log::info!( - "Window settings: use_system_titlebar={}", - window_settings.use_system_titlebar + "Window settings: use_system_titlebar={}, size={}x{}, maximized={}", + window_settings.use_system_titlebar, + window_settings.window_width as u32, + window_settings.window_height as u32, + window_settings.is_maximized, ); let use_system_titlebar = window_settings.use_system_titlebar; + let saved_win_width = window_settings.window_width; + let saved_win_height = window_settings.window_height; + let saved_win_maximized = window_settings.is_maximized; // One-time cleanup: remove the KWin SSD window rule written by QBZ 1.1.14. // That version wrote a kwinrulesrc entry forcing server-side decorations; it @@ -603,13 +609,13 @@ pub fn run() { gtk_decorations, use_kwin_ssd ); - tauri::WebviewWindowBuilder::new( + let main_window = tauri::WebviewWindowBuilder::new( app, "main", tauri::WebviewUrl::App(std::path::PathBuf::from("index.html")), ) .title("QBZ") - .inner_size(1280.0, 800.0) + .inner_size(saved_win_width, saved_win_height) .min_inner_size(800.0, 600.0) .decorations(gtk_decorations) .transparent(true) @@ -621,6 +627,48 @@ pub fn run() { e })?; + // Restore maximized state + if saved_win_maximized { + let _ = main_window.maximize(); + } + + // Persist window size across sessions. + // - Resize (non-maximized): saves width/height so last user size is remembered. + // - CloseRequested: saves the maximized flag. + { + let ws_state = app.state::(); + let store = std::sync::Arc::clone(&ws_state.store); + let win_for_events = main_window.clone(); + main_window.on_window_event(move |event| { + match event { + tauri::WindowEvent::Resized(size) => { + if size.width > 0 && size.height > 0 { + let maximized = win_for_events.is_maximized().unwrap_or(false); + if !maximized { + if let Ok(guard) = store.lock() { + if let Some(s) = guard.as_ref() { + let _ = s.set_window_size( + size.width as f64, + size.height as f64, + ); + } + } + } + } + } + tauri::WindowEvent::CloseRequested { .. } => { + let maximized = win_for_events.is_maximized().unwrap_or(false); + if let Ok(guard) = store.lock() { + if let Some(s) = guard.as_ref() { + let _ = s.set_is_maximized(maximized); + } + } + } + _ => {} + } + }); + } + // Add KWin window rule to force server-side decorations for QBZ if use_kwin_ssd { std::thread::spawn(|| {