Add searchable command palette with nested menus and shared dispatch

This commit is contained in:
2026-11-17 01:29:05 -08:00
parent 7782c47b38
commit 79553a180e
5 changed files with 1473 additions and 67 deletions
+299
View File
@@ -0,0 +1,299 @@
//! Command metadata shared by the palette and workspace dispatch.
//!
//! Add an action and a registry entry here to expose a command. A shortcut is
//! optional; menus use the same item model and may be nested to any depth.
use crate::protocol::{ScrollKind, Snapshot};
#[derive(Clone, Debug)]
pub enum CommandAction {
NewTab,
SplitPane,
ClosePane,
RenamePane,
ResetPaneName,
Copy,
Paste,
PreviousTab,
NextTab,
PreviousPane,
NextPane,
FocusLeft,
FocusRight,
FocusTab(u64),
FocusPane(u64),
Scroll(ScrollKind),
Detach,
}
#[derive(Clone, Debug)]
pub enum PaletteItemKind {
Action(CommandAction),
Menu(Vec<PaletteItem>),
}
#[derive(Clone, Debug)]
pub struct PaletteItem {
/// Stable across snapshots, so open submenus survive background updates.
pub id: String,
pub title: String,
pub keywords: String,
pub shortcut: Option<&'static str>,
pub enabled: bool,
pub kind: PaletteItemKind,
}
impl PaletteItem {
pub fn action(
id: impl Into<String>,
title: impl Into<String>,
keywords: impl Into<String>,
shortcut: Option<&'static str>,
action: CommandAction,
) -> Self {
Self {
id: id.into(),
title: title.into(),
keywords: keywords.into(),
shortcut,
enabled: true,
kind: PaletteItemKind::Action(action),
}
}
pub fn menu(
id: impl Into<String>,
title: impl Into<String>,
keywords: impl Into<String>,
items: Vec<Self>,
) -> Self {
Self {
id: id.into(),
title: title.into(),
keywords: keywords.into(),
shortcut: None,
enabled: !items.is_empty(),
kind: PaletteItemKind::Menu(items),
}
}
fn available(mut self, enabled: bool) -> Self {
self.enabled = enabled;
self
}
}
/// The complete command list. UI state affects availability, never discovery.
pub fn root_items(snapshot: Option<&Snapshot>) -> Vec<PaletteItem> {
use CommandAction::*;
let pane = snapshot.is_some_and(|s| !s.panes.is_empty());
let tabs = snapshot.is_some_and(|s| !s.tabs.is_empty());
let mut items = vec![
PaletteItem::action(
"new-tab",
"New tab",
"create shell terminal",
Some("Ctrl+Shift+T"),
NewTab,
),
PaletteItem::action(
"split-pane",
"Split pane right",
"new create horizontal shell",
Some("Ctrl+Shift+D"),
SplitPane,
)
.available(pane),
PaletteItem::action(
"close-pane",
"Close pane",
"exit shell terminate",
Some("Ctrl+Shift+W"),
ClosePane,
)
.available(pane),
PaletteItem::action(
"rename-pane",
"Rename pane",
"name title label",
Some("Ctrl+Shift+R"),
RenamePane,
)
.available(pane),
PaletteItem::action(
"reset-pane-name",
"Use automatic pane name",
"reset rename title cwd directory",
None,
ResetPaneName,
)
.available(pane),
PaletteItem::action(
"previous-tab",
"Previous tab",
"switch navigate left",
None,
PreviousTab,
)
.available(tabs),
PaletteItem::action(
"next-tab",
"Next tab",
"switch navigate right",
None,
NextTab,
)
.available(tabs),
PaletteItem::action(
"previous-pane",
"Previous pane",
"switch focus cycle",
Some("Ctrl+Shift+Left"),
PreviousPane,
)
.available(pane),
PaletteItem::action(
"next-pane",
"Next pane",
"switch focus cycle",
Some("Ctrl+Shift+Right"),
NextPane,
)
.available(pane),
PaletteItem::action(
"focus-left",
"Focus pane or tab left",
"navigate previous horizontal",
None,
FocusLeft,
)
.available(pane),
PaletteItem::action(
"focus-right",
"Focus pane or tab right",
"navigate next horizontal",
None,
FocusRight,
)
.available(pane),
PaletteItem::action(
"copy",
"Copy selection",
"clipboard text",
Some("Ctrl+Shift+C"),
Copy,
)
.available(pane),
PaletteItem::action(
"paste",
"Paste",
"clipboard text",
Some("Ctrl+Shift+V"),
Paste,
)
.available(pane),
PaletteItem::action(
"history-page-up",
"Scroll history up one page",
"scrollback previous page",
Some("Shift+PageUp"),
Scroll(ScrollKind::PageUp),
)
.available(pane),
PaletteItem::action(
"history-page-down",
"Scroll history down one page",
"scrollback next page",
Some("Shift+PageDown"),
Scroll(ScrollKind::PageDown),
)
.available(pane),
PaletteItem::action(
"history-top",
"Go to oldest history",
"scrollback top beginning",
Some("Shift+Home"),
Scroll(ScrollKind::Top),
)
.available(pane),
PaletteItem::action(
"history-bottom",
"Return to live terminal",
"scrollback bottom latest end",
Some("Shift+End"),
Scroll(ScrollKind::Bottom),
)
.available(pane),
PaletteItem::action(
"detach",
"Detach window",
"close window keep sessions running",
None,
Detach,
),
];
let tab_items = snapshot
.into_iter()
.flat_map(|snapshot| snapshot.tabs.iter())
.enumerate()
.map(|(index, tab)| {
PaletteItem::action(
format!("tab-{}", tab.id),
format!("{} {}", index + 1, tab.title),
"switch focus tab",
None,
FocusTab(tab.id),
)
})
.collect();
let pane_items = snapshot
.into_iter()
.flat_map(|snapshot| snapshot.panes.iter())
.enumerate()
.map(|(index, pane)| {
PaletteItem::action(
format!("pane-{}", pane.id),
format!("{} {}", index + 1, pane.title),
"switch focus pane",
None,
FocusPane(pane.id),
)
})
.collect();
items.insert(
5,
PaletteItem::menu(
"switch-tab",
"Switch to tab…",
"navigate focus tabs",
tab_items,
),
);
items.insert(
6,
PaletteItem::menu(
"focus-pane",
"Focus pane…",
"navigate switch panes",
pane_items,
),
);
items
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty_workspace_keeps_commands_discoverable_without_unsafe_actions() {
let items = root_items(None);
let find = |id: &str| items.iter().find(|item| item.id == id).unwrap();
assert!(find("new-tab").enabled);
assert!(find("detach").enabled);
assert!(!find("close-pane").enabled);
assert!(!find("switch-tab").enabled);
assert!(find("reset-pane-name").shortcut.is_none());
let unique: std::collections::HashSet<_> = items.iter().map(|item| &item.id).collect();
assert_eq!(unique.len(), items.len());
}
}
+2
View File
@@ -1,11 +1,13 @@
mod chrome;
mod client;
mod colors;
mod commands;
mod cursor;
mod fonts;
mod input;
mod label;
mod launcher;
mod palette;
mod pane_name;
mod protocol;
mod render;
+943
View File
@@ -0,0 +1,943 @@
//! Searchable command launcher with nested menus and isolated text input.
use std::ops::Range;
use gpui::{
App, Bounds, ClipboardItem, ContentMask, Context, CursorStyle, Div, ElementId,
ElementInputHandler, EntityInputHandler, FocusHandle, Focusable, KeyDownEvent, MouseButton,
MouseDownEvent, MouseMoveEvent, Pixels, Point, Render, ScrollHandle, ShapedLine, TextRun,
UTF16Selection, UnderlineStyle, Window, canvas, div, fill, font, point, prelude::*, px,
relative, rgb, rgba, size,
};
use crate::{
chrome,
commands::{CommandAction, PaletteItem, PaletteItemKind},
pane_name::NameEditor,
};
#[derive(Clone)]
struct Match {
item: PaletteItem,
path: Vec<String>,
context: String,
score: i64,
}
struct PaletteModel {
items: Vec<PaletteItem>,
path: Vec<String>,
query: String,
matches: Vec<Match>,
selected: usize,
}
impl PaletteModel {
fn new(items: Vec<PaletteItem>) -> Self {
let mut model = Self {
items,
path: Vec::new(),
query: String::new(),
matches: Vec::new(),
selected: 0,
};
model.refresh(false);
model
}
fn set_items(&mut self, items: Vec<PaletteItem>) {
self.items = items;
while !self.path.is_empty() && items_at_path(&self.items, &self.path).is_none() {
self.path.pop();
}
self.refresh(true);
}
fn set_query(&mut self, query: String) {
if self.query != query {
self.query = query;
self.selected = 0;
self.refresh(false);
}
}
fn refresh(&mut self, keep_selection: bool) {
let selected_path = keep_selection
.then(|| {
self.matches
.get(self.selected)
.map(|item| item.path.clone())
})
.flatten();
let items = items_at_path(&self.items, &self.path).unwrap_or(&self.items);
let mut matches = Vec::new();
gather_matches(items, &self.path, &[], &self.query, &mut matches);
if !self.query.trim().is_empty() {
matches.sort_by_key(|item| std::cmp::Reverse(item.score));
}
self.matches = matches;
self.selected = selected_path
.and_then(|path| self.matches.iter().position(|item| item.path == path))
.unwrap_or(self.selected)
.min(self.matches.len().saturating_sub(1));
}
fn move_selection(&mut self, delta: isize) {
if !self.matches.is_empty() {
self.selected =
(self.selected as isize + delta).rem_euclid(self.matches.len() as isize) as usize;
}
}
fn activate(&mut self) -> Option<CommandAction> {
let result = self.matches.get(self.selected)?;
if !result.item.enabled {
return None;
}
match &result.item.kind {
PaletteItemKind::Action(action) => Some(action.clone()),
PaletteItemKind::Menu(_) => {
self.path = result.path.clone();
self.query.clear();
self.selected = 0;
self.refresh(false);
None
}
}
}
fn go_to_depth(&mut self, depth: usize) {
self.path.truncate(depth);
self.query.clear();
self.selected = 0;
self.refresh(false);
}
fn back(&mut self) -> bool {
if self.path.is_empty() {
false
} else {
self.go_to_depth(self.path.len() - 1);
true
}
}
fn breadcrumbs(&self) -> Vec<String> {
let mut labels = Vec::new();
let mut items = self.items.as_slice();
for id in &self.path {
let Some(item) = items.iter().find(|item| &item.id == id) else {
break;
};
labels.push(item.title.trim_end_matches('…').to_owned());
if let PaletteItemKind::Menu(children) = &item.kind {
items = children;
}
}
labels
}
}
fn items_at_path<'a>(items: &'a [PaletteItem], path: &[String]) -> Option<&'a [PaletteItem]> {
let mut items = items;
for id in path {
let item = items.iter().find(|item| &item.id == id)?;
let PaletteItemKind::Menu(children) = &item.kind else {
return None;
};
items = children;
}
Some(items)
}
fn gather_matches(
items: &[PaletteItem],
parent_path: &[String],
ancestors: &[String],
query: &str,
output: &mut Vec<Match>,
) {
let searching = !query.trim().is_empty();
for item in items {
let mut path = parent_path.to_vec();
path.push(item.id.clone());
let context = ancestors.join(" › ");
let keywords = format!("{} {}", item.keywords, context);
if let Some(score) = match_score(query, &item.title, &keywords) {
output.push(Match {
item: item.clone(),
path: path.clone(),
context,
score,
});
}
if searching && let PaletteItemKind::Menu(children) = &item.kind {
let mut ancestors = ancestors.to_vec();
ancestors.push(item.title.trim_end_matches('…').to_owned());
gather_matches(children, &path, &ancestors, query, output);
}
}
}
fn match_score(query: &str, title: &str, keywords: &str) -> Option<i64> {
let title = title.to_lowercase();
let keywords = keywords.to_lowercase();
let mut score = 0;
for word in query.to_lowercase().split_whitespace() {
score += if let Some(score) = word_score(word, &title) {
score + 1_000
} else {
word_score(word, &keywords)?
};
}
Some(score)
}
fn word_score(word: &str, text: &str) -> Option<i64> {
if word == text {
return Some(10_000);
}
if let Some(index) = text.find(word) {
let boundary = index == 0
|| text[..index]
.chars()
.next_back()
.is_some_and(|c| !c.is_alphanumeric());
return Some(500 + if boundary { 100 } else { 0 } - index as i64);
}
let mut characters = text.chars().enumerate();
let mut previous = None;
let mut score = 0;
for wanted in word.chars() {
let (index, _) = characters.find(|&(_, character)| character == wanted)?;
if previous.is_some_and(|previous| previous + 1 == index) {
score += 12;
} else {
score -= index as i64 - previous.map_or(0, |previous| previous as i64);
}
previous = Some(index);
}
Some(score)
}
const INPUT_HEIGHT: f32 = 40.;
const INPUT_PADDING: f32 = 12.;
const INPUT_TEXT_SIZE: f32 = 15.;
type Finish = Box<dyn Fn(Option<CommandAction>, &mut Window, &mut App)>;
/// An overlay whose entire key and pointer surface is separate from PTY input.
pub struct CommandPalette {
model: PaletteModel,
editor: NameEditor,
focus: FocusHandle,
on_finish: Finish,
query_bounds: Bounds<Pixels>,
query_line: Option<ShapedLine>,
query_scroll: Pixels,
selecting: bool,
results_scroll: ScrollHandle,
}
impl CommandPalette {
pub fn new(
items: Vec<PaletteItem>,
on_finish: impl Fn(Option<CommandAction>, &mut Window, &mut App) + 'static,
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
let focus = cx.focus_handle();
window.focus(&focus);
Self {
model: PaletteModel::new(items),
editor: NameEditor::new(""),
focus,
on_finish: Box::new(on_finish),
query_bounds: Bounds::default(),
query_line: None,
query_scroll: px(0.),
selecting: false,
results_scroll: ScrollHandle::new(),
}
}
pub fn focus(&self, window: &mut Window) {
window.focus(&self.focus);
}
pub fn set_items(&mut self, items: Vec<PaletteItem>, cx: &mut Context<Self>) {
self.model.set_items(items);
cx.notify();
}
fn query_changed(&mut self, cx: &mut Context<Self>) {
if self.model.query != self.editor.text {
self.model.set_query(self.editor.text.clone());
self.results_scroll.set_offset(point(px(0.), px(0.)));
}
cx.notify();
}
fn activate(&mut self, window: &mut Window, cx: &mut Context<Self>) {
if let Some(action) = self.model.activate() {
(self.on_finish)(Some(action), window, cx);
} else {
if self.editor.text != self.model.query {
self.editor = NameEditor::new(&self.model.query);
}
self.results_scroll.scroll_to_item(self.model.selected);
cx.notify();
}
}
fn go_to_depth(&mut self, depth: usize, cx: &mut Context<Self>) {
self.model.go_to_depth(depth);
self.editor = NameEditor::new("");
self.results_scroll.set_offset(point(px(0.), px(0.)));
cx.notify();
}
fn back(&mut self, window: &mut Window, cx: &mut Context<Self>) {
if self.model.back() {
self.editor = NameEditor::new("");
self.results_scroll.set_offset(point(px(0.), px(0.)));
cx.notify();
} else {
(self.on_finish)(None, window, cx);
}
}
fn key_down(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
cx.stop_propagation();
let key = &event.keystroke;
let primary = key.modifiers.control || key.modifiers.platform;
match key.key.as_str() {
"escape" => {
self.back(window, cx);
return;
}
"enter" => {
if self.editor.marked_utf16().is_some() {
self.editor.unmark();
cx.notify();
} else {
self.activate(window, cx);
}
return;
}
"up" | "down" | "tab" => {
let delta = if key.key == "up" || key.key == "tab" && key.modifiers.shift {
-1
} else {
1
};
self.model.move_selection(delta);
self.results_scroll.scroll_to_item(self.model.selected);
cx.notify();
return;
}
"pageup" | "pagedown" => {
self.model
.move_selection(if key.key == "pageup" { -8 } else { 8 });
self.results_scroll.scroll_to_item(self.model.selected);
cx.notify();
return;
}
"left" if key.modifiers.alt => {
self.back(window, cx);
return;
}
"left" => self.editor.left(key.modifiers.shift),
"right" => self.editor.right(key.modifiers.shift),
"home" => self.editor.home(key.modifiers.shift),
"end" => self.editor.end(key.modifiers.shift),
"backspace" => self.editor.backspace(),
"delete" => self.editor.delete(),
_ if primary && !key.modifiers.alt => match key.key.to_lowercase().as_str() {
"a" => self.editor.select_all(),
"c" | "x" => {
let selection = self.editor.selection();
if !selection.is_empty() {
cx.write_to_clipboard(ClipboardItem::new_string(
self.editor.text[selection].to_owned(),
));
if key.key.eq_ignore_ascii_case("x") {
self.editor.replace(None, "");
}
}
}
"v" => {
if let Some(text) = cx.read_from_clipboard().and_then(|item| item.text()) {
self.editor.replace(None, &text);
}
}
_ => {}
},
_ if !primary && !key.modifiers.alt => {
if let Some(text) = &key.key_char {
self.editor.replace(None, text);
}
}
_ => {}
}
self.query_changed(cx);
}
fn query_index(&self, position: Point<Pixels>) -> usize {
if self.editor.text.is_empty() {
return 0;
}
self.query_line.as_ref().map_or(0, |line| {
line.closest_index_for_x(
position.x - self.query_bounds.left() - px(INPUT_PADDING) + self.query_scroll,
)
})
}
fn query_mouse_down(
&mut self,
event: &MouseDownEvent,
window: &mut Window,
cx: &mut Context<Self>,
) {
cx.stop_propagation();
self.focus(window);
if event.click_count > 1 {
self.editor.select_all();
} else {
self.editor
.set_cursor(self.query_index(event.position), event.modifiers.shift);
}
self.selecting = true;
cx.notify();
}
fn prepare_query(&mut self, bounds: Bounds<Pixels>, window: &mut Window) {
self.query_bounds = bounds;
let empty = self.editor.text.is_empty();
let text = if empty {
"Search commands…"
} else {
&self.editor.text
};
let default = TextRun {
len: text.len(),
font: font(".SystemUIFont"),
color: rgb(if empty { chrome::MUTED } else { chrome::TEXT }).into(),
background_color: None,
underline: None,
strikethrough: None,
};
let runs = if let Some(marked) = self.editor.marked_utf16() {
let start = self.editor.byte_offset_for_utf16(marked.start);
let end = self.editor.byte_offset_for_utf16(marked.end);
[
(0..start, false),
(start..end, true),
(end..text.len(), false),
]
.into_iter()
.filter(|(range, _)| !range.is_empty())
.map(|(range, marked)| TextRun {
len: range.len(),
underline: marked.then_some(UnderlineStyle {
thickness: px(1.),
color: None,
wavy: false,
}),
..default.clone()
})
.collect()
} else {
vec![default]
};
let line = window.text_system().shape_line(
text.to_owned().into(),
px(INPUT_TEXT_SIZE),
&runs,
None,
);
let caret = if empty {
px(0.)
} else {
line.x_for_index(self.editor.cursor())
};
let width = (bounds.size.width - px(INPUT_PADDING * 2. + 1.)).max(px(1.));
if caret - self.query_scroll > width {
self.query_scroll = caret - width;
} else if caret < self.query_scroll {
self.query_scroll = caret;
}
if empty {
self.query_scroll = px(0.);
}
self.query_line = Some(line);
}
fn query_field(&self, cx: &mut Context<Self>) -> Div {
let prepare = cx.entity();
let paint = cx.entity();
div()
.w_full()
.h(px(INPUT_HEIGHT))
.flex_shrink_0()
.bg(rgb(chrome::CONTROL_BACKGROUND))
.border_b_1()
.border_color(rgb(chrome::BORDER))
.cursor(CursorStyle::IBeam)
.on_mouse_down(MouseButton::Left, cx.listener(Self::query_mouse_down))
.on_mouse_move(cx.listener(|palette, event: &MouseMoveEvent, _, cx| {
if palette.selecting && event.dragging() {
palette
.editor
.set_cursor(palette.query_index(event.position), true);
cx.stop_propagation();
cx.notify();
}
}))
.on_mouse_up(
MouseButton::Left,
cx.listener(|palette, _, _, cx| {
palette.selecting = false;
cx.stop_propagation();
}),
)
.on_mouse_up_out(
MouseButton::Left,
cx.listener(|palette, _, _, _| palette.selecting = false),
)
.child(
canvas(
move |bounds, window, cx| {
prepare.update(cx, |palette, _| palette.prepare_query(bounds, window))
},
move |bounds, (), window, cx| {
let palette = paint.read(cx);
let focus = palette.focus.clone();
let line = palette.query_line.clone();
let selection = palette.editor.selection();
let caret = palette.editor.cursor();
let empty = palette.editor.text.is_empty();
let origin =
bounds.origin + point(px(INPUT_PADDING) - palette.query_scroll, px(0.));
window.handle_input(
&focus,
ElementInputHandler::new(bounds, paint.clone()),
cx,
);
if let Some(line) = line {
window.with_content_mask(Some(ContentMask { bounds }), |window| {
if !selection.is_empty() {
let start = line.x_for_index(selection.start);
let end = line.x_for_index(selection.end);
window.paint_quad(fill(
Bounds::new(
origin + point(start, px(6.)),
size(end - start, bounds.size.height - px(12.)),
),
rgb(chrome::BORDER),
));
}
let _ = line.paint(origin, bounds.size.height, window, cx);
if focus.is_focused(window) {
let x = if empty {
px(0.)
} else {
line.x_for_index(caret)
};
window.paint_quad(fill(
Bounds::new(
origin + point(x, px(10.)),
size(px(1.), bounds.size.height - px(20.)),
),
rgb(chrome::PANE_FOCUS),
));
}
});
}
},
)
.size_full(),
)
}
}
impl Focusable for CommandPalette {
fn focus_handle(&self, _: &App) -> FocusHandle {
self.focus.clone()
}
}
impl Render for CommandPalette {
fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let mut breadcrumbs = div()
.flex()
.items_center()
.gap(px(6.))
.h(px(32.))
.px(px(12.))
.flex_shrink_0()
.text_size(px(11.))
.text_color(rgb(chrome::MUTED))
.child(
div()
.id("palette-root")
.cursor_pointer()
.text_color(rgb(chrome::PANE_FOCUS))
.on_click(cx.listener(|palette, _, _, cx| palette.go_to_depth(0, cx)))
.child("Commands"),
);
for (index, title) in self.model.breadcrumbs().into_iter().enumerate() {
breadcrumbs = breadcrumbs.child("›").child(
div()
.id(ElementId::Name(format!("palette-crumb-{index}").into()))
.min_w_0()
.text_ellipsis()
.cursor_pointer()
.on_click(
cx.listener(move |palette, _, _, cx| palette.go_to_depth(index + 1, cx)),
)
.child(title),
);
}
let mut results = div()
.id("palette-results")
.w_full()
.min_h_0()
.max_h(px(336.))
.overflow_y_scroll()
.track_scroll(&self.results_scroll);
if self.model.matches.is_empty() {
results = results.child(
div()
.p(px(16.))
.text_color(rgb(chrome::MUTED))
.child("No matching commands"),
);
}
for (index, matched) in self.model.matches.iter().enumerate() {
let selected = index == self.model.selected;
let enabled = matched.item.enabled;
let menu = matches!(matched.item.kind, PaletteItemKind::Menu(_));
let mut title = div()
.flex_1()
.min_w_0()
.flex()
.flex_col()
.justify_center()
.child(
div()
.min_w_0()
.text_ellipsis()
.child(matched.item.title.clone()),
);
if !matched.context.is_empty() {
title = title.child(
div()
.text_size(px(10.))
.text_color(rgb(chrome::MUTED))
.text_ellipsis()
.child(matched.context.clone()),
);
}
let mut row = div()
.id(ElementId::Name(
format!("palette-item-{}", matched.path.join("/")).into(),
))
.h(px(42.))
.w_full()
.flex()
.items_center()
.gap(px(12.))
.px(px(12.))
.border_l_2()
.border_color(rgb(if selected {
chrome::PANE_FOCUS
} else {
chrome::PANEL_BACKGROUND
}))
.bg(rgb(if selected {
chrome::HOVER_BACKGROUND
} else {
chrome::PANEL_BACKGROUND
}))
.text_color(rgb(if enabled { chrome::TEXT } else { chrome::MUTED }))
.cursor_pointer()
.on_hover(cx.listener(move |palette, hovered, _, cx| {
if *hovered && palette.model.selected != index {
palette.model.selected = index;
cx.notify();
}
}))
.on_click(cx.listener(move |palette, _, window, cx| {
cx.stop_propagation();
palette.model.selected = index;
palette.activate(window, cx);
}))
.child(title);
if let Some(shortcut) = matched.item.shortcut {
row = row.child(
div()
.flex_shrink_0()
.text_size(px(10.))
.text_color(rgb(chrome::MUTED))
.child(shortcut),
);
}
if menu {
row = row.child(
div()
.flex_shrink_0()
.text_color(rgb(chrome::PANE_FOCUS))
.child("›"),
);
}
results = results.child(row);
}
let hint = if self
.model
.matches
.get(self.model.selected)
.is_some_and(|item| !item.item.enabled)
{
"Unavailable in this workspace"
} else if self
.model
.matches
.get(self.model.selected)
.is_some_and(|item| matches!(item.item.kind, PaletteItemKind::Menu(_)))
{
"↑↓ Select Enter Open Esc Back"
} else {
"↑↓ Select Enter Run Esc Back"
};
let query = self.query_field(cx);
let panel = div()
.w(px(620.))
.max_w(relative(0.9))
.max_h(relative(0.85))
.flex()
.flex_col()
.min_h_0()
.overflow_hidden()
.border_1()
.border_color(rgb(chrome::PANE_FOCUS))
.bg(rgb(chrome::PANEL_BACKGROUND))
.shadow_lg()
.font_family(".SystemUIFont")
.text_size(px(13.))
.text_color(rgb(chrome::TEXT))
.on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
.child(breadcrumbs)
.child(query)
.child(results)
.child(
div()
.h(px(30.))
.flex_shrink_0()
.flex()
.items_center()
.px(px(12.))
.border_t_1()
.border_color(rgb(chrome::BORDER))
.text_size(px(10.))
.text_color(rgb(chrome::MUTED))
.child(hint),
);
div()
.absolute()
.inset_0()
.flex()
.justify_center()
.items_start()
.pt(px(64.))
.bg(rgba(0x00000066))
.track_focus(&self.focus)
.on_key_down(cx.listener(Self::key_down))
.on_mouse_down(
MouseButton::Left,
cx.listener(|palette, _, window, cx| {
cx.stop_propagation();
(palette.on_finish)(None, window, cx);
}),
)
.on_scroll_wheel(|_, _, cx| cx.stop_propagation())
.child(panel)
}
}
impl EntityInputHandler for CommandPalette {
fn text_for_range(
&mut self,
range: Range<usize>,
actual: &mut Option<Range<usize>>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<String> {
let (text, range) = self.editor.text_for_range(range);
*actual = Some(range);
Some(text)
}
fn selected_text_range(
&mut self,
_: bool,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<UTF16Selection> {
Some(UTF16Selection {
range: self.editor.selection_utf16(),
reversed: self.editor.reversed(),
})
}
fn marked_text_range(&self, _: &mut Window, _: &mut Context<Self>) -> Option<Range<usize>> {
self.editor.marked_utf16()
}
fn unmark_text(&mut self, _: &mut Window, cx: &mut Context<Self>) {
self.editor.unmark();
cx.notify();
}
fn replace_text_in_range(
&mut self,
range: Option<Range<usize>>,
text: &str,
_: &mut Window,
cx: &mut Context<Self>,
) {
self.editor.replace(range, text);
self.query_changed(cx);
}
fn replace_and_mark_text_in_range(
&mut self,
range: Option<Range<usize>>,
text: &str,
selected: Option<Range<usize>>,
_: &mut Window,
cx: &mut Context<Self>,
) {
self.editor.replace_and_mark(range, text, selected);
self.query_changed(cx);
}
fn bounds_for_range(
&mut self,
range: Range<usize>,
_: Bounds<Pixels>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<Bounds<Pixels>> {
let line = self.query_line.as_ref()?;
let start = line.x_for_index(self.editor.byte_offset_for_utf16(range.start));
let end = line.x_for_index(self.editor.byte_offset_for_utf16(range.end));
Some(Bounds::new(
self.query_bounds.origin + point(px(INPUT_PADDING) - self.query_scroll + start, px(0.)),
size((end - start).max(px(1.)), self.query_bounds.size.height),
))
}
fn character_index_for_point(
&mut self,
position: Point<Pixels>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<usize> {
Some(
self.editor
.utf16_offset_for_byte(self.query_index(position)),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn fixture() -> Vec<PaletteItem> {
vec![
PaletteItem::action(
"new",
"New tab",
"create terminal",
None,
CommandAction::NewTab,
),
PaletteItem::action(
"rename",
"Rename pane",
"title name",
None,
CommandAction::RenamePane,
),
PaletteItem::menu(
"tabs",
"Switch to tab…",
"tabs",
vec![
PaletteItem::action("tab-2", "Codex", "work", None, CommandAction::FocusTab(2)),
PaletteItem::action(
"tab-5",
"日本語",
"notes",
None,
CommandAction::FocusTab(5),
),
],
),
]
}
#[test]
fn matching_accepts_keywords_and_subsequences_but_ranks_direct_titles_first() {
assert!(match_score("rnp", "Rename pane", "").is_some());
assert!(match_score("create", "New tab", "create terminal").is_some());
assert!(match_score("pane rename", "Rename pane", "").is_some());
assert!(match_score("missing", "New tab", "create terminal").is_none());
assert!(
match_score("tab", "Tab", "").unwrap() > match_score("tab", "New tab", "").unwrap()
);
assert!(match_score("日本", "日本語", "").is_some());
}
#[test]
fn search_reaches_nested_commands_and_escape_restores_parent() {
let mut model = PaletteModel::new(fixture());
model.set_query("codex".into());
assert_eq!(model.matches.len(), 1);
assert_eq!(model.matches[0].context, "Switch to tab");
assert!(matches!(model.activate(), Some(CommandAction::FocusTab(2))));
model.set_query(String::new());
model.selected = 2;
assert!(model.activate().is_none());
assert_eq!(model.path, vec!["tabs"]);
assert_eq!(model.matches.len(), 2);
assert!(model.back());
assert!(!model.back());
assert_eq!(model.matches.len(), 3);
}
#[test]
fn snapshots_keep_query_selection_and_submenu_by_stable_ids() {
let mut model = PaletteModel::new(fixture());
model.selected = 2;
model.activate();
model.move_selection(1);
model.set_items(fixture());
assert_eq!(model.matches[model.selected].item.id, "tab-5");
model.set_query("日本".into());
model.set_items(fixture());
assert_eq!(model.query, "日本");
assert_eq!(model.path, vec!["tabs"]);
assert_eq!(model.matches[model.selected].item.id, "tab-5");
model.set_items(Vec::new());
assert!(model.path.is_empty());
assert!(model.matches.is_empty());
}
#[test]
fn disabled_commands_never_execute_and_empty_navigation_is_safe() {
let mut items = fixture();
items[0].enabled = false;
let mut model = PaletteModel::new(items);
assert!(model.activate().is_none());
model.move_selection(-1);
assert_eq!(model.selected, 2);
model.set_query("unmatched".into());
model.move_selection(1);
assert!(model.activate().is_none());
}
}
+216 -66
View File
@@ -3,9 +3,11 @@ use crate::{
chrome,
client::{Client, Updates},
colors,
commands::{self, CommandAction},
cursor::CursorAnimator,
input,
label::middle_label,
palette::CommandPalette,
pane_name::RenameField,
protocol::{
ClientMessage, PaneSnapshot, ScrollKind, SelectionCommand, SelectionKind, SelectionSide,
@@ -33,12 +35,205 @@ pub struct Workspace {
snapshot: Option<Arc<Snapshot>>,
panes: HashMap<u64, Entity<TerminalPane>>,
error: Option<String>,
focus: FocusHandle,
palette: Option<Entity<CommandPalette>>,
outgoing: Vec<Entity<TerminalPane>>,
transition: Option<Slide>,
transition_frame_pending: bool,
_updates: Task<()>,
}
impl Workspace {
fn focused_pane(&self) -> Option<Entity<TerminalPane>> {
let snapshot = self.snapshot.as_ref()?;
let tab = snapshot
.tabs
.iter()
.find(|tab| tab.id == snapshot.active_tab)?;
self.panes.get(&tab.active_pane).cloned()
}
fn restore_focus(&self, window: &mut Window, cx: &mut Context<Self>) {
if let Some(pane) = self.focused_pane() {
window.focus(&pane.read(cx).focus);
} else {
window.focus(&self.focus);
}
}
fn close_palette(&mut self, window: &mut Window, cx: &mut Context<Self>) {
self.palette = None;
self.restore_focus(window, cx);
cx.notify();
}
fn open_palette(&mut self, window: &mut Window, cx: &mut Context<Self>) {
if self.palette.is_some() {
self.close_palette(window, cx);
return;
}
for pane in self.panes.values() {
pane.update(cx, |pane, cx| {
pane.rename = None;
pane.selecting = false;
pane.preedit.clear();
cx.notify();
});
}
let items = commands::root_items(self.snapshot.as_deref());
let owner = cx.weak_entity();
self.palette = Some(cx.new(|cx| {
CommandPalette::new(
items,
move |action, window, cx| {
let _ = owner.update(cx, |view, cx| {
view.close_palette(window, cx);
if let Some(action) = action {
view.execute(action, window, cx);
}
});
},
window,
cx,
)
}));
cx.notify();
}
fn key_down(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
let key = &event.keystroke;
let command = (key.modifiers.control || key.modifiers.platform)
&& key.modifiers.shift
&& !key.modifiers.alt;
if command && key.key.eq_ignore_ascii_case("p") {
self.open_palette(window, cx);
cx.stop_propagation();
return;
}
if self.palette.is_some()
|| self
.focused_pane()
.is_some_and(|pane| pane.read(cx).rename.is_some())
{
return;
}
let action = if command {
match key.key.to_lowercase().as_str() {
"t" => Some(CommandAction::NewTab),
"d" => Some(CommandAction::SplitPane),
"w" => Some(CommandAction::ClosePane),
"r" => Some(CommandAction::RenamePane),
"c" => Some(CommandAction::Copy),
"v" => Some(CommandAction::Paste),
"left" => Some(CommandAction::PreviousPane),
"right" => Some(CommandAction::NextPane),
_ => None,
}
} else {
None
};
if let Some(action) = action {
self.execute(action, window, cx);
cx.stop_propagation();
}
}
fn execute(&mut self, action: CommandAction, window: &mut Window, cx: &mut Context<Self>) {
use CommandAction::*;
let pane = self.focused_pane();
let pane_id = pane.as_ref().map(|pane| pane.read(cx).data().id);
let message = match action {
NewTab => Some(ClientMessage::NewTab { cwd: None }),
SplitPane => pane_id.map(|pane| ClientMessage::Split { pane, cwd: None }),
ClosePane => pane_id.map(|pane| ClientMessage::ClosePane { pane }),
ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }),
Copy => pane_id.map(|pane| ClientMessage::Copy { pane }),
Scroll(kind) => pane_id.map(|pane| ClientMessage::Scroll { pane, kind }),
FocusTab(tab) => Some(ClientMessage::FocusTab { tab }),
FocusPane(pane) => Some(ClientMessage::FocusPane { pane }),
PreviousTab | NextTab => self.adjacent_tab(matches!(action, NextTab)),
PreviousPane | NextPane => self.snapshot.as_ref().and_then(|snapshot| {
let index = snapshot
.panes
.iter()
.position(|pane| Some(pane.id) == pane_id)?;
let count = snapshot.panes.len();
let next = if matches!(action, NextPane) {
(index + 1) % count
} else {
(index + count - 1) % count
};
Some(ClientMessage::FocusPane {
pane: snapshot.panes[next].id,
})
}),
FocusLeft | FocusRight => {
let forward = matches!(action, FocusRight);
self.snapshot.as_ref().and_then(|snapshot| {
let index = snapshot
.panes
.iter()
.position(|pane| Some(pane.id) == pane_id)?;
let next = if forward {
index.checked_add(1)
} else {
index.checked_sub(1)
};
next.and_then(|next| snapshot.panes.get(next))
.map(|pane| ClientMessage::FocusPane { pane: pane.id })
.or_else(|| self.adjacent_tab(forward))
})
}
RenamePane => {
if let Some(pane) = pane {
pane.update(cx, |pane, cx| pane.begin_rename(window, cx));
}
None
}
Paste => {
if let Some(pane) = pane
&& let Some(text) = cx.read_from_clipboard().and_then(|item| item.text())
{
pane.update(cx, |pane, cx| {
pane.send(
input::paste_text(
&text,
pane.mode().contains(TermMode::BRACKETED_PASTE),
),
cx,
);
});
}
None
}
Detach => {
window.remove_window();
None
}
};
if let Some(message) = message
&& let Err(error) = self.client.send(message)
{
self.error = Some(error.to_string());
cx.notify();
}
}
fn adjacent_tab(&self, forward: bool) -> Option<ClientMessage> {
let snapshot = self.snapshot.as_ref()?;
let index = snapshot
.tabs
.iter()
.position(|tab| tab.id == snapshot.active_tab)?;
let count = snapshot.tabs.len();
let next = if forward {
(index + 1) % count
} else {
(index + count - 1) % count
};
Some(ClientMessage::FocusTab {
tab: snapshot.tabs[next].id,
})
}
pub fn new(
client: Client,
updates: Updates,
@@ -46,6 +241,8 @@ impl Workspace {
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
let focus = cx.focus_handle();
window.focus(&focus);
let task = cx.spawn_in(window, async move |view, cx| {
while let Some(update) = updates.recv().await {
if cx
@@ -140,6 +337,15 @@ impl Workspace {
.unwrap_or("Terminal");
window.set_window_title(&format!("psyTerm — {title}"));
view.snapshot = Some(snapshot);
if let Some(palette) = &view.palette {
let items = commands::root_items(view.snapshot.as_deref());
palette.update(cx, |palette, cx| {
palette.set_items(items, cx);
palette.focus(window);
});
} else if view.panes.is_empty() {
window.focus(&view.focus);
}
}
cx.notify();
})
@@ -157,6 +363,8 @@ impl Workspace {
snapshot: None,
panes: HashMap::new(),
error: None,
focus,
palette: None,
outgoing: Vec::new(),
transition: None,
transition_frame_pending: false,
@@ -254,6 +462,9 @@ impl Render for Workspace {
}
body = body.child(incoming);
let mut root = div()
.relative()
.track_focus(&self.focus)
.capture_key_down(cx.listener(Self::key_down))
.size_full()
.flex()
.flex_col()
@@ -271,6 +482,9 @@ impl Render for Workspace {
.child(error.clone()),
);
}
if let Some(palette) = &self.palette {
root = root.child(palette.clone());
}
root
}
}
@@ -500,77 +714,13 @@ impl TerminalPane {
header
}
fn key_down(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
fn key_down(&mut self, event: &KeyDownEvent, _: &mut Window, cx: &mut Context<Self>) {
if self.read_only || self.rename.is_some() {
return;
}
let key = &event.keystroke;
let pane = self.data().id;
self.activity(cx);
if key.modifiers.control
&& key.modifiers.shift
&& !key.modifiers.alt
&& !key.modifiers.platform
{
let handled = match key.key.to_lowercase().as_str() {
"r" => {
self.begin_rename(window, cx);
true
}
"c" => {
self.command(ClientMessage::Copy { pane });
true
}
"v" => {
if let Some(text) = cx.read_from_clipboard().and_then(|item| item.text()) {
self.send(
input::paste_text(
&text,
self.mode().contains(TermMode::BRACKETED_PASTE),
),
cx,
);
}
true
}
"t" => {
self.command(ClientMessage::NewTab { cwd: None });
true
}
"d" => {
self.command(ClientMessage::Split { pane, cwd: None });
true
}
"w" => {
self.command(ClientMessage::ClosePane { pane });
true
}
"left" | "right" => {
if let Some(tab) = self
.snapshot
.tabs
.iter()
.find(|t| t.id == self.snapshot.active_tab)
&& let Some(index) = tab.panes.iter().position(|p| *p == pane)
{
let next = if key.key == "right" {
(index + 1) % tab.panes.len()
} else {
(index + tab.panes.len() - 1) % tab.panes.len()
};
self.command(ClientMessage::FocusPane {
pane: tab.panes[next],
});
}
true
}
_ => false,
};
if handled {
cx.stop_propagation();
return;
}
}
if key.modifiers.shift
&& !key.modifiers.control
&& !key.modifiers.alt
@@ -823,7 +973,7 @@ impl Render for TerminalPane {
let mut delay=None;
window.with_content_mask(Some(ContentMask{bounds}),|window| {
let origin=bounds.origin+point(px(PADDING),px(PADDING));
let focused=window.is_window_active() && pane.active && pane.rename.is_none();
let focused=window.is_window_active() && pane.active && pane.focus.is_focused(window) && pane.rename.is_none();
pane.renderer.paint_with_cursor(origin,window,cx,|window| {
if !pane.transitioning {
delay=pane.cursor.paint(Instant::now(),focused,window);