1#[cfg(test)]
2mod tab_switcher_tests;
3
4use collections::HashMap;
5use gpui::{
6 actions, impl_actions, rems, Action, AnyElement, AppContext, DismissEvent, EntityId,
7 EventEmitter, FocusHandle, FocusableView, Modifiers, ModifiersChangedEvent, MouseButton,
8 MouseUpEvent, ParentElement, Render, Styled, Task, View, ViewContext, VisualContext, WeakView,
9};
10use picker::{Picker, PickerDelegate};
11use serde::Deserialize;
12use std::sync::Arc;
13use ui::{prelude::*, ListItem, ListItemSpacing, Tooltip};
14use util::ResultExt;
15use workspace::{
16 item::ItemHandle,
17 pane::{render_item_indicator, tab_details, Event as PaneEvent},
18 ModalView, Pane, SaveIntent, Workspace,
19};
20
21const PANEL_WIDTH_REMS: f32 = 28.;
22
23#[derive(PartialEq, Clone, Deserialize, Default)]
24pub struct Toggle {
25 #[serde(default)]
26 pub select_last: bool,
27}
28
29impl_actions!(tab_switcher, [Toggle]);
30actions!(tab_switcher, [CloseSelectedItem]);
31
32pub struct TabSwitcher {
33 picker: View<Picker<TabSwitcherDelegate>>,
34 init_modifiers: Option<Modifiers>,
35}
36
37impl ModalView for TabSwitcher {}
38
39pub fn init(cx: &mut AppContext) {
40 cx.observe_new_views(TabSwitcher::register).detach();
41}
42
43impl TabSwitcher {
44 fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
45 workspace.register_action(|workspace, action: &Toggle, cx| {
46 let Some(tab_switcher) = workspace.active_modal::<Self>(cx) else {
47 Self::open(action, workspace, cx);
48 return;
49 };
50
51 tab_switcher.update(cx, |tab_switcher, cx| {
52 tab_switcher
53 .picker
54 .update(cx, |picker, cx| picker.cycle_selection(cx))
55 });
56 });
57 }
58
59 fn open(action: &Toggle, workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
60 let terminal = workspace.panel::<terminal_view::terminal_panel::TerminalPanel>(cx);
61 let terminal_pane = terminal.and_then(|terminal| {
62 terminal
63 .focus_handle(cx)
64 .contains_focused(cx)
65 .then(|| terminal.read(cx).pane())
66 });
67 let weak_pane = terminal_pane
68 .unwrap_or_else(|| workspace.active_pane())
69 .downgrade();
70 workspace.toggle_modal(cx, |cx| {
71 let delegate = TabSwitcherDelegate::new(action, cx.view().downgrade(), weak_pane, cx);
72 TabSwitcher::new(delegate, cx)
73 });
74 }
75
76 fn new(delegate: TabSwitcherDelegate, cx: &mut ViewContext<Self>) -> Self {
77 Self {
78 picker: cx.new_view(|cx| Picker::nonsearchable_uniform_list(delegate, cx)),
79 init_modifiers: cx.modifiers().modified().then_some(cx.modifiers()),
80 }
81 }
82
83 fn handle_modifiers_changed(
84 &mut self,
85 event: &ModifiersChangedEvent,
86 cx: &mut ViewContext<Self>,
87 ) {
88 let Some(init_modifiers) = self.init_modifiers else {
89 return;
90 };
91 if !event.modified() || !init_modifiers.is_subset_of(event) {
92 self.init_modifiers = None;
93 if self.picker.read(cx).delegate.matches.is_empty() {
94 cx.emit(DismissEvent)
95 } else {
96 cx.dispatch_action(menu::Confirm.boxed_clone());
97 }
98 }
99 }
100
101 fn handle_close_selected_item(&mut self, _: &CloseSelectedItem, cx: &mut ViewContext<Self>) {
102 self.picker.update(cx, |picker, cx| {
103 picker
104 .delegate
105 .close_item_at(picker.delegate.selected_index(), cx)
106 });
107 }
108}
109
110impl EventEmitter<DismissEvent> for TabSwitcher {}
111
112impl FocusableView for TabSwitcher {
113 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
114 self.picker.focus_handle(cx)
115 }
116}
117
118impl Render for TabSwitcher {
119 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
120 v_flex()
121 .key_context("TabSwitcher")
122 .w(rems(PANEL_WIDTH_REMS))
123 .on_modifiers_changed(cx.listener(Self::handle_modifiers_changed))
124 .on_action(cx.listener(Self::handle_close_selected_item))
125 .child(self.picker.clone())
126 }
127}
128
129struct TabMatch {
130 item_index: usize,
131 item: Box<dyn ItemHandle>,
132 detail: usize,
133}
134
135pub struct TabSwitcherDelegate {
136 select_last: bool,
137 tab_switcher: WeakView<TabSwitcher>,
138 selected_index: usize,
139 pane: WeakView<Pane>,
140 matches: Vec<TabMatch>,
141}
142
143impl TabSwitcherDelegate {
144 fn new(
145 action: &Toggle,
146 tab_switcher: WeakView<TabSwitcher>,
147 pane: WeakView<Pane>,
148 cx: &mut ViewContext<TabSwitcher>,
149 ) -> Self {
150 Self::subscribe_to_updates(&pane, cx);
151 Self {
152 select_last: action.select_last,
153 tab_switcher,
154 selected_index: 0,
155 pane,
156 matches: Vec::new(),
157 }
158 }
159
160 fn subscribe_to_updates(pane: &WeakView<Pane>, cx: &mut ViewContext<TabSwitcher>) {
161 let Some(pane) = pane.upgrade() else {
162 return;
163 };
164 cx.subscribe(&pane, |tab_switcher, _, event, cx| {
165 match event {
166 PaneEvent::AddItem { .. } | PaneEvent::RemoveItem { .. } | PaneEvent::Remove => {
167 tab_switcher.picker.update(cx, |picker, cx| {
168 let selected_item_id = picker.delegate.selected_item_id();
169 picker.delegate.update_matches(cx);
170 if let Some(item_id) = selected_item_id {
171 picker.delegate.select_item(item_id, cx);
172 }
173 cx.notify();
174 })
175 }
176 _ => {}
177 };
178 })
179 .detach();
180 }
181
182 fn update_matches(&mut self, cx: &mut WindowContext) {
183 self.matches.clear();
184 let Some(pane) = self.pane.upgrade() else {
185 return;
186 };
187
188 let pane = pane.read(cx);
189 let mut history_indices = HashMap::default();
190 pane.activation_history().iter().rev().enumerate().for_each(
191 |(history_index, entity_id)| {
192 history_indices.insert(entity_id, history_index);
193 },
194 );
195
196 let items: Vec<Box<dyn ItemHandle>> = pane.items().map(|item| item.boxed_clone()).collect();
197 items
198 .iter()
199 .enumerate()
200 .zip(tab_details(&items, cx))
201 .map(|((item_index, item), detail)| TabMatch {
202 item_index,
203 item: item.boxed_clone(),
204 detail,
205 })
206 .for_each(|tab_match| self.matches.push(tab_match));
207
208 let non_history_base = history_indices.len();
209 self.matches.sort_by(move |a, b| {
210 let a_score = *history_indices
211 .get(&a.item.item_id())
212 .unwrap_or(&(a.item_index + non_history_base));
213 let b_score = *history_indices
214 .get(&b.item.item_id())
215 .unwrap_or(&(b.item_index + non_history_base));
216 a_score.cmp(&b_score)
217 });
218
219 if self.matches.len() > 1 {
220 if self.select_last {
221 self.selected_index = self.matches.len() - 1;
222 } else {
223 self.selected_index = 1;
224 }
225 }
226 }
227
228 fn selected_item_id(&self) -> Option<EntityId> {
229 self.matches
230 .get(self.selected_index())
231 .map(|tab_match| tab_match.item.item_id())
232 }
233
234 fn select_item(
235 &mut self,
236 item_id: EntityId,
237 cx: &mut ViewContext<'_, Picker<TabSwitcherDelegate>>,
238 ) {
239 let selected_idx = self
240 .matches
241 .iter()
242 .position(|tab_match| tab_match.item.item_id() == item_id)
243 .unwrap_or(0);
244 self.set_selected_index(selected_idx, cx);
245 }
246
247 fn close_item_at(&mut self, ix: usize, cx: &mut ViewContext<'_, Picker<TabSwitcherDelegate>>) {
248 let Some(tab_match) = self.matches.get(ix) else {
249 return;
250 };
251 let Some(pane) = self.pane.upgrade() else {
252 return;
253 };
254 pane.update(cx, |pane, cx| {
255 pane.close_item_by_id(tab_match.item.item_id(), SaveIntent::Close, cx)
256 .detach_and_log_err(cx);
257 });
258 }
259}
260
261impl PickerDelegate for TabSwitcherDelegate {
262 type ListItem = ListItem;
263
264 fn placeholder_text(&self, _cx: &mut WindowContext) -> Arc<str> {
265 "".into()
266 }
267
268 fn no_matches_text(&self, _cx: &mut WindowContext) -> SharedString {
269 "No tabs".into()
270 }
271
272 fn match_count(&self) -> usize {
273 self.matches.len()
274 }
275
276 fn selected_index(&self) -> usize {
277 self.selected_index
278 }
279
280 fn set_selected_index(&mut self, ix: usize, cx: &mut ViewContext<Picker<Self>>) {
281 self.selected_index = ix;
282 cx.notify();
283 }
284
285 fn separators_after_indices(&self) -> Vec<usize> {
286 Vec::new()
287 }
288
289 fn update_matches(
290 &mut self,
291 _raw_query: String,
292 cx: &mut ViewContext<Picker<Self>>,
293 ) -> Task<()> {
294 self.update_matches(cx);
295 Task::ready(())
296 }
297
298 fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<TabSwitcherDelegate>>) {
299 let Some(pane) = self.pane.upgrade() else {
300 return;
301 };
302 let Some(selected_match) = self.matches.get(self.selected_index()) else {
303 return;
304 };
305 pane.update(cx, |pane, cx| {
306 pane.activate_item(selected_match.item_index, true, true, cx);
307 });
308 }
309
310 fn dismissed(&mut self, cx: &mut ViewContext<Picker<TabSwitcherDelegate>>) {
311 self.tab_switcher
312 .update(cx, |_, cx| cx.emit(DismissEvent))
313 .log_err();
314 }
315
316 fn render_match(
317 &self,
318 ix: usize,
319 selected: bool,
320 cx: &mut ViewContext<Picker<Self>>,
321 ) -> Option<Self::ListItem> {
322 let tab_match = self
323 .matches
324 .get(ix)
325 .expect("Invalid matches state: no element for index {ix}");
326
327 let label = tab_match.item.tab_content(Some(tab_match.detail), true, cx);
328 let indicator = render_item_indicator(tab_match.item.boxed_clone(), cx);
329 let indicator_color = if let Some(ref indicator) = indicator {
330 indicator.color
331 } else {
332 Color::default()
333 };
334 let indicator = h_flex()
335 .flex_shrink_0()
336 .children(indicator)
337 .child(div().w_2())
338 .into_any_element();
339 let close_button = div()
340 // We need this on_mouse_up here instead of on_click on the close
341 // button because Picker intercepts the same events and handles them
342 // as click's on list items.
343 // See the same handler in Picker for more details.
344 .on_mouse_up(
345 MouseButton::Right,
346 cx.listener(move |picker, _: &MouseUpEvent, cx| {
347 cx.stop_propagation();
348 picker.delegate.close_item_at(ix, cx);
349 }),
350 )
351 .child(
352 IconButton::new("close_tab", IconName::Close)
353 .icon_size(IconSize::Small)
354 .icon_color(indicator_color)
355 .tooltip(|cx| Tooltip::text("Close", cx)),
356 )
357 .into_any_element();
358
359 Some(
360 ListItem::new(ix)
361 .spacing(ListItemSpacing::Sparse)
362 .inset(true)
363 .selected(selected)
364 .child(h_flex().w_full().child(label))
365 .map(|el| {
366 if self.selected_index == ix {
367 el.end_slot::<AnyElement>(close_button)
368 } else {
369 el.end_slot::<AnyElement>(indicator)
370 .end_hover_slot::<AnyElement>(close_button)
371 }
372 }),
373 )
374 }
375}