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(
364        &mut self,
365        query: String,
366        window: &mut Window,
367        cx: &mut Context<Picker<Self>>,
368    ) {
369        let Some(workspace) = self.workspace.upgrade() else {
370            return;
371        };
372        let mut all_items = Vec::new();
373        let mut item_index = 0;
374        for pane_handle in workspace.read(cx).panes() {
375            let pane = pane_handle.read(cx);
376            let items: Vec<Box<dyn ItemHandle>> =
377                pane.items().map(|item| item.boxed_clone()).collect();
378            for ((_detail, item), detail) in items
379                .iter()
380                .enumerate()
381                .zip(tab_details(&items, window, cx))
382            {
383                all_items.push(TabMatch {
384                    pane: pane_handle.downgrade(),
385                    item_index,
386                    item: item.clone(),
387                    detail,
388                    preview: pane.is_active_preview_item(item.item_id()),
389                });
390                item_index += 1;
391            }
392        }
393
394        let matches = if query.is_empty() {
395            let history = workspace.read(cx).recently_activated_items(cx);
396            all_items
397                .sort_by_key(|tab| (Reverse(history.get(&tab.item.item_id())), tab.item_index));
398            all_items
399        } else {
400            let candidates = all_items
401                .iter()
402                .enumerate()
403                .flat_map(|(ix, tab_match)| {
404                    Some(StringMatchCandidate::new(
405                        ix,
406                        &tab_match.item.tab_content_text(0, cx),
407                    ))
408                })
409                .collect::<Vec<_>>();
410            smol::block_on(fuzzy::match_strings(
411                &candidates,
412                &query,
413                true,
414                true,
415                10000,
416                &Default::default(),
417                cx.background_executor().clone(),
418            ))
419            .into_iter()
420            .map(|m| all_items[m.candidate_id].clone())
421            .collect()
422        };
423
424        let selected_item_id = self.selected_item_id();
425        self.matches = matches;
426        self.selected_index = self.compute_selected_index(selected_item_id, window, cx);
427    }
428
429    fn update_matches(
430        &mut self,
431        query: String,
432        window: &mut Window,
433        cx: &mut Context<Picker<Self>>,
434    ) {
435        if self.is_all_panes {
436            // needed because we need to borrow the workspace, but that may be borrowed when the picker
437            // calls update_matches.
438            let this = cx.entity();
439            window.defer(cx, move |window, cx| {
440                this.update(cx, |this, cx| {
441                    this.delegate.update_all_pane_matches(query, window, cx);
442                })
443            });
444            return;
445        }
446        let selected_item_id = self.selected_item_id();
447        self.matches.clear();
448        let Some(pane) = self.pane.upgrade() else {
449            return;
450        };
451
452        let pane = pane.read(cx);
453        let mut history_indices = HashMap::default();
454        pane.activation_history().iter().rev().enumerate().for_each(
455            |(history_index, history_entry)| {
456                history_indices.insert(history_entry.entity_id, history_index);
457            },
458        );
459
460        let items: Vec<Box<dyn ItemHandle>> = pane.items().map(|item| item.boxed_clone()).collect();
461        items
462            .iter()
463            .enumerate()
464            .zip(tab_details(&items, window, cx))
465            .map(|((item_index, item), detail)| TabMatch {
466                pane: self.pane.clone(),
467                item_index,
468                item: item.boxed_clone(),
469                detail,
470                preview: pane.is_active_preview_item(item.item_id()),
471            })
472            .for_each(|tab_match| self.matches.push(tab_match));
473
474        let non_history_base = history_indices.len();
475        self.matches.sort_by(move |a, b| {
476            let a_score = *history_indices
477                .get(&a.item.item_id())
478                .unwrap_or(&(a.item_index + non_history_base));
479            let b_score = *history_indices
480                .get(&b.item.item_id())
481                .unwrap_or(&(b.item_index + non_history_base));
482            a_score.cmp(&b_score)
483        });
484
485        self.selected_index = self.compute_selected_index(selected_item_id, window, cx);
486    }
487
488    fn selected_item_id(&self) -> Option<EntityId> {
489        self.matches
490            .get(self.selected_index())
491            .map(|tab_match| tab_match.item.item_id())
492    }
493
494    fn compute_selected_index(
495        &mut self,
496        prev_selected_item_id: Option<EntityId>,
497        window: &mut Window,
498        cx: &mut Context<Picker<Self>>,
499    ) -> usize {
500        if self.matches.is_empty() {
501            return 0;
502        }
503
504        if let Some(selected_item_id) = prev_selected_item_id {
505            // If the previously selected item is still in the list, select its new position.
506            if let Some(item_index) = self
507                .matches
508                .iter()
509                .position(|tab_match| tab_match.item.item_id() == selected_item_id)
510            {
511                return item_index;
512            }
513            // Otherwise, try to preserve the previously selected index.
514            return self.selected_index.min(self.matches.len() - 1);
515        }
516
517        if self.select_last {
518            return self.matches.len() - 1;
519        }
520
521        // This only runs when initially opening the picker
522        // Index 0 is already active, so don't preselect it for switching.
523        if self.matches.len() > 1 {
524            self.set_selected_index(1, window, cx);
525            return 1;
526        }
527
528        0
529    }
530
531    fn close_item_at(
532        &mut self,
533        ix: usize,
534        window: &mut Window,
535        cx: &mut Context<Picker<TabSwitcherDelegate>>,
536    ) {
537        let Some(tab_match) = self.matches.get(ix) else {
538            return;
539        };
540        let Some(pane) = self.pane.upgrade() else {
541            return;
542        };
543        pane.update(cx, |pane, cx| {
544            pane.close_item_by_id(tab_match.item.item_id(), SaveIntent::Close, window, cx)
545                .detach_and_log_err(cx);
546        });
547    }
548}
549
550impl PickerDelegate for TabSwitcherDelegate {
551    type ListItem = ListItem;
552
553    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
554        "Search all tabs…".into()
555    }
556
557    fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option<SharedString> {
558        Some("No tabs".into())
559    }
560
561    fn match_count(&self) -> usize {
562        self.matches.len()
563    }
564
565    fn selected_index(&self) -> usize {
566        self.selected_index
567    }
568
569    fn set_selected_index(
570        &mut self,
571        ix: usize,
572        window: &mut Window,
573        cx: &mut Context<Picker<Self>>,
574    ) {
575        self.selected_index = ix;
576
577        let Some(selected_match) = self.matches.get(self.selected_index()) else {
578            return;
579        };
580        selected_match
581            .pane
582            .update(cx, |pane, cx| {
583                if let Some(index) = pane.index_for_item(selected_match.item.as_ref()) {
584                    pane.activate_item(index, false, false, window, cx);
585                }
586            })
587            .ok();
588        cx.notify();
589    }
590
591    fn separators_after_indices(&self) -> Vec<usize> {
592        Vec::new()
593    }
594
595    fn update_matches(
596        &mut self,
597        raw_query: String,
598        window: &mut Window,
599        cx: &mut Context<Picker<Self>>,
600    ) -> Task<()> {
601        self.update_matches(raw_query, window, cx);
602        Task::ready(())
603    }
604
605    fn confirm(
606        &mut self,
607        _secondary: bool,
608        window: &mut Window,
609        cx: &mut Context<Picker<TabSwitcherDelegate>>,
610    ) {
611        let Some(selected_match) = self.matches.get(self.selected_index()) else {
612            return;
613        };
614
615        self.restored_items = true;
616        for (pane, index) in self.original_items.iter() {
617            pane.update(cx, |this, cx| {
618                this.activate_item(*index, false, false, window, cx);
619            })
620        }
621        selected_match
622            .pane
623            .update(cx, |pane, cx| {
624                if let Some(index) = pane.index_for_item(selected_match.item.as_ref()) {
625                    pane.activate_item(index, true, true, window, cx);
626                }
627            })
628            .ok();
629    }
630
631    fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<TabSwitcherDelegate>>) {
632        if !self.restored_items {
633            for (pane, index) in self.original_items.iter() {
634                pane.update(cx, |this, cx| {
635                    this.activate_item(*index, false, false, window, cx);
636                })
637            }
638        }
639
640        self.tab_switcher
641            .update(cx, |_, cx| cx.emit(DismissEvent))
642            .log_err();
643    }
644
645    fn render_match(
646        &self,
647        ix: usize,
648        selected: bool,
649        window: &mut Window,
650        cx: &mut Context<Picker<Self>>,
651    ) -> Option<Self::ListItem> {
652        let tab_match = self
653            .matches
654            .get(ix)
655            .expect("Invalid matches state: no element for index {ix}");
656
657        let params = TabContentParams {
658            detail: Some(tab_match.detail),
659            selected: true,
660            preview: tab_match.preview,
661            deemphasized: false,
662        };
663        let label = tab_match.item.tab_content(params, window, cx);
664
665        let icon = tab_match.icon(&self.project, selected, window, cx);
666
667        let indicator = render_item_indicator(tab_match.item.boxed_clone(), cx);
668        let indicator_color = if let Some(ref indicator) = indicator {
669            indicator.color
670        } else {
671            Color::default()
672        };
673        let indicator = h_flex()
674            .flex_shrink_0()
675            .children(indicator)
676            .child(div().w_2())
677            .into_any_element();
678        let close_button = div()
679            .id("close-button")
680            .on_mouse_up(
681                // We need this on_mouse_up here because on macOS you may have ctrl held
682                // down to open the menu, and a ctrl-click comes through as a right click.
683                MouseButton::Right,
684                cx.listener(move |picker, _: &MouseUpEvent, window, cx| {
685                    cx.stop_propagation();
686                    picker.delegate.close_item_at(ix, window, cx);
687                }),
688            )
689            .child(
690                IconButton::new("close_tab", IconName::Close)
691                    .icon_size(IconSize::Small)
692                    .icon_color(indicator_color)
693                    .tooltip(Tooltip::for_action_title("Close", &CloseSelectedItem))
694                    .on_click(cx.listener(move |picker, _, window, cx| {
695                        cx.stop_propagation();
696                        picker.delegate.close_item_at(ix, window, cx);
697                    })),
698            )
699            .into_any_element();
700
701        Some(
702            ListItem::new(ix)
703                .spacing(ListItemSpacing::Sparse)
704                .inset(true)
705                .toggle_state(selected)
706                .child(h_flex().w_full().child(label))
707                .start_slot::<DecoratedIcon>(icon)
708                .map(|el| {
709                    if self.selected_index == ix {
710                        el.end_slot::<AnyElement>(close_button)
711                    } else {
712                        el.end_slot::<AnyElement>(indicator)
713                            .end_hover_slot::<AnyElement>(close_button)
714                    }
715                }),
716        )
717    }
718}