diff options
Diffstat (limited to 'src/app')
| -rw-r--r-- | src/app/actions.rs | 97 | ||||
| -rw-r--r-- | src/app/api.rs | 1 | ||||
| -rw-r--r-- | src/app/api/panes.rs | 290 |
3 files changed, 376 insertions, 12 deletions
diff --git a/src/app/actions.rs b/src/app/actions.rs index 8124be93..17daa6ff 100644 --- a/src/app/actions.rs +++ b/src/app/actions.rs @@ -1350,6 +1350,28 @@ impl AppState { // Pane operations // --------------------------------------------------------------------------- +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum PaneZoomCommand { + Toggle, + On, + Off, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum PaneZoomNoopReason { + SinglePane, + AlreadyZoomed, + AlreadyUnzoomed, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) struct PaneZoomOutcome { + pub changed: bool, + pub focus_changed: bool, + pub reason: Option<PaneZoomNoopReason>, + pub zoomed: bool, +} + impl AppState { pub fn navigate_pane(&mut self, direction: NavDirection) { let Some(ws_idx) = self.active else { @@ -1468,17 +1490,72 @@ impl AppState { } } - pub fn toggle_zoom(&mut self) { - if let Some(tab) = self - .active - .and_then(|i| self.workspaces.get_mut(i)) - .and_then(|ws| ws.active_tab_mut()) - { - if tab.layout.pane_count() > 1 { - tab.zoomed = !tab.zoomed; - self.mark_session_dirty(); - } + pub(crate) fn apply_pane_zoom( + &mut self, + ws_idx: usize, + pane_id: PaneId, + command: PaneZoomCommand, + ) -> Option<PaneZoomOutcome> { + let tab_idx = self + .workspaces + .get(ws_idx)? + .find_tab_index_for_pane(pane_id)?; + let focus_changed = self.focus_pane_in_workspace(ws_idx, pane_id); + let tab = self + .workspaces + .get_mut(ws_idx) + .and_then(|ws| ws.tabs.get_mut(tab_idx))?; + if tab.layout.pane_count() <= 1 { + return Some(PaneZoomOutcome { + changed: false, + focus_changed, + reason: Some(PaneZoomNoopReason::SinglePane), + zoomed: tab.zoomed, + }); } + + let desired = match command { + PaneZoomCommand::Toggle => !tab.zoomed, + PaneZoomCommand::On => true, + PaneZoomCommand::Off => false, + }; + let reason = match (command, tab.zoomed) { + (PaneZoomCommand::On, true) => Some(PaneZoomNoopReason::AlreadyZoomed), + (PaneZoomCommand::Off, false) => Some(PaneZoomNoopReason::AlreadyUnzoomed), + _ => None, + }; + if reason.is_some() { + return Some(PaneZoomOutcome { + changed: false, + focus_changed, + reason, + zoomed: tab.zoomed, + }); + } + + tab.zoomed = desired; + let zoomed = tab.zoomed; + self.mark_session_dirty(); + Some(PaneZoomOutcome { + changed: true, + focus_changed, + reason: None, + zoomed, + }) + } + + pub fn toggle_zoom(&mut self) { + let Some(ws_idx) = self.active else { + return; + }; + let Some(pane_id) = self + .workspaces + .get(ws_idx) + .and_then(crate::workspace::Workspace::focused_pane_id) + else { + return; + }; + self.apply_pane_zoom(ws_idx, pane_id, PaneZoomCommand::Toggle); } pub(crate) fn workspace_close_would_close_worktree_group(&self, ws_idx: usize) -> bool { diff --git a/src/app/api.rs b/src/app/api.rs index 35994bff..592ee7da 100644 --- a/src/app/api.rs +++ b/src/app/api.rs @@ -556,6 +556,7 @@ impl App { Method::AgentSend(params) => return self.handle_agent_send(request.id, params), Method::PaneSplit(params) => return self.handle_pane_split(request.id, params), Method::PaneSwap(params) => return self.handle_pane_swap(request.id, params), + Method::PaneZoom(params) => return self.handle_pane_zoom(request.id, params), Method::PaneLayout(params) => return self.handle_pane_layout(request.id, params), Method::PaneNeighbor(params) => return self.handle_pane_neighbor(request.id, params), Method::PaneEdges(params) => return self.handle_pane_edges(request.id, params), diff --git a/src/app/api/panes.rs b/src/app/api/panes.rs index 23272ffd..d824d26b 100644 --- a/src/app/api/panes.rs +++ b/src/app/api/panes.rs @@ -8,9 +8,10 @@ use crate::api::schema::{ PaneReadResult, PaneReleaseAgentParams, PaneRenameParams, PaneReportAgentParams, PaneReportAgentSessionParams, PaneReportMetadataParams, PaneResizeParams, PaneResizeReason, PaneResizeResult, PaneSendInputParams, PaneSendKeysParams, PaneSendTextParams, PaneSplitParams, - PaneSwapParams, PaneSwapReason, PaneSwapResult, PaneTarget, ReadFormat, ReadSource, - ResponseResult, + PaneSwapParams, PaneSwapReason, PaneSwapResult, PaneTarget, PaneZoomMode, PaneZoomParams, + PaneZoomReason, PaneZoomResult, ReadFormat, ReadSource, ResponseResult, }; +use crate::app::actions::{PaneZoomCommand, PaneZoomNoopReason}; use crate::app::{App, Mode}; use crate::layout::{find_in_direction, NavDirection, PaneId}; @@ -517,6 +518,57 @@ impl App { ) } + pub(super) fn handle_pane_zoom(&mut self, id: String, params: PaneZoomParams) -> String { + let Some((ws_idx, pane_id)) = self.resolve_optional_pane(params.pane_id.as_deref()) else { + return encode_error(id, "pane_not_found", "pane not found"); + }; + let Some(tab_idx) = self.state.workspaces[ws_idx].find_tab_index_for_pane(pane_id) else { + return pane_not_found( + id, + &self.public_pane_id(ws_idx, pane_id).unwrap_or_default(), + ); + }; + let Some(pane_public_id) = self.public_pane_id(ws_idx, pane_id) else { + return encode_error(id, "pane_not_found", "pane not found"); + }; + let command = match params.mode { + PaneZoomMode::Toggle => PaneZoomCommand::Toggle, + PaneZoomMode::On => PaneZoomCommand::On, + PaneZoomMode::Off => PaneZoomCommand::Off, + }; + let Some(outcome) = self.state.apply_pane_zoom(ws_idx, pane_id, command) else { + return pane_not_found(id, &pane_public_id); + }; + if outcome.changed || outcome.focus_changed { + self.schedule_session_save(); + } + self.state.mode = Mode::Terminal; + let Some(layout) = self.pane_layout_snapshot(ws_idx, tab_idx) else { + return encode_error(id, "pane_layout_unavailable", "pane layout unavailable"); + }; + let focused_pane_id = layout.focused_pane_id.clone(); + + encode_success( + id, + ResponseResult::PaneZoom { + zoom: PaneZoomResult { + changed: outcome.changed || outcome.focus_changed, + zoom_changed: outcome.changed, + focus_changed: outcome.focus_changed, + reason: outcome.reason.map(|reason| match reason { + PaneZoomNoopReason::SinglePane => PaneZoomReason::SinglePane, + PaneZoomNoopReason::AlreadyZoomed => PaneZoomReason::AlreadyZoomed, + PaneZoomNoopReason::AlreadyUnzoomed => PaneZoomReason::AlreadyUnzoomed, + }), + pane_id: pane_public_id, + focused_pane_id, + zoomed: outcome.zoomed, + layout, + }, + }, + ) + } + pub(super) fn handle_pane_rename(&mut self, id: String, params: PaneRenameParams) -> String { let Some((ws_idx, pane_id)) = self.parse_pane_id(¶ms.pane_id) else { return pane_not_found(id, ¶ms.pane_id); @@ -1281,6 +1333,240 @@ mod tests { } #[test] + fn api_pane_zoom_current_toggles_zoom() { + let mut app = app_with_linked_worktree(); + app.state.active = Some(0); + app.state.selected = 0; + let root = app.state.workspaces[0].tabs[0].root_pane; + let _right = app.state.workspaces[0].test_split(ratatui::layout::Direction::Horizontal); + app.state.workspaces[0].tabs[0].layout.focus_pane(root); + let root_public = app.public_pane_id(0, root).unwrap(); + + let response = app.handle_pane_zoom("req".into(), PaneZoomParams::default()); + + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(zoom.changed); + assert!(zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert_eq!(zoom.reason, None); + assert_eq!(zoom.pane_id, root_public); + assert_eq!(zoom.focused_pane_id, zoom.pane_id); + assert!(zoom.zoomed); + assert!(zoom.layout.zoomed); + + let response = app.handle_pane_zoom("req".into(), PaneZoomParams::default()); + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(zoom.changed); + assert!(zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert!(!zoom.zoomed); + assert!(!zoom.layout.zoomed); + } + + #[test] + fn api_pane_zoom_explicit_background_pane_updates_focus_history() { + let mut app = app_with_linked_worktree(); + app.state.workspaces.push(Workspace::test_new("other")); + let first = app.state.workspaces[0].tabs[0].root_pane; + let target = app.state.workspaces[1].tabs[0].root_pane; + let _other = app.state.workspaces[1].test_split(ratatui::layout::Direction::Horizontal); + app.state.active = Some(0); + app.state.selected = 0; + app.state.workspaces[0].tabs[0].layout.focus_pane(first); + let target_public = app.public_pane_id(1, target).unwrap(); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: Some(target_public.clone()), + mode: PaneZoomMode::On, + }, + ); + + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(zoom.changed); + assert!(zoom.zoom_changed); + assert!(zoom.focus_changed); + assert_eq!(zoom.pane_id, target_public); + assert_eq!(app.state.active, Some(1)); + assert_eq!(app.state.workspaces[1].focused_pane_id(), Some(target)); + assert!(app.state.workspaces[1].tabs[0].zoomed); + + app.state.last_pane(); + + assert_eq!(app.state.active, Some(0)); + assert_eq!(app.state.workspaces[0].focused_pane_id(), Some(first)); + } + + #[test] + fn api_pane_zoom_single_pane_returns_noop() { + let mut app = app_with_linked_worktree(); + app.state.active = Some(0); + app.state.selected = 0; + let root = app.state.workspaces[0].tabs[0].root_pane; + let root_public = app.public_pane_id(0, root).unwrap(); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: Some(root_public.clone()), + mode: PaneZoomMode::Toggle, + }, + ); + + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(!zoom.changed); + assert!(!zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert_eq!(zoom.reason, Some(PaneZoomReason::SinglePane)); + assert_eq!(zoom.pane_id, root_public); + assert!(!zoom.zoomed); + assert!(!app.state.workspaces[0].tabs[0].zoomed); + } + + #[test] + fn api_pane_zoom_on_and_off_are_idempotent() { + let mut app = app_with_linked_worktree(); + app.state.active = Some(0); + app.state.selected = 0; + let root = app.state.workspaces[0].tabs[0].root_pane; + let _right = app.state.workspaces[0].test_split(ratatui::layout::Direction::Horizontal); + app.state.workspaces[0].tabs[0].layout.focus_pane(root); + let root_public = app.public_pane_id(0, root).unwrap(); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: Some(root_public.clone()), + mode: PaneZoomMode::On, + }, + ); + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(zoom.changed); + assert!(zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert!(zoom.zoomed); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: Some(root_public.clone()), + mode: PaneZoomMode::On, + }, + ); + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(!zoom.changed); + assert!(!zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert_eq!(zoom.reason, Some(PaneZoomReason::AlreadyZoomed)); + assert!(zoom.zoomed); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: Some(root_public), + mode: PaneZoomMode::Off, + }, + ); + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(zoom.changed); + assert!(zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert!(!zoom.zoomed); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: None, + mode: PaneZoomMode::Off, + }, + ); + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(!zoom.changed); + assert!(!zoom.zoom_changed); + assert!(!zoom.focus_changed); + assert_eq!(zoom.reason, Some(PaneZoomReason::AlreadyUnzoomed)); + assert!(!zoom.zoomed); + } + + #[test] + fn api_pane_zoom_idempotent_mode_reports_focus_change() { + let mut app = app_with_linked_worktree(); + app.state.active = Some(0); + app.state.selected = 0; + let root = app.state.workspaces[0].tabs[0].root_pane; + let right = app.state.workspaces[0].test_split(ratatui::layout::Direction::Horizontal); + app.state.workspaces[0].tabs[0].layout.focus_pane(root); + app.state.workspaces[0].tabs[0].zoomed = true; + let right_public = app.public_pane_id(0, right).unwrap(); + + let response = app.handle_pane_zoom( + "req".into(), + PaneZoomParams { + pane_id: Some(right_public), + mode: PaneZoomMode::On, + }, + ); + + let success: SuccessResponse = serde_json::from_str(&response).unwrap(); + let ResponseResult::PaneZoom { zoom } = success.result else { + panic!("expected pane zoom response"); + }; + assert!(zoom.changed); + assert!(!zoom.zoom_changed); + assert!(zoom.focus_changed); + assert_eq!(zoom.reason, Some(PaneZoomReason::AlreadyZoomed)); + assert!(zoom.zoomed); + assert_eq!(app.state.workspaces[0].focused_pane_id(), Some(right)); + } + + #[test] + fn api_pane_zoom_params_serialize_modes() { + let request = crate::api::schema::Request { + id: "req".into(), + method: crate::api::schema::Method::PaneZoom(PaneZoomParams { + pane_id: Some("issue-1".into()), + mode: PaneZoomMode::On, + }), + }; + + let encoded = serde_json::to_string(&request).unwrap(); + assert!(encoded.contains("\"method\":\"pane.zoom\"")); + assert!(encoded.contains("\"mode\":\"on\"")); + + let decoded: crate::api::schema::Request = serde_json::from_str(&encoded).unwrap(); + let crate::api::schema::Method::PaneZoom(params) = decoded.method else { + panic!("expected pane zoom request"); + }; + assert_eq!(params.pane_id, Some("issue-1".into())); + assert_eq!(params.mode, PaneZoomMode::On); + } + + #[test] fn api_pane_layout_returns_public_ids_rects_and_splits() { let mut app = app_with_linked_worktree(); let root = app.state.workspaces[0].tabs[0].root_pane; |