mirrors/helix
1
0
Fork 0
mirror of https://github.com/helix-editor/helix.git synced 2025-04-03 10:57:48 +03:00
Code Issues Projects Releases Packages Wiki Activity

FEAT: Add labelled buffer picker

Browse source
This commit is contained in:
leath-dub 2025-03-23 21:32:39 +00:00
parent 0ee5850016
commit 5c7a960cdc
No known key found for this signature in database
5 changed files with 262 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

179
helix-term/src/commands.rs
View file

@ -45,7 +45,7 @@ use helix_view::{
document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
editor::Action,
info::Info,
input::KeyEvent,
input::{Event, KeyEvent, KeyModifiers},
keyboard::KeyCode,
theme::Style,
tree,
@ -58,10 +58,13 @@ use insert::*;
use movement::Movement;
use crate::{
compositor::{self, Component, Compositor},
compositor::{self, Component, Compositor, EventResult},
filter_picker_entry,
job::Callback,
ui::{self, overlay::overlaid, Picker, PickerColumn, Popup, Prompt, PromptEvent},
ui::{
self, overlay::overlaid, picker::PickerSideEffect, Picker, PickerColumn, Popup, Prompt,
PromptEvent,
},
};
use crate::job::{self, Jobs};
@ -78,6 +81,7 @@ use std::{
use std::{
borrow::Cow,
iter,
path::{Path, PathBuf},
};
@ -402,6 +406,7 @@ impl MappableCommand {
file_explorer_in_current_buffer_directory, "Open file explorer at current buffer's directory",
file_explorer_in_current_directory, "Open file explorer at current working directory",
code_action, "Perform code action",
labelled_buffer_picker, "Open labelled buffer picker",
buffer_picker, "Open buffer picker",
jumplist_picker, "Open jumplist picker",
symbol_picker, "Open symbol picker",
@ -3113,36 +3118,79 @@ fn file_explorer_in_current_directory(cx: &mut Context) {
}
}
fn buffer_picker(cx: &mut Context) {
fn iter_newbase(n: u32, base: u32) -> impl Iterator<Item = u32> {
let mut num = n;
let mut divisor = 1;
while divisor * base <= n {
divisor *= base;
}
iter::from_fn(move || {
if divisor <= 0 {
return None;
}
let digit = num / divisor;
num %= divisor;
divisor /= base;
Some(digit)
})
}
fn ord_label_nopad(ord: u32, labels: &[char]) -> impl Iterator<Item = char> + '_ {
iter_newbase(ord, labels.len() as u32)
.map(|i| labels.get(i as usize))
.filter_map(|o| o)
.map(|r| *r)
}
fn ord_label(ord: u32, max: u32, labels: &[char]) -> Vec<char> {
let max_len = ord_label_nopad(max, labels).count();
let label_nopad: Vec<char> = ord_label_nopad(ord, labels).collect();
iter::repeat(labels[0])
.take(max_len - label_nopad.len())
.chain(label_nopad.into_iter())
.collect()
}
#[derive(Clone)]
struct BufferMeta {
id: DocumentId,
label: Vec<char>,
path: Option<PathBuf>,
is_modified: bool,
is_current: bool,
focused_at: std::time::Instant,
}
fn get_buffers(cx: &mut Context) -> Vec<BufferMeta> {
let current = view!(cx.editor).doc;
struct BufferMeta {
id: DocumentId,
path: Option<PathBuf>,
is_modified: bool,
is_current: bool,
focused_at: std::time::Instant,
}
let labels = &cx.editor.config().buffer_picker.label_alphabet;
let new_meta = |doc: &Document| BufferMeta {
let new_meta = |(i, doc): (usize, &Document)| BufferMeta {
id: doc.id(),
path: doc.path().cloned(),
is_modified: doc.is_modified(),
is_current: doc.id() == current,
focused_at: doc.focused_at,
label: ord_label(i as u32, cx.editor.documents.len() as u32, labels),
};
let mut items = cx
.editor
cx.editor
.documents
.values()
.enumerate()
.map(new_meta)
.collect::<Vec<BufferMeta>>();
.collect::<Vec<BufferMeta>>()
}
// mru
items.sort_unstable_by_key(|item| std::cmp::Reverse(item.focused_at));
fn get_buffers_mru(cx: &mut Context) -> Vec<BufferMeta> {
let mut buffers = get_buffers(cx);
buffers.sort_unstable_by_key(|item| std::cmp::Reverse(item.focused_at));
buffers
}
let columns = [
fn get_buffer_picker_columns<T>() -> impl IntoIterator<Item = PickerColumn<BufferMeta, T>> {
[
PickerColumn::new("id", |meta: &BufferMeta, _| meta.id.to_string().into()),
PickerColumn::new("flags", |meta: &BufferMeta, _| {
let mut flags = String::new();
@ -3165,10 +3213,97 @@ fn buffer_picker(cx: &mut Context) {
.to_string()
.into()
}),
];
let picker = Picker::new(columns, 2, items, (), |cx, meta, action| {
cx.editor.switch(meta.id, action);
})
]
}
fn get_labelled_buffer_picker_columns<T>() -> impl IntoIterator<Item = PickerColumn<BufferMeta, T>>
{
iter::once(PickerColumn::new("label", |meta: &BufferMeta, _| {
(&meta.label).into()
}))
.chain(get_buffer_picker_columns())
}
fn labelled_buffer_picker(cx: &mut Context) {
let items = get_buffers(cx);
let labels = &cx.editor.config().buffer_picker.label_alphabet;
let max_label = ord_label_nopad(cx.editor.documents.len() as u32, labels).count();
let mut chars_read = 0;
let mut matching: Vec<bool> = iter::repeat(true).take(items.len()).collect();
let picker = Picker::new(
get_labelled_buffer_picker_columns(),
2,
items.clone(),
(),
|cx, meta, action| {
cx.editor.switch(meta.id, action);
},
)
.with_text_typing_handler(
move |event: &Event, cx: &mut compositor::Context| -> (PickerSideEffect, EventResult) {
if let Event::Key(KeyEvent {
code: KeyCode::Char(c),
modifiers: KeyModifiers::NONE,
}) = event
{
chars_read += 1;
if chars_read > max_label {
// TODO: raise message that match failed (invalid key sequence)
chars_read = 0;
matching.iter_mut().for_each(|v| *v = true);
return (PickerSideEffect::None, EventResult::Consumed(None));
}
let idx = chars_read - 1;
items.iter().enumerate().for_each(|(i, item)| {
if *c != item.label[idx] {
matching[i] = false;
}
});
let nmatches = matching.iter().fold(0, |acc, &c| acc + c as i32);
if nmatches == 0 {
// TODO: raise message that match failed (invalid key sequence)
chars_read = 0;
matching.iter_mut().for_each(|v| *v = true);
} else if nmatches == 1 {
// unique match found
let match_idx = matching
.iter()
.enumerate()
.find(|(_, c)| **c)
.map(|(i, _)| i)
.unwrap();
cx.editor.switch(items[match_idx].id, Action::Replace);
return (PickerSideEffect::Close, EventResult::Consumed(None));
}
}
(PickerSideEffect::None, EventResult::Consumed(None))
},
)
.with_preview(|editor, meta| {
let doc = &editor.documents.get(&meta.id)?;
let lines = doc.selections().values().next().map(|selection| {
let cursor_line = selection.primary().cursor_line(doc.text().slice(..));
(cursor_line, cursor_line)
});
Some((meta.id.into(), lines))
});
cx.push_layer(Box::new(overlaid(picker)));
}
fn buffer_picker(cx: &mut Context) {
let items = get_buffers_mru(cx);
let picker = Picker::new(
get_buffer_picker_columns(),
2,
items,
(),
|cx, meta, action| {
cx.editor.switch(meta.id, action);
},
)
.with_preview(|editor, meta| {
let doc = &editor.documents.get(&meta.id)?;
let lines = doc.selections().values().next().map(|selection| {

1
helix-term/src/keymap/default.rs
View file

@ -57,6 +57,7 @@ pub fn default() -> HashMap<Mode, KeyTrie> {
"p" => goto_previous_buffer,
"k" => move_line_up,
"j" => move_line_down,
"o" => labelled_buffer_picker,
"." => goto_last_modification,
"w" => goto_word,
},

127
helix-term/src/ui/picker.rs
View file

@ -29,14 +29,10 @@ use tui::{
use tui::widgets::Widget;
use std::{
borrow::Cow,
collections::HashMap,
io::Read,
path::Path,
sync::{
borrow::Cow, collections::HashMap, io::Read, path::Path, sync::{
atomic::{self, AtomicUsize},
Arc,
},
}
};
use crate::ui::{Prompt, PromptEvent};
@ -238,6 +234,11 @@ impl<T, D> Column<T, D> {
type DynQueryCallback<T, D> =
fn(&str, &mut Editor, Arc<D>, &Injector<T, D>) -> BoxFuture<'static, anyhow::Result<()>>;
pub enum PickerSideEffect {
Close,
None,
}
pub struct Picker<T: 'static + Send + Sync, D: 'static> {
columns: Arc<[Column<T, D>]>,
primary_column: usize,
@ -250,6 +251,7 @@ pub struct Picker<T: 'static + Send + Sync, D: 'static> {
cursor: u32,
prompt: Prompt,
custom_handle_event: Option<Box<dyn FnMut(&Event, &mut Context) -> (PickerSideEffect, EventResult)>>,
query: PickerQuery,
/// Whether to show the preview panel (default true)
@ -378,6 +380,7 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
version,
cursor: 0,
prompt,
custom_handle_event: None,
query,
truncate_start: true,
show_preview: true,
@ -408,6 +411,14 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
self
}
pub fn with_text_typing_handler<C>(mut self, handle_event: C) -> Self
where
C: FnMut(&Event, &mut Context) -> (PickerSideEffect, EventResult) + 'static,
{
self.custom_handle_event = Some(Box::new(handle_event));
self
}
pub fn with_preview(
mut self,
preview_fn: impl for<'a> Fn(&'a Editor, &'a T) -> Option<FileLocation<'a>> + 'static,
@ -516,6 +527,17 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
EventResult::Consumed(None)
}
fn typing_handle_event(&mut self, event: &Event, cx: &mut Context) -> EventResult {
self
.custom_handle_event.as_mut()
.map(|handler| (handler)(event, cx))
.map(|(se, ev)| match se {
PickerSideEffect::Close => self.close_from_event(),
PickerSideEffect::None => ev,
})
.unwrap_or_else(|| self.prompt_handle_event(event, cx))
}
fn handle_prompt_change(&mut self, is_paste: bool) {
// TODO: better track how the pattern has changed
let line = self.prompt.line();
@ -698,28 +720,33 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
let line_area = area.clip_right(count.len() as u16 + 1);
// render the prompt first since it will clear its background
self.prompt.render(line_area, surface, cx);
if self.custom_handle_event.is_none() {
self.prompt.render(line_area, surface, cx);
surface.set_stringn(
(area.x + area.width).saturating_sub(count.len() as u16 + 1),
area.y,
&count,
(count.len()).min(area.width as usize),
text_style,
);
surface.set_stringn(
(area.x + area.width).saturating_sub(count.len() as u16 + 1),
area.y,
&count,
(count.len()).min(area.width as usize),
text_style,
);
// -- Separator
let sep_style = cx.editor.theme.get("ui.background.separator");
let borders = BorderType::line_symbols(BorderType::Plain);
for x in inner.left()..inner.right() {
if let Some(cell) = surface.get_mut(x, inner.y + 1) {
cell.set_symbol(borders.horizontal).set_style(sep_style);
// -- Separator
let sep_style = cx.editor.theme.get("ui.background.separator");
let borders = BorderType::line_symbols(BorderType::Plain);
for x in inner.left()..inner.right() {
if let Some(cell) = surface.get_mut(x, inner.y + 1) {
cell.set_symbol(borders.horizontal).set_style(sep_style);
}
}
}
// We only reserve space if prompt is drawn
let clip = if self.custom_handle_event.is_some() { 0 } else { 2 };
// -- Render the contents:
// subtract area of prompt from top
let inner = inner.clip_top(2);
let inner = inner.clip_top(clip);
let rows = inner.height.saturating_sub(self.header_height()) as u32;
let offset = self.cursor - (self.cursor % std::cmp::max(1, rows));
let cursor = self.cursor.saturating_sub(offset);
@ -984,6 +1011,29 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
);
}
}
pub fn close_from_event(&mut self) -> EventResult {
// if the picker is very large don't store it as last_picker to avoid
// excessive memory consumption
let callback: compositor::Callback = if self.matcher.snapshot().item_count() > 100_000
{
Box::new(|compositor: &mut Compositor, _ctx| {
// remove the layer
compositor.pop();
})
} else {
// stop streaming in new items in the background, really we should
// be restarting the stream somehow once the picker gets
// reopened instead (like for an FS crawl) that would also remove the
// need for the special case above but that is pretty tricky
self.version.fetch_add(1, atomic::Ordering::Relaxed);
Box::new(|compositor: &mut Compositor, _ctx| {
// remove the layer
compositor.last_picker = compositor.pop();
})
};
EventResult::Consumed(Some(callback))
}
}
impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, D> {
@ -1018,34 +1068,11 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I,
let key_event = match event {
Event::Key(event) => *event,
Event::Paste(..) => return self.prompt_handle_event(event, ctx),
Event::Paste(..) => return self.typing_handle_event(event, ctx),
Event::Resize(..) => return EventResult::Consumed(None),
_ => return EventResult::Ignored(None),
};
let close_fn = |picker: &mut Self| {
// if the picker is very large don't store it as last_picker to avoid
// excessive memory consumption
let callback: compositor::Callback = if picker.matcher.snapshot().item_count() > 100_000
{
Box::new(|compositor: &mut Compositor, _ctx| {
// remove the layer
compositor.pop();
})
} else {
// stop streaming in new items in the background, really we should
// be restarting the stream somehow once the picker gets
// reopened instead (like for an FS crawl) that would also remove the
// need for the special case above but that is pretty tricky
picker.version.fetch_add(1, atomic::Ordering::Relaxed);
Box::new(|compositor: &mut Compositor, _ctx| {
// remove the layer
compositor.last_picker = compositor.pop();
})
};
EventResult::Consumed(Some(callback))
};
match key_event {
shift!(Tab) | key!(Up) | ctrl!('p') => {
self.move_by(1, Direction::Backward);
@ -1065,7 +1092,7 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I,
key!(End) => {
self.to_end();
}
key!(Esc) | ctrl!('c') => return close_fn(self),
key!(Esc) | ctrl!('c') => return self.close_from_event(),
alt!(Enter) => {
if let Some(option) = self.selection() {
(self.callback_fn)(ctx, option, Action::Replace);
@ -1103,26 +1130,26 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I,
ctx.editor.set_error(err.to_string());
}
}
return close_fn(self);
return self.close_from_event();
}
}
ctrl!('s') => {
if let Some(option) = self.selection() {
(self.callback_fn)(ctx, option, Action::HorizontalSplit);
}
return close_fn(self);
return self.close_from_event();
}
ctrl!('v') => {
if let Some(option) = self.selection() {
(self.callback_fn)(ctx, option, Action::VerticalSplit);
}
return close_fn(self);
return self.close_from_event();
}
ctrl!('t') => {
self.toggle_preview();
}
_ => {
self.prompt_handle_event(event, ctx);
return self.typing_handle_event(event, ctx);
}
}

6
helix-tui/src/text.rs
View file

@ -436,6 +436,12 @@ impl<'a> From<Vec<Spans<'a>>> for Text<'a> {
}
}
impl<'a> From<&Vec<char>> for Text<'a> {
fn from(chars: &Vec<char>) -> Text<'a> {
chars.iter().collect::<String>().into()
}
}
impl<'a> From<Text<'a>> for String {
fn from(text: Text<'a>) -> String {
String::from(&text)

21
helix-view/src/editor.rs
View file

@ -219,6 +219,25 @@ impl Default for FilePickerConfig {
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case", default, deny_unknown_fields)]
pub struct BufferPickerConfig {
/// labels characters used in buffer picker
#[serde(
serialize_with = "serialize_alphabet",
deserialize_with = "deserialize_alphabet"
)]
pub label_alphabet: Vec<char>,
}
impl Default for BufferPickerConfig {
fn default() -> Self {
Self {
label_alphabet: "sadflewcmpghio".chars().collect(),
}
}
}
fn serialize_alphabet<S>(alphabet: &[char], serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -313,6 +332,7 @@ pub struct Config {
/// Whether to display infoboxes. Defaults to true.
pub auto_info: bool,
pub file_picker: FilePickerConfig,
pub buffer_picker: BufferPickerConfig,
/// Configuration of the statusline elements
pub statusline: StatusLineConfig,
/// Shape for cursor in each mode
@ -985,6 +1005,7 @@ impl Default for Config {
completion_trigger_len: 2,
auto_info: true,
file_picker: FilePickerConfig::default(),
buffer_picker: BufferPickerConfig::default(),
statusline: StatusLineConfig::default(),
cursor_shape: CursorShapeConfig::default(),
true_color: false,