Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

fix(mux): size a zoomed stack's page from the frontend that drives it

RoversXfddd67e64c5f
diff --git a/mux/src/lib.rs b/mux/src/lib.rs
index a71b9d08..7045e0e1 100644
--- a/mux/src/lib.rs
+++ b/mux/src/lib.rs
@@ -283,6 +283,31 @@ fn is_sole_live_renderer(
})
}
+/// The size the frontend driving `tab_id` last gave `pane_id` over the whole
+/// tab, `root` as it is now: a page of a zoomed stack, which that frontend
+/// sizes before it is shown. None when nobody drives the tab, the driver
+/// reports cells rather than panes, or its layout no longer fits the tab.
+fn driving_frontend_size_over_root(
+ lease: &FrontendLeaseState,
+ tab_id: TabId,
+ pane_id: PaneId,
+ root: wezterm_term::TerminalSize,
+) -> Option<wezterm_term::TerminalSize> {
+ let state = lease.tabs.get(&tab_id)?;
+ let driver = match lease.access_mode {
+ FrontendAccessMode::TmuxLatest => state.owner.as_ref(),
+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref(),
+ }?;
+ let FrontendViewport::Native { panes, .. } = state.viewports.get(driver)? else {
+ return None;
+ };
+ panes
+ .iter()
+ .find(|pane| pane.pane_id == pane_id)
+ .filter(|pane| pane.frame.cols == root.cols && pane.frame.rows == root.rows)
+ .map(|pane| pane.size)
+}
+
struct FrontendLeaseState {
tabs: HashMap<TabId, TabFrontendLease>,
access_mode: FrontendAccessMode,
@@ -3182,7 +3207,18 @@ impl Mux {
let tab = self
.get_tab(tab_id)
.ok_or_else(|| anyhow!("tab_id {} invalid", tab_id))?;
- tab.activate_pane_in_stack(pane_id)?;
+ // A zoomed stack gives the page it switches to the whole tab. The
+ // frontend driving the tab has already sized every page for that,
+ // with each page's own font scale and nav bar; the raw tab size was
+ // only put back by that frontend later, the page meanwhile drawn at
+ // the wrong width.
+ let zoomed_size = driving_frontend_size_over_root(
+ &self.frontend_lease.lock(),
+ tab_id,
+ pane_id,
+ tab.get_size(),
+ );
+ tab.activate_pane_in_stack_sized(pane_id, zoomed_size)?;
Ok(())
}
@@ -3960,6 +3996,86 @@ mod tests {
tab.tab_id()
}
+ #[test]
+ fn a_zoomed_page_takes_the_size_its_driving_frontend_gave_it() {
+ let driver = client_id(90);
+ let other = client_id(91);
+ let root = frontend_test_size(120, 34);
+ let page = FrontendPaneViewport {
+ pane_id: 7,
+ size: frontend_test_size(97, 26),
+ frame: root,
+ };
+ let beside = FrontendPaneViewport {
+ pane_id: 8,
+ size: frontend_test_size(50, 30),
+ frame: frontend_test_size(60, 34),
+ };
+ let tab = TabFrontendLease {
+ owner: Some(driver.clone()),
+ viewports: HashMap::from([
+ (
+ driver.clone(),
+ FrontendViewport::Native {
+ size: root,
+ panes: vec![page, beside],
+ },
+ ),
+ (
+ other.clone(),
+ FrontendViewport::Native {
+ size: root,
+ panes: vec![FrontendPaneViewport {
+ size: frontend_test_size(10, 5),
+ ..page
+ }],
+ },
+ ),
+ ]),
+ ..Default::default()
+ };
+ let mut lease = FrontendLeaseState {
+ tabs: HashMap::from([(3, tab)]),
+ handoff_owner: Some(driver.clone()),
+ ..Default::default()
+ };
+
+ assert_eq!(driving_frontend_size_over_root(&lease, 3, 7, root), Some(page.size));
+ assert_eq!(
+ driving_frontend_size_over_root(&lease, 3, 8, root),
+ None,
+ "a pane that does not cover the tab is not a zoomed page"
+ );
+ assert_eq!(
+ driving_frontend_size_over_root(&lease, 3, 7, frontend_test_size(130, 34)),
+ None,
+ "a layout for a tab of another size"
+ );
+ assert_eq!(driving_frontend_size_over_root(&lease, 3, 9, root), None);
+ assert_eq!(driving_frontend_size_over_root(&lease, 4, 7, root), None);
+
+ lease.handoff_owner = Some(other.clone());
+ assert_eq!(
+ driving_frontend_size_over_root(&lease, 3, 7, root),
+ Some(frontend_test_size(10, 5)),
+ "only the driving frontend's sizes count"
+ );
+ lease.handoff_owner = None;
+ assert_eq!(driving_frontend_size_over_root(&lease, 3, 7, root), None);
+
+ lease.access_mode = FrontendAccessMode::TmuxLatest;
+ assert_eq!(
+ driving_frontend_size_over_root(&lease, 3, 7, root),
+ Some(page.size),
+ "TmuxLatest drives each tab on its own"
+ );
+ lease.tabs.get_mut(&3).unwrap().viewports.insert(
+ driver.clone(),
+ FrontendViewport::CellGrid { size: root },
+ );
+ assert_eq!(driving_frontend_size_over_root(&lease, 3, 7, root), None);
+ }
+
#[test]
fn sole_live_renderer_ignores_itself_and_dead_clients() {
let me = client_id(150);
diff --git a/mux/src/tab.rs b/mux/src/tab.rs
index 29347ad5..6386ac18 100644
--- a/mux/src/tab.rs
+++ b/mux/src/tab.rs
@@ -1289,7 +1289,20 @@ impl Tab {
}
pub fn activate_pane_in_stack(&self, pane_id: PaneId) -> anyhow::Result<usize> {
- self.inner.lock().activate_pane_in_stack(pane_id)
+ self.activate_pane_in_stack_sized(pane_id, None)
+ }
+
+ /// As `activate_pane_in_stack`. In a zoomed stack the page switched to
+ /// covers the whole tab; `zoomed_size` is the size its frontend gave it
+ /// there, when known, and takes the place of the raw tab size.
+ pub fn activate_pane_in_stack_sized(
+ &self,
+ pane_id: PaneId,
+ zoomed_size: Option<TerminalSize>,
+ ) -> anyhow::Result<usize> {
+ self.inner
+ .lock()
+ .activate_pane_in_stack(pane_id, zoomed_size)
}
/// Assigns the root pane.
@@ -3137,9 +3150,13 @@ impl TabInner {
}
}
- fn activate_pane_in_stack(&mut self, pane_id: PaneId) -> anyhow::Result<usize> {
+ fn activate_pane_in_stack(
+ &mut self,
+ pane_id: PaneId,
+ zoomed_size: Option<TerminalSize>,
+ ) -> anyhow::Result<usize> {
if self.zoomed.is_some() {
- return self.activate_zoomed_pane_in_stack(pane_id);
+ return self.activate_zoomed_pane_in_stack(pane_id, zoomed_size);
}
let prior = self.get_active_pane();
@@ -3158,7 +3175,11 @@ impl TabInner {
Ok(pane_index)
}
- fn activate_zoomed_pane_in_stack(&mut self, pane_id: PaneId) -> anyhow::Result<usize> {
+ fn activate_zoomed_pane_in_stack(
+ &mut self,
+ pane_id: PaneId,
+ zoomed_size: Option<TerminalSize>,
+ ) -> anyhow::Result<usize> {
let prior = self.get_active_pane();
let Some(zoomed_pane_id) = prior.as_ref().map(|pane| pane.pane_id()) else {
anyhow::bail!("cannot switch pane tab while zoomed");
@@ -3199,8 +3220,15 @@ impl TabInner {
prior.set_zoomed(false);
}
target_pane.set_zoomed(true);
- if let Err(err) = target_pane.resize(self.size) {
- log::error!("failed to resize zoomed pane: {err:#}");
+ // As in toggle_zoom: a remote mirror is sized by its frontend,
+ // which takes off its own nav bar and font scale. The raw tab
+ // size is not this pane's, and a mirror would send it on as a
+ // Resize the server then keeps. Where that frontend's size for
+ // the page is known, it is used instead of the raw one.
+ if !target_pane.is_remote_mirror() {
+ if let Err(err) = target_pane.resize(zoomed_size.unwrap_or(self.size)) {
+ log::error!("failed to resize zoomed pane: {err:#}");
+ }
}
}
self.zoomed.replace(target_pane);
@@ -4335,6 +4363,66 @@ mod test {
assert_eq!(tab.iter_panes()[0].height, tab_size.rows);
}
+ #[test]
+ fn switching_a_zoomed_stack_does_not_raw_resize_a_remote_mirror() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let pane_size = TerminalSize {
+ rows: 11,
+ cols: 39,
+ pixel_width: 390,
+ pixel_height: 275,
+ dpi: 96,
+ };
+ let tab = Tab::new(&tab_size);
+ let first = FakePane::remote_mirror(1, pane_size);
+ tab.assign_pane(&first);
+ tab.add_pane_to_stack(1, FakePane::remote_mirror(2, pane_size))
+ .unwrap();
+ tab.set_zoomed(true);
+
+ tab.activate_pane_in_stack(1).unwrap();
+
+ assert_eq!(tab.get_zoomed_pane().unwrap().pane_id(), 1);
+ let dimensions = first.get_dimensions();
+ assert_eq!(dimensions.cols, pane_size.cols);
+ assert_eq!(dimensions.viewport_rows, pane_size.rows);
+ }
+
+ #[test]
+ fn switching_a_zoomed_stack_gives_the_page_its_frontend_size() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let tab = Tab::new(&tab_size);
+ let first = FakePane::new(1, tab_size);
+ let second = FakePane::new(2, tab_size);
+ tab.assign_pane(&first);
+ tab.add_pane_to_stack(1, Arc::clone(&second)).unwrap();
+ tab.set_zoomed(true);
+ let frontend_size = TerminalSize {
+ rows: 11,
+ cols: 39,
+ pixel_width: 390,
+ pixel_height: 275,
+ dpi: 96,
+ };
+
+ tab.activate_pane_in_stack_sized(1, Some(frontend_size))
+ .unwrap();
+ let dimensions = first.get_dimensions();
+ assert_eq!(dimensions.cols, frontend_size.cols);
+ assert_eq!(dimensions.viewport_rows, frontend_size.rows);
+
+ second.resize(frontend_size).unwrap();
+ tab.activate_pane_in_stack(2).unwrap();
+ let dimensions = second.get_dimensions();
+ assert_eq!(
+ (dimensions.cols, dimensions.viewport_rows),
+ (tab_size.cols, tab_size.rows),
+ "without one the page still gets the whole tab"
+ );
+ }
+
#[test]
fn unzoom_preserves_the_divider_and_leaves_pty_sizing_to_the_frontend() {
let _mux = install_mux();