1use std::{cmp, ops::ControlFlow, path::PathBuf, process::ExitStatus, sync::Arc, time::Duration};
2
3use crate::{
4 TerminalView, default_working_directory,
5 persistence::{
6 SerializedItems, SerializedTerminalPanel, deserialize_terminal_panel, serialize_pane_group,
7 },
8};
9use breadcrumbs::Breadcrumbs;
10use collections::HashMap;
11use db::kvp::KEY_VALUE_STORE;
12use futures::{channel::oneshot, future::join_all};
13use gpui::{
14 Action, AnyView, App, AsyncApp, AsyncWindowContext, Context, Corner, Entity, EventEmitter,
15 ExternalPaths, FocusHandle, Focusable, IntoElement, ParentElement, Pixels, Render, Styled,
16 Task, WeakEntity, Window, actions,
17};
18use itertools::Itertools;
19use project::{Fs, Project, ProjectEntryId};
20use search::{BufferSearchBar, buffer_search::DivRegistrar};
21use settings::{Settings, TerminalDockPosition};
22use task::{RevealStrategy, RevealTarget, Shell, ShellBuilder, SpawnInTerminal, TaskId};
23use terminal::{Terminal, terminal_settings::TerminalSettings};
24use ui::{
25 ButtonLike, Clickable, ContextMenu, FluentBuilder, PopoverMenu, SplitButton, Toggleable,
26 Tooltip, prelude::*,
27};
28use util::{ResultExt, TryFutureExt};
29use workspace::{
30 ActivateNextPane, ActivatePane, ActivatePaneDown, ActivatePaneLeft, ActivatePaneRight,
31 ActivatePaneUp, ActivatePreviousPane, DraggedSelection, DraggedTab, ItemId, MoveItemToPane,
32 MoveItemToPaneInDirection, MovePaneDown, MovePaneLeft, MovePaneRight, MovePaneUp, NewTerminal,
33 Pane, PaneGroup, SplitDirection, SplitDown, SplitLeft, SplitRight, SplitUp, SwapPaneDown,
34 SwapPaneLeft, SwapPaneRight, SwapPaneUp, ToggleZoom, Workspace,
35 dock::{DockPosition, Panel, PanelEvent, PanelHandle},
36 item::SerializableItem,
37 move_active_item, move_item, pane,
38};
39
40use anyhow::{Result, anyhow};
41use zed_actions::assistant::InlineAssist;
42
43const TERMINAL_PANEL_KEY: &str = "TerminalPanel";
44
45actions!(
46 terminal_panel,
47 [
48 /// Toggles the terminal panel.
49 Toggle,
50 /// Toggles focus on the terminal panel.
51 ToggleFocus
52 ]
53);
54
55pub fn init(cx: &mut App) {
56 cx.observe_new(
57 |workspace: &mut Workspace, _window, _: &mut Context<Workspace>| {
58 workspace.register_action(TerminalPanel::new_terminal);
59 workspace.register_action(TerminalPanel::open_terminal);
60 workspace.register_action(|workspace, _: &ToggleFocus, window, cx| {
61 if is_enabled_in_workspace(workspace, cx) {
62 workspace.toggle_panel_focus::<TerminalPanel>(window, cx);
63 }
64 });
65 workspace.register_action(|workspace, _: &Toggle, window, cx| {
66 if is_enabled_in_workspace(workspace, cx) {
67 if !workspace.toggle_panel_focus::<TerminalPanel>(window, cx) {
68 workspace.close_panel::<TerminalPanel>(window, cx);
69 }
70 }
71 });
72 },
73 )
74 .detach();
75}
76
77pub struct TerminalPanel {
78 pub(crate) active_pane: Entity<Pane>,
79 pub(crate) center: PaneGroup,
80 fs: Arc<dyn Fs>,
81 workspace: WeakEntity<Workspace>,
82 pub(crate) width: Option<Pixels>,
83 pub(crate) height: Option<Pixels>,
84 pending_serialization: Task<Option<()>>,
85 pending_terminals_to_add: usize,
86 deferred_tasks: HashMap<TaskId, Task<()>>,
87 assistant_enabled: bool,
88 assistant_tab_bar_button: Option<AnyView>,
89 active: bool,
90}
91
92impl TerminalPanel {
93 pub fn new(workspace: &Workspace, window: &mut Window, cx: &mut Context<Self>) -> Self {
94 let project = workspace.project();
95 let pane = new_terminal_pane(workspace.weak_handle(), project.clone(), false, window, cx);
96 let center = PaneGroup::new(pane.clone());
97 let terminal_panel = Self {
98 center,
99 active_pane: pane,
100 fs: workspace.app_state().fs.clone(),
101 workspace: workspace.weak_handle(),
102 pending_serialization: Task::ready(None),
103 width: None,
104 height: None,
105 pending_terminals_to_add: 0,
106 deferred_tasks: HashMap::default(),
107 assistant_enabled: false,
108 assistant_tab_bar_button: None,
109 active: false,
110 };
111 terminal_panel.apply_tab_bar_buttons(&terminal_panel.active_pane, cx);
112 terminal_panel
113 }
114
115 pub fn set_assistant_enabled(&mut self, enabled: bool, cx: &mut Context<Self>) {
116 self.assistant_enabled = enabled;
117 if enabled {
118 let focus_handle = self
119 .active_pane
120 .read(cx)
121 .active_item()
122 .map(|item| item.item_focus_handle(cx))
123 .unwrap_or(self.focus_handle(cx));
124 self.assistant_tab_bar_button = Some(
125 cx.new(move |_| InlineAssistTabBarButton { focus_handle })
126 .into(),
127 );
128 } else {
129 self.assistant_tab_bar_button = None;
130 }
131 for pane in self.center.panes() {
132 self.apply_tab_bar_buttons(pane, cx);
133 }
134 }
135
136 fn apply_tab_bar_buttons(&self, terminal_pane: &Entity<Pane>, cx: &mut Context<Self>) {
137 let assistant_tab_bar_button = self.assistant_tab_bar_button.clone();
138 terminal_pane.update(cx, |pane, cx| {
139 pane.set_render_tab_bar_buttons(cx, move |pane, window, cx| {
140 let split_context = pane
141 .active_item()
142 .and_then(|item| item.downcast::<TerminalView>())
143 .map(|terminal_view| terminal_view.read(cx).focus_handle.clone());
144 if !pane.has_focus(window, cx) && !pane.context_menu_focused(window, cx) {
145 return (None, None);
146 }
147 let focus_handle = pane.focus_handle(cx);
148 let right_children = h_flex()
149 .gap(DynamicSpacing::Base02.rems(cx))
150 .child(
151 PopoverMenu::new("terminal-tab-bar-popover-menu")
152 .trigger_with_tooltip(
153 IconButton::new("plus", IconName::Plus).icon_size(IconSize::Small),
154 Tooltip::text("New…"),
155 )
156 .anchor(Corner::TopRight)
157 .with_handle(pane.new_item_context_menu_handle.clone())
158 .menu(move |window, cx| {
159 let focus_handle = focus_handle.clone();
160 let menu = ContextMenu::build(window, cx, |menu, _, _| {
161 menu.context(focus_handle.clone())
162 .action(
163 "New Terminal",
164 workspace::NewTerminal.boxed_clone(),
165 )
166 // We want the focus to go back to terminal panel once task modal is dismissed,
167 // hence we focus that first. Otherwise, we'd end up without a focused element, as
168 // context menu will be gone the moment we spawn the modal.
169 .action(
170 "Spawn task",
171 zed_actions::Spawn::modal().boxed_clone(),
172 )
173 });
174
175 Some(menu)
176 }),
177 )
178 .children(assistant_tab_bar_button.clone())
179 .child(
180 PopoverMenu::new("terminal-pane-tab-bar-split")
181 .trigger_with_tooltip(
182 IconButton::new("terminal-pane-split", IconName::Split)
183 .icon_size(IconSize::Small),
184 Tooltip::text("Split Pane"),
185 )
186 .anchor(Corner::TopRight)
187 .with_handle(pane.split_item_context_menu_handle.clone())
188 .menu({
189 move |window, cx| {
190 ContextMenu::build(window, cx, |menu, _, _| {
191 menu.when_some(
192 split_context.clone(),
193 |menu, split_context| menu.context(split_context),
194 )
195 .action("Split Right", SplitRight.boxed_clone())
196 .action("Split Left", SplitLeft.boxed_clone())
197 .action("Split Up", SplitUp.boxed_clone())
198 .action("Split Down", SplitDown.boxed_clone())
199 })
200 .into()
201 }
202 }),
203 )
204 .child({
205 let zoomed = pane.is_zoomed();
206 IconButton::new("toggle_zoom", IconName::Maximize)
207 .icon_size(IconSize::Small)
208 .toggle_state(zoomed)
209 .selected_icon(IconName::Minimize)
210 .on_click(cx.listener(|pane, _, window, cx| {
211 pane.toggle_zoom(&workspace::ToggleZoom, window, cx);
212 }))
213 .tooltip(move |window, cx| {
214 Tooltip::for_action(
215 if zoomed { "Zoom Out" } else { "Zoom In" },
216 &ToggleZoom,
217 window,
218 cx,
219 )
220 })
221 })
222 .into_any_element()
223 .into();
224 (None, right_children)
225 });
226 });
227 }
228
229 fn serialization_key(workspace: &Workspace) -> Option<String> {
230 workspace
231 .database_id()
232 .map(|id| i64::from(id).to_string())
233 .or(workspace.session_id())
234 .map(|id| format!("{:?}-{:?}", TERMINAL_PANEL_KEY, id))
235 }
236
237 pub async fn load(
238 workspace: WeakEntity<Workspace>,
239 mut cx: AsyncWindowContext,
240 ) -> Result<Entity<Self>> {
241 let mut terminal_panel = None;
242
243 if let Some((database_id, serialization_key)) = workspace
244 .read_with(&cx, |workspace, _| {
245 workspace
246 .database_id()
247 .zip(TerminalPanel::serialization_key(workspace))
248 })
249 .ok()
250 .flatten()
251 && let Some(serialized_panel) = cx
252 .background_spawn(async move { KEY_VALUE_STORE.read_kvp(&serialization_key) })
253 .await
254 .log_err()
255 .flatten()
256 .map(|panel| serde_json::from_str::<SerializedTerminalPanel>(&panel))
257 .transpose()
258 .log_err()
259 .flatten()
260 && let Ok(serialized) = workspace
261 .update_in(&mut cx, |workspace, window, cx| {
262 deserialize_terminal_panel(
263 workspace.weak_handle(),
264 workspace.project().clone(),
265 database_id,
266 serialized_panel,
267 window,
268 cx,
269 )
270 })?
271 .await
272 {
273 terminal_panel = Some(serialized);
274 }
275
276 let terminal_panel = if let Some(panel) = terminal_panel {
277 panel
278 } else {
279 workspace.update_in(&mut cx, |workspace, window, cx| {
280 cx.new(|cx| TerminalPanel::new(workspace, window, cx))
281 })?
282 };
283
284 if let Some(workspace) = workspace.upgrade() {
285 workspace
286 .update(&mut cx, |workspace, _| {
287 workspace.set_terminal_provider(TerminalProvider(terminal_panel.clone()))
288 })
289 .ok();
290 }
291
292 // Since panels/docks are loaded outside from the workspace, we cleanup here, instead of through the workspace.
293 if let Some(workspace) = workspace.upgrade() {
294 let cleanup_task = workspace.update_in(&mut cx, |workspace, window, cx| {
295 let alive_item_ids = terminal_panel
296 .read(cx)
297 .center
298 .panes()
299 .into_iter()
300 .flat_map(|pane| pane.read(cx).items())
301 .map(|item| item.item_id().as_u64() as ItemId)
302 .collect();
303 workspace.database_id().map(|workspace_id| {
304 TerminalView::cleanup(workspace_id, alive_item_ids, window, cx)
305 })
306 })?;
307 if let Some(task) = cleanup_task {
308 task.await.log_err();
309 }
310 }
311
312 if let Some(workspace) = workspace.upgrade() {
313 let should_focus = workspace
314 .update_in(&mut cx, |workspace, window, cx| {
315 workspace.active_item(cx).is_none()
316 && workspace
317 .is_dock_at_position_open(terminal_panel.position(window, cx), cx)
318 })
319 .unwrap_or(false);
320
321 if should_focus {
322 terminal_panel
323 .update_in(&mut cx, |panel, window, cx| {
324 panel.active_pane.update(cx, |pane, cx| {
325 pane.focus_active_item(window, cx);
326 });
327 })
328 .ok();
329 }
330 }
331 Ok(terminal_panel)
332 }
333
334 fn handle_pane_event(
335 &mut self,
336 pane: &Entity<Pane>,
337 event: &pane::Event,
338 window: &mut Window,
339 cx: &mut Context<Self>,
340 ) {
341 match event {
342 pane::Event::ActivateItem { .. } => self.serialize(cx),
343 pane::Event::RemovedItem { .. } => self.serialize(cx),
344 pane::Event::Remove { focus_on_pane } => {
345 let pane_count_before_removal = self.center.panes().len();
346 let _removal_result = self.center.remove(pane);
347 if pane_count_before_removal == 1 {
348 self.center.first_pane().update(cx, |pane, cx| {
349 pane.set_zoomed(false, cx);
350 });
351 cx.emit(PanelEvent::Close);
352 } else if let Some(focus_on_pane) =
353 focus_on_pane.as_ref().or_else(|| self.center.panes().pop())
354 {
355 focus_on_pane.focus_handle(cx).focus(window);
356 }
357 }
358 pane::Event::ZoomIn => {
359 for pane in self.center.panes() {
360 pane.update(cx, |pane, cx| {
361 pane.set_zoomed(true, cx);
362 })
363 }
364 cx.emit(PanelEvent::ZoomIn);
365 cx.notify();
366 }
367 pane::Event::ZoomOut => {
368 for pane in self.center.panes() {
369 pane.update(cx, |pane, cx| {
370 pane.set_zoomed(false, cx);
371 })
372 }
373 cx.emit(PanelEvent::ZoomOut);
374 cx.notify();
375 }
376 pane::Event::AddItem { item } => {
377 if let Some(workspace) = self.workspace.upgrade() {
378 workspace.update(cx, |workspace, cx| {
379 item.added_to_pane(workspace, pane.clone(), window, cx)
380 })
381 }
382 self.serialize(cx);
383 }
384 &pane::Event::Split {
385 direction,
386 clone_active_item,
387 } => {
388 if clone_active_item {
389 let fut = self.new_pane_with_cloned_active_terminal(window, cx);
390 let pane = pane.clone();
391 cx.spawn_in(window, async move |panel, cx| {
392 let Some(new_pane) = fut.await else {
393 return;
394 };
395 panel
396 .update_in(cx, |panel, window, cx| {
397 panel.center.split(&pane, &new_pane, direction).log_err();
398 window.focus(&new_pane.focus_handle(cx));
399 })
400 .ok();
401 })
402 .detach();
403 } else {
404 let Some(item) = pane.update(cx, |pane, cx| pane.take_active_item(window, cx))
405 else {
406 return;
407 };
408 let Ok(project) = self
409 .workspace
410 .update(cx, |workspace, _| workspace.project().clone())
411 else {
412 return;
413 };
414 let new_pane =
415 new_terminal_pane(self.workspace.clone(), project, false, window, cx);
416 new_pane.update(cx, |pane, cx| {
417 pane.add_item(item, true, true, None, window, cx);
418 });
419 self.center.split(&pane, &new_pane, direction).log_err();
420 window.focus(&new_pane.focus_handle(cx));
421 }
422 }
423 pane::Event::Focus => {
424 self.active_pane = pane.clone();
425 }
426 pane::Event::ItemPinned | pane::Event::ItemUnpinned => {
427 self.serialize(cx);
428 }
429
430 _ => {}
431 }
432 }
433
434 fn new_pane_with_cloned_active_terminal(
435 &mut self,
436 window: &mut Window,
437 cx: &mut Context<Self>,
438 ) -> Task<Option<Entity<Pane>>> {
439 let Some(workspace) = self.workspace.upgrade() else {
440 return Task::ready(None);
441 };
442 let workspace = workspace.read(cx);
443 let database_id = workspace.database_id();
444 let weak_workspace = self.workspace.clone();
445 let project = workspace.project().clone();
446 let active_pane = &self.active_pane;
447 let terminal_view = active_pane
448 .read(cx)
449 .active_item()
450 .and_then(|item| item.downcast::<TerminalView>());
451 let working_directory = terminal_view
452 .as_ref()
453 .and_then(|terminal_view| {
454 terminal_view
455 .read(cx)
456 .terminal()
457 .read(cx)
458 .working_directory()
459 })
460 .or_else(|| default_working_directory(workspace, cx));
461 let is_zoomed = active_pane.read(cx).is_zoomed();
462 cx.spawn_in(window, async move |panel, cx| {
463 let terminal = project
464 .update(cx, |project, cx| match terminal_view {
465 Some(view) => Task::ready(project.clone_terminal(
466 &view.read(cx).terminal.clone(),
467 cx,
468 working_directory,
469 )),
470 None => project.create_terminal_shell(working_directory, cx),
471 })
472 .ok()?
473 .await
474 .log_err()?;
475
476 panel
477 .update_in(cx, move |terminal_panel, window, cx| {
478 let terminal_view = Box::new(cx.new(|cx| {
479 TerminalView::new(
480 terminal.clone(),
481 weak_workspace.clone(),
482 database_id,
483 project.downgrade(),
484 window,
485 cx,
486 )
487 }));
488 let pane = new_terminal_pane(weak_workspace, project, is_zoomed, window, cx);
489 terminal_panel.apply_tab_bar_buttons(&pane, cx);
490 pane.update(cx, |pane, cx| {
491 pane.add_item(terminal_view, true, true, None, window, cx);
492 });
493 Some(pane)
494 })
495 .ok()
496 .flatten()
497 })
498 }
499
500 pub fn open_terminal(
501 workspace: &mut Workspace,
502 action: &workspace::OpenTerminal,
503 window: &mut Window,
504 cx: &mut Context<Workspace>,
505 ) {
506 let Some(terminal_panel) = workspace.panel::<Self>(cx) else {
507 return;
508 };
509
510 terminal_panel
511 .update(cx, |panel, cx| {
512 panel.add_terminal_shell(
513 Some(action.working_directory.clone()),
514 RevealStrategy::Always,
515 window,
516 cx,
517 )
518 })
519 .detach_and_log_err(cx);
520 }
521
522 pub fn spawn_task(
523 &mut self,
524 task: &SpawnInTerminal,
525 window: &mut Window,
526 cx: &mut Context<Self>,
527 ) -> Task<Result<WeakEntity<Terminal>>> {
528 let Some(workspace) = self.workspace.upgrade() else {
529 return Task::ready(Err(anyhow!("failed to read workspace")));
530 };
531
532 let project = workspace.read(cx).project().read(cx);
533
534 if project.is_via_collab() {
535 return Task::ready(Err(anyhow!("cannot spawn tasks as a guest")));
536 }
537
538 let remote_client = project.remote_client();
539 let is_windows = project.path_style(cx).is_windows();
540 let remote_shell = remote_client
541 .as_ref()
542 .and_then(|remote_client| remote_client.read(cx).shell());
543
544 let shell = if let Some(remote_shell) = remote_shell
545 && task.shell == Shell::System
546 {
547 Shell::Program(remote_shell)
548 } else {
549 task.shell.clone()
550 };
551
552 let builder = ShellBuilder::new(&shell, is_windows);
553 let command_label = builder.command_label(task.command.as_deref().unwrap_or(""));
554 let (command, args) = builder.build(task.command.clone(), &task.args);
555
556 let task = SpawnInTerminal {
557 command_label,
558 command: Some(command),
559 args,
560 ..task.clone()
561 };
562
563 if task.allow_concurrent_runs && task.use_new_terminal {
564 return self.spawn_in_new_terminal(task, window, cx);
565 }
566
567 let mut terminals_for_task = self.terminals_for_task(&task.full_label, cx);
568 let Some(existing) = terminals_for_task.pop() else {
569 return self.spawn_in_new_terminal(task, window, cx);
570 };
571
572 let (existing_item_index, task_pane, existing_terminal) = existing;
573 if task.allow_concurrent_runs {
574 return self.replace_terminal(
575 task,
576 task_pane,
577 existing_item_index,
578 existing_terminal,
579 window,
580 cx,
581 );
582 }
583
584 let (tx, rx) = oneshot::channel();
585
586 self.deferred_tasks.insert(
587 task.id.clone(),
588 cx.spawn_in(window, async move |terminal_panel, cx| {
589 wait_for_terminals_tasks(terminals_for_task, cx).await;
590 let task = terminal_panel.update_in(cx, |terminal_panel, window, cx| {
591 if task.use_new_terminal {
592 terminal_panel.spawn_in_new_terminal(task, window, cx)
593 } else {
594 terminal_panel.replace_terminal(
595 task,
596 task_pane,
597 existing_item_index,
598 existing_terminal,
599 window,
600 cx,
601 )
602 }
603 });
604 if let Ok(task) = task {
605 tx.send(task.await).ok();
606 }
607 }),
608 );
609
610 cx.spawn(async move |_, _| rx.await?)
611 }
612
613 fn spawn_in_new_terminal(
614 &mut self,
615 spawn_task: SpawnInTerminal,
616 window: &mut Window,
617 cx: &mut Context<Self>,
618 ) -> Task<Result<WeakEntity<Terminal>>> {
619 let reveal = spawn_task.reveal;
620 let reveal_target = spawn_task.reveal_target;
621 match reveal_target {
622 RevealTarget::Center => self
623 .workspace
624 .update(cx, |workspace, cx| {
625 Self::add_center_terminal(workspace, window, cx, |project, cx| {
626 project.create_terminal_task(spawn_task, cx)
627 })
628 })
629 .unwrap_or_else(|e| Task::ready(Err(e))),
630 RevealTarget::Dock => self.add_terminal_task(spawn_task, reveal, window, cx),
631 }
632 }
633
634 /// Create a new Terminal in the current working directory or the user's home directory
635 fn new_terminal(
636 workspace: &mut Workspace,
637 _: &workspace::NewTerminal,
638 window: &mut Window,
639 cx: &mut Context<Workspace>,
640 ) {
641 let Some(terminal_panel) = workspace.panel::<Self>(cx) else {
642 return;
643 };
644
645 terminal_panel
646 .update(cx, |this, cx| {
647 this.add_terminal_shell(
648 default_working_directory(workspace, cx),
649 RevealStrategy::Always,
650 window,
651 cx,
652 )
653 })
654 .detach_and_log_err(cx);
655 }
656
657 fn terminals_for_task(
658 &self,
659 label: &str,
660 cx: &mut App,
661 ) -> Vec<(usize, Entity<Pane>, Entity<TerminalView>)> {
662 let Some(workspace) = self.workspace.upgrade() else {
663 return Vec::new();
664 };
665
666 let pane_terminal_views = |pane: Entity<Pane>| {
667 pane.read(cx)
668 .items()
669 .enumerate()
670 .filter_map(|(index, item)| Some((index, item.act_as::<TerminalView>(cx)?)))
671 .filter_map(|(index, terminal_view)| {
672 let task_state = terminal_view.read(cx).terminal().read(cx).task()?;
673 if &task_state.spawned_task.full_label == label {
674 Some((index, terminal_view))
675 } else {
676 None
677 }
678 })
679 .map(move |(index, terminal_view)| (index, pane.clone(), terminal_view))
680 };
681
682 self.center
683 .panes()
684 .into_iter()
685 .cloned()
686 .flat_map(pane_terminal_views)
687 .chain(
688 workspace
689 .read(cx)
690 .panes()
691 .iter()
692 .cloned()
693 .flat_map(pane_terminal_views),
694 )
695 .sorted_by_key(|(_, _, terminal_view)| terminal_view.entity_id())
696 .collect()
697 }
698
699 fn activate_terminal_view(
700 &self,
701 pane: &Entity<Pane>,
702 item_index: usize,
703 focus: bool,
704 window: &mut Window,
705 cx: &mut App,
706 ) {
707 pane.update(cx, |pane, cx| {
708 pane.activate_item(item_index, true, focus, window, cx)
709 })
710 }
711
712 pub fn add_center_terminal(
713 workspace: &mut Workspace,
714 window: &mut Window,
715 cx: &mut Context<Workspace>,
716 create_terminal: impl FnOnce(
717 &mut Project,
718 &mut Context<Project>,
719 ) -> Task<Result<Entity<Terminal>>>
720 + 'static,
721 ) -> Task<Result<WeakEntity<Terminal>>> {
722 if !is_enabled_in_workspace(workspace, cx) {
723 return Task::ready(Err(anyhow!(
724 "terminal not yet supported for remote projects"
725 )));
726 }
727 let project = workspace.project().downgrade();
728 cx.spawn_in(window, async move |workspace, cx| {
729 let terminal = project.update(cx, create_terminal)?.await?;
730
731 workspace.update_in(cx, |workspace, window, cx| {
732 let terminal_view = cx.new(|cx| {
733 TerminalView::new(
734 terminal.clone(),
735 workspace.weak_handle(),
736 workspace.database_id(),
737 workspace.project().downgrade(),
738 window,
739 cx,
740 )
741 });
742 workspace.add_item_to_active_pane(Box::new(terminal_view), None, true, window, cx);
743 })?;
744 Ok(terminal.downgrade())
745 })
746 }
747
748 pub fn add_terminal_task(
749 &mut self,
750 task: SpawnInTerminal,
751 reveal_strategy: RevealStrategy,
752 window: &mut Window,
753 cx: &mut Context<Self>,
754 ) -> Task<Result<WeakEntity<Terminal>>> {
755 let workspace = self.workspace.clone();
756 cx.spawn_in(window, async move |terminal_panel, cx| {
757 if workspace.update(cx, |workspace, cx| !is_enabled_in_workspace(workspace, cx))? {
758 anyhow::bail!("terminal not yet supported for remote projects");
759 }
760 let pane = terminal_panel.update(cx, |terminal_panel, _| {
761 terminal_panel.pending_terminals_to_add += 1;
762 terminal_panel.active_pane.clone()
763 })?;
764 let project = workspace.read_with(cx, |workspace, _| workspace.project().clone())?;
765 let terminal = project
766 .update(cx, |project, cx| project.create_terminal_task(task, cx))?
767 .await?;
768 let result = workspace.update_in(cx, |workspace, window, cx| {
769 let terminal_view = Box::new(cx.new(|cx| {
770 TerminalView::new(
771 terminal.clone(),
772 workspace.weak_handle(),
773 workspace.database_id(),
774 workspace.project().downgrade(),
775 window,
776 cx,
777 )
778 }));
779
780 match reveal_strategy {
781 RevealStrategy::Always => {
782 workspace.focus_panel::<Self>(window, cx);
783 }
784 RevealStrategy::NoFocus => {
785 workspace.open_panel::<Self>(window, cx);
786 }
787 RevealStrategy::Never => {}
788 }
789
790 pane.update(cx, |pane, cx| {
791 let focus = pane.has_focus(window, cx)
792 || matches!(reveal_strategy, RevealStrategy::Always);
793 pane.add_item(terminal_view, true, focus, None, window, cx);
794 });
795
796 Ok(terminal.downgrade())
797 })?;
798 terminal_panel.update(cx, |terminal_panel, cx| {
799 terminal_panel.pending_terminals_to_add =
800 terminal_panel.pending_terminals_to_add.saturating_sub(1);
801 terminal_panel.serialize(cx)
802 })?;
803 result
804 })
805 }
806
807 fn add_terminal_shell(
808 &mut self,
809 cwd: Option<PathBuf>,
810 reveal_strategy: RevealStrategy,
811 window: &mut Window,
812 cx: &mut Context<Self>,
813 ) -> Task<Result<WeakEntity<Terminal>>> {
814 let workspace = self.workspace.clone();
815
816 cx.spawn_in(window, async move |terminal_panel, cx| {
817 if workspace.update(cx, |workspace, cx| !is_enabled_in_workspace(workspace, cx))? {
818 anyhow::bail!("terminal not yet supported for collaborative projects");
819 }
820 let pane = terminal_panel.update(cx, |terminal_panel, _| {
821 terminal_panel.pending_terminals_to_add += 1;
822 terminal_panel.active_pane.clone()
823 })?;
824 let project = workspace.read_with(cx, |workspace, _| workspace.project().clone())?;
825 let terminal = project
826 .update(cx, |project, cx| project.create_terminal_shell(cwd, cx))?
827 .await;
828
829 match terminal {
830 Ok(terminal) => {
831 let result = workspace.update_in(cx, |workspace, window, cx| {
832 let terminal_view = Box::new(cx.new(|cx| {
833 TerminalView::new(
834 terminal.clone(),
835 workspace.weak_handle(),
836 workspace.database_id(),
837 workspace.project().downgrade(),
838 window,
839 cx,
840 )
841 }));
842
843 match reveal_strategy {
844 RevealStrategy::Always => {
845 workspace.focus_panel::<Self>(window, cx);
846 }
847 RevealStrategy::NoFocus => {
848 workspace.open_panel::<Self>(window, cx);
849 }
850 RevealStrategy::Never => {}
851 }
852
853 pane.update(cx, |pane, cx| {
854 let focus = pane.has_focus(window, cx)
855 || matches!(reveal_strategy, RevealStrategy::Always);
856 pane.add_item(terminal_view, true, focus, None, window, cx);
857 });
858
859 Ok(terminal.downgrade())
860 })?;
861 terminal_panel.update(cx, |terminal_panel, cx| {
862 terminal_panel.pending_terminals_to_add =
863 terminal_panel.pending_terminals_to_add.saturating_sub(1);
864 terminal_panel.serialize(cx)
865 })?;
866 result
867 }
868 Err(error) => {
869 pane.update_in(cx, |pane, window, cx| {
870 let focus = pane.has_focus(window, cx);
871 let failed_to_spawn = cx.new(|cx| FailedToSpawnTerminal {
872 error: error.to_string(),
873 focus_handle: cx.focus_handle(),
874 });
875 pane.add_item(Box::new(failed_to_spawn), true, focus, None, window, cx);
876 })?;
877 Err(error)
878 }
879 }
880 })
881 }
882
883 fn serialize(&mut self, cx: &mut Context<Self>) {
884 let height = self.height;
885 let width = self.width;
886 let Some(serialization_key) = self
887 .workspace
888 .read_with(cx, |workspace, _| {
889 TerminalPanel::serialization_key(workspace)
890 })
891 .ok()
892 .flatten()
893 else {
894 return;
895 };
896 self.pending_serialization = cx.spawn(async move |terminal_panel, cx| {
897 cx.background_executor()
898 .timer(Duration::from_millis(50))
899 .await;
900 let terminal_panel = terminal_panel.upgrade()?;
901 let items = terminal_panel
902 .update(cx, |terminal_panel, cx| {
903 SerializedItems::WithSplits(serialize_pane_group(
904 &terminal_panel.center,
905 &terminal_panel.active_pane,
906 cx,
907 ))
908 })
909 .ok()?;
910 cx.background_spawn(
911 async move {
912 KEY_VALUE_STORE
913 .write_kvp(
914 serialization_key,
915 serde_json::to_string(&SerializedTerminalPanel {
916 items,
917 active_item_id: None,
918 height,
919 width,
920 })?,
921 )
922 .await?;
923 anyhow::Ok(())
924 }
925 .log_err(),
926 )
927 .await;
928 Some(())
929 });
930 }
931
932 fn replace_terminal(
933 &self,
934 spawn_task: SpawnInTerminal,
935 task_pane: Entity<Pane>,
936 terminal_item_index: usize,
937 terminal_to_replace: Entity<TerminalView>,
938 window: &mut Window,
939 cx: &mut Context<Self>,
940 ) -> Task<Result<WeakEntity<Terminal>>> {
941 let reveal = spawn_task.reveal;
942 let reveal_target = spawn_task.reveal_target;
943 let task_workspace = self.workspace.clone();
944 cx.spawn_in(window, async move |terminal_panel, cx| {
945 let project = terminal_panel.update(cx, |this, cx| {
946 this.workspace
947 .update(cx, |workspace, _| workspace.project().clone())
948 })??;
949 let new_terminal = project
950 .update(cx, |project, cx| {
951 project.create_terminal_task(spawn_task, cx)
952 })?
953 .await?;
954 terminal_to_replace.update_in(cx, |terminal_to_replace, window, cx| {
955 terminal_to_replace.set_terminal(new_terminal.clone(), window, cx);
956 })?;
957
958 match reveal {
959 RevealStrategy::Always => match reveal_target {
960 RevealTarget::Center => {
961 task_workspace.update_in(cx, |workspace, window, cx| {
962 let did_activate = workspace.activate_item(
963 &terminal_to_replace,
964 true,
965 true,
966 window,
967 cx,
968 );
969
970 anyhow::ensure!(did_activate, "Failed to retrieve terminal pane");
971
972 anyhow::Ok(())
973 })??;
974 }
975 RevealTarget::Dock => {
976 terminal_panel.update_in(cx, |terminal_panel, window, cx| {
977 terminal_panel.activate_terminal_view(
978 &task_pane,
979 terminal_item_index,
980 true,
981 window,
982 cx,
983 )
984 })?;
985
986 cx.spawn(async move |cx| {
987 task_workspace
988 .update_in(cx, |workspace, window, cx| {
989 workspace.focus_panel::<Self>(window, cx)
990 })
991 .ok()
992 })
993 .detach();
994 }
995 },
996 RevealStrategy::NoFocus => match reveal_target {
997 RevealTarget::Center => {
998 task_workspace.update_in(cx, |workspace, window, cx| {
999 workspace.active_pane().focus_handle(cx).focus(window);
1000 })?;
1001 }
1002 RevealTarget::Dock => {
1003 terminal_panel.update_in(cx, |terminal_panel, window, cx| {
1004 terminal_panel.activate_terminal_view(
1005 &task_pane,
1006 terminal_item_index,
1007 false,
1008 window,
1009 cx,
1010 )
1011 })?;
1012
1013 cx.spawn(async move |cx| {
1014 task_workspace
1015 .update_in(cx, |workspace, window, cx| {
1016 workspace.open_panel::<Self>(window, cx)
1017 })
1018 .ok()
1019 })
1020 .detach();
1021 }
1022 },
1023 RevealStrategy::Never => {}
1024 }
1025
1026 Ok(new_terminal.downgrade())
1027 })
1028 }
1029
1030 fn has_no_terminals(&self, cx: &App) -> bool {
1031 self.active_pane.read(cx).items_len() == 0 && self.pending_terminals_to_add == 0
1032 }
1033
1034 pub fn assistant_enabled(&self) -> bool {
1035 self.assistant_enabled
1036 }
1037
1038 fn is_enabled(&self, cx: &App) -> bool {
1039 self.workspace
1040 .upgrade()
1041 .is_some_and(|workspace| is_enabled_in_workspace(workspace.read(cx), cx))
1042 }
1043
1044 fn activate_pane_in_direction(
1045 &mut self,
1046 direction: SplitDirection,
1047 window: &mut Window,
1048 cx: &mut Context<Self>,
1049 ) {
1050 if let Some(pane) = self
1051 .center
1052 .find_pane_in_direction(&self.active_pane, direction, cx)
1053 {
1054 window.focus(&pane.focus_handle(cx));
1055 } else {
1056 self.workspace
1057 .update(cx, |workspace, cx| {
1058 workspace.activate_pane_in_direction(direction, window, cx)
1059 })
1060 .ok();
1061 }
1062 }
1063
1064 fn swap_pane_in_direction(&mut self, direction: SplitDirection, cx: &mut Context<Self>) {
1065 if let Some(to) = self
1066 .center
1067 .find_pane_in_direction(&self.active_pane, direction, cx)
1068 .cloned()
1069 {
1070 self.center.swap(&self.active_pane, &to);
1071 cx.notify();
1072 }
1073 }
1074
1075 fn move_pane_to_border(&mut self, direction: SplitDirection, cx: &mut Context<Self>) {
1076 if self
1077 .center
1078 .move_to_border(&self.active_pane, direction)
1079 .unwrap()
1080 {
1081 cx.notify();
1082 }
1083 }
1084}
1085
1086fn is_enabled_in_workspace(workspace: &Workspace, cx: &App) -> bool {
1087 workspace.project().read(cx).supports_terminal(cx)
1088}
1089
1090pub fn new_terminal_pane(
1091 workspace: WeakEntity<Workspace>,
1092 project: Entity<Project>,
1093 zoomed: bool,
1094 window: &mut Window,
1095 cx: &mut Context<TerminalPanel>,
1096) -> Entity<Pane> {
1097 let is_local = project.read(cx).is_local();
1098 let terminal_panel = cx.entity();
1099 let pane = cx.new(|cx| {
1100 let mut pane = Pane::new(
1101 workspace.clone(),
1102 project.clone(),
1103 Default::default(),
1104 None,
1105 NewTerminal.boxed_clone(),
1106 window,
1107 cx,
1108 );
1109 pane.set_zoomed(zoomed, cx);
1110 pane.set_can_navigate(false, cx);
1111 pane.display_nav_history_buttons(None);
1112 pane.set_should_display_tab_bar(|_, _| true);
1113 pane.set_zoom_out_on_close(false);
1114
1115 let split_closure_terminal_panel = terminal_panel.downgrade();
1116 pane.set_can_split(Some(Arc::new(move |pane, dragged_item, _window, cx| {
1117 if let Some(tab) = dragged_item.downcast_ref::<DraggedTab>() {
1118 let is_current_pane = tab.pane == cx.entity();
1119 let Some(can_drag_away) = split_closure_terminal_panel
1120 .read_with(cx, |terminal_panel, _| {
1121 let current_panes = terminal_panel.center.panes();
1122 !current_panes.contains(&&tab.pane)
1123 || current_panes.len() > 1
1124 || (!is_current_pane || pane.items_len() > 1)
1125 })
1126 .ok()
1127 else {
1128 return false;
1129 };
1130 if can_drag_away {
1131 let item = if is_current_pane {
1132 pane.item_for_index(tab.ix)
1133 } else {
1134 tab.pane.read(cx).item_for_index(tab.ix)
1135 };
1136 if let Some(item) = item {
1137 return item.downcast::<TerminalView>().is_some();
1138 }
1139 }
1140 }
1141 false
1142 })));
1143
1144 let buffer_search_bar = cx.new(|cx| {
1145 search::BufferSearchBar::new(Some(project.read(cx).languages().clone()), window, cx)
1146 });
1147 let breadcrumbs = cx.new(|_| Breadcrumbs::new());
1148 pane.toolbar().update(cx, |toolbar, cx| {
1149 toolbar.add_item(buffer_search_bar, window, cx);
1150 toolbar.add_item(breadcrumbs, window, cx);
1151 });
1152
1153 let drop_closure_project = project.downgrade();
1154 let drop_closure_terminal_panel = terminal_panel.downgrade();
1155 pane.set_custom_drop_handle(cx, move |pane, dropped_item, window, cx| {
1156 let Some(project) = drop_closure_project.upgrade() else {
1157 return ControlFlow::Break(());
1158 };
1159 if let Some(tab) = dropped_item.downcast_ref::<DraggedTab>() {
1160 let this_pane = cx.entity();
1161 let item = if tab.pane == this_pane {
1162 pane.item_for_index(tab.ix)
1163 } else {
1164 tab.pane.read(cx).item_for_index(tab.ix)
1165 };
1166 if let Some(item) = item {
1167 if item.downcast::<TerminalView>().is_some() {
1168 let source = tab.pane.clone();
1169 let item_id_to_move = item.item_id();
1170
1171 let Ok(new_split_pane) = pane
1172 .drag_split_direction()
1173 .map(|split_direction| {
1174 drop_closure_terminal_panel.update(cx, |terminal_panel, cx| {
1175 let is_zoomed = if terminal_panel.active_pane == this_pane {
1176 pane.is_zoomed()
1177 } else {
1178 terminal_panel.active_pane.read(cx).is_zoomed()
1179 };
1180 let new_pane = new_terminal_pane(
1181 workspace.clone(),
1182 project.clone(),
1183 is_zoomed,
1184 window,
1185 cx,
1186 );
1187 terminal_panel.apply_tab_bar_buttons(&new_pane, cx);
1188 terminal_panel.center.split(
1189 &this_pane,
1190 &new_pane,
1191 split_direction,
1192 )?;
1193 anyhow::Ok(new_pane)
1194 })
1195 })
1196 .transpose()
1197 else {
1198 return ControlFlow::Break(());
1199 };
1200
1201 match new_split_pane.transpose() {
1202 // Source pane may be the one currently updated, so defer the move.
1203 Ok(Some(new_pane)) => cx
1204 .spawn_in(window, async move |_, cx| {
1205 cx.update(|window, cx| {
1206 move_item(
1207 &source,
1208 &new_pane,
1209 item_id_to_move,
1210 new_pane.read(cx).active_item_index(),
1211 true,
1212 window,
1213 cx,
1214 );
1215 })
1216 .ok();
1217 })
1218 .detach(),
1219 // If we drop into existing pane or current pane,
1220 // regular pane drop handler will take care of it,
1221 // using the right tab index for the operation.
1222 Ok(None) => return ControlFlow::Continue(()),
1223 err @ Err(_) => {
1224 err.log_err();
1225 return ControlFlow::Break(());
1226 }
1227 };
1228 } else if let Some(project_path) = item.project_path(cx)
1229 && let Some(entry_path) = project.read(cx).absolute_path(&project_path, cx)
1230 {
1231 add_paths_to_terminal(pane, &[entry_path], window, cx);
1232 }
1233 }
1234 } else if let Some(selection) = dropped_item.downcast_ref::<DraggedSelection>() {
1235 let project = project.read(cx);
1236 let paths_to_add = selection
1237 .items()
1238 .map(|selected_entry| selected_entry.entry_id)
1239 .filter_map(|entry_id| project.path_for_entry(entry_id, cx))
1240 .filter_map(|project_path| project.absolute_path(&project_path, cx))
1241 .collect::<Vec<_>>();
1242 if !paths_to_add.is_empty() {
1243 add_paths_to_terminal(pane, &paths_to_add, window, cx);
1244 }
1245 } else if let Some(&entry_id) = dropped_item.downcast_ref::<ProjectEntryId>() {
1246 if let Some(entry_path) = project
1247 .read(cx)
1248 .path_for_entry(entry_id, cx)
1249 .and_then(|project_path| project.read(cx).absolute_path(&project_path, cx))
1250 {
1251 add_paths_to_terminal(pane, &[entry_path], window, cx);
1252 }
1253 } else if is_local && let Some(paths) = dropped_item.downcast_ref::<ExternalPaths>() {
1254 add_paths_to_terminal(pane, paths.paths(), window, cx);
1255 }
1256
1257 ControlFlow::Break(())
1258 });
1259
1260 pane
1261 });
1262
1263 cx.subscribe_in(&pane, window, TerminalPanel::handle_pane_event)
1264 .detach();
1265 cx.observe(&pane, |_, _, cx| cx.notify()).detach();
1266
1267 pane
1268}
1269
1270async fn wait_for_terminals_tasks(
1271 terminals_for_task: Vec<(usize, Entity<Pane>, Entity<TerminalView>)>,
1272 cx: &mut AsyncApp,
1273) {
1274 let pending_tasks = terminals_for_task.iter().filter_map(|(_, _, terminal)| {
1275 terminal
1276 .update(cx, |terminal_view, cx| {
1277 terminal_view
1278 .terminal()
1279 .update(cx, |terminal, cx| terminal.wait_for_completed_task(cx))
1280 })
1281 .ok()
1282 });
1283 join_all(pending_tasks).await;
1284}
1285
1286fn add_paths_to_terminal(
1287 pane: &mut Pane,
1288 paths: &[PathBuf],
1289 window: &mut Window,
1290 cx: &mut Context<Pane>,
1291) {
1292 if let Some(terminal_view) = pane
1293 .active_item()
1294 .and_then(|item| item.downcast::<TerminalView>())
1295 {
1296 window.focus(&terminal_view.focus_handle(cx));
1297 let mut new_text = paths.iter().map(|path| format!(" {path:?}")).join("");
1298 new_text.push(' ');
1299 terminal_view.update(cx, |terminal_view, cx| {
1300 terminal_view.terminal().update(cx, |terminal, _| {
1301 terminal.paste(&new_text);
1302 });
1303 });
1304 }
1305}
1306
1307struct FailedToSpawnTerminal {
1308 error: String,
1309 focus_handle: FocusHandle,
1310}
1311
1312impl Focusable for FailedToSpawnTerminal {
1313 fn focus_handle(&self, _: &App) -> FocusHandle {
1314 self.focus_handle.clone()
1315 }
1316}
1317
1318impl Render for FailedToSpawnTerminal {
1319 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1320 let popover_menu = PopoverMenu::new("settings-popover")
1321 .trigger(
1322 IconButton::new("icon-button-popover", IconName::ChevronDown)
1323 .icon_size(IconSize::XSmall),
1324 )
1325 .menu(move |window, cx| {
1326 Some(ContextMenu::build(window, cx, |context_menu, _, _| {
1327 context_menu
1328 .action("Open Settings", zed_actions::OpenSettings.boxed_clone())
1329 .action(
1330 "Edit settings.json",
1331 zed_actions::OpenSettingsFile.boxed_clone(),
1332 )
1333 }))
1334 })
1335 .anchor(Corner::TopRight)
1336 .offset(gpui::Point {
1337 x: px(0.0),
1338 y: px(2.0),
1339 });
1340
1341 v_flex()
1342 .track_focus(&self.focus_handle)
1343 .size_full()
1344 .p_4()
1345 .items_center()
1346 .justify_center()
1347 .bg(cx.theme().colors().editor_background)
1348 .child(
1349 v_flex()
1350 .max_w_112()
1351 .items_center()
1352 .justify_center()
1353 .text_center()
1354 .child(Label::new("Failed to spawn terminal"))
1355 .child(
1356 Label::new(self.error.to_string())
1357 .size(LabelSize::Small)
1358 .color(Color::Muted)
1359 .mb_4(),
1360 )
1361 .child(SplitButton::new(
1362 ButtonLike::new("open-settings-ui")
1363 .child(Label::new("Edit Settings").size(LabelSize::Small))
1364 .on_click(|_, window, cx| {
1365 window.dispatch_action(zed_actions::OpenSettings.boxed_clone(), cx);
1366 }),
1367 popover_menu.into_any_element(),
1368 )),
1369 )
1370 }
1371}
1372
1373impl EventEmitter<()> for FailedToSpawnTerminal {}
1374
1375impl workspace::Item for FailedToSpawnTerminal {
1376 type Event = ();
1377
1378 fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString {
1379 SharedString::new_static("Failed to spawn terminal")
1380 }
1381}
1382
1383impl EventEmitter<PanelEvent> for TerminalPanel {}
1384
1385impl Render for TerminalPanel {
1386 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1387 let mut registrar = DivRegistrar::new(
1388 |panel, _, cx| {
1389 panel
1390 .active_pane
1391 .read(cx)
1392 .toolbar()
1393 .read(cx)
1394 .item_of_type::<BufferSearchBar>()
1395 },
1396 cx,
1397 );
1398 BufferSearchBar::register(&mut registrar);
1399 let registrar = registrar.into_div();
1400 self.workspace
1401 .update(cx, |workspace, cx| {
1402 registrar.size_full().child(self.center.render(
1403 workspace.zoomed_item(),
1404 &workspace::PaneRenderContext {
1405 follower_states: &HashMap::default(),
1406 active_call: workspace.active_call(),
1407 active_pane: &self.active_pane,
1408 app_state: workspace.app_state(),
1409 project: workspace.project(),
1410 workspace: &workspace.weak_handle(),
1411 },
1412 window,
1413 cx,
1414 ))
1415 })
1416 .ok()
1417 .map(|div| {
1418 div.on_action({
1419 cx.listener(|terminal_panel, _: &ActivatePaneLeft, window, cx| {
1420 terminal_panel.activate_pane_in_direction(SplitDirection::Left, window, cx);
1421 })
1422 })
1423 .on_action({
1424 cx.listener(|terminal_panel, _: &ActivatePaneRight, window, cx| {
1425 terminal_panel.activate_pane_in_direction(
1426 SplitDirection::Right,
1427 window,
1428 cx,
1429 );
1430 })
1431 })
1432 .on_action({
1433 cx.listener(|terminal_panel, _: &ActivatePaneUp, window, cx| {
1434 terminal_panel.activate_pane_in_direction(SplitDirection::Up, window, cx);
1435 })
1436 })
1437 .on_action({
1438 cx.listener(|terminal_panel, _: &ActivatePaneDown, window, cx| {
1439 terminal_panel.activate_pane_in_direction(SplitDirection::Down, window, cx);
1440 })
1441 })
1442 .on_action(
1443 cx.listener(|terminal_panel, _action: &ActivateNextPane, window, cx| {
1444 let panes = terminal_panel.center.panes();
1445 if let Some(ix) = panes
1446 .iter()
1447 .position(|pane| **pane == terminal_panel.active_pane)
1448 {
1449 let next_ix = (ix + 1) % panes.len();
1450 window.focus(&panes[next_ix].focus_handle(cx));
1451 }
1452 }),
1453 )
1454 .on_action(cx.listener(
1455 |terminal_panel, _action: &ActivatePreviousPane, window, cx| {
1456 let panes = terminal_panel.center.panes();
1457 if let Some(ix) = panes
1458 .iter()
1459 .position(|pane| **pane == terminal_panel.active_pane)
1460 {
1461 let prev_ix = cmp::min(ix.wrapping_sub(1), panes.len() - 1);
1462 window.focus(&panes[prev_ix].focus_handle(cx));
1463 }
1464 },
1465 ))
1466 .on_action(
1467 cx.listener(|terminal_panel, action: &ActivatePane, window, cx| {
1468 let panes = terminal_panel.center.panes();
1469 if let Some(&pane) = panes.get(action.0) {
1470 window.focus(&pane.read(cx).focus_handle(cx));
1471 } else {
1472 let future =
1473 terminal_panel.new_pane_with_cloned_active_terminal(window, cx);
1474 cx.spawn_in(window, async move |terminal_panel, cx| {
1475 if let Some(new_pane) = future.await {
1476 _ = terminal_panel.update_in(
1477 cx,
1478 |terminal_panel, window, cx| {
1479 terminal_panel
1480 .center
1481 .split(
1482 &terminal_panel.active_pane,
1483 &new_pane,
1484 SplitDirection::Right,
1485 )
1486 .log_err();
1487 let new_pane = new_pane.read(cx);
1488 window.focus(&new_pane.focus_handle(cx));
1489 },
1490 );
1491 }
1492 })
1493 .detach();
1494 }
1495 }),
1496 )
1497 .on_action(cx.listener(|terminal_panel, _: &SwapPaneLeft, _, cx| {
1498 terminal_panel.swap_pane_in_direction(SplitDirection::Left, cx);
1499 }))
1500 .on_action(cx.listener(|terminal_panel, _: &SwapPaneRight, _, cx| {
1501 terminal_panel.swap_pane_in_direction(SplitDirection::Right, cx);
1502 }))
1503 .on_action(cx.listener(|terminal_panel, _: &SwapPaneUp, _, cx| {
1504 terminal_panel.swap_pane_in_direction(SplitDirection::Up, cx);
1505 }))
1506 .on_action(cx.listener(|terminal_panel, _: &SwapPaneDown, _, cx| {
1507 terminal_panel.swap_pane_in_direction(SplitDirection::Down, cx);
1508 }))
1509 .on_action(cx.listener(|terminal_panel, _: &MovePaneLeft, _, cx| {
1510 terminal_panel.move_pane_to_border(SplitDirection::Left, cx);
1511 }))
1512 .on_action(cx.listener(|terminal_panel, _: &MovePaneRight, _, cx| {
1513 terminal_panel.move_pane_to_border(SplitDirection::Right, cx);
1514 }))
1515 .on_action(cx.listener(|terminal_panel, _: &MovePaneUp, _, cx| {
1516 terminal_panel.move_pane_to_border(SplitDirection::Up, cx);
1517 }))
1518 .on_action(cx.listener(|terminal_panel, _: &MovePaneDown, _, cx| {
1519 terminal_panel.move_pane_to_border(SplitDirection::Down, cx);
1520 }))
1521 .on_action(
1522 cx.listener(|terminal_panel, action: &MoveItemToPane, window, cx| {
1523 let Some(&target_pane) =
1524 terminal_panel.center.panes().get(action.destination)
1525 else {
1526 return;
1527 };
1528 move_active_item(
1529 &terminal_panel.active_pane,
1530 target_pane,
1531 action.focus,
1532 true,
1533 window,
1534 cx,
1535 );
1536 }),
1537 )
1538 .on_action(cx.listener(
1539 |terminal_panel, action: &MoveItemToPaneInDirection, window, cx| {
1540 let source_pane = &terminal_panel.active_pane;
1541 if let Some(destination_pane) = terminal_panel
1542 .center
1543 .find_pane_in_direction(source_pane, action.direction, cx)
1544 {
1545 move_active_item(
1546 source_pane,
1547 destination_pane,
1548 action.focus,
1549 true,
1550 window,
1551 cx,
1552 );
1553 };
1554 },
1555 ))
1556 })
1557 .unwrap_or_else(|| div())
1558 }
1559}
1560
1561impl Focusable for TerminalPanel {
1562 fn focus_handle(&self, cx: &App) -> FocusHandle {
1563 self.active_pane.focus_handle(cx)
1564 }
1565}
1566
1567impl Panel for TerminalPanel {
1568 fn position(&self, _window: &Window, cx: &App) -> DockPosition {
1569 match TerminalSettings::get_global(cx).dock {
1570 TerminalDockPosition::Left => DockPosition::Left,
1571 TerminalDockPosition::Bottom => DockPosition::Bottom,
1572 TerminalDockPosition::Right => DockPosition::Right,
1573 }
1574 }
1575
1576 fn position_is_valid(&self, _: DockPosition) -> bool {
1577 true
1578 }
1579
1580 fn set_position(
1581 &mut self,
1582 position: DockPosition,
1583 _window: &mut Window,
1584 cx: &mut Context<Self>,
1585 ) {
1586 settings::update_settings_file(self.fs.clone(), cx, move |settings, _| {
1587 let dock = match position {
1588 DockPosition::Left => TerminalDockPosition::Left,
1589 DockPosition::Bottom => TerminalDockPosition::Bottom,
1590 DockPosition::Right => TerminalDockPosition::Right,
1591 };
1592 settings.terminal.get_or_insert_default().dock = Some(dock);
1593 });
1594 }
1595
1596 fn size(&self, window: &Window, cx: &App) -> Pixels {
1597 let settings = TerminalSettings::get_global(cx);
1598 match self.position(window, cx) {
1599 DockPosition::Left | DockPosition::Right => {
1600 self.width.unwrap_or(settings.default_width)
1601 }
1602 DockPosition::Bottom => self.height.unwrap_or(settings.default_height),
1603 }
1604 }
1605
1606 fn set_size(&mut self, size: Option<Pixels>, window: &mut Window, cx: &mut Context<Self>) {
1607 match self.position(window, cx) {
1608 DockPosition::Left | DockPosition::Right => self.width = size,
1609 DockPosition::Bottom => self.height = size,
1610 }
1611 cx.notify();
1612 cx.defer_in(window, |this, _, cx| {
1613 this.serialize(cx);
1614 })
1615 }
1616
1617 fn is_zoomed(&self, _window: &Window, cx: &App) -> bool {
1618 self.active_pane.read(cx).is_zoomed()
1619 }
1620
1621 fn set_zoomed(&mut self, zoomed: bool, _: &mut Window, cx: &mut Context<Self>) {
1622 for pane in self.center.panes() {
1623 pane.update(cx, |pane, cx| {
1624 pane.set_zoomed(zoomed, cx);
1625 })
1626 }
1627 cx.notify();
1628 }
1629
1630 fn set_active(&mut self, active: bool, window: &mut Window, cx: &mut Context<Self>) {
1631 let old_active = self.active;
1632 self.active = active;
1633 if !active || old_active == active || !self.has_no_terminals(cx) {
1634 return;
1635 }
1636 cx.defer_in(window, |this, window, cx| {
1637 let Ok(kind) = this
1638 .workspace
1639 .update(cx, |workspace, cx| default_working_directory(workspace, cx))
1640 else {
1641 return;
1642 };
1643
1644 this.add_terminal_shell(kind, RevealStrategy::Always, window, cx)
1645 .detach_and_log_err(cx)
1646 })
1647 }
1648
1649 fn icon_label(&self, _window: &Window, cx: &App) -> Option<String> {
1650 let count = self
1651 .center
1652 .panes()
1653 .into_iter()
1654 .map(|pane| pane.read(cx).items_len())
1655 .sum::<usize>();
1656 if count == 0 {
1657 None
1658 } else {
1659 Some(count.to_string())
1660 }
1661 }
1662
1663 fn persistent_name() -> &'static str {
1664 "TerminalPanel"
1665 }
1666
1667 fn panel_key() -> &'static str {
1668 TERMINAL_PANEL_KEY
1669 }
1670
1671 fn icon(&self, _window: &Window, cx: &App) -> Option<IconName> {
1672 if (self.is_enabled(cx) || !self.has_no_terminals(cx))
1673 && TerminalSettings::get_global(cx).button
1674 {
1675 Some(IconName::TerminalAlt)
1676 } else {
1677 None
1678 }
1679 }
1680
1681 fn icon_tooltip(&self, _window: &Window, _cx: &App) -> Option<&'static str> {
1682 Some("Terminal Panel")
1683 }
1684
1685 fn toggle_action(&self) -> Box<dyn gpui::Action> {
1686 Box::new(ToggleFocus)
1687 }
1688
1689 fn pane(&self) -> Option<Entity<Pane>> {
1690 Some(self.active_pane.clone())
1691 }
1692
1693 fn activation_priority(&self) -> u32 {
1694 1
1695 }
1696}
1697
1698struct TerminalProvider(Entity<TerminalPanel>);
1699
1700impl workspace::TerminalProvider for TerminalProvider {
1701 fn spawn(
1702 &self,
1703 task: SpawnInTerminal,
1704 window: &mut Window,
1705 cx: &mut App,
1706 ) -> Task<Option<Result<ExitStatus>>> {
1707 let terminal_panel = self.0.clone();
1708 window.spawn(cx, async move |cx| {
1709 let terminal = terminal_panel
1710 .update_in(cx, |terminal_panel, window, cx| {
1711 terminal_panel.spawn_task(&task, window, cx)
1712 })
1713 .ok()?
1714 .await;
1715 match terminal {
1716 Ok(terminal) => {
1717 let exit_status = terminal
1718 .read_with(cx, |terminal, cx| terminal.wait_for_completed_task(cx))
1719 .ok()?
1720 .await?;
1721 Some(Ok(exit_status))
1722 }
1723 Err(e) => Some(Err(e)),
1724 }
1725 })
1726 }
1727}
1728
1729struct InlineAssistTabBarButton {
1730 focus_handle: FocusHandle,
1731}
1732
1733impl Render for InlineAssistTabBarButton {
1734 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1735 let focus_handle = self.focus_handle.clone();
1736 IconButton::new("terminal_inline_assistant", IconName::ZedAssistant)
1737 .icon_size(IconSize::Small)
1738 .on_click(cx.listener(|_, _, window, cx| {
1739 window.dispatch_action(InlineAssist::default().boxed_clone(), cx);
1740 }))
1741 .tooltip(move |window, cx| {
1742 Tooltip::for_action_in(
1743 "Inline Assist",
1744 &InlineAssist::default(),
1745 &focus_handle,
1746 window,
1747 cx,
1748 )
1749 })
1750 }
1751}
1752
1753#[cfg(test)]
1754mod tests {
1755 use super::*;
1756 use gpui::{TestAppContext, UpdateGlobal as _};
1757 use pretty_assertions::assert_eq;
1758 use project::FakeFs;
1759 use settings::SettingsStore;
1760
1761 #[gpui::test]
1762 async fn test_spawn_an_empty_task(cx: &mut TestAppContext) {
1763 init_test(cx);
1764
1765 let fs = FakeFs::new(cx.executor());
1766 let project = Project::test(fs, [], cx).await;
1767 let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1768
1769 let (window_handle, terminal_panel) = workspace
1770 .update(cx, |workspace, window, cx| {
1771 let window_handle = window.window_handle();
1772 let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1773 (window_handle, terminal_panel)
1774 })
1775 .unwrap();
1776
1777 let task = window_handle
1778 .update(cx, |_, window, cx| {
1779 terminal_panel.update(cx, |terminal_panel, cx| {
1780 terminal_panel.spawn_task(&SpawnInTerminal::default(), window, cx)
1781 })
1782 })
1783 .unwrap();
1784
1785 let terminal = task.await.unwrap();
1786 let expected_shell = util::get_system_shell();
1787 terminal
1788 .update(cx, |terminal, _| {
1789 let task_metadata = terminal
1790 .task()
1791 .expect("When spawning a task, should have the task metadata")
1792 .spawned_task
1793 .clone();
1794 assert_eq!(task_metadata.env, HashMap::default());
1795 assert_eq!(task_metadata.cwd, None);
1796 assert_eq!(task_metadata.shell, task::Shell::System);
1797 assert_eq!(
1798 task_metadata.command,
1799 Some(expected_shell.clone()),
1800 "Empty tasks should spawn a -i shell"
1801 );
1802 assert_eq!(task_metadata.args, Vec::<String>::new());
1803 assert_eq!(
1804 task_metadata.command_label, expected_shell,
1805 "We show the shell launch for empty commands"
1806 );
1807 })
1808 .unwrap();
1809 }
1810
1811 // A complex Unix command won't be properly parsed by the Windows terminal hence omit the test there.
1812 #[cfg(unix)]
1813 #[gpui::test]
1814 async fn test_spawn_script_like_task(cx: &mut TestAppContext) {
1815 init_test(cx);
1816
1817 let fs = FakeFs::new(cx.executor());
1818 let project = Project::test(fs, [], cx).await;
1819 let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1820
1821 let (window_handle, terminal_panel) = workspace
1822 .update(cx, |workspace, window, cx| {
1823 let window_handle = window.window_handle();
1824 let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1825 (window_handle, terminal_panel)
1826 })
1827 .unwrap();
1828
1829 let user_command = r#"REPO_URL=$(git remote get-url origin | sed -e \"s/^git@\\(.*\\):\\(.*\\)\\.git$/https:\\/\\/\\1\\/\\2/\"); COMMIT_SHA=$(git log -1 --format=\"%H\" -- \"${ZED_RELATIVE_FILE}\"); echo \"${REPO_URL}/blob/${COMMIT_SHA}/${ZED_RELATIVE_FILE}#L${ZED_ROW}-$(echo $(($(wc -l <<< \"$ZED_SELECTED_TEXT\") + $ZED_ROW - 1)))\" | xclip -selection clipboard"#.to_string();
1830
1831 let expected_cwd = PathBuf::from("/some/work");
1832 let task = window_handle
1833 .update(cx, |_, window, cx| {
1834 terminal_panel.update(cx, |terminal_panel, cx| {
1835 terminal_panel.spawn_task(
1836 &SpawnInTerminal {
1837 command: Some(user_command.clone()),
1838 cwd: Some(expected_cwd.clone()),
1839 ..SpawnInTerminal::default()
1840 },
1841 window,
1842 cx,
1843 )
1844 })
1845 })
1846 .unwrap();
1847
1848 let terminal = task.await.unwrap();
1849 let shell = util::get_system_shell();
1850 terminal
1851 .update(cx, |terminal, _| {
1852 let task_metadata = terminal
1853 .task()
1854 .expect("When spawning a task, should have the task metadata")
1855 .spawned_task
1856 .clone();
1857 assert_eq!(task_metadata.env, HashMap::default());
1858 assert_eq!(task_metadata.cwd, Some(expected_cwd));
1859 assert_eq!(task_metadata.shell, task::Shell::System);
1860 assert_eq!(task_metadata.command, Some(shell.clone()));
1861 assert_eq!(
1862 task_metadata.args,
1863 vec!["-i".to_string(), "-c".to_string(), user_command.clone(),],
1864 "Use command should have been moved into the arguments, as we're spawning a new -i shell",
1865 );
1866 assert_eq!(
1867 task_metadata.command_label,
1868 format!("{shell} {interactive}-c '{user_command}'", interactive = if cfg!(windows) {""} else {"-i "}),
1869 "We want to show to the user the entire command spawned");
1870 })
1871 .unwrap();
1872 }
1873
1874 #[gpui::test]
1875 async fn renders_error_if_default_shell_fails(cx: &mut TestAppContext) {
1876 init_test(cx);
1877
1878 cx.update(|cx| {
1879 SettingsStore::update_global(cx, |store, cx| {
1880 store.update_user_settings(cx, |settings| {
1881 settings.terminal.get_or_insert_default().project.shell =
1882 Some(settings::Shell::Program("asdf".to_owned()));
1883 });
1884 });
1885 });
1886
1887 let fs = FakeFs::new(cx.executor());
1888 let project = Project::test(fs, [], cx).await;
1889 let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1890
1891 let (window_handle, terminal_panel) = workspace
1892 .update(cx, |workspace, window, cx| {
1893 let window_handle = window.window_handle();
1894 let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1895 (window_handle, terminal_panel)
1896 })
1897 .unwrap();
1898
1899 window_handle
1900 .update(cx, |_, window, cx| {
1901 terminal_panel.update(cx, |terminal_panel, cx| {
1902 terminal_panel.add_terminal_shell(None, RevealStrategy::Always, window, cx)
1903 })
1904 })
1905 .unwrap()
1906 .await
1907 .unwrap_err();
1908
1909 window_handle
1910 .update(cx, |_, _, cx| {
1911 terminal_panel.update(cx, |terminal_panel, cx| {
1912 assert!(
1913 terminal_panel
1914 .active_pane
1915 .read(cx)
1916 .items()
1917 .any(|item| item.downcast::<FailedToSpawnTerminal>().is_some()),
1918 "should spawn `FailedToSpawnTerminal` pane"
1919 );
1920 })
1921 })
1922 .unwrap();
1923 }
1924
1925 pub fn init_test(cx: &mut TestAppContext) {
1926 cx.update(|cx| {
1927 let store = SettingsStore::test(cx);
1928 cx.set_global(store);
1929 theme::init(theme::LoadThemes::JustBase, cx);
1930 client::init_settings(cx);
1931 language::init(cx);
1932 Project::init_settings(cx);
1933 workspace::init_settings(cx);
1934 editor::init(cx);
1935 crate::init(cx);
1936 });
1937 }
1938}