1use crate::{
2 item::{
3 ActivateOnClose, ClosePosition, Item, ItemHandle, ItemSettings, PreviewTabsSettings,
4 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, OpenTerminal, OpenVisible, SplitDirection,
11 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 ActivatePrevItem,
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 always_show_close_button = settings.always_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 IconButton::new("close tab", IconName::Close)
2377 .when(!always_show_close_button, |button| {
2378 button.visible_on_hover("")
2379 })
2380 .shape(IconButtonShape::Square)
2381 .icon_color(Color::Muted)
2382 .size(ButtonSize::None)
2383 .icon_size(IconSize::XSmall)
2384 .on_click(cx.listener(move |pane, _, window, cx| {
2385 pane.close_item_by_id(item_id, SaveIntent::Close, window, cx)
2386 .detach_and_log_err(cx);
2387 }))
2388 }
2389 .map(|this| {
2390 if is_active {
2391 let focus_handle = focus_handle.clone();
2392 this.tooltip(move |window, cx| {
2393 Tooltip::for_action_in(
2394 end_slot_tooltip_text,
2395 end_slot_action,
2396 &focus_handle,
2397 window,
2398 cx,
2399 )
2400 })
2401 } else {
2402 this.tooltip(Tooltip::text(end_slot_tooltip_text))
2403 }
2404 });
2405 this.end_slot(end_slot)
2406 })
2407 .child(
2408 h_flex()
2409 .gap_1()
2410 .items_center()
2411 .children(
2412 std::iter::once(if let Some(decorated_icon) = decorated_icon {
2413 Some(div().child(decorated_icon.into_any_element()))
2414 } else if let Some(icon) = icon {
2415 Some(div().child(icon.into_any_element()))
2416 } else {
2417 None
2418 })
2419 .flatten(),
2420 )
2421 .child(label),
2422 );
2423
2424 let single_entry_to_resolve = {
2425 let item_entries = self.items[ix].project_entry_ids(cx);
2426 if item_entries.len() == 1 {
2427 Some(item_entries[0])
2428 } else {
2429 None
2430 }
2431 };
2432
2433 let total_items = self.items.len();
2434 let has_items_to_left = ix > 0;
2435 let has_items_to_right = ix < total_items - 1;
2436 let is_pinned = self.is_tab_pinned(ix);
2437 let pane = cx.entity().downgrade();
2438 let menu_context = item.item_focus_handle(cx);
2439 right_click_menu(ix).trigger(tab).menu(move |window, cx| {
2440 let pane = pane.clone();
2441 let menu_context = menu_context.clone();
2442 ContextMenu::build(window, cx, move |mut menu, window, cx| {
2443 if let Some(pane) = pane.upgrade() {
2444 menu = menu
2445 .entry(
2446 "Close",
2447 Some(Box::new(CloseActiveItem {
2448 save_intent: None,
2449 close_pinned: true,
2450 })),
2451 window.handler_for(&pane, move |pane, window, cx| {
2452 pane.close_item_by_id(item_id, SaveIntent::Close, window, cx)
2453 .detach_and_log_err(cx);
2454 }),
2455 )
2456 .item(ContextMenuItem::Entry(
2457 ContextMenuEntry::new("Close Others")
2458 .action(Box::new(CloseInactiveItems {
2459 save_intent: None,
2460 close_pinned: false,
2461 }))
2462 .disabled(total_items == 1)
2463 .handler(window.handler_for(&pane, move |pane, window, cx| {
2464 pane.close_items(window, cx, SaveIntent::Close, |id| {
2465 id != item_id
2466 })
2467 .detach_and_log_err(cx);
2468 })),
2469 ))
2470 .separator()
2471 .item(ContextMenuItem::Entry(
2472 ContextMenuEntry::new("Close Left")
2473 .action(Box::new(CloseItemsToTheLeft {
2474 close_pinned: false,
2475 }))
2476 .disabled(!has_items_to_left)
2477 .handler(window.handler_for(&pane, move |pane, window, cx| {
2478 pane.close_items_to_the_left_by_id(
2479 item_id,
2480 &CloseItemsToTheLeft {
2481 close_pinned: false,
2482 },
2483 pane.get_non_closeable_item_ids(false),
2484 window,
2485 cx,
2486 )
2487 .detach_and_log_err(cx);
2488 })),
2489 ))
2490 .item(ContextMenuItem::Entry(
2491 ContextMenuEntry::new("Close Right")
2492 .action(Box::new(CloseItemsToTheRight {
2493 close_pinned: false,
2494 }))
2495 .disabled(!has_items_to_right)
2496 .handler(window.handler_for(&pane, move |pane, window, cx| {
2497 pane.close_items_to_the_right_by_id(
2498 item_id,
2499 &CloseItemsToTheRight {
2500 close_pinned: false,
2501 },
2502 pane.get_non_closeable_item_ids(false),
2503 window,
2504 cx,
2505 )
2506 .detach_and_log_err(cx);
2507 })),
2508 ))
2509 .separator()
2510 .entry(
2511 "Close Clean",
2512 Some(Box::new(CloseCleanItems {
2513 close_pinned: false,
2514 })),
2515 window.handler_for(&pane, move |pane, window, cx| {
2516 if let Some(task) = pane.close_clean_items(
2517 &CloseCleanItems {
2518 close_pinned: false,
2519 },
2520 window,
2521 cx,
2522 ) {
2523 task.detach_and_log_err(cx)
2524 }
2525 }),
2526 )
2527 .entry(
2528 "Close All",
2529 Some(Box::new(CloseAllItems {
2530 save_intent: None,
2531 close_pinned: false,
2532 })),
2533 window.handler_for(&pane, |pane, window, cx| {
2534 if let Some(task) = pane.close_all_items(
2535 &CloseAllItems {
2536 save_intent: None,
2537 close_pinned: false,
2538 },
2539 window,
2540 cx,
2541 ) {
2542 task.detach_and_log_err(cx)
2543 }
2544 }),
2545 );
2546
2547 let pin_tab_entries = |menu: ContextMenu| {
2548 menu.separator().map(|this| {
2549 if is_pinned {
2550 this.entry(
2551 "Unpin Tab",
2552 Some(TogglePinTab.boxed_clone()),
2553 window.handler_for(&pane, move |pane, window, cx| {
2554 pane.unpin_tab_at(ix, window, cx);
2555 }),
2556 )
2557 } else {
2558 this.entry(
2559 "Pin Tab",
2560 Some(TogglePinTab.boxed_clone()),
2561 window.handler_for(&pane, move |pane, window, cx| {
2562 pane.pin_tab_at(ix, window, cx);
2563 }),
2564 )
2565 }
2566 })
2567 };
2568 if let Some(entry) = single_entry_to_resolve {
2569 let project_path = pane
2570 .read(cx)
2571 .item_for_entry(entry, cx)
2572 .and_then(|item| item.project_path(cx));
2573 let worktree = project_path.as_ref().and_then(|project_path| {
2574 pane.read(cx)
2575 .project
2576 .upgrade()?
2577 .read(cx)
2578 .worktree_for_id(project_path.worktree_id, cx)
2579 });
2580 let has_relative_path = worktree.as_ref().is_some_and(|worktree| {
2581 worktree
2582 .read(cx)
2583 .root_entry()
2584 .map_or(false, |entry| entry.is_dir())
2585 });
2586
2587 let entry_abs_path = pane.read(cx).entry_abs_path(entry, cx);
2588 let parent_abs_path = entry_abs_path
2589 .as_deref()
2590 .and_then(|abs_path| Some(abs_path.parent()?.to_path_buf()));
2591 let relative_path = project_path
2592 .map(|project_path| project_path.path)
2593 .filter(|_| has_relative_path);
2594
2595 let visible_in_project_panel = relative_path.is_some()
2596 && worktree.is_some_and(|worktree| worktree.read(cx).is_visible());
2597
2598 let entry_id = entry.to_proto();
2599 menu = menu
2600 .separator()
2601 .when_some(entry_abs_path, |menu, abs_path| {
2602 menu.entry(
2603 "Copy Path",
2604 Some(Box::new(zed_actions::workspace::CopyPath)),
2605 window.handler_for(&pane, move |_, _, cx| {
2606 cx.write_to_clipboard(ClipboardItem::new_string(
2607 abs_path.to_string_lossy().to_string(),
2608 ));
2609 }),
2610 )
2611 })
2612 .when_some(relative_path, |menu, relative_path| {
2613 menu.entry(
2614 "Copy Relative Path",
2615 Some(Box::new(zed_actions::workspace::CopyRelativePath)),
2616 window.handler_for(&pane, move |_, _, cx| {
2617 cx.write_to_clipboard(ClipboardItem::new_string(
2618 relative_path.to_string_lossy().to_string(),
2619 ));
2620 }),
2621 )
2622 })
2623 .map(pin_tab_entries)
2624 .separator()
2625 .when(visible_in_project_panel, |menu| {
2626 menu.entry(
2627 "Reveal In Project Panel",
2628 Some(Box::new(RevealInProjectPanel {
2629 entry_id: Some(entry_id),
2630 })),
2631 window.handler_for(&pane, move |pane, _, cx| {
2632 pane.project
2633 .update(cx, |_, cx| {
2634 cx.emit(project::Event::RevealInProjectPanel(
2635 ProjectEntryId::from_proto(entry_id),
2636 ))
2637 })
2638 .ok();
2639 }),
2640 )
2641 })
2642 .when_some(parent_abs_path, |menu, parent_abs_path| {
2643 menu.entry(
2644 "Open in Terminal",
2645 Some(Box::new(OpenInTerminal)),
2646 window.handler_for(&pane, move |_, window, cx| {
2647 window.dispatch_action(
2648 OpenTerminal {
2649 working_directory: parent_abs_path.clone(),
2650 }
2651 .boxed_clone(),
2652 cx,
2653 );
2654 }),
2655 )
2656 });
2657 } else {
2658 menu = menu.map(pin_tab_entries);
2659 }
2660 }
2661
2662 menu.context(menu_context)
2663 })
2664 })
2665 }
2666
2667 fn render_tab_bar(&mut self, window: &mut Window, cx: &mut Context<Pane>) -> impl IntoElement {
2668 let focus_handle = self.focus_handle.clone();
2669 let navigate_backward = IconButton::new("navigate_backward", IconName::ArrowLeft)
2670 .icon_size(IconSize::Small)
2671 .on_click({
2672 let entity = cx.entity().clone();
2673 move |_, window, cx| {
2674 entity.update(cx, |pane, cx| pane.navigate_backward(window, cx))
2675 }
2676 })
2677 .disabled(!self.can_navigate_backward())
2678 .tooltip({
2679 let focus_handle = focus_handle.clone();
2680 move |window, cx| {
2681 Tooltip::for_action_in("Go Back", &GoBack, &focus_handle, window, cx)
2682 }
2683 });
2684
2685 let navigate_forward = IconButton::new("navigate_forward", IconName::ArrowRight)
2686 .icon_size(IconSize::Small)
2687 .on_click({
2688 let entity = cx.entity().clone();
2689 move |_, window, cx| entity.update(cx, |pane, cx| pane.navigate_forward(window, cx))
2690 })
2691 .disabled(!self.can_navigate_forward())
2692 .tooltip({
2693 let focus_handle = focus_handle.clone();
2694 move |window, cx| {
2695 Tooltip::for_action_in("Go Forward", &GoForward, &focus_handle, window, cx)
2696 }
2697 });
2698
2699 let mut tab_items = self
2700 .items
2701 .iter()
2702 .enumerate()
2703 .zip(tab_details(&self.items, cx))
2704 .map(|((ix, item), detail)| {
2705 self.render_tab(ix, &**item, detail, &focus_handle, window, cx)
2706 })
2707 .collect::<Vec<_>>();
2708 let tab_count = tab_items.len();
2709 let unpinned_tabs = tab_items.split_off(self.pinned_tab_count);
2710 let pinned_tabs = tab_items;
2711 TabBar::new("tab_bar")
2712 .when(
2713 self.display_nav_history_buttons.unwrap_or_default(),
2714 |tab_bar| {
2715 tab_bar
2716 .start_child(navigate_backward)
2717 .start_child(navigate_forward)
2718 },
2719 )
2720 .map(|tab_bar| {
2721 if self.show_tab_bar_buttons {
2722 let render_tab_buttons = self.render_tab_bar_buttons.clone();
2723 let (left_children, right_children) = render_tab_buttons(self, window, cx);
2724 tab_bar
2725 .start_children(left_children)
2726 .end_children(right_children)
2727 } else {
2728 tab_bar
2729 }
2730 })
2731 .children(pinned_tabs.len().ne(&0).then(|| {
2732 h_flex()
2733 .children(pinned_tabs)
2734 .border_r_2()
2735 .border_color(cx.theme().colors().border)
2736 }))
2737 .child(
2738 h_flex()
2739 .id("unpinned tabs")
2740 .overflow_x_scroll()
2741 .w_full()
2742 .track_scroll(&self.tab_bar_scroll_handle)
2743 .children(unpinned_tabs)
2744 .child(
2745 div()
2746 .id("tab_bar_drop_target")
2747 .min_w_6()
2748 // HACK: This empty child is currently necessary to force the drop target to appear
2749 // despite us setting a min width above.
2750 .child("")
2751 .h_full()
2752 .flex_grow()
2753 .drag_over::<DraggedTab>(|bar, _, _, cx| {
2754 bar.bg(cx.theme().colors().drop_target_background)
2755 })
2756 .drag_over::<DraggedSelection>(|bar, _, _, cx| {
2757 bar.bg(cx.theme().colors().drop_target_background)
2758 })
2759 .on_drop(cx.listener(
2760 move |this, dragged_tab: &DraggedTab, window, cx| {
2761 this.drag_split_direction = None;
2762 this.handle_tab_drop(dragged_tab, this.items.len(), window, cx)
2763 },
2764 ))
2765 .on_drop(cx.listener(
2766 move |this, selection: &DraggedSelection, window, cx| {
2767 this.drag_split_direction = None;
2768 this.handle_project_entry_drop(
2769 &selection.active_selection.entry_id,
2770 Some(tab_count),
2771 window,
2772 cx,
2773 )
2774 },
2775 ))
2776 .on_drop(cx.listener(move |this, paths, window, cx| {
2777 this.drag_split_direction = None;
2778 this.handle_external_paths_drop(paths, window, cx)
2779 }))
2780 .on_click(cx.listener(move |this, event: &ClickEvent, window, cx| {
2781 if event.up.click_count == 2 {
2782 window.dispatch_action(
2783 this.double_click_dispatch_action.boxed_clone(),
2784 cx,
2785 )
2786 }
2787 })),
2788 ),
2789 )
2790 }
2791
2792 pub fn render_menu_overlay(menu: &Entity<ContextMenu>) -> Div {
2793 div().absolute().bottom_0().right_0().size_0().child(
2794 deferred(anchored().anchor(Corner::TopRight).child(menu.clone())).with_priority(1),
2795 )
2796 }
2797
2798 pub fn set_zoomed(&mut self, zoomed: bool, cx: &mut Context<Self>) {
2799 self.zoomed = zoomed;
2800 cx.notify();
2801 }
2802
2803 pub fn is_zoomed(&self) -> bool {
2804 self.zoomed
2805 }
2806
2807 fn handle_drag_move<T: 'static>(
2808 &mut self,
2809 event: &DragMoveEvent<T>,
2810 window: &mut Window,
2811 cx: &mut Context<Self>,
2812 ) {
2813 let can_split_predicate = self.can_split_predicate.take();
2814 let can_split = match &can_split_predicate {
2815 Some(can_split_predicate) => {
2816 can_split_predicate(self, event.dragged_item(), window, cx)
2817 }
2818 None => false,
2819 };
2820 self.can_split_predicate = can_split_predicate;
2821 if !can_split {
2822 return;
2823 }
2824
2825 let rect = event.bounds.size;
2826
2827 let size = event.bounds.size.width.min(event.bounds.size.height)
2828 * WorkspaceSettings::get_global(cx).drop_target_size;
2829
2830 let relative_cursor = Point::new(
2831 event.event.position.x - event.bounds.left(),
2832 event.event.position.y - event.bounds.top(),
2833 );
2834
2835 let direction = if relative_cursor.x < size
2836 || relative_cursor.x > rect.width - size
2837 || relative_cursor.y < size
2838 || relative_cursor.y > rect.height - size
2839 {
2840 [
2841 SplitDirection::Up,
2842 SplitDirection::Right,
2843 SplitDirection::Down,
2844 SplitDirection::Left,
2845 ]
2846 .iter()
2847 .min_by_key(|side| match side {
2848 SplitDirection::Up => relative_cursor.y,
2849 SplitDirection::Right => rect.width - relative_cursor.x,
2850 SplitDirection::Down => rect.height - relative_cursor.y,
2851 SplitDirection::Left => relative_cursor.x,
2852 })
2853 .cloned()
2854 } else {
2855 None
2856 };
2857
2858 if direction != self.drag_split_direction {
2859 self.drag_split_direction = direction;
2860 }
2861 }
2862
2863 fn handle_tab_drop(
2864 &mut self,
2865 dragged_tab: &DraggedTab,
2866 ix: usize,
2867 window: &mut Window,
2868 cx: &mut Context<Self>,
2869 ) {
2870 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
2871 if let ControlFlow::Break(()) = custom_drop_handle(self, dragged_tab, window, cx) {
2872 return;
2873 }
2874 }
2875 let mut to_pane = cx.entity().clone();
2876 let split_direction = self.drag_split_direction;
2877 let item_id = dragged_tab.item.item_id();
2878 if let Some(preview_item_id) = self.preview_item_id {
2879 if item_id == preview_item_id {
2880 self.set_preview_item_id(None, cx);
2881 }
2882 }
2883
2884 let from_pane = dragged_tab.pane.clone();
2885 self.workspace
2886 .update(cx, |_, cx| {
2887 cx.defer_in(window, move |workspace, window, cx| {
2888 if let Some(split_direction) = split_direction {
2889 to_pane = workspace.split_pane(to_pane, split_direction, window, cx);
2890 }
2891 let old_ix = from_pane.read(cx).index_for_item_id(item_id);
2892 let old_len = to_pane.read(cx).items.len();
2893 move_item(&from_pane, &to_pane, item_id, ix, window, cx);
2894 if to_pane == from_pane {
2895 if let Some(old_index) = old_ix {
2896 to_pane.update(cx, |this, _| {
2897 if old_index < this.pinned_tab_count
2898 && (ix == this.items.len() || ix > this.pinned_tab_count)
2899 {
2900 this.pinned_tab_count -= 1;
2901 } else if this.has_pinned_tabs()
2902 && old_index >= this.pinned_tab_count
2903 && ix < this.pinned_tab_count
2904 {
2905 this.pinned_tab_count += 1;
2906 }
2907 });
2908 }
2909 } else {
2910 to_pane.update(cx, |this, _| {
2911 if this.items.len() > old_len // Did we not deduplicate on drag?
2912 && this.has_pinned_tabs()
2913 && ix < this.pinned_tab_count
2914 {
2915 this.pinned_tab_count += 1;
2916 }
2917 });
2918 from_pane.update(cx, |this, _| {
2919 if let Some(index) = old_ix {
2920 if this.pinned_tab_count > index {
2921 this.pinned_tab_count -= 1;
2922 }
2923 }
2924 })
2925 }
2926 });
2927 })
2928 .log_err();
2929 }
2930
2931 fn handle_dragged_selection_drop(
2932 &mut self,
2933 dragged_selection: &DraggedSelection,
2934 dragged_onto: Option<usize>,
2935 window: &mut Window,
2936 cx: &mut Context<Self>,
2937 ) {
2938 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
2939 if let ControlFlow::Break(()) = custom_drop_handle(self, dragged_selection, window, cx)
2940 {
2941 return;
2942 }
2943 }
2944 self.handle_project_entry_drop(
2945 &dragged_selection.active_selection.entry_id,
2946 dragged_onto,
2947 window,
2948 cx,
2949 );
2950 }
2951
2952 fn handle_project_entry_drop(
2953 &mut self,
2954 project_entry_id: &ProjectEntryId,
2955 target: Option<usize>,
2956 window: &mut Window,
2957 cx: &mut Context<Self>,
2958 ) {
2959 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
2960 if let ControlFlow::Break(()) = custom_drop_handle(self, project_entry_id, window, cx) {
2961 return;
2962 }
2963 }
2964 let mut to_pane = cx.entity().clone();
2965 let split_direction = self.drag_split_direction;
2966 let project_entry_id = *project_entry_id;
2967 self.workspace
2968 .update(cx, |_, cx| {
2969 cx.defer_in(window, move |workspace, window, cx| {
2970 if let Some(path) = workspace
2971 .project()
2972 .read(cx)
2973 .path_for_entry(project_entry_id, cx)
2974 {
2975 let load_path_task = workspace.load_path(path, window, cx);
2976 cx.spawn_in(window, |workspace, mut cx| async move {
2977 if let Some((project_entry_id, build_item)) =
2978 load_path_task.await.notify_async_err(&mut cx)
2979 {
2980 let (to_pane, new_item_handle) = workspace
2981 .update_in(&mut cx, |workspace, window, cx| {
2982 if let Some(split_direction) = split_direction {
2983 to_pane = workspace.split_pane(
2984 to_pane,
2985 split_direction,
2986 window,
2987 cx,
2988 );
2989 }
2990 let new_item_handle = to_pane.update(cx, |pane, cx| {
2991 pane.open_item(
2992 project_entry_id,
2993 true,
2994 false,
2995 true,
2996 target,
2997 window,
2998 cx,
2999 build_item,
3000 )
3001 });
3002 (to_pane, new_item_handle)
3003 })
3004 .log_err()?;
3005 to_pane
3006 .update_in(&mut cx, |this, window, cx| {
3007 let Some(index) = this.index_for_item(&*new_item_handle)
3008 else {
3009 return;
3010 };
3011
3012 if target.map_or(false, |target| this.is_tab_pinned(target))
3013 {
3014 this.pin_tab_at(index, window, cx);
3015 }
3016 })
3017 .ok()?
3018 }
3019 Some(())
3020 })
3021 .detach();
3022 };
3023 });
3024 })
3025 .log_err();
3026 }
3027
3028 fn handle_external_paths_drop(
3029 &mut self,
3030 paths: &ExternalPaths,
3031 window: &mut Window,
3032 cx: &mut Context<Self>,
3033 ) {
3034 if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
3035 if let ControlFlow::Break(()) = custom_drop_handle(self, paths, window, cx) {
3036 return;
3037 }
3038 }
3039 let mut to_pane = cx.entity().clone();
3040 let mut split_direction = self.drag_split_direction;
3041 let paths = paths.paths().to_vec();
3042 let is_remote = self
3043 .workspace
3044 .update(cx, |workspace, cx| {
3045 if workspace.project().read(cx).is_via_collab() {
3046 workspace.show_error(
3047 &anyhow::anyhow!("Cannot drop files on a remote project"),
3048 cx,
3049 );
3050 true
3051 } else {
3052 false
3053 }
3054 })
3055 .unwrap_or(true);
3056 if is_remote {
3057 return;
3058 }
3059
3060 self.workspace
3061 .update(cx, |workspace, cx| {
3062 let fs = Arc::clone(workspace.project().read(cx).fs());
3063 cx.spawn_in(window, |workspace, mut cx| async move {
3064 let mut is_file_checks = FuturesUnordered::new();
3065 for path in &paths {
3066 is_file_checks.push(fs.is_file(path))
3067 }
3068 let mut has_files_to_open = false;
3069 while let Some(is_file) = is_file_checks.next().await {
3070 if is_file {
3071 has_files_to_open = true;
3072 break;
3073 }
3074 }
3075 drop(is_file_checks);
3076 if !has_files_to_open {
3077 split_direction = None;
3078 }
3079
3080 if let Ok(open_task) = workspace.update_in(&mut cx, |workspace, window, cx| {
3081 if let Some(split_direction) = split_direction {
3082 to_pane = workspace.split_pane(to_pane, split_direction, window, cx);
3083 }
3084 workspace.open_paths(
3085 paths,
3086 OpenVisible::OnlyDirectories,
3087 Some(to_pane.downgrade()),
3088 window,
3089 cx,
3090 )
3091 }) {
3092 let opened_items: Vec<_> = open_task.await;
3093 _ = workspace.update(&mut cx, |workspace, cx| {
3094 for item in opened_items.into_iter().flatten() {
3095 if let Err(e) = item {
3096 workspace.show_error(&e, cx);
3097 }
3098 }
3099 });
3100 }
3101 })
3102 .detach();
3103 })
3104 .log_err();
3105 }
3106
3107 pub fn display_nav_history_buttons(&mut self, display: Option<bool>) {
3108 self.display_nav_history_buttons = display;
3109 }
3110
3111 fn get_non_closeable_item_ids(&self, close_pinned: bool) -> Vec<EntityId> {
3112 if close_pinned {
3113 return vec![];
3114 }
3115
3116 self.items
3117 .iter()
3118 .enumerate()
3119 .filter(|(index, _item)| self.is_tab_pinned(*index))
3120 .map(|(_, item)| item.item_id())
3121 .collect()
3122 }
3123
3124 pub fn drag_split_direction(&self) -> Option<SplitDirection> {
3125 self.drag_split_direction
3126 }
3127
3128 pub fn set_zoom_out_on_close(&mut self, zoom_out_on_close: bool) {
3129 self.zoom_out_on_close = zoom_out_on_close;
3130 }
3131}
3132
3133impl Focusable for Pane {
3134 fn focus_handle(&self, _cx: &App) -> FocusHandle {
3135 self.focus_handle.clone()
3136 }
3137}
3138
3139impl Render for Pane {
3140 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
3141 let mut key_context = KeyContext::new_with_defaults();
3142 key_context.add("Pane");
3143 if self.active_item().is_none() {
3144 key_context.add("EmptyPane");
3145 }
3146
3147 let should_display_tab_bar = self.should_display_tab_bar.clone();
3148 let display_tab_bar = should_display_tab_bar(window, cx);
3149 let Some(project) = self.project.upgrade() else {
3150 return div().track_focus(&self.focus_handle(cx));
3151 };
3152 let is_local = project.read(cx).is_local();
3153
3154 v_flex()
3155 .key_context(key_context)
3156 .track_focus(&self.focus_handle(cx))
3157 .size_full()
3158 .flex_none()
3159 .overflow_hidden()
3160 .on_action(cx.listener(|pane, _: &AlternateFile, window, cx| {
3161 pane.alternate_file(window, cx);
3162 }))
3163 .on_action(
3164 cx.listener(|pane, _: &SplitLeft, _, cx| pane.split(SplitDirection::Left, cx)),
3165 )
3166 .on_action(cx.listener(|pane, _: &SplitUp, _, cx| pane.split(SplitDirection::Up, cx)))
3167 .on_action(cx.listener(|pane, _: &SplitHorizontal, _, cx| {
3168 pane.split(SplitDirection::horizontal(cx), cx)
3169 }))
3170 .on_action(cx.listener(|pane, _: &SplitVertical, _, cx| {
3171 pane.split(SplitDirection::vertical(cx), cx)
3172 }))
3173 .on_action(
3174 cx.listener(|pane, _: &SplitRight, _, cx| pane.split(SplitDirection::Right, cx)),
3175 )
3176 .on_action(
3177 cx.listener(|pane, _: &SplitDown, _, cx| pane.split(SplitDirection::Down, cx)),
3178 )
3179 .on_action(
3180 cx.listener(|pane, _: &GoBack, window, cx| pane.navigate_backward(window, cx)),
3181 )
3182 .on_action(
3183 cx.listener(|pane, _: &GoForward, window, cx| pane.navigate_forward(window, cx)),
3184 )
3185 .on_action(cx.listener(|_, _: &JoinIntoNext, _, cx| {
3186 cx.emit(Event::JoinIntoNext);
3187 }))
3188 .on_action(cx.listener(|_, _: &JoinAll, _, cx| {
3189 cx.emit(Event::JoinAll);
3190 }))
3191 .on_action(cx.listener(Pane::toggle_zoom))
3192 .on_action(
3193 cx.listener(|pane: &mut Pane, action: &ActivateItem, window, cx| {
3194 pane.activate_item(action.0, true, true, window, cx);
3195 }),
3196 )
3197 .on_action(
3198 cx.listener(|pane: &mut Pane, _: &ActivateLastItem, window, cx| {
3199 pane.activate_item(pane.items.len() - 1, true, true, window, cx);
3200 }),
3201 )
3202 .on_action(
3203 cx.listener(|pane: &mut Pane, _: &ActivatePrevItem, window, cx| {
3204 pane.activate_prev_item(true, window, cx);
3205 }),
3206 )
3207 .on_action(
3208 cx.listener(|pane: &mut Pane, _: &ActivateNextItem, window, cx| {
3209 pane.activate_next_item(true, window, cx);
3210 }),
3211 )
3212 .on_action(
3213 cx.listener(|pane, _: &SwapItemLeft, window, cx| pane.swap_item_left(window, cx)),
3214 )
3215 .on_action(
3216 cx.listener(|pane, _: &SwapItemRight, window, cx| pane.swap_item_right(window, cx)),
3217 )
3218 .on_action(cx.listener(|pane, action, window, cx| {
3219 pane.toggle_pin_tab(action, window, cx);
3220 }))
3221 .when(PreviewTabsSettings::get_global(cx).enabled, |this| {
3222 this.on_action(cx.listener(|pane: &mut Pane, _: &TogglePreviewTab, _, cx| {
3223 if let Some(active_item_id) = pane.active_item().map(|i| i.item_id()) {
3224 if pane.is_active_preview_item(active_item_id) {
3225 pane.set_preview_item_id(None, cx);
3226 } else {
3227 pane.set_preview_item_id(Some(active_item_id), cx);
3228 }
3229 }
3230 }))
3231 })
3232 .on_action(
3233 cx.listener(|pane: &mut Self, action: &CloseActiveItem, window, cx| {
3234 if let Some(task) = pane.close_active_item(action, window, cx) {
3235 task.detach_and_log_err(cx)
3236 }
3237 }),
3238 )
3239 .on_action(
3240 cx.listener(|pane: &mut Self, action: &CloseInactiveItems, window, cx| {
3241 if let Some(task) = pane.close_inactive_items(action, window, cx) {
3242 task.detach_and_log_err(cx)
3243 }
3244 }),
3245 )
3246 .on_action(
3247 cx.listener(|pane: &mut Self, action: &CloseCleanItems, window, cx| {
3248 if let Some(task) = pane.close_clean_items(action, window, cx) {
3249 task.detach_and_log_err(cx)
3250 }
3251 }),
3252 )
3253 .on_action(cx.listener(
3254 |pane: &mut Self, action: &CloseItemsToTheLeft, window, cx| {
3255 if let Some(task) = pane.close_items_to_the_left(action, window, cx) {
3256 task.detach_and_log_err(cx)
3257 }
3258 },
3259 ))
3260 .on_action(cx.listener(
3261 |pane: &mut Self, action: &CloseItemsToTheRight, window, cx| {
3262 if let Some(task) = pane.close_items_to_the_right(action, window, cx) {
3263 task.detach_and_log_err(cx)
3264 }
3265 },
3266 ))
3267 .on_action(
3268 cx.listener(|pane: &mut Self, action: &CloseAllItems, window, cx| {
3269 if let Some(task) = pane.close_all_items(action, window, cx) {
3270 task.detach_and_log_err(cx)
3271 }
3272 }),
3273 )
3274 .on_action(
3275 cx.listener(|pane: &mut Self, action: &CloseActiveItem, window, cx| {
3276 if let Some(task) = pane.close_active_item(action, window, cx) {
3277 task.detach_and_log_err(cx)
3278 }
3279 }),
3280 )
3281 .on_action(
3282 cx.listener(|pane: &mut Self, action: &RevealInProjectPanel, _, cx| {
3283 let entry_id = action
3284 .entry_id
3285 .map(ProjectEntryId::from_proto)
3286 .or_else(|| pane.active_item()?.project_entry_ids(cx).first().copied());
3287 if let Some(entry_id) = entry_id {
3288 pane.project
3289 .update(cx, |_, cx| {
3290 cx.emit(project::Event::RevealInProjectPanel(entry_id))
3291 })
3292 .ok();
3293 }
3294 }),
3295 )
3296 .when(self.active_item().is_some() && display_tab_bar, |pane| {
3297 pane.child(self.render_tab_bar(window, cx))
3298 })
3299 .child({
3300 let has_worktrees = project.read(cx).worktrees(cx).next().is_some();
3301 // main content
3302 div()
3303 .flex_1()
3304 .relative()
3305 .group("")
3306 .overflow_hidden()
3307 .on_drag_move::<DraggedTab>(cx.listener(Self::handle_drag_move))
3308 .on_drag_move::<DraggedSelection>(cx.listener(Self::handle_drag_move))
3309 .when(is_local, |div| {
3310 div.on_drag_move::<ExternalPaths>(cx.listener(Self::handle_drag_move))
3311 })
3312 .map(|div| {
3313 if let Some(item) = self.active_item() {
3314 div.v_flex()
3315 .size_full()
3316 .overflow_hidden()
3317 .child(self.toolbar.clone())
3318 .child(item.to_any())
3319 } else {
3320 let placeholder = div.h_flex().size_full().justify_center();
3321 if has_worktrees {
3322 placeholder
3323 } else {
3324 placeholder.child(
3325 Label::new("Open a file or project to get started.")
3326 .color(Color::Muted),
3327 )
3328 }
3329 }
3330 })
3331 .child(
3332 // drag target
3333 div()
3334 .invisible()
3335 .absolute()
3336 .bg(cx.theme().colors().drop_target_background)
3337 .group_drag_over::<DraggedTab>("", |style| style.visible())
3338 .group_drag_over::<DraggedSelection>("", |style| style.visible())
3339 .when(is_local, |div| {
3340 div.group_drag_over::<ExternalPaths>("", |style| style.visible())
3341 })
3342 .when_some(self.can_drop_predicate.clone(), |this, p| {
3343 this.can_drop(move |a, window, cx| p(a, window, cx))
3344 })
3345 .on_drop(cx.listener(move |this, dragged_tab, window, cx| {
3346 this.handle_tab_drop(
3347 dragged_tab,
3348 this.active_item_index(),
3349 window,
3350 cx,
3351 )
3352 }))
3353 .on_drop(cx.listener(
3354 move |this, selection: &DraggedSelection, window, cx| {
3355 this.handle_dragged_selection_drop(selection, None, window, cx)
3356 },
3357 ))
3358 .on_drop(cx.listener(move |this, paths, window, cx| {
3359 this.handle_external_paths_drop(paths, window, cx)
3360 }))
3361 .map(|div| {
3362 let size = DefiniteLength::Fraction(0.5);
3363 match self.drag_split_direction {
3364 None => div.top_0().right_0().bottom_0().left_0(),
3365 Some(SplitDirection::Up) => {
3366 div.top_0().left_0().right_0().h(size)
3367 }
3368 Some(SplitDirection::Down) => {
3369 div.left_0().bottom_0().right_0().h(size)
3370 }
3371 Some(SplitDirection::Left) => {
3372 div.top_0().left_0().bottom_0().w(size)
3373 }
3374 Some(SplitDirection::Right) => {
3375 div.top_0().bottom_0().right_0().w(size)
3376 }
3377 }
3378 }),
3379 )
3380 })
3381 .on_mouse_down(
3382 MouseButton::Navigate(NavigationDirection::Back),
3383 cx.listener(|pane, _, window, cx| {
3384 if let Some(workspace) = pane.workspace.upgrade() {
3385 let pane = cx.entity().downgrade();
3386 window.defer(cx, move |window, cx| {
3387 workspace.update(cx, |workspace, cx| {
3388 workspace.go_back(pane, window, cx).detach_and_log_err(cx)
3389 })
3390 })
3391 }
3392 }),
3393 )
3394 .on_mouse_down(
3395 MouseButton::Navigate(NavigationDirection::Forward),
3396 cx.listener(|pane, _, window, cx| {
3397 if let Some(workspace) = pane.workspace.upgrade() {
3398 let pane = cx.entity().downgrade();
3399 window.defer(cx, move |window, cx| {
3400 workspace.update(cx, |workspace, cx| {
3401 workspace
3402 .go_forward(pane, window, cx)
3403 .detach_and_log_err(cx)
3404 })
3405 })
3406 }
3407 }),
3408 )
3409 }
3410}
3411
3412impl ItemNavHistory {
3413 pub fn push<D: 'static + Send + Any>(&mut self, data: Option<D>, cx: &mut App) {
3414 if self
3415 .item
3416 .upgrade()
3417 .is_some_and(|item| item.include_in_nav_history())
3418 {
3419 self.history
3420 .push(data, self.item.clone(), self.is_preview, cx);
3421 }
3422 }
3423
3424 pub fn pop_backward(&mut self, cx: &mut App) -> Option<NavigationEntry> {
3425 self.history.pop(NavigationMode::GoingBack, cx)
3426 }
3427
3428 pub fn pop_forward(&mut self, cx: &mut App) -> Option<NavigationEntry> {
3429 self.history.pop(NavigationMode::GoingForward, cx)
3430 }
3431}
3432
3433impl NavHistory {
3434 pub fn for_each_entry(
3435 &self,
3436 cx: &App,
3437 mut f: impl FnMut(&NavigationEntry, (ProjectPath, Option<PathBuf>)),
3438 ) {
3439 let borrowed_history = self.0.lock();
3440 borrowed_history
3441 .forward_stack
3442 .iter()
3443 .chain(borrowed_history.backward_stack.iter())
3444 .chain(borrowed_history.closed_stack.iter())
3445 .for_each(|entry| {
3446 if let Some(project_and_abs_path) =
3447 borrowed_history.paths_by_item.get(&entry.item.id())
3448 {
3449 f(entry, project_and_abs_path.clone());
3450 } else if let Some(item) = entry.item.upgrade() {
3451 if let Some(path) = item.project_path(cx) {
3452 f(entry, (path, None));
3453 }
3454 }
3455 })
3456 }
3457
3458 pub fn set_mode(&mut self, mode: NavigationMode) {
3459 self.0.lock().mode = mode;
3460 }
3461
3462 pub fn mode(&self) -> NavigationMode {
3463 self.0.lock().mode
3464 }
3465
3466 pub fn disable(&mut self) {
3467 self.0.lock().mode = NavigationMode::Disabled;
3468 }
3469
3470 pub fn enable(&mut self) {
3471 self.0.lock().mode = NavigationMode::Normal;
3472 }
3473
3474 pub fn pop(&mut self, mode: NavigationMode, cx: &mut App) -> Option<NavigationEntry> {
3475 let mut state = self.0.lock();
3476 let entry = match mode {
3477 NavigationMode::Normal | NavigationMode::Disabled | NavigationMode::ClosingItem => {
3478 return None
3479 }
3480 NavigationMode::GoingBack => &mut state.backward_stack,
3481 NavigationMode::GoingForward => &mut state.forward_stack,
3482 NavigationMode::ReopeningClosedItem => &mut state.closed_stack,
3483 }
3484 .pop_back();
3485 if entry.is_some() {
3486 state.did_update(cx);
3487 }
3488 entry
3489 }
3490
3491 pub fn push<D: 'static + Send + Any>(
3492 &mut self,
3493 data: Option<D>,
3494 item: Arc<dyn WeakItemHandle>,
3495 is_preview: bool,
3496 cx: &mut App,
3497 ) {
3498 let state = &mut *self.0.lock();
3499 match state.mode {
3500 NavigationMode::Disabled => {}
3501 NavigationMode::Normal | NavigationMode::ReopeningClosedItem => {
3502 if state.backward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3503 state.backward_stack.pop_front();
3504 }
3505 state.backward_stack.push_back(NavigationEntry {
3506 item,
3507 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3508 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3509 is_preview,
3510 });
3511 state.forward_stack.clear();
3512 }
3513 NavigationMode::GoingBack => {
3514 if state.forward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3515 state.forward_stack.pop_front();
3516 }
3517 state.forward_stack.push_back(NavigationEntry {
3518 item,
3519 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3520 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3521 is_preview,
3522 });
3523 }
3524 NavigationMode::GoingForward => {
3525 if state.backward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3526 state.backward_stack.pop_front();
3527 }
3528 state.backward_stack.push_back(NavigationEntry {
3529 item,
3530 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3531 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3532 is_preview,
3533 });
3534 }
3535 NavigationMode::ClosingItem => {
3536 if state.closed_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
3537 state.closed_stack.pop_front();
3538 }
3539 state.closed_stack.push_back(NavigationEntry {
3540 item,
3541 data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
3542 timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
3543 is_preview,
3544 });
3545 }
3546 }
3547 state.did_update(cx);
3548 }
3549
3550 pub fn remove_item(&mut self, item_id: EntityId) {
3551 let mut state = self.0.lock();
3552 state.paths_by_item.remove(&item_id);
3553 state
3554 .backward_stack
3555 .retain(|entry| entry.item.id() != item_id);
3556 state
3557 .forward_stack
3558 .retain(|entry| entry.item.id() != item_id);
3559 state
3560 .closed_stack
3561 .retain(|entry| entry.item.id() != item_id);
3562 }
3563
3564 pub fn path_for_item(&self, item_id: EntityId) -> Option<(ProjectPath, Option<PathBuf>)> {
3565 self.0.lock().paths_by_item.get(&item_id).cloned()
3566 }
3567}
3568
3569impl NavHistoryState {
3570 pub fn did_update(&self, cx: &mut App) {
3571 if let Some(pane) = self.pane.upgrade() {
3572 cx.defer(move |cx| {
3573 pane.update(cx, |pane, cx| pane.history_updated(cx));
3574 });
3575 }
3576 }
3577}
3578
3579fn dirty_message_for(buffer_path: Option<ProjectPath>) -> String {
3580 let path = buffer_path
3581 .as_ref()
3582 .and_then(|p| {
3583 p.path
3584 .to_str()
3585 .and_then(|s| if s.is_empty() { None } else { Some(s) })
3586 })
3587 .unwrap_or("This buffer");
3588 let path = truncate_and_remove_front(path, 80);
3589 format!("{path} contains unsaved edits. Do you want to save it?")
3590}
3591
3592pub fn tab_details(items: &[Box<dyn ItemHandle>], cx: &App) -> Vec<usize> {
3593 let mut tab_details = items.iter().map(|_| 0).collect::<Vec<_>>();
3594 let mut tab_descriptions = HashMap::default();
3595 let mut done = false;
3596 while !done {
3597 done = true;
3598
3599 // Store item indices by their tab description.
3600 for (ix, (item, detail)) in items.iter().zip(&tab_details).enumerate() {
3601 if let Some(description) = item.tab_description(*detail, cx) {
3602 if *detail == 0
3603 || Some(&description) != item.tab_description(detail - 1, cx).as_ref()
3604 {
3605 tab_descriptions
3606 .entry(description)
3607 .or_insert(Vec::new())
3608 .push(ix);
3609 }
3610 }
3611 }
3612
3613 // If two or more items have the same tab description, increase their level
3614 // of detail and try again.
3615 for (_, item_ixs) in tab_descriptions.drain() {
3616 if item_ixs.len() > 1 {
3617 done = false;
3618 for ix in item_ixs {
3619 tab_details[ix] += 1;
3620 }
3621 }
3622 }
3623 }
3624
3625 tab_details
3626}
3627
3628pub fn render_item_indicator(item: Box<dyn ItemHandle>, cx: &App) -> Option<Indicator> {
3629 maybe!({
3630 let indicator_color = match (item.has_conflict(cx), item.is_dirty(cx)) {
3631 (true, _) => Color::Warning,
3632 (_, true) => Color::Accent,
3633 (false, false) => return None,
3634 };
3635
3636 Some(Indicator::dot().color(indicator_color))
3637 })
3638}
3639
3640impl Render for DraggedTab {
3641 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
3642 let ui_font = ThemeSettings::get_global(cx).ui_font.clone();
3643 let label = self.item.tab_content(
3644 TabContentParams {
3645 detail: Some(self.detail),
3646 selected: false,
3647 preview: false,
3648 },
3649 window,
3650 cx,
3651 );
3652 Tab::new("")
3653 .toggle_state(self.is_active)
3654 .child(label)
3655 .render(window, cx)
3656 .font(ui_font)
3657 }
3658}
3659
3660#[cfg(test)]
3661mod tests {
3662 use std::num::NonZero;
3663
3664 use super::*;
3665 use crate::item::test::{TestItem, TestProjectItem};
3666 use gpui::{TestAppContext, VisualTestContext};
3667 use project::FakeFs;
3668 use settings::SettingsStore;
3669 use theme::LoadThemes;
3670
3671 #[gpui::test]
3672 async fn test_remove_active_empty(cx: &mut TestAppContext) {
3673 init_test(cx);
3674 let fs = FakeFs::new(cx.executor());
3675
3676 let project = Project::test(fs, None, cx).await;
3677 let (workspace, cx) =
3678 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3679 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3680
3681 pane.update_in(cx, |pane, window, cx| {
3682 assert!(pane
3683 .close_active_item(
3684 &CloseActiveItem {
3685 save_intent: None,
3686 close_pinned: false
3687 },
3688 window,
3689 cx
3690 )
3691 .is_none())
3692 });
3693 }
3694
3695 #[gpui::test]
3696 async fn test_add_item_capped_to_max_tabs(cx: &mut TestAppContext) {
3697 init_test(cx);
3698 let fs = FakeFs::new(cx.executor());
3699
3700 let project = Project::test(fs, None, cx).await;
3701 let (workspace, cx) =
3702 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3703 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3704
3705 for i in 0..7 {
3706 add_labeled_item(&pane, format!("{}", i).as_str(), false, cx);
3707 }
3708 set_max_tabs(cx, Some(5));
3709 add_labeled_item(&pane, "7", false, cx);
3710 // Remove items to respect the max tab cap.
3711 assert_item_labels(&pane, ["3", "4", "5", "6", "7*"], cx);
3712 pane.update_in(cx, |pane, window, cx| {
3713 pane.activate_item(0, false, false, window, cx);
3714 });
3715 add_labeled_item(&pane, "X", false, cx);
3716 // Respect activation order.
3717 assert_item_labels(&pane, ["3", "X*", "5", "6", "7"], cx);
3718
3719 for i in 0..7 {
3720 add_labeled_item(&pane, format!("D{}", i).as_str(), true, cx);
3721 }
3722 // Keeps dirty items, even over max tab cap.
3723 assert_item_labels(
3724 &pane,
3725 ["D0^", "D1^", "D2^", "D3^", "D4^", "D5^", "D6*^"],
3726 cx,
3727 );
3728
3729 set_max_tabs(cx, None);
3730 for i in 0..7 {
3731 add_labeled_item(&pane, format!("N{}", i).as_str(), false, cx);
3732 }
3733 // No cap when max tabs is None.
3734 assert_item_labels(
3735 &pane,
3736 [
3737 "D0^", "D1^", "D2^", "D3^", "D4^", "D5^", "D6^", "N0", "N1", "N2", "N3", "N4",
3738 "N5", "N6*",
3739 ],
3740 cx,
3741 );
3742 }
3743
3744 #[gpui::test]
3745 async fn test_add_item_with_new_item(cx: &mut TestAppContext) {
3746 init_test(cx);
3747 let fs = FakeFs::new(cx.executor());
3748
3749 let project = Project::test(fs, None, cx).await;
3750 let (workspace, cx) =
3751 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3752 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3753
3754 // 1. Add with a destination index
3755 // a. Add before the active item
3756 set_labeled_items(&pane, ["A", "B*", "C"], cx);
3757 pane.update_in(cx, |pane, window, cx| {
3758 pane.add_item(
3759 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3760 false,
3761 false,
3762 Some(0),
3763 window,
3764 cx,
3765 );
3766 });
3767 assert_item_labels(&pane, ["D*", "A", "B", "C"], cx);
3768
3769 // b. Add after the active item
3770 set_labeled_items(&pane, ["A", "B*", "C"], cx);
3771 pane.update_in(cx, |pane, window, cx| {
3772 pane.add_item(
3773 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3774 false,
3775 false,
3776 Some(2),
3777 window,
3778 cx,
3779 );
3780 });
3781 assert_item_labels(&pane, ["A", "B", "D*", "C"], cx);
3782
3783 // c. Add at the end of the item list (including off the length)
3784 set_labeled_items(&pane, ["A", "B*", "C"], cx);
3785 pane.update_in(cx, |pane, window, cx| {
3786 pane.add_item(
3787 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3788 false,
3789 false,
3790 Some(5),
3791 window,
3792 cx,
3793 );
3794 });
3795 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
3796
3797 // 2. Add without a destination index
3798 // a. Add with active item at the start of the item list
3799 set_labeled_items(&pane, ["A*", "B", "C"], cx);
3800 pane.update_in(cx, |pane, window, cx| {
3801 pane.add_item(
3802 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3803 false,
3804 false,
3805 None,
3806 window,
3807 cx,
3808 );
3809 });
3810 set_labeled_items(&pane, ["A", "D*", "B", "C"], cx);
3811
3812 // b. Add with active item at the end of the item list
3813 set_labeled_items(&pane, ["A", "B", "C*"], cx);
3814 pane.update_in(cx, |pane, window, cx| {
3815 pane.add_item(
3816 Box::new(cx.new(|cx| TestItem::new(cx).with_label("D"))),
3817 false,
3818 false,
3819 None,
3820 window,
3821 cx,
3822 );
3823 });
3824 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
3825 }
3826
3827 #[gpui::test]
3828 async fn test_add_item_with_existing_item(cx: &mut TestAppContext) {
3829 init_test(cx);
3830 let fs = FakeFs::new(cx.executor());
3831
3832 let project = Project::test(fs, None, cx).await;
3833 let (workspace, cx) =
3834 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3835 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3836
3837 // 1. Add with a destination index
3838 // 1a. Add before the active item
3839 let [_, _, _, d] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
3840 pane.update_in(cx, |pane, window, cx| {
3841 pane.add_item(d, false, false, Some(0), window, cx);
3842 });
3843 assert_item_labels(&pane, ["D*", "A", "B", "C"], cx);
3844
3845 // 1b. Add after the active item
3846 let [_, _, _, d] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
3847 pane.update_in(cx, |pane, window, cx| {
3848 pane.add_item(d, false, false, Some(2), window, cx);
3849 });
3850 assert_item_labels(&pane, ["A", "B", "D*", "C"], cx);
3851
3852 // 1c. Add at the end of the item list (including off the length)
3853 let [a, _, _, _] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
3854 pane.update_in(cx, |pane, window, cx| {
3855 pane.add_item(a, false, false, Some(5), window, cx);
3856 });
3857 assert_item_labels(&pane, ["B", "C", "D", "A*"], cx);
3858
3859 // 1d. Add same item to active index
3860 let [_, b, _] = set_labeled_items(&pane, ["A", "B*", "C"], cx);
3861 pane.update_in(cx, |pane, window, cx| {
3862 pane.add_item(b, false, false, Some(1), window, cx);
3863 });
3864 assert_item_labels(&pane, ["A", "B*", "C"], cx);
3865
3866 // 1e. Add item to index after same item in last position
3867 let [_, _, c] = set_labeled_items(&pane, ["A", "B*", "C"], cx);
3868 pane.update_in(cx, |pane, window, cx| {
3869 pane.add_item(c, false, false, Some(2), window, cx);
3870 });
3871 assert_item_labels(&pane, ["A", "B", "C*"], cx);
3872
3873 // 2. Add without a destination index
3874 // 2a. Add with active item at the start of the item list
3875 let [_, _, _, d] = set_labeled_items(&pane, ["A*", "B", "C", "D"], cx);
3876 pane.update_in(cx, |pane, window, cx| {
3877 pane.add_item(d, false, false, None, window, cx);
3878 });
3879 assert_item_labels(&pane, ["A", "D*", "B", "C"], cx);
3880
3881 // 2b. Add with active item at the end of the item list
3882 let [a, _, _, _] = set_labeled_items(&pane, ["A", "B", "C", "D*"], cx);
3883 pane.update_in(cx, |pane, window, cx| {
3884 pane.add_item(a, false, false, None, window, cx);
3885 });
3886 assert_item_labels(&pane, ["B", "C", "D", "A*"], cx);
3887
3888 // 2c. Add active item to active item at end of list
3889 let [_, _, c] = set_labeled_items(&pane, ["A", "B", "C*"], cx);
3890 pane.update_in(cx, |pane, window, cx| {
3891 pane.add_item(c, false, false, None, window, cx);
3892 });
3893 assert_item_labels(&pane, ["A", "B", "C*"], cx);
3894
3895 // 2d. Add active item to active item at start of list
3896 let [a, _, _] = set_labeled_items(&pane, ["A*", "B", "C"], cx);
3897 pane.update_in(cx, |pane, window, cx| {
3898 pane.add_item(a, false, false, None, window, cx);
3899 });
3900 assert_item_labels(&pane, ["A*", "B", "C"], cx);
3901 }
3902
3903 #[gpui::test]
3904 async fn test_add_item_with_same_project_entries(cx: &mut TestAppContext) {
3905 init_test(cx);
3906 let fs = FakeFs::new(cx.executor());
3907
3908 let project = Project::test(fs, None, cx).await;
3909 let (workspace, cx) =
3910 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
3911 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
3912
3913 // singleton view
3914 pane.update_in(cx, |pane, window, cx| {
3915 pane.add_item(
3916 Box::new(cx.new(|cx| {
3917 TestItem::new(cx)
3918 .with_singleton(true)
3919 .with_label("buffer 1")
3920 .with_project_items(&[TestProjectItem::new(1, "one.txt", cx)])
3921 })),
3922 false,
3923 false,
3924 None,
3925 window,
3926 cx,
3927 );
3928 });
3929 assert_item_labels(&pane, ["buffer 1*"], cx);
3930
3931 // new singleton view with the same project entry
3932 pane.update_in(cx, |pane, window, cx| {
3933 pane.add_item(
3934 Box::new(cx.new(|cx| {
3935 TestItem::new(cx)
3936 .with_singleton(true)
3937 .with_label("buffer 1")
3938 .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
3939 })),
3940 false,
3941 false,
3942 None,
3943 window,
3944 cx,
3945 );
3946 });
3947 assert_item_labels(&pane, ["buffer 1*"], cx);
3948
3949 // new singleton view with different project entry
3950 pane.update_in(cx, |pane, window, cx| {
3951 pane.add_item(
3952 Box::new(cx.new(|cx| {
3953 TestItem::new(cx)
3954 .with_singleton(true)
3955 .with_label("buffer 2")
3956 .with_project_items(&[TestProjectItem::new(2, "2.txt", cx)])
3957 })),
3958 false,
3959 false,
3960 None,
3961 window,
3962 cx,
3963 );
3964 });
3965 assert_item_labels(&pane, ["buffer 1", "buffer 2*"], cx);
3966
3967 // new multibuffer view with the same project entry
3968 pane.update_in(cx, |pane, window, cx| {
3969 pane.add_item(
3970 Box::new(cx.new(|cx| {
3971 TestItem::new(cx)
3972 .with_singleton(false)
3973 .with_label("multibuffer 1")
3974 .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
3975 })),
3976 false,
3977 false,
3978 None,
3979 window,
3980 cx,
3981 );
3982 });
3983 assert_item_labels(&pane, ["buffer 1", "buffer 2", "multibuffer 1*"], cx);
3984
3985 // another multibuffer view with the same project entry
3986 pane.update_in(cx, |pane, window, cx| {
3987 pane.add_item(
3988 Box::new(cx.new(|cx| {
3989 TestItem::new(cx)
3990 .with_singleton(false)
3991 .with_label("multibuffer 1b")
3992 .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
3993 })),
3994 false,
3995 false,
3996 None,
3997 window,
3998 cx,
3999 );
4000 });
4001 assert_item_labels(
4002 &pane,
4003 ["buffer 1", "buffer 2", "multibuffer 1", "multibuffer 1b*"],
4004 cx,
4005 );
4006 }
4007
4008 #[gpui::test]
4009 async fn test_remove_item_ordering_history(cx: &mut TestAppContext) {
4010 init_test(cx);
4011 let fs = FakeFs::new(cx.executor());
4012
4013 let project = Project::test(fs, None, cx).await;
4014 let (workspace, cx) =
4015 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4016 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4017
4018 add_labeled_item(&pane, "A", false, cx);
4019 add_labeled_item(&pane, "B", false, cx);
4020 add_labeled_item(&pane, "C", false, cx);
4021 add_labeled_item(&pane, "D", false, cx);
4022 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4023
4024 pane.update_in(cx, |pane, window, cx| {
4025 pane.activate_item(1, false, false, window, cx)
4026 });
4027 add_labeled_item(&pane, "1", false, cx);
4028 assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
4029
4030 pane.update_in(cx, |pane, window, cx| {
4031 pane.close_active_item(
4032 &CloseActiveItem {
4033 save_intent: None,
4034 close_pinned: false,
4035 },
4036 window,
4037 cx,
4038 )
4039 })
4040 .unwrap()
4041 .await
4042 .unwrap();
4043 assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
4044
4045 pane.update_in(cx, |pane, window, cx| {
4046 pane.activate_item(3, false, false, window, cx)
4047 });
4048 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4049
4050 pane.update_in(cx, |pane, window, cx| {
4051 pane.close_active_item(
4052 &CloseActiveItem {
4053 save_intent: None,
4054 close_pinned: false,
4055 },
4056 window,
4057 cx,
4058 )
4059 })
4060 .unwrap()
4061 .await
4062 .unwrap();
4063 assert_item_labels(&pane, ["A", "B*", "C"], cx);
4064
4065 pane.update_in(cx, |pane, window, cx| {
4066 pane.close_active_item(
4067 &CloseActiveItem {
4068 save_intent: None,
4069 close_pinned: false,
4070 },
4071 window,
4072 cx,
4073 )
4074 })
4075 .unwrap()
4076 .await
4077 .unwrap();
4078 assert_item_labels(&pane, ["A", "C*"], cx);
4079
4080 pane.update_in(cx, |pane, window, cx| {
4081 pane.close_active_item(
4082 &CloseActiveItem {
4083 save_intent: None,
4084 close_pinned: false,
4085 },
4086 window,
4087 cx,
4088 )
4089 })
4090 .unwrap()
4091 .await
4092 .unwrap();
4093 assert_item_labels(&pane, ["A*"], cx);
4094 }
4095
4096 #[gpui::test]
4097 async fn test_remove_item_ordering_neighbour(cx: &mut TestAppContext) {
4098 init_test(cx);
4099 cx.update_global::<SettingsStore, ()>(|s, cx| {
4100 s.update_user_settings::<ItemSettings>(cx, |s| {
4101 s.activate_on_close = Some(ActivateOnClose::Neighbour);
4102 });
4103 });
4104 let fs = FakeFs::new(cx.executor());
4105
4106 let project = Project::test(fs, None, cx).await;
4107 let (workspace, cx) =
4108 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4109 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4110
4111 add_labeled_item(&pane, "A", false, cx);
4112 add_labeled_item(&pane, "B", false, cx);
4113 add_labeled_item(&pane, "C", false, cx);
4114 add_labeled_item(&pane, "D", false, cx);
4115 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4116
4117 pane.update_in(cx, |pane, window, cx| {
4118 pane.activate_item(1, false, false, window, cx)
4119 });
4120 add_labeled_item(&pane, "1", false, cx);
4121 assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
4122
4123 pane.update_in(cx, |pane, window, cx| {
4124 pane.close_active_item(
4125 &CloseActiveItem {
4126 save_intent: None,
4127 close_pinned: false,
4128 },
4129 window,
4130 cx,
4131 )
4132 })
4133 .unwrap()
4134 .await
4135 .unwrap();
4136 assert_item_labels(&pane, ["A", "B", "C*", "D"], cx);
4137
4138 pane.update_in(cx, |pane, window, cx| {
4139 pane.activate_item(3, false, false, window, cx)
4140 });
4141 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4142
4143 pane.update_in(cx, |pane, window, cx| {
4144 pane.close_active_item(
4145 &CloseActiveItem {
4146 save_intent: None,
4147 close_pinned: false,
4148 },
4149 window,
4150 cx,
4151 )
4152 })
4153 .unwrap()
4154 .await
4155 .unwrap();
4156 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4157
4158 pane.update_in(cx, |pane, window, cx| {
4159 pane.close_active_item(
4160 &CloseActiveItem {
4161 save_intent: None,
4162 close_pinned: false,
4163 },
4164 window,
4165 cx,
4166 )
4167 })
4168 .unwrap()
4169 .await
4170 .unwrap();
4171 assert_item_labels(&pane, ["A", "B*"], cx);
4172
4173 pane.update_in(cx, |pane, window, cx| {
4174 pane.close_active_item(
4175 &CloseActiveItem {
4176 save_intent: None,
4177 close_pinned: false,
4178 },
4179 window,
4180 cx,
4181 )
4182 })
4183 .unwrap()
4184 .await
4185 .unwrap();
4186 assert_item_labels(&pane, ["A*"], cx);
4187 }
4188
4189 #[gpui::test]
4190 async fn test_remove_item_ordering_left_neighbour(cx: &mut TestAppContext) {
4191 init_test(cx);
4192 cx.update_global::<SettingsStore, ()>(|s, cx| {
4193 s.update_user_settings::<ItemSettings>(cx, |s| {
4194 s.activate_on_close = Some(ActivateOnClose::LeftNeighbour);
4195 });
4196 });
4197 let fs = FakeFs::new(cx.executor());
4198
4199 let project = Project::test(fs, None, cx).await;
4200 let (workspace, cx) =
4201 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4202 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4203
4204 add_labeled_item(&pane, "A", false, cx);
4205 add_labeled_item(&pane, "B", false, cx);
4206 add_labeled_item(&pane, "C", false, cx);
4207 add_labeled_item(&pane, "D", false, cx);
4208 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4209
4210 pane.update_in(cx, |pane, window, cx| {
4211 pane.activate_item(1, false, false, window, cx)
4212 });
4213 add_labeled_item(&pane, "1", false, cx);
4214 assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
4215
4216 pane.update_in(cx, |pane, window, cx| {
4217 pane.close_active_item(
4218 &CloseActiveItem {
4219 save_intent: None,
4220 close_pinned: false,
4221 },
4222 window,
4223 cx,
4224 )
4225 })
4226 .unwrap()
4227 .await
4228 .unwrap();
4229 assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
4230
4231 pane.update_in(cx, |pane, window, cx| {
4232 pane.activate_item(3, false, false, window, cx)
4233 });
4234 assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
4235
4236 pane.update_in(cx, |pane, window, cx| {
4237 pane.close_active_item(
4238 &CloseActiveItem {
4239 save_intent: None,
4240 close_pinned: false,
4241 },
4242 window,
4243 cx,
4244 )
4245 })
4246 .unwrap()
4247 .await
4248 .unwrap();
4249 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4250
4251 pane.update_in(cx, |pane, window, cx| {
4252 pane.activate_item(0, false, false, window, cx)
4253 });
4254 assert_item_labels(&pane, ["A*", "B", "C"], cx);
4255
4256 pane.update_in(cx, |pane, window, cx| {
4257 pane.close_active_item(
4258 &CloseActiveItem {
4259 save_intent: None,
4260 close_pinned: false,
4261 },
4262 window,
4263 cx,
4264 )
4265 })
4266 .unwrap()
4267 .await
4268 .unwrap();
4269 assert_item_labels(&pane, ["B*", "C"], cx);
4270
4271 pane.update_in(cx, |pane, window, cx| {
4272 pane.close_active_item(
4273 &CloseActiveItem {
4274 save_intent: None,
4275 close_pinned: false,
4276 },
4277 window,
4278 cx,
4279 )
4280 })
4281 .unwrap()
4282 .await
4283 .unwrap();
4284 assert_item_labels(&pane, ["C*"], cx);
4285 }
4286
4287 #[gpui::test]
4288 async fn test_close_inactive_items(cx: &mut TestAppContext) {
4289 init_test(cx);
4290 let fs = FakeFs::new(cx.executor());
4291
4292 let project = Project::test(fs, None, cx).await;
4293 let (workspace, cx) =
4294 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4295 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4296
4297 set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
4298
4299 pane.update_in(cx, |pane, window, cx| {
4300 pane.close_inactive_items(
4301 &CloseInactiveItems {
4302 save_intent: None,
4303 close_pinned: false,
4304 },
4305 window,
4306 cx,
4307 )
4308 })
4309 .unwrap()
4310 .await
4311 .unwrap();
4312 assert_item_labels(&pane, ["C*"], cx);
4313 }
4314
4315 #[gpui::test]
4316 async fn test_close_clean_items(cx: &mut TestAppContext) {
4317 init_test(cx);
4318 let fs = FakeFs::new(cx.executor());
4319
4320 let project = Project::test(fs, None, cx).await;
4321 let (workspace, cx) =
4322 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4323 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4324
4325 add_labeled_item(&pane, "A", true, cx);
4326 add_labeled_item(&pane, "B", false, cx);
4327 add_labeled_item(&pane, "C", true, cx);
4328 add_labeled_item(&pane, "D", false, cx);
4329 add_labeled_item(&pane, "E", false, cx);
4330 assert_item_labels(&pane, ["A^", "B", "C^", "D", "E*"], cx);
4331
4332 pane.update_in(cx, |pane, window, cx| {
4333 pane.close_clean_items(
4334 &CloseCleanItems {
4335 close_pinned: false,
4336 },
4337 window,
4338 cx,
4339 )
4340 })
4341 .unwrap()
4342 .await
4343 .unwrap();
4344 assert_item_labels(&pane, ["A^", "C*^"], cx);
4345 }
4346
4347 #[gpui::test]
4348 async fn test_close_items_to_the_left(cx: &mut TestAppContext) {
4349 init_test(cx);
4350 let fs = FakeFs::new(cx.executor());
4351
4352 let project = Project::test(fs, None, cx).await;
4353 let (workspace, cx) =
4354 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4355 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4356
4357 set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
4358
4359 pane.update_in(cx, |pane, window, cx| {
4360 pane.close_items_to_the_left(
4361 &CloseItemsToTheLeft {
4362 close_pinned: false,
4363 },
4364 window,
4365 cx,
4366 )
4367 })
4368 .unwrap()
4369 .await
4370 .unwrap();
4371 assert_item_labels(&pane, ["C*", "D", "E"], cx);
4372 }
4373
4374 #[gpui::test]
4375 async fn test_close_items_to_the_right(cx: &mut TestAppContext) {
4376 init_test(cx);
4377 let fs = FakeFs::new(cx.executor());
4378
4379 let project = Project::test(fs, None, cx).await;
4380 let (workspace, cx) =
4381 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4382 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4383
4384 set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
4385
4386 pane.update_in(cx, |pane, window, cx| {
4387 pane.close_items_to_the_right(
4388 &CloseItemsToTheRight {
4389 close_pinned: false,
4390 },
4391 window,
4392 cx,
4393 )
4394 })
4395 .unwrap()
4396 .await
4397 .unwrap();
4398 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4399 }
4400
4401 #[gpui::test]
4402 async fn test_close_all_items(cx: &mut TestAppContext) {
4403 init_test(cx);
4404 let fs = FakeFs::new(cx.executor());
4405
4406 let project = Project::test(fs, None, cx).await;
4407 let (workspace, cx) =
4408 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4409 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4410
4411 let item_a = add_labeled_item(&pane, "A", false, cx);
4412 add_labeled_item(&pane, "B", false, cx);
4413 add_labeled_item(&pane, "C", false, cx);
4414 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4415
4416 pane.update_in(cx, |pane, window, cx| {
4417 let ix = pane.index_for_item_id(item_a.item_id()).unwrap();
4418 pane.pin_tab_at(ix, window, cx);
4419 pane.close_all_items(
4420 &CloseAllItems {
4421 save_intent: None,
4422 close_pinned: false,
4423 },
4424 window,
4425 cx,
4426 )
4427 })
4428 .unwrap()
4429 .await
4430 .unwrap();
4431 assert_item_labels(&pane, ["A*"], cx);
4432
4433 pane.update_in(cx, |pane, window, cx| {
4434 let ix = pane.index_for_item_id(item_a.item_id()).unwrap();
4435 pane.unpin_tab_at(ix, window, cx);
4436 pane.close_all_items(
4437 &CloseAllItems {
4438 save_intent: None,
4439 close_pinned: false,
4440 },
4441 window,
4442 cx,
4443 )
4444 })
4445 .unwrap()
4446 .await
4447 .unwrap();
4448
4449 assert_item_labels(&pane, [], cx);
4450
4451 add_labeled_item(&pane, "A", true, cx).update(cx, |item, cx| {
4452 item.project_items
4453 .push(TestProjectItem::new_dirty(1, "A.txt", cx))
4454 });
4455 add_labeled_item(&pane, "B", true, cx).update(cx, |item, cx| {
4456 item.project_items
4457 .push(TestProjectItem::new_dirty(2, "B.txt", cx))
4458 });
4459 add_labeled_item(&pane, "C", true, cx).update(cx, |item, cx| {
4460 item.project_items
4461 .push(TestProjectItem::new_dirty(3, "C.txt", cx))
4462 });
4463 assert_item_labels(&pane, ["A^", "B^", "C*^"], cx);
4464
4465 let save = pane
4466 .update_in(cx, |pane, window, cx| {
4467 pane.close_all_items(
4468 &CloseAllItems {
4469 save_intent: None,
4470 close_pinned: false,
4471 },
4472 window,
4473 cx,
4474 )
4475 })
4476 .unwrap();
4477
4478 cx.executor().run_until_parked();
4479 cx.simulate_prompt_answer("Save all");
4480 save.await.unwrap();
4481 assert_item_labels(&pane, [], cx);
4482
4483 add_labeled_item(&pane, "A", true, cx);
4484 add_labeled_item(&pane, "B", true, cx);
4485 add_labeled_item(&pane, "C", true, cx);
4486 assert_item_labels(&pane, ["A^", "B^", "C*^"], cx);
4487 let save = pane
4488 .update_in(cx, |pane, window, cx| {
4489 pane.close_all_items(
4490 &CloseAllItems {
4491 save_intent: None,
4492 close_pinned: false,
4493 },
4494 window,
4495 cx,
4496 )
4497 })
4498 .unwrap();
4499
4500 cx.executor().run_until_parked();
4501 cx.simulate_prompt_answer("Discard all");
4502 save.await.unwrap();
4503 assert_item_labels(&pane, [], cx);
4504 }
4505
4506 #[gpui::test]
4507 async fn test_close_with_save_intent(cx: &mut TestAppContext) {
4508 init_test(cx);
4509 let fs = FakeFs::new(cx.executor());
4510
4511 let project = Project::test(fs, None, cx).await;
4512 let (workspace, cx) =
4513 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4514 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4515
4516 let a = cx.update(|_, cx| TestProjectItem::new_dirty(1, "A.txt", cx));
4517 let b = cx.update(|_, cx| TestProjectItem::new_dirty(1, "B.txt", cx));
4518 let c = cx.update(|_, cx| TestProjectItem::new_dirty(1, "C.txt", cx));
4519
4520 add_labeled_item(&pane, "AB", true, cx).update(cx, |item, _| {
4521 item.project_items.push(a.clone());
4522 item.project_items.push(b.clone());
4523 });
4524 add_labeled_item(&pane, "C", true, cx)
4525 .update(cx, |item, _| item.project_items.push(c.clone()));
4526 assert_item_labels(&pane, ["AB^", "C*^"], cx);
4527
4528 pane.update_in(cx, |pane, window, cx| {
4529 pane.close_all_items(
4530 &CloseAllItems {
4531 save_intent: Some(SaveIntent::Save),
4532 close_pinned: false,
4533 },
4534 window,
4535 cx,
4536 )
4537 })
4538 .unwrap()
4539 .await
4540 .unwrap();
4541
4542 assert_item_labels(&pane, [], cx);
4543 cx.update(|_, cx| {
4544 assert!(!a.read(cx).is_dirty);
4545 assert!(!b.read(cx).is_dirty);
4546 assert!(!c.read(cx).is_dirty);
4547 });
4548 }
4549
4550 #[gpui::test]
4551 async fn test_close_all_items_including_pinned(cx: &mut TestAppContext) {
4552 init_test(cx);
4553 let fs = FakeFs::new(cx.executor());
4554
4555 let project = Project::test(fs, None, cx).await;
4556 let (workspace, cx) =
4557 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4558 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4559
4560 let item_a = add_labeled_item(&pane, "A", false, cx);
4561 add_labeled_item(&pane, "B", false, cx);
4562 add_labeled_item(&pane, "C", false, cx);
4563 assert_item_labels(&pane, ["A", "B", "C*"], cx);
4564
4565 pane.update_in(cx, |pane, window, cx| {
4566 let ix = pane.index_for_item_id(item_a.item_id()).unwrap();
4567 pane.pin_tab_at(ix, window, cx);
4568 pane.close_all_items(
4569 &CloseAllItems {
4570 save_intent: None,
4571 close_pinned: true,
4572 },
4573 window,
4574 cx,
4575 )
4576 })
4577 .unwrap()
4578 .await
4579 .unwrap();
4580 assert_item_labels(&pane, [], cx);
4581 }
4582
4583 #[gpui::test]
4584 async fn test_close_pinned_tab_with_non_pinned_in_same_pane(cx: &mut TestAppContext) {
4585 init_test(cx);
4586 let fs = FakeFs::new(cx.executor());
4587 let project = Project::test(fs, None, cx).await;
4588 let (workspace, cx) =
4589 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4590
4591 // Non-pinned tabs in same pane
4592 let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4593 add_labeled_item(&pane, "A", false, cx);
4594 add_labeled_item(&pane, "B", false, cx);
4595 add_labeled_item(&pane, "C", false, cx);
4596 pane.update_in(cx, |pane, window, cx| {
4597 pane.pin_tab_at(0, window, cx);
4598 });
4599 set_labeled_items(&pane, ["A*", "B", "C"], cx);
4600 pane.update_in(cx, |pane, window, cx| {
4601 pane.close_active_item(
4602 &CloseActiveItem {
4603 save_intent: None,
4604 close_pinned: false,
4605 },
4606 window,
4607 cx,
4608 );
4609 });
4610 // Non-pinned tab should be active
4611 assert_item_labels(&pane, ["A", "B*", "C"], cx);
4612 }
4613
4614 #[gpui::test]
4615 async fn test_close_pinned_tab_with_non_pinned_in_different_pane(cx: &mut TestAppContext) {
4616 init_test(cx);
4617 let fs = FakeFs::new(cx.executor());
4618 let project = Project::test(fs, None, cx).await;
4619 let (workspace, cx) =
4620 cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx));
4621
4622 // No non-pinned tabs in same pane, non-pinned tabs in another pane
4623 let pane1 = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
4624 let pane2 = workspace.update_in(cx, |workspace, window, cx| {
4625 workspace.split_pane(pane1.clone(), SplitDirection::Right, window, cx)
4626 });
4627 add_labeled_item(&pane1, "A", false, cx);
4628 pane1.update_in(cx, |pane, window, cx| {
4629 pane.pin_tab_at(0, window, cx);
4630 });
4631 set_labeled_items(&pane1, ["A*"], cx);
4632 add_labeled_item(&pane2, "B", false, cx);
4633 set_labeled_items(&pane2, ["B"], cx);
4634 pane1.update_in(cx, |pane, window, cx| {
4635 pane.close_active_item(
4636 &CloseActiveItem {
4637 save_intent: None,
4638 close_pinned: false,
4639 },
4640 window,
4641 cx,
4642 );
4643 });
4644 // Non-pinned tab of other pane should be active
4645 assert_item_labels(&pane2, ["B*"], cx);
4646 }
4647
4648 fn init_test(cx: &mut TestAppContext) {
4649 cx.update(|cx| {
4650 let settings_store = SettingsStore::test(cx);
4651 cx.set_global(settings_store);
4652 theme::init(LoadThemes::JustBase, cx);
4653 crate::init_settings(cx);
4654 Project::init_settings(cx);
4655 });
4656 }
4657
4658 fn set_max_tabs(cx: &mut TestAppContext, value: Option<usize>) {
4659 cx.update_global(|store: &mut SettingsStore, cx| {
4660 store.update_user_settings::<WorkspaceSettings>(cx, |settings| {
4661 settings.max_tabs = value.map(|v| NonZero::new(v).unwrap())
4662 });
4663 });
4664 }
4665
4666 fn add_labeled_item(
4667 pane: &Entity<Pane>,
4668 label: &str,
4669 is_dirty: bool,
4670 cx: &mut VisualTestContext,
4671 ) -> Box<Entity<TestItem>> {
4672 pane.update_in(cx, |pane, window, cx| {
4673 let labeled_item =
4674 Box::new(cx.new(|cx| TestItem::new(cx).with_label(label).with_dirty(is_dirty)));
4675 pane.add_item(labeled_item.clone(), false, false, None, window, cx);
4676 labeled_item
4677 })
4678 }
4679
4680 fn set_labeled_items<const COUNT: usize>(
4681 pane: &Entity<Pane>,
4682 labels: [&str; COUNT],
4683 cx: &mut VisualTestContext,
4684 ) -> [Box<Entity<TestItem>>; COUNT] {
4685 pane.update_in(cx, |pane, window, cx| {
4686 pane.items.clear();
4687 let mut active_item_index = 0;
4688
4689 let mut index = 0;
4690 let items = labels.map(|mut label| {
4691 if label.ends_with('*') {
4692 label = label.trim_end_matches('*');
4693 active_item_index = index;
4694 }
4695
4696 let labeled_item = Box::new(cx.new(|cx| TestItem::new(cx).with_label(label)));
4697 pane.add_item(labeled_item.clone(), false, false, None, window, cx);
4698 index += 1;
4699 labeled_item
4700 });
4701
4702 pane.activate_item(active_item_index, false, false, window, cx);
4703
4704 items
4705 })
4706 }
4707
4708 // Assert the item label, with the active item label suffixed with a '*'
4709 #[track_caller]
4710 fn assert_item_labels<const COUNT: usize>(
4711 pane: &Entity<Pane>,
4712 expected_states: [&str; COUNT],
4713 cx: &mut VisualTestContext,
4714 ) {
4715 let actual_states = pane.update(cx, |pane, cx| {
4716 pane.items
4717 .iter()
4718 .enumerate()
4719 .map(|(ix, item)| {
4720 let mut state = item
4721 .to_any()
4722 .downcast::<TestItem>()
4723 .unwrap()
4724 .read(cx)
4725 .label
4726 .clone();
4727 if ix == pane.active_item_index {
4728 state.push('*');
4729 }
4730 if item.is_dirty(cx) {
4731 state.push('^');
4732 }
4733 state
4734 })
4735 .collect::<Vec<_>>()
4736 });
4737 assert_eq!(
4738 actual_states, expected_states,
4739 "pane items do not match expectation"
4740 );
4741 }
4742}