1use collections::CommandPaletteFilter;
2use fuzzy::{StringMatch, StringMatchCandidate};
3use gpui::{
4 actions, elements::*, keymap_matcher::Keystroke, Action, AppContext, Element, MouseState,
5 ViewContext, WindowContext,
6};
7use picker::{Picker, PickerDelegate, PickerEvent};
8use settings::Settings;
9use std::cmp;
10use util::ResultExt;
11use workspace::Workspace;
12
13pub fn init(cx: &mut AppContext) {
14 cx.add_action(toggle_command_palette);
15 CommandPalette::init(cx);
16}
17
18actions!(command_palette, [Toggle]);
19
20pub type CommandPalette = Picker<CommandPaletteDelegate>;
21
22pub struct CommandPaletteDelegate {
23 actions: Vec<Command>,
24 matches: Vec<StringMatch>,
25 selected_ix: usize,
26 focused_view_id: usize,
27}
28
29pub enum Event {
30 Dismissed,
31 Confirmed {
32 window_id: usize,
33 focused_view_id: usize,
34 action: Box<dyn Action>,
35 },
36}
37
38struct Command {
39 name: String,
40 action: Box<dyn Action>,
41 keystrokes: Vec<Keystroke>,
42}
43
44fn toggle_command_palette(_: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
45 let workspace = cx.handle();
46 let focused_view_id = cx.focused_view_id().unwrap_or_else(|| workspace.id());
47
48 cx.window_context().defer(move |cx| {
49 // Build the delegate before the workspace is put on the stack so we can find it when
50 // computing the actions. We should really not allow available_actions to be called
51 // if it's not reliable however.
52 let delegate = CommandPaletteDelegate::new(focused_view_id, cx);
53 workspace.update(cx, |workspace, cx| {
54 workspace.toggle_modal(cx, |_, cx| cx.add_view(|cx| Picker::new(delegate, cx)));
55 })
56 });
57}
58
59impl CommandPaletteDelegate {
60 pub fn new(focused_view_id: usize, cx: &mut WindowContext) -> Self {
61 let actions = cx
62 .available_actions(focused_view_id)
63 .filter_map(|(name, action, bindings)| {
64 if cx.has_global::<CommandPaletteFilter>() {
65 let filter = cx.global::<CommandPaletteFilter>();
66 if filter.filtered_namespaces.contains(action.namespace()) {
67 return None;
68 }
69 }
70
71 Some(Command {
72 name: humanize_action_name(name),
73 action,
74 keystrokes: bindings
75 .iter()
76 .map(|binding| binding.keystrokes())
77 .last()
78 .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
79 })
80 })
81 .collect();
82
83 Self {
84 actions,
85 matches: vec![],
86 selected_ix: 0,
87 focused_view_id,
88 }
89 }
90}
91
92impl PickerDelegate for CommandPaletteDelegate {
93 fn placeholder_text(&self) -> std::sync::Arc<str> {
94 "Execute a command...".into()
95 }
96
97 fn match_count(&self) -> usize {
98 self.matches.len()
99 }
100
101 fn selected_index(&self) -> usize {
102 self.selected_ix
103 }
104
105 fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Picker<Self>>) {
106 self.selected_ix = ix;
107 }
108
109 fn update_matches(
110 &mut self,
111 query: String,
112 cx: &mut ViewContext<Picker<Self>>,
113 ) -> gpui::Task<()> {
114 let candidates = self
115 .actions
116 .iter()
117 .enumerate()
118 .map(|(ix, command)| StringMatchCandidate {
119 id: ix,
120 string: command.name.to_string(),
121 char_bag: command.name.chars().collect(),
122 })
123 .collect::<Vec<_>>();
124 cx.spawn(move |picker, mut cx| async move {
125 let matches = if query.is_empty() {
126 candidates
127 .into_iter()
128 .enumerate()
129 .map(|(index, candidate)| StringMatch {
130 candidate_id: index,
131 string: candidate.string,
132 positions: Vec::new(),
133 score: 0.0,
134 })
135 .collect()
136 } else {
137 fuzzy::match_strings(
138 &candidates,
139 &query,
140 true,
141 10000,
142 &Default::default(),
143 cx.background(),
144 )
145 .await
146 };
147 picker
148 .update(&mut cx, |picker, _| {
149 let delegate = picker.delegate_mut();
150 delegate.matches = matches;
151 if delegate.matches.is_empty() {
152 delegate.selected_ix = 0;
153 } else {
154 delegate.selected_ix =
155 cmp::min(delegate.selected_ix, delegate.matches.len() - 1);
156 }
157 })
158 .log_err();
159 })
160 }
161
162 fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}
163
164 fn confirm(&mut self, cx: &mut ViewContext<Picker<Self>>) {
165 if !self.matches.is_empty() {
166 let window_id = cx.window_id();
167 let focused_view_id = self.focused_view_id;
168 let action_ix = self.matches[self.selected_ix].candidate_id;
169 let action = self.actions.remove(action_ix).action;
170 cx.app_context()
171 .spawn(move |mut cx| async move {
172 cx.dispatch_action(window_id, focused_view_id, action.as_ref())
173 })
174 .detach_and_log_err(cx);
175 }
176 cx.emit(PickerEvent::Dismiss);
177 }
178
179 fn render_match(
180 &self,
181 ix: usize,
182 mouse_state: &mut MouseState,
183 selected: bool,
184 cx: &gpui::AppContext,
185 ) -> AnyElement<Picker<Self>> {
186 let mat = &self.matches[ix];
187 let command = &self.actions[mat.candidate_id];
188 let settings = cx.global::<Settings>();
189 let theme = &settings.theme;
190 let style = theme.picker.item.style_for(mouse_state, selected);
191 let key_style = &theme.command_palette.key.style_for(mouse_state, selected);
192 let keystroke_spacing = theme.command_palette.keystroke_spacing;
193
194 Flex::row()
195 .with_child(
196 Label::new(mat.string.clone(), style.label.clone())
197 .with_highlights(mat.positions.clone()),
198 )
199 .with_children(command.keystrokes.iter().map(|keystroke| {
200 Flex::row()
201 .with_children(
202 [
203 (keystroke.ctrl, "^"),
204 (keystroke.alt, "⎇"),
205 (keystroke.cmd, "⌘"),
206 (keystroke.shift, "⇧"),
207 ]
208 .into_iter()
209 .filter_map(|(modifier, label)| {
210 if modifier {
211 Some(
212 Label::new(label, key_style.label.clone())
213 .contained()
214 .with_style(key_style.container),
215 )
216 } else {
217 None
218 }
219 }),
220 )
221 .with_child(
222 Label::new(keystroke.key.clone(), key_style.label.clone())
223 .contained()
224 .with_style(key_style.container),
225 )
226 .contained()
227 .with_margin_left(keystroke_spacing)
228 .flex_float()
229 }))
230 .contained()
231 .with_style(style.container)
232 .into_any()
233 }
234}
235
236fn humanize_action_name(name: &str) -> String {
237 let capacity = name.len() + name.chars().filter(|c| c.is_uppercase()).count();
238 let mut result = String::with_capacity(capacity);
239 for char in name.chars() {
240 if char == ':' {
241 if result.ends_with(':') {
242 result.push(' ');
243 } else {
244 result.push(':');
245 }
246 } else if char == '_' {
247 result.push(' ');
248 } else if char.is_uppercase() {
249 if !result.ends_with(' ') {
250 result.push(' ');
251 }
252 result.extend(char.to_lowercase());
253 } else {
254 result.push(char);
255 }
256 }
257 result
258}
259
260impl std::fmt::Debug for Command {
261 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
262 f.debug_struct("Command")
263 .field("name", &self.name)
264 .field("keystrokes", &self.keystrokes)
265 .finish()
266 }
267}
268
269#[cfg(test)]
270mod tests {
271 use super::*;
272 use editor::Editor;
273 use gpui::TestAppContext;
274 use project::Project;
275 use workspace::{AppState, Workspace};
276
277 #[test]
278 fn test_humanize_action_name() {
279 assert_eq!(
280 humanize_action_name("editor::GoToDefinition"),
281 "editor: go to definition"
282 );
283 assert_eq!(
284 humanize_action_name("editor::Backspace"),
285 "editor: backspace"
286 );
287 assert_eq!(
288 humanize_action_name("go_to_line::Deploy"),
289 "go to line: deploy"
290 );
291 }
292
293 #[gpui::test]
294 async fn test_command_palette(cx: &mut TestAppContext) {
295 let app_state = cx.update(AppState::test);
296
297 cx.update(|cx| {
298 editor::init(cx);
299 workspace::init(app_state.clone(), cx);
300 init(cx);
301 });
302
303 let project = Project::test(app_state.fs.clone(), [], cx).await;
304 let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
305 let editor = cx.add_view(&workspace, |cx| {
306 let mut editor = Editor::single_line(None, cx);
307 editor.set_text("abc", cx);
308 editor
309 });
310
311 workspace.update(cx, |workspace, cx| {
312 cx.focus(&editor);
313 workspace.add_item(Box::new(editor.clone()), cx)
314 });
315
316 workspace.update(cx, |workspace, cx| {
317 toggle_command_palette(workspace, &Toggle, cx);
318 });
319
320 let palette = workspace.read_with(cx, |workspace, _| {
321 workspace.modal::<CommandPalette>().unwrap()
322 });
323
324 palette
325 .update(cx, |palette, cx| {
326 palette
327 .delegate_mut()
328 .update_matches("bcksp".to_string(), cx)
329 })
330 .await;
331
332 palette.update(cx, |palette, cx| {
333 assert_eq!(palette.delegate().matches[0].string, "editor: backspace");
334 palette.confirm(&Default::default(), cx);
335 });
336
337 editor.read_with(cx, |editor, cx| {
338 assert_eq!(editor.text(cx), "ab");
339 });
340
341 // Add namespace filter, and redeploy the palette
342 cx.update(|cx| {
343 cx.update_default_global::<CommandPaletteFilter, _, _>(|filter, _| {
344 filter.filtered_namespaces.insert("editor");
345 })
346 });
347
348 workspace.update(cx, |workspace, cx| {
349 toggle_command_palette(workspace, &Toggle, cx);
350 });
351
352 // Assert editor command not present
353 let palette = workspace.read_with(cx, |workspace, _| {
354 workspace.modal::<CommandPalette>().unwrap()
355 });
356
357 palette
358 .update(cx, |palette, cx| {
359 palette
360 .delegate_mut()
361 .update_matches("bcksp".to_string(), cx)
362 })
363 .await;
364
365 palette.update(cx, |palette, _| {
366 assert!(palette.delegate().matches.is_empty())
367 });
368 }
369}