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