1use crate::{
   2    item::{
   3        ClosePosition, Item, ItemHandle, ItemSettings, PreviewTabsSettings, TabContentParams,
   4        WeakItemHandle,
   5    },
   6    toolbar::Toolbar,
   7    workspace_settings::{AutosaveSetting, TabBarSettings, WorkspaceSettings},
   8    NewCenterTerminal, NewFile, NewSearch, OpenInTerminal, OpenTerminal, OpenVisible,
   9    SplitDirection, ToggleZoom, Workspace,
  10};
  11use anyhow::Result;
  12use collections::{HashMap, HashSet, VecDeque};
  13use futures::{stream::FuturesUnordered, StreamExt};
  14use gpui::{
  15    actions, anchored, deferred, impl_actions, prelude::*, Action, AnchorCorner, AnyElement,
  16    AppContext, AsyncWindowContext, ClickEvent, DismissEvent, Div, DragMoveEvent, EntityId,
  17    EventEmitter, ExternalPaths, FocusHandle, FocusableView, KeyContext, Model, MouseButton,
  18    MouseDownEvent, NavigationDirection, Pixels, Point, PromptLevel, Render, ScrollHandle,
  19    Subscription, Task, View, ViewContext, VisualContext, WeakFocusHandle, WeakView, WindowContext,
  20};
  21use parking_lot::Mutex;
  22use project::{Project, ProjectEntryId, ProjectPath};
  23use serde::Deserialize;
  24use settings::{Settings, SettingsStore};
  25use std::{
  26    any::Any,
  27    cmp, fmt, mem,
  28    ops::ControlFlow,
  29    path::PathBuf,
  30    rc::Rc,
  31    sync::{
  32        atomic::{AtomicUsize, Ordering},
  33        Arc,
  34    },
  35};
  36use theme::ThemeSettings;
  37
  38use ui::{
  39    prelude::*, right_click_menu, ButtonSize, Color, IconButton, IconButtonShape, IconName,
  40    IconSize, Indicator, Label, Tab, TabBar, TabPosition, Tooltip,
  41};
  42use ui::{v_flex, ContextMenu};
  43use util::{maybe, truncate_and_remove_front, ResultExt};
  44
  45#[derive(PartialEq, Clone, Copy, Deserialize, Debug)]
  46#[serde(rename_all = "camelCase")]
  47pub enum SaveIntent {
  48    /// write all files (even if unchanged)
  49    /// prompt before overwriting on-disk changes
  50    Save,
  51    /// same as Save, but without auto formatting
  52    SaveWithoutFormat,
  53    /// write any files that have local changes
  54    /// prompt before overwriting on-disk changes
  55    SaveAll,
  56    /// always prompt for a new path
  57    SaveAs,
  58    /// prompt "you have unsaved changes" before writing
  59    Close,
  60    /// write all dirty files, don't prompt on conflict
  61    Overwrite,
  62    /// skip all save-related behavior
  63    Skip,
  64}
  65
  66#[derive(Clone, Deserialize, PartialEq, Debug)]
  67pub struct ActivateItem(pub usize);
  68
  69#[derive(Clone, PartialEq, Debug, Deserialize, Default)]
  70#[serde(rename_all = "camelCase")]
  71pub struct CloseActiveItem {
  72    pub save_intent: Option<SaveIntent>,
  73}
  74
  75#[derive(Clone, PartialEq, Debug, Deserialize, Default)]
  76#[serde(rename_all = "camelCase")]
  77pub struct CloseInactiveItems {
  78    pub save_intent: Option<SaveIntent>,
  79}
  80
  81#[derive(Clone, PartialEq, Debug, Deserialize, Default)]
  82#[serde(rename_all = "camelCase")]
  83pub struct CloseAllItems {
  84    pub save_intent: Option<SaveIntent>,
  85}
  86
  87#[derive(Clone, PartialEq, Debug, Deserialize, Default)]
  88#[serde(rename_all = "camelCase")]
  89pub struct RevealInProjectPanel {
  90    pub entry_id: Option<u64>,
  91}
  92
  93#[derive(PartialEq, Clone, Deserialize)]
  94pub struct DeploySearch {
  95    #[serde(default)]
  96    pub replace_enabled: bool,
  97}
  98
  99impl_actions!(
 100    pane,
 101    [
 102        CloseAllItems,
 103        CloseActiveItem,
 104        CloseInactiveItems,
 105        ActivateItem,
 106        RevealInProjectPanel,
 107        DeploySearch,
 108    ]
 109);
 110
 111actions!(
 112    pane,
 113    [
 114        ActivatePrevItem,
 115        ActivateNextItem,
 116        ActivateLastItem,
 117        CloseCleanItems,
 118        CloseItemsToTheLeft,
 119        CloseItemsToTheRight,
 120        GoBack,
 121        GoForward,
 122        ReopenClosedItem,
 123        SplitLeft,
 124        SplitUp,
 125        SplitRight,
 126        SplitDown,
 127        TogglePreviewTab,
 128    ]
 129);
 130
 131impl DeploySearch {
 132    pub fn find() -> Self {
 133        Self {
 134            replace_enabled: false,
 135        }
 136    }
 137}
 138
 139const MAX_NAVIGATION_HISTORY_LEN: usize = 1024;
 140
 141pub enum Event {
 142    AddItem { item: Box<dyn ItemHandle> },
 143    ActivateItem { local: bool },
 144    Remove,
 145    RemoveItem { item_id: EntityId },
 146    Split(SplitDirection),
 147    ChangeItemTitle,
 148    Focus,
 149    ZoomIn,
 150    ZoomOut,
 151}
 152
 153impl fmt::Debug for Event {
 154    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 155        match self {
 156            Event::AddItem { item } => f
 157                .debug_struct("AddItem")
 158                .field("item", &item.item_id())
 159                .finish(),
 160            Event::ActivateItem { local } => f
 161                .debug_struct("ActivateItem")
 162                .field("local", local)
 163                .finish(),
 164            Event::Remove => f.write_str("Remove"),
 165            Event::RemoveItem { item_id } => f
 166                .debug_struct("RemoveItem")
 167                .field("item_id", item_id)
 168                .finish(),
 169            Event::Split(direction) => f
 170                .debug_struct("Split")
 171                .field("direction", direction)
 172                .finish(),
 173            Event::ChangeItemTitle => f.write_str("ChangeItemTitle"),
 174            Event::Focus => f.write_str("Focus"),
 175            Event::ZoomIn => f.write_str("ZoomIn"),
 176            Event::ZoomOut => f.write_str("ZoomOut"),
 177        }
 178    }
 179}
 180
 181/// A container for 0 to many items that are open in the workspace.
 182/// Treats all items uniformly via the [`ItemHandle`] trait, whether it's an editor, search results multibuffer, terminal or something else,
 183/// responsible for managing item tabs, focus and zoom states and drag and drop features.
 184/// Can be split, see `PaneGroup` for more details.
 185pub struct Pane {
 186    focus_handle: FocusHandle,
 187    items: Vec<Box<dyn ItemHandle>>,
 188    activation_history: Vec<EntityId>,
 189    zoomed: bool,
 190    was_focused: bool,
 191    active_item_index: usize,
 192    preview_item_id: Option<EntityId>,
 193    last_focus_handle_by_item: HashMap<EntityId, WeakFocusHandle>,
 194    nav_history: NavHistory,
 195    toolbar: View<Toolbar>,
 196    pub new_item_menu: Option<View<ContextMenu>>,
 197    split_item_menu: Option<View<ContextMenu>>,
 198    //     tab_context_menu: View<ContextMenu>,
 199    pub(crate) workspace: WeakView<Workspace>,
 200    project: Model<Project>,
 201    drag_split_direction: Option<SplitDirection>,
 202    can_drop_predicate: Option<Arc<dyn Fn(&dyn Any, &mut WindowContext) -> bool>>,
 203    custom_drop_handle:
 204        Option<Arc<dyn Fn(&mut Pane, &dyn Any, &mut ViewContext<Pane>) -> ControlFlow<(), ()>>>,
 205    can_split: bool,
 206    render_tab_bar_buttons: Rc<dyn Fn(&mut Pane, &mut ViewContext<Pane>) -> AnyElement>,
 207    _subscriptions: Vec<Subscription>,
 208    tab_bar_scroll_handle: ScrollHandle,
 209    /// Is None if navigation buttons are permanently turned off (and should not react to setting changes).
 210    /// Otherwise, when `display_nav_history_buttons` is Some, it determines whether nav buttons should be displayed.
 211    display_nav_history_buttons: Option<bool>,
 212    double_click_dispatch_action: Box<dyn Action>,
 213}
 214
 215pub struct ItemNavHistory {
 216    history: NavHistory,
 217    item: Arc<dyn WeakItemHandle>,
 218    is_preview: bool,
 219}
 220
 221#[derive(Clone)]
 222pub struct NavHistory(Arc<Mutex<NavHistoryState>>);
 223
 224struct NavHistoryState {
 225    mode: NavigationMode,
 226    backward_stack: VecDeque<NavigationEntry>,
 227    forward_stack: VecDeque<NavigationEntry>,
 228    closed_stack: VecDeque<NavigationEntry>,
 229    paths_by_item: HashMap<EntityId, (ProjectPath, Option<PathBuf>)>,
 230    pane: WeakView<Pane>,
 231    next_timestamp: Arc<AtomicUsize>,
 232}
 233
 234#[derive(Debug, Copy, Clone)]
 235pub enum NavigationMode {
 236    Normal,
 237    GoingBack,
 238    GoingForward,
 239    ClosingItem,
 240    ReopeningClosedItem,
 241    Disabled,
 242}
 243
 244impl Default for NavigationMode {
 245    fn default() -> Self {
 246        Self::Normal
 247    }
 248}
 249
 250pub struct NavigationEntry {
 251    pub item: Arc<dyn WeakItemHandle>,
 252    pub data: Option<Box<dyn Any + Send>>,
 253    pub timestamp: usize,
 254    pub is_preview: bool,
 255}
 256
 257#[derive(Clone)]
 258pub struct DraggedTab {
 259    pub pane: View<Pane>,
 260    pub item: Box<dyn ItemHandle>,
 261    pub ix: usize,
 262    pub detail: usize,
 263    pub is_active: bool,
 264}
 265
 266impl EventEmitter<Event> for Pane {}
 267
 268impl Pane {
 269    pub fn new(
 270        workspace: WeakView<Workspace>,
 271        project: Model<Project>,
 272        next_timestamp: Arc<AtomicUsize>,
 273        can_drop_predicate: Option<Arc<dyn Fn(&dyn Any, &mut WindowContext) -> bool + 'static>>,
 274        double_click_dispatch_action: Box<dyn Action>,
 275        cx: &mut ViewContext<Self>,
 276    ) -> Self {
 277        let focus_handle = cx.focus_handle();
 278
 279        let subscriptions = vec![
 280            cx.on_focus(&focus_handle, Pane::focus_in),
 281            cx.on_focus_in(&focus_handle, Pane::focus_in),
 282            cx.on_focus_out(&focus_handle, Pane::focus_out),
 283            cx.observe_global::<SettingsStore>(Self::settings_changed),
 284        ];
 285
 286        let handle = cx.view().downgrade();
 287        Self {
 288            focus_handle,
 289            items: Vec::new(),
 290            activation_history: Vec::new(),
 291            was_focused: false,
 292            zoomed: false,
 293            active_item_index: 0,
 294            preview_item_id: None,
 295            last_focus_handle_by_item: Default::default(),
 296            nav_history: NavHistory(Arc::new(Mutex::new(NavHistoryState {
 297                mode: NavigationMode::Normal,
 298                backward_stack: Default::default(),
 299                forward_stack: Default::default(),
 300                closed_stack: Default::default(),
 301                paths_by_item: Default::default(),
 302                pane: handle.clone(),
 303                next_timestamp,
 304            }))),
 305            toolbar: cx.new_view(|_| Toolbar::new()),
 306            new_item_menu: None,
 307            split_item_menu: None,
 308            tab_bar_scroll_handle: ScrollHandle::new(),
 309            drag_split_direction: None,
 310            workspace,
 311            project,
 312            can_drop_predicate,
 313            custom_drop_handle: None,
 314            can_split: true,
 315            render_tab_bar_buttons: Rc::new(move |pane, cx| {
 316                h_flex()
 317                    .gap_2()
 318                    .child(
 319                        IconButton::new("plus", IconName::Plus)
 320                            .icon_size(IconSize::Small)
 321                            .icon_color(Color::Muted)
 322                            .on_click(cx.listener(|pane, _, cx| {
 323                                let menu = ContextMenu::build(cx, |menu, _| {
 324                                    menu.action("New File", NewFile.boxed_clone())
 325                                        .action("New Terminal", NewCenterTerminal.boxed_clone())
 326                                        .action("New Search", NewSearch.boxed_clone())
 327                                });
 328                                cx.subscribe(&menu, |pane, _, _: &DismissEvent, cx| {
 329                                    pane.focus(cx);
 330                                    pane.new_item_menu = None;
 331                                })
 332                                .detach();
 333                                pane.new_item_menu = Some(menu);
 334                            }))
 335                            .tooltip(|cx| Tooltip::text("New...", cx)),
 336                    )
 337                    .when_some(pane.new_item_menu.as_ref(), |el, new_item_menu| {
 338                        el.child(Self::render_menu_overlay(new_item_menu))
 339                    })
 340                    .child(
 341                        IconButton::new("split", IconName::Split)
 342                            .icon_size(IconSize::Small)
 343                            .icon_color(Color::Muted)
 344                            .on_click(cx.listener(|pane, _, cx| {
 345                                let menu = ContextMenu::build(cx, |menu, _| {
 346                                    menu.action("Split Right", SplitRight.boxed_clone())
 347                                        .action("Split Left", SplitLeft.boxed_clone())
 348                                        .action("Split Up", SplitUp.boxed_clone())
 349                                        .action("Split Down", SplitDown.boxed_clone())
 350                                });
 351                                cx.subscribe(&menu, |pane, _, _: &DismissEvent, cx| {
 352                                    pane.focus(cx);
 353                                    pane.split_item_menu = None;
 354                                })
 355                                .detach();
 356                                pane.split_item_menu = Some(menu);
 357                            }))
 358                            .tooltip(|cx| Tooltip::text("Split Pane", cx)),
 359                    )
 360                    .child({
 361                        let zoomed = pane.is_zoomed();
 362                        IconButton::new("toggle_zoom", IconName::Maximize)
 363                            .icon_size(IconSize::Small)
 364                            .icon_color(Color::Muted)
 365                            .selected(zoomed)
 366                            .selected_icon(IconName::Minimize)
 367                            .on_click(cx.listener(|pane, _, cx| {
 368                                pane.toggle_zoom(&crate::ToggleZoom, cx);
 369                            }))
 370                            .tooltip(move |cx| {
 371                                Tooltip::for_action(
 372                                    if zoomed { "Zoom Out" } else { "Zoom In" },
 373                                    &ToggleZoom,
 374                                    cx,
 375                                )
 376                            })
 377                    })
 378                    .when_some(pane.split_item_menu.as_ref(), |el, split_item_menu| {
 379                        el.child(Self::render_menu_overlay(split_item_menu))
 380                    })
 381                    .into_any_element()
 382            }),
 383            display_nav_history_buttons: Some(
 384                TabBarSettings::get_global(cx).show_nav_history_buttons,
 385            ),
 386            _subscriptions: subscriptions,
 387            double_click_dispatch_action,
 388        }
 389    }
 390
 391    pub fn has_focus(&self, cx: &WindowContext) -> bool {
 392        // We not only check whether our focus handle contains focus, but also
 393        // whether the active_item might have focus, because we might have just activated an item
 394        // but that hasn't rendered yet.
 395        // So before the next render, we might have transferred focus
 396        // to the item and `focus_handle.contains_focus` returns false because the `active_item`
 397        // is not hooked up to us in the dispatch tree.
 398        self.focus_handle.contains_focused(cx)
 399            || self
 400                .active_item()
 401                .map_or(false, |item| item.focus_handle(cx).contains_focused(cx))
 402    }
 403
 404    fn focus_in(&mut self, cx: &mut ViewContext<Self>) {
 405        if !self.was_focused {
 406            self.was_focused = true;
 407            cx.emit(Event::Focus);
 408            cx.notify();
 409        }
 410
 411        self.toolbar.update(cx, |toolbar, cx| {
 412            toolbar.focus_changed(true, cx);
 413        });
 414
 415        if let Some(active_item) = self.active_item() {
 416            if self.focus_handle.is_focused(cx) {
 417                // Pane was focused directly. We need to either focus a view inside the active item,
 418                // or focus the active item itself
 419                if let Some(weak_last_focus_handle) =
 420                    self.last_focus_handle_by_item.get(&active_item.item_id())
 421                {
 422                    if let Some(focus_handle) = weak_last_focus_handle.upgrade() {
 423                        focus_handle.focus(cx);
 424                        return;
 425                    }
 426                }
 427
 428                active_item.focus_handle(cx).focus(cx);
 429            } else if let Some(focused) = cx.focused() {
 430                if !self.context_menu_focused(cx) {
 431                    self.last_focus_handle_by_item
 432                        .insert(active_item.item_id(), focused.downgrade());
 433                }
 434            }
 435        }
 436    }
 437
 438    fn context_menu_focused(&self, cx: &mut ViewContext<Self>) -> bool {
 439        self.new_item_menu
 440            .as_ref()
 441            .or(self.split_item_menu.as_ref())
 442            .map_or(false, |menu| menu.focus_handle(cx).is_focused(cx))
 443    }
 444
 445    fn focus_out(&mut self, cx: &mut ViewContext<Self>) {
 446        self.was_focused = false;
 447        self.toolbar.update(cx, |toolbar, cx| {
 448            toolbar.focus_changed(false, cx);
 449        });
 450        cx.notify();
 451    }
 452
 453    fn settings_changed(&mut self, cx: &mut ViewContext<Self>) {
 454        if let Some(display_nav_history_buttons) = self.display_nav_history_buttons.as_mut() {
 455            *display_nav_history_buttons = TabBarSettings::get_global(cx).show_nav_history_buttons;
 456        }
 457        if !PreviewTabsSettings::get_global(cx).enabled {
 458            self.preview_item_id = None;
 459        }
 460        cx.notify();
 461    }
 462
 463    pub fn active_item_index(&self) -> usize {
 464        self.active_item_index
 465    }
 466
 467    pub fn activation_history(&self) -> &Vec<EntityId> {
 468        &self.activation_history
 469    }
 470
 471    pub fn set_can_split(&mut self, can_split: bool, cx: &mut ViewContext<Self>) {
 472        self.can_split = can_split;
 473        cx.notify();
 474    }
 475
 476    pub fn set_can_navigate(&mut self, can_navigate: bool, cx: &mut ViewContext<Self>) {
 477        self.toolbar.update(cx, |toolbar, cx| {
 478            toolbar.set_can_navigate(can_navigate, cx);
 479        });
 480        cx.notify();
 481    }
 482
 483    pub fn set_render_tab_bar_buttons<F>(&mut self, cx: &mut ViewContext<Self>, render: F)
 484    where
 485        F: 'static + Fn(&mut Pane, &mut ViewContext<Pane>) -> AnyElement,
 486    {
 487        self.render_tab_bar_buttons = Rc::new(render);
 488        cx.notify();
 489    }
 490
 491    pub fn set_custom_drop_handle<F>(&mut self, cx: &mut ViewContext<Self>, handle: F)
 492    where
 493        F: 'static + Fn(&mut Pane, &dyn Any, &mut ViewContext<Pane>) -> ControlFlow<(), ()>,
 494    {
 495        self.custom_drop_handle = Some(Arc::new(handle));
 496        cx.notify();
 497    }
 498
 499    pub fn nav_history_for_item<T: Item>(&self, item: &View<T>) -> ItemNavHistory {
 500        ItemNavHistory {
 501            history: self.nav_history.clone(),
 502            item: Arc::new(item.downgrade()),
 503            is_preview: self.preview_item_id == Some(item.item_id()),
 504        }
 505    }
 506
 507    pub fn nav_history(&self) -> &NavHistory {
 508        &self.nav_history
 509    }
 510
 511    pub fn nav_history_mut(&mut self) -> &mut NavHistory {
 512        &mut self.nav_history
 513    }
 514
 515    pub fn disable_history(&mut self) {
 516        self.nav_history.disable();
 517    }
 518
 519    pub fn enable_history(&mut self) {
 520        self.nav_history.enable();
 521    }
 522
 523    pub fn can_navigate_backward(&self) -> bool {
 524        !self.nav_history.0.lock().backward_stack.is_empty()
 525    }
 526
 527    pub fn can_navigate_forward(&self) -> bool {
 528        !self.nav_history.0.lock().forward_stack.is_empty()
 529    }
 530
 531    fn navigate_backward(&mut self, cx: &mut ViewContext<Self>) {
 532        if let Some(workspace) = self.workspace.upgrade() {
 533            let pane = cx.view().downgrade();
 534            cx.window_context().defer(move |cx| {
 535                workspace.update(cx, |workspace, cx| {
 536                    workspace.go_back(pane, cx).detach_and_log_err(cx)
 537                })
 538            })
 539        }
 540    }
 541
 542    fn navigate_forward(&mut self, cx: &mut ViewContext<Self>) {
 543        if let Some(workspace) = self.workspace.upgrade() {
 544            let pane = cx.view().downgrade();
 545            cx.window_context().defer(move |cx| {
 546                workspace.update(cx, |workspace, cx| {
 547                    workspace.go_forward(pane, cx).detach_and_log_err(cx)
 548                })
 549            })
 550        }
 551    }
 552
 553    fn history_updated(&mut self, cx: &mut ViewContext<Self>) {
 554        self.toolbar.update(cx, |_, cx| cx.notify());
 555    }
 556
 557    pub fn preview_item_id(&self) -> Option<EntityId> {
 558        self.preview_item_id
 559    }
 560
 561    fn preview_item_idx(&self) -> Option<usize> {
 562        if let Some(preview_item_id) = self.preview_item_id {
 563            self.items
 564                .iter()
 565                .position(|item| item.item_id() == preview_item_id)
 566        } else {
 567            None
 568        }
 569    }
 570
 571    pub fn is_active_preview_item(&self, item_id: EntityId) -> bool {
 572        self.preview_item_id == Some(item_id)
 573    }
 574
 575    /// Marks the item with the given ID as the preview item.
 576    /// This will be ignored if the global setting `preview_tabs` is disabled.
 577    pub fn set_preview_item_id(&mut self, item_id: Option<EntityId>, cx: &AppContext) {
 578        if PreviewTabsSettings::get_global(cx).enabled {
 579            self.preview_item_id = item_id;
 580        }
 581    }
 582
 583    pub fn handle_item_edit(&mut self, item_id: EntityId, cx: &AppContext) {
 584        if let Some(preview_item_id) = self.preview_item_id {
 585            if preview_item_id == item_id {
 586                self.set_preview_item_id(None, cx)
 587            }
 588        }
 589    }
 590
 591    pub(crate) fn open_item(
 592        &mut self,
 593        project_entry_id: Option<ProjectEntryId>,
 594        focus_item: bool,
 595        allow_preview: bool,
 596        cx: &mut ViewContext<Self>,
 597        build_item: impl FnOnce(&mut ViewContext<Pane>) -> Box<dyn ItemHandle>,
 598    ) -> Box<dyn ItemHandle> {
 599        let mut existing_item = None;
 600        if let Some(project_entry_id) = project_entry_id {
 601            for (index, item) in self.items.iter().enumerate() {
 602                if item.is_singleton(cx)
 603                    && item.project_entry_ids(cx).as_slice() == [project_entry_id]
 604                {
 605                    let item = item.boxed_clone();
 606                    existing_item = Some((index, item));
 607                    break;
 608                }
 609            }
 610        }
 611
 612        if let Some((index, existing_item)) = existing_item {
 613            // If the item is already open, and the item is a preview item
 614            // and we are not allowing items to open as preview, mark the item as persistent.
 615            if let Some(preview_item_id) = self.preview_item_id {
 616                if let Some(tab) = self.items.get(index) {
 617                    if tab.item_id() == preview_item_id && !allow_preview {
 618                        self.set_preview_item_id(None, cx);
 619                    }
 620                }
 621            }
 622
 623            self.activate_item(index, focus_item, focus_item, cx);
 624            existing_item
 625        } else {
 626            // If the item is being opened as preview and we have an existing preview tab,
 627            // open the new item in the position of the existing preview tab.
 628            let destination_index = if allow_preview {
 629                self.close_current_preview_item(cx)
 630            } else {
 631                None
 632            };
 633
 634            let new_item = build_item(cx);
 635
 636            if allow_preview {
 637                self.set_preview_item_id(Some(new_item.item_id()), cx);
 638            }
 639
 640            self.add_item(new_item.clone(), true, focus_item, destination_index, cx);
 641
 642            new_item
 643        }
 644    }
 645
 646    pub fn close_current_preview_item(&mut self, cx: &mut ViewContext<Self>) -> Option<usize> {
 647        let Some(item_idx) = self.preview_item_idx() else {
 648            return None;
 649        };
 650
 651        let prev_active_item_index = self.active_item_index;
 652        self.remove_item(item_idx, false, false, cx);
 653        self.active_item_index = prev_active_item_index;
 654
 655        if item_idx < self.items.len() {
 656            Some(item_idx)
 657        } else {
 658            None
 659        }
 660    }
 661
 662    pub fn add_item(
 663        &mut self,
 664        item: Box<dyn ItemHandle>,
 665        activate_pane: bool,
 666        focus_item: bool,
 667        destination_index: Option<usize>,
 668        cx: &mut ViewContext<Self>,
 669    ) {
 670        if item.is_singleton(cx) {
 671            if let Some(&entry_id) = item.project_entry_ids(cx).get(0) {
 672                let project = self.project.read(cx);
 673                if let Some(project_path) = project.path_for_entry(entry_id, cx) {
 674                    let abs_path = project.absolute_path(&project_path, cx);
 675                    self.nav_history
 676                        .0
 677                        .lock()
 678                        .paths_by_item
 679                        .insert(item.item_id(), (project_path, abs_path));
 680                }
 681            }
 682        }
 683        // If no destination index is specified, add or move the item after the active item.
 684        let mut insertion_index = {
 685            cmp::min(
 686                if let Some(destination_index) = destination_index {
 687                    destination_index
 688                } else {
 689                    self.active_item_index + 1
 690                },
 691                self.items.len(),
 692            )
 693        };
 694
 695        // Does the item already exist?
 696        let project_entry_id = if item.is_singleton(cx) {
 697            item.project_entry_ids(cx).get(0).copied()
 698        } else {
 699            None
 700        };
 701
 702        let existing_item_index = self.items.iter().position(|existing_item| {
 703            if existing_item.item_id() == item.item_id() {
 704                true
 705            } else if existing_item.is_singleton(cx) {
 706                existing_item
 707                    .project_entry_ids(cx)
 708                    .get(0)
 709                    .map_or(false, |existing_entry_id| {
 710                        Some(existing_entry_id) == project_entry_id.as_ref()
 711                    })
 712            } else {
 713                false
 714            }
 715        });
 716
 717        if let Some(existing_item_index) = existing_item_index {
 718            // If the item already exists, move it to the desired destination and activate it
 719
 720            if existing_item_index != insertion_index {
 721                let existing_item_is_active = existing_item_index == self.active_item_index;
 722
 723                // If the caller didn't specify a destination and the added item is already
 724                // the active one, don't move it
 725                if existing_item_is_active && destination_index.is_none() {
 726                    insertion_index = existing_item_index;
 727                } else {
 728                    self.items.remove(existing_item_index);
 729                    if existing_item_index < self.active_item_index {
 730                        self.active_item_index -= 1;
 731                    }
 732                    insertion_index = insertion_index.min(self.items.len());
 733
 734                    self.items.insert(insertion_index, item.clone());
 735
 736                    if existing_item_is_active {
 737                        self.active_item_index = insertion_index;
 738                    } else if insertion_index <= self.active_item_index {
 739                        self.active_item_index += 1;
 740                    }
 741                }
 742
 743                cx.notify();
 744            }
 745
 746            self.activate_item(insertion_index, activate_pane, focus_item, cx);
 747        } else {
 748            self.items.insert(insertion_index, item.clone());
 749
 750            if insertion_index <= self.active_item_index
 751                && self.preview_item_idx() != Some(self.active_item_index)
 752            {
 753                self.active_item_index += 1;
 754            }
 755
 756            self.activate_item(insertion_index, activate_pane, focus_item, cx);
 757            cx.notify();
 758        }
 759
 760        cx.emit(Event::AddItem { item });
 761    }
 762
 763    pub fn items_len(&self) -> usize {
 764        self.items.len()
 765    }
 766
 767    pub fn items(&self) -> impl DoubleEndedIterator<Item = &Box<dyn ItemHandle>> {
 768        self.items.iter()
 769    }
 770
 771    pub fn items_of_type<T: Render>(&self) -> impl '_ + Iterator<Item = View<T>> {
 772        self.items
 773            .iter()
 774            .filter_map(|item| item.to_any().downcast().ok())
 775    }
 776
 777    pub fn active_item(&self) -> Option<Box<dyn ItemHandle>> {
 778        self.items.get(self.active_item_index).cloned()
 779    }
 780
 781    pub fn pixel_position_of_cursor(&self, cx: &AppContext) -> Option<Point<Pixels>> {
 782        self.items
 783            .get(self.active_item_index)?
 784            .pixel_position_of_cursor(cx)
 785    }
 786
 787    pub fn item_for_entry(
 788        &self,
 789        entry_id: ProjectEntryId,
 790        cx: &AppContext,
 791    ) -> Option<Box<dyn ItemHandle>> {
 792        self.items.iter().find_map(|item| {
 793            if item.is_singleton(cx) && item.project_entry_ids(cx).as_slice() == [entry_id] {
 794                Some(item.boxed_clone())
 795            } else {
 796                None
 797            }
 798        })
 799    }
 800
 801    pub fn index_for_item(&self, item: &dyn ItemHandle) -> Option<usize> {
 802        self.items
 803            .iter()
 804            .position(|i| i.item_id() == item.item_id())
 805    }
 806
 807    pub fn item_for_index(&self, ix: usize) -> Option<&dyn ItemHandle> {
 808        self.items.get(ix).map(|i| i.as_ref())
 809    }
 810
 811    pub fn toggle_zoom(&mut self, _: &ToggleZoom, cx: &mut ViewContext<Self>) {
 812        if self.zoomed {
 813            cx.emit(Event::ZoomOut);
 814        } else if !self.items.is_empty() {
 815            if !self.focus_handle.contains_focused(cx) {
 816                cx.focus_self();
 817            }
 818            cx.emit(Event::ZoomIn);
 819        }
 820    }
 821
 822    pub fn activate_item(
 823        &mut self,
 824        index: usize,
 825        activate_pane: bool,
 826        focus_item: bool,
 827        cx: &mut ViewContext<Self>,
 828    ) {
 829        use NavigationMode::{GoingBack, GoingForward};
 830
 831        if index < self.items.len() {
 832            let prev_active_item_ix = mem::replace(&mut self.active_item_index, index);
 833            if prev_active_item_ix != self.active_item_index
 834                || matches!(self.nav_history.mode(), GoingBack | GoingForward)
 835            {
 836                if let Some(prev_item) = self.items.get(prev_active_item_ix) {
 837                    prev_item.deactivated(cx);
 838                }
 839            }
 840            cx.emit(Event::ActivateItem {
 841                local: activate_pane,
 842            });
 843
 844            if let Some(newly_active_item) = self.items.get(index) {
 845                self.activation_history
 846                    .retain(|&previously_active_item_id| {
 847                        previously_active_item_id != newly_active_item.item_id()
 848                    });
 849                self.activation_history.push(newly_active_item.item_id());
 850            }
 851
 852            self.update_toolbar(cx);
 853            self.update_status_bar(cx);
 854
 855            if focus_item {
 856                self.focus_active_item(cx);
 857            }
 858
 859            self.tab_bar_scroll_handle.scroll_to_item(index);
 860            cx.notify();
 861        }
 862    }
 863
 864    pub fn activate_prev_item(&mut self, activate_pane: bool, cx: &mut ViewContext<Self>) {
 865        let mut index = self.active_item_index;
 866        if index > 0 {
 867            index -= 1;
 868        } else if !self.items.is_empty() {
 869            index = self.items.len() - 1;
 870        }
 871        self.activate_item(index, activate_pane, activate_pane, cx);
 872    }
 873
 874    pub fn activate_next_item(&mut self, activate_pane: bool, cx: &mut ViewContext<Self>) {
 875        let mut index = self.active_item_index;
 876        if index + 1 < self.items.len() {
 877            index += 1;
 878        } else {
 879            index = 0;
 880        }
 881        self.activate_item(index, activate_pane, activate_pane, cx);
 882    }
 883
 884    pub fn close_active_item(
 885        &mut self,
 886        action: &CloseActiveItem,
 887        cx: &mut ViewContext<Self>,
 888    ) -> Option<Task<Result<()>>> {
 889        if self.items.is_empty() {
 890            return None;
 891        }
 892        let active_item_id = self.items[self.active_item_index].item_id();
 893        Some(self.close_item_by_id(
 894            active_item_id,
 895            action.save_intent.unwrap_or(SaveIntent::Close),
 896            cx,
 897        ))
 898    }
 899
 900    pub fn close_item_by_id(
 901        &mut self,
 902        item_id_to_close: EntityId,
 903        save_intent: SaveIntent,
 904        cx: &mut ViewContext<Self>,
 905    ) -> Task<Result<()>> {
 906        self.close_items(cx, save_intent, move |view_id| view_id == item_id_to_close)
 907    }
 908
 909    pub fn close_inactive_items(
 910        &mut self,
 911        action: &CloseInactiveItems,
 912        cx: &mut ViewContext<Self>,
 913    ) -> Option<Task<Result<()>>> {
 914        if self.items.is_empty() {
 915            return None;
 916        }
 917
 918        let active_item_id = self.items[self.active_item_index].item_id();
 919        Some(self.close_items(
 920            cx,
 921            action.save_intent.unwrap_or(SaveIntent::Close),
 922            move |item_id| item_id != active_item_id,
 923        ))
 924    }
 925
 926    pub fn close_clean_items(
 927        &mut self,
 928        _: &CloseCleanItems,
 929        cx: &mut ViewContext<Self>,
 930    ) -> Option<Task<Result<()>>> {
 931        let item_ids: Vec<_> = self
 932            .items()
 933            .filter(|item| !item.is_dirty(cx))
 934            .map(|item| item.item_id())
 935            .collect();
 936        Some(self.close_items(cx, SaveIntent::Close, move |item_id| {
 937            item_ids.contains(&item_id)
 938        }))
 939    }
 940
 941    pub fn close_items_to_the_left(
 942        &mut self,
 943        _: &CloseItemsToTheLeft,
 944        cx: &mut ViewContext<Self>,
 945    ) -> Option<Task<Result<()>>> {
 946        if self.items.is_empty() {
 947            return None;
 948        }
 949        let active_item_id = self.items[self.active_item_index].item_id();
 950        Some(self.close_items_to_the_left_by_id(active_item_id, cx))
 951    }
 952
 953    pub fn close_items_to_the_left_by_id(
 954        &mut self,
 955        item_id: EntityId,
 956        cx: &mut ViewContext<Self>,
 957    ) -> Task<Result<()>> {
 958        let item_ids: Vec<_> = self
 959            .items()
 960            .take_while(|item| item.item_id() != item_id)
 961            .map(|item| item.item_id())
 962            .collect();
 963        self.close_items(cx, SaveIntent::Close, move |item_id| {
 964            item_ids.contains(&item_id)
 965        })
 966    }
 967
 968    pub fn close_items_to_the_right(
 969        &mut self,
 970        _: &CloseItemsToTheRight,
 971        cx: &mut ViewContext<Self>,
 972    ) -> Option<Task<Result<()>>> {
 973        if self.items.is_empty() {
 974            return None;
 975        }
 976        let active_item_id = self.items[self.active_item_index].item_id();
 977        Some(self.close_items_to_the_right_by_id(active_item_id, cx))
 978    }
 979
 980    pub fn close_items_to_the_right_by_id(
 981        &mut self,
 982        item_id: EntityId,
 983        cx: &mut ViewContext<Self>,
 984    ) -> Task<Result<()>> {
 985        let item_ids: Vec<_> = self
 986            .items()
 987            .rev()
 988            .take_while(|item| item.item_id() != item_id)
 989            .map(|item| item.item_id())
 990            .collect();
 991        self.close_items(cx, SaveIntent::Close, move |item_id| {
 992            item_ids.contains(&item_id)
 993        })
 994    }
 995
 996    pub fn close_all_items(
 997        &mut self,
 998        action: &CloseAllItems,
 999        cx: &mut ViewContext<Self>,
1000    ) -> Option<Task<Result<()>>> {
1001        if self.items.is_empty() {
1002            return None;
1003        }
1004
1005        Some(
1006            self.close_items(cx, action.save_intent.unwrap_or(SaveIntent::Close), |_| {
1007                true
1008            }),
1009        )
1010    }
1011
1012    pub(super) fn file_names_for_prompt(
1013        items: &mut dyn Iterator<Item = &Box<dyn ItemHandle>>,
1014        all_dirty_items: usize,
1015        cx: &AppContext,
1016    ) -> (String, String) {
1017        /// Quantity of item paths displayed in prompt prior to cutoff..
1018        const FILE_NAMES_CUTOFF_POINT: usize = 10;
1019        let mut file_names: Vec<_> = items
1020            .filter_map(|item| {
1021                item.project_path(cx).and_then(|project_path| {
1022                    project_path
1023                        .path
1024                        .file_name()
1025                        .and_then(|name| name.to_str().map(ToOwned::to_owned))
1026                })
1027            })
1028            .take(FILE_NAMES_CUTOFF_POINT)
1029            .collect();
1030        let should_display_followup_text =
1031            all_dirty_items > FILE_NAMES_CUTOFF_POINT || file_names.len() != all_dirty_items;
1032        if should_display_followup_text {
1033            let not_shown_files = all_dirty_items - file_names.len();
1034            if not_shown_files == 1 {
1035                file_names.push(".. 1 file not shown".into());
1036            } else {
1037                file_names.push(format!(".. {} files not shown", not_shown_files));
1038            }
1039        }
1040        (
1041            format!(
1042                "Do you want to save changes to the following {} files?",
1043                all_dirty_items
1044            ),
1045            file_names.join("\n"),
1046        )
1047    }
1048
1049    pub fn close_items(
1050        &mut self,
1051        cx: &mut ViewContext<Pane>,
1052        mut save_intent: SaveIntent,
1053        should_close: impl Fn(EntityId) -> bool,
1054    ) -> Task<Result<()>> {
1055        // Find the items to close.
1056        let mut items_to_close = Vec::new();
1057        let mut dirty_items = Vec::new();
1058        for item in &self.items {
1059            if should_close(item.item_id()) {
1060                items_to_close.push(item.boxed_clone());
1061                if item.is_dirty(cx) {
1062                    dirty_items.push(item.boxed_clone());
1063                }
1064            }
1065        }
1066
1067        // If a buffer is open both in a singleton editor and in a multibuffer, make sure
1068        // to focus the singleton buffer when prompting to save that buffer, as opposed
1069        // to focusing the multibuffer, because this gives the user a more clear idea
1070        // of what content they would be saving.
1071        items_to_close.sort_by_key(|item| !item.is_singleton(cx));
1072
1073        let workspace = self.workspace.clone();
1074        cx.spawn(|pane, mut cx| async move {
1075            if save_intent == SaveIntent::Close && dirty_items.len() > 1 {
1076                let answer = pane.update(&mut cx, |_, cx| {
1077                    let (prompt, detail) =
1078                        Self::file_names_for_prompt(&mut dirty_items.iter(), dirty_items.len(), cx);
1079                    cx.prompt(
1080                        PromptLevel::Warning,
1081                        &prompt,
1082                        Some(&detail),
1083                        &["Save all", "Discard all", "Cancel"],
1084                    )
1085                })?;
1086                match answer.await {
1087                    Ok(0) => save_intent = SaveIntent::SaveAll,
1088                    Ok(1) => save_intent = SaveIntent::Skip,
1089                    _ => {}
1090                }
1091            }
1092            let mut saved_project_items_ids = HashSet::default();
1093            for item in items_to_close.clone() {
1094                // Find the item's current index and its set of project item models. Avoid
1095                // storing these in advance, in case they have changed since this task
1096                // was started.
1097                let (item_ix, mut project_item_ids) = pane.update(&mut cx, |pane, cx| {
1098                    (pane.index_for_item(&*item), item.project_item_model_ids(cx))
1099                })?;
1100                let item_ix = if let Some(ix) = item_ix {
1101                    ix
1102                } else {
1103                    continue;
1104                };
1105
1106                // Check if this view has any project items that are not open anywhere else
1107                // in the workspace, AND that the user has not already been prompted to save.
1108                // If there are any such project entries, prompt the user to save this item.
1109                let project = workspace.update(&mut cx, |workspace, cx| {
1110                    for item in workspace.items(cx) {
1111                        if !items_to_close
1112                            .iter()
1113                            .any(|item_to_close| item_to_close.item_id() == item.item_id())
1114                        {
1115                            let other_project_item_ids = item.project_item_model_ids(cx);
1116                            project_item_ids.retain(|id| !other_project_item_ids.contains(id));
1117                        }
1118                    }
1119                    workspace.project().clone()
1120                })?;
1121                let should_save = project_item_ids
1122                    .iter()
1123                    .any(|id| saved_project_items_ids.insert(*id));
1124
1125                if should_save
1126                    && !Self::save_item(
1127                        project.clone(),
1128                        &pane,
1129                        item_ix,
1130                        &*item,
1131                        save_intent,
1132                        &mut cx,
1133                    )
1134                    .await?
1135                {
1136                    break;
1137                }
1138
1139                // Remove the item from the pane.
1140                pane.update(&mut cx, |pane, cx| {
1141                    if let Some(item_ix) = pane
1142                        .items
1143                        .iter()
1144                        .position(|i| i.item_id() == item.item_id())
1145                    {
1146                        pane.remove_item(item_ix, false, true, cx);
1147                    }
1148                })
1149                .ok();
1150            }
1151
1152            pane.update(&mut cx, |_, cx| cx.notify()).ok();
1153            Ok(())
1154        })
1155    }
1156
1157    pub fn remove_item(
1158        &mut self,
1159        item_index: usize,
1160        activate_pane: bool,
1161        close_pane_if_empty: bool,
1162        cx: &mut ViewContext<Self>,
1163    ) {
1164        self.activation_history
1165            .retain(|&history_entry| history_entry != self.items[item_index].item_id());
1166
1167        if item_index == self.active_item_index {
1168            let index_to_activate = self
1169                .activation_history
1170                .pop()
1171                .and_then(|last_activated_item| {
1172                    self.items.iter().enumerate().find_map(|(index, item)| {
1173                        (item.item_id() == last_activated_item).then_some(index)
1174                    })
1175                })
1176                // We didn't have a valid activation history entry, so fallback
1177                // to activating the item to the left
1178                .unwrap_or_else(|| item_index.min(self.items.len()).saturating_sub(1));
1179
1180            let should_activate = activate_pane || self.has_focus(cx);
1181            if self.items.len() == 1 && should_activate {
1182                self.focus_handle.focus(cx);
1183            } else {
1184                self.activate_item(index_to_activate, should_activate, should_activate, cx);
1185            }
1186        }
1187
1188        let item = self.items.remove(item_index);
1189
1190        cx.emit(Event::RemoveItem {
1191            item_id: item.item_id(),
1192        });
1193        if self.items.is_empty() {
1194            item.deactivated(cx);
1195            if close_pane_if_empty {
1196                self.update_toolbar(cx);
1197                cx.emit(Event::Remove);
1198            }
1199        }
1200
1201        if item_index < self.active_item_index {
1202            self.active_item_index -= 1;
1203        }
1204
1205        let mode = self.nav_history.mode();
1206        self.nav_history.set_mode(NavigationMode::ClosingItem);
1207        item.deactivated(cx);
1208        self.nav_history.set_mode(mode);
1209
1210        if self.is_active_preview_item(item.item_id()) {
1211            self.set_preview_item_id(None, cx);
1212        }
1213
1214        if let Some(path) = item.project_path(cx) {
1215            let abs_path = self
1216                .nav_history
1217                .0
1218                .lock()
1219                .paths_by_item
1220                .get(&item.item_id())
1221                .and_then(|(_, abs_path)| abs_path.clone());
1222
1223            self.nav_history
1224                .0
1225                .lock()
1226                .paths_by_item
1227                .insert(item.item_id(), (path, abs_path));
1228        } else {
1229            self.nav_history
1230                .0
1231                .lock()
1232                .paths_by_item
1233                .remove(&item.item_id());
1234        }
1235
1236        if self.items.is_empty() && close_pane_if_empty && self.zoomed {
1237            cx.emit(Event::ZoomOut);
1238        }
1239
1240        cx.notify();
1241    }
1242
1243    pub async fn save_item(
1244        project: Model<Project>,
1245        pane: &WeakView<Pane>,
1246        item_ix: usize,
1247        item: &dyn ItemHandle,
1248        save_intent: SaveIntent,
1249        cx: &mut AsyncWindowContext,
1250    ) -> Result<bool> {
1251        const CONFLICT_MESSAGE: &str =
1252                "This file has changed on disk since you started editing it. Do you want to overwrite it?";
1253
1254        if save_intent == SaveIntent::Skip {
1255            return Ok(true);
1256        }
1257
1258        let (mut has_conflict, mut is_dirty, mut can_save, can_save_as) = cx.update(|cx| {
1259            (
1260                item.has_conflict(cx),
1261                item.is_dirty(cx),
1262                item.can_save(cx),
1263                item.is_singleton(cx),
1264            )
1265        })?;
1266
1267        // when saving a single buffer, we ignore whether or not it's dirty.
1268        if save_intent == SaveIntent::Save || save_intent == SaveIntent::SaveWithoutFormat {
1269            is_dirty = true;
1270        }
1271
1272        if save_intent == SaveIntent::SaveAs {
1273            is_dirty = true;
1274            has_conflict = false;
1275            can_save = false;
1276        }
1277
1278        if save_intent == SaveIntent::Overwrite {
1279            has_conflict = false;
1280        }
1281
1282        let should_format = save_intent != SaveIntent::SaveWithoutFormat;
1283
1284        if has_conflict && can_save {
1285            let answer = pane.update(cx, |pane, cx| {
1286                pane.activate_item(item_ix, true, true, cx);
1287                cx.prompt(
1288                    PromptLevel::Warning,
1289                    CONFLICT_MESSAGE,
1290                    None,
1291                    &["Overwrite", "Discard", "Cancel"],
1292                )
1293            })?;
1294            match answer.await {
1295                Ok(0) => {
1296                    pane.update(cx, |_, cx| item.save(should_format, project, cx))?
1297                        .await?
1298                }
1299                Ok(1) => pane.update(cx, |_, cx| item.reload(project, cx))?.await?,
1300                _ => return Ok(false),
1301            }
1302        } else if is_dirty && (can_save || can_save_as) {
1303            if save_intent == SaveIntent::Close {
1304                let will_autosave = cx.update(|cx| {
1305                    matches!(
1306                        WorkspaceSettings::get_global(cx).autosave,
1307                        AutosaveSetting::OnFocusChange | AutosaveSetting::OnWindowChange
1308                    ) && Self::can_autosave_item(item, cx)
1309                })?;
1310                if !will_autosave {
1311                    let answer = pane.update(cx, |pane, cx| {
1312                        pane.activate_item(item_ix, true, true, cx);
1313                        let prompt = dirty_message_for(item.project_path(cx));
1314                        cx.prompt(
1315                            PromptLevel::Warning,
1316                            &prompt,
1317                            None,
1318                            &["Save", "Don't Save", "Cancel"],
1319                        )
1320                    })?;
1321                    match answer.await {
1322                        Ok(0) => {}
1323                        Ok(1) => return Ok(true), // Don't save this file
1324                        _ => return Ok(false),    // Cancel
1325                    }
1326                }
1327            }
1328
1329            if can_save {
1330                pane.update(cx, |_, cx| item.save(should_format, project, cx))?
1331                    .await?;
1332            } else if can_save_as {
1333                let abs_path = pane.update(cx, |pane, cx| {
1334                    pane.workspace
1335                        .update(cx, |workspace, cx| workspace.prompt_for_new_path(cx))
1336                })??;
1337                if let Some(abs_path) = abs_path.await.ok().flatten() {
1338                    pane.update(cx, |_, cx| item.save_as(project, abs_path, cx))?
1339                        .await?;
1340                } else {
1341                    return Ok(false);
1342                }
1343            }
1344        }
1345        Ok(true)
1346    }
1347
1348    fn can_autosave_item(item: &dyn ItemHandle, cx: &AppContext) -> bool {
1349        let is_deleted = item.project_entry_ids(cx).is_empty();
1350        item.is_dirty(cx) && !item.has_conflict(cx) && item.can_save(cx) && !is_deleted
1351    }
1352
1353    pub fn autosave_item(
1354        item: &dyn ItemHandle,
1355        project: Model<Project>,
1356        cx: &mut WindowContext,
1357    ) -> Task<Result<()>> {
1358        if Self::can_autosave_item(item, cx) {
1359            item.save(true, project, cx)
1360        } else {
1361            Task::ready(Ok(()))
1362        }
1363    }
1364
1365    pub fn focus(&mut self, cx: &mut ViewContext<Pane>) {
1366        cx.focus(&self.focus_handle);
1367    }
1368
1369    pub fn focus_active_item(&mut self, cx: &mut ViewContext<Self>) {
1370        if let Some(active_item) = self.active_item() {
1371            let focus_handle = active_item.focus_handle(cx);
1372            cx.focus(&focus_handle);
1373        }
1374    }
1375
1376    pub fn split(&mut self, direction: SplitDirection, cx: &mut ViewContext<Self>) {
1377        cx.emit(Event::Split(direction));
1378    }
1379
1380    pub fn toolbar(&self) -> &View<Toolbar> {
1381        &self.toolbar
1382    }
1383
1384    pub fn handle_deleted_project_item(
1385        &mut self,
1386        entry_id: ProjectEntryId,
1387        cx: &mut ViewContext<Pane>,
1388    ) -> Option<()> {
1389        let (item_index_to_delete, item_id) = self.items().enumerate().find_map(|(i, item)| {
1390            if item.is_singleton(cx) && item.project_entry_ids(cx).as_slice() == [entry_id] {
1391                Some((i, item.item_id()))
1392            } else {
1393                None
1394            }
1395        })?;
1396
1397        self.remove_item(item_index_to_delete, false, true, cx);
1398        self.nav_history.remove_item(item_id);
1399
1400        Some(())
1401    }
1402
1403    fn update_toolbar(&mut self, cx: &mut ViewContext<Self>) {
1404        let active_item = self
1405            .items
1406            .get(self.active_item_index)
1407            .map(|item| item.as_ref());
1408        self.toolbar.update(cx, |toolbar, cx| {
1409            toolbar.set_active_item(active_item, cx);
1410        });
1411    }
1412
1413    fn update_status_bar(&mut self, cx: &mut ViewContext<Self>) {
1414        let workspace = self.workspace.clone();
1415        let pane = cx.view().clone();
1416
1417        cx.window_context().defer(move |cx| {
1418            let Ok(status_bar) = workspace.update(cx, |workspace, _| workspace.status_bar.clone())
1419            else {
1420                return;
1421            };
1422
1423            status_bar.update(cx, move |status_bar, cx| {
1424                status_bar.set_active_pane(&pane, cx);
1425            });
1426        });
1427    }
1428
1429    fn render_tab(
1430        &self,
1431        ix: usize,
1432        item: &Box<dyn ItemHandle>,
1433        detail: usize,
1434        cx: &mut ViewContext<'_, Pane>,
1435    ) -> impl IntoElement {
1436        let is_active = ix == self.active_item_index;
1437        let is_preview = self
1438            .preview_item_id
1439            .map(|id| id == item.item_id())
1440            .unwrap_or(false);
1441
1442        let label = item.tab_content(
1443            TabContentParams {
1444                detail: Some(detail),
1445                selected: is_active,
1446                preview: is_preview,
1447            },
1448            cx,
1449        );
1450        let close_side = &ItemSettings::get_global(cx).close_position;
1451        let indicator = render_item_indicator(item.boxed_clone(), cx);
1452        let item_id = item.item_id();
1453        let is_first_item = ix == 0;
1454        let is_last_item = ix == self.items.len() - 1;
1455        let position_relative_to_active_item = ix.cmp(&self.active_item_index);
1456
1457        let tab = Tab::new(ix)
1458            .position(if is_first_item {
1459                TabPosition::First
1460            } else if is_last_item {
1461                TabPosition::Last
1462            } else {
1463                TabPosition::Middle(position_relative_to_active_item)
1464            })
1465            .close_side(match close_side {
1466                ClosePosition::Left => ui::TabCloseSide::Start,
1467                ClosePosition::Right => ui::TabCloseSide::End,
1468            })
1469            .selected(is_active)
1470            .on_click(
1471                cx.listener(move |pane: &mut Self, _, cx| pane.activate_item(ix, true, true, cx)),
1472            )
1473            // TODO: This should be a click listener with the middle mouse button instead of a mouse down listener.
1474            .on_mouse_down(
1475                MouseButton::Middle,
1476                cx.listener(move |pane, _event, cx| {
1477                    pane.close_item_by_id(item_id, SaveIntent::Close, cx)
1478                        .detach_and_log_err(cx);
1479                }),
1480            )
1481            .on_mouse_down(
1482                MouseButton::Left,
1483                cx.listener(move |pane, event: &MouseDownEvent, cx| {
1484                    if let Some(id) = pane.preview_item_id {
1485                        if id == item_id && event.click_count > 1 {
1486                            pane.set_preview_item_id(None, cx);
1487                        }
1488                    }
1489                }),
1490            )
1491            .on_drag(
1492                DraggedTab {
1493                    item: item.boxed_clone(),
1494                    pane: cx.view().clone(),
1495                    detail,
1496                    is_active,
1497                    ix,
1498                },
1499                |tab, cx| cx.new_view(|_| tab.clone()),
1500            )
1501            .drag_over::<DraggedTab>(|tab, _, cx| {
1502                tab.bg(cx.theme().colors().drop_target_background)
1503            })
1504            .drag_over::<ProjectEntryId>(|tab, _, cx| {
1505                tab.bg(cx.theme().colors().drop_target_background)
1506            })
1507            .when_some(self.can_drop_predicate.clone(), |this, p| {
1508                this.can_drop(move |a, cx| p(a, cx))
1509            })
1510            .on_drop(cx.listener(move |this, dragged_tab: &DraggedTab, cx| {
1511                this.drag_split_direction = None;
1512                this.handle_tab_drop(dragged_tab, ix, cx)
1513            }))
1514            .on_drop(cx.listener(move |this, entry_id: &ProjectEntryId, cx| {
1515                this.drag_split_direction = None;
1516                this.handle_project_entry_drop(entry_id, cx)
1517            }))
1518            .on_drop(cx.listener(move |this, paths, cx| {
1519                this.drag_split_direction = None;
1520                this.handle_external_paths_drop(paths, cx)
1521            }))
1522            .when_some(item.tab_tooltip_text(cx), |tab, text| {
1523                tab.tooltip(move |cx| Tooltip::text(text.clone(), cx))
1524            })
1525            .start_slot::<Indicator>(indicator)
1526            .end_slot(
1527                IconButton::new("close tab", IconName::Close)
1528                    .shape(IconButtonShape::Square)
1529                    .icon_color(Color::Muted)
1530                    .size(ButtonSize::None)
1531                    .icon_size(IconSize::XSmall)
1532                    .on_click(cx.listener(move |pane, _, cx| {
1533                        pane.close_item_by_id(item_id, SaveIntent::Close, cx)
1534                            .detach_and_log_err(cx);
1535                    })),
1536            )
1537            .child(label);
1538
1539        let single_entry_to_resolve = {
1540            let item_entries = self.items[ix].project_entry_ids(cx);
1541            if item_entries.len() == 1 {
1542                Some(item_entries[0])
1543            } else {
1544                None
1545            }
1546        };
1547
1548        let pane = cx.view().downgrade();
1549        right_click_menu(ix).trigger(tab).menu(move |cx| {
1550            let pane = pane.clone();
1551            ContextMenu::build(cx, move |mut menu, cx| {
1552                if let Some(pane) = pane.upgrade() {
1553                    menu = menu
1554                        .entry(
1555                            "Close",
1556                            Some(Box::new(CloseActiveItem { save_intent: None })),
1557                            cx.handler_for(&pane, move |pane, cx| {
1558                                pane.close_item_by_id(item_id, SaveIntent::Close, cx)
1559                                    .detach_and_log_err(cx);
1560                            }),
1561                        )
1562                        .entry(
1563                            "Close Others",
1564                            Some(Box::new(CloseInactiveItems { save_intent: None })),
1565                            cx.handler_for(&pane, move |pane, cx| {
1566                                pane.close_items(cx, SaveIntent::Close, |id| id != item_id)
1567                                    .detach_and_log_err(cx);
1568                            }),
1569                        )
1570                        .separator()
1571                        .entry(
1572                            "Close Left",
1573                            Some(Box::new(CloseItemsToTheLeft)),
1574                            cx.handler_for(&pane, move |pane, cx| {
1575                                pane.close_items_to_the_left_by_id(item_id, cx)
1576                                    .detach_and_log_err(cx);
1577                            }),
1578                        )
1579                        .entry(
1580                            "Close Right",
1581                            Some(Box::new(CloseItemsToTheRight)),
1582                            cx.handler_for(&pane, move |pane, cx| {
1583                                pane.close_items_to_the_right_by_id(item_id, cx)
1584                                    .detach_and_log_err(cx);
1585                            }),
1586                        )
1587                        .separator()
1588                        .entry(
1589                            "Close Clean",
1590                            Some(Box::new(CloseCleanItems)),
1591                            cx.handler_for(&pane, move |pane, cx| {
1592                                if let Some(task) = pane.close_clean_items(&CloseCleanItems, cx) {
1593                                    task.detach_and_log_err(cx)
1594                                }
1595                            }),
1596                        )
1597                        .entry(
1598                            "Close All",
1599                            Some(Box::new(CloseAllItems { save_intent: None })),
1600                            cx.handler_for(&pane, |pane, cx| {
1601                                if let Some(task) =
1602                                    pane.close_all_items(&CloseAllItems { save_intent: None }, cx)
1603                                {
1604                                    task.detach_and_log_err(cx)
1605                                }
1606                            }),
1607                        );
1608
1609                    if let Some(entry) = single_entry_to_resolve {
1610                        let parent_abs_path = pane
1611                            .update(cx, |pane, cx| {
1612                                pane.workspace.update(cx, |workspace, cx| {
1613                                    let project = workspace.project().read(cx);
1614                                    project.worktree_for_entry(entry, cx).and_then(|worktree| {
1615                                        let worktree = worktree.read(cx);
1616                                        let entry = worktree.entry_for_id(entry)?;
1617                                        let abs_path = worktree.absolutize(&entry.path).ok()?;
1618                                        let parent = if entry.is_symlink {
1619                                            abs_path.canonicalize().ok()?
1620                                        } else {
1621                                            abs_path
1622                                        }
1623                                        .parent()?
1624                                        .to_path_buf();
1625                                        Some(parent)
1626                                    })
1627                                })
1628                            })
1629                            .ok()
1630                            .flatten();
1631
1632                        let entry_id = entry.to_proto();
1633                        menu = menu
1634                            .separator()
1635                            .entry(
1636                                "Reveal In Project Panel",
1637                                Some(Box::new(RevealInProjectPanel {
1638                                    entry_id: Some(entry_id),
1639                                })),
1640                                cx.handler_for(&pane, move |pane, cx| {
1641                                    pane.project.update(cx, |_, cx| {
1642                                        cx.emit(project::Event::RevealInProjectPanel(
1643                                            ProjectEntryId::from_proto(entry_id),
1644                                        ))
1645                                    });
1646                                }),
1647                            )
1648                            .when_some(parent_abs_path, |menu, abs_path| {
1649                                menu.entry(
1650                                    "Open in Terminal",
1651                                    Some(Box::new(OpenInTerminal)),
1652                                    cx.handler_for(&pane, move |_, cx| {
1653                                        cx.dispatch_action(
1654                                            OpenTerminal {
1655                                                working_directory: abs_path.clone(),
1656                                            }
1657                                            .boxed_clone(),
1658                                        );
1659                                    }),
1660                                )
1661                            });
1662                    }
1663                }
1664
1665                menu
1666            })
1667        })
1668    }
1669
1670    fn render_tab_bar(&mut self, cx: &mut ViewContext<'_, Pane>) -> impl IntoElement {
1671        TabBar::new("tab_bar")
1672            .track_scroll(self.tab_bar_scroll_handle.clone())
1673            .when(
1674                self.display_nav_history_buttons.unwrap_or_default(),
1675                |tab_bar| {
1676                    tab_bar.start_child(
1677                        h_flex()
1678                            .gap_2()
1679                            .child(
1680                                IconButton::new("navigate_backward", IconName::ArrowLeft)
1681                                    .icon_size(IconSize::Small)
1682                                    .on_click({
1683                                        let view = cx.view().clone();
1684                                        move |_, cx| view.update(cx, Self::navigate_backward)
1685                                    })
1686                                    .disabled(!self.can_navigate_backward())
1687                                    .tooltip(|cx| Tooltip::for_action("Go Back", &GoBack, cx)),
1688                            )
1689                            .child(
1690                                IconButton::new("navigate_forward", IconName::ArrowRight)
1691                                    .icon_size(IconSize::Small)
1692                                    .on_click({
1693                                        let view = cx.view().clone();
1694                                        move |_, cx| view.update(cx, Self::navigate_forward)
1695                                    })
1696                                    .disabled(!self.can_navigate_forward())
1697                                    .tooltip(|cx| {
1698                                        Tooltip::for_action("Go Forward", &GoForward, cx)
1699                                    }),
1700                            ),
1701                    )
1702                },
1703            )
1704            .when(self.has_focus(cx), |tab_bar| {
1705                tab_bar.end_child({
1706                    let render_tab_buttons = self.render_tab_bar_buttons.clone();
1707                    render_tab_buttons(self, cx)
1708                })
1709            })
1710            .children(
1711                self.items
1712                    .iter()
1713                    .enumerate()
1714                    .zip(tab_details(&self.items, cx))
1715                    .map(|((ix, item), detail)| self.render_tab(ix, item, detail, cx)),
1716            )
1717            .child(
1718                div()
1719                    .id("tab_bar_drop_target")
1720                    .min_w_6()
1721                    // HACK: This empty child is currently necessary to force the drop target to appear
1722                    // despite us setting a min width above.
1723                    .child("")
1724                    .h_full()
1725                    .flex_grow()
1726                    .drag_over::<DraggedTab>(|bar, _, cx| {
1727                        bar.bg(cx.theme().colors().drop_target_background)
1728                    })
1729                    .drag_over::<ProjectEntryId>(|bar, _, cx| {
1730                        bar.bg(cx.theme().colors().drop_target_background)
1731                    })
1732                    .on_drop(cx.listener(move |this, dragged_tab: &DraggedTab, cx| {
1733                        this.drag_split_direction = None;
1734                        this.handle_tab_drop(dragged_tab, this.items.len(), cx)
1735                    }))
1736                    .on_drop(cx.listener(move |this, entry_id: &ProjectEntryId, cx| {
1737                        this.drag_split_direction = None;
1738                        this.handle_project_entry_drop(entry_id, cx)
1739                    }))
1740                    .on_drop(cx.listener(move |this, paths, cx| {
1741                        this.drag_split_direction = None;
1742                        this.handle_external_paths_drop(paths, cx)
1743                    }))
1744                    .on_click(cx.listener(move |this, event: &ClickEvent, cx| {
1745                        if event.up.click_count == 2 {
1746                            cx.dispatch_action(this.double_click_dispatch_action.boxed_clone())
1747                        }
1748                    })),
1749            )
1750    }
1751
1752    pub fn render_menu_overlay(menu: &View<ContextMenu>) -> Div {
1753        div().absolute().bottom_0().right_0().size_0().child(
1754            deferred(
1755                anchored()
1756                    .anchor(AnchorCorner::TopRight)
1757                    .child(menu.clone()),
1758            )
1759            .with_priority(1),
1760        )
1761    }
1762
1763    pub fn set_zoomed(&mut self, zoomed: bool, cx: &mut ViewContext<Self>) {
1764        self.zoomed = zoomed;
1765        cx.notify();
1766    }
1767
1768    pub fn is_zoomed(&self) -> bool {
1769        self.zoomed
1770    }
1771
1772    fn handle_drag_move<T>(&mut self, event: &DragMoveEvent<T>, cx: &mut ViewContext<Self>) {
1773        if !self.can_split {
1774            return;
1775        }
1776
1777        let rect = event.bounds.size;
1778
1779        let size = event.bounds.size.width.min(event.bounds.size.height)
1780            * WorkspaceSettings::get_global(cx).drop_target_size;
1781
1782        let relative_cursor = Point::new(
1783            event.event.position.x - event.bounds.left(),
1784            event.event.position.y - event.bounds.top(),
1785        );
1786
1787        let direction = if relative_cursor.x < size
1788            || relative_cursor.x > rect.width - size
1789            || relative_cursor.y < size
1790            || relative_cursor.y > rect.height - size
1791        {
1792            [
1793                SplitDirection::Up,
1794                SplitDirection::Right,
1795                SplitDirection::Down,
1796                SplitDirection::Left,
1797            ]
1798            .iter()
1799            .min_by_key(|side| match side {
1800                SplitDirection::Up => relative_cursor.y,
1801                SplitDirection::Right => rect.width - relative_cursor.x,
1802                SplitDirection::Down => rect.height - relative_cursor.y,
1803                SplitDirection::Left => relative_cursor.x,
1804            })
1805            .cloned()
1806        } else {
1807            None
1808        };
1809
1810        if direction != self.drag_split_direction {
1811            self.drag_split_direction = direction;
1812        }
1813    }
1814
1815    fn handle_tab_drop(
1816        &mut self,
1817        dragged_tab: &DraggedTab,
1818        ix: usize,
1819        cx: &mut ViewContext<'_, Self>,
1820    ) {
1821        if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
1822            if let ControlFlow::Break(()) = custom_drop_handle(self, dragged_tab, cx) {
1823                return;
1824            }
1825        }
1826        let mut to_pane = cx.view().clone();
1827        let split_direction = self.drag_split_direction;
1828        let item_id = dragged_tab.item.item_id();
1829        if let Some(preview_item_id) = self.preview_item_id {
1830            if item_id == preview_item_id {
1831                self.set_preview_item_id(None, cx);
1832            }
1833        }
1834
1835        let from_pane = dragged_tab.pane.clone();
1836        self.workspace
1837            .update(cx, |_, cx| {
1838                cx.defer(move |workspace, cx| {
1839                    if let Some(split_direction) = split_direction {
1840                        to_pane = workspace.split_pane(to_pane, split_direction, cx);
1841                    }
1842                    workspace.move_item(from_pane, to_pane, item_id, ix, cx);
1843                });
1844            })
1845            .log_err();
1846    }
1847
1848    fn handle_project_entry_drop(
1849        &mut self,
1850        project_entry_id: &ProjectEntryId,
1851        cx: &mut ViewContext<'_, Self>,
1852    ) {
1853        if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
1854            if let ControlFlow::Break(()) = custom_drop_handle(self, project_entry_id, cx) {
1855                return;
1856            }
1857        }
1858        let mut to_pane = cx.view().clone();
1859        let split_direction = self.drag_split_direction;
1860        let project_entry_id = *project_entry_id;
1861        self.workspace
1862            .update(cx, |_, cx| {
1863                cx.defer(move |workspace, cx| {
1864                    if let Some(path) = workspace
1865                        .project()
1866                        .read(cx)
1867                        .path_for_entry(project_entry_id, cx)
1868                    {
1869                        if let Some(split_direction) = split_direction {
1870                            to_pane = workspace.split_pane(to_pane, split_direction, cx);
1871                        }
1872                        workspace
1873                            .open_path(path, Some(to_pane.downgrade()), true, cx)
1874                            .detach_and_log_err(cx);
1875                    }
1876                });
1877            })
1878            .log_err();
1879    }
1880
1881    fn handle_external_paths_drop(
1882        &mut self,
1883        paths: &ExternalPaths,
1884        cx: &mut ViewContext<'_, Self>,
1885    ) {
1886        if let Some(custom_drop_handle) = self.custom_drop_handle.clone() {
1887            if let ControlFlow::Break(()) = custom_drop_handle(self, paths, cx) {
1888                return;
1889            }
1890        }
1891        let mut to_pane = cx.view().clone();
1892        let mut split_direction = self.drag_split_direction;
1893        let paths = paths.paths().to_vec();
1894        let is_remote = self
1895            .workspace
1896            .update(cx, |workspace, cx| {
1897                if workspace.project().read(cx).is_remote() {
1898                    workspace.show_error(
1899                        &anyhow::anyhow!("Cannot drop files on a remote project"),
1900                        cx,
1901                    );
1902                    true
1903                } else {
1904                    false
1905                }
1906            })
1907            .unwrap_or(true);
1908        if is_remote {
1909            return;
1910        }
1911
1912        self.workspace
1913            .update(cx, |workspace, cx| {
1914                let fs = Arc::clone(workspace.project().read(cx).fs());
1915                cx.spawn(|workspace, mut cx| async move {
1916                    let mut is_file_checks = FuturesUnordered::new();
1917                    for path in &paths {
1918                        is_file_checks.push(fs.is_file(path))
1919                    }
1920                    let mut has_files_to_open = false;
1921                    while let Some(is_file) = is_file_checks.next().await {
1922                        if is_file {
1923                            has_files_to_open = true;
1924                            break;
1925                        }
1926                    }
1927                    drop(is_file_checks);
1928                    if !has_files_to_open {
1929                        split_direction = None;
1930                    }
1931
1932                    if let Some(open_task) = workspace
1933                        .update(&mut cx, |workspace, cx| {
1934                            if let Some(split_direction) = split_direction {
1935                                to_pane = workspace.split_pane(to_pane, split_direction, cx);
1936                            }
1937                            workspace.open_paths(
1938                                paths,
1939                                OpenVisible::OnlyDirectories,
1940                                Some(to_pane.downgrade()),
1941                                cx,
1942                            )
1943                        })
1944                        .ok()
1945                    {
1946                        let _opened_items: Vec<_> = open_task.await;
1947                    }
1948                })
1949                .detach();
1950            })
1951            .log_err();
1952    }
1953
1954    pub fn display_nav_history_buttons(&mut self, display: Option<bool>) {
1955        self.display_nav_history_buttons = display;
1956    }
1957}
1958
1959impl FocusableView for Pane {
1960    fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {
1961        self.focus_handle.clone()
1962    }
1963}
1964
1965impl Render for Pane {
1966    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1967        let mut key_context = KeyContext::new_with_defaults();
1968        key_context.add("Pane");
1969        if self.active_item().is_none() {
1970            key_context.add("EmptyPane");
1971        }
1972
1973        v_flex()
1974            .key_context(key_context)
1975            .track_focus(&self.focus_handle)
1976            .size_full()
1977            .flex_none()
1978            .overflow_hidden()
1979            .on_action(cx.listener(|pane, _: &SplitLeft, cx| pane.split(SplitDirection::Left, cx)))
1980            .on_action(cx.listener(|pane, _: &SplitUp, cx| pane.split(SplitDirection::Up, cx)))
1981            .on_action(
1982                cx.listener(|pane, _: &SplitRight, cx| pane.split(SplitDirection::Right, cx)),
1983            )
1984            .on_action(cx.listener(|pane, _: &SplitDown, cx| pane.split(SplitDirection::Down, cx)))
1985            .on_action(cx.listener(|pane, _: &GoBack, cx| pane.navigate_backward(cx)))
1986            .on_action(cx.listener(|pane, _: &GoForward, cx| pane.navigate_forward(cx)))
1987            .on_action(cx.listener(Pane::toggle_zoom))
1988            .on_action(cx.listener(|pane: &mut Pane, action: &ActivateItem, cx| {
1989                pane.activate_item(action.0, true, true, cx);
1990            }))
1991            .on_action(cx.listener(|pane: &mut Pane, _: &ActivateLastItem, cx| {
1992                pane.activate_item(pane.items.len() - 1, true, true, cx);
1993            }))
1994            .on_action(cx.listener(|pane: &mut Pane, _: &ActivatePrevItem, cx| {
1995                pane.activate_prev_item(true, cx);
1996            }))
1997            .on_action(cx.listener(|pane: &mut Pane, _: &ActivateNextItem, cx| {
1998                pane.activate_next_item(true, cx);
1999            }))
2000            .when(PreviewTabsSettings::get_global(cx).enabled, |this| {
2001                this.on_action(cx.listener(|pane: &mut Pane, _: &TogglePreviewTab, cx| {
2002                    if let Some(active_item_id) = pane.active_item().map(|i| i.item_id()) {
2003                        if pane.is_active_preview_item(active_item_id) {
2004                            pane.set_preview_item_id(None, cx);
2005                        } else {
2006                            pane.set_preview_item_id(Some(active_item_id), cx);
2007                        }
2008                    }
2009                }))
2010            })
2011            .on_action(
2012                cx.listener(|pane: &mut Self, action: &CloseActiveItem, cx| {
2013                    if let Some(task) = pane.close_active_item(action, cx) {
2014                        task.detach_and_log_err(cx)
2015                    }
2016                }),
2017            )
2018            .on_action(
2019                cx.listener(|pane: &mut Self, action: &CloseInactiveItems, cx| {
2020                    if let Some(task) = pane.close_inactive_items(action, cx) {
2021                        task.detach_and_log_err(cx)
2022                    }
2023                }),
2024            )
2025            .on_action(
2026                cx.listener(|pane: &mut Self, action: &CloseCleanItems, cx| {
2027                    if let Some(task) = pane.close_clean_items(action, cx) {
2028                        task.detach_and_log_err(cx)
2029                    }
2030                }),
2031            )
2032            .on_action(
2033                cx.listener(|pane: &mut Self, action: &CloseItemsToTheLeft, cx| {
2034                    if let Some(task) = pane.close_items_to_the_left(action, cx) {
2035                        task.detach_and_log_err(cx)
2036                    }
2037                }),
2038            )
2039            .on_action(
2040                cx.listener(|pane: &mut Self, action: &CloseItemsToTheRight, cx| {
2041                    if let Some(task) = pane.close_items_to_the_right(action, cx) {
2042                        task.detach_and_log_err(cx)
2043                    }
2044                }),
2045            )
2046            .on_action(cx.listener(|pane: &mut Self, action: &CloseAllItems, cx| {
2047                if let Some(task) = pane.close_all_items(action, cx) {
2048                    task.detach_and_log_err(cx)
2049                }
2050            }))
2051            .on_action(
2052                cx.listener(|pane: &mut Self, action: &CloseActiveItem, cx| {
2053                    if let Some(task) = pane.close_active_item(action, cx) {
2054                        task.detach_and_log_err(cx)
2055                    }
2056                }),
2057            )
2058            .on_action(
2059                cx.listener(|pane: &mut Self, action: &RevealInProjectPanel, cx| {
2060                    let entry_id = action
2061                        .entry_id
2062                        .map(ProjectEntryId::from_proto)
2063                        .or_else(|| pane.active_item()?.project_entry_ids(cx).first().copied());
2064                    if let Some(entry_id) = entry_id {
2065                        pane.project.update(cx, |_, cx| {
2066                            cx.emit(project::Event::RevealInProjectPanel(entry_id))
2067                        });
2068                    }
2069                }),
2070            )
2071            .when(self.active_item().is_some(), |pane| {
2072                pane.child(self.render_tab_bar(cx))
2073            })
2074            .child({
2075                let has_worktrees = self.project.read(cx).worktrees().next().is_some();
2076                // main content
2077                div()
2078                    .flex_1()
2079                    .relative()
2080                    .group("")
2081                    .on_drag_move::<DraggedTab>(cx.listener(Self::handle_drag_move))
2082                    .on_drag_move::<ProjectEntryId>(cx.listener(Self::handle_drag_move))
2083                    .on_drag_move::<ExternalPaths>(cx.listener(Self::handle_drag_move))
2084                    .map(|div| {
2085                        if let Some(item) = self.active_item() {
2086                            div.v_flex()
2087                                .child(self.toolbar.clone())
2088                                .child(item.to_any())
2089                        } else {
2090                            let placeholder = div.h_flex().size_full().justify_center();
2091                            if has_worktrees {
2092                                placeholder
2093                            } else {
2094                                placeholder.child(
2095                                    Label::new("Open a file or project to get started.")
2096                                        .color(Color::Muted),
2097                                )
2098                            }
2099                        }
2100                    })
2101                    .child(
2102                        // drag target
2103                        div()
2104                            .invisible()
2105                            .absolute()
2106                            .bg(cx.theme().colors().drop_target_background)
2107                            .group_drag_over::<DraggedTab>("", |style| style.visible())
2108                            .group_drag_over::<ProjectEntryId>("", |style| style.visible())
2109                            .group_drag_over::<ExternalPaths>("", |style| style.visible())
2110                            .when_some(self.can_drop_predicate.clone(), |this, p| {
2111                                this.can_drop(move |a, cx| p(a, cx))
2112                            })
2113                            .on_drop(cx.listener(move |this, dragged_tab, cx| {
2114                                this.handle_tab_drop(dragged_tab, this.active_item_index(), cx)
2115                            }))
2116                            .on_drop(cx.listener(move |this, entry_id, cx| {
2117                                this.handle_project_entry_drop(entry_id, cx)
2118                            }))
2119                            .on_drop(cx.listener(move |this, paths, cx| {
2120                                this.handle_external_paths_drop(paths, cx)
2121                            }))
2122                            .map(|div| {
2123                                let size = DefiniteLength::Fraction(0.5);
2124                                match self.drag_split_direction {
2125                                    None => div.top_0().right_0().bottom_0().left_0(),
2126                                    Some(SplitDirection::Up) => {
2127                                        div.top_0().left_0().right_0().h(size)
2128                                    }
2129                                    Some(SplitDirection::Down) => {
2130                                        div.left_0().bottom_0().right_0().h(size)
2131                                    }
2132                                    Some(SplitDirection::Left) => {
2133                                        div.top_0().left_0().bottom_0().w(size)
2134                                    }
2135                                    Some(SplitDirection::Right) => {
2136                                        div.top_0().bottom_0().right_0().w(size)
2137                                    }
2138                                }
2139                            }),
2140                    )
2141            })
2142            .on_mouse_down(
2143                MouseButton::Navigate(NavigationDirection::Back),
2144                cx.listener(|pane, _, cx| {
2145                    if let Some(workspace) = pane.workspace.upgrade() {
2146                        let pane = cx.view().downgrade();
2147                        cx.window_context().defer(move |cx| {
2148                            workspace.update(cx, |workspace, cx| {
2149                                workspace.go_back(pane, cx).detach_and_log_err(cx)
2150                            })
2151                        })
2152                    }
2153                }),
2154            )
2155            .on_mouse_down(
2156                MouseButton::Navigate(NavigationDirection::Forward),
2157                cx.listener(|pane, _, cx| {
2158                    if let Some(workspace) = pane.workspace.upgrade() {
2159                        let pane = cx.view().downgrade();
2160                        cx.window_context().defer(move |cx| {
2161                            workspace.update(cx, |workspace, cx| {
2162                                workspace.go_forward(pane, cx).detach_and_log_err(cx)
2163                            })
2164                        })
2165                    }
2166                }),
2167            )
2168    }
2169}
2170
2171impl ItemNavHistory {
2172    pub fn push<D: 'static + Send + Any>(&mut self, data: Option<D>, cx: &mut WindowContext) {
2173        self.history
2174            .push(data, self.item.clone(), self.is_preview, cx);
2175    }
2176
2177    pub fn pop_backward(&mut self, cx: &mut WindowContext) -> Option<NavigationEntry> {
2178        self.history.pop(NavigationMode::GoingBack, cx)
2179    }
2180
2181    pub fn pop_forward(&mut self, cx: &mut WindowContext) -> Option<NavigationEntry> {
2182        self.history.pop(NavigationMode::GoingForward, cx)
2183    }
2184}
2185
2186impl NavHistory {
2187    pub fn for_each_entry(
2188        &self,
2189        cx: &AppContext,
2190        mut f: impl FnMut(&NavigationEntry, (ProjectPath, Option<PathBuf>)),
2191    ) {
2192        let borrowed_history = self.0.lock();
2193        borrowed_history
2194            .forward_stack
2195            .iter()
2196            .chain(borrowed_history.backward_stack.iter())
2197            .chain(borrowed_history.closed_stack.iter())
2198            .for_each(|entry| {
2199                if let Some(project_and_abs_path) =
2200                    borrowed_history.paths_by_item.get(&entry.item.id())
2201                {
2202                    f(entry, project_and_abs_path.clone());
2203                } else if let Some(item) = entry.item.upgrade() {
2204                    if let Some(path) = item.project_path(cx) {
2205                        f(entry, (path, None));
2206                    }
2207                }
2208            })
2209    }
2210
2211    pub fn set_mode(&mut self, mode: NavigationMode) {
2212        self.0.lock().mode = mode;
2213    }
2214
2215    pub fn mode(&self) -> NavigationMode {
2216        self.0.lock().mode
2217    }
2218
2219    pub fn disable(&mut self) {
2220        self.0.lock().mode = NavigationMode::Disabled;
2221    }
2222
2223    pub fn enable(&mut self) {
2224        self.0.lock().mode = NavigationMode::Normal;
2225    }
2226
2227    pub fn pop(&mut self, mode: NavigationMode, cx: &mut WindowContext) -> Option<NavigationEntry> {
2228        let mut state = self.0.lock();
2229        let entry = match mode {
2230            NavigationMode::Normal | NavigationMode::Disabled | NavigationMode::ClosingItem => {
2231                return None
2232            }
2233            NavigationMode::GoingBack => &mut state.backward_stack,
2234            NavigationMode::GoingForward => &mut state.forward_stack,
2235            NavigationMode::ReopeningClosedItem => &mut state.closed_stack,
2236        }
2237        .pop_back();
2238        if entry.is_some() {
2239            state.did_update(cx);
2240        }
2241        entry
2242    }
2243
2244    pub fn push<D: 'static + Send + Any>(
2245        &mut self,
2246        data: Option<D>,
2247        item: Arc<dyn WeakItemHandle>,
2248        is_preview: bool,
2249        cx: &mut WindowContext,
2250    ) {
2251        let state = &mut *self.0.lock();
2252        match state.mode {
2253            NavigationMode::Disabled => {}
2254            NavigationMode::Normal | NavigationMode::ReopeningClosedItem => {
2255                if state.backward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
2256                    state.backward_stack.pop_front();
2257                }
2258                state.backward_stack.push_back(NavigationEntry {
2259                    item,
2260                    data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
2261                    timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
2262                    is_preview,
2263                });
2264                state.forward_stack.clear();
2265            }
2266            NavigationMode::GoingBack => {
2267                if state.forward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
2268                    state.forward_stack.pop_front();
2269                }
2270                state.forward_stack.push_back(NavigationEntry {
2271                    item,
2272                    data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
2273                    timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
2274                    is_preview,
2275                });
2276            }
2277            NavigationMode::GoingForward => {
2278                if state.backward_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
2279                    state.backward_stack.pop_front();
2280                }
2281                state.backward_stack.push_back(NavigationEntry {
2282                    item,
2283                    data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
2284                    timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
2285                    is_preview,
2286                });
2287            }
2288            NavigationMode::ClosingItem => {
2289                if state.closed_stack.len() >= MAX_NAVIGATION_HISTORY_LEN {
2290                    state.closed_stack.pop_front();
2291                }
2292                state.closed_stack.push_back(NavigationEntry {
2293                    item,
2294                    data: data.map(|data| Box::new(data) as Box<dyn Any + Send>),
2295                    timestamp: state.next_timestamp.fetch_add(1, Ordering::SeqCst),
2296                    is_preview,
2297                });
2298            }
2299        }
2300        state.did_update(cx);
2301    }
2302
2303    pub fn remove_item(&mut self, item_id: EntityId) {
2304        let mut state = self.0.lock();
2305        state.paths_by_item.remove(&item_id);
2306        state
2307            .backward_stack
2308            .retain(|entry| entry.item.id() != item_id);
2309        state
2310            .forward_stack
2311            .retain(|entry| entry.item.id() != item_id);
2312        state
2313            .closed_stack
2314            .retain(|entry| entry.item.id() != item_id);
2315    }
2316
2317    pub fn path_for_item(&self, item_id: EntityId) -> Option<(ProjectPath, Option<PathBuf>)> {
2318        self.0.lock().paths_by_item.get(&item_id).cloned()
2319    }
2320}
2321
2322impl NavHistoryState {
2323    pub fn did_update(&self, cx: &mut WindowContext) {
2324        if let Some(pane) = self.pane.upgrade() {
2325            cx.defer(move |cx| {
2326                pane.update(cx, |pane, cx| pane.history_updated(cx));
2327            });
2328        }
2329    }
2330}
2331
2332fn dirty_message_for(buffer_path: Option<ProjectPath>) -> String {
2333    let path = buffer_path
2334        .as_ref()
2335        .and_then(|p| {
2336            p.path
2337                .to_str()
2338                .and_then(|s| if s == "" { None } else { Some(s) })
2339        })
2340        .unwrap_or("This buffer");
2341    let path = truncate_and_remove_front(path, 80);
2342    format!("{path} contains unsaved edits. Do you want to save it?")
2343}
2344
2345pub fn tab_details(items: &Vec<Box<dyn ItemHandle>>, cx: &AppContext) -> Vec<usize> {
2346    let mut tab_details = items.iter().map(|_| 0).collect::<Vec<_>>();
2347    let mut tab_descriptions = HashMap::default();
2348    let mut done = false;
2349    while !done {
2350        done = true;
2351
2352        // Store item indices by their tab description.
2353        for (ix, (item, detail)) in items.iter().zip(&tab_details).enumerate() {
2354            if let Some(description) = item.tab_description(*detail, cx) {
2355                if *detail == 0
2356                    || Some(&description) != item.tab_description(detail - 1, cx).as_ref()
2357                {
2358                    tab_descriptions
2359                        .entry(description)
2360                        .or_insert(Vec::new())
2361                        .push(ix);
2362                }
2363            }
2364        }
2365
2366        // If two or more items have the same tab description, increase their level
2367        // of detail and try again.
2368        for (_, item_ixs) in tab_descriptions.drain() {
2369            if item_ixs.len() > 1 {
2370                done = false;
2371                for ix in item_ixs {
2372                    tab_details[ix] += 1;
2373                }
2374            }
2375        }
2376    }
2377
2378    tab_details
2379}
2380
2381pub fn render_item_indicator(item: Box<dyn ItemHandle>, cx: &WindowContext) -> Option<Indicator> {
2382    maybe!({
2383        let indicator_color = match (item.has_conflict(cx), item.is_dirty(cx)) {
2384            (true, _) => Color::Warning,
2385            (_, true) => Color::Accent,
2386            (false, false) => return None,
2387        };
2388
2389        Some(Indicator::dot().color(indicator_color))
2390    })
2391}
2392
2393#[cfg(test)]
2394mod tests {
2395    use super::*;
2396    use crate::item::test::{TestItem, TestProjectItem};
2397    use gpui::{TestAppContext, VisualTestContext};
2398    use project::FakeFs;
2399    use settings::SettingsStore;
2400    use theme::LoadThemes;
2401
2402    #[gpui::test]
2403    async fn test_remove_active_empty(cx: &mut TestAppContext) {
2404        init_test(cx);
2405        let fs = FakeFs::new(cx.executor());
2406
2407        let project = Project::test(fs, None, cx).await;
2408        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2409        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2410
2411        pane.update(cx, |pane, cx| {
2412            assert!(pane
2413                .close_active_item(&CloseActiveItem { save_intent: None }, cx)
2414                .is_none())
2415        });
2416    }
2417
2418    #[gpui::test]
2419    async fn test_add_item_with_new_item(cx: &mut TestAppContext) {
2420        init_test(cx);
2421        let fs = FakeFs::new(cx.executor());
2422
2423        let project = Project::test(fs, None, cx).await;
2424        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2425        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2426
2427        // 1. Add with a destination index
2428        //   a. Add before the active item
2429        set_labeled_items(&pane, ["A", "B*", "C"], cx);
2430        pane.update(cx, |pane, cx| {
2431            pane.add_item(
2432                Box::new(cx.new_view(|cx| TestItem::new(cx).with_label("D"))),
2433                false,
2434                false,
2435                Some(0),
2436                cx,
2437            );
2438        });
2439        assert_item_labels(&pane, ["D*", "A", "B", "C"], cx);
2440
2441        //   b. Add after the active item
2442        set_labeled_items(&pane, ["A", "B*", "C"], cx);
2443        pane.update(cx, |pane, cx| {
2444            pane.add_item(
2445                Box::new(cx.new_view(|cx| TestItem::new(cx).with_label("D"))),
2446                false,
2447                false,
2448                Some(2),
2449                cx,
2450            );
2451        });
2452        assert_item_labels(&pane, ["A", "B", "D*", "C"], cx);
2453
2454        //   c. Add at the end of the item list (including off the length)
2455        set_labeled_items(&pane, ["A", "B*", "C"], cx);
2456        pane.update(cx, |pane, cx| {
2457            pane.add_item(
2458                Box::new(cx.new_view(|cx| TestItem::new(cx).with_label("D"))),
2459                false,
2460                false,
2461                Some(5),
2462                cx,
2463            );
2464        });
2465        assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
2466
2467        // 2. Add without a destination index
2468        //   a. Add with active item at the start of the item list
2469        set_labeled_items(&pane, ["A*", "B", "C"], cx);
2470        pane.update(cx, |pane, cx| {
2471            pane.add_item(
2472                Box::new(cx.new_view(|cx| TestItem::new(cx).with_label("D"))),
2473                false,
2474                false,
2475                None,
2476                cx,
2477            );
2478        });
2479        set_labeled_items(&pane, ["A", "D*", "B", "C"], cx);
2480
2481        //   b. Add with active item at the end of the item list
2482        set_labeled_items(&pane, ["A", "B", "C*"], cx);
2483        pane.update(cx, |pane, cx| {
2484            pane.add_item(
2485                Box::new(cx.new_view(|cx| TestItem::new(cx).with_label("D"))),
2486                false,
2487                false,
2488                None,
2489                cx,
2490            );
2491        });
2492        assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
2493    }
2494
2495    #[gpui::test]
2496    async fn test_add_item_with_existing_item(cx: &mut TestAppContext) {
2497        init_test(cx);
2498        let fs = FakeFs::new(cx.executor());
2499
2500        let project = Project::test(fs, None, cx).await;
2501        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2502        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2503
2504        // 1. Add with a destination index
2505        //   1a. Add before the active item
2506        let [_, _, _, d] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
2507        pane.update(cx, |pane, cx| {
2508            pane.add_item(d, false, false, Some(0), cx);
2509        });
2510        assert_item_labels(&pane, ["D*", "A", "B", "C"], cx);
2511
2512        //   1b. Add after the active item
2513        let [_, _, _, d] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
2514        pane.update(cx, |pane, cx| {
2515            pane.add_item(d, false, false, Some(2), cx);
2516        });
2517        assert_item_labels(&pane, ["A", "B", "D*", "C"], cx);
2518
2519        //   1c. Add at the end of the item list (including off the length)
2520        let [a, _, _, _] = set_labeled_items(&pane, ["A", "B*", "C", "D"], cx);
2521        pane.update(cx, |pane, cx| {
2522            pane.add_item(a, false, false, Some(5), cx);
2523        });
2524        assert_item_labels(&pane, ["B", "C", "D", "A*"], cx);
2525
2526        //   1d. Add same item to active index
2527        let [_, b, _] = set_labeled_items(&pane, ["A", "B*", "C"], cx);
2528        pane.update(cx, |pane, cx| {
2529            pane.add_item(b, false, false, Some(1), cx);
2530        });
2531        assert_item_labels(&pane, ["A", "B*", "C"], cx);
2532
2533        //   1e. Add item to index after same item in last position
2534        let [_, _, c] = set_labeled_items(&pane, ["A", "B*", "C"], cx);
2535        pane.update(cx, |pane, cx| {
2536            pane.add_item(c, false, false, Some(2), cx);
2537        });
2538        assert_item_labels(&pane, ["A", "B", "C*"], cx);
2539
2540        // 2. Add without a destination index
2541        //   2a. Add with active item at the start of the item list
2542        let [_, _, _, d] = set_labeled_items(&pane, ["A*", "B", "C", "D"], cx);
2543        pane.update(cx, |pane, cx| {
2544            pane.add_item(d, false, false, None, cx);
2545        });
2546        assert_item_labels(&pane, ["A", "D*", "B", "C"], cx);
2547
2548        //   2b. Add with active item at the end of the item list
2549        let [a, _, _, _] = set_labeled_items(&pane, ["A", "B", "C", "D*"], cx);
2550        pane.update(cx, |pane, cx| {
2551            pane.add_item(a, false, false, None, cx);
2552        });
2553        assert_item_labels(&pane, ["B", "C", "D", "A*"], cx);
2554
2555        //   2c. Add active item to active item at end of list
2556        let [_, _, c] = set_labeled_items(&pane, ["A", "B", "C*"], cx);
2557        pane.update(cx, |pane, cx| {
2558            pane.add_item(c, false, false, None, cx);
2559        });
2560        assert_item_labels(&pane, ["A", "B", "C*"], cx);
2561
2562        //   2d. Add active item to active item at start of list
2563        let [a, _, _] = set_labeled_items(&pane, ["A*", "B", "C"], cx);
2564        pane.update(cx, |pane, cx| {
2565            pane.add_item(a, false, false, None, cx);
2566        });
2567        assert_item_labels(&pane, ["A*", "B", "C"], cx);
2568    }
2569
2570    #[gpui::test]
2571    async fn test_add_item_with_same_project_entries(cx: &mut TestAppContext) {
2572        init_test(cx);
2573        let fs = FakeFs::new(cx.executor());
2574
2575        let project = Project::test(fs, None, cx).await;
2576        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2577        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2578
2579        // singleton view
2580        pane.update(cx, |pane, cx| {
2581            pane.add_item(
2582                Box::new(cx.new_view(|cx| {
2583                    TestItem::new(cx)
2584                        .with_singleton(true)
2585                        .with_label("buffer 1")
2586                        .with_project_items(&[TestProjectItem::new(1, "one.txt", cx)])
2587                })),
2588                false,
2589                false,
2590                None,
2591                cx,
2592            );
2593        });
2594        assert_item_labels(&pane, ["buffer 1*"], cx);
2595
2596        // new singleton view with the same project entry
2597        pane.update(cx, |pane, cx| {
2598            pane.add_item(
2599                Box::new(cx.new_view(|cx| {
2600                    TestItem::new(cx)
2601                        .with_singleton(true)
2602                        .with_label("buffer 1")
2603                        .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
2604                })),
2605                false,
2606                false,
2607                None,
2608                cx,
2609            );
2610        });
2611        assert_item_labels(&pane, ["buffer 1*"], cx);
2612
2613        // new singleton view with different project entry
2614        pane.update(cx, |pane, cx| {
2615            pane.add_item(
2616                Box::new(cx.new_view(|cx| {
2617                    TestItem::new(cx)
2618                        .with_singleton(true)
2619                        .with_label("buffer 2")
2620                        .with_project_items(&[TestProjectItem::new(2, "2.txt", cx)])
2621                })),
2622                false,
2623                false,
2624                None,
2625                cx,
2626            );
2627        });
2628        assert_item_labels(&pane, ["buffer 1", "buffer 2*"], cx);
2629
2630        // new multibuffer view with the same project entry
2631        pane.update(cx, |pane, cx| {
2632            pane.add_item(
2633                Box::new(cx.new_view(|cx| {
2634                    TestItem::new(cx)
2635                        .with_singleton(false)
2636                        .with_label("multibuffer 1")
2637                        .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
2638                })),
2639                false,
2640                false,
2641                None,
2642                cx,
2643            );
2644        });
2645        assert_item_labels(&pane, ["buffer 1", "buffer 2", "multibuffer 1*"], cx);
2646
2647        // another multibuffer view with the same project entry
2648        pane.update(cx, |pane, cx| {
2649            pane.add_item(
2650                Box::new(cx.new_view(|cx| {
2651                    TestItem::new(cx)
2652                        .with_singleton(false)
2653                        .with_label("multibuffer 1b")
2654                        .with_project_items(&[TestProjectItem::new(1, "1.txt", cx)])
2655                })),
2656                false,
2657                false,
2658                None,
2659                cx,
2660            );
2661        });
2662        assert_item_labels(
2663            &pane,
2664            ["buffer 1", "buffer 2", "multibuffer 1", "multibuffer 1b*"],
2665            cx,
2666        );
2667    }
2668
2669    #[gpui::test]
2670    async fn test_remove_item_ordering(cx: &mut TestAppContext) {
2671        init_test(cx);
2672        let fs = FakeFs::new(cx.executor());
2673
2674        let project = Project::test(fs, None, cx).await;
2675        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2676        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2677
2678        add_labeled_item(&pane, "A", false, cx);
2679        add_labeled_item(&pane, "B", false, cx);
2680        add_labeled_item(&pane, "C", false, cx);
2681        add_labeled_item(&pane, "D", false, cx);
2682        assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
2683
2684        pane.update(cx, |pane, cx| pane.activate_item(1, false, false, cx));
2685        add_labeled_item(&pane, "1", false, cx);
2686        assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
2687
2688        pane.update(cx, |pane, cx| {
2689            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
2690        })
2691        .unwrap()
2692        .await
2693        .unwrap();
2694        assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
2695
2696        pane.update(cx, |pane, cx| pane.activate_item(3, false, false, cx));
2697        assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
2698
2699        pane.update(cx, |pane, cx| {
2700            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
2701        })
2702        .unwrap()
2703        .await
2704        .unwrap();
2705        assert_item_labels(&pane, ["A", "B*", "C"], cx);
2706
2707        pane.update(cx, |pane, cx| {
2708            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
2709        })
2710        .unwrap()
2711        .await
2712        .unwrap();
2713        assert_item_labels(&pane, ["A", "C*"], cx);
2714
2715        pane.update(cx, |pane, cx| {
2716            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
2717        })
2718        .unwrap()
2719        .await
2720        .unwrap();
2721        assert_item_labels(&pane, ["A*"], cx);
2722    }
2723
2724    #[gpui::test]
2725    async fn test_close_inactive_items(cx: &mut TestAppContext) {
2726        init_test(cx);
2727        let fs = FakeFs::new(cx.executor());
2728
2729        let project = Project::test(fs, None, cx).await;
2730        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2731        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2732
2733        set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
2734
2735        pane.update(cx, |pane, cx| {
2736            pane.close_inactive_items(&CloseInactiveItems { save_intent: None }, cx)
2737        })
2738        .unwrap()
2739        .await
2740        .unwrap();
2741        assert_item_labels(&pane, ["C*"], cx);
2742    }
2743
2744    #[gpui::test]
2745    async fn test_close_clean_items(cx: &mut TestAppContext) {
2746        init_test(cx);
2747        let fs = FakeFs::new(cx.executor());
2748
2749        let project = Project::test(fs, None, cx).await;
2750        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2751        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2752
2753        add_labeled_item(&pane, "A", true, cx);
2754        add_labeled_item(&pane, "B", false, cx);
2755        add_labeled_item(&pane, "C", true, cx);
2756        add_labeled_item(&pane, "D", false, cx);
2757        add_labeled_item(&pane, "E", false, cx);
2758        assert_item_labels(&pane, ["A^", "B", "C^", "D", "E*"], cx);
2759
2760        pane.update(cx, |pane, cx| pane.close_clean_items(&CloseCleanItems, cx))
2761            .unwrap()
2762            .await
2763            .unwrap();
2764        assert_item_labels(&pane, ["A^", "C*^"], cx);
2765    }
2766
2767    #[gpui::test]
2768    async fn test_close_items_to_the_left(cx: &mut TestAppContext) {
2769        init_test(cx);
2770        let fs = FakeFs::new(cx.executor());
2771
2772        let project = Project::test(fs, None, cx).await;
2773        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2774        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2775
2776        set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
2777
2778        pane.update(cx, |pane, cx| {
2779            pane.close_items_to_the_left(&CloseItemsToTheLeft, cx)
2780        })
2781        .unwrap()
2782        .await
2783        .unwrap();
2784        assert_item_labels(&pane, ["C*", "D", "E"], cx);
2785    }
2786
2787    #[gpui::test]
2788    async fn test_close_items_to_the_right(cx: &mut TestAppContext) {
2789        init_test(cx);
2790        let fs = FakeFs::new(cx.executor());
2791
2792        let project = Project::test(fs, None, cx).await;
2793        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2794        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2795
2796        set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
2797
2798        pane.update(cx, |pane, cx| {
2799            pane.close_items_to_the_right(&CloseItemsToTheRight, cx)
2800        })
2801        .unwrap()
2802        .await
2803        .unwrap();
2804        assert_item_labels(&pane, ["A", "B", "C*"], cx);
2805    }
2806
2807    #[gpui::test]
2808    async fn test_close_all_items(cx: &mut TestAppContext) {
2809        init_test(cx);
2810        let fs = FakeFs::new(cx.executor());
2811
2812        let project = Project::test(fs, None, cx).await;
2813        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
2814        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
2815
2816        add_labeled_item(&pane, "A", false, cx);
2817        add_labeled_item(&pane, "B", false, cx);
2818        add_labeled_item(&pane, "C", false, cx);
2819        assert_item_labels(&pane, ["A", "B", "C*"], cx);
2820
2821        pane.update(cx, |pane, cx| {
2822            pane.close_all_items(&CloseAllItems { save_intent: None }, cx)
2823        })
2824        .unwrap()
2825        .await
2826        .unwrap();
2827        assert_item_labels(&pane, [], cx);
2828
2829        add_labeled_item(&pane, "A", true, cx);
2830        add_labeled_item(&pane, "B", true, cx);
2831        add_labeled_item(&pane, "C", true, cx);
2832        assert_item_labels(&pane, ["A^", "B^", "C*^"], cx);
2833
2834        let save = pane
2835            .update(cx, |pane, cx| {
2836                pane.close_all_items(&CloseAllItems { save_intent: None }, cx)
2837            })
2838            .unwrap();
2839
2840        cx.executor().run_until_parked();
2841        cx.simulate_prompt_answer(2);
2842        save.await.unwrap();
2843        assert_item_labels(&pane, [], cx);
2844    }
2845
2846    fn init_test(cx: &mut TestAppContext) {
2847        cx.update(|cx| {
2848            let settings_store = SettingsStore::test(cx);
2849            cx.set_global(settings_store);
2850            theme::init(LoadThemes::JustBase, cx);
2851            crate::init_settings(cx);
2852            Project::init_settings(cx);
2853        });
2854    }
2855
2856    fn add_labeled_item(
2857        pane: &View<Pane>,
2858        label: &str,
2859        is_dirty: bool,
2860        cx: &mut VisualTestContext,
2861    ) -> Box<View<TestItem>> {
2862        pane.update(cx, |pane, cx| {
2863            let labeled_item = Box::new(
2864                cx.new_view(|cx| TestItem::new(cx).with_label(label).with_dirty(is_dirty)),
2865            );
2866            pane.add_item(labeled_item.clone(), false, false, None, cx);
2867            labeled_item
2868        })
2869    }
2870
2871    fn set_labeled_items<const COUNT: usize>(
2872        pane: &View<Pane>,
2873        labels: [&str; COUNT],
2874        cx: &mut VisualTestContext,
2875    ) -> [Box<View<TestItem>>; COUNT] {
2876        pane.update(cx, |pane, cx| {
2877            pane.items.clear();
2878            let mut active_item_index = 0;
2879
2880            let mut index = 0;
2881            let items = labels.map(|mut label| {
2882                if label.ends_with('*') {
2883                    label = label.trim_end_matches('*');
2884                    active_item_index = index;
2885                }
2886
2887                let labeled_item = Box::new(cx.new_view(|cx| TestItem::new(cx).with_label(label)));
2888                pane.add_item(labeled_item.clone(), false, false, None, cx);
2889                index += 1;
2890                labeled_item
2891            });
2892
2893            pane.activate_item(active_item_index, false, false, cx);
2894
2895            items
2896        })
2897    }
2898
2899    // Assert the item label, with the active item label suffixed with a '*'
2900    fn assert_item_labels<const COUNT: usize>(
2901        pane: &View<Pane>,
2902        expected_states: [&str; COUNT],
2903        cx: &mut VisualTestContext,
2904    ) {
2905        pane.update(cx, |pane, cx| {
2906            let actual_states = pane
2907                .items
2908                .iter()
2909                .enumerate()
2910                .map(|(ix, item)| {
2911                    let mut state = item
2912                        .to_any()
2913                        .downcast::<TestItem>()
2914                        .unwrap()
2915                        .read(cx)
2916                        .label
2917                        .clone();
2918                    if ix == pane.active_item_index {
2919                        state.push('*');
2920                    }
2921                    if item.is_dirty(cx) {
2922                        state.push('^');
2923                    }
2924                    state
2925                })
2926                .collect::<Vec<_>>();
2927
2928            assert_eq!(
2929                actual_states, expected_states,
2930                "pane items do not match expectation"
2931            );
2932        })
2933    }
2934}
2935
2936impl Render for DraggedTab {
2937    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
2938        let ui_font = ThemeSettings::get_global(cx).ui_font.family.clone();
2939        let label = self.item.tab_content(
2940            TabContentParams {
2941                detail: Some(self.detail),
2942                selected: false,
2943                preview: false,
2944            },
2945            cx,
2946        );
2947        Tab::new("")
2948            .selected(self.is_active)
2949            .child(label)
2950            .render(cx)
2951            .font_family(ui_font)
2952    }
2953}