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(window): keep merged project tabs from moving the frame or menu bar (#1697)
youngledofca9d1e08faa
diff --git a/src-tauri/src/commands/window.rs b/src-tauri/src/commands/window.rsindex 9994abe05..d1d99d650 100644--- a/src-tauri/src/commands/window.rs+++ b/src-tauri/src/commands/window.rs@@ -214,7 +214,9 @@ pub fn app_cancel_quit(app: AppHandle, windows: State<'_, WindowsState>) {});}-/// Sets the menu's labels / shortcut text (on locale or keymap change) and rebuilds it.+/// Sets the menu's labels / shortcut text and rebuilds it when they changed.+/// Focusing another project window re-pushes the same shared menu; an identical+/// config must not call `set_menu`, which redraws the macOS menu bar.#[tauri::command]#[specta::specta]pub fn menu_configure(@@ -223,8 +225,9 @@ pub fn menu_configure(state: State<'_, AppState>,config: MenuConfig,) {- *menu_state.config.lock() = config;- menu::install(&app, &menu_state, &state.recent.list());+ if menu::store_config(&menu_state, config) {+ menu::install(&app, &menu_state, &state.recent.list());+ }}/// Rebuilds the menu (e.g. after the recent-projects list changed).diff --git a/src-tauri/src/macos.rs b/src-tauri/src/macos.rsindex 1a5ce3caa..7deeb54b1 100644--- a/src-tauri/src/macos.rs+++ b/src-tauri/src/macos.rs@@ -7,8 +7,9 @@ use objc2::{rc::Retained,runtime::{AnyClass, AnyObject, Imp, ProtocolObject, Sel},};-use objc2_app_kit::{NSWindow, NSWindowUserTabbingPreference};+use objc2_app_kit::{NSWindow, NSWindowAnimationBehavior, NSWindowUserTabbingPreference};use objc2_foundation::{NSNotificationCenter, NSObjectProtocol, NSRect};+use std::cell::Cell;use tauri::{AppHandle, Manager, WebviewWindow};fn tabbing_preference(app: &AppHandle) -> IdeResult<TabbingPreference> {@@ -275,16 +276,102 @@ type ConstrainFrameRect = unsafe extern "C-unwind" fn(*mut AnyObject, Sel, NSRecstatic NATIVE_CONSTRAIN_FRAME_RECT: std::sync::OnceLock<ConstrainFrameRect> = std::sync::OnceLock::new();+thread_local! {+ /// Native window whose next frame assignment must keep the rectangle it was given.+ static EXACT_FRAME: Cell<usize> = const { Cell::new(0) };+}++struct ExactFrame(usize);++impl ExactFrame {+ fn begin(native: usize) -> Self {+ EXACT_FRAME.with(|slot| slot.set(native));+ Self(native)+ }+}++impl Drop for ExactFrame {+ fn drop(&mut self) {+ EXACT_FRAME.with(|slot| {+ if slot.get() == self.0 {+ slot.set(0);+ }+ });+ }+}++/// Copies `from`'s frame onto `to`. `setFrame:display:animate:` finishes before it returns;+/// tao's position and size setters only schedule the change.+pub fn copy_window_frame(from: &WebviewWindow, to: &WebviewWindow) -> tauri::Result<()> {+ apply_window_frame(from, to, false)+}++/// Copies the frame and orders `to` front before AppKit can animate or constrain it.+/// A later `show` runs `constrainFrameRect:toScreen:` and slides a titled window into place.+pub fn present_window_frame(from: &WebviewWindow, to: &WebviewWindow) -> tauri::Result<()> {+ apply_window_frame(from, to, true)+}++fn apply_window_frame(from: &WebviewWindow, to: &WebviewWindow, show: bool) -> tauri::Result<()> {+ if MainThreadMarker::new().is_some() {+ return apply_window_frame_on_main(from, to, show);+ }+ let (tx, rx) = std::sync::mpsc::sync_channel(1);+ let from = from.clone();+ let to = to.clone();+ to.clone().run_on_main_thread(move || {+ let _ = tx.send(apply_window_frame_on_main(&from, &to, show));+ })?;+ rx.recv().map_err(|error| tauri::Error::Io(std::io::Error::other(error.to_string())))?+}++fn apply_window_frame_on_main(from: &WebviewWindow, to: &WebviewWindow, show: bool) -> tauri::Result<()> {+ let source_pointer = from.ns_window()?;+ let target_pointer = to.ns_window()?;+ unsafe {+ let source = &*source_pointer.cast::<NSWindow>();+ let target = &*target_pointer.cast::<NSWindow>();+ let frame = source.frame();+ let current = target.frame();+ let differs = frame.origin.x != current.origin.x+ || frame.origin.y != current.origin.y+ || frame.size.width != current.size.width+ || frame.size.height != current.size.height;+ if !differs && !show {+ return Ok(());+ }+ // Zoom and ordering use the window's animation behavior. `animate: false` alone does not+ // stop a zoomed window from sliding to the new frame as it is shown.+ let behavior = target.animationBehavior();+ target.setAnimationBehavior(NSWindowAnimationBehavior::None);+ let result = (|| {+ let _exact = ExactFrame::begin(target_pointer as usize);+ if differs {+ target.setFrame_display_animate(frame, false, false);+ }+ if show {+ to.show()?;+ to.set_focus()?;+ }+ Ok(())+ })();+ target.setAnimationBehavior(behavior);+ result+ }+}+/// AppKit keeps a titled window's top edge below the menu bar, and on a notched display below the/// camera housing, whenever the window is placed, shown or resized. A window in simple fullscreen-/// is titled for its buttons but must still cover the whole screen.+/// is titled for its buttons but must still cover the whole screen. A group-tab frame copy also+/// keeps the rectangle it was given, so the window about to be shown is not shifted.unsafe extern "C-unwind" fn constrain_frame_rect(this: *mut AnyObject,selector: Sel,frame: NSRect,screen: *mut AnyObject,) -> NSRect {- if COVERING.with_borrow(|windows| windows.values().any(|covering| covering.native == this as usize)) {+ let exact = EXACT_FRAME.with(|slot| slot.get() == this as usize);+ if exact || COVERING.with_borrow(|windows| windows.values().any(|covering| covering.native == this as usize)) {return frame;}match NATIVE_CONSTRAIN_FRAME_RECT.get() {diff --git a/src-tauri/src/menu.rs b/src-tauri/src/menu.rsindex 8b9fc95ae..efebf4d34 100644--- a/src-tauri/src/menu.rs+++ b/src-tauri/src/menu.rs@@ -895,7 +895,7 @@ pub fn action_ids(spec: &[Entry]) -> Vec<&'static str> {}/// Localised labels and displayed shortcuts, pushed by the frontend.-#[derive(Debug, Clone, Default, Serialize, Deserialize, Type)]+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, Type)]#[serde(rename_all = "camelCase")]pub struct MenuConfig {pub locale: String,@@ -961,6 +961,17 @@ pub struct MenuState {pub disabled: Mutex<HashSet<String>>,}+/// Stores `next` when it differs from the config last used to build the menu.+/// Callers must not replace the menu on `false`: `set_menu` redraws the macOS menu bar.+pub fn store_config(state: &MenuState, next: MenuConfig) -> bool {+ let mut current = state.config.lock();+ if *current == next {+ return false;+ }+ *current = next;+ true+}+/// The action an item id stands for, if it is an IDE action item.fn item_action(id: &str) -> Option<&str> {if id.starts_with(RECENT_PREFIX) || id == "recent.none" || id.starts_with("submenu:") {@@ -1267,6 +1278,16 @@ mod tests {}}+ #[test]+ fn unchanged_menu_config_is_not_rebuilt() {+ let state = MenuState::default();+ let mut config = MenuConfig { locale: "en".into(), ..MenuConfig::default() };+ assert!(store_config(&state, config.clone()));+ assert!(!store_config(&state, config.clone()));+ config.labels.insert("menu.file".into(), "File".into());+ assert!(store_config(&state, config));+ }+#[test]fn recent_items_route_to_open_recent_with_path() {let spec = spec(Os::Mac);diff --git a/src-tauri/src/window_groups.rs b/src-tauri/src/window_groups.rsindex 5cdb52a86..993ad606f 100644--- a/src-tauri/src/window_groups.rs+++ b/src-tauri/src/window_groups.rs@@ -56,30 +56,76 @@ 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;+/// Outer frame in physical pixels. A maximized window is represented by the rectangle it+/// occupies, not by the maximized flag: that flag can match while the rectangles do not.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+struct OuterFrame {+ x: i32,+ y: i32,+ width: u32,+ height: u32,+}++/// Where a group member can be placed.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+enum FrameHost {+ /// The client can move and resize the window.+ Desktop,+ /// Wayland does not let clients place top-level windows.+ #[cfg_attr(not(any(target_os = "linux", test)), allow(dead_code))]+ Wayland,+ /// macOS simple fullscreen already covers the screen; rewriting the frame would shrink it.+ SimpleFullscreen,+ /// Native fullscreen owns a Space. A different frame is transferred, not assigned.+ NativeFullscreen,+}++/// What to write before the target window is shown.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+enum FrameWrite {+ /// Already the same rectangle, or this host must not be placed.+ Leave,+ TransferFullscreen,+ Assign(OuterFrame),+}++/// Two windows are aligned only when their outer rectangles match. Maximized or fullscreen+/// flags are not a substitute: `show` presents the current rectangle, and a later move is visible.+fn frame_write(host: FrameHost, from: OuterFrame, to: OuterFrame) -> FrameWrite {+ match host {+ FrameHost::Wayland | FrameHost::SimpleFullscreen => FrameWrite::Leave,+ FrameHost::NativeFullscreen if from == to => FrameWrite::Leave,+ FrameHost::NativeFullscreen => FrameWrite::TransferFullscreen,+ FrameHost::Desktop if from == to => FrameWrite::Leave,+ FrameHost::Desktop => FrameWrite::Assign(from),+ }+}++fn outer_frame(window: &WebviewWindow) -> IdeResult<OuterFrame> {+ let err = |error: tauri::Error| IdeError::internal(error.to_string());+ let position = window.outer_position().map_err(err)?;+ let size = window.outer_size().map_err(err)?;+ Ok(OuterFrame { x: position.x, y: position.y, width: size.width, height: size.height })+}++fn frame_host(from: &WebviewWindow) -> IdeResult<FrameHost> {+ if simple_fullscreen(from.label()) {+ return Ok(FrameHost::SimpleFullscreen);+ }+ #[cfg(target_os = "linux")]+ if crate::linux_window_state::is_wayland() {+ return Ok(FrameHost::Wayland);}- from_full- || from_max- || (from.outer_position().ok() == to.outer_position().ok() && from.inner_size().ok() == to.inner_size().ok())+ if from.is_fullscreen().map_err(|error| IdeError::internal(error.to_string()))? {+ return Ok(FrameHost::NativeFullscreen);+ }+ Ok(FrameHost::Desktop)}/// 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.+/// visibly jump across displays when its tab is selected. macOS copies the AppKit frame instead.+#[cfg(not(target_os = "macos"))]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")]@@ -93,47 +139,91 @@ fn place_on_monitor(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {Ok(())}+/// Gives `to` the source window's outer frame before `to` is shown.+///+/// Tauri's position, size and maximize calls are queued. On macOS the AppKit calls return+/// before the frame changes, while `show` orders the window front immediately, so the old+/// rectangle appears and then jumps. The frame is written synchronously instead.fn copy_frame(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {- if same_frame(from, to) {+ let host = frame_host(from)?;+ if matches!(host, FrameHost::Wayland | FrameHost::SimpleFullscreen) {return Ok(());}- let err = |e: tauri::Error| IdeError::internal(e.to_string());- let fullscreen = from.is_fullscreen().map_err(err)?;- if fullscreen {- #[cfg(target_os = "macos")]- 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)?;- }- return Ok(());+ // Tauri's physical rectangles round through the scale factor. On macOS the AppKit frame is+ // the one `show` will present, so compare that instead of skipping a real difference.+ #[cfg(target_os = "macos")]+ if host == FrameHost::Desktop {+ return crate::macos::copy_window_frame(from, to).map_err(|error| IdeError::internal(error.to_string()));}- to.set_fullscreen(false).map_err(err)?;- let maximized = from.is_maximized().map_err(err)?;- if !maximized {- to.unmaximize().map_err(err)?;- to.set_position(from.outer_position().map_err(err)?).map_err(err)?;- // `set_size` excludes GTK's CSD shadow, which tao's inner size includes on Wayland.- #[cfg(target_os = "linux")]- let size = crate::linux_window_state::content_size(&from.as_ref().window()).map_err(err)?;- #[cfg(not(target_os = "linux"))]- 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 {- // Maximize the target on the source's monitor, not on the monitor it happened to- // occupy while hidden.- to.unmaximize().map_err(err)?;+ match frame_write(host, outer_frame(from)?, outer_frame(to)?) {+ FrameWrite::Leave => Ok(()),+ FrameWrite::TransferFullscreen => transfer_native_fullscreen(from, to),+ FrameWrite::Assign(frame) => assign_outer_frame(from, to, frame),+ }+}++fn transfer_native_fullscreen(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {+ let err = |error: tauri::Error| IdeError::internal(error.to_string());+ #[cfg(target_os = "macos")]+ 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)?;- to.maximize().map_err(err)?;+ from.set_fullscreen(false).map_err(err)?;+ to.set_fullscreen(true).map_err(err)?;}Ok(())}+fn assign_outer_frame(from: &WebviewWindow, to: &WebviewWindow, _frame: OuterFrame) -> IdeResult<()> {+ #[cfg(target_os = "macos")]+ {+ crate::macos::copy_window_frame(from, to).map_err(|error| IdeError::internal(error.to_string()))+ }+ #[cfg(not(target_os = "macos"))]+ {+ let err = |error: tauri::Error| IdeError::internal(error.to_string());+ to.set_fullscreen(false).map_err(err)?;+ if from.is_maximized().map_err(err)? {+ // Maximize on the source's monitor. The rectangles differed, so the maximized flags+ // alone are not enough; a hidden peer would otherwise appear at its old size.+ to.unmaximize().map_err(err)?;+ place_on_monitor(from, to)?;+ to.maximize().map_err(err)?;+ } else {+ to.unmaximize().map_err(err)?;+ to.set_position(from.outer_position().map_err(err)?).map_err(err)?;+ // `set_size` excludes GTK's CSD shadow, which tao's inner size includes on Wayland.+ #[cfg(target_os = "linux")]+ let size = crate::linux_window_state::content_size(&from.as_ref().window()).map_err(err)?;+ #[cfg(not(target_os = "linux"))]+ 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)?;+ }+ Ok(())+ }+}++/// Shows `to` in place of `from`, at `from`'s frame.+fn show_at_frame(from: &WebviewWindow, to: &WebviewWindow) -> IdeResult<()> {+ let err = |error: tauri::Error| IdeError::internal(error.to_string());+ // Order the target front in the same AppKit turn as the frame write. A separate `show` runs+ // after that turn and constrains the titled window, which is the jump. Native fullscreen is+ // handed over by `copy_frame` instead.+ #[cfg(target_os = "macos")]+ if !from.is_fullscreen().map_err(err)? {+ to.unminimize().map_err(err)?;+ return crate::macos::present_window_frame(from, to).map_err(err);+ }+ copy_frame(from, to)?;+ to.unminimize().map_err(err)?;+ to.show().map_err(err)?;+ to.set_focus().map_err(err)+}+/// 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) {@@ -235,11 +325,12 @@ pub fn select(app: &AppHandle, caller: &str, target: &str) -> IdeResult<()> {&& previous.selected != target&& let Some(from) = app.get_webview_window(&previous.selected){- copy_frame(&from, &to)?;+ show_at_frame(&from, &to)?;+ } else {+ to.unminimize().map_err(|e| IdeError::internal(e.to_string()))?;+ to.show().map_err(|e| IdeError::internal(e.to_string()))?;+ to.set_focus().map_err(|e| IdeError::internal(e.to_string()))?;}- to.unminimize().map_err(|e| IdeError::internal(e.to_string()))?;- to.show().map_err(|e| IdeError::internal(e.to_string()))?;- to.set_focus().map_err(|e| IdeError::internal(e.to_string()))?;for member in &previous.members {if member != target&& let Some(window) = app.get_webview_window(member)@@ -546,3 +637,54 @@ pub async fn restore(app: &AppHandle, caller: &str) -> IdeResult<()> {}Ok(())}++#[cfg(test)]+mod tests {+ use super::{FrameHost, FrameWrite, OuterFrame, frame_write};++ fn frame(x: i32, y: i32, width: u32, height: u32) -> OuterFrame {+ OuterFrame { x, y, width, height }+ }++ #[test]+ fn matching_outer_rects_are_left_alone() {+ let frame = frame(100, 80, 1200, 800);+ assert_eq!(frame_write(FrameHost::Desktop, frame, frame), FrameWrite::Leave);+ }++ #[test]+ fn a_different_outer_rect_is_assigned_before_the_window_is_shown() {+ let from = frame(100, 80, 1200, 800);+ let to = frame(40, 40, 900, 600);+ assert_eq!(frame_write(FrameHost::Desktop, from, to), FrameWrite::Assign(from));+ }++ #[test]+ fn maximized_windows_with_different_rects_still_assign() {+ let from = frame(0, 25, 1728, 1055);+ let to = frame(0, 25, 1512, 900);+ assert_eq!(frame_write(FrameHost::Desktop, from, to), FrameWrite::Assign(from));+ }++ #[test]+ fn simple_fullscreen_does_not_copy_a_frame() {+ let from = frame(0, 0, 1728, 1117);+ let to = frame(100, 80, 1200, 800);+ assert_eq!(frame_write(FrameHost::SimpleFullscreen, from, to), FrameWrite::Leave);+ }++ #[test]+ fn wayland_does_not_place_a_window() {+ let from = frame(0, 0, 1200, 800);+ let to = frame(10, 10, 800, 600);+ assert_eq!(frame_write(FrameHost::Wayland, from, to), FrameWrite::Leave);+ }++ #[test]+ fn native_fullscreen_transfers_only_when_the_rects_differ() {+ let from = frame(0, 0, 1728, 1117);+ let other = frame(100, 80, 1200, 800);+ assert_eq!(frame_write(FrameHost::NativeFullscreen, from, from), FrameWrite::Leave);+ assert_eq!(frame_write(FrameHost::NativeFullscreen, from, other), FrameWrite::TransferFullscreen);+ }+}diff --git a/src/bindings.ts b/src/bindings.tsindex bdb23e097..c9ca52c93 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -897,7 +897,11 @@ export const commands = {appQuit: () => __TAURI_INVOKE<void>("app_quit"),/** A window vetoed the quit (user cancelled its unsaved-changes prompt). */appCancelQuit: () => __TAURI_INVOKE<void>("app_cancel_quit"),- /** Sets the menu's labels / shortcut text (on locale or keymap change) and rebuilds it. */+ /**+ * Sets the menu's labels / shortcut text and rebuilds it when they changed.+ * Focusing another project window re-pushes the same shared menu; an identical+ * config must not call `set_menu`, which redraws the macOS menu bar.+ */menuConfigure: (config: MenuConfig) => __TAURI_INVOKE<void>("menu_configure", { config }),/** Rebuilds the menu (e.g. after the recent-projects list changed). */menuRefresh: () => __TAURI_INVOKE<void>("menu_refresh"),diff --git a/src/features/app/menuBridge.ts b/src/features/app/menuBridge.tsindex 1cb210867..2f8f4e6f4 100644--- a/src/features/app/menuBridge.ts+++ b/src/features/app/menuBridge.ts@@ -147,7 +147,8 @@ export function installMenuBridge(): () => void {push();pushEnablement(true);};- // The native menu bar is shared: a focused window re-pushes its own window-scoped labels.+ // The menu bar is shared. A focused window re-pushes labels that can differ per window.+ // An identical config does not replace the menu, so switching project tabs does not redraw it.window.addEventListener("focus", onFocus);const unsubs = [useI18n.subscribe((s, prev) => {