Turns the keybind in command pallet entry into button to keymap editor

Opens a keybind create modal if there was no keybind set for the command pallet entry.

Co-authored-by: Joseph T. Lyons <[email protected]>
Co-authored-by: Julia Ryan <[email protected]>

Author: 3 people

crates/command_palette/src/command_palette.rs

@@ -22,7 +22,9 @@ use persistence::COMMAND_PALETTE_HISTORY;
 use picker::{Picker, PickerDelegate};
 use postage::{sink::Sink, stream::Stream};
 use settings::Settings;
-use ui::{HighlightedLabel, KeyBinding, ListItem, ListItemSpacing, h_flex, prelude::*, v_flex};
+use ui::{
+    ButtonLike, HighlightedLabel, KeyBinding, ListItem, ListItemSpacing, h_flex, prelude::*, v_flex,
+};
 use util::ResultExt;
 use workspace::{ModalView, Workspace, WorkspaceSettings};
 use zed_actions::{OpenZedUrl, command_palette::Toggle};
@@ -448,6 +450,7 @@ impl PickerDelegate for CommandPaletteDelegate {
     ) -> Option<Self::ListItem> {
         let matching_command = self.matches.get(ix)?;
         let command = self.commands.get(matching_command.candidate_id)?;
+        let name = command.action.name();
         Some(
             ListItem::new(ix)
                 .inset(true)
@@ -462,12 +465,49 @@ impl PickerDelegate for CommandPaletteDelegate {
                             command.name.clone(),
                             matching_command.positions.clone(),
                         ))
-                        .children(KeyBinding::for_action_in(
-                            &*command.action,
-                            &self.previous_focus_handle,
-                            window,
-                            cx,
-                        )),
+                        .child(
+                            div().child(
+                                KeyBinding::for_action_in(
+                                    &*command.action,
+                                    &self.previous_focus_handle,
+                                    window,
+                                    cx,
+                                )
+                                .map(|keybind| {
+                                    ButtonLike::new(name)
+                                        .style(ButtonStyle::Transparent)
+                                        .child(keybind)
+                                        .tooltip(ui::Tooltip::text("Change key binding…"))
+                                        .on_click(|_, window, cx| {
+                                            window.dispatch_action(
+                                                zed_actions::OpenKeymapWithFilter {
+                                                    filter: name.to_string(),
+                                                }
+                                                .boxed_clone(),
+                                                cx,
+                                            );
+                                        })
+                                        .into_any_element()
+                                })
+                                .unwrap_or_else(|| {
+                                    IconButton::new(command.action.name(), IconName::Keyboard)
+                                        .style(ButtonStyle::Transparent)
+                                        .alpha(0.8)
+                                        .icon_size(IconSize::XSmall)
+                                        .tooltip(ui::Tooltip::text("Add key binding…"))
+                                        .on_click(|_, window, cx| {
+                                            window.dispatch_action(
+                                                zed_actions::OpenKeymapWithFilter {
+                                                    filter: name.to_string(),
+                                                }
+                                                .boxed_clone(),
+                                                cx,
+                                            );
+                                        })
+                                        .into_any_element()
+                                }),
+                            ),
+                        ),
                 ),
         )
     }

crates/keymap_editor/src/keymap_editor.rs

@@ -1,8 +1,10 @@
 use std::{
+    cell::RefCell,
     cmp::{self},
     ops::{Not as _, Range},
+    rc::Rc,
     sync::Arc,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 mod ui_components;
@@ -40,7 +42,7 @@ use workspace::{
 };
 
 pub use ui_components::*;
-use zed_actions::OpenKeymap;
+use zed_actions::{OpenKeymap, OpenKeymapWithFilter};
 
 use crate::{
     persistence::KEYBINDING_EDITORS,
@@ -79,37 +81,75 @@ pub fn init(cx: &mut App) {
     let keymap_event_channel = KeymapEventChannel::new();
     cx.set_global(keymap_event_channel);
 
-    cx.on_action(|_: &OpenKeymap, cx| {
+    fn common(filter: String, cx: &mut App) {
         workspace::with_active_or_new_workspace(cx, move |workspace, window, cx| {
             workspace
-                .with_local_workspace(window, cx, |workspace, window, cx| {
+                .with_local_workspace(window, cx, move |workspace, window, cx| {
                     let existing = workspace
                         .active_pane()
                         .read(cx)
                         .items()
                         .find_map(|item| item.downcast::<KeymapEditor>());
 
-                    if let Some(existing) = existing {
+                    let keymap_editor = if let Some(existing) = existing {
                         workspace.activate_item(&existing, true, true, window, cx);
+                        existing
                     } else {
                         let keymap_editor =
                             cx.new(|cx| KeymapEditor::new(workspace.weak_handle(), window, cx));
                         workspace.add_item_to_active_pane(
-                            Box::new(keymap_editor),
+                            Box::new(keymap_editor.clone()),
                             None,
                             true,
                             window,
                             cx,
                         );
-                    }
+                        keymap_editor
+                    };
+
+                    keymap_editor.update(cx, |editor, cx| {
+                        editor.filter_editor.update(cx, |editor, cx| {
+                            editor.clear(window, cx);
+                            editor.insert(&filter, window, cx);
+                        });
+                        if !editor.has_binding_for(&filter) {
+                            open_binding_modal_after_loading(cx)
+                        }
+                    })
                 })
                 .detach();
         })
-    });
+    }
+
+    cx.on_action(|_: &OpenKeymap, cx| common(String::new(), cx));
+    cx.on_action(|action: &OpenKeymapWithFilter, cx| common(action.filter.clone(), cx));
 
     register_serializable_item::<KeymapEditor>(cx);
 }
 
+fn open_binding_modal_after_loading(cx: &mut Context<KeymapEditor>) {
+    let started_at = Instant::now();
+    let observer = Rc::new(RefCell::new(None));
+    let handle = {
+        let observer = Rc::clone(&observer);
+        cx.observe(&cx.entity(), move |editor, _, cx| {
+            let subscription = observer.borrow_mut().take();
+
+            if started_at.elapsed().as_secs() > 10 {
+                return;
+            }
+            if !editor.matches.is_empty() {
+                editor.selected_index = Some(0);
+                cx.dispatch_action(&CreateBinding);
+                return;
+            }
+
+            *observer.borrow_mut() = subscription;
+        })
+    };
+    *observer.borrow_mut() = Some(handle);
+}
+
 pub struct KeymapEventChannel {}
 
 impl Global for KeymapEventChannel {}
@@ -1323,6 +1363,13 @@ impl KeymapEditor {
             editor.set_keystrokes(keystrokes, cx);
         });
     }
+
+    fn has_binding_for(&self, action_name: &str) -> bool {
+        self.keybindings
+            .iter()
+            .filter(|kb| kb.keystrokes().is_some())
+            .any(|kb| kb.action().name == action_name)
+    }
 }
 
 struct HumanizedActionNameCache {

crates/zed_actions/src/lib.rs

@@ -27,6 +27,13 @@ pub struct OpenZedUrl {
     pub url: String,
 }
 
+/// Opens the keymap editor.
+#[derive(PartialEq, Clone, Deserialize, Default, JsonSchema, Action)]
+#[action(namespace = zed)]
+pub struct OpenKeymapWithFilter {
+    pub filter: String,
+}
+
 actions!(
     zed,
     [