1use crate::{
2 item::{
3 ActivateOnClose, ClosePosition, Item, ItemHandle, ItemSettings, PreviewTabsSettings,
4 ShowCloseButton, ShowDiagnostics, TabContentParams, TabTooltipContent, WeakItemHandle,
5 },
6 move_item,
7 notifications::NotifyResultExt,
8 toolbar::Toolbar,
9 workspace_settings::{AutosaveSetting, TabBarSettings, WorkspaceSettings},
10 CloseWindow, NewFile, NewTerminal, OpenInTerminal, OpenOptions, OpenTerminal, OpenVisible,
11 SplitDirection, ToggleFileFinder, ToggleProjectSymbols, ToggleZoom, Workspace,
12};
13use anyhow::Result;
14use collections::{BTreeSet, HashMap, HashSet, VecDeque};
15use futures::{stream::FuturesUnordered, StreamExt};
16use gpui::{
17 actions, anchored, deferred, impl_actions, prelude::*, Action, AnyElement, App,
18 AsyncWindowContext, ClickEvent, ClipboardItem, Context, Corner, Div, DragMoveEvent, Entity,
19 EntityId, EventEmitter, ExternalPaths, FocusHandle, FocusOutEvent, Focusable, KeyContext,
20 MouseButton, MouseDownEvent, NavigationDirection, Pixels, Point, PromptLevel, Render,
21 ScrollHandle, Subscription, Task, WeakEntity, WeakFocusHandle, Window,
22};
23use itertools::Itertools;
24use language::DiagnosticSeverity;
25use parking_lot::Mutex;
26use project::{Project, ProjectEntryId, ProjectPath, WorktreeId};
27use schemars::JsonSchema;
28use serde::Deserialize;
29use settings::{Settings, SettingsStore};
30use std::{
31 any::Any,
32 cmp, fmt, mem,
33 ops::ControlFlow,
34 path::PathBuf,
35 rc::Rc,
36 sync::{
37 atomic::{AtomicUsize, Ordering},
38 Arc,
39 },
40};
41use theme::ThemeSettings;
42use ui::{
43 prelude::*, right_click_menu, ButtonSize, Color, ContextMenu, ContextMenuEntry,
44 ContextMenuItem, DecoratedIcon, IconButton, IconButtonShape, IconDecoration,
45 IconDecorationKind, IconName, IconSize, Indicator, Label, PopoverMenu, PopoverMenuHandle, Tab,
46 TabBar, TabPosition, Tooltip,
47};
48use util::{debug_panic, maybe, truncate_and_remove_front, ResultExt};
49
50/// A selected entry in e.g. project panel.
51#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
52pub struct SelectedEntry {
53 pub worktree_id: WorktreeId,
54 pub entry_id: ProjectEntryId,
55}
56
57/// A group of selected entries from project panel.
58#[derive(Debug)]
59pub struct DraggedSelection {
60 pub active_selection: SelectedEntry,
61 pub marked_selections: Arc<BTreeSet<SelectedEntry>>,
62}
63
64impl DraggedSelection {
65 pub fn items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a SelectedEntry> + 'a> {
66 if self.marked_selections.contains(&self.active_selection) {
67 Box::new(self.marked_selections.iter())
68 } else {
69 Box::new(std::iter::once(&self.active_selection))
70 }
71 }
72}
73
74#[derive(Clone, Copy, PartialEq, Debug, Deserialize, JsonSchema)]
75#[serde(rename_all = "snake_case")]
76pub enum SaveIntent {
77 /// write all files (even if unchanged)
78 /// prompt before overwriting on-disk changes
79 Save,
80 /// same as Save, but without auto formatting
81 SaveWithoutFormat,
82 /// write any files that have local changes
83 /// prompt before overwriting on-disk changes
84 SaveAll,
85 /// always prompt for a new path
86 SaveAs,
87 /// prompt "you have unsaved changes" before writing
88 Close,
89 /// write all dirty files, don't prompt on conflict
90 Overwrite,
91 /// skip all save-related behavior
92 Skip,
93}
94
95#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
96pub struct ActivateItem(pub usize);
97
98#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
99#[serde(deny_unknown_fields)]
100pub struct CloseActiveItem {
101 pub save_intent: Option<SaveIntent>,
102 #[serde(default)]
103 pub close_pinned: bool,
104}
105
106#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
107#[serde(deny_unknown_fields)]
108pub struct CloseInactiveItems {
109 pub save_intent: Option<SaveIntent>,
110 #[serde(default)]
111 pub close_pinned: bool,
112}
113
114#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
115#[serde(deny_unknown_fields)]
116pub struct CloseAllItems {
117 pub save_intent: Option<SaveIntent>,
118 #[serde(default)]
119 pub close_pinned: bool,
120}
121
122#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
123#[serde(deny_unknown_fields)]
124pub struct CloseCleanItems {
125 #[serde(default)]
126 pub close_pinned: bool,
127}
128
129#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
130#[serde(deny_unknown_fields)]
131pub struct CloseItemsToTheRight {
132 #[serde(default)]
133 pub close_pinned: bool,
134}
135
136#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
137#[serde(deny_unknown_fields)]
138pub struct CloseItemsToTheLeft {
139 #[serde(default)]
140 pub close_pinned: bool,
141}
142
143#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
144#[serde(deny_unknown_fields)]
145pub struct RevealInProjectPanel {
146 #[serde(skip)]
147 pub entry_id: Option<u64>,
148}
149
150#[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default)]
151#[serde(deny_unknown_fields)]
152pub struct DeploySearch {
153 #[serde(default)]
154 pub replace_enabled: bool,
155}
156
157impl_actions!(
158 pane,
159 [
160 CloseAllItems,
161 CloseActiveItem,
162 CloseCleanItems,
163 CloseItemsToTheLeft,
164 CloseItemsToTheRight,
165 CloseInactiveItems,
166 ActivateItem,
167 RevealInProjectPanel,
168 DeploySearch,
169 ]
170);
171
172actions!(
173 pane,
174 [
175 ActivatePreviousItem,
176 ActivateNextItem,
177 ActivateLastItem,
178 AlternateFile,
179 GoBack,
180 GoForward,
181 JoinIntoNext,
182 JoinAll,
183 ReopenClosedItem,
184 SplitLeft,
185 SplitUp,
186 SplitRight,
187 SplitDown,
188 SplitHorizontal,
189 SplitVertical,
190 SwapItemLeft,
191 SwapItemRight,
192 TogglePreviewTab,
193 TogglePinTab,
194 ]
195);
196
197impl DeploySearch {
198 pub fn find() -> Self {
199 Self {
200 replace_enabled: false,
201 }
202 }
203}
204
205const MAX_NAVIGATION_HISTORY_LEN: usize = 1024;
206
207pub enum Event {
208 AddItem {
209 item: Box<dyn ItemHandle>,
210 },
211 ActivateItem {
212 local: bool,
213 focus_changed: bool,
214 },
215 Remove {
216 focus_on_pane: Option<Entity<Pane>>,
217 },
218 RemoveItem {
219 idx: usize,
220 },
221 RemovedItem {
222 item_id: EntityId,
223 },
224 Split(SplitDirection),
225 JoinAll,
226 JoinIntoNext,
227 ChangeItemTitle,
228 Focus,
229 ZoomIn,
230 ZoomOut,
231 UserSavedItem {
232 item: Box<dyn WeakItemHandle>,
233 save_intent: SaveIntent,
234 },
235}
236
237impl fmt::Debug for Event {
238 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
239 match self {
240 Event::AddItem { item } => f
241 .debug_struct("AddItem")
242 .field("item", &item.item_id())
243 .finish(),
244 Event::ActivateItem { local, .. } => f
245 .debug_struct("ActivateItem")
246 .field("local", local)
247 .finish(),
248 Event::Remove { .. } => f.write_str("Remove"),
249 Event::RemoveItem { idx } => f.debug_struct("RemoveItem").field("idx", idx).finish(),
250 Event::RemovedItem { item_id } => f
251 .debug_struct("RemovedItem")
252 .field("item_id", item_id)
253 .finish(),
254 Event::Split(direction) => f
255 .debug_struct("Split")
256 .field("direction", direction)
257 .finish(),
258 Event::JoinAll => f.write_str("JoinAll"),
259 Event::JoinIntoNext => f.write_str("JoinIntoNext"),
260 Event::ChangeItemTitle => f.write_str("ChangeItemTitle"),
261 Event::Focus => f.write_str("Focus"),
262 Event::ZoomIn => f.write_str("ZoomIn"),
263 Event::ZoomOut => f.write_str("ZoomOut"),
264 Event::UserSavedItem { item, save_intent } => f
265 .debug_struct("UserSavedItem")
266 .field("item", &item.id())
267 .field("save_intent", save_intent)
268 .finish(),
269 }
270 }
271}
272
273/// A container for 0 to many items that are open in the workspace.
274/// Treats all items uniformly via the [`ItemHandle`] trait, whether it's an editor, search results multibuffer, terminal or something else,
275/// responsible for managing item tabs, focus and zoom states and drag and drop features.
276/// Can be split, see `PaneGroup` for more details.
277pub struct Pane {
278 alternate_file_items: (
279 Option<Box<dyn WeakItemHandle>>,
280 Option<Box<dyn WeakItemHandle>>,
281 ),
282 focus_handle: FocusHandle,
283 items: Vec<Box<dyn ItemHandle>>,
284 activation_history: Vec<ActivationHistoryEntry>,
285 next_activation_timestamp: Arc<AtomicUsize>,
286 zoomed: bool,
287 was_focused: bool,
288 active_item_index: usize,
289 preview_item_id: Option<EntityId>,
290 last_focus_handle_by_item: HashMap<EntityId, WeakFocusHandle>,
291 nav_history: NavHistory,
292 toolbar: Entity<Toolbar>,
293 pub(crate) workspace: WeakEntity<Workspace>,
294 project: WeakEntity<Project>,
295 drag_split_direction: Option<SplitDirection>,
296 can_drop_predicate: Option<Arc<dyn Fn(&dyn Any, &mut Window, &mut App) -> bool>>,
297 custom_drop_handle: Option<
298 Arc<dyn Fn(&mut Pane, &dyn Any, &mut Window, &mut Context<Pane>) -> ControlFlow<(), ()>>,
299 >,
300 can_split_predicate:
301 Option<Arc<dyn Fn(&mut Self, &dyn Any, &mut Window, &mut Context<Self>) -> bool>>,
302 should_display_tab_bar: Rc<dyn Fn(&Window, &mut Context<Pane>) -> bool>,
303 render_tab_bar_buttons: Rc<
304 dyn Fn(
305 &mut Pane,
306 &mut Window,
307 &mut Context<Pane>,
308 ) -> (Option<AnyElement>, Option<AnyElement>),
309 >,
310 show_tab_bar_buttons: bool,
311 _subscriptions: Vec<Subscription>,
312 tab_bar_scroll_handle: ScrollHandle,
313 /// Is None if navigation buttons are permanently turned off (and should not react to setting changes).
314 /// Otherwise, when `display_nav_history_buttons` is Some, it determines whether nav buttons should be displayed.
315 display_nav_history_buttons: Option<bool>,
316 double_click_dispatch_action: Box<dyn Action>,
317 save_modals_spawned: HashSet<EntityId>,
318 pub new_item_context_menu_handle: PopoverMenuHandle<ContextMenu>,
319 pub split_item_context_menu_handle: PopoverMenuHandle<ContextMenu>,
320 pinned_tab_count: usize,
321 diagnostics: HashMap<ProjectPath, DiagnosticSeverity>,
322 zoom_out_on_close: bool,
323}
324
325pub struct ActivationHistoryEntry {
326 pub entity_id: EntityId,
327 pub timestamp: usize,
328}
329
330pub struct ItemNavHistory {
331 history: NavHistory,
332 item: Arc<dyn WeakItemHandle>,
333 is_preview: bool,
334}
335
336#[derive(Clone)]
337pub struct NavHistory(Arc<Mutex<NavHistoryState>>);
338
339struct NavHistoryState {
340 mode: NavigationMode,
341 backward_stack: VecDeque<NavigationEntry>,
342 forward_stack: VecDeque<NavigationEntry>,
343 closed_stack: VecDeque<NavigationEntry>,
344 paths_by_item: HashMap<EntityId, (ProjectPath, Option<PathBuf>)>,
345 pane: WeakEntity<Pane>,
346 next_timestamp: Arc<AtomicUsize>,
347}
348
349#[derive(Debug, Copy, Clone)]
350pub enum NavigationMode {
351 Normal,
352 GoingBack,
353 GoingForward,
354 ClosingItem,
355 ReopeningClosedItem,
356 Disabled,
357}
358
359impl Default for NavigationMode {
360 fn default() -> Self {
361 Self::Normal
362 }
363}
364
365pub struct NavigationEntry {
366 pub item: Arc<dyn WeakItemHandle>,
367 pub data: Option<Box<dyn Any + Send>>,
368 pub timestamp: usize,
369 pub is_preview: bool,
370}
371
372#[derive(Clone)]
373pub struct DraggedTab {
374 pub pane: Entity<Pane>,
375 pub item: Box<dyn ItemHandle>,
376 pub ix: usize,
377 pub detail: usize,
378 pub is_active: bool,
379}
380
381impl EventEmitter<Event> for Pane {}
382
383impl Pane {
384 pub fn new(
385 workspace: WeakEntity<Workspace>,
386 project: Entity<Project>,
387 next_timestamp: Arc<AtomicUsize>,
388 can_drop_predicate: Option<Arc<dyn Fn(&dyn Any, &mut Window, &mut App) -> bool + 'static>>,
389 double_click_dispatch_action: Box<dyn Action>,
390 window: &mut Window,
391 cx: &mut Context<Self>,
392 ) -> Self {
393 let focus_handle = cx.focus_handle();
394
395 let subscriptions = vec![
396 cx.on_focus(&focus_handle, window, Pane::focus_in),
397 cx.on_focus_in(&focus_handle, window, Pane::focus_in),
398 cx.on_focus_out(&focus_handle, window, Pane::focus_out),
399 cx.observe_global::<SettingsStore>(Self::settings_changed),
400 cx.subscribe(&project, Self::project_events),
401 ];
402
403 let handle = cx.entity().downgrade();
404 Self {
405 alternate_file_items: (None, None),
406 focus_handle,
407 items: Vec::new(),
408 activation_history: Vec::new(),
409 next_activation_timestamp: next_timestamp.clone(),
410 was_focused: false,
411 zoomed: false,
412 active_item_index: 0,
413 preview_item_id: None,
414 last_focus_handle_by_item: Default::default(),
415 nav_history: NavHistory(Arc::new(Mutex::new(NavHistoryState {
416 mode: NavigationMode::Normal,
417 backward_stack: Default::default(),
418 forward_stack: Default::default(),
419 closed_stack: Default::default(),
420 paths_by_item: Default::default(),
421 pane: handle.clone(),
422 next_timestamp,
423 }))),
424 toolbar: cx.new(|_| Toolbar::new()),
425 tab_bar_scroll_handle: ScrollHandle::new(),
426 drag_split_direction: None,
427 workspace,
428 project: project.downgrade(),
429 can_drop_predicate,
430 custom_drop_handle: None,
431 can_split_predicate: None,
432 should_display_tab_bar: Rc::new(|_, cx| TabBarSettings::get_global(cx).show),
433 render_tab_bar_buttons: Rc::new(move |pane, window, cx| {
434 if !pane.has_focus(window, cx) && !pane.context_menu_focused(window, cx) {
435 return (None, None);
436 }
437 // Ideally we would return a vec of elements here to pass directly to the [TabBar]'s
438 // `end_slot`, but due to needing a view here that isn't possible.
439 let right_children = h_flex()
440 // Instead we need to replicate the spacing from the [TabBar]'s `end_slot` here.
441 .gap(DynamicSpacing::Base04.rems(cx))
442 .child(
443 PopoverMenu::new("pane-tab-bar-popover-menu")
444 .trigger_with_tooltip(
445 IconButton::new("plus", IconName::Plus).icon_size(IconSize::Small),
446 Tooltip::text("New..."),
447 )
448 .anchor(Corner::TopRight)
449 .with_handle(pane.new_item_context_menu_handle.clone())
450 .menu(move |window, cx| {
451 Some(ContextMenu::build(window, cx, |menu, _, _| {
452 menu.action("New File", NewFile.boxed_clone())
453 .action(
454 "Open File",
455 ToggleFileFinder::default().boxed_clone(),
456 )
457 .separator()
458 .action(
459 "Search Project",
460 DeploySearch {
461 replace_enabled: false,
462 }
463 .boxed_clone(),
464 )
465 .action(
466 "Search Symbols",
467 ToggleProjectSymbols.boxed_clone(),
468 )
469 .separator()
470 .action("New Terminal", NewTerminal.boxed_clone())
471 }))
472 }),
473 )
474 .child(
475 PopoverMenu::new("pane-tab-bar-split")
476 .trigger_with_tooltip(
477 IconButton::new("split", IconName::Split)
478 .icon_size(IconSize::Small),
479 Tooltip::text("Split Pane"),
480 )
481 .anchor(Corner::TopRight)
482 .with_handle(pane.split_item_context_menu_handle.clone())
483 .menu(move |window, cx| {
484 ContextMenu::build(window, cx, |menu, _, _| {
485 menu.action("Split Right", SplitRight.boxed_clone())
486 .action("Split Left", SplitLeft.boxed_clone())
487 .action("Split Up", SplitUp.boxed_clone())
488 .action("Split Down", SplitDown.boxed_clone())
489 })
490 .into()
491 }),
492 )
493 .child({
494 let zoomed = pane.is_zoomed();
495 IconButton::new("toggle_zoom", IconName::Maximize)
496 .icon_size(IconSize::Small)
497 .toggle_state(zoomed)
498 .selected_icon(IconName::Minimize)
499 .on_click(cx.listener(|pane, _, window, cx| {
500 pane.toggle_zoom(&crate::ToggleZoom, window, cx);
501 }))
502 .tooltip(move |window, cx| {
503 Tooltip::for_action(
504 if zoomed { "Zoom Out" } else { "Zoom In" },
505 &ToggleZoom,
506 window,
507 cx,
508 )
509 })
510 })
511 .into_any_element()
512 .into();
513 (None, right_children)
514 }),
515 show_tab_bar_buttons: TabBarSettings::get_global(cx).show_tab_bar_buttons,
516 display_nav_history_buttons: Some(
517 TabBarSettings::get_global(cx).show_nav_history_buttons,
518 ),
519 _subscriptions: subscriptions,
520 double_click_dispatch_action,
521 save_modals_spawned: HashSet::default(),
522 split_item_context_menu_handle: Default::default(),
523 new_item_context_menu_handle: Default::default(),
524 pinned_tab_count: 0,
525 diagnostics: Default::default(),
526 zoom_out_on_close: true,
527 }
528 }
529
530 fn alternate_file(&mut self, window: &mut Window, cx: &mut Context<Pane>) {
531 let (_, alternative) = &self.alternate_file_items;
532 if let Some(alternative) = alternative {
533 let existing = self
534 .items()
535 .find_position(|item| item.item_id() == alternative.id());
536 if let Some((ix, _)) = existing {
537 self.activate_item(ix, true, true, window, cx);
538 } else if let Some(upgraded) = alternative.upgrade() {
539 self.add_item(upgraded, true, true, None, window, cx);
540 }
541 }
542 }
543
544 pub fn track_alternate_file_items(&mut self) {
545 if let Some(item) = self.active_item().map(|item| item.downgrade_item()) {
546 let (current, _) = &self.alternate_file_items;
547 match current {
548 Some(current) => {
549 if current.id() != item.id() {
550 self.alternate_file_items =
551 (Some(item), self.alternate_file_items.0.take());
552 }
553 }
554 None => {
555 self.alternate_file_items = (Some(item), None);
556 }
557 }
558 }
559 }
560
561 pub fn has_focus(&self, window: &Window, cx: &App) -> bool {
562 // We not only check whether our focus handle contains focus, but also
563 // whether the active item might have focus, because we might have just activated an item
564 // that hasn't rendered yet.
565 // Before the next render, we might transfer focus
566 // to the item, and `focus_handle.contains_focus` returns false because the `active_item`
567 // is not hooked up to us in the dispatch tree.
568 self.focus_handle.contains_focused(window, cx)
569 || self.active_item().map_or(false, |item| {
570 item.item_focus_handle(cx).contains_focused(window, cx)
571 })
572 }
573
574 fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
575 if !self.was_focused {
576 self.was_focused = true;
577 cx.emit(Event::Focus);
578 cx.notify();
579 }
580
581 self.toolbar.update(cx, |toolbar, cx| {
582 toolbar.focus_changed(true, window, cx);
583 });
584
585 if let Some(active_item) = self.active_item() {
586 if self.focus_handle.is_focused(window) {
587 // Schedule a redraw next frame, so that the focus changes below take effect
588 cx.on_next_frame(window, |_, _, cx| {
589 cx.notify();
590 });
591
592 // Pane was focused directly. We need to either focus a view inside the active item,
593 // or focus the active item itself
594 if let Some(weak_last_focus_handle) =
595 self.last_focus_handle_by_item.get(&active_item.item_id())
596 {
597 if let Some(focus_handle) = weak_last_focus_handle.upgrade() {
598 focus_handle.focus(window);
599 return;
600 }
601 }
602
603 active_item.item_focus_handle(cx).focus(window);
604 } else if let Some(focused) = window.focused(cx) {
605 if !self.context_menu_focused(window, cx) {
606 self.last_focus_handle_by_item
607 .insert(active_item.item_id(), focused.downgrade());
608 }
609 }
610 }
611 }
612
613 pub fn context_menu_focused(&self, window: &mut Window, cx: &mut Context<Self>) -> bool {
614 self.new_item_context_menu_handle.is_focused(window, cx)
615 || self.split_item_context_menu_handle.is_focused(window, cx)
616 }
617
618 fn focus_out(&mut self, _event: FocusOutEvent, window: &mut Window, cx: &mut Context<Self>) {
619 self.was_focused = false;
620 self.toolbar.update(cx, |toolbar, cx| {
621 toolbar.focus_changed(false, window, cx);
622 });
623 cx.notify();
624 }
625
626 fn project_events(
627 &mut self,
628 _project: Entity<Project>,
629 event: &project::Event,
630 cx: &mut Context<Self>,
631 ) {
632 match event {
633 project::Event::DiskBasedDiagnosticsFinished { .. }
634 | project::Event::DiagnosticsUpdated { .. } => {
635 if ItemSettings::get_global(cx).show_diagnostics != ShowDiagnostics::Off {
636 self.update_diagnostics(cx);
637 cx.notify();
638 }
639 }
640 _ => {}
641 }
642 }
643
644 fn update_diagnostics(&mut self, cx: &mut Context<Self>) {
645 let Some(project) = self.project.upgrade() else {
646 return;
647 };
648 let show_diagnostics = ItemSettings::get_global(cx).show_diagnostics;
649 self.diagnostics = if show_diagnostics != ShowDiagnostics::Off {
650 project
651 .read(cx)
652 .diagnostic_summaries(false, cx)
653 .filter_map(|(project_path, _, diagnostic_summary)| {
654 if diagnostic_summary.error_count > 0 {
655 Some((project_path, DiagnosticSeverity::ERROR))
656 } else if diagnostic_summary.warning_count > 0
657 && show_diagnostics != ShowDiagnostics::Errors
658 {
659 Some((project_path, DiagnosticSeverity::WARNING))
660 } else {
661 None
662 }
663 })
664 .collect()
665 } else {
666 HashMap::default()
667 }
668 }
669
670 fn settings_changed(&mut self, cx: &mut Context<Self>) {
671 let tab_bar_settings = TabBarSettings::get_global(cx);
672
673 if let Some(display_nav_history_buttons) = self.display_nav_history_buttons.as_mut() {
674 *display_nav_history_buttons = tab_bar_settings.show_nav_history_buttons;
675 }
676 self.show_tab_bar_buttons = tab_bar_settings.show_tab_bar_buttons;
677
678 if !PreviewTabsSettings::get_global(cx).enabled {
679 self.preview_item_id = None;
680 }
681 self.update_diagnostics(cx);
682 cx.notify();
683 }
684
685 pub fn active_item_index(&self) -> usize {
686 self.active_item_index
687 }
688
689 pub fn activation_history(&self) -> &[ActivationHistoryEntry] {
690 &self.activation_history
691 }
692
693 pub fn set_should_display_tab_bar<F>(&mut self, should_display_tab_bar: F)
694 where
695 F: 'static + Fn(&Window, &mut Context<Pane>) -> bool,
696 {
697 self.should_display_tab_bar = Rc::new(should_display_tab_bar);
698 }
699
700 pub fn set_can_split(
701 &mut self,
702 can_split_predicate: Option<
703 Arc<dyn Fn(&mut Self, &dyn Any, &mut Window, &mut Context<Self>) -> bool + 'static>,
704 >,
705 ) {
706 self.can_split_predicate = can_split_predicate;
707 }
708
709 pub fn set_can_navigate(&mut self, can_navigate: bool, cx: &mut Context<Self>) {
710 self.toolbar.update(cx, |toolbar, cx| {
711 toolbar.set_can_navigate(can_navigate, cx);
712 });
713 cx.notify();
714 }
715
716 pub fn set_render_tab_bar_buttons<F>(&mut self, cx: &mut Context<Self>, render: F)
717 where
718 F: 'static
719 + Fn(
720 &mut Pane,
721 &mut Window,
722 &mut Context<Pane>,
723 ) -> (Option<AnyElement>, Option<AnyElement>),
724 {
725 self.render_tab_bar_buttons = Rc::new(render);
726 cx.notify();
727 }
728
729 pub fn set_custom_drop_handle<F>(&mut self, cx: &mut Context<Self>, handle: F)
730 where
731 F: 'static
732 + Fn(&mut Pane, &dyn Any, &mut Window, &mut Context<Pane>) -> ControlFlow<(), ()>,
733 {
734 self.custom_drop_handle = Some(Arc::new(handle));
735 cx.notify();
736 }
737
738 pub fn nav_history_for_item<T: Item>(&self, item: &Entity<T>) -> ItemNavHistory {
739 ItemNavHistory {
740 history: self.nav_history.clone(),
741 item: Arc::new(item.downgrade()),
742 is_preview: self.preview_item_id == Some(item.item_id()),
743 }
744 }
745
746 pub fn nav_history(&self) -> &NavHistory {
747 &self.nav_history
748 }
749
750 pub fn nav_history_mut(&mut self) -> &mut NavHistory {
751 &mut self.nav_history
752 }
753
754 pub fn disable_history(&mut self) {
755 self.nav_history.disable();
756 }
757
758 pub fn enable_history(&mut self) {
759 self.nav_history.enable();
760 }
761
762 pub fn can_navigate_backward(&self) -> bool {
763 !self.nav_history.0.lock().backward_stack.is_empty()
764 }
765
766 pub fn can_navigate_forward(&self) -> bool {
767 !self.nav_history.0.lock().forward_stack.is_empty()
768 }
769
770 fn navigate_backward(&mut self, window: &mut Window, cx: &mut Context<Self>) {
771 if let Some(workspace) = self.workspace.upgrade() {
772 let pane = cx.entity().downgrade();
773 window.defer(cx, move |window, cx| {
774 workspace.update(cx, |workspace, cx| {
775 workspace.go_back(pane, window, cx).detach_and_log_err(cx)
776 })
777 })
778 }
779 }
780
781 fn navigate_forward(&mut self, window: &mut Window, cx: &mut Context<Self>) {
782 if let Some(workspace) = self.workspace.upgrade() {
783 let pane = cx.entity().downgrade();
784 window.defer(cx, move |window, cx| {
785 workspace.update(cx, |workspace, cx| {
786 workspace
787 .go_forward(pane, window, cx)
788 .detach_and_log_err(cx)
789 })
790 })
791 }
792 }
793
794 fn history_updated(&mut self, cx: &mut Context<Self>) {
795 self.toolbar.update(cx, |_, cx| cx.notify());
796 }
797
798 pub fn preview_item_id(&self) -> Option<EntityId> {
799 self.preview_item_id
800 }
801
802 pub fn preview_item(&self) -> Option<Box<dyn ItemHandle>> {
803 self.preview_item_id
804 .and_then(|id| self.items.iter().find(|item| item.item_id() == id))
805 .cloned()
806 }
807
808 fn preview_item_idx(&self) -> Option<usize> {
809 if let Some(preview_item_id) = self.preview_item_id {
810 self.items
811 .iter()
812 .position(|item| item.item_id() == preview_item_id)
813 } else {
814 None
815 }
816 }
817
818 pub fn is_active_preview_item(&self, item_id: EntityId) -> bool {
819 self.preview_item_id == Some(item_id)
820 }
821
822 /// Marks the item with the given ID as the preview item.
823 /// This will be ignored if the global setting `preview_tabs` is disabled.
824 pub fn set_preview_item_id(&mut self, item_id: Option<EntityId>, cx: &App) {
825 if PreviewTabsSettings::get_global(cx).enabled {
826 self.preview_item_id = item_id;
827 }
828 }
829
830 pub(crate) fn set_pinned_count(&mut self, count: usize) {
831 self.pinned_tab_count = count;
832 }
833
834 pub(crate) fn pinned_count(&self) -> usize {
835 self.pinned_tab_count
836 }
837
838 pub fn handle_item_edit(&mut self, item_id: EntityId, cx: &App) {
839 if let Some(preview_item) = self.preview_item() {
840 if preview_item.item_id() == item_id && !preview_item.preserve_preview(cx) {
841 self.set_preview_item_id(None, cx);
842 }
843 }
844 }
845
846 #[allow(clippy::too_many_arguments)]
847 pub(crate) fn open_item(
848 &mut self,
849 project_entry_id: Option<ProjectEntryId>,
850 focus_item: bool,
851 allow_preview: bool,
852 activate: bool,
853 suggested_position: Option<usize>,
854 window: &mut Window,
855 cx: &mut Context<Self>,
856 build_item: impl FnOnce(&mut Window, &mut Context<Pane>) -> Box<dyn ItemHandle>,
857 ) -> Box<dyn ItemHandle> {
858 let mut existing_item = None;
859 if let Some(project_entry_id) = project_entry_id {
860 for (index, item) in self.items.iter().enumerate() {
861 if item.is_singleton(cx)
862 && item.project_entry_ids(cx).as_slice() == [project_entry_id]
863 {
864 let item = item.boxed_clone();
865 existing_item = Some((index, item));
866 break;
867 }
868 }
869 }
870 if let Some((index, existing_item)) = existing_item {
871 // If the item is already open, and the item is a preview item
872 // and we are not allowing items to open as preview, mark the item as persistent.
873 if let Some(preview_item_id) = self.preview_item_id {
874 if let Some(tab) = self.items.get(index) {
875 if tab.item_id() == preview_item_id && !allow_preview {
876 self.set_preview_item_id(None, cx);
877 }
878 }
879 }
880 if activate {
881 self.activate_item(index, focus_item, focus_item, window, cx);
882 }
883 existing_item
884 } else {
885 // If the item is being opened as preview and we have an existing preview tab,
886 // open the new item in the position of the existing preview tab.
887 let destination_index = if allow_preview {
888 self.close_current_preview_item(window, cx)
889 } else {
890 suggested_position
891 };
892
893 let new_item = build_item(window, cx);
894
895 if allow_preview {
896 self.set_preview_item_id(Some(new_item.item_id()), cx);
897 }
898 self.add_item_inner(
899 new_item.clone(),
900 true,
901 focus_item,
902 activate,
903 destination_index,
904 window,
905 cx,
906 );
907
908 new_item
909 }
910 }
911
912 pub fn close_current_preview_item(
913 &mut self,
914 window: &mut Window,
915 cx: &mut Context<Self>,
916 ) -> Option<usize> {
917 let item_idx = self.preview_item_idx()?;
918 let id = self.preview_item_id()?;
919
920 let prev_active_item_index = self.active_item_index;
921 self.remove_item(id, false, false, window, cx);
922 self.active_item_index = prev_active_item_index;
923
924 if item_idx < self.items.len() {
925 Some(item_idx)
926 } else {
927 None
928 }
929 }
930
931 #[allow(clippy::too_many_arguments)]
932 pub fn add_item_inner(
933 &mut self,
934 item: Box<dyn ItemHandle>,
935 activate_pane: bool,
936 focus_item: bool,
937 activate: bool,
938 destination_index: Option<usize>,
939 window: &mut Window,
940 cx: &mut Context<Self>,
941 ) {
942 self.close_items_over_max_tabs(window, cx);
943
944 if item.is_singleton(cx) {
945 if let Some(&entry_id) = item.project_entry_ids(cx).first() {
946 let Some(project) = self.project.upgrade() else {
947 return;
948 };
949 let project = project.read(cx);
950 if let Some(project_path) = project.path_for_entry(entry_id, cx) {
951 let abs_path = project.absolute_path(&project_path, cx);
952 self.nav_history
953 .0
954 .lock()
955 .paths_by_item
956 .insert(item.item_id(), (project_path, abs_path));
957 }
958 }
959 }
960 // If no destination index is specified, add or move the item after the
961 // active item (or at the start of tab bar, if the active item is pinned)
962 let mut insertion_index = {
963 cmp::min(
964 if let Some(destination_index) = destination_index {
965 destination_index
966 } else {
967 cmp::max(self.active_item_index + 1, self.pinned_count())
968 },
969 self.items.len(),
970 )
971 };
972
973 // Does the item already exist?
974 let project_entry_id = if item.is_singleton(cx) {
975 item.project_entry_ids(cx).first().copied()
976 } else {
977 None
978 };
979
980 let existing_item_index = self.items.iter().position(|existing_item| {
981 if existing_item.item_id() == item.item_id() {
982 true
983 } else if existing_item.is_singleton(cx) {
984 existing_item
985 .project_entry_ids(cx)
986 .first()
987 .map_or(false, |existing_entry_id| {
988 Some(existing_entry_id) == project_entry_id.as_ref()
989 })
990 } else {
991 false
992 }
993 });
994
995 if let Some(existing_item_index) = existing_item_index {
996 // If the item already exists, move it to the desired destination and activate it
997
998 if existing_item_index != insertion_index {
999 let existing_item_is_active = existing_item_index == self.active_item_index;
1000
1001 // If the caller didn't specify a destination and the added item is already
1002 // the active one, don't move it
1003 if existing_item_is_active && destination_index.is_none() {
1004 insertion_index = existing_item_index;
1005 } else {
1006 self.items.remove(existing_item_index);
1007 if existing_item_index < self.active_item_index {
1008 self.active_item_index -= 1;
1009 }
1010 insertion_index = insertion_index.min(self.items.len());
1011
1012 self.items.insert(insertion_index, item.clone());
1013
1014 if existing_item_is_active {
1015 self.active_item_index = insertion_index;
1016 } else if insertion_index <= self.active_item_index {
1017 self.active_item_index += 1;
1018 }
1019 }
1020
1021 cx.notify();
1022 }
1023
1024 if activate {
1025 self.activate_item(insertion_index, activate_pane, focus_item, window, cx);
1026 }
1027 } else {
1028 self.items.insert(insertion_index, item.clone());
1029
1030 if activate {
1031 if insertion_index <= self.active_item_index
1032 && self.preview_item_idx() != Some(self.active_item_index)
1033 {
1034 self.active_item_index += 1;
1035 }
1036
1037 self.activate_item(insertion_index, activate_pane, focus_item, window, cx);
1038 }
1039 cx.notify();
1040 }
1041
1042 cx.emit(Event::AddItem { item });
1043 }
1044
1045 pub fn add_item(
1046 &mut self,
1047 item: Box<dyn ItemHandle>,
1048 activate_pane: bool,
1049 focus_item: bool,
1050 destination_index: Option<usize>,
1051 window: &mut Window,
1052 cx: &mut Context<Self>,
1053 ) {
1054 self.add_item_inner(
1055 item,
1056 activate_pane,
1057 focus_item,
1058 true,
1059 destination_index,
1060 window,
1061 cx,
1062 )
1063 }
1064
1065 pub fn items_len(&self) -> usize {
1066 self.items.len()
1067 }
1068
1069 pub fn items(&self) -> impl DoubleEndedIterator<Item = &Box<dyn ItemHandle>> {
1070 self.items.iter()
1071 }
1072
1073 pub fn items_of_type<T: Render>(&self) -> impl '_ + Iterator<Item = Entity<T>> {
1074 self.items
1075 .iter()
1076 .filter_map(|item| item.to_any().downcast().ok())
1077 }
1078
1079 pub fn active_item(&self) -> Option<Box<dyn ItemHandle>> {
1080 self.items.get(self.active_item_index).cloned()
1081 }
1082
1083 pub fn pixel_position_of_cursor(&self, cx: &App) -> Option<Point<Pixels>> {
1084 self.items
1085 .get(self.active_item_index)?
1086 .pixel_position_of_cursor(cx)
1087 }
1088
1089 pub fn item_for_entry(
1090 &self,
1091 entry_id: ProjectEntryId,
1092 cx: &App,
1093 ) -> Option<Box<dyn ItemHandle>> {
1094 self.items.iter().find_map(|item| {
1095 if item.is_singleton(cx) && (item.project_entry_ids(cx).as_slice() == [entry_id]) {
1096 Some(item.boxed_clone())
1097 } else {
1098 None
1099 }
1100 })
1101 }
1102
1103 pub fn item_for_path(
1104 &self,
1105 project_path: ProjectPath,
1106 cx: &App,
1107 ) -> Option<Box<dyn ItemHandle>> {
1108 self.items.iter().find_map(move |item| {
1109 if item.is_singleton(cx) && (item.project_path(cx).as_slice() == [project_path.clone()])
1110 {
1111 Some(item.boxed_clone())
1112 } else {
1113 None
1114 }
1115 })
1116 }
1117
1118 pub fn index_for_item(&self, item: &dyn ItemHandle) -> Option<usize> {
1119 self.index_for_item_id(item.item_id())
1120 }
1121
1122 fn index_for_item_id(&self, item_id: EntityId) -> Option<usize> {
1123 self.items.iter().position(|i| i.item_id() == item_id)
1124 }
1125
1126 pub fn item_for_index(&self, ix: usize) -> Option<&dyn ItemHandle> {
1127 self.items.get(ix).map(|i| i.as_ref())
1128 }
1129
1130 pub fn toggle_zoom(&mut self, _: &ToggleZoom, window: &mut Window, cx: &mut Context<Self>) {
1131 if self.zoomed {
1132 cx.emit(Event::ZoomOut);
1133 } else if !self.items.is_empty() {
1134 if !self.focus_handle.contains_focused(window, cx) {
1135 cx.focus_self(window);
1136 }
1137 cx.emit(Event::ZoomIn);
1138 }
1139 }
1140
1141 pub fn activate_item(
1142 &mut self,
1143 index: usize,
1144 activate_pane: bool,
1145 focus_item: bool,
1146 window: &mut Window,
1147 cx: &mut Context<Self>,
1148 ) {
1149 use NavigationMode::{GoingBack, GoingForward};
1150 if index < self.items.len() {
1151 let prev_active_item_ix = mem::replace(&mut self.active_item_index, index);
1152 if prev_active_item_ix != self.active_item_index
1153 || matches!(self.nav_history.mode(), GoingBack | GoingForward)
1154 {
1155 if let Some(prev_item) = self.items.get(prev_active_item_ix) {
1156 prev_item.deactivated(window, cx);
1157 }
1158 }
1159 if let Some(newly_active_item) = self.items.get(index) {
1160 self.activation_history
1161 .retain(|entry| entry.entity_id != newly_active_item.item_id());
1162 self.activation_history.push(ActivationHistoryEntry {
1163 entity_id: newly_active_item.item_id(),
1164 timestamp: self
1165 .next_activation_timestamp
1166 .fetch_add(1, Ordering::SeqCst),
1167 });
1168 }
1169
1170 self.update_toolbar(window, cx);
1171 self.update_status_bar(window, cx);
1172
1173 if focus_item {
1174 self.focus_active_item(window, cx);
1175 }
1176
1177 cx.emit(Event::ActivateItem {
1178 local: activate_pane,
1179 focus_changed: focus_item,
1180 });
1181
1182 if !self.is_tab_pinned(index) {
1183 self.tab_bar_scroll_handle
1184 .scroll_to_item(index - self.pinned_tab_count);
1185 }
1186
1187 cx.notify();
1188 }
1189 }
1190
1191 pub fn activate_prev_item(
1192 &mut self,
1193 activate_pane: bool,
1194 window: &mut Window,
1195 cx: &mut Context<Self>,
1196 ) {
1197 let mut index = self.active_item_index;
1198 if index > 0 {
1199 index -= 1;
1200 } else if !self.items.is_empty() {
1201 index = self.items.len() - 1;
1202 }
1203 self.activate_item(index, activate_pane, activate_pane, window, cx);
1204 }
1205
1206 pub fn activate_next_item(
1207 &mut self,
1208 activate_pane: bool,
1209 window: &mut Window,
1210 cx: &mut Context<Self>,
1211 ) {
1212 let mut index = self.active_item_index;
1213 if index + 1 < self.items.len() {
1214 index += 1;
1215 } else {
1216 index = 0;
1217 }
1218 self.activate_item(index, activate_pane, activate_pane, window, cx);
1219 }
1220
1221 pub fn swap_item_left(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1222 let index = self.active_item_index;
1223 if index == 0 {
1224 return;
1225 }
1226
1227 self.items.swap(index, index - 1);
1228 self.activate_item(index - 1, true, true, window, cx);
1229 }
1230
1231 pub fn swap_item_right(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1232 let index = self.active_item_index;
1233 if index + 1 == self.items.len() {
1234 return;
1235 }
1236
1237 self.items.swap(index, index + 1);
1238 self.activate_item(index + 1, true, true, window, cx);
1239 }
1240
1241 pub fn close_active_item(
1242 &mut self,
1243 action: &CloseActiveItem,
1244 window: &mut Window,
1245 cx: &mut Context<Self>,
1246 ) -> Option<Task<Result<()>>> {
1247 if self.items.is_empty() {
1248 // Close the window when there's no active items to close, if configured
1249 if WorkspaceSettings::get_global(cx)
1250 .when_closing_with_no_tabs
1251 .should_close()
1252 {
1253 window.dispatch_action(Box::new(CloseWindow), cx);
1254 }
1255
1256 return None;
1257 }
1258 if self.is_tab_pinned(self.active_item_index) && !action.close_pinned {
1259 // Activate any non-pinned tab in same pane
1260 let non_pinned_tab_index = self
1261 .items()
1262 .enumerate()
1263 .find(|(index, _item)| !self.is_tab_pinned(*index))
1264 .map(|(index, _item)| index);
1265 if let Some(index) = non_pinned_tab_index {
1266 self.activate_item(index, false, false, window, cx);
1267 return None;
1268 }
1269
1270 // Activate any non-pinned tab in different pane
1271 let current_pane = cx.entity();
1272 self.workspace
1273 .update(cx, |workspace, cx| {
1274 let panes = workspace.center.panes();
1275 let pane_with_unpinned_tab = panes.iter().find(|pane| {
1276 if **pane == ¤t_pane {
1277 return false;
1278 }
1279 pane.read(cx).has_unpinned_tabs()
1280 });
1281 if let Some(pane) = pane_with_unpinned_tab {
1282 pane.update(cx, |pane, cx| pane.activate_unpinned_tab(window, cx));
1283 }
1284 })
1285 .ok();
1286
1287 return None;
1288 };
1289 let active_item_id = self.items[self.active_item_index].item_id();
1290 Some(self.close_item_by_id(
1291 active_item_id,
1292 action.save_intent.unwrap_or(SaveIntent::Close),
1293 window,
1294 cx,
1295 ))
1296 }
1297
1298 pub fn close_item_by_id(
1299 &mut self,
1300 item_id_to_close: EntityId,
1301 save_intent: SaveIntent,
1302 window: &mut Window,
1303 cx: &mut Context<Self>,
1304 ) -> Task<Result<()>> {
1305 self.close_items(window, cx, save_intent, move |view_id| {
1306 view_id == item_id_to_close
1307 })
1308 }
1309
1310 pub fn close_inactive_items(
1311 &mut self,
1312 action: &CloseInactiveItems,
1313 window: &mut Window,
1314 cx: &mut Context<Self>,
1315 ) -> Option<Task<Result<()>>> {
1316 if self.items.is_empty() {
1317 return None;
1318 }
1319
1320 let active_item_id = self.items[self.active_item_index].item_id();
1321 let non_closeable_items = self.get_non_closeable_item_ids(action.close_pinned);
1322 Some(self.close_items(
1323 window,
1324 cx,
1325 action.save_intent.unwrap_or(SaveIntent::Close),
1326 move |item_id| item_id != active_item_id && !non_closeable_items.contains(&item_id),
1327 ))
1328 }
1329
1330 pub fn close_clean_items(
1331 &mut self,
1332 action: &CloseCleanItems,
1333 window: &mut Window,
1334 cx: &mut Context<Self>,
1335 ) -> Option<Task<Result<()>>> {
1336 let item_ids: Vec<_> = self
1337 .items()
1338 .filter(|item| !item.is_dirty(cx))
1339 .map(|item| item.item_id())
1340 .collect();
1341 let non_closeable_items = self.get_non_closeable_item_ids(action.close_pinned);
1342 Some(
1343 self.close_items(window, cx, SaveIntent::Close, move |item_id| {
1344 item_ids.contains(&item_id) && !non_closeable_items.contains(&item_id)
1345 }),
1346 )
1347 }
1348
1349 pub fn close_items_to_the_left(
1350 &mut self,
1351 action: &CloseItemsToTheLeft,
1352 window: &mut Window,
1353 cx: &mut Context<Self>,
1354 ) -> Option<Task<Result<()>>> {
1355 if self.items.is_empty() {
1356 return None;
1357 }
1358 let active_item_id = self.items[self.active_item_index].item_id();
1359 let non_closeable_items = self.get_non_closeable_item_ids(action.close_pinned);
1360 Some(self.close_items_to_the_left_by_id(
1361 active_item_id,
1362 action,
1363 non_closeable_items,
1364 window,
1365 cx,
1366 ))
1367 }
1368
1369 pub fn close_items_to_the_left_by_id(
1370 &mut self,
1371 item_id: EntityId,
1372 action: &CloseItemsToTheLeft,
1373 non_closeable_items: Vec<EntityId>,
1374 window: &mut Window,
1375 cx: &mut Context<Self>,
1376 ) -> Task<Result<()>> {
1377 let item_ids: Vec<_> = self
1378 .items()
1379 .take_while(|item| item.item_id() != item_id)
1380 .map(|item| item.item_id())
1381 .collect();
1382 self.close_items(window, cx, SaveIntent::Close, move |item_id| {
1383 item_ids.contains(&item_id)
1384 && !action.close_pinned
1385 && !non_closeable_items.contains(&item_id)
1386 })
1387 }
1388
1389 pub fn close_items_to_the_right(
1390 &mut self,
1391 action: &CloseItemsToTheRight,
1392 window: &mut Window,
1393 cx: &mut Context<Self>,
1394 ) -> Option<Task<Result<()>>> {
1395 if self.items.is_empty() {
1396 return None;
1397 }
1398 let active_item_id = self.items[self.active_item_index].item_id();
1399 let non_closeable_items = self.get_non_closeable_item_ids(action.close_pinned);
1400 Some(self.close_items_to_the_right_by_id(
1401 active_item_id,
1402 action,
1403 non_closeable_items,
1404 window,
1405 cx,
1406 ))
1407 }
1408
1409 pub fn close_items_to_the_right_by_id(
1410 &mut self,
1411 item_id: EntityId,
1412 action: &CloseItemsToTheRight,
1413 non_closeable_items: Vec<EntityId>,
1414 window: &mut Window,
1415 cx: &mut Context<Self>,
1416 ) -> Task<Result<()>> {
1417 let item_ids: Vec<_> = self
1418 .items()
1419 .rev()
1420 .take_while(|item| item.item_id() != item_id)
1421 .map(|item| item.item_id())
1422 .collect();
1423 self.close_items(window, cx, SaveIntent::Close, move |item_id| {
1424 item_ids.contains(&item_id)
1425 && !action.close_pinned
1426 && !non_closeable_items.contains(&item_id)
1427 })
1428 }
1429
1430 pub fn close_all_items(
1431 &mut self,
1432 action: &CloseAllItems,
1433 window: &mut Window,
1434 cx: &mut Context<Self>,
1435 ) -> Option<Task<Result<()>>> {
1436 if self.items.is_empty() {
1437 return None;
1438 }
1439
1440 let non_closeable_items = self.get_non_closeable_item_ids(action.close_pinned);
1441 Some(self.close_items(
1442 window,
1443 cx,
1444 action.save_intent.unwrap_or(SaveIntent::Close),
1445 |item_id| !non_closeable_items.contains(&item_id),
1446 ))
1447 }
1448
1449 pub fn close_items_over_max_tabs(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1450 let Some(max_tabs) = WorkspaceSettings::get_global(cx).max_tabs.map(|i| i.get()) else {
1451 return;
1452 };
1453
1454 // Reduce over the activation history to get every dirty items up to max_tabs
1455 // count.
1456 let mut index_list = Vec::new();
1457 let mut items_len = self.items_len();
1458 let mut indexes: HashMap<EntityId, usize> = HashMap::default();
1459 for (index, item) in self.items.iter().enumerate() {
1460 indexes.insert(item.item_id(), index);
1461 }
1462 for entry in self.activation_history.iter() {
1463 if items_len < max_tabs {
1464 break;
1465 }
1466 let Some(&index) = indexes.get(&entry.entity_id) else {
1467 continue;
1468 };
1469 if let Some(true) = self.items.get(index).map(|item| item.is_dirty(cx)) {
1470 continue;
1471 }
1472
1473 index_list.push(index);
1474 items_len -= 1;
1475 }
1476 // The sort and reverse is necessary since we remove items
1477 // using their index position, hence removing from the end
1478 // of the list first to avoid changing indexes.
1479 index_list.sort_unstable();
1480 index_list
1481 .iter()
1482 .rev()
1483 .for_each(|&index| self._remove_item(index, false, false, None, window, cx));
1484 }
1485
1486 // Usually when you close an item that has unsaved changes, we prompt you to
1487 // save it. That said, if you still have the buffer open in a different pane
1488 // we can close this one without fear of losing data.
1489 pub fn skip_save_on_close(item: &dyn ItemHandle, workspace: &Workspace, cx: &App) -> bool {
1490 let mut dirty_project_item_ids = Vec::new();
1491 item.for_each_project_item(cx, &mut |project_item_id, project_item| {
1492 if project_item.is_dirty() {
1493 dirty_project_item_ids.push(project_item_id);
1494 }
1495 });
1496 if dirty_project_item_ids.is_empty() {
1497 if item.is_singleton(cx) && item.is_dirty(cx) {
1498 return false;
1499 }
1500 return true;
1501 }
1502
1503 for open_item in workspace.items(cx) {
1504 if open_item.item_id() == item.item_id() {
1505 continue;
1506 }
1507 if !open_item.is_singleton(cx) {
1508 continue;
1509 }
1510 let other_project_item_ids = open_item.project_item_model_ids(cx);
1511 dirty_project_item_ids.retain(|id| !other_project_item_ids.contains(id));
1512 }
1513 if dirty_project_item_ids.is_empty() {
1514 return true;
1515 }
1516
1517 false
1518 }
1519
1520 pub(super) fn file_names_for_prompt(
1521 items: &mut dyn Iterator<Item = &Box<dyn ItemHandle>>,
1522 cx: &App,
1523 ) -> String {
1524 let mut file_names = BTreeSet::default();
1525 for item in items {
1526 item.for_each_project_item(cx, &mut |_, project_item| {
1527 if !project_item.is_dirty() {
1528 return;
1529 }
1530 let filename = project_item.project_path(cx).and_then(|path| {
1531 path.path
1532 .file_name()
1533 .and_then(|name| name.to_str().map(ToOwned::to_owned))
1534 });
1535 file_names.insert(filename.unwrap_or("untitled".to_string()));
1536 });
1537 }
1538 if file_names.len() > 6 {
1539 format!(
1540 "{}\n.. and {} more",
1541 file_names.iter().take(5).join("\n"),
1542 file_names.len() - 5
1543 )
1544 } else {
1545 file_names.into_iter().join("\n")
1546 }
1547 }
1548
1549 pub fn close_items(
1550 &mut self,
1551 window: &mut Window,
1552 cx: &mut Context<Pane>,
1553 mut save_intent: SaveIntent,
1554 should_close: impl Fn(EntityId) -> bool,
1555 ) -> Task<Result<()>> {
1556 // Find the items to close.
1557 let mut items_to_close = Vec::new();
1558 for item in &self.items {
1559 if should_close(item.item_id()) {
1560 items_to_close.push(item.boxed_clone());
1561 }
1562 }
1563
1564 let active_item_id = self.active_item().map(|item| item.item_id());
1565
1566 items_to_close.sort_by_key(|item| {
1567 let path = item.project_path(cx);
1568 // Put the currently active item at the end, because if the currently active item is not closed last
1569 // closing the currently active item will cause the focus to switch to another item
1570 // This will cause Zed to expand the content of the currently active item
1571 //
1572 // Beyond that sort in order of project path, with untitled files and multibuffers coming last.
1573 (active_item_id == Some(item.item_id()), path.is_none(), path)
1574 });
1575
1576 let workspace = self.workspace.clone();
1577 let Some(project) = self.project.upgrade() else {
1578 return Task::ready(Ok(()));
1579 };
1580 cx.spawn_in(window, |pane, mut cx| async move {
1581 let dirty_items = workspace.update(&mut cx, |workspace, cx| {
1582 items_to_close
1583 .iter()
1584 .filter(|item| {
1585 item.is_dirty(cx)
1586 && !Self::skip_save_on_close(item.as_ref(), &workspace, cx)
1587 })
1588 .map(|item| item.boxed_clone())
1589 .collect::<Vec<_>>()
1590 })?;
1591
1592 if save_intent == SaveIntent::Close && dirty_items.len() > 1 {
1593 let answer = pane.update_in(&mut cx, |_, window, cx| {
1594 let detail = Self::file_names_for_prompt(&mut dirty_items.iter(), cx);
1595 window.prompt(
1596 PromptLevel::Warning,
1597 "Do you want to save changes to the following files?",
1598 Some(&detail),
1599 &["Save all", "Discard all", "Cancel"],
1600 cx,
1601 )
1602 })?;
1603 match answer.await {
1604 Ok(0) => save_intent = SaveIntent::SaveAll,
1605 Ok(1) => save_intent = SaveIntent::Skip,
1606 Ok(2) => return Ok(()),
1607 _ => {}
1608 }
1609 }
1610
1611 for item_to_close in items_to_close {
1612 let mut should_save = true;
1613 if save_intent == SaveIntent::Close {
1614 workspace.update(&mut cx, |workspace, cx| {
1615 if Self::skip_save_on_close(item_to_close.as_ref(), &workspace, cx) {
1616 should_save = false;
1617 }
1618 })?;
1619 }
1620
1621 if should_save {
1622 if !Self::save_item(
1623 project.clone(),
1624 &pane,
1625 &*item_to_close,
1626 save_intent,
1627 &mut cx,
1628 )
1629 .await?
1630 {
1631 break;
1632 }
1633 }
1634
1635 // Remove the item from the pane.
1636 pane.update_in(&mut cx, |pane, window, cx| {
1637 pane.remove_item(item_to_close.item_id(), false, true, window, cx);
1638 })
1639 .ok();
1640 }
1641
1642 pane.update(&mut cx, |_, cx| cx.notify()).ok();
1643 Ok(())
1644 })
1645 }
1646
1647 pub fn remove_item(
1648 &mut self,
1649 item_id: EntityId,
1650 activate_pane: bool,
1651 close_pane_if_empty: bool,
1652 window: &mut Window,
1653 cx: &mut Context<Self>,
1654 ) {
1655 let Some(item_index) = self.index_for_item_id(item_id) else {
1656 return;
1657 };
1658 self._remove_item(
1659 item_index,
1660 activate_pane,
1661 close_pane_if_empty,
1662 None,
1663 window,
1664 cx,
1665 )
1666 }
1667
1668 pub fn remove_item_and_focus_on_pane(
1669 &mut self,
1670 item_index: usize,
1671 activate_pane: bool,
1672 focus_on_pane_if_closed: Entity<Pane>,
1673 window: &mut Window,
1674 cx: &mut Context<Self>,
1675 ) {
1676 self._remove_item(
1677 item_index,
1678 activate_pane,
1679 true,
1680 Some(focus_on_pane_if_closed),
1681 window,
1682 cx,
1683 )
1684 }
1685
1686 fn _remove_item(
1687 &mut self,
1688 item_index: usize,
1689 activate_pane: bool,
1690 close_pane_if_empty: bool,
1691 focus_on_pane_if_closed: Option<Entity<Pane>>,
1692 window: &mut Window,
1693 cx: &mut Context<Self>,
1694 ) {
1695 let activate_on_close = &ItemSettings::get_global(cx).activate_on_close;
1696 self.activation_history
1697 .retain(|entry| entry.entity_id != self.items[item_index].item_id());
1698
1699 if self.is_tab_pinned(item_index) {
1700 self.pinned_tab_count -= 1;
1701 }
1702 if item_index == self.active_item_index {
1703 let left_neighbour_index = || item_index.min(self.items.len()).saturating_sub(1);
1704 let index_to_activate = match activate_on_close {
1705 ActivateOnClose::History => self
1706 .activation_history
1707 .pop()
1708 .and_then(|last_activated_item| {
1709 self.items.iter().enumerate().find_map(|(index, item)| {
1710 (item.item_id() == last_activated_item.entity_id).then_some(index)
1711 })
1712 })
1713 // We didn't have a valid activation history entry, so fallback
1714 // to activating the item to the left
1715 .unwrap_or_else(left_neighbour_index),
1716 ActivateOnClose::Neighbour => {
1717 self.activation_history.pop();
1718 if item_index + 1 < self.items.len() {
1719 item_index + 1
1720 } else {
1721 item_index.saturating_sub(1)
1722 }
1723 }
1724 ActivateOnClose::LeftNeighbour => {
1725 self.activation_history.pop();
1726 left_neighbour_index()
1727 }
1728 };
1729
1730 let should_activate = activate_pane || self.has_focus(window, cx);
1731 if self.items.len() == 1 && should_activate {
1732 self.focus_handle.focus(window);
1733 } else {
1734 self.activate_item(
1735 index_to_activate,
1736 should_activate,
1737 should_activate,
1738 window,
1739 cx,
1740 );
1741 }
1742 }
1743
1744 cx.emit(Event::RemoveItem { idx: item_index });
1745
1746 let item = self.items.remove(item_index);
1747
1748 cx.emit(Event::RemovedItem {
1749 item_id: item.item_id(),
1750 });
1751 if self.items.is_empty() {
1752 item.deactivated(window, cx);
1753 if close_pane_if_empty {
1754 self.update_toolbar(window, cx);
1755 cx.emit(Event::Remove {
1756 focus_on_pane: focus_on_pane_if_closed,
1757 });
1758 }
1759 }
1760
1761 if item_index < self.active_item_index {
1762 self.active_item_index -= 1;
1763 }
1764
1765 let mode = self.nav_history.mode();
1766 self.nav_history.set_mode(NavigationMode::ClosingItem);
1767 item.deactivated(window, cx);
1768 self.nav_history.set_mode(mode);
1769
1770 if self.is_active_preview_item(item.item_id()) {
1771 self.set_preview_item_id(None, cx);
1772 }
1773
1774 if let Some(path) = item.project_path(cx) {
1775 let abs_path = self
1776 .nav_history
1777 .0
1778 .lock()
1779 .paths_by_item
1780 .get(&item.item_id())
1781 .and_then(|(_, abs_path)| abs_path.clone());
1782
1783 self.nav_history
1784 .0
1785 .lock()
1786 .paths_by_item
1787 .insert(item.item_id(), (path, abs_path));
1788 } else {
1789 self.nav_history
1790 .0
1791 .lock()
1792 .paths_by_item
1793 .remove(&item.item_id());
1794 }
1795
1796 if self.zoom_out_on_close && self.items.is_empty() && close_pane_if_empty && self.zoomed {
1797 cx.emit(Event::ZoomOut);
1798 }
1799
1800 cx.notify();
1801 }
1802
1803 pub async fn save_item(
1804 project: Entity<Project>,
1805 pane: &WeakEntity<Pane>,
1806 item: &dyn ItemHandle,
1807 save_intent: SaveIntent,
1808 cx: &mut AsyncWindowContext,
1809 ) -> Result<bool> {
1810 const CONFLICT_MESSAGE: &str =
1811 "This file has changed on disk since you started editing it. Do you want to overwrite it?";
1812
1813 const DELETED_MESSAGE: &str =
1814 "This file has been deleted on disk since you started editing it. Do you want to recreate it?";
1815
1816 if save_intent == SaveIntent::Skip {
1817 return Ok(true);
1818 }
1819 let Some(item_ix) = pane
1820 .update(cx, |pane, _| pane.index_for_item(item))
1821 .ok()
1822 .flatten()
1823 else {
1824 return Ok(true);
1825 };
1826
1827 let (
1828 mut has_conflict,
1829 mut is_dirty,
1830 mut can_save,
1831 can_save_as,
1832 is_singleton,
1833 has_deleted_file,
1834 ) = cx.update(|_window, cx| {
1835 (
1836 item.has_conflict(cx),
1837 item.is_dirty(cx),
1838 item.can_save(cx),
1839 item.can_save_as(cx),
1840 item.is_singleton(cx),
1841 item.has_deleted_file(cx),
1842 )
1843 })?;
1844
1845 // when saving a single buffer, we ignore whether or not it's dirty.
1846 if save_intent == SaveIntent::Save || save_intent == SaveIntent::SaveWithoutFormat {
1847 is_dirty = true;
1848 }
1849
1850 if save_intent == SaveIntent::SaveAs {
1851 is_dirty = true;
1852 has_conflict = false;
1853 can_save = false;
1854 }
1855
1856 if save_intent == SaveIntent::Overwrite {
1857 has_conflict = false;
1858 }
1859
1860 let should_format = save_intent != SaveIntent::SaveWithoutFormat;
1861
1862 if has_conflict && can_save {
1863 if has_deleted_file && is_singleton {
1864 let answer = pane.update_in(cx, |pane, window, cx| {
1865 pane.activate_item(item_ix, true, true, window, cx);
1866 window.prompt(
1867 PromptLevel::Warning,
1868 DELETED_MESSAGE,
1869 None,
1870 &["Save", "Close", "Cancel"],
1871 cx,
1872 )
1873 })?;
1874 match answer.await {
1875 Ok(0) => {
1876 pane.update_in(cx, |_, window, cx| {
1877 item.save(should_format, project, window, cx)
1878 })?
1879 .await?
1880 }
1881 Ok(1) => {
1882 pane.update_in(cx, |pane, window, cx| {
1883 pane.remove_item(item.item_id(), false, false, window, cx)
1884 })?;
1885 }
1886 _ => return Ok(false),
1887 }
1888 return Ok(true);
1889 } else {
1890 let answer = pane.update_in(cx, |pane, window, cx| {
1891 pane.activate_item(item_ix, true, true, window, cx);
1892 window.prompt(
1893 PromptLevel::Warning,
1894 CONFLICT_MESSAGE,
1895 None,
1896 &["Overwrite", "Discard", "Cancel"],
1897 cx,
1898 )
1899 })?;
1900 match answer.await {
1901 Ok(0) => {
1902 pane.update_in(cx, |_, window, cx| {
1903 item.save(should_format, project, window, cx)
1904 })?
1905 .await?
1906 }
1907 Ok(1) => {
1908 pane.update_in(cx, |_, window, cx| item.reload(project, window, cx))?
1909 .await?
1910 }
1911 _ => return Ok(false),
1912 }
1913 }
1914 } else if is_dirty && (can_save || can_save_as) {
1915 if save_intent == SaveIntent::Close {
1916 let will_autosave = cx.update(|_window, cx| {
1917 matches!(
1918 item.workspace_settings(cx).autosave,
1919 AutosaveSetting::OnFocusChange | AutosaveSetting::OnWindowChange
1920 ) && Self::can_autosave_item(item, cx)
1921 })?;
1922 if !will_autosave {
1923 let item_id = item.item_id();
1924 let answer_task = pane.update_in(cx, |pane, window, cx| {
1925 if pane.save_modals_spawned.insert(item_id) {
1926 pane.activate_item(item_ix, true, true, window, cx);
1927 let prompt = dirty_message_for(item.project_path(cx));
1928 Some(window.prompt(
1929 PromptLevel::Warning,
1930 &prompt,
1931 None,
1932 &["Save", "Don't Save", "Cancel"],
1933 cx,
1934 ))
1935 } else {
1936 None
1937 }
1938 })?;
1939 if let Some(answer_task) = answer_task {
1940 let answer = answer_task.await;
1941 pane.update(cx, |pane, _| {
1942 if !pane.save_modals_spawned.remove(&item_id) {
1943 debug_panic!(
1944 "save modal was not present in spawned modals after awaiting for its answer"
1945 )
1946 }
1947 })?;
1948 match answer {
1949 Ok(0) => {}
1950 Ok(1) => {
1951 // Don't save this file
1952 pane.update_in(cx, |pane, window, cx| {
1953 if pane.is_tab_pinned(item_ix) && !item.can_save(cx) {
1954 pane.pinned_tab_count -= 1;
1955 }
1956 item.discarded(project, window, cx)
1957 })
1958 .log_err();
1959 return Ok(true);
1960 }
1961 _ => return Ok(false), // Cancel
1962 }
1963 } else {
1964 return Ok(false);
1965 }
1966 }
1967 }
1968
1969 if can_save {
1970 pane.update_in(cx, |pane, window, cx| {
1971 if pane.is_active_preview_item(item.item_id()) {
1972 pane.set_preview_item_id(None, cx);
1973 }
1974 item.save(should_format, project, window, cx)
1975 })?
1976 .await?;
1977 } else if can_save_as && is_singleton {
1978 let abs_path = pane.update_in(cx, |pane, window, cx| {
1979 pane.activate_item(item_ix, true, true, window, cx);
1980 pane.workspace.update(cx, |workspace, cx| {
1981 workspace.prompt_for_new_path(window, cx)
1982 })
1983 })??;
1984 if let Some(abs_path) = abs_path.await.ok().flatten() {
1985 pane.update_in(cx, |pane, window, cx| {
1986 if let Some(item) = pane.item_for_path(abs_path.clone(), cx) {
1987 pane.remove_item(item.item_id(), false, false, window, cx);
1988 }
1989
1990 item.save_as(project, abs_path, window, cx)
1991 })?
1992 .await?;
1993 } else {
1994 return Ok(false);
1995 }
1996 }
1997 }
1998
1999 pane.update(cx, |_, cx| {
2000 cx.emit(Event::UserSavedItem {
2001 item: item.downgrade_item(),
2002 save_intent,
2003 });
2004 true
2005 })
2006 }
2007
2008 fn can_autosave_item(item: &dyn ItemHandle, cx: &App) -> bool {
2009 let is_deleted = item.project_entry_ids(cx).is_empty();
2010 item.is_dirty(cx) && !item.has_conflict(cx) && item.can_save(cx) && !is_deleted
2011 }
2012
2013 pub fn autosave_item(
2014 item: &dyn ItemHandle,
2015 project: Entity<Project>,
2016 window: &mut Window,
2017 cx: &mut App,
2018 ) -> Task<Result<()>> {
2019 let format = !matches!(
2020 item.workspace_settings(cx).autosave,
2021 AutosaveSetting::AfterDelay { .. }
2022 );
2023 if Self::can_autosave_item(item, cx) {
2024 item.save(format, project, window, cx)
2025 } else {
2026 Task::ready(Ok(()))
2027 }
2028 }
2029
2030 pub fn focus_active_item(&mut self, window: &mut Window, cx: &mut Context<Self>) {
2031 if let Some(active_item) = self.active_item() {
2032 let focus_handle = active_item.item_focus_handle(cx);
2033 window.focus(&focus_handle);
2034 }
2035 }
2036
2037 pub fn split(&mut self, direction: SplitDirection, cx: &mut Context<Self>) {
2038 cx.emit(Event::Split(direction));
2039 }
2040
2041 pub fn toolbar(&self) -> &Entity<Toolbar> {
2042 &self.toolbar
2043 }
2044
2045 pub fn handle_deleted_project_item(
2046 &mut self,
2047 entry_id: ProjectEntryId,
2048 window: &mut Window,
2049 cx: &mut Context<Pane>,
2050 ) -> Option<()> {
2051 let item_id = self.items().find_map(|item| {
2052 if item.is_singleton(cx) && item.project_entry_ids(cx).as_slice() == [entry_id] {
2053 Some(item.item_id())
2054 } else {
2055 None
2056 }
2057 })?;
2058
2059 self.remove_item(item_id, false, true, window, cx);
2060 self.nav_history.remove_item(item_id);
2061
2062 Some(())
2063 }
2064
2065 fn update_toolbar(&mut self, window: &mut Window, cx: &mut Context<Self>) {
2066 let active_item = self
2067 .items
2068 .get(self.active_item_index)
2069 .map(|item| item.as_ref());
2070 self.toolbar.update(cx, |toolbar, cx| {
2071 toolbar.set_active_item(active_item, window, cx);
2072 });
2073 }
2074
2075 fn update_status_bar(&mut self, window: &mut Window, cx: &mut Context<Self>) {
2076 let workspace = self.workspace.clone();
2077 let pane = cx.entity().clone();
2078
2079 window.defer(cx, move |window, cx| {
2080 let Ok(status_bar) = workspace.update(cx, |workspace, _| workspace.status_bar.clone())
2081 else {
2082 return;
2083 };
2084
2085 status_bar.update(cx, move |status_bar, cx| {
2086 status_bar.set_active_pane(&pane, window, cx);
2087 });
2088 });
2089 }
2090
2091 fn entry_abs_path(&self, entry: ProjectEntryId, cx: &App) -> Option<PathBuf> {
2092 let worktree = self
2093 .workspace
2094 .upgrade()?
2095 .read(cx)
2096 .project()
2097 .read(cx)
2098 .worktree_for_entry(entry, cx)?
2099 .read(cx);
2100 let entry = worktree.entry_for_id(entry)?;
2101 match &entry.canonical_path {
2102 Some(canonical_path) => Some(canonical_path.to_path_buf()),
2103 None => worktree.absolutize(&entry.path).ok(),
2104 }
2105 }
2106
2107 pub fn icon_color(selected: bool) -> Color {
2108 if selected {
2109 Color::Default
2110 } else {
2111 Color::Muted
2112 }
2113 }
2114
2115 fn toggle_pin_tab(&mut self, _: &TogglePinTab, window: &mut Window, cx: &mut Context<Self>) {
2116 if self.items.is_empty() {
2117 return;
2118 }
2119 let active_tab_ix = self.active_item_index();
2120 if self.is_tab_pinned(active_tab_ix) {
2121 self.unpin_tab_at(active_tab_ix, window, cx);
2122 } else {
2123 self.pin_tab_at(active_tab_ix, window, cx);
2124 }
2125 }
2126
2127 fn pin_tab_at(&mut self, ix: usize, window: &mut Window, cx: &mut Context<Self>) {
2128 maybe!({
2129 let pane = cx.entity().clone();
2130 let destination_index = self.pinned_tab_count.min(ix);
2131 self.pinned_tab_count += 1;
2132 let id = self.item_for_index(ix)?.item_id();
2133
2134 if self.is_active_preview_item(id) {
2135 self.set_preview_item_id(None, cx);
2136 }
2137
2138 self.workspace
2139 .update(cx, |_, cx| {
2140 cx.defer_in(window, move |_, window, cx| {
2141 move_item(&pane, &pane, id, destination_index, window, cx)
2142 });
2143 })
2144 .ok()?;
2145
2146 Some(())
2147 });
2148 }
2149
2150 fn unpin_tab_at(&mut self, ix: usize, window: &mut Window, cx: &mut Context<Self>) {
2151 maybe!({
2152 let pane = cx.entity().clone();
2153 self.pinned_tab_count = self.pinned_tab_count.checked_sub(1)?;
2154 let destination_index = self.pinned_tab_count;
2155
2156 let id = self.item_for_index(ix)?.item_id();
2157
2158 self.workspace
2159 .update(cx, |_, cx| {
2160 cx.defer_in(window, move |_, window, cx| {
2161 move_item(&pane, &pane, id, destination_index, window, cx)
2162 });
2163 })
2164 .ok()?;
2165
2166 Some(())
2167 });
2168 }
2169
2170 fn is_tab_pinned(&self, ix: usize) -> bool {
2171 self.pinned_tab_count > ix
2172 }
2173
2174 fn has_pinned_tabs(&self) -> bool {
2175 self.pinned_tab_count != 0
2176 }
2177
2178 fn has_unpinned_tabs(&self) -> bool {
2179 self.pinned_tab_count < self.items.len()
2180 }
2181
2182 fn activate_unpinned_tab(&mut self, window: &mut Window, cx: &mut Context<Self>) {
2183 if self.items.is_empty() {
2184 return;
2185 }
2186 let Some(index) = self
2187 .items()
2188 .enumerate()
2189 .find_map(|(index, _item)| (!self.is_tab_pinned(index)).then_some(index))
2190 else {
2191 return;
2192 };
2193 self.activate_item(index, true, true, window, cx);
2194 }
2195
2196 fn render_tab(
2197 &self,
2198 ix: usize,
2199 item: &dyn ItemHandle,
2200 detail: usize,
2201 focus_handle: &FocusHandle,
2202 window: &mut Window,
2203 cx: &mut Context<Pane>,
2204 ) -> impl IntoElement {
2205 let is_active = ix == self.active_item_index;
2206 let is_preview = self
2207 .preview_item_id
2208 .map(|id| id == item.item_id())
2209 .unwrap_or(false);
2210
2211 let label = item.tab_content(
2212 TabContentParams {
2213 detail: Some(detail),
2214 selected: is_active,
2215 preview: is_preview,
2216 },
2217 window,
2218 cx,
2219 );
2220
2221 let item_diagnostic = item
2222 .project_path(cx)
2223 .map_or(None, |project_path| self.diagnostics.get(&project_path));
2224
2225 let decorated_icon = item_diagnostic.map_or(None, |diagnostic| {
2226 let icon = match item.tab_icon(window, cx) {
2227 Some(icon) => icon,
2228 None => return None,
2229 };
2230
2231 let knockout_item_color = if is_active {
2232 cx.theme().colors().tab_active_background
2233 } else {
2234 cx.theme().colors().tab_bar_background
2235 };
2236
2237 let (icon_decoration, icon_color) = if matches!(diagnostic, &DiagnosticSeverity::ERROR)
2238 {
2239 (IconDecorationKind::X, Color::Error)
2240 } else {
2241 (IconDecorationKind::Triangle, Color::Warning)
2242 };
2243
2244 Some(DecoratedIcon::new(
2245 icon.size(IconSize::Small).color(Color::Muted),
2246 Some(
2247 IconDecoration::new(icon_decoration, knockout_item_color, cx)
2248 .color(icon_color.color(cx))
2249 .position(Point {
2250 x: px(-2.),
2251 y: px(-2.),
2252 }),
2253 ),
2254 ))
2255 });
2256
2257 let icon = if decorated_icon.is_none() {
2258 match item_diagnostic {
2259 Some(&DiagnosticSeverity::ERROR) => None,
2260 Some(&DiagnosticSeverity::WARNING) => None,
2261 _ => item
2262 .tab_icon(window, cx)
2263 .map(|icon| icon.color(Color::Muted)),
2264 }
2265 .map(|icon| icon.size(IconSize::Small))
2266 } else {
2267 None
2268 };
2269
2270 let settings = ItemSettings::get_global(cx);
2271 let close_side = &settings.close_position;
2272 let show_close_button = &settings.show_close_button;
2273 let indicator = render_item_indicator(item.boxed_clone(), cx);
2274 let item_id = item.item_id();
2275 let is_first_item = ix == 0;
2276 let is_last_item = ix == self.items.len() - 1;
2277 let is_pinned = self.is_tab_pinned(ix);
2278 let position_relative_to_active_item = ix.cmp(&self.active_item_index);
2279
2280 let tab = Tab::new(ix)
2281 .position(if is_first_item {
2282 TabPosition::First
2283 } else if is_last_item {
2284 TabPosition::Last
2285 } else {
2286 TabPosition::Middle(position_relative_to_active_item)
2287 })
2288 .close_side(match close_side {
2289 ClosePosition::Left => ui::TabCloseSide::Start,
2290 ClosePosition::Right => ui::TabCloseSide::End,
2291 })
2292 .toggle_state(is_active)
2293 .on_click(cx.listener(move |pane: &mut Self, _, window, cx| {
2294 pane.activate_item(ix, true, true, window, cx)
2295 }))
2296 // TODO: This should be a click listener with the middle mouse button instead of a mouse down listener.
2297 .on_mouse_down(
2298 MouseButton::Middle,
2299 cx.listener(move |pane, _event, window, cx| {
2300 pane.close_item_by_id(item_id, SaveIntent::Close, window, cx)
2301 .detach_and_log_err(cx);
2302 }),
2303 )
2304 .on_mouse_down(
2305 MouseButton::Left,
2306 cx.listener(move |pane, event: &MouseDownEvent, _, cx| {
2307 if let Some(id) = pane.preview_item_id {
2308 if id == item_id && event.click_count > 1 {
2309 pane.set_preview_item_id(None, cx);
2310 }
2311 }
2312 }),
2313 )
2314 .on_drag(
2315 DraggedTab {
2316 item: item.boxed_clone(),
2317 pane: cx.entity().clone(),
2318 detail,
2319 is_active,
2320 ix,
2321 },
2322 |tab, _, _, cx| cx.new(|_| tab.clone()),
2323 )
2324 .drag_over::<DraggedTab>(|tab, _, _, cx| {
2325 tab.bg(cx.theme().colors().drop_target_background)
2326 })
2327 .drag_over::<DraggedSelection>(|tab, _, _, cx| {
2328 tab.bg(cx.theme().colors().drop_target_background)
2329 })
2330 .when_some(self.can_drop_predicate.clone(), |this, p| {
2331 this.can_drop(move |a, window, cx| p(a, window, cx))
2332 })
2333 .on_drop(
2334 cx.listener(move |this, dragged_tab: &DraggedTab, window, cx| {
2335 this.drag_split_direction = None;
2336 this.handle_tab_drop(dragged_tab, ix, window, cx)
2337 }),
2338 )
2339 .on_drop(
2340 cx.listener(move |this, selection: &DraggedSelection, window, cx| {
2341 this.drag_split_direction = None;
2342 this.handle_dragged_selection_drop(selection, Some(ix), window, cx)
2343 }),
2344 )
2345 .on_drop(cx.listener(move |this, paths, window, cx| {
2346 this.drag_split_direction = None;
2347 this.handle_external_paths_drop(paths, window, cx)
2348 }))
2349 .when_some(item.tab_tooltip_content(cx), |tab, content| match content {
2350 TabTooltipContent::Text(text) => tab.tooltip(Tooltip::text(text.clone())),
2351 TabTooltipContent::Custom(element_fn) => {
2352 tab.tooltip(move |window, cx| element_fn(window, cx))
2353 }
2354 })
2355 .start_slot::<Indicator>(indicator)
2356 .map(|this| {
2357 let end_slot_action: &'static dyn Action;
2358 let end_slot_tooltip_text: &'static str;
2359 let end_slot = if is_pinned {
2360 end_slot_action = &TogglePinTab;
2361 end_slot_tooltip_text = "Unpin Tab";
2362 IconButton::new("unpin tab", IconName::Pin)
2363 .shape(IconButtonShape::Square)
2364 .icon_color(Color::Muted)
2365 .size(ButtonSize::None)
2366 .icon_size(IconSize::XSmall)
2367 .on_click(cx.listener(move |pane, _, window, cx| {
2368 pane.unpin_tab_at(ix, window, cx);
2369 }))
2370 } else {
2371 end_slot_action = &CloseActiveItem {
2372 save_intent: None,
2373 close_pinned: false,
2374 };
2375 end_slot_tooltip_text = "Close Tab";
2376 match show_close_button {
2377 ShowCloseButton::Always => IconButton::new("close tab", IconName::Close),
2378 ShowCloseButton::Hover => {
2379 IconButton::new("close tab", IconName::Close).visible_on_hover("")
2380 }
2381 ShowCloseButton::Hidden => return this,
2382 }
2383 .shape(IconButtonShape::Square)
2384 .icon_color(Color::Muted)
2385 .size(ButtonSize::None)
2386 .icon_size(IconSize::XSmall)
2387 .on_click(cx.listener(move |pane, _, window, cx| {
2388 pane.close_item_by_id(item_id, SaveIntent::Close, window, cx)
2389 .detach_and_log_err(cx);
2390 }))
2391 }
2392 .map(|this| {
2393 if is_active {
2394 let focus_handle = focus_handle.clone();
2395 this.tooltip(move |window, cx| {
2396 Tooltip::for_action_in(
2397 end_slot_tooltip_text,
2398 end_slot_action,
2399 &focus_handle,
2400 window,
2401 cx,
2402 )
2403 })
2404 } else {
2405 this.tooltip(Tooltip::text(end_slot_tooltip_text))
2406 }
2407 });
2408 this.end_slot(end_slot)
2409 })
2410 .child(
2411 h_flex()
2412 .gap_1()
2413 .items_center()
2414 .children(
2415 std::iter::once(if let Some(decorated_icon) = decorated_icon {
2416 Some(div().child(decorated_icon.into_any_element()))
2417 } else if let Some(icon) = icon {
2418 Some(div().child(icon.into_any_element()))
2419 } else {
2420 None
2421 })
2422 .flatten(),
2423 )
2424 .child(label),
2425 );
2426
2427 let single_entry_to_resolve = self.items[ix]
2428 .is_singleton(cx)
2429 .then(|| self.items[ix].project_entry_ids(cx).get(0).copied())
2430 .flatten();
2431
2432 let total_items = self.items.len();
2433 let has_items_to_left = ix > 0;
2434 let has_items_to_right = ix < total_items - 1;
2435 let is_pinned = self.is_tab_pinned(ix);
2436 let pane = cx.entity().downgrade();
2437 let menu_context = item.item_focus_handle(cx);
2438 right_click_menu(ix).trigger(tab).menu(move |window, cx| {
2439 let pane = pane.clone();
2440 let menu_context = menu_context.clone();
2441 ContextMenu::build(window, cx, move |mut menu, window, cx| {
2442 if let Some(pane) = pane.upgrade() {
2443 menu = menu
2444 .entry(
2445 "Close",
2446 Some(Box::new(CloseActiveItem {
2447 save_intent: None,
2448 close_pinned: true,
2449 })),
2450 window.handler_for(&pane, move |pane, window, cx| {
2451 pane.close_item_by_id(item_id, SaveIntent::Close, window, cx)
2452 .detach_and_log_err(cx);
2453 }),
2454 )
2455 .item(ContextMenuItem::Entry(
2456 ContextMenuEntry::new("Close Others")
2457 .action(Box::new(CloseInactiveItems {
2458 save_intent: None,
2459 close_pinned: false,
2460 }))
2461 .disabled(total_items == 1)
2462 .handler(window.handler_for(&pane, move |pane, window, cx| {
2463 pane.close_items(window, cx, SaveIntent::Close, |id| {
2464 id != item_id
2465 })
2466 .detach_and_log_err(cx);
2467 })),
2468 ))
2469 .separator()
2470 .item(ContextMenuItem::Entry(
2471 ContextMenuEntry::new("Close Left")
2472 .action(Box::new(CloseItemsToTheLeft {
2473 close_pinned: false,
2474 }))
2475 .disabled(!has_items_to_left)
2476 .handler(window.handler_for(&pane, move |pane, window, cx| {
2477 pane.close_items_to_the_left_by_id(
2478 item_id,
2479 &CloseItemsToTheLeft {
2480 close_pinned: false,
2481 },
2482 pane.get_non_closeable_item_ids(false),
2483 window,
2484 cx,
2485 )
2486 .detach_and_log_err(cx);
2487 })),
2488 ))
2489 .item(ContextMenuItem::Entry(
2490 ContextMenuEntry::new("Close Right")
2491 .action(Box::new(CloseItemsToTheRight {
2492 close_pinned: false,
2493 }))
2494 .disabled(!has_items_to_right)
2495 .handler(window.handler_for(&pane, move |pane, window, cx| {
2496 pane.close_items_to_the_right_by_id(
2497 item_id,
2498 &CloseItemsToTheRight {
2499 close_pinned: false,
2500 },
2501 pane.get_non_closeable_item_ids(false),
2502 window,
2503 cx,
2504 )
2505 .detach_and_log_err(cx);
2506 })),
2507 ))
2508 .separator()
2509 .entry(
2510 "Close Clean",
2511 Some(Box::new(CloseCleanItems {
2512 close_pinned: false,
2513 })),
2514 window.handler_for(&pane, move |pane, window, cx| {
2515 if let Some(task) = pane.close_clean_items(
2516 &CloseCleanItems {
2517 close_pinned: false,
2518 },
2519 window,
2520 cx,
2521 ) {
2522 task.detach_and_log_err(cx)
2523 }
2524 }),
2525 )
2526 .entry(
2527 "Close All",
2528 Some(Box::new(CloseAllItems {
2529 save_intent: None,
2530 close_pinned: false,
2531 })),
2532 window.handler_for(&pane, |pane, window, cx| {
2533 if let Some(task) = pane.close_all_items(
2534 &CloseAllItems {
2535 save_intent: None,
2536 close_pinned: false,
2537 },
2538 window,
2539 cx,
2540 ) {
2541 task.detach_and_log_err(cx)
2542 }
2543 }),
2544 );
2545
2546 let pin_tab_entries = |menu: ContextMenu| {
2547 menu.separator().map(|this| {
2548 if is_pinned {
2549 this.entry(
2550 "Unpin Tab",
2551 Some(TogglePinTab.boxed_clone()),
2552 window.handler_for(&pane, move |pane, window, cx| {
2553 pane.unpin_tab_at(ix, window, cx);
2554 }),
2555 )
2556 } else {
2557 this.entry(
2558 "Pin Tab",
2559 Some(TogglePinTab.boxed_clone()),
2560 window.handler_for(&pane, move |pane, window, cx| {
2561 pane.pin_tab_at(ix, window, cx);
2562 }),
2563 )
2564 }
2565 })
2566 };
2567 if let Some(entry) = single_entry_to_resolve {
2568 let project_path = pane
2569 .read(cx)
2570 .item_for_entry(entry, cx)
2571 .and_then(|item| item.project_path(cx));
2572 let worktree = project_path.as_ref().and_then(|project_path| {
2573 pane.read(cx)
2574 .project
2575 .upgrade()?
2576 .read(cx)
2577 .worktree_for_id(project_path.worktree_id, cx)
2578 });
2579 let has_relative_path = worktree.as_ref().is_some_and(|worktree| {
2580 worktree
2581 .read(cx)
2582 .root_entry()
2583 .map_or(false, |entry| entry.is_dir())
2584 });
2585
2586 let entry_abs_path = pane.read(cx).entry_abs_path(entry, cx);
2587 let parent_abs_path = entry_abs_path
2588 .as_deref()
2589 .and_then(|abs_path| Some(abs_path.parent()?.to_path_buf()));
2590 let relative_path = project_path
2591 .map(|project_path| project_path.path)
2592 .filter(|_| has_relative_path);
2593
2594 let visible_in_project_panel = relative_path.is_some()
2595 && worktree.is_some_and(|worktree| worktree.read(cx).is_visible());
2596
2597 let entry_id = entry.to_proto();
2598 menu = menu
2599 .separator()
2600 .when_some(entry_abs_path, |menu, abs_path| {
2601 menu.entry(
2602 "Copy Path",
2603 Some(Box::new(zed_actions::workspace::CopyPath)),
2604 window.handler_for(&pane, move |_, _, cx| {
2605 cx.write_to_clipboard(ClipboardItem::new_string(
2606 abs_path.to_string_lossy().to_string(),
2607 ));
2608 }),
2609 )
2610 })
2611 .when_some(relative_path, |menu, relative_path| {
2612 menu.entry(
2613 "Copy Relative Path",
2614 Some(Box::new(zed_actions::workspace::CopyRelativePath)),
2615 window.handler_for(&pane, move |_, _, cx| {
2616 cx.write_to_clipboard(ClipboardItem::new_string(
2617 relative_path.to_string_lossy().to_string(),
2618 ));
2619 }),
2620 )
2621 })
2622 .map(pin_tab_entries)
2623 .separator()
2624 .when(visible_in_project_panel, |menu| {
2625 menu.entry(
2626 "Reveal In Project Panel",
2627 Some(Box::new(RevealInProjectPanel {
2628 entry_id: Some(entry_id),
2629 })),
2630 window.handler_for(&pane, move |pane, _, cx| {
2631 pane.project
2632 .update(cx, |_, cx| {
2633 cx.emit(project::Event::RevealInProjectPanel(
2634 ProjectEntryId::from_proto(entry_id),
2635 ))
2636 })
2637 .ok();
2638 }),
2639 )
2640 })
2641 .when_some(parent_abs_path, |menu, parent_abs_path| {
2642 menu.entry(
2643 "Open in Terminal",
2644 Some(Box::new(OpenInTerminal)),
2645 window.handler_for(&pane, move |_, window, cx| {
2646 window.dispatch_action(
2647 OpenTerminal {
2648 working_directory: parent_abs_path.clone(),
2649 }
2650 .boxed_clone(),
2651 cx,
2652 );
2653 }),
2654 )
2655 });
2656 } else {
2657 menu = menu.map(pin_tab_entries);
2658 }
2659 }
2660
2661 menu.context(menu_context)
2662 })
2663 })
2664 }
2665
2666 fn render_tab_bar(&mut self, window: &mut Window, cx: &mut Context<Pane>) -> impl IntoElement {
2667 let focus_handle = self.focus_handle.clone();
2668 let navigate_backward = IconButton::new("navigate_backward", IconName::ArrowLeft)
2669 .icon_size(IconSize::Small)
2670 .on_click({
2671 let entity = cx.entity().clone();
2672 move |_, window, cx| {
2673 entity.update(cx, |pane, cx| pane.navigate_backward(window, cx))
2674 }
2675 })
2676 .disabled(!self.can_navigate_backward())
2677 .tooltip({
2678 let focus_handle = focus_handle.clone();
2679 move |window, cx| {
2680 Tooltip::for_action_in("Go Back", &GoBack, &focus_handle, window, cx)
2681 }
2682 });
2683
2684 let navigate_forward = IconButton::new("navigate_forward", IconName::ArrowRight)
2685 .icon_size(IconSize::Small)
2686 .on_click({
2687 let entity = cx.entity().clone();
2688 move |_, window, cx| entity.update(cx, |pane, cx| pane.navigate_forward(window, cx))
2689 })
2690 .disabled(!self.can_navigate_forward())
2691 .tooltip({
2692 let focus_handle = focus_handle.clone();
2693 move |window, cx| {
2694 Tooltip::for_action_in("Go Forward", &GoForward, &focus_handle, window, cx)
2695 }
2696 });
2697
2698 let mut tab_items = self
2699 .items
2700 .iter()
2701 .enumerate()
2702 .zip(tab_details(&self.items, cx))
2703 .map(|((ix, item), detail)| {
2704 self.render_tab(ix, &**item, detail, &focus_handle, window, cx)
2705 })
2706 .collect::<Vec<_>>();
2707 let tab_count = tab_items.len();
2708 let unpinned_tabs = tab_items.split_off(self.pinned_tab_count);
2709 let pinned_tabs = tab_items;
2710 TabBar::new("tab_bar")
2711 .when(
2712 self.display_nav_history_buttons.unwrap_or_default(),
2713 |tab_bar| {
2714 tab_bar
2715 .start_child(navigate_backward)
2716 .start_child(navigate_forward)
2717 },
2718 )
2719 .map(|tab_bar| {
2720 if self.show_tab_bar_buttons {
2721 let render_tab_buttons = self.render_tab_bar_buttons.clone();
2722 let (left_children, right_children) = render_tab_buttons(self, window, cx);
2723 tab_bar
2724 .start_children(left_children)
2725 .end_children(right_children)
2726 } else {
2727 tab_bar
2728 }
2729 })
2730 .children(pinned_tabs.len().ne(&0).then(|| {
2731 h_flex()
2732 .children(pinned_tabs)
2733 .border_r_2()
2734 .border_color(cx.theme().colors().border)
2735 }))
2736 .child(
2737 h_flex()
2738 .id("unpinned tabs")
2739 .overflow_x_scroll()
2740 .w_full()
2741 .track_scroll(&self.tab_bar_scroll_handle)
2742 .children(unpinned_tabs)
2743 .child(
2744 div()
2745 .id("tab_bar_drop_target")
2746 .min_w_6()
2747 // HACK: This empty child is currently necessary to force the drop target to appear
2748 // despite us setting a min width above.
2749 .child("")
2750 .h_full()
2751 .flex_grow()
2752 .drag_over::<DraggedTab>(|bar, _, _, cx| {
2753 bar.bg(cx.theme().colors().drop_target_background)
2754 })
2755 .drag_over::<DraggedSelection>(|bar, _, _, cx| {
2756 bar.bg(cx.theme().colors().drop_target_background)
2757 })
2758 .on_drop(cx.listener(
2759 move |this, dragged_tab: &DraggedTab, window, cx| {
2760 this.drag_split_direction = None;
2761 this.handle_tab_drop(dragged_tab, this.items.len(), window, cx)
2762 },
2763 ))
2764 .on_drop(cx.listener(
2765 move |this, selection: &DraggedSelection, window, cx| {
2766 this.drag_split_direction = None;
2767 this.handle_project_entry_drop(
2768 &selection.active_selection.entry_id,
2769 Some(tab_count),
2770 window,
2771 cx,
2772 )
2773 },
2774 ))
2775 .on_drop(cx.listener(move |this, paths, window, cx| {
2776 this.drag_split_direction = None;
2777 this.handle_external_paths_drop(paths, window, cx)
2778 }))
2779 .on_click(cx.listener(move |this, event: &ClickEvent, window, cx| {
2780 if event.up.click_count == 2 {
2781 window.dispatch_action(
2782 this.double_click_dispatch_action.boxed_clone(),
2783 cx,
2784 )
2785 }
2786 })),
2787 ),
2788 )
2789 }
2790
2791 pub fn render_menu_overlay(menu: &Entity<ContextMenu>) -> Div {
2792 div().absolute().bottom_0().right_0().size_0().child(
2793 deferred(anchored().anchor(Corner::TopRight).child(menu.clone())).with_priority(1),
2794 )
2795 }
2796
2797 pub fn set_zoomed(&mut self, zoomed: bool, cx: &mut Context<Self>) {
2798 self.zoomed = zoomed;
2799 cx.notify();
2800 }
2801
2802 pub fn is_zoomed(&self) -> bool {
2803 self.zoomed
2804 }
2805
2806 fn handle_drag_move<T: 'static>(
2807 &mut self,
2808 event: &DragMoveEvent<T>,
2809 window: &mut Window,
2810 cx: &mut Context<Self>,
2811 ) {
2812 let can_split_predicate = self.can_split_predicate.take();
2813 let can_split = match &can_split_predicate {
2814 Some(can_split_predicate) => {
2815 can_split_predicate(self, event.dragged_item(), window, cx)
2816 }
2817 None => false,
2818 };
2819 self.can_split_predicate = can_split_predicate;
2820 if !can_split {
2821 return;
2822 }
2823
2824 let rect = event.bounds.size;
2825
2826 let size = event.bounds.size.width.min(event.bounds.size.height)
2827 * WorkspaceSettings::get_global(cx).drop_target_size;
2828
2829 let relative_cursor = Point::new(
2830 event.event.position.x - event.bounds.left(),
2831 event.event.position.y - event.bounds.top(),
2832 );
2833
2834 let direction = if relative_cursor.x < size
2835 || relative_cursor.x > rect.width - size
2836 || relative_cursor.y < size
2837 || relative_cursor.y > rect.height - size
2838 {
2839 [
2840 SplitDirection::Up,
2841 SplitDirection::Right,
2842 SplitDirection::Down,
2843 SplitDirection::Left,
2844 ]
2845 .iter()
2846 .min_by_key(|side| match side {
2847 SplitDirection::Up => relative_cursor.y,
2848 SplitDirection::Right => rect.width - relative_cursor.x,
2849 SplitDirection::Down => rect.height - relative_cursor.y,
2850 SplitDirection::Left => relative_cursor.x,
2851 })
2852 .cloned()
2853 } else {
2854 None
2855 };
2856
2857 if direction != self.drag_split_direction {
2858 self.drag_split_direction = direction;
2859 }
2860 }
2861
2862 fn handle_tab_drop(
2863 &mut self,
2864 dragged_tab: &DraggedTab,
2865 ix: usize,
2866 window: &mut Window,
2867 cx: &mut Context<Self>,
2868 ) {
2869 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
2870 if let ControlFlow::Break(()) = custom_drop_handle(self, dragged_tab, window, cx) {
2871 return;
2872 }
2873 }
2874 let mut to_pane = cx.entity().clone();
2875 let split_direction = self.drag_split_direction;
2876 let item_id = dragged_tab.item.item_id();
2877 if let Some(preview_item_id) = self.preview_item_id {
2878 if item_id == preview_item_id {
2879 self.set_preview_item_id(None, cx);
2880 }
2881 }
2882
2883 let from_pane = dragged_tab.pane.clone();
2884 self.workspace
2885 .update(cx, |_, cx| {
2886 cx.defer_in(window, move |workspace, window, cx| {
2887 if let Some(split_direction) = split_direction {
2888 to_pane = workspace.split_pane(to_pane, split_direction, window, cx);
2889 }
2890 let old_ix = from_pane.read(cx).index_for_item_id(item_id);
2891 let old_len = to_pane.read(cx).items.len();
2892 move_item(&from_pane, &to_pane, item_id, ix, window, cx);
2893 if to_pane == from_pane {
2894 if let Some(old_index) = old_ix {
2895 to_pane.update(cx, |this, _| {
2896 if old_index < this.pinned_tab_count
2897 && (ix == this.items.len() || ix > this.pinned_tab_count)
2898 {
2899 this.pinned_tab_count -= 1;
2900 } else if this.has_pinned_tabs()
2901 && old_index >= this.pinned_tab_count
2902 && ix < this.pinned_tab_count
2903 {
2904 this.pinned_tab_count += 1;
2905 }
2906 });
2907 }
2908 } else {
2909 to_pane.update(cx, |this, _| {
2910 if this.items.len() > old_len // Did we not deduplicate on drag?
2911 && this.has_pinned_tabs()
2912 && ix < this.pinned_tab_count
2913 {
2914 this.pinned_tab_count += 1;
2915 }
2916 });
2917 from_pane.update(cx, |this, _| {
2918 if let Some(index) = old_ix {
2919 if this.pinned_tab_count > index {
2920 this.pinned_tab_count -= 1;
2921 }
2922 }
2923 })
2924 }
2925 });
2926 })
2927 .log_err();
2928 }
2929
2930 fn handle_dragged_selection_drop(
2931 &mut self,
2932 dragged_selection: &DraggedSelection,
2933 dragged_onto: Option<usize>,
2934 window: &mut Window,
2935 cx: &mut Context<Self>,
2936 ) {
2937 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
2938 if let ControlFlow::Break(()) = custom_drop_handle(self, dragged_selection, window, cx)
2939 {
2940 return;
2941 }
2942 }
2943 self.handle_project_entry_drop(
2944 &dragged_selection.active_selection.entry_id,
2945 dragged_onto,
2946 window,
2947 cx,
2948 );
2949 }
2950
2951 fn handle_project_entry_drop(
2952 &mut self,
2953 project_entry_id: &ProjectEntryId,
2954 target: Option<usize>,
2955 window: &mut Window,
2956 cx: &mut Context<Self>,
2957 ) {
2958 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
2959 if let ControlFlow::Break(()) = custom_drop_handle(self, project_entry_id, window, cx) {
2960 return;
2961 }
2962 }
2963 let mut to_pane = cx.entity().clone();
2964 let split_direction = self.drag_split_direction;
2965 let project_entry_id = *project_entry_id;
2966 self.workspace
2967 .update(cx, |_, cx| {
2968 cx.defer_in(window, move |workspace, window, cx| {
2969 if let Some(path) = workspace
2970 .project()
2971 .read(cx)
2972 .path_for_entry(project_entry_id, cx)
2973 {
2974 let load_path_task = workspace.load_path(path, window, cx);
2975 cx.spawn_in(window, |workspace, mut cx| async move {
2976 if let Some((project_entry_id, build_item)) =
2977 load_path_task.await.notify_async_err(&mut cx)
2978 {
2979 let (to_pane, new_item_handle) = workspace
2980 .update_in(&mut cx, |workspace, window, cx| {
2981 if let Some(split_direction) = split_direction {
2982 to_pane = workspace.split_pane(
2983 to_pane,
2984 split_direction,
2985 window,
2986 cx,
2987 );
2988 }
2989 let new_item_handle = to_pane.update(cx, |pane, cx| {
2990 pane.open_item(
2991 project_entry_id,
2992 true,
2993 false,
2994 true,
2995 target,
2996 window,
2997 cx,
2998 build_item,
2999 )
3000 });
3001 (to_pane, new_item_handle)
3002 })
3003 .log_err()?;
3004 to_pane
3005 .update_in(&mut cx, |this, window, cx| {
3006 let Some(index) = this.index_for_item(&*new_item_handle)
3007 else {
3008 return;
3009 };
3010
3011 if target.map_or(false, |target| this.is_tab_pinned(target))
3012 {
3013 this.pin_tab_at(index, window, cx);
3014 }
3015 })
3016 .ok()?
3017 }
3018 Some(())
3019 })
3020 .detach();
3021 };
3022 });
3023 })
3024 .log_err();
3025 }
3026
3027 fn handle_external_paths_drop(
3028 &mut self,
3029 paths: &ExternalPaths,
3030 window: &mut Window,
3031 cx: &mut Context<Self>,
3032 ) {
3033 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
3034 if let ControlFlow::Break(()) = custom_drop_handle(self, paths, window, cx) {
3035 return;
3036 }
3037 }
3038 let mut to_pane = cx.entity().clone();
3039 let mut split_direction = self.drag_split_direction;
3040 let paths = paths.paths().to_vec();
3041 let is_remote = self
3042 .workspace
3043 .update(cx, |workspace, cx| {
3044 if workspace.project().read(cx).is_via_collab() {
3045 workspace.show_error(
3046 &anyhow::anyhow!("Cannot drop files on a remote project"),
3047 cx,
3048 );
3049 true
3050 } else {
3051 false
3052 }
3053 })
3054 .unwrap_or(true);
3055 if is_remote {
3056 return;
3057 }
3058
3059 self.workspace
3060 .update(cx, |workspace, cx| {
3061 let fs = Arc::clone(workspace.project().read(cx).fs());
3062 cx.spawn_in(window, |workspace, mut cx| async move {
3063 let mut is_file_checks = FuturesUnordered::new();
3064 for path in &paths {
3065 is_file_checks.push(fs.is_file(path))
3066 }
3067 let mut has_files_to_open = false;
3068 while let Some(is_file) = is_file_checks.next().await {
3069 if is_file {
3070 has_files_to_open = true;
3071 break;
3072 }
3073 }
3074 drop(is_file_checks);
3075 if !has_files_to_open {
3076 split_direction = None;
3077 }
3078
3079 if let Ok(open_task) = workspace.update_in(&mut cx, |workspace, window, cx| {
3080 if let Some(split_direction) = split_direction {
3081 to_pane = workspace.split_pane(to_pane, split_direction, window, cx);
3082 }
3083 workspace.open_paths(
3084 paths,
3085 OpenOptions {
3086 visible: Some(OpenVisible::OnlyDirectories),
3087 ..Default::default()
3088 },
3089 Some(to_pane.downgrade()),
3090 window,
3091 cx,
3092 )
3093 }) {
3094 let opened_items: Vec<_> = open_task.await;
3095 _ = workspace.update(&mut cx, |workspace, cx| {
3096 for item in opened_items.into_iter().flatten() {
3097 if let Err(e) = item {
3098 workspace.show_error(&e, cx);
3099 }
3100 }
3101 });
3102 }
3103 })
3104 .detach();
3105 })
3106 .log_err();
3107 }
3108
3109 pub fn display_nav_history_buttons(&mut self, display: Option<bool>) {
3110 self.display_nav_history_buttons = display;
3111 }
3112
3113 fn get_non_closeable_item_ids(&self, close_pinned: bool) -> Vec<EntityId> {
3114 if close_pinned {
3115 return vec![];
3116 }
3117
3118 self.items
3119 .iter()
3120 .enumerate()
3121 .filter(|(index, _item)| self.is_tab_pinned(*index))
3122 .map(|(_, item)| item.item_id())
3123 .collect()
3124 }
3125
3126 pub fn drag_split_direction(&self) -> Option<SplitDirection> {
3127 self.drag_split_direction
3128 }
3129
3130 pub fn set_zoom_out_on_close(&mut self, zoom_out_on_close: bool) {
3131 self.zoom_out_on_close = zoom_out_on_close;
3132 }
3133}
3134
3135impl Focusable for Pane {
3136 fn focus_handle(&self, _cx: &App) -> FocusHandle {
3137 self.focus_handle.clone()
3138 }
3139}
3140
3141impl Render for Pane {
3142 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
3143 let mut key_context = KeyContext::new_with_defaults();
3144 key_context.add("Pane");
3145 if self.active_item().is_none() {
3146 key_context.add("EmptyPane");
3147 }
3148
3149 let should_display_tab_bar = self.should_display_tab_bar.clone();
3150 let display_tab_bar = should_display_tab_bar(window, cx);
3151 let Some(project) = self.project.upgrade() else {
3152 return div().track_focus(&self.focus_handle(cx));
3153 };
3154 let is_local = project.read(cx).is_local();
3155
3156 v_flex()
3157 .key_context(key_context)
3158 .track_focus(&self.focus_handle(cx))
3159 .size_full()
3160 .flex_none()
3161 .overflow_hidden()
3162 .on_action(cx.listener(|pane, _: &AlternateFile, window, cx| {
3163 pane.alternate_file(window, cx);
3164 }))
3165 .on_action(
3166 cx.listener(|pane, _: &SplitLeft, _, cx| pane.split(SplitDirection::Left, cx)),
3167 )
3168 .on_action(cx.listener(|pane, _: &SplitUp, _, cx| pane.split(SplitDirection::Up, cx)))
3169 .on_action(cx.listener(|pane, _: &SplitHorizontal, _, cx| {
3170 pane.split(SplitDirection::horizontal(cx), cx)
3171 }))
3172 .on_action(cx.listener(|pane, _: &SplitVertical, _, cx| {
3173 pane.split(SplitDirection::vertical(cx), cx)
3174 }))
3175 .on_action(
3176 cx.listener(|pane, _: &SplitRight, _, cx| pane.split(SplitDirection::Right, cx)),
3177 )
3178 .on_action(
3179 cx.listener(|pane, _: &SplitDown, _, cx| pane.split(SplitDirection::Down, cx)),
3180 )
3181 .on_action(
3182 cx.listener(|pane, _: &GoBack, window, cx| pane.navigate_backward(window, cx)),
3183 )
3184 .on_action(
3185 cx.listener(|pane, _: &GoForward, window, cx| pane.navigate_forward(window, cx)),
3186 )
3187 .on_action(cx.listener(|_, _: &JoinIntoNext, _, cx| {
3188 cx.emit(Event::JoinIntoNext);
3189 }))
3190 .on_action(cx.listener(|_, _: &JoinAll, _, cx| {
3191 cx.emit(Event::JoinAll);
3192 }))
3193 .on_action(cx.listener(Pane::toggle_zoom))
3194 .on_action(
3195 cx.listener(|pane: &mut Pane, action: &ActivateItem, window, cx| {
3196 pane.activate_item(action.0, true, true, window, cx);
3197 }),
3198 )
3199 .on_action(
3200 cx.listener(|pane: &mut Pane, _: &ActivateLastItem, window, cx| {
3201 pane.activate_item(pane.items.len() - 1, true, true, window, cx);
3202 }),
3203 )
3204 .on_action(
3205 cx.listener(|pane: &mut Pane, _: &ActivatePreviousItem, window, cx| {
3206 pane.activate_prev_item(true, window, cx);
3207 }),
3208 )
3209 .on_action(
3210 cx.listener(|pane: &mut Pane, _: &ActivateNextItem, window, cx| {
3211 pane.activate_next_item(true, window, cx);
3212 }),
3213 )
3214 .on_action(
3215 cx.listener(|pane, _: &SwapItemLeft, window, cx| pane.swap_item_left(window, cx)),
3216 )
3217 .on_action(
3218 cx.listener(|pane, _: &SwapItemRight, window, cx| pane.swap_item_right(window, cx)),
3219 )
3220 .on_action(cx.listener(|pane, action, window, cx| {
3221 pane.toggle_pin_tab(action, window, cx);
3222 }))
3223 .when(PreviewTabsSettings::get_global(cx).enabled, |this| {
3224 this.on_action(cx.listener(|pane: &mut Pane, _: &TogglePreviewTab, _, cx| {
3225 if let Some(active_item_id) = pane.active_item().map(|i| i.item_id()) {
3226 if pane.is_active_preview_item(active_item_id) {
3227 pane.set_preview_item_id(None, cx);
3228 } else {
3229 pane.set_preview_item_id(Some(active_item_id), cx);
3230 }
3231 }
3232 }))
3233 })
3234 .on_action(
3235 cx.listener(|pane: &mut Self, action: &CloseActiveItem, window, cx| {
3236 if let Some(task) = pane.close_active_item(action, window, cx) {
3237 task.detach_and_log_err(cx)
3238 }
3239 }),
3240 )
3241 .on_action(
3242 cx.listener(|pane: &mut Self, action: &CloseInactiveItems, window, cx| {
3243 if let Some(task) = pane.close_inactive_items(action, window, cx) {
3244 task.detach_and_log_err(cx)
3245 }
3246 }),
3247 )
3248 .on_action(
3249 cx.listener(|pane: &mut Self, action: &CloseCleanItems, window, cx| {
3250 if let Some(task) = pane.close_clean_items(action, window, cx) {
3251 task.detach_and_log_err(cx)
3252 }
3253 }),
3254 )
3255 .on_action(cx.listener(
3256 |pane: &mut Self, action: &CloseItemsToTheLeft, window, cx| {
3257 if let Some(task) = pane.close_items_to_the_left(action, window, cx) {
3258 task.detach_and_log_err(cx)
3259 }
3260 },
3261 ))
3262 .on_action(cx.listener(
3263 |pane: &mut Self, action: &CloseItemsToTheRight, window, cx| {
3264 if let Some(task) = pane.close_items_to_the_right(action, window, cx) {
3265 task.detach_and_log_err(cx)
3266 }
3267 },
3268 ))
3269 .on_action(
3270 cx.listener(|pane: &mut Self, action: &CloseAllItems, window, cx| {
3271 if let Some(task) = pane.close_all_items(action, window, cx) {
3272 task.detach_and_log_err(cx)
3273 }
3274 }),
3275 )
3276 .on_action(
3277 cx.listener(|pane: &mut Self, action: &CloseActiveItem, window, cx| {
3278 if let Some(task) = pane.close_active_item(action, window, cx) {
3279 task.detach_and_log_err(cx)
3280 }
3281 }),
3282 )
3283 .on_action(
3284 cx.listener(|pane: &mut Self, action: &RevealInProjectPanel, _, cx| {
3285 let entry_id = action
3286 .entry_id
3287 .map(ProjectEntryId::from_proto)
3288 .or_else(|| pane.active_item()?.project_entry_ids(cx).first().copied());
3289 if let Some(entry_id) = entry_id {
3290 pane.project
3291 .update(cx, |_, cx| {
3292 cx.emit(project::Event::RevealInProjectPanel(entry_id))
3293 })
3294 .ok();
3295 }
3296 }),
3297 )
3298 .when(self.active_item().is_some() && display_tab_bar, |pane| {
3299 pane.child(self.render_tab_bar(window, cx))
3300 })
3301 .child({
3302 let has_worktrees = project.read(cx).visible_worktrees(cx).next().is_some();
3303 // main content
3304 div()
3305 .flex_1()
3306 .relative()
3307 .group("")
3308 .overflow_hidden()
3309 .on_drag_move::<DraggedTab>(cx.listener(Self::handle_drag_move))
3310 .on_drag_move::<DraggedSelection>(cx.listener(Self::handle_drag_move))
3311 .when(is_local, |div| {
3312 div.on_drag_move::<ExternalPaths>(cx.listener(Self::handle_drag_move))
3313 })
3314 .map(|div| {
3315 if let Some(item) = self.active_item() {
3316 div.v_flex()
3317 .size_full()
3318 .overflow_hidden()
3319 .child(self.toolbar.clone())
3320 .child(item.to_any())
3321 } else {
3322 let placeholder = div.h_flex().size_full().justify_center();
3323 if has_worktrees {
3324 placeholder
3325 } else {
3326 placeholder.child(
3327 Label::new("Open a file or project to get started.")
3328 .color(Color::Muted),
3329 )
3330 }
3331 }
3332 })
3333 .child(
3334 // drag target
3335 div()
3336 .invisible()
3337 .absolute()
3338 .bg(cx.theme().colors().drop_target_background)
3339 .group_drag_over::<DraggedTab>("", |style| style.visible())
3340 .group_drag_over::<DraggedSelection>("", |style| style.visible())
3341 .when(is_local, |div| {
3342 div.group_drag_over::<ExternalPaths>("", |style| style.visible())
3343 })
3344 .when_some(self.can_drop_predicate.clone(), |this, p| {
3345 this.can_drop(move |a, window, cx| p(a, window, cx))
3346 })
3347 .on_drop(cx.listener(move |this, dragged_tab, window, cx| {
3348 this.handle_tab_drop(
3349 dragged_tab,
3350 this.active_item_index(),
3351 window,
3352 cx,
3353 )
3354 }))
3355 .on_drop(cx.listener(
3356 move |this, selection: &DraggedSelection, window, cx| {
3357 this.handle_dragged_selection_drop(selection, None, window, cx)
3358 },
3359 ))
3360 .on_drop(cx.listener(move |this, paths, window, cx| {
3361 this.handle_external_paths_drop(paths, window, cx)
3362 }))
3363 .map(|div| {
3364 let size = DefiniteLength::Fraction(0.5);
3365 match self.drag_split_direction {
3366 None => div.top_0().right_0().bottom_0().left_0(),
3367 Some(SplitDirection::Up) => {
3368 div.top_0().left_0().right_0().h(size)
3369 }
3370 Some(SplitDirection::Down) => {
3371 div.left_0().bottom_0().right_0().h(size)
3372 }
3373 Some(SplitDirection::Left) => {
3374 div.top_0().left_0().bottom_0().w(size)
3375 }
3376 Some(SplitDirection::Right) => {
3377 div.top_0().bottom_0().right_0().w(size)
3378 }
3379 }
3380 }),
3381 )
3382 })
3383 .on_mouse_down(
3384 MouseButton::Navigate(NavigationDirection::Back),
3385 cx.listener(|pane, _, window, cx| {
3386 if let Some(workspace) = pane.workspace.upgrade() {
3387 let pane = cx.entity().downgrade();
3388 window.defer(cx, move |window, cx| {
3389 workspace.update(cx, |workspace, cx| {
3390 workspace.go_back(pane, window, cx).detach_and_log_err(cx)
3391 })
3392 })
3393 }
3394 }),
3395 )
3396 .on_mouse_down(
3397 MouseButton::Navigate(NavigationDirection::Forward),
3398 cx.listener(|pane, _, window, cx| {
3399 if let Some(workspace) = pane.workspace.upgrade() {
3400 let pane = cx.entity().downgrade();
3401 window.defer(cx, move |window, cx| {
3402 workspace.update(cx, |workspace, cx| {
3403 workspace
3404 .go_forward(pane, window, cx)
3405 .detach_and_log_err(cx)
3406 })
3407 })
3408 }
3409 }),
3410 )
3411 }
3412}
3413
3414impl ItemNavHistory {
3415 pub fn push<D: 'static + Send + Any>(&mut self, data: Option<D>, cx: &mut App) {
3416 if self
3417 .item
3418 .upgrade()
3419 .is_some_and(|item| item.include_in_nav_history())
3420 {
3421 self.history
3422 .push(data, self.item.clone(), self.is_preview, cx);
3423 }
3424 }
3425
3426 pub fn pop_backward(&mut self, cx: &mut App) -> Option<NavigationEntry> {
3427 self.history.pop(NavigationMode::GoingBack, cx)
3428 }
3429
3430 pub fn pop_forward(&mut self, cx: &mut App) -> Option<NavigationEntry> {
3431 self.history.pop(NavigationMode::GoingForward, cx)
3432 }
3433}
3434
3435impl NavHistory {
3436 pub fn for_each_entry(
3437 &self,
3438 cx: &App,
3439 mut f: impl FnMut(&NavigationEntry, (ProjectPath, Option<PathBuf>)),
3440 ) {
3441 let borrowed_history = self.0.lock();
3442 borrowed_history
3443 .forward_stack
3444 .iter()
3445 .chain(borrowed_history.backward_stack.iter())
3446 .chain(borrowed_history.closed_stack.iter())
3447 .for_each(|entry| {
3448 if let Some(project_and_abs_path) =
3449 borrowed_history.paths_by_item.get(&entry.item.id())
3450 {
3451 f(entry, project_and_abs_path.clone());
3452 } else if let Some(item) = entry.item.upgrade() {
3453 if let Some(path) = item.project_path(cx) {
3454 f(entry, (path, None));
3455 }
3456 }
3457 })
3458 }
3459
3460 pub fn set_mode(&mut self, mode: NavigationMode) {
3461 self.0.lock().mode = mode;
3462 }
3463
3464 pub fn mode(&self) -> NavigationMode {
3465 self.0.lock().mode
3466 }
3467
3468 pub fn disable(&mut self) {
3469 self.0.lock().mode = NavigationMode::Disabled;
3470 }
3471
3472 pub fn enable(&mut self) {
3473 self.0.lock().mode = NavigationMode::Normal;
3474 }
3475
3476 pub fn pop(&mut self, mode: NavigationMode, cx: &mut App) -> Option<NavigationEntry> {
3477 let mut state = self.0.lock();
3478 let entry = match mode {
3479 NavigationMode::Normal | NavigationMode::Disabled | NavigationMode::ClosingItem => {
3480 return None
3481 }
3482 NavigationMode::GoingBack => &mut state.backward_stack,
3483 NavigationMode::GoingForward => &mut state.forward_stack,
3484 NavigationMode::ReopeningClosedItem => &mut state.closed_stack,
3485 }
3486 .pop_back();
3487 if entry.is_some() {
3488 state.did_update(cx);
3489 }
3490 entry
3491 }
3492
3493 pub fn push<D: 'static + Send + Any>(
3494 &mut self,
3495 data: Option<D>,
3496 item: Arc<dyn WeakItemHandle>,
3497 is_preview: bool,
3498 cx: &mut App,
3499 ) {
3500 let state = &mut *self.0.lock();
3501 match state.mode {
3502 NavigationMode::Disabled => {}
3503 NavigationMode::Normal | NavigationMode::ReopeningClosedItem => {
3504 if state.backward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3505 state.backward_stack.pop_front();
3506 }
3507 state.backward_stack.push_back(NavigationEntry {
3508 item,
3509 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3510 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3511 is_preview,
3512 });
3513 state.forward_stack.clear();
3514 }
3515 NavigationMode::GoingBack => {
3516 if state.forward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3517 state.forward_stack.pop_front();
3518 }
3519 state.forward_stack.push_back(NavigationEntry {
3520 item,
3521 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3522 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3523 is_preview,
3524 });
3525 }
3526 NavigationMode::GoingForward => {
3527 if state.backward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3528 state.backward_stack.pop_front();
3529 }
3530 state.backward_stack.push_back(NavigationEntry {
3531 item,
3532 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3533 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3534 is_preview,
3535 });
3536 }
3537 NavigationMode::ClosingItem => {
3538 if state.closed_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3539 state.closed_stack.pop_front();
3540 }
3541 state.closed_stack.push_back(NavigationEntry {
3542 item,
3543 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3544 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3545 is_preview,
3546 });
3547 }
3548 }
3549 state.did_update(cx);
3550 }
3551
3552 pub fn remove_item(&mut self, item_id: EntityId) {
3553 let mut state = self.0.lock();
3554 state.paths_by_item.remove(&item_id);
3555 state
3556 .backward_stack
3557 .retain(|entry| entry.item.id() != item_id);
3558 state
3559 .forward_stack
3560 .retain(|entry| entry.item.id() != item_id);
3561 state
3562 .closed_stack
3563 .retain(|entry| entry.item.id() != item_id);
3564 }
3565
3566 pub fn path_for_item(&self, item_id: EntityId) -> Option<(ProjectPath, Option<PathBuf>)> {
3567 self.0.lock().paths_by_item.get(&item_id).cloned()
3568 }
3569}
3570
3571impl NavHistoryState {
3572 pub fn did_update(&self, cx: &mut App) {
3573 if let Some(pane) = self.pane.upgrade() {
3574 cx.defer(move |cx| {
3575 pane.update(cx, |pane, cx| pane.history_updated(cx));
3576 });
3577 }
3578 }
3579}
3580
3581fn dirty_message_for(buffer_path: Option<ProjectPath>) -> String {
3582 let path = buffer_path
3583 .as_ref()
3584 .and_then(|p| {
3585 p.path
3586 .to_str()
3587 .and_then(|s| if s.is_empty() { None } else { Some(s) })
3588 })
3589 .unwrap_or("This buffer");
3590 let path = truncate_and_remove_front(path, 80);
3591 format!("{path} contains unsaved edits. Do you want to save it?")
3592}
3593
3594pub fn tab_details(items: &[Box<dyn ItemHandle>], cx: &App) -> Vec<usize> {
3595 let mut tab_details = items.iter().map(|_| 0).collect::<Vec<_>>();
3596 let mut tab_descriptions = HashMap::default();
3597 let mut done = false;
3598 while !done {
3599 done = true;
3600
3601 // Store item indices by their tab description.
3602 for (ix, (item, detail)) in items.iter().zip(&tab_details).enumerate() {
3603 if let Some(description) = item.tab_description(*detail, cx) {
3604 if *detail == 0
3605 || Some(&description) != item.tab_description(detail - 1, cx).as_ref()
3606 {
3607 tab_descriptions
3608 .entry(description)
3609 .or_insert(Vec::new())
3610 .push(ix);
3611 }
3612 }
3613 }
3614
3615 // If two or more items have the same tab description, increase their level
3616 // of detail and try again.
3617 for (_, item_ixs) in tab_descriptions.drain() {
3618 if item_ixs.len() > 1 {
3619 done = false;
3620 for ix in item_ixs {
3621 tab_details[ix] += 1;
3622 }
3623 }
3624 }
3625 }
3626
3627 tab_details
3628}
3629
3630pub fn render_item_indicator(item: Box<dyn ItemHandle>, cx: &App) -> Option<Indicator> {
3631 maybe!({
3632 let indicator_color = match (item.has_conflict(cx), item.is_dirty(cx)) {
3633 (true, _) => Color::Warning,
3634 (_, true) => Color::Accent,
3635 (false, false) => return None,
3636 };
3637
3638 Some(Indicator::dot().color(indicator_color))
3639 })
3640}
3641
3642impl Render for DraggedTab {
3643 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
3644 let ui_font = ThemeSettings::get_global(cx).ui_font.clone();
3645 let label = self.item.tab_content(
3646 TabContentParams {
3647 detail: Some(self.detail),
3648 selected: false,
3649 preview: false,
3650 },
3651 window,
3652 cx,
3653 );
3654 Tab::new("")
3655 .toggle_state(self.is_active)
3656 .child(label)
3657 .render(window, cx)
3658 .font(ui_font)
3659 }
3660}
3661
3662#[cfg(test)]
3663mod tests {
3664 use std::num::NonZero;
3665
3666 use super::*;
3667 use crate::item::test::{TestItem, TestProjectItem};
3668 use gpui::{TestAppContext, VisualTestContext};
3669 use project::FakeFs;
3670 use settings::SettingsStore;
3671 use theme::LoadThemes;
3672
3673 #[gpui::test]
3674 async fn test_remove_active_empty(cx: &mut TestAppContext) {
3675 init_test(cx);
3676 let fs = FakeFs::new(cx.executor());
3677
3678 let project = Project::test(fs, None, cx).await;
3679 let (workspace, cx) =
3680 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3681 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3682
3683 pane.update_in(cx, |pane, window, cx| {
3684 assert!(pane
3685 .close_active_item(
3686 &CloseActiveItem {
3687 save_intent: None,
3688 close_pinned: false
3689 },
3690 window,
3691 cx
3692 )
3693 .is_none())
3694 });
3695 }
3696
3697 #[gpui::test]
3698 async fn test_add_item_capped_to_max_tabs(cx: &mut TestAppContext) {
3699 init_test(cx);
3700 let fs = FakeFs::new(cx.executor());
3701
3702 let project = Project::test(fs, None, cx).await;
3703 let (workspace, cx) =
3704 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3705 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3706
3707 for i in 0..7 {
3708 add_labeled_item(&pane, format!("{}", i).as_str(), false, cx);
3709 }
3710 set_max_tabs(cx, Some(5));
3711 add_labeled_item(&pane, "7", false, cx);
3712 // Remove items to respect the max tab cap.
3713 assert_item_labels(&pane, ["3", "4", "5", "6", "7*"], cx);
3714 pane.update_in(cx, |pane, window, cx| {
3715 pane.activate_item(0, false, false, window, cx);
3716 });
3717 add_labeled_item(&pane, "X", false, cx);
3718 // Respect activation order.
3719 assert_item_labels(&pane, ["3", "X*", "5", "6", "7"], cx);
3720
3721 for i in 0..7 {
3722 add_labeled_item(&pane, format!("D{}", i).as_str(), true, cx);
3723 }
3724 // Keeps dirty items, even over max tab cap.
3725 assert_item_labels(
3726 &pane,
3727 ["D0^", "D1^", "D2^", "D3^", "D4^", "D5^", "D6*^"],
3728 cx,
3729 );
3730
3731 set_max_tabs(cx, None);
3732 for i in 0..7 {
3733 add_labeled_item(&pane, format!("N{}", i).as_str(), false, cx);
3734 }
3735 // No cap when max tabs is None.
3736 assert_item_labels(
3737 &pane,
3738 [
3739 "D0^", "D1^", "D2^", "D3^", "D4^", "D5^", "D6^", "N0", "N1", "N2", "N3", "N4",
3740 "N5", "N6*",
3741 ],
3742 cx,
3743 );
3744 }
3745
3746 #[gpui::test]
3747 async fn test_add_item_with_new_item(cx: &mut TestAppContext) {
3748 init_test(cx);
3749 let fs = FakeFs::new(cx.executor());
3750
3751 let project = Project::test(fs, None, cx).await;
3752 let (workspace, cx) =
3753 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3754 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3755
3756 // 1. Add with a destination index
3757 // a. Add before the active item
3758 set_labeled_items(&pane, ["A", "B*", "C"], cx);
3759 pane.update_in(cx, |pane, window, cx| {
3760 pane.add_item(
3761 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3762 false,
3763 false,
3764 Some(0),
3765 window,
3766 cx,
3767 );
3768 });
3769 assert_item_labels(&pane, ["D*", "A", "B", "C"], cx);
3770
3771 // b. Add after the active item
3772 set_labeled_items(&pane, ["A", "B*", "C"], cx);
3773 pane.update_in(cx, |pane, window, cx| {
3774 pane.add_item(
3775 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3776 false,
3777 false,
3778 Some(2),
3779 window,
3780 cx,
3781 );
3782 });
3783 assert_item_labels(&pane, ["A", "B", "D*", "C"], cx);
3784
3785 // c. Add at the end of the item list (including off the length)
3786 set_labeled_items(&pane, ["A", "B*", "C"], cx);
3787 pane.update_in(cx, |pane, window, cx| {
3788 pane.add_item(
3789 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3790 false,
3791 false,
3792 Some(5),
3793 window,
3794 cx,
3795 );
3796 });
3797 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
3798
3799 // 2. Add without a destination index
3800 // a. Add with active item at the start of the item list
3801 set_labeled_items(&pane, ["A*", "B", "C"], cx);
3802 pane.update_in(cx, |pane, window, cx| {
3803 pane.add_item(
3804 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3805 false,
3806 false,
3807 None,
3808 window,
3809 cx,
3810 );
3811 });
3812 set_labeled_items(&pane, ["A", "D*", "B", "C"], cx);
3813
3814 // b. Add with active item at the end of the item list
3815 set_labeled_items(&pane, ["A", "B", "C*"], cx);
3816 pane.update_in(cx, |pane, window, cx| {
3817 pane.add_item(
3818 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3819 false,
3820 false,
3821 None,
3822 window,
3823 cx,
3824 );
3825 });
3826 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
3827 }
3828
3829 #[gpui::test]
3830 async fn test_add_item_with_existing_item(cx: &mut TestAppContext) {
3831 init_test(cx);
3832 let fs = FakeFs::new(cx.executor());
3833
3834 let project = Project::test(fs, None, cx).await;
3835 let (workspace, cx) =
3836 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3837 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3838
3839 // 1. Add with a destination index
3840 // 1a. Add before the active item
3841 let [_, _, _, d] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
3842 pane.update_in(cx, |pane, window, cx| {
3843 pane.add_item(d, false, false, Some(0), window, cx);
3844 });
3845 assert_item_labels(&pane, ["D*", "A", "B", "C"], cx);
3846
3847 // 1b. Add after the active item
3848 let [_, _, _, d] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
3849 pane.update_in(cx, |pane, window, cx| {
3850 pane.add_item(d, false, false, Some(2), window, cx);
3851 });
3852 assert_item_labels(&pane, ["A", "B", "D*", "C"], cx);
3853
3854 // 1c. Add at the end of the item list (including off the length)
3855 let [a, _, _, _] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
3856 pane.update_in(cx, |pane, window, cx| {
3857 pane.add_item(a, false, false, Some(5), window, cx);
3858 });
3859 assert_item_labels(&pane, ["B", "C", "D", "A*"], cx);
3860
3861 // 1d. Add same item to active index
3862 let [_, b, _] = set_labeled_items(&pane, ["A", "B*", "C"], cx);
3863 pane.update_in(cx, |pane, window, cx| {
3864 pane.add_item(b, false, false, Some(1), window, cx);
3865 });
3866 assert_item_labels(&pane, ["A", "B*", "C"], cx);
3867
3868 // 1e. Add item to index after same item in last position
3869 let [_, _, c] = set_labeled_items(&pane, ["A", "B*", "C"], cx);
3870 pane.update_in(cx, |pane, window, cx| {
3871 pane.add_item(c, false, false, Some(2), window, cx);
3872 });
3873 assert_item_labels(&pane, ["A", "B", "C*"], cx);
3874
3875 // 2. Add without a destination index
3876 // 2a. Add with active item at the start of the item list
3877 let [_, _, _, d] = set_labeled_items(&pane, ["A*", "B", "C", "D"], cx);
3878 pane.update_in(cx, |pane, window, cx| {
3879 pane.add_item(d, false, false, None, window, cx);
3880 });
3881 assert_item_labels(&pane, ["A", "D*", "B", "C"], cx);
3882
3883 // 2b. Add with active item at the end of the item list
3884 let [a, _, _, _] = set_labeled_items(&pane, ["A", "B", "C", "D*"], cx);
3885 pane.update_in(cx, |pane, window, cx| {
3886 pane.add_item(a, false, false, None, window, cx);
3887 });
3888 assert_item_labels(&pane, ["B", "C", "D", "A*"], cx);
3889
3890 // 2c. Add active item to active item at end of list
3891 let [_, _, c] = set_labeled_items(&pane, ["A", "B", "C*"], cx);
3892 pane.update_in(cx, |pane, window, cx| {
3893 pane.add_item(c, false, false, None, window, cx);
3894 });
3895 assert_item_labels(&pane, ["A", "B", "C*"], cx);
3896
3897 // 2d. Add active item to active item at start of list
3898 let [a, _, _] = set_labeled_items(&pane, ["A*", "B", "C"], cx);
3899 pane.update_in(cx, |pane, window, cx| {
3900 pane.add_item(a, false, false, None, window, cx);
3901 });
3902 assert_item_labels(&pane, ["A*", "B", "C"], cx);
3903 }
3904
3905 #[gpui::test]
3906 async fn test_add_item_with_same_project_entries(cx: &mut TestAppContext) {
3907 init_test(cx);
3908 let fs = FakeFs::new(cx.executor());
3909
3910 let project = Project::test(fs, None, cx).await;
3911 let (workspace, cx) =
3912 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3913 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3914
3915 // singleton view
3916 pane.update_in(cx, |pane, window, cx| {
3917 pane.add_item(
3918 Box::new(cx.new(|cx| {
3919 TestItem::new(cx)
3920 .with_singleton(true)
3921 .with_label("buffer 1")
3922 .with_project_items(&[TestProjectItem::new(1, "one.txt", cx)])
3923 })),
3924 false,
3925 false,
3926 None,
3927 window,
3928 cx,
3929 );
3930 });
3931 assert_item_labels(&pane, ["buffer 1*"], cx);
3932
3933 // new singleton view with the same project entry
3934 pane.update_in(cx, |pane, window, cx| {
3935 pane.add_item(
3936 Box::new(cx.new(|cx| {
3937 TestItem::new(cx)
3938 .with_singleton(true)
3939 .with_label("buffer 1")
3940 .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
3941 })),
3942 false,
3943 false,
3944 None,
3945 window,
3946 cx,
3947 );
3948 });
3949 assert_item_labels(&pane, ["buffer 1*"], cx);
3950
3951 // new singleton view with different project entry
3952 pane.update_in(cx, |pane, window, cx| {
3953 pane.add_item(
3954 Box::new(cx.new(|cx| {
3955 TestItem::new(cx)
3956 .with_singleton(true)
3957 .with_label("buffer 2")
3958 .with_project_items(&[TestProjectItem::new(2, "2.txt", cx)])
3959 })),
3960 false,
3961 false,
3962 None,
3963 window,
3964 cx,
3965 );
3966 });
3967 assert_item_labels(&pane, ["buffer 1", "buffer 2*"], cx);
3968
3969 // new multibuffer view with the same project entry
3970 pane.update_in(cx, |pane, window, cx| {
3971 pane.add_item(
3972 Box::new(cx.new(|cx| {
3973 TestItem::new(cx)
3974 .with_singleton(false)
3975 .with_label("multibuffer 1")
3976 .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
3977 })),
3978 false,
3979 false,
3980 None,
3981 window,
3982 cx,
3983 );
3984 });
3985 assert_item_labels(&pane, ["buffer 1", "buffer 2", "multibuffer 1*"], cx);
3986
3987 // another multibuffer view with the same project entry
3988 pane.update_in(cx, |pane, window, cx| {
3989 pane.add_item(
3990 Box::new(cx.new(|cx| {
3991 TestItem::new(cx)
3992 .with_singleton(false)
3993 .with_label("multibuffer 1b")
3994 .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
3995 })),
3996 false,
3997 false,
3998 None,
3999 window,
4000 cx,
4001 );
4002 });
4003 assert_item_labels(
4004 &pane,
4005 ["buffer 1", "buffer 2", "multibuffer 1", "multibuffer 1b*"],
4006 cx,
4007 );
4008 }
4009
4010 #[gpui::test]
4011 async fn test_remove_item_ordering_history(cx: &mut TestAppContext) {
4012 init_test(cx);
4013 let fs = FakeFs::new(cx.executor());
4014
4015 let project = Project::test(fs, None, cx).await;
4016 let (workspace, cx) =
4017 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4018 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4019
4020 add_labeled_item(&pane, "A", false, cx);
4021 add_labeled_item(&pane, "B", false, cx);
4022 add_labeled_item(&pane, "C", false, cx);
4023 add_labeled_item(&pane, "D", false, cx);
4024 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4025
4026 pane.update_in(cx, |pane, window, cx| {
4027 pane.activate_item(1, false, false, window, cx)
4028 });
4029 add_labeled_item(&pane, "1", false, cx);
4030 assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
4031
4032 pane.update_in(cx, |pane, window, cx| {
4033 pane.close_active_item(
4034 &CloseActiveItem {
4035 save_intent: None,
4036 close_pinned: false,
4037 },
4038 window,
4039 cx,
4040 )
4041 })
4042 .unwrap()
4043 .await
4044 .unwrap();
4045 assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
4046
4047 pane.update_in(cx, |pane, window, cx| {
4048 pane.activate_item(3, false, false, window, cx)
4049 });
4050 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4051
4052 pane.update_in(cx, |pane, window, cx| {
4053 pane.close_active_item(
4054 &CloseActiveItem {
4055 save_intent: None,
4056 close_pinned: false,
4057 },
4058 window,
4059 cx,
4060 )
4061 })
4062 .unwrap()
4063 .await
4064 .unwrap();
4065 assert_item_labels(&pane, ["A", "B*", "C"], cx);
4066
4067 pane.update_in(cx, |pane, window, cx| {
4068 pane.close_active_item(
4069 &CloseActiveItem {
4070 save_intent: None,
4071 close_pinned: false,
4072 },
4073 window,
4074 cx,
4075 )
4076 })
4077 .unwrap()
4078 .await
4079 .unwrap();
4080 assert_item_labels(&pane, ["A", "C*"], cx);
4081
4082 pane.update_in(cx, |pane, window, cx| {
4083 pane.close_active_item(
4084 &CloseActiveItem {
4085 save_intent: None,
4086 close_pinned: false,
4087 },
4088 window,
4089 cx,
4090 )
4091 })
4092 .unwrap()
4093 .await
4094 .unwrap();
4095 assert_item_labels(&pane, ["A*"], cx);
4096 }
4097
4098 #[gpui::test]
4099 async fn test_remove_item_ordering_neighbour(cx: &mut TestAppContext) {
4100 init_test(cx);
4101 cx.update_global::<SettingsStore, ()>(|s, cx| {
4102 s.update_user_settings::<ItemSettings>(cx, |s| {
4103 s.activate_on_close = Some(ActivateOnClose::Neighbour);
4104 });
4105 });
4106 let fs = FakeFs::new(cx.executor());
4107
4108 let project = Project::test(fs, None, cx).await;
4109 let (workspace, cx) =
4110 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4111 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4112
4113 add_labeled_item(&pane, "A", false, cx);
4114 add_labeled_item(&pane, "B", false, cx);
4115 add_labeled_item(&pane, "C", false, cx);
4116 add_labeled_item(&pane, "D", false, cx);
4117 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4118
4119 pane.update_in(cx, |pane, window, cx| {
4120 pane.activate_item(1, false, false, window, cx)
4121 });
4122 add_labeled_item(&pane, "1", false, cx);
4123 assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
4124
4125 pane.update_in(cx, |pane, window, cx| {
4126 pane.close_active_item(
4127 &CloseActiveItem {
4128 save_intent: None,
4129 close_pinned: false,
4130 },
4131 window,
4132 cx,
4133 )
4134 })
4135 .unwrap()
4136 .await
4137 .unwrap();
4138 assert_item_labels(&pane, ["A", "B", "C*", "D"], cx);
4139
4140 pane.update_in(cx, |pane, window, cx| {
4141 pane.activate_item(3, false, false, window, cx)
4142 });
4143 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4144
4145 pane.update_in(cx, |pane, window, cx| {
4146 pane.close_active_item(
4147 &CloseActiveItem {
4148 save_intent: None,
4149 close_pinned: false,
4150 },
4151 window,
4152 cx,
4153 )
4154 })
4155 .unwrap()
4156 .await
4157 .unwrap();
4158 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4159
4160 pane.update_in(cx, |pane, window, cx| {
4161 pane.close_active_item(
4162 &CloseActiveItem {
4163 save_intent: None,
4164 close_pinned: false,
4165 },
4166 window,
4167 cx,
4168 )
4169 })
4170 .unwrap()
4171 .await
4172 .unwrap();
4173 assert_item_labels(&pane, ["A", "B*"], cx);
4174
4175 pane.update_in(cx, |pane, window, cx| {
4176 pane.close_active_item(
4177 &CloseActiveItem {
4178 save_intent: None,
4179 close_pinned: false,
4180 },
4181 window,
4182 cx,
4183 )
4184 })
4185 .unwrap()
4186 .await
4187 .unwrap();
4188 assert_item_labels(&pane, ["A*"], cx);
4189 }
4190
4191 #[gpui::test]
4192 async fn test_remove_item_ordering_left_neighbour(cx: &mut TestAppContext) {
4193 init_test(cx);
4194 cx.update_global::<SettingsStore, ()>(|s, cx| {
4195 s.update_user_settings::<ItemSettings>(cx, |s| {
4196 s.activate_on_close = Some(ActivateOnClose::LeftNeighbour);
4197 });
4198 });
4199 let fs = FakeFs::new(cx.executor());
4200
4201 let project = Project::test(fs, None, cx).await;
4202 let (workspace, cx) =
4203 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4204 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4205
4206 add_labeled_item(&pane, "A", false, cx);
4207 add_labeled_item(&pane, "B", false, cx);
4208 add_labeled_item(&pane, "C", false, cx);
4209 add_labeled_item(&pane, "D", false, cx);
4210 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4211
4212 pane.update_in(cx, |pane, window, cx| {
4213 pane.activate_item(1, false, false, window, cx)
4214 });
4215 add_labeled_item(&pane, "1", false, cx);
4216 assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
4217
4218 pane.update_in(cx, |pane, window, cx| {
4219 pane.close_active_item(
4220 &CloseActiveItem {
4221 save_intent: None,
4222 close_pinned: false,
4223 },
4224 window,
4225 cx,
4226 )
4227 })
4228 .unwrap()
4229 .await
4230 .unwrap();
4231 assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
4232
4233 pane.update_in(cx, |pane, window, cx| {
4234 pane.activate_item(3, false, false, window, cx)
4235 });
4236 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4237
4238 pane.update_in(cx, |pane, window, cx| {
4239 pane.close_active_item(
4240 &CloseActiveItem {
4241 save_intent: None,
4242 close_pinned: false,
4243 },
4244 window,
4245 cx,
4246 )
4247 })
4248 .unwrap()
4249 .await
4250 .unwrap();
4251 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4252
4253 pane.update_in(cx, |pane, window, cx| {
4254 pane.activate_item(0, false, false, window, cx)
4255 });
4256 assert_item_labels(&pane, ["A*", "B", "C"], cx);
4257
4258 pane.update_in(cx, |pane, window, cx| {
4259 pane.close_active_item(
4260 &CloseActiveItem {
4261 save_intent: None,
4262 close_pinned: false,
4263 },
4264 window,
4265 cx,
4266 )
4267 })
4268 .unwrap()
4269 .await
4270 .unwrap();
4271 assert_item_labels(&pane, ["B*", "C"], cx);
4272
4273 pane.update_in(cx, |pane, window, cx| {
4274 pane.close_active_item(
4275 &CloseActiveItem {
4276 save_intent: None,
4277 close_pinned: false,
4278 },
4279 window,
4280 cx,
4281 )
4282 })
4283 .unwrap()
4284 .await
4285 .unwrap();
4286 assert_item_labels(&pane, ["C*"], cx);
4287 }
4288
4289 #[gpui::test]
4290 async fn test_close_inactive_items(cx: &mut TestAppContext) {
4291 init_test(cx);
4292 let fs = FakeFs::new(cx.executor());
4293
4294 let project = Project::test(fs, None, cx).await;
4295 let (workspace, cx) =
4296 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4297 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4298
4299 set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
4300
4301 pane.update_in(cx, |pane, window, cx| {
4302 pane.close_inactive_items(
4303 &CloseInactiveItems {
4304 save_intent: None,
4305 close_pinned: false,
4306 },
4307 window,
4308 cx,
4309 )
4310 })
4311 .unwrap()
4312 .await
4313 .unwrap();
4314 assert_item_labels(&pane, ["C*"], cx);
4315 }
4316
4317 #[gpui::test]
4318 async fn test_close_clean_items(cx: &mut TestAppContext) {
4319 init_test(cx);
4320 let fs = FakeFs::new(cx.executor());
4321
4322 let project = Project::test(fs, None, cx).await;
4323 let (workspace, cx) =
4324 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4325 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4326
4327 add_labeled_item(&pane, "A", true, cx);
4328 add_labeled_item(&pane, "B", false, cx);
4329 add_labeled_item(&pane, "C", true, cx);
4330 add_labeled_item(&pane, "D", false, cx);
4331 add_labeled_item(&pane, "E", false, cx);
4332 assert_item_labels(&pane, ["A^", "B", "C^", "D", "E*"], cx);
4333
4334 pane.update_in(cx, |pane, window, cx| {
4335 pane.close_clean_items(
4336 &CloseCleanItems {
4337 close_pinned: false,
4338 },
4339 window,
4340 cx,
4341 )
4342 })
4343 .unwrap()
4344 .await
4345 .unwrap();
4346 assert_item_labels(&pane, ["A^", "C*^"], cx);
4347 }
4348
4349 #[gpui::test]
4350 async fn test_close_items_to_the_left(cx: &mut TestAppContext) {
4351 init_test(cx);
4352 let fs = FakeFs::new(cx.executor());
4353
4354 let project = Project::test(fs, None, cx).await;
4355 let (workspace, cx) =
4356 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4357 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4358
4359 set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
4360
4361 pane.update_in(cx, |pane, window, cx| {
4362 pane.close_items_to_the_left(
4363 &CloseItemsToTheLeft {
4364 close_pinned: false,
4365 },
4366 window,
4367 cx,
4368 )
4369 })
4370 .unwrap()
4371 .await
4372 .unwrap();
4373 assert_item_labels(&pane, ["C*", "D", "E"], cx);
4374 }
4375
4376 #[gpui::test]
4377 async fn test_close_items_to_the_right(cx: &mut TestAppContext) {
4378 init_test(cx);
4379 let fs = FakeFs::new(cx.executor());
4380
4381 let project = Project::test(fs, None, cx).await;
4382 let (workspace, cx) =
4383 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4384 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4385
4386 set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
4387
4388 pane.update_in(cx, |pane, window, cx| {
4389 pane.close_items_to_the_right(
4390 &CloseItemsToTheRight {
4391 close_pinned: false,
4392 },
4393 window,
4394 cx,
4395 )
4396 })
4397 .unwrap()
4398 .await
4399 .unwrap();
4400 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4401 }
4402
4403 #[gpui::test]
4404 async fn test_close_all_items(cx: &mut TestAppContext) {
4405 init_test(cx);
4406 let fs = FakeFs::new(cx.executor());
4407
4408 let project = Project::test(fs, None, cx).await;
4409 let (workspace, cx) =
4410 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4411 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4412
4413 let item_a = add_labeled_item(&pane, "A", false, cx);
4414 add_labeled_item(&pane, "B", false, cx);
4415 add_labeled_item(&pane, "C", false, cx);
4416 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4417
4418 pane.update_in(cx, |pane, window, cx| {
4419 let ix = pane.index_for_item_id(item_a.item_id()).unwrap();
4420 pane.pin_tab_at(ix, window, cx);
4421 pane.close_all_items(
4422 &CloseAllItems {
4423 save_intent: None,
4424 close_pinned: false,
4425 },
4426 window,
4427 cx,
4428 )
4429 })
4430 .unwrap()
4431 .await
4432 .unwrap();
4433 assert_item_labels(&pane, ["A*"], cx);
4434
4435 pane.update_in(cx, |pane, window, cx| {
4436 let ix = pane.index_for_item_id(item_a.item_id()).unwrap();
4437 pane.unpin_tab_at(ix, window, cx);
4438 pane.close_all_items(
4439 &CloseAllItems {
4440 save_intent: None,
4441 close_pinned: false,
4442 },
4443 window,
4444 cx,
4445 )
4446 })
4447 .unwrap()
4448 .await
4449 .unwrap();
4450
4451 assert_item_labels(&pane, [], cx);
4452
4453 add_labeled_item(&pane, "A", true, cx).update(cx, |item, cx| {
4454 item.project_items
4455 .push(TestProjectItem::new_dirty(1, "A.txt", cx))
4456 });
4457 add_labeled_item(&pane, "B", true, cx).update(cx, |item, cx| {
4458 item.project_items
4459 .push(TestProjectItem::new_dirty(2, "B.txt", cx))
4460 });
4461 add_labeled_item(&pane, "C", true, cx).update(cx, |item, cx| {
4462 item.project_items
4463 .push(TestProjectItem::new_dirty(3, "C.txt", cx))
4464 });
4465 assert_item_labels(&pane, ["A^", "B^", "C*^"], cx);
4466
4467 let save = pane
4468 .update_in(cx, |pane, window, cx| {
4469 pane.close_all_items(
4470 &CloseAllItems {
4471 save_intent: None,
4472 close_pinned: false,
4473 },
4474 window,
4475 cx,
4476 )
4477 })
4478 .unwrap();
4479
4480 cx.executor().run_until_parked();
4481 cx.simulate_prompt_answer("Save all");
4482 save.await.unwrap();
4483 assert_item_labels(&pane, [], cx);
4484
4485 add_labeled_item(&pane, "A", true, cx);
4486 add_labeled_item(&pane, "B", true, cx);
4487 add_labeled_item(&pane, "C", true, cx);
4488 assert_item_labels(&pane, ["A^", "B^", "C*^"], cx);
4489 let save = pane
4490 .update_in(cx, |pane, window, cx| {
4491 pane.close_all_items(
4492 &CloseAllItems {
4493 save_intent: None,
4494 close_pinned: false,
4495 },
4496 window,
4497 cx,
4498 )
4499 })
4500 .unwrap();
4501
4502 cx.executor().run_until_parked();
4503 cx.simulate_prompt_answer("Discard all");
4504 save.await.unwrap();
4505 assert_item_labels(&pane, [], cx);
4506 }
4507
4508 #[gpui::test]
4509 async fn test_close_with_save_intent(cx: &mut TestAppContext) {
4510 init_test(cx);
4511 let fs = FakeFs::new(cx.executor());
4512
4513 let project = Project::test(fs, None, cx).await;
4514 let (workspace, cx) =
4515 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4516 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4517
4518 let a = cx.update(|_, cx| TestProjectItem::new_dirty(1, "A.txt", cx));
4519 let b = cx.update(|_, cx| TestProjectItem::new_dirty(1, "B.txt", cx));
4520 let c = cx.update(|_, cx| TestProjectItem::new_dirty(1, "C.txt", cx));
4521
4522 add_labeled_item(&pane, "AB", true, cx).update(cx, |item, _| {
4523 item.project_items.push(a.clone());
4524 item.project_items.push(b.clone());
4525 });
4526 add_labeled_item(&pane, "C", true, cx)
4527 .update(cx, |item, _| item.project_items.push(c.clone()));
4528 assert_item_labels(&pane, ["AB^", "C*^"], cx);
4529
4530 pane.update_in(cx, |pane, window, cx| {
4531 pane.close_all_items(
4532 &CloseAllItems {
4533 save_intent: Some(SaveIntent::Save),
4534 close_pinned: false,
4535 },
4536 window,
4537 cx,
4538 )
4539 })
4540 .unwrap()
4541 .await
4542 .unwrap();
4543
4544 assert_item_labels(&pane, [], cx);
4545 cx.update(|_, cx| {
4546 assert!(!a.read(cx).is_dirty);
4547 assert!(!b.read(cx).is_dirty);
4548 assert!(!c.read(cx).is_dirty);
4549 });
4550 }
4551
4552 #[gpui::test]
4553 async fn test_close_all_items_including_pinned(cx: &mut TestAppContext) {
4554 init_test(cx);
4555 let fs = FakeFs::new(cx.executor());
4556
4557 let project = Project::test(fs, None, cx).await;
4558 let (workspace, cx) =
4559 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4560 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4561
4562 let item_a = add_labeled_item(&pane, "A", false, cx);
4563 add_labeled_item(&pane, "B", false, cx);
4564 add_labeled_item(&pane, "C", false, cx);
4565 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4566
4567 pane.update_in(cx, |pane, window, cx| {
4568 let ix = pane.index_for_item_id(item_a.item_id()).unwrap();
4569 pane.pin_tab_at(ix, window, cx);
4570 pane.close_all_items(
4571 &CloseAllItems {
4572 save_intent: None,
4573 close_pinned: true,
4574 },
4575 window,
4576 cx,
4577 )
4578 })
4579 .unwrap()
4580 .await
4581 .unwrap();
4582 assert_item_labels(&pane, [], cx);
4583 }
4584
4585 #[gpui::test]
4586 async fn test_close_pinned_tab_with_non_pinned_in_same_pane(cx: &mut TestAppContext) {
4587 init_test(cx);
4588 let fs = FakeFs::new(cx.executor());
4589 let project = Project::test(fs, None, cx).await;
4590 let (workspace, cx) =
4591 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4592
4593 // Non-pinned tabs in same pane
4594 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4595 add_labeled_item(&pane, "A", false, cx);
4596 add_labeled_item(&pane, "B", false, cx);
4597 add_labeled_item(&pane, "C", false, cx);
4598 pane.update_in(cx, |pane, window, cx| {
4599 pane.pin_tab_at(0, window, cx);
4600 });
4601 set_labeled_items(&pane, ["A*", "B", "C"], cx);
4602 pane.update_in(cx, |pane, window, cx| {
4603 pane.close_active_item(
4604 &CloseActiveItem {
4605 save_intent: None,
4606 close_pinned: false,
4607 },
4608 window,
4609 cx,
4610 );
4611 });
4612 // Non-pinned tab should be active
4613 assert_item_labels(&pane, ["A", "B*", "C"], cx);
4614 }
4615
4616 #[gpui::test]
4617 async fn test_close_pinned_tab_with_non_pinned_in_different_pane(cx: &mut TestAppContext) {
4618 init_test(cx);
4619 let fs = FakeFs::new(cx.executor());
4620 let project = Project::test(fs, None, cx).await;
4621 let (workspace, cx) =
4622 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4623
4624 // No non-pinned tabs in same pane, non-pinned tabs in another pane
4625 let pane1 = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4626 let pane2 = workspace.update_in(cx, |workspace, window, cx| {
4627 workspace.split_pane(pane1.clone(), SplitDirection::Right, window, cx)
4628 });
4629 add_labeled_item(&pane1, "A", false, cx);
4630 pane1.update_in(cx, |pane, window, cx| {
4631 pane.pin_tab_at(0, window, cx);
4632 });
4633 set_labeled_items(&pane1, ["A*"], cx);
4634 add_labeled_item(&pane2, "B", false, cx);
4635 set_labeled_items(&pane2, ["B"], cx);
4636 pane1.update_in(cx, |pane, window, cx| {
4637 pane.close_active_item(
4638 &CloseActiveItem {
4639 save_intent: None,
4640 close_pinned: false,
4641 },
4642 window,
4643 cx,
4644 );
4645 });
4646 // Non-pinned tab of other pane should be active
4647 assert_item_labels(&pane2, ["B*"], cx);
4648 }
4649
4650 fn init_test(cx: &mut TestAppContext) {
4651 cx.update(|cx| {
4652 let settings_store = SettingsStore::test(cx);
4653 cx.set_global(settings_store);
4654 theme::init(LoadThemes::JustBase, cx);
4655 crate::init_settings(cx);
4656 Project::init_settings(cx);
4657 });
4658 }
4659
4660 fn set_max_tabs(cx: &mut TestAppContext, value: Option<usize>) {
4661 cx.update_global(|store: &mut SettingsStore, cx| {
4662 store.update_user_settings::<WorkspaceSettings>(cx, |settings| {
4663 settings.max_tabs = value.map(|v| NonZero::new(v).unwrap())
4664 });
4665 });
4666 }
4667
4668 fn add_labeled_item(
4669 pane: &Entity<Pane>,
4670 label: &str,
4671 is_dirty: bool,
4672 cx: &mut VisualTestContext,
4673 ) -> Box<Entity<TestItem>> {
4674 pane.update_in(cx, |pane, window, cx| {
4675 let labeled_item =
4676 Box::new(cx.new(|cx| TestItem::new(cx).with_label(label).with_dirty(is_dirty)));
4677 pane.add_item(labeled_item.clone(), false, false, None, window, cx);
4678 labeled_item
4679 })
4680 }
4681
4682 fn set_labeled_items<const COUNT: usize>(
4683 pane: &Entity<Pane>,
4684 labels: [&str; COUNT],
4685 cx: &mut VisualTestContext,
4686 ) -> [Box<Entity<TestItem>>; COUNT] {
4687 pane.update_in(cx, |pane, window, cx| {
4688 pane.items.clear();
4689 let mut active_item_index = 0;
4690
4691 let mut index = 0;
4692 let items = labels.map(|mut label| {
4693 if label.ends_with('*') {
4694 label = label.trim_end_matches('*');
4695 active_item_index = index;
4696 }
4697
4698 let labeled_item = Box::new(cx.new(|cx| TestItem::new(cx).with_label(label)));
4699 pane.add_item(labeled_item.clone(), false, false, None, window, cx);
4700 index += 1;
4701 labeled_item
4702 });
4703
4704 pane.activate_item(active_item_index, false, false, window, cx);
4705
4706 items
4707 })
4708 }
4709
4710 // Assert the item label, with the active item label suffixed with a '*'
4711 #[track_caller]
4712 fn assert_item_labels<const COUNT: usize>(
4713 pane: &Entity<Pane>,
4714 expected_states: [&str; COUNT],
4715 cx: &mut VisualTestContext,
4716 ) {
4717 let actual_states = pane.update(cx, |pane, cx| {
4718 pane.items
4719 .iter()
4720 .enumerate()
4721 .map(|(ix, item)| {
4722 let mut state = item
4723 .to_any()
4724 .downcast::<TestItem>()
4725 .unwrap()
4726 .read(cx)
4727 .label
4728 .clone();
4729 if ix == pane.active_item_index {
4730 state.push('*');
4731 }
4732 if item.is_dirty(cx) {
4733 state.push('^');
4734 }
4735 state
4736 })
4737 .collect::<Vec<_>>()
4738 });
4739 assert_eq!(
4740 actual_states, expected_states,
4741 "pane items do not match expectation"
4742 );
4743 }
4744}