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(window): stop project tab switches from moving the group window (#1287)

xtr-hub7cdf690b4b48
diff --git a/docs/workspaces-and-window-groups.md b/docs/workspaces-and-window-groups.md
index db86800ed..48937ffb3 100644
--- a/docs/workspaces-and-window-groups.md
+++ b/docs/workspaces-and-window-groups.md
@@ -30,7 +30,7 @@ Open two project windows, then use **Window → Merge All Project Windows**. The
Use the tab's close button to close that project, or **Move Tab to New Window** to detach the current tab. Right-click a tab for **Close Other Tabs**, **Close Tabs to the Left** and **Close Tabs to the Right**, which close the projects one at a time and keep the clicked tab; cancelling one project's unsaved-changes prompt leaves it and the rest open. The same commands are in the Command Palette and can be assigned shortcuts. Closing uses the existing unsaved-changes guard. Quit visits project windows in sequence so a hidden project's prompt is visible. Groups restore when **Reopen last project** is enabled.
-The grouping model lives in `ide-workspace`, independently of project ownership. The desktop adapter keeps each member's WebView and backend services alive, presents the selected window at the group's position/size, and hides its peers. This is an application-drawn tab strip, not the macOS native tab strip. Its persistence is application-local in `window-groups.json`. Language servers, terminals, editor buffers and settings remain independent between group members.
+The grouping model lives in `ide-workspace`, independently of project ownership. The desktop adapter keeps each member's WebView and backend services alive, presents the selected window at the group's position/size, and hides its peers. Hidden members are kept at the selected window's frame and display (and follow it after a move or resize), so switching projects only changes which window is visible. This is an application-drawn tab strip, not the macOS native tab strip. Its persistence is application-local in `window-groups.json`. Language servers, terminals, editor buffers and settings remain independent between group members.
## Validation
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index f7ecc3c68..3e889ed71 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -176,6 +176,9 @@ pub fn run() {
}
}
tauri::WindowEvent::Focused(false) => application_focus::changed(window.app_handle(), false),
+ tauri::WindowEvent::Moved(_) | tauri::WindowEvent::Resized(_) => {
+ window_groups::frame_changed(window.app_handle(), window.label());
+ }
tauri::WindowEvent::Destroyed => {
#[cfg(target_os = "macos")]
{
diff --git a/src-tauri/src/window_groups.rs b/src-tauri/src/window_groups.rs
index d184c33d8..44e70c2d2 100644
--- a/src-tauri/src/window_groups.rs
+++ b/src-tauri/src/window_groups.rs
@@ -8,9 +8,17 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::VecDeque;
use std::path::PathBuf;
-use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Duration;
use tauri::{AppHandle, Manager, WebviewWindow};
+/// Wait for the selection's asynchronous `hide` calls to take effect before moving the peers.
+const FRAME_SETTLE_AFTER_SELECT: Duration = Duration::from_millis(50);
+/// Wait for a drag/resize to stop before copying its frame to the hidden peers.
+const FRAME_SETTLE_AFTER_MOVE: Duration = Duration::from_millis(100);
+/// Coalesces the move/resize events a drag emits.
+static FRAME_SYNC_GENERATION: AtomicU64 = AtomicU64::new(0);
+
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WindowTab {
@@ -48,7 +56,47 @@ fn changed(app: &AppHandle) {
app.state::<AppState>().sink.emit(IdeEvent::WindowGroupsChanged);
}
+/// Whether `to` already presents `from`'s frame, so moving it would only make it flicker.
+fn same_frame(from: &WebviewWindow, to: &WebviewWindow) -> bool {
+ let (Ok(from_max), Ok(to_max)) = (from.is_maximized(), to.is_maximized()) else { return false };
+ let (Ok(from_full), Ok(to_full)) = (from.is_fullscreen(), to.is_fullscreen()) else { return false };
+ if from_max != to_max || from_full != to_full {
+ return false;
+ }
+ let same_monitor = match (from.current_monitor(), to.current_monitor()) {
+ (Ok(Some(a)), Ok(Some(b))) => a.position() == b.position() && a.size() == b.size(),
+ // An unmapped window may not report a monitor; treat only equal states as matching.
+ (Ok(None), Ok(None)) | (Err(_), Err(_)) => true,
+ _ => false,
+ };
+ if !same_monitor {
+ return false;
+ }
+ from_full
+ || from_max
+ || (from.outer_position().ok() == to.outer_position().ok() && from.inner_size().ok() == to.inner_size().ok())
+}
+
+/// Moves a hidden window onto `from`'s monitor. A restored window keeps its normal position on
+/// the monitor it last occupied; maximizing or going fullscreen there would make the window
+/// visibly jump across displays when its tab is selected.
+fn place_on_monitor(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {
+ // Wayland does not let clients place top-level windows; maximizing stays on that output.
+ #[cfg(target_os = "linux")]
+ if crate::linux_window_state::is_wayland() {
+ return Ok(());
+ }
+ let err = |e: tauri::Error| IdeError::internal(e.to_string());
+ if let Some(monitor) = from.current_monitor().map_err(err)? {
+ to.set_position(*monitor.position()).map_err(err)?;
+ }
+ Ok(())
+}
+
fn copy_frame(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {
+ if same_frame(from, to) {
+ return Ok(());
+ }
let err = |e: tauri::Error| IdeError::internal(e.to_string());
let fullscreen = from.is_fullscreen().map_err(err)?;
if fullscreen {
@@ -56,6 +104,8 @@ fn copy_frame(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {
crate::macos::transfer_fullscreen(from, to).map_err(err)?;
#[cfg(not(target_os = "macos"))]
{
+ to.set_fullscreen(false).map_err(err)?;
+ place_on_monitor(from, to)?;
from.set_fullscreen(false).map_err(err)?;
to.set_fullscreen(true).map_err(err)?;
}
@@ -75,11 +125,59 @@ fn copy_frame(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {
crate::linux_window_state::normal_size_requested(to.app_handle(), to.label(), size);
to.set_size(size).map_err(err)?;
} else {
+ // Maximize the target on the source's monitor, not on the monitor it happened to
+ // occupy while hidden.
+ to.unmaximize().map_err(err)?;
+ place_on_monitor(from, to)?;
to.maximize().map_err(err)?;
}
Ok(())
}
+/// Keeps hidden group members at the selected window's frame. Selecting a tab then only
+/// changes which window is visible instead of moving or resizing one on screen.
+fn sync_member_frames(app: &AppHandle, selected: &str) {
+ let Some(group) = app.state::<WindowsState>().groups.lock().group(selected).cloned() else { return };
+ if group.selected != selected {
+ return;
+ }
+ let Some(from) = app.get_webview_window(selected) else { return };
+ if from.is_fullscreen().unwrap_or(false) || from.is_minimized().unwrap_or(false) || simple_fullscreen(selected) {
+ return;
+ }
+ for member in group.members.iter().filter(|member| member.as_str() != selected) {
+ let Some(to) = app.get_webview_window(member) else { continue };
+ // A visible peer is the one being presented; never move it behind the user's back.
+ if to.is_visible().unwrap_or(false) {
+ continue;
+ }
+ if let Err(error) = copy_frame(&from, &to) {
+ tracing::warn!("cannot align window {member} with {selected}: {}", error.message);
+ }
+ }
+}
+
+/// A presented group window moved or resized. Align its hidden peers after the user stops, so
+/// the next tab selection is only a visibility change.
+pub fn frame_changed(app: &AppHandle, label: &str) {
+ let Some(group) = app.state::<WindowsState>().groups.lock().group(label).cloned() else { return };
+ if group.selected != label {
+ return;
+ }
+ let generation = FRAME_SYNC_GENERATION.fetch_add(1, Ordering::Relaxed) + 1;
+ let app = app.clone();
+ let label = label.to_owned();
+ tauri::async_runtime::spawn(async move {
+ tokio::time::sleep(FRAME_SETTLE_AFTER_MOVE).await;
+ if FRAME_SYNC_GENERATION.load(Ordering::Relaxed) != generation {
+ return;
+ }
+ if !app.state::<WindowsState>().quitting() {
+ sync_member_frames(&app, &label);
+ }
+ });
+}
+
fn simple_fullscreen(label: &str) -> bool {
#[cfg(target_os = "macos")]
return crate::macos::is_simple_fullscreen(label);
@@ -163,6 +261,18 @@ pub fn select(app: &AppHandle, caller: &str, target: &str) -> IdeResult<()> {
}
}
}
+ } else if !state.quitting() {
+ // Align the members that are now hidden while they stay invisible, so the next
+ // selection does not move or resize a window on screen. Hiding is asynchronous;
+ // wait for it before moving a peer that is still on screen.
+ let app = app.clone();
+ let target = target.to_owned();
+ tauri::async_runtime::spawn(async move {
+ tokio::time::sleep(FRAME_SETTLE_AFTER_SELECT).await;
+ if !app.state::<WindowsState>().quitting() {
+ sync_member_frames(&app, &target);
+ }
+ });
}
changed(app);
result