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