1#[cfg(test)]
  2mod tab_switcher_tests;
  3
  4use collections::HashMap;
  5use editor::items::{
  6    entry_diagnostic_aware_icon_decoration_and_color, entry_git_aware_label_color,
  7};
  8use fuzzy::StringMatchCandidate;
  9use gpui::{
 10    Action, AnyElement, App, Context, DismissEvent, Entity, EntityId, EventEmitter, FocusHandle,
 11    Focusable, Modifiers, ModifiersChangedEvent, MouseButton, MouseUpEvent, ParentElement, Point,
 12    Render, Styled, Task, WeakEntity, Window, actions, rems,
 13};
 14use picker::{Picker, PickerDelegate};
 15use project::Project;
 16use schemars::JsonSchema;
 17use serde::Deserialize;
 18use settings::Settings;
 19use std::{cmp::Reverse, sync::Arc};
 20use ui::{
 21    DecoratedIcon, IconDecoration, IconDecorationKind, ListItem, ListItemSpacing, Tooltip,
 22    prelude::*,
 23};
 24use util::ResultExt;
 25use workspace::{
 26    ModalView, Pane, SaveIntent, Workspace,
 27    item::{ItemHandle, ItemSettings, ShowDiagnostics, TabContentParams},
 28    pane::{Event as PaneEvent, render_item_indicator, tab_details},
 29};
 30
 31const PANEL_WIDTH_REMS: f32 = 28.;
 32
 33/// Toggles the tab switcher interface.
 34#[derive(PartialEq, Clone, Deserialize, JsonSchema, Default, Action)]
 35#[action(namespace = tab_switcher)]
 36#[serde(deny_unknown_fields)]
 37pub struct Toggle {
 38    #[serde(default)]
 39    pub select_last: bool,
 40}
 41actions!(
 42    tab_switcher,
 43    [
 44        /// Closes the selected item in the tab switcher.
 45        CloseSelectedItem,
 46        /// Toggles between showing all tabs or just the current pane's tabs.
 47        ToggleAll
 48    ]
 49);
 50
 51pub struct TabSwitcher {
 52    picker: Entity<Picker<TabSwitcherDelegate>>,
 53    init_modifiers: Option<Modifiers>,
 54}
 55
 56impl ModalView for TabSwitcher {}
 57
 58pub fn init(cx: &mut App) {
 59    cx.observe_new(TabSwitcher::register).detach();
 60}
 61
 62impl TabSwitcher {
 63    fn register(
 64        workspace: &mut Workspace,
 65        _window: Option<&mut Window>,
 66        _: &mut Context<Workspace>,
 67    ) {
 68        workspace.register_action(|workspace, action: &Toggle, window, cx| {
 69            let Some(tab_switcher) = workspace.active_modal::<Self>(cx) else {
 70                Self::open(workspace, action.select_last, false, window, cx);
 71                return;
 72            };
 73
 74            tab_switcher.update(cx, |tab_switcher, cx| {
 75                tab_switcher
 76                    .picker
 77                    .update(cx, |picker, cx| picker.cycle_selection(window, cx))
 78            });
 79        });
 80        workspace.register_action(|workspace, _action: &ToggleAll, window, cx| {
 81            let Some(tab_switcher) = workspace.active_modal::<Self>(cx) else {
 82                Self::open(workspace, false, true, window, cx);
 83                return;
 84            };
 85
 86            tab_switcher.update(cx, |tab_switcher, cx| {
 87                tab_switcher
 88                    .picker
 89                    .update(cx, |picker, cx| picker.cycle_selection(window, cx))
 90            });
 91        });
 92    }
 93
 94    fn open(
 95        workspace: &mut Workspace,
 96        select_last: bool,
 97        is_global: bool,
 98        window: &mut Window,
 99        cx: &mut Context<Workspace>,
100    ) {
101        let mut weak_pane = workspace.active_pane().downgrade();
102        for dock in [
103            workspace.left_dock(),
104            workspace.bottom_dock(),
105            workspace.right_dock(),
106        ] {
107            dock.update(cx, |this, cx| {
108                let Some(panel) = this
109                    .active_panel()
110                    .filter(|panel| panel.panel_focus_handle(cx).contains_focused(window, cx))
111                else {
112                    return;
113                };
114                if let Some(pane) = panel.pane(cx) {
115                    weak_pane = pane.downgrade();
116                }
117            })
118        }
119
120        let weak_workspace = workspace.weak_handle();
121
122        let project = workspace.project().clone();
123        let original_items: Vec<_> = workspace
124            .panes()
125            .iter()
126            .map(|p| (p.clone(), p.read(cx).active_item_index()))
127            .collect();
128        workspace.toggle_modal(window, cx, |window, cx| {
129            let delegate = TabSwitcherDelegate::new(
130                project,
131                select_last,
132                cx.entity().downgrade(),
133                weak_pane,
134                weak_workspace,
135                is_global,
136                window,
137                cx,
138                original_items,
139            );
140            TabSwitcher::new(delegate, window, is_global, cx)
141        });
142    }
143
144    fn new(
145        delegate: TabSwitcherDelegate,
146        window: &mut Window,
147        is_global: bool,
148        cx: &mut Context<Self>,
149    ) -> Self {
150        let init_modifiers = if is_global {
151            None
152        } else {
153            window.modifiers().modified().then_some(window.modifiers())
154        };
155        Self {
156            picker: cx.new(|cx| {
157                if is_global {
158                    Picker::uniform_list(delegate, window, cx)
159                } else {
160                    Picker::nonsearchable_uniform_list(delegate, window, cx)
161                }
162            }),
163            init_modifiers,
164        }
165    }
166
167    fn handle_modifiers_changed(
168        &mut self,
169        event: &ModifiersChangedEvent,
170        window: &mut Window,
171        cx: &mut Context<Self>,
172    ) {
173        let Some(init_modifiers) = self.init_modifiers else {
174            return;
175        };
176        if !event.modified() || !init_modifiers.is_subset_of(event) {
177            self.init_modifiers = None;
178            if self.picker.read(cx).delegate.matches.is_empty() {
179                cx.emit(DismissEvent)
180            } else {
181                window.dispatch_action(menu::Confirm.boxed_clone(), cx);
182            }
183        }
184    }
185
186    fn handle_close_selected_item(
187        &mut self,
188        _: &CloseSelectedItem,
189        window: &mut Window,
190        cx: &mut Context<Self>,
191    ) {
192        self.picker.update(cx, |picker, cx| {
193            picker
194                .delegate
195                .close_item_at(picker.delegate.selected_index(), window, cx)
196        });
197    }
198}
199
200impl EventEmitter<DismissEvent> for TabSwitcher {}
201
202impl Focusable for TabSwitcher {
203    fn focus_handle(&self, cx: &App) -> FocusHandle {
204        self.picker.focus_handle(cx)
205    }
206}
207
208impl Render for TabSwitcher {
209    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
210        v_flex()
211            .key_context("TabSwitcher")
212            .w(rems(PANEL_WIDTH_REMS))
213            .on_modifiers_changed(cx.listener(Self::handle_modifiers_changed))
214            .on_action(cx.listener(Self::handle_close_selected_item))
215            .child(self.picker.clone())
216    }
217}
218
219#[derive(Clone)]
220struct TabMatch {
221    pane: WeakEntity<Pane>,
222    item_index: usize,
223    item: Box<dyn ItemHandle>,
224    detail: usize,
225    preview: bool,
226}
227
228pub struct TabSwitcherDelegate {
229    select_last: bool,
230    tab_switcher: WeakEntity<TabSwitcher>,
231    selected_index: usize,
232    pane: WeakEntity<Pane>,
233    workspace: WeakEntity<Workspace>,
234    project: Entity<Project>,
235    matches: Vec<TabMatch>,
236    original_items: Vec<(Entity<Pane>, usize)>,
237    is_all_panes: bool,
238    restored_items: bool,
239}
240
241impl TabMatch {
242    fn icon(
243        &self,
244        project: &Entity<Project>,
245        selected: bool,
246        window: &Window,
247        cx: &App,
248    ) -> Option<DecoratedIcon> {
249        let icon = self.item.tab_icon(window, cx)?;
250        let item_settings = ItemSettings::get_global(cx);
251        let show_diagnostics = item_settings.show_diagnostics;
252        let git_status_color = item_settings
253            .git_status
254            .then(|| {
255                let path = self.item.project_path(cx)?;
256                let project = project.read(cx);
257                let entry = project.entry_for_path(&path, cx)?;
258                let git_status = project
259                    .project_path_git_status(&path, cx)
260                    .map(|status| status.summary())
261                    .unwrap_or_default();
262                Some(entry_git_aware_label_color(
263                    git_status,
264                    entry.is_ignored,
265                    selected,
266                ))
267            })
268            .flatten();
269        let colored_icon = icon.color(git_status_color.unwrap_or_default());
270
271        let most_severe_diagnostic_level = if show_diagnostics == ShowDiagnostics::Off {
272            None
273        } else {
274            let buffer_store = project.read(cx).buffer_store().read(cx);
275            let buffer = self
276                .item
277                .project_path(cx)
278                .and_then(|path| buffer_store.get_by_path(&path))
279                .map(|buffer| buffer.read(cx));
280            buffer.and_then(|buffer| {
281                buffer
282                    .buffer_diagnostics(None)
283                    .iter()
284                    .map(|diagnostic_entry| diagnostic_entry.diagnostic.severity)
285                    .min()
286            })
287        };
288
289        let decorations =
290            entry_diagnostic_aware_icon_decoration_and_color(most_severe_diagnostic_level)
291                .filter(|(d, _)| {
292                    *d != IconDecorationKind::Triangle
293                        || show_diagnostics != ShowDiagnostics::Errors
294                })
295                .map(|(icon, color)| {
296                    let knockout_item_color = if selected {
297                        cx.theme().colors().element_selected
298                    } else {
299                        cx.theme().colors().element_background
300                    };
301                    IconDecoration::new(icon, knockout_item_color, cx)
302                        .color(color.color(cx))
303                        .position(Point {
304                            x: px(-2.),
305                            y: px(-2.),
306                        })
307                });
308        Some(DecoratedIcon::new(colored_icon, decorations))
309    }
310}
311
312impl TabSwitcherDelegate {
313    #[allow(clippy::complexity)]
314    fn new(
315        project: Entity<Project>,
316        select_last: bool,
317        tab_switcher: WeakEntity<TabSwitcher>,
318        pane: WeakEntity<Pane>,
319        workspace: WeakEntity<Workspace>,
320        is_all_panes: bool,
321        window: &mut Window,
322        cx: &mut Context<TabSwitcher>,
323        original_items: Vec<(Entity<Pane>, usize)>,
324    ) -> Self {
325        Self::subscribe_to_updates(&pane, window, cx);
326        Self {
327            select_last,
328            tab_switcher,
329            selected_index: 0,
330            pane,
331            workspace,
332            project,
333            matches: Vec::new(),
334            is_all_panes,
335            original_items,
336            restored_items: false,
337        }
338    }
339
340    fn subscribe_to_updates(
341        pane: &WeakEntity<Pane>,
342        window: &mut Window,
343        cx: &mut Context<TabSwitcher>,
344    ) {
345        let Some(pane) = pane.upgrade() else {
346            return;
347        };
348        cx.subscribe_in(&pane, window, |tab_switcher, _, event, window, cx| {
349            match event {
350                PaneEvent::AddItem { .. }
351                | PaneEvent::RemovedItem { .. }
352                | PaneEvent::Remove { .. } => tab_switcher.picker.update(cx, |picker, cx| {
353                    let query = picker.query(cx);
354                    picker.delegate.update_matches(query, window, cx);
355                    cx.notify();
356                }),
357                _ => {}
358            };
359        })
360        .detach();
361    }
362
363    fn update_all_pane_matches(&mut self, query: String, window: &mut Window, cx: &mut App) {
364        let Some(workspace) = self.workspace.upgrade() else {
365            return;
366        };
367        let mut all_items = Vec::new();
368        let mut item_index = 0;
369        for pane_handle in workspace.read(cx).panes() {
370            let pane = pane_handle.read(cx);
371            let items: Vec<Box<dyn ItemHandle>> =
372                pane.items().map(|item| item.boxed_clone()).collect();
373            for ((_detail, item), detail) in items
374                .iter()
375                .enumerate()
376                .zip(tab_details(&items, window, cx))
377            {
378                all_items.push(TabMatch {
379                    pane: pane_handle.downgrade(),
380                    item_index,
381                    item: item.clone(),
382                    detail,
383                    preview: pane.is_active_preview_item(item.item_id()),
384                });
385                item_index += 1;
386            }
387        }
388
389        let matches = if query.is_empty() {
390            let history = workspace.read(cx).recently_activated_items(cx);
391            all_items
392                .sort_by_key(|tab| (Reverse(history.get(&tab.item.item_id())), tab.item_index));
393            all_items
394        } else {
395            let candidates = all_items
396                .iter()
397                .enumerate()
398                .flat_map(|(ix, tab_match)| {
399                    Some(StringMatchCandidate::new(
400                        ix,
401                        &tab_match.item.tab_content_text(0, cx),
402                    ))
403                })
404                .collect::<Vec<_>>();
405            smol::block_on(fuzzy::match_strings(
406                &candidates,
407                &query,
408                true,
409                true,
410                10000,
411                &Default::default(),
412                cx.background_executor().clone(),
413            ))
414            .into_iter()
415            .map(|m| all_items[m.candidate_id].clone())
416            .collect()
417        };
418
419        let selected_item_id = self.selected_item_id();
420        self.matches = matches;
421        self.selected_index = self.compute_selected_index(selected_item_id);
422    }
423
424    fn update_matches(
425        &mut self,
426        query: String,
427        window: &mut Window,
428        cx: &mut Context<Picker<Self>>,
429    ) {
430        if self.is_all_panes {
431            // needed because we need to borrow the workspace, but that may be borrowed when the picker
432            // calls update_matches.
433            let this = cx.entity();
434            window.defer(cx, move |window, cx| {
435                this.update(cx, |this, cx| {
436                    this.delegate.update_all_pane_matches(query, window, cx);
437                })
438            });
439            return;
440        }
441        let selected_item_id = self.selected_item_id();
442        self.matches.clear();
443        let Some(pane) = self.pane.upgrade() else {
444            return;
445        };
446
447        let pane = pane.read(cx);
448        let mut history_indices = HashMap::default();
449        pane.activation_history().iter().rev().enumerate().for_each(
450            |(history_index, history_entry)| {
451                history_indices.insert(history_entry.entity_id, history_index);
452            },
453        );
454
455        let items: Vec<Box<dyn ItemHandle>> = pane.items().map(|item| item.boxed_clone()).collect();
456        items
457            .iter()
458            .enumerate()
459            .zip(tab_details(&items, window, cx))
460            .map(|((item_index, item), detail)| TabMatch {
461                pane: self.pane.clone(),
462                item_index,
463                item: item.boxed_clone(),
464                detail,
465                preview: pane.is_active_preview_item(item.item_id()),
466            })
467            .for_each(|tab_match| self.matches.push(tab_match));
468
469        let non_history_base = history_indices.len();
470        self.matches.sort_by(move |a, b| {
471            let a_score = *history_indices
472                .get(&a.item.item_id())
473                .unwrap_or(&(a.item_index + non_history_base));
474            let b_score = *history_indices
475                .get(&b.item.item_id())
476                .unwrap_or(&(b.item_index + non_history_base));
477            a_score.cmp(&b_score)
478        });
479
480        self.selected_index = self.compute_selected_index(selected_item_id);
481    }
482
483    fn selected_item_id(&self) -> Option<EntityId> {
484        self.matches
485            .get(self.selected_index())
486            .map(|tab_match| tab_match.item.item_id())
487    }
488
489    fn compute_selected_index(&mut self, prev_selected_item_id: Option<EntityId>) -> usize {
490        if self.matches.is_empty() {
491            return 0;
492        }
493
494        if let Some(selected_item_id) = prev_selected_item_id {
495            // If the previously selected item is still in the list, select its new position.
496            if let Some(item_index) = self
497                .matches
498                .iter()
499                .position(|tab_match| tab_match.item.item_id() == selected_item_id)
500            {
501                return item_index;
502            }
503            // Otherwise, try to preserve the previously selected index.
504            return self.selected_index.min(self.matches.len() - 1);
505        }
506
507        if self.select_last {
508            return self.matches.len() - 1;
509        }
510
511        if self.matches.len() > 1 {
512            // Index 0 is active, so don't preselect it for switching.
513            return 1;
514        }
515
516        0
517    }
518
519    fn close_item_at(
520        &mut self,
521        ix: usize,
522        window: &mut Window,
523        cx: &mut Context<Picker<TabSwitcherDelegate>>,
524    ) {
525        let Some(tab_match) = self.matches.get(ix) else {
526            return;
527        };
528        let Some(pane) = self.pane.upgrade() else {
529            return;
530        };
531        pane.update(cx, |pane, cx| {
532            pane.close_item_by_id(tab_match.item.item_id(), SaveIntent::Close, window, cx)
533                .detach_and_log_err(cx);
534        });
535    }
536}
537
538impl PickerDelegate for TabSwitcherDelegate {
539    type ListItem = ListItem;
540
541    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
542        "Search all tabs…".into()
543    }
544
545    fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option<SharedString> {
546        Some("No tabs".into())
547    }
548
549    fn match_count(&self) -> usize {
550        self.matches.len()
551    }
552
553    fn selected_index(&self) -> usize {
554        self.selected_index
555    }
556
557    fn set_selected_index(
558        &mut self,
559        ix: usize,
560        window: &mut Window,
561        cx: &mut Context<Picker<Self>>,
562    ) {
563        self.selected_index = ix;
564
565        let Some(selected_match) = self.matches.get(self.selected_index()) else {
566            return;
567        };
568        selected_match
569            .pane
570            .update(cx, |pane, cx| {
571                if let Some(index) = pane.index_for_item(selected_match.item.as_ref()) {
572                    pane.activate_item(index, false, false, window, cx);
573                }
574            })
575            .ok();
576        cx.notify();
577    }
578
579    fn separators_after_indices(&self) -> Vec<usize> {
580        Vec::new()
581    }
582
583    fn update_matches(
584        &mut self,
585        raw_query: String,
586        window: &mut Window,
587        cx: &mut Context<Picker<Self>>,
588    ) -> Task<()> {
589        self.update_matches(raw_query, window, cx);
590        Task::ready(())
591    }
592
593    fn confirm(
594        &mut self,
595        _secondary: bool,
596        window: &mut Window,
597        cx: &mut Context<Picker<TabSwitcherDelegate>>,
598    ) {
599        let Some(selected_match) = self.matches.get(self.selected_index()) else {
600            return;
601        };
602
603        self.restored_items = true;
604        for (pane, index) in self.original_items.iter() {
605            pane.update(cx, |this, cx| {
606                this.activate_item(*index, false, false, window, cx);
607            })
608        }
609        selected_match
610            .pane
611            .update(cx, |pane, cx| {
612                if let Some(index) = pane.index_for_item(selected_match.item.as_ref()) {
613                    pane.activate_item(index, true, true, window, cx);
614                }
615            })
616            .ok();
617    }
618
619    fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<TabSwitcherDelegate>>) {
620        if !self.restored_items {
621            for (pane, index) in self.original_items.iter() {
622                pane.update(cx, |this, cx| {
623                    this.activate_item(*index, false, false, window, cx);
624                })
625            }
626        }
627
628        self.tab_switcher
629            .update(cx, |_, cx| cx.emit(DismissEvent))
630            .log_err();
631    }
632
633    fn render_match(
634        &self,
635        ix: usize,
636        selected: bool,
637        window: &mut Window,
638        cx: &mut Context<Picker<Self>>,
639    ) -> Option<Self::ListItem> {
640        let tab_match = self
641            .matches
642            .get(ix)
643            .expect("Invalid matches state: no element for index {ix}");
644
645        let params = TabContentParams {
646            detail: Some(tab_match.detail),
647            selected: true,
648            preview: tab_match.preview,
649            deemphasized: false,
650        };
651        let label = tab_match.item.tab_content(params, window, cx);
652
653        let icon = tab_match.icon(&self.project, selected, window, cx);
654
655        let indicator = render_item_indicator(tab_match.item.boxed_clone(), cx);
656        let indicator_color = if let Some(ref indicator) = indicator {
657            indicator.color
658        } else {
659            Color::default()
660        };
661        let indicator = h_flex()
662            .flex_shrink_0()
663            .children(indicator)
664            .child(div().w_2())
665            .into_any_element();
666        let close_button = div()
667            .id("close-button")
668            .on_mouse_up(
669                // We need this on_mouse_up here because on macOS you may have ctrl held
670                // down to open the menu, and a ctrl-click comes through as a right click.
671                MouseButton::Right,
672                cx.listener(move |picker, _: &MouseUpEvent, window, cx| {
673                    cx.stop_propagation();
674                    picker.delegate.close_item_at(ix, window, cx);
675                }),
676            )
677            .child(
678                IconButton::new("close_tab", IconName::Close)
679                    .icon_size(IconSize::Small)
680                    .icon_color(indicator_color)
681                    .tooltip(Tooltip::for_action_title("Close", &CloseSelectedItem))
682                    .on_click(cx.listener(move |picker, _, window, cx| {
683                        cx.stop_propagation();
684                        picker.delegate.close_item_at(ix, window, cx);
685                    })),
686            )
687            .into_any_element();
688
689        Some(
690            ListItem::new(ix)
691                .spacing(ListItemSpacing::Sparse)
692                .inset(true)
693                .toggle_state(selected)
694                .child(h_flex().w_full().child(label))
695                .start_slot::<DecoratedIcon>(icon)
696                .map(|el| {
697                    if self.selected_index == ix {
698                        el.end_slot::<AnyElement>(close_button)
699                    } else {
700                        el.end_slot::<AnyElement>(indicator)
701                            .end_hover_slot::<AnyElement>(close_button)
702                    }
703                }),
704        )
705    }
706}