bendns' repos / helix
Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'helix-term/src/ui/picker.rs')
-rw-r--r--helix-term/src/ui/picker.rs1395
1 files changed, 424 insertions, 971 deletions
diff --git a/helix-term/src/ui/picker.rs b/helix-term/src/ui/picker.rs
index 4f77f8b9..e316fca2 100644
--- a/helix-term/src/ui/picker.rs
+++ b/helix-term/src/ui/picker.rs
@@ -1,91 +1,54 @@
-mod handlers;
-mod query;
-
use crate::{
- alt,
- compositor::{self, Component, Compositor, Context, Event, EventResult},
+ compositor::{Component, Compositor, Context, EventResult},
ctrl, key, shift,
- ui::{
- self,
- document::{render_document, LinePos, TextRenderer},
- picker::query::PickerQuery,
- text_decorations::DecorationManager,
- EditorView,
- },
+ ui::{self, EditorView},
};
-use futures_util::future::BoxFuture;
-use helix_event::AsyncHook;
-use nucleo::pattern::{CaseMatching, Normalization};
-use nucleo::{Config, Nucleo};
-use thiserror::Error;
-use tokio::sync::mpsc::Sender;
+use crossterm::event::Event;
use tui::{
- buffer::Buffer as Surface,
- layout::Constraint,
- text::{Span, Spans},
- widgets::{Block, BorderType, Cell, Row, Table},
+ buffer::{Buffer as Surface, SurfaceExt},
+ widgets::{Block, BorderType, Borders},
};
+use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
+use fuzzy_matcher::FuzzyMatcher;
use tui::widgets::Widget;
+use std::time::Instant;
use std::{
borrow::Cow,
+ cmp::Reverse,
collections::HashMap,
io::Read,
- path::Path,
- sync::{
- atomic::{self, AtomicUsize},
- Arc,
- },
+ path::{Path, PathBuf},
};
use crate::ui::{Prompt, PromptEvent};
-use helix_core::{
- char_idx_at_visual_offset, fuzzy::MATCHER, movement::Direction,
- text_annotations::TextAnnotations, unicode::segmentation::UnicodeSegmentation, Position,
-};
+use helix_core::{movement::Direction, Position};
use helix_view::{
editor::Action,
- graphics::{CursorKind, Margin, Modifier, Rect},
- theme::Style,
- view::ViewPosition,
- Document, DocumentId, Editor,
+ graphics::{Color, CursorKind, Margin, Modifier, Rect, Style},
+ Document, Editor,
};
-use self::handlers::{DynamicQueryChange, DynamicQueryHandler, PreviewHighlightHandler};
-
-pub const ID: &str = "picker";
-
pub const MIN_AREA_WIDTH_FOR_PREVIEW: u16 = 72;
/// Biggest file size to preview in bytes
pub const MAX_FILE_SIZE_FOR_PREVIEW: u64 = 10 * 1024 * 1024;
-#[derive(PartialEq, Eq, Hash)]
-pub enum PathOrId<'a> {
- Id(DocumentId),
- Path(&'a Path),
-}
-
-impl<'a> From<&'a Path> for PathOrId<'a> {
- fn from(path: &'a Path) -> Self {
- Self::Path(path)
- }
-}
+/// File path and range of lines (used to align and highlight lines)
+pub type FileLocation = (PathBuf, Option<(usize, usize)>);
-impl From<DocumentId> for PathOrId<'_> {
- fn from(v: DocumentId) -> Self {
- Self::Id(v)
- }
+pub struct FilePicker<T> {
+ picker: Picker<T>,
+ pub truncate_start: bool,
+ /// Caches paths to documents
+ preview_cache: HashMap<PathBuf, CachedPreview>,
+ read_buffer: Vec<u8>,
+ /// Given an item in the picker, return the file path and line number to display.
+ file_fn: Box<dyn Fn(&Editor, &T) -> Option<FileLocation>>,
}
-type FileCallback<T> = Box<dyn for<'a> Fn(&'a Editor, &'a T) -> Option<FileLocation<'a>>>;
-
-/// File path and range of lines (used to align and highlight lines)
-pub type FileLocation<'a> = (PathOrId<'a>, Option<(usize, usize)>);
-
pub enum CachedPreview {
Document(Box<Document>),
- Directory(Vec<(String, bool)>),
Binary,
LargeFile,
NotFound,
@@ -107,20 +70,12 @@ impl Preview<'_, '_> {
}
}
- fn dir_content(&self) -> Option<&Vec<(String, bool)>> {
- match self {
- Preview::Cached(CachedPreview::Directory(dir_content)) => Some(dir_content),
- _ => None,
- }
- }
-
/// Alternate text to show for the preview.
fn placeholder(&self) -> &str {
match *self {
- Self::EditorDocument(_) => "<Invalid file location>",
+ Self::EditorDocument(_) => "<File preview>",
Self::Cached(preview) => match preview {
- CachedPreview::Document(_) => "<Invalid file location>",
- CachedPreview::Directory(_) => "<Invalid directory location>",
+ CachedPreview::Document(_) => "<File preview>",
CachedPreview::Binary => "<Binary file>",
CachedPreview::LargeFile => "<File too large to preview>",
CachedPreview::NotFound => "<File not found>",
@@ -129,237 +84,224 @@ impl Preview<'_, '_> {
}
}
-fn inject_nucleo_item<T, D>(
- injector: &nucleo::Injector<T>,
- columns: &[Column<T, D>],
- item: T,
- editor_data: &D,
-) {
- injector.push(item, |item, dst| {
- for (column, text) in columns.iter().filter(|column| column.filter).zip(dst) {
- *text = column.format_text(item, editor_data).into()
+impl<T> FilePicker<T> {
+ pub fn new(
+ options: Vec<T>,
+ format_fn: impl Fn(&T) -> Cow<str> + 'static,
+ callback_fn: impl Fn(&mut Context, &T, Action) + 'static,
+ preview_fn: impl Fn(&Editor, &T) -> Option<FileLocation> + 'static,
+ ) -> Self {
+ Self {
+ picker: Picker::new(options, format_fn, callback_fn),
+ truncate_start: true,
+ preview_cache: HashMap::new(),
+ read_buffer: Vec::with_capacity(1024),
+ file_fn: Box::new(preview_fn),
}
- });
-}
-
-pub struct Injector<T, D> {
- dst: nucleo::Injector<T>,
- columns: Arc<[Column<T, D>]>,
- editor_data: Arc<D>,
- version: usize,
- picker_version: Arc<AtomicUsize>,
- /// A marker that requests a redraw when the injector drops.
- /// This marker causes the "running" indicator to disappear when a background job
- /// providing items is finished and drops. This could be wrapped in an [Arc] to ensure
- /// that the redraw is only requested when all Injectors drop for a Picker (which removes
- /// the "running" indicator) but the redraw handle is debounced so this is unnecessary.
- _redraw: helix_event::RequestRedrawOnDrop,
-}
+ }
-impl<I, D> Clone for Injector<I, D> {
- fn clone(&self) -> Self {
- Injector {
- dst: self.dst.clone(),
- columns: self.columns.clone(),
- editor_data: self.editor_data.clone(),
- version: self.version,
- picker_version: self.picker_version.clone(),
- _redraw: helix_event::RequestRedrawOnDrop,
- }
+ fn current_file(&self, editor: &Editor) -> Option<FileLocation> {
+ self.picker
+ .selection()
+ .and_then(|current| (self.file_fn)(editor, current))
+ .and_then(|(path, line)| {
+ helix_core::path::get_canonicalized_path(&path)
+ .ok()
+ .zip(Some(line))
+ })
}
-}
-#[derive(Error, Debug)]
-#[error("picker has been shut down")]
-pub struct InjectorShutdown;
+ /// Get (cached) preview for a given path. If a document corresponding
+ /// to the path is already open in the editor, it is used instead.
+ fn get_preview<'picker, 'editor>(
+ &'picker mut self,
+ path: &Path,
+ editor: &'editor Editor,
+ ) -> Preview<'picker, 'editor> {
+ if let Some(doc) = editor.document_by_path(path) {
+ return Preview::EditorDocument(doc);
+ }
-impl<T, D> Injector<T, D> {
- pub fn push(&self, item: T) -> Result<(), InjectorShutdown> {
- if self.version != self.picker_version.load(atomic::Ordering::Relaxed) {
- return Err(InjectorShutdown);
+ if self.preview_cache.contains_key(path) {
+ return Preview::Cached(&self.preview_cache[path]);
}
- inject_nucleo_item(&self.dst, &self.columns, item, &self.editor_data);
- Ok(())
+ let data = std::fs::File::open(path).and_then(|file| {
+ let metadata = file.metadata()?;
+ // Read up to 1kb to detect the content type
+ let n = file.take(1024).read_to_end(&mut self.read_buffer)?;
+ let content_type = content_inspector::inspect(&self.read_buffer[..n]);
+ self.read_buffer.clear();
+ Ok((metadata, content_type))
+ });
+ let preview = data
+ .map(
+ |(metadata, content_type)| match (metadata.len(), content_type) {
+ (_, content_inspector::ContentType::BINARY) => CachedPreview::Binary,
+ (size, _) if size > MAX_FILE_SIZE_FOR_PREVIEW => CachedPreview::LargeFile,
+ _ => {
+ // TODO: enable syntax highlighting; blocked by async rendering
+ Document::open(path, None, None)
+ .map(|doc| CachedPreview::Document(Box::new(doc)))
+ .unwrap_or(CachedPreview::NotFound)
+ }
+ },
+ )
+ .unwrap_or(CachedPreview::NotFound);
+ self.preview_cache.insert(path.to_owned(), preview);
+ Preview::Cached(&self.preview_cache[path])
}
}
-type ColumnFormatFn<T, D> = for<'a> fn(&'a T, &'a D) -> Cell<'a>;
+impl<T: 'static> Component for FilePicker<T> {
+ fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+ // +---------+ +---------+
+ // |prompt | |preview |
+ // +---------+ | |
+ // |picker | | |
+ // | | | |
+ // +---------+ +---------+
+
+ let render_preview = area.width > MIN_AREA_WIDTH_FOR_PREVIEW;
+ // -- Render the frame:
+ // clear area
+ let background = cx.editor.theme.get("ui.background");
+ let text = cx.editor.theme.get("ui.text");
+ surface.clear_with(area, background);
-pub struct Column<T, D> {
- name: Arc<str>,
- format: ColumnFormatFn<T, D>,
- /// Whether the column should be passed to nucleo for matching and filtering.
- /// `DynamicPicker` uses this so that the dynamic column (for example regex in
- /// global search) is not used for filtering twice.
- filter: bool,
- hidden: bool,
-}
+ let picker_width = if render_preview {
+ area.width / 2
+ } else {
+ area.width
+ };
-impl<T, D> Column<T, D> {
- pub fn new(name: impl Into<Arc<str>>, format: ColumnFormatFn<T, D>) -> Self {
- Self {
- name: name.into(),
- format,
- filter: true,
- hidden: false,
+ let picker_area = area.with_width(picker_width);
+ self.picker.truncate_start = self.truncate_start;
+ self.picker.render(picker_area, surface, cx);
+
+ if !render_preview {
+ return;
}
- }
- /// A column which does not display any contents
- pub fn hidden(name: impl Into<Arc<str>>) -> Self {
- let format = |_: &T, _: &D| unreachable!();
+ let preview_area = area.clip_left(picker_width);
- Self {
- name: name.into(),
- format,
- filter: false,
- hidden: true,
+ // don't like this but the lifetime sucks
+ let block = Block::default().borders(Borders::ALL);
+
+ // calculate the inner area inside the box
+ let inner = block.inner(preview_area);
+ // 1 column gap on either side
+ let margin = Margin {
+ vertical: 0,
+ horizontal: 1,
+ };
+ let inner = inner.inner(&margin);
+ block.render(preview_area, surface);
+
+ if let Some((path, range)) = self.current_file(cx.editor) {
+ let preview = self.get_preview(&path, cx.editor);
+ let doc = match preview.document() {
+ Some(doc) => doc,
+ None => {
+ let alt_text = preview.placeholder();
+ let x = inner.x + inner.width.saturating_sub(alt_text.len() as u16) / 2;
+ let y = inner.y + inner.height / 2;
+ surface.set_stringn(x, y, alt_text, inner.width as usize, text);
+ return;
+ }
+ };
+
+ // align to middle
+ let first_line = range
+ .map(|(start, end)| {
+ let height = end.saturating_sub(start) + 1;
+ let middle = start + (height.saturating_sub(1) / 2);
+ middle.saturating_sub(inner.height as usize / 2).min(start)
+ })
+ .unwrap_or(0);
+
+ let offset = Position::new(first_line, 0);
+
+ let highlights =
+ EditorView::doc_syntax_highlights(doc, offset, area.height, &cx.editor.theme);
+ EditorView::render_text_highlights(
+ doc,
+ offset,
+ inner,
+ surface,
+ &cx.editor.theme,
+ highlights,
+ );
+
+ // highlight the line
+ if let Some((start, end)) = range {
+ let offset = start.saturating_sub(first_line) as u16;
+ surface.set_style(
+ Rect::new(
+ inner.x,
+ inner.y + offset,
+ inner.width,
+ (end.saturating_sub(start) as u16 + 1)
+ .min(inner.height.saturating_sub(offset)),
+ ),
+ cx.editor
+ .theme
+ .try_get("ui.highlight")
+ .unwrap_or_else(|| cx.editor.theme.get("ui.selection")),
+ );
+ }
}
}
- pub fn without_filtering(mut self) -> Self {
- self.filter = false;
- self
+ fn handle_event(&mut self, event: Event, ctx: &mut Context) -> EventResult {
+ // TODO: keybinds for scrolling preview
+ self.picker.handle_event(event, ctx)
}
- fn format<'a>(&self, item: &'a T, data: &'a D) -> Cell<'a> {
- (self.format)(item, data)
+ fn cursor(&self, area: Rect, ctx: &Editor) -> (Option<Position>, CursorKind) {
+ self.picker.cursor(area, ctx)
}
- fn format_text<'a>(&self, item: &'a T, data: &'a D) -> Cow<'a, str> {
- let text: String = self.format(item, data).content.into();
- text.into()
+ fn required_size(&mut self, (width, height): (u16, u16)) -> Option<(u16, u16)> {
+ let picker_width = if width > MIN_AREA_WIDTH_FOR_PREVIEW {
+ width / 2
+ } else {
+ width
+ };
+ self.picker.required_size((picker_width, height))?;
+ Some((width, height))
}
}
-/// Returns a new list of options to replace the contents of the picker
-/// when called with the current picker query,
-type DynQueryCallback<T, D> =
- fn(&str, &mut Editor, Arc<D>, &Injector<T, D>) -> BoxFuture<'static, anyhow::Result<()>>;
-
-pub struct Picker<T: 'static + Send + Sync, D: 'static> {
- columns: Arc<[Column<T, D>]>,
- primary_column: usize,
- editor_data: Arc<D>,
- version: Arc<AtomicUsize>,
- matcher: Nucleo<T>,
+pub struct Picker<T> {
+ options: Vec<T>,
+ // filter: String,
+ matcher: Box<Matcher>,
+ /// (index, score)
+ matches: Vec<(usize, i64)>,
+ /// Filter over original options.
+ filters: Vec<usize>, // could be optimized into bit but not worth it now
/// Current height of the completions box
completion_height: u16,
- cursor: u32,
+ cursor: usize,
+ // pattern: String,
prompt: Prompt,
- query: PickerQuery,
-
- /// Whether to show the preview panel (default true)
- show_preview: bool,
- /// Constraints for tabular formatting
- widths: Vec<Constraint>,
-
- callback_fn: PickerCallback<T>,
- default_action: Action,
-
+ previous_pattern: String,
+ /// Whether to truncate the start (default true)
pub truncate_start: bool,
- /// Caches paths to documents
- preview_cache: HashMap<Arc<Path>, CachedPreview>,
- read_buffer: Vec<u8>,
- /// Given an item in the picker, return the file path and line number to display.
- file_fn: Option<FileCallback<T>>,
- /// An event handler for syntax highlighting the currently previewed file.
- preview_highlight_handler: Sender<Arc<Path>>,
- dynamic_query_handler: Option<Sender<DynamicQueryChange>>,
-}
-impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
- pub fn stream(
- columns: impl IntoIterator<Item = Column<T, D>>,
- editor_data: D,
- ) -> (Nucleo<T>, Injector<T, D>) {
- let columns: Arc<[_]> = columns.into_iter().collect();
- let matcher_columns = columns.iter().filter(|col| col.filter).count() as u32;
- assert!(matcher_columns > 0);
- let matcher = Nucleo::new(
- Config::DEFAULT,
- Arc::new(helix_event::request_redraw),
- None,
- matcher_columns,
- );
- let streamer = Injector {
- dst: matcher.injector(),
- columns,
- editor_data: Arc::new(editor_data),
- version: 0,
- picker_version: Arc::new(AtomicUsize::new(0)),
- _redraw: helix_event::RequestRedrawOnDrop,
- };
- (matcher, streamer)
- }
-
- pub fn new<C, O, F>(
- columns: C,
- primary_column: usize,
- options: O,
- editor_data: D,
- callback_fn: F,
- ) -> Self
- where
- C: IntoIterator<Item = Column<T, D>>,
- O: IntoIterator<Item = T>,
- F: Fn(&mut Context, &T, Action) + 'static,
- {
- let columns: Arc<[_]> = columns.into_iter().collect();
- let matcher_columns = columns
- .iter()
- .filter(|col: &&Column<T, D>| col.filter)
- .count() as u32;
- assert!(matcher_columns > 0);
- let matcher = Nucleo::new(
- Config::DEFAULT,
- Arc::new(helix_event::request_redraw),
- None,
- matcher_columns,
- );
- let injector = matcher.injector();
- for item in options {
- inject_nucleo_item(&injector, &columns, item, &editor_data);
- }
- Self::with(
- matcher,
- columns,
- primary_column,
- Arc::new(editor_data),
- Arc::new(AtomicUsize::new(0)),
- callback_fn,
- )
- }
-
- pub fn with_stream(
- matcher: Nucleo<T>,
- primary_column: usize,
- injector: Injector<T, D>,
- callback_fn: impl Fn(&mut Context, &T, Action) + 'static,
- ) -> Self {
- Self::with(
- matcher,
- injector.columns,
- primary_column,
- injector.editor_data,
- injector.picker_version,
- callback_fn,
- )
- }
+ format_fn: Box<dyn Fn(&T) -> Cow<str>>,
+ callback_fn: Box<dyn Fn(&mut Context, &T, Action)>,
+}
- fn with(
- matcher: Nucleo<T>,
- columns: Arc<[Column<T, D>]>,
- default_column: usize,
- editor_data: Arc<D>,
- version: Arc<AtomicUsize>,
+impl<T> Picker<T> {
+ pub fn new(
+ options: Vec<T>,
+ format_fn: impl Fn(&T) -> Cow<str> + 'static,
callback_fn: impl Fn(&mut Context, &T, Action) + 'static,
) -> Self {
- assert!(!columns.is_empty());
-
let prompt = Prompt::new(
"".into(),
None,
@@ -367,97 +309,111 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
|_editor: &mut Context, _pattern: &str, _event: PromptEvent| {},
);
- let widths = columns
- .iter()
- .map(|column| Constraint::Length(column.name.chars().count() as u16))
- .collect();
-
- let query = PickerQuery::new(columns.iter().map(|col| &col.name).cloned(), default_column);
-
- Self {
- columns,
- primary_column: default_column,
- matcher,
- editor_data,
- version,
+ let mut picker = Self {
+ options,
+ matcher: Box::new(Matcher::default()),
+ matches: Vec::new(),
+ filters: Vec::new(),
cursor: 0,
prompt,
- query,
+ previous_pattern: String::new(),
truncate_start: true,
- show_preview: true,
+ format_fn: Box::new(format_fn),
callback_fn: Box::new(callback_fn),
- default_action: Action::Replace,
completion_height: 0,
- widths,
- preview_cache: HashMap::new(),
- read_buffer: Vec::with_capacity(1024),
- file_fn: None,
- preview_highlight_handler: PreviewHighlightHandler::<T, D>::default().spawn(),
- dynamic_query_handler: None,
- }
+ };
+
+ // scoring on empty input:
+ // TODO: just reuse score()
+ picker.matches.extend(
+ picker
+ .options
+ .iter()
+ .enumerate()
+ .map(|(index, _option)| (index, 0)),
+ );
+
+ picker
}
- pub fn injector(&self) -> Injector<T, D> {
- Injector {
- dst: self.matcher.injector(),
- columns: self.columns.clone(),
- editor_data: self.editor_data.clone(),
- version: self.version.load(atomic::Ordering::Relaxed),
- picker_version: self.version.clone(),
- _redraw: helix_event::RequestRedrawOnDrop,
+ pub fn score(&mut self) {
+ let now = Instant::now();
+
+ let pattern = &self.prompt.line;
+
+ if pattern == &self.previous_pattern {
+ return;
}
- }
- pub fn truncate_start(mut self, truncate_start: bool) -> Self {
- self.truncate_start = truncate_start;
- self
- }
+ if pattern.is_empty() {
+ // Fast path for no pattern.
+ self.matches.clear();
+ self.matches.extend(
+ self.options
+ .iter()
+ .enumerate()
+ .map(|(index, _option)| (index, 0)),
+ );
+ } else if pattern.starts_with(&self.previous_pattern) {
+ // TODO: remove when retain_mut is in stable rust
+ use retain_mut::RetainMut;
+
+ // optimization: if the pattern is a more specific version of the previous one
+ // then we can score the filtered set.
+ #[allow(unstable_name_collisions)]
+ self.matches.retain_mut(|(index, score)| {
+ let option = &self.options[*index];
+ // TODO: maybe using format_fn isn't the best idea here
+ let text = (self.format_fn)(option);
+
+ match self.matcher.fuzzy_match(&text, pattern) {
+ Some(s) => {
+ // Update the score
+ *score = s;
+ true
+ }
+ None => false,
+ }
+ });
- pub fn with_preview(
- mut self,
- preview_fn: impl for<'a> Fn(&'a Editor, &'a T) -> Option<FileLocation<'a>> + 'static,
- ) -> Self {
- self.file_fn = Some(Box::new(preview_fn));
- // assumption: if we have a preview we are matching paths... If this is ever
- // not true this could be a separate builder function
- self.matcher.update_config(Config::DEFAULT.match_paths());
- self
- }
+ self.matches
+ .sort_unstable_by_key(|(_, score)| Reverse(*score));
+ } else {
+ self.matches.clear();
+ self.matches.extend(
+ self.options
+ .iter()
+ .enumerate()
+ .filter_map(|(index, option)| {
+ // filter options first before matching
+ if !self.filters.is_empty() {
+ // TODO: this filters functionality seems inefficient,
+ // instead store and operate on filters if any
+ self.filters.binary_search(&index).ok()?;
+ }
- pub fn with_history_register(mut self, history_register: Option<char>) -> Self {
- self.prompt.with_history_register(history_register);
- self
- }
+ // TODO: maybe using format_fn isn't the best idea here
+ let text = (self.format_fn)(option);
- pub fn with_initial_cursor(mut self, cursor: u32) -> Self {
- self.cursor = cursor;
- self
- }
+ self.matcher
+ .fuzzy_match(&text, pattern)
+ .map(|score| (index, score))
+ }),
+ );
+ self.matches
+ .sort_unstable_by_key(|(_, score)| Reverse(*score));
+ }
- pub fn with_dynamic_query(
- mut self,
- callback: DynQueryCallback<T, D>,
- debounce_ms: Option<u64>,
- ) -> Self {
- let handler = DynamicQueryHandler::new(callback, debounce_ms).spawn();
- let event = DynamicQueryChange {
- query: self.primary_query(),
- // Treat the initial query as a paste.
- is_paste: true,
- };
- helix_event::send_blocking(&handler, event);
- self.dynamic_query_handler = Some(handler);
- self
- }
+ log::debug!("picker score {:?}", Instant::now().duration_since(now));
- pub fn with_default_action(mut self, action: Action) -> Self {
- self.default_action = action;
- self
+ // reset cursor position
+ self.cursor = 0;
+ self.previous_pattern.clone_from(pattern);
}
/// Move the cursor by a number of lines, either down (`Forward`) or up (`Backward`)
- pub fn move_by(&mut self, amount: u32, direction: Direction) {
- let len = self.matcher.snapshot().matched_item_count();
+ pub fn move_by(&mut self, amount: usize, direction: Direction) {
+ let len = self.matches.len();
if len == 0 {
// No results, can't move.
@@ -476,12 +432,12 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
/// Move the cursor down by exactly one page. After the last page comes the first page.
pub fn page_up(&mut self) {
- self.move_by(self.completion_height as u32, Direction::Backward);
+ self.move_by(self.completion_height as usize, Direction::Backward);
}
/// Move the cursor up by exactly one page. After the first page comes the last page.
pub fn page_down(&mut self) {
- self.move_by(self.completion_height as u32, Direction::Forward);
+ self.move_by(self.completion_height as usize, Direction::Forward);
}
/// Move the cursor to the first entry
@@ -491,240 +447,124 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
/// Move the cursor to the last entry
pub fn to_end(&mut self) {
- self.cursor = self
- .matcher
- .snapshot()
- .matched_item_count()
- .saturating_sub(1);
+ self.cursor = self.matches.len().saturating_sub(1);
}
pub fn selection(&self) -> Option<&T> {
- self.matcher
- .snapshot()
- .get_matched_item(self.cursor)
- .map(|item| item.data)
+ self.matches
+ .get(self.cursor)
+ .map(|(index, _score)| &self.options[*index])
}
- fn primary_query(&self) -> Arc<str> {
- self.query
- .get(&self.columns[self.primary_column].name)
- .cloned()
- .unwrap_or_else(|| "".into())
+ pub fn save_filter(&mut self, cx: &Context) {
+ self.filters.clear();
+ self.filters
+ .extend(self.matches.iter().map(|(index, _)| *index));
+ self.filters.sort_unstable(); // used for binary search later
+ self.prompt.clear(cx);
}
+}
- fn header_height(&self) -> u16 {
- if self.columns.len() > 1 {
- 1
- } else {
- 0
- }
- }
+// process:
+// - read all the files into a list, maxed out at a large value
+// - on input change:
+// - score all the names in relation to input
- pub fn toggle_preview(&mut self) {
- self.show_preview = !self.show_preview;
+impl<T: 'static> Component for Picker<T> {
+ fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
+ self.completion_height = viewport.1.saturating_sub(4);
+ Some(viewport)
}
- fn prompt_handle_event(&mut self, event: &Event, cx: &mut Context) -> EventResult {
- if let EventResult::Consumed(_) = self.prompt.handle_event(event, cx) {
- self.handle_prompt_change(matches!(event, Event::Paste(_)));
- }
- EventResult::Consumed(None)
- }
+ fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
+ let key_event = match event {
+ Event::Key(event) => event,
+ Event::Resize(..) => return EventResult::Consumed(None),
+ _ => return EventResult::Ignored(None),
+ };
- fn handle_prompt_change(&mut self, is_paste: bool) {
- // TODO: better track how the pattern has changed
- let line = self.prompt.line();
- let old_query = self.query.parse(line);
- if self.query == old_query {
- return;
- }
- // If the query has meaningfully changed, reset the cursor to the top of the results.
- self.cursor = 0;
- // Have nucleo reparse each changed column.
- for (i, column) in self
- .columns
- .iter()
- .filter(|column| column.filter)
- .enumerate()
- {
- let pattern = self
- .query
- .get(&column.name)
- .map(|f| &**f)
- .unwrap_or_default();
- let old_pattern = old_query
- .get(&column.name)
- .map(|f| &**f)
- .unwrap_or_default();
- // Fastlane: most columns will remain unchanged after each edit.
- if pattern == old_pattern {
- continue;
- }
- let is_append = pattern.starts_with(old_pattern);
- self.matcher.pattern.reparse(
- i,
- pattern,
- CaseMatching::Smart,
- Normalization::Smart,
- is_append,
- );
- }
- // If this is a dynamic picker, notify the query hook that the primary
- // query might have been updated.
- if let Some(handler) = &self.dynamic_query_handler {
- let event = DynamicQueryChange {
- query: self.primary_query(),
- is_paste,
- };
- helix_event::send_blocking(handler, event);
- }
- }
+ let close_fn = EventResult::Consumed(Some(Box::new(|compositor: &mut Compositor, _| {
+ // remove the layer
+ compositor.last_picker = compositor.pop();
+ })));
- /// Get (cached) preview for the currently selected item. If a document corresponding
- /// to the path is already open in the editor, it is used instead.
- fn get_preview<'picker, 'editor>(
- &'picker mut self,
- editor: &'editor Editor,
- ) -> Option<(Preview<'picker, 'editor>, Option<(usize, usize)>)> {
- let current = self.selection()?;
- let (path_or_id, range) = (self.file_fn.as_ref()?)(editor, current)?;
-
- match path_or_id {
- PathOrId::Path(path) => {
- if let Some(doc) = editor.document_by_path(path) {
- return Some((Preview::EditorDocument(doc), range));
+ match key_event.into() {
+ shift!(Tab) | key!(Up) | ctrl!('p') | ctrl!('k') => {
+ self.move_by(1, Direction::Backward);
+ }
+ key!(Tab) | key!(Down) | ctrl!('n') | ctrl!('j') => {
+ self.move_by(1, Direction::Forward);
+ }
+ key!(PageDown) | ctrl!('f') => {
+ self.page_down();
+ }
+ key!(PageUp) | ctrl!('b') => {
+ self.page_up();
+ }
+ key!(Home) => {
+ self.to_start();
+ }
+ key!(End) => {
+ self.to_end();
+ }
+ key!(Esc) | ctrl!('c') => {
+ return close_fn;
+ }
+ key!(Enter) => {
+ if let Some(option) = self.selection() {
+ (self.callback_fn)(cx, option, Action::Replace);
}
-
- if self.preview_cache.contains_key(path) {
- // NOTE: we use `HashMap::get_key_value` here instead of indexing so we can
- // retrieve the `Arc<Path>` key. The `path` in scope here is a `&Path` and
- // we can cheaply clone the key for the preview highlight handler.
- let (path, preview) = self.preview_cache.get_key_value(path).unwrap();
- if matches!(preview, CachedPreview::Document(doc) if doc.syntax().is_none()) {
- helix_event::send_blocking(&self.preview_highlight_handler, path.clone());
- }
- return Some((Preview::Cached(preview), range));
+ return close_fn;
+ }
+ ctrl!('s') => {
+ if let Some(option) = self.selection() {
+ (self.callback_fn)(cx, option, Action::HorizontalSplit);
}
-
- let path: Arc<Path> = path.into();
- let preview = std::fs::metadata(&path)
- .and_then(|metadata| {
- if metadata.is_dir() {
- let files = super::directory_content(&path, editor)?;
- let file_names: Vec<_> = files
- .iter()
- .filter_map(|(file_path, is_dir)| {
- let name = file_path
- .strip_prefix(&path)
- .map(|p| Some(p.as_os_str()))
- .unwrap_or_else(|_| file_path.file_name())?
- .to_string_lossy();
- if *is_dir {
- Some((format!("{}/", name), true))
- } else {
- Some((name.into_owned(), false))
- }
- })
- .collect();
- Ok(CachedPreview::Directory(file_names))
- } else if metadata.is_file() {
- if metadata.len() > MAX_FILE_SIZE_FOR_PREVIEW {
- return Ok(CachedPreview::LargeFile);
- }
- let content_type = std::fs::File::open(&path).and_then(|file| {
- // Read up to 1kb to detect the content type
- let n = file.take(1024).read_to_end(&mut self.read_buffer)?;
- let content_type =
- content_inspector::inspect(&self.read_buffer[..n]);
- self.read_buffer.clear();
- Ok(content_type)
- })?;
- if content_type.is_binary() {
- return Ok(CachedPreview::Binary);
- }
- let mut doc = Document::open(
- &path,
- None,
- false,
- editor.config.clone(),
- editor.syn_loader.clone(),
- )
- .or(Err(std::io::Error::new(
- std::io::ErrorKind::NotFound,
- "Cannot open document",
- )))?;
- let loader = editor.syn_loader.load();
- if let Some(language_config) = doc.detect_language_config(&loader) {
- doc.language = Some(language_config);
- // Asynchronously highlight the new document
- helix_event::send_blocking(
- &self.preview_highlight_handler,
- path.clone(),
- );
- }
- Ok(CachedPreview::Document(Box::new(doc)))
- } else {
- Err(std::io::Error::new(
- std::io::ErrorKind::NotFound,
- "Neither a dir, nor a file",
- ))
- }
- })
- .unwrap_or(CachedPreview::NotFound);
- self.preview_cache.insert(path.clone(), preview);
- Some((Preview::Cached(&self.preview_cache[&path]), range))
+ return close_fn;
}
- PathOrId::Id(id) => {
- let doc = editor.documents.get(&id).unwrap();
- Some((Preview::EditorDocument(doc), range))
+ ctrl!('v') => {
+ if let Some(option) = self.selection() {
+ (self.callback_fn)(cx, option, Action::VerticalSplit);
+ }
+ return close_fn;
+ }
+ ctrl!(' ') => {
+ self.save_filter(cx);
+ }
+ _ => {
+ if let EventResult::Consumed(_) = self.prompt.handle_event(event, cx) {
+ // TODO: recalculate only if pattern changed
+ self.score();
+ }
}
}
- }
- fn render_picker(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
- let status = self.matcher.tick(10);
- let snapshot = self.matcher.snapshot();
- if status.changed {
- self.cursor = self
- .cursor
- .min(snapshot.matched_item_count().saturating_sub(1))
- }
+ EventResult::Consumed(None)
+ }
+ fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
let text_style = cx.editor.theme.get("ui.text");
let selected = cx.editor.theme.get("ui.text.focus");
- let highlight_style = cx.editor.theme.get("special").add_modifier(Modifier::BOLD);
+ let highlighted = cx.editor.theme.get("special").add_modifier(Modifier::BOLD);
// -- Render the frame:
// clear area
let background = cx.editor.theme.get("ui.background");
surface.clear_with(area, background);
- const BLOCK: Block<'_> = Block::bordered();
+ // don't like this but the lifetime sucks
+ let block = Block::default().borders(Borders::ALL);
// calculate the inner area inside the box
- let inner = BLOCK.inner(area);
+ let inner = block.inner(area);
- BLOCK.render(area, surface);
+ block.render(area, surface);
// -- Render the input bar:
- let count = format!(
- "{}{}/{}",
- if status.running || self.matcher.active_injectors() > 0 {
- "(running) "
- } else {
- ""
- },
- snapshot.matched_item_count(),
- snapshot.item_count(),
- );
-
let area = inner.clip_left(1).with_height(1);
- 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);
+ let count = format!("{}/{}", self.matches.len(), self.options.len());
surface.set_stringn(
(area.x + area.width).saturating_sub(count.len() as u16 + 1),
area.y,
@@ -733,457 +573,70 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
text_style,
);
+ self.prompt.render(area, surface, cx);
+
// -- Separator
- let sep_style = cx.editor.theme.get("ui.background.separator");
+ let sep_style = Style::default().fg(Color::Rgb(90, 89, 119));
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);
- }
+ let cell = surface.get_mut(x, inner.y + 1);
+ cell.set_symbol(borders.horizontal).set_style(sep_style);
}
// -- Render the contents:
- // subtract area of prompt from top
- let inner = inner.clip_top(2);
- 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);
- let end = offset
- .saturating_add(rows)
- .min(snapshot.matched_item_count());
- let mut indices = Vec::new();
- let mut matcher = MATCHER.lock();
- matcher.config = Config::DEFAULT;
- if self.file_fn.is_some() {
- matcher.config.set_match_paths()
- }
-
- let options = snapshot.matched_items(offset..end).map(|item| {
- let mut widths = self.widths.iter_mut();
- let mut matcher_index = 0;
-
- Row::new(self.columns.iter().map(|column| {
- if column.hidden {
- return Cell::default();
- }
-
- let Some(Constraint::Length(max_width)) = widths.next() else {
- unreachable!();
- };
- let mut cell = column.format(item.data, &self.editor_data);
- let width = if column.filter {
- snapshot.pattern().column_pattern(matcher_index).indices(
- item.matcher_columns[matcher_index].slice(..),
- &mut matcher,
- &mut indices,
- );
- indices.sort_unstable();
- indices.dedup();
- let mut indices = indices.drain(..);
- let mut next_highlight_idx = indices.next().unwrap_or(u32::MAX);
- let mut span_list = Vec::new();
- let mut current_span = String::new();
- let mut current_style = Style::default();
- let mut grapheme_idx = 0u32;
- let mut width = 0;
-
- let spans: &[Span] =
- cell.content.lines.first().map_or(&[], |it| it.0.as_slice());
- for span in spans {
- // this looks like a bug on first glance, we are iterating
- // graphemes but treating them as char indices. The reason that
- // this is correct is that nucleo will only ever consider the first char
- // of a grapheme (and discard the rest of the grapheme) so the indices
- // returned by nucleo are essentially grapheme indecies
- for grapheme in span.content.graphemes(true) {
- let style = if grapheme_idx == next_highlight_idx {
- next_highlight_idx = indices.next().unwrap_or(u32::MAX);
- span.style.patch(highlight_style)
- } else {
- span.style
- };
- if style != current_style {
- if !current_span.is_empty() {
- span_list.push(Span::styled(current_span, current_style))
- }
- current_span = String::new();
- current_style = style;
- }
- current_span.push_str(grapheme);
- grapheme_idx += 1;
- }
- width += span.width();
- }
-
- span_list.push(Span::styled(current_span, current_style));
- cell = Cell::from(Spans::from(span_list));
- matcher_index += 1;
- width
- } else {
- cell.content
- .lines
- .first()
- .map(|line| line.width())
- .unwrap_or_default()
- };
-
- if width as u16 > *max_width {
- *max_width = width as u16;
- }
-
- cell
- }))
- });
-
- let mut table = Table::new(options)
- .style(text_style)
- .highlight_style(selected)
- .highlight_symbol(" > ")
- .column_spacing(1)
- .widths(&self.widths);
-
- // -- Header
- if self.columns.len() > 1 {
- let active_column = self.query.active_column(self.prompt.position());
- let header_style = cx.editor.theme.get("ui.picker.header");
- let header_column_style = cx.editor.theme.get("ui.picker.header.column");
-
- table = table.header(
- Row::new(self.columns.iter().map(|column| {
- if column.hidden {
- Cell::default()
- } else {
- let style =
- if active_column.is_some_and(|name| Arc::ptr_eq(name, &column.name)) {
- cx.editor.theme.get("ui.picker.header.column.active")
- } else {
- header_column_style
- };
-
- Cell::from(Span::styled(Cow::from(&*column.name), style))
- }
- }))
- .style(header_style),
- );
- }
-
- use tui::widgets::TableState;
-
- table.render_table(
- inner,
- surface,
- &mut TableState {
- offset: 0,
- selected: Some(cursor as usize),
- },
- self.truncate_start,
- );
- }
-
- fn render_preview(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
- // -- Render the frame:
- // clear area
- let background = cx.editor.theme.get("ui.background");
- let text = cx.editor.theme.get("ui.text");
- let directory = cx.editor.theme.get("ui.text.directory");
- surface.clear_with(area, background);
-
- const BLOCK: Block<'_> = Block::bordered();
-
- // calculate the inner area inside the box
- let inner = BLOCK.inner(area);
- // 1 column gap on either side
- let margin = Margin::horizontal(1);
- let inner = inner.inner(margin);
- BLOCK.render(area, surface);
-
- if let Some((preview, range)) = self.get_preview(cx.editor) {
- let doc = match preview.document() {
- Some(doc)
- if range.is_none_or(|(start, end)| {
- start <= end && end <= doc.text().len_lines()
- }) =>
- {
- doc
- }
- _ => {
- if let Some(dir_content) = preview.dir_content() {
- for (i, (path, is_dir)) in
- dir_content.iter().take(inner.height as usize).enumerate()
- {
- let style = if *is_dir { directory } else { text };
- surface.set_stringn(
- inner.x,
- inner.y + i as u16,
- path,
- inner.width as usize,
- style,
- );
- }
- return;
- }
-
- let alt_text = preview.placeholder();
- let x = inner.x + inner.width.saturating_sub(alt_text.len() as u16) / 2;
- let y = inner.y + inner.height / 2;
- surface.set_stringn(x, y, alt_text, inner.width as usize, text);
- return;
- }
- };
-
- let mut offset = ViewPosition::default();
- if let Some((start_line, end_line)) = range {
- let height = end_line - start_line;
- let text = doc.text().slice(..);
- let start = text.line_to_char(start_line);
- let middle = text.line_to_char(start_line + height / 2);
- if height < inner.height as usize {
- let text_fmt = doc.text_format(inner.width, None);
- let annotations = TextAnnotations::default();
- (offset.anchor, offset.vertical_offset) = char_idx_at_visual_offset(
- text,
- middle,
- // align to middle
- -(inner.height as isize / 2),
- 0,
- &text_fmt,
- &annotations,
- );
- if start < offset.anchor {
- offset.anchor = start;
- offset.vertical_offset = 0;
- }
- } else {
- offset.anchor = start;
- }
+ // subtract area of prompt from top and current item marker " > " from left
+ let inner = inner.clip_top(2).clip_left(3);
+
+ let rows = inner.height;
+ let offset = self.cursor - (self.cursor % std::cmp::max(1, rows as usize));
+
+ let files = self
+ .matches
+ .iter_mut()
+ .skip(offset)
+ .map(|(index, _score)| (*index, self.options.get(*index).unwrap()));
+
+ for (i, (_index, option)) in files.take(rows as usize).enumerate() {
+ let is_active = i == (self.cursor - offset);
+ if is_active {
+ surface.set_string(inner.x.saturating_sub(2), inner.y + i as u16, ">", selected);
}
- let loader = cx.editor.syn_loader.load();
-
- let syntax_highlighter =
- EditorView::doc_syntax_highlighter(doc, offset.anchor, area.height, &loader);
- let mut overlay_highlights = Vec::new();
-
- EditorView::doc_diagnostics_highlights_into(
- doc,
- &cx.editor.theme,
- &mut overlay_highlights,
- );
-
- let mut decorations = DecorationManager::default();
-
- if let Some((start, end)) = range {
- let style = cx
- .editor
- .theme
- .try_get("ui.highlight")
- .unwrap_or_else(|| cx.editor.theme.get("ui.selection"));
- let draw_highlight = move |renderer: &mut TextRenderer, pos: LinePos| {
- if (start..=end).contains(&pos.doc_line) {
- let area = Rect::new(
- renderer.viewport.x,
- pos.visual_line,
- renderer.viewport.width,
- 1,
- );
- renderer.set_style(area, style)
- }
- };
- decorations.add_decoration(draw_highlight);
- }
+ let formatted = (self.format_fn)(option);
- render_document(
- surface,
- inner,
- doc,
- offset,
- // TODO: compute text annotations asynchronously here (like inlay hints)
- &TextAnnotations::default(),
- syntax_highlighter,
- overlay_highlights,
- &cx.editor.theme,
- decorations,
- );
- }
- }
-}
-
-impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, D> {
- fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
- // +---------+ +---------+
- // |prompt | |preview |
- // +---------+ | |
- // |picker | | |
- // | | | |
- // +---------+ +---------+
-
- let render_preview =
- self.show_preview && self.file_fn.is_some() && area.width > MIN_AREA_WIDTH_FOR_PREVIEW;
-
- let picker_width = if render_preview {
- area.width / 2
- } else {
- area.width
- };
-
- let picker_area = area.with_width(picker_width);
- self.render_picker(picker_area, surface, cx);
-
- if render_preview {
- let preview_area = area.clip_left(picker_width);
- self.render_preview(preview_area, surface, cx);
- }
- }
-
- fn handle_event(&mut self, event: &Event, ctx: &mut Context) -> EventResult {
- // TODO: keybinds for scrolling preview
-
- let key_event = match event {
- Event::Key(event) => *event,
- Event::Paste(..) => return self.prompt_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() > 1_000_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))
- };
+ let (_score, highlights) = self
+ .matcher
+ .fuzzy_indices(&formatted, &self.prompt.line)
+ .unwrap_or_default();
- match key_event {
- shift!(Tab) | key!(Up) | ctrl!('p') => {
- self.move_by(1, Direction::Backward);
- }
- key!(Tab) | key!(Down) | ctrl!('n') => {
- self.move_by(1, Direction::Forward);
- }
- key!(PageDown) | ctrl!('d') => {
- self.page_down();
- }
- key!(PageUp) | ctrl!('u') => {
- self.page_up();
- }
- key!(Home) => {
- self.to_start();
- }
- key!(End) => {
- self.to_end();
- }
- key!(Esc) | ctrl!('c') => return close_fn(self),
- alt!(Enter) => {
- if let Some(option) = self.selection() {
- (self.callback_fn)(ctx, option, self.default_action);
- }
- }
- key!(Enter) => {
- // If the prompt has a history completion and is empty, use enter to accept
- // that completion
- if let Some(completion) = self
- .prompt
- .first_history_completion(ctx.editor)
- .filter(|_| self.prompt.line().is_empty())
- {
- // The percent character is used by the query language and needs to be
- // escaped with a backslash.
- let completion = if completion.contains('%') {
- completion.replace('%', "\\%")
+ surface.set_string_truncated(
+ inner.x,
+ inner.y + i as u16,
+ &formatted,
+ inner.width as usize,
+ |idx| {
+ if highlights.contains(&idx) {
+ highlighted
+ } else if is_active {
+ selected
} else {
- completion.into_owned()
- };
- self.prompt.set_line(completion, ctx.editor);
-
- // Inserting from the history register is a paste.
- self.handle_prompt_change(true);
- } else {
- if let Some(option) = self.selection() {
- (self.callback_fn)(ctx, option, self.default_action);
+ text_style
}
- if let Some(history_register) = self.prompt.history_register() {
- if let Err(err) = ctx
- .editor
- .registers
- .push(history_register, self.primary_query().to_string())
- {
- ctx.editor.set_error(err.to_string());
- }
- }
- return close_fn(self);
- }
- }
- ctrl!('s') => {
- if let Some(option) = self.selection() {
- (self.callback_fn)(ctx, option, Action::HorizontalSplit);
- }
- return close_fn(self);
- }
- ctrl!('v') => {
- if let Some(option) = self.selection() {
- (self.callback_fn)(ctx, option, Action::VerticalSplit);
- }
- return close_fn(self);
- }
- ctrl!('t') => {
- self.toggle_preview();
- }
- _ => {
- self.prompt_handle_event(event, ctx);
- }
+ },
+ true,
+ self.truncate_start,
+ );
}
-
- EventResult::Consumed(None)
}
fn cursor(&self, area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) {
- let block = Block::bordered();
+ let block = Block::default().borders(Borders::ALL);
// calculate the inner area inside the box
let inner = block.inner(area);
// prompt area
- let render_preview =
- self.show_preview && self.file_fn.is_some() && area.width > MIN_AREA_WIDTH_FOR_PREVIEW;
-
- let picker_width = if render_preview {
- area.width / 2
- } else {
- area.width
- };
- let area = inner.clip_left(1).with_height(1).with_width(picker_width);
+ let area = inner.clip_left(1).with_height(1);
self.prompt.cursor(area, editor)
}
-
- fn required_size(&mut self, (width, height): (u16, u16)) -> Option<(u16, u16)> {
- self.completion_height = height.saturating_sub(4 + self.header_height());
- Some((width, height))
- }
-
- fn id(&self) -> Option<&'static str> {
- Some(ID)
- }
}
-impl<T: 'static + Send + Sync, D> Drop for Picker<T, D> {
- fn drop(&mut self) {
- // ensure we cancel any ongoing background threads streaming into the picker
- self.version.fetch_add(1, atomic::Ordering::Relaxed);
- }
-}
-
-type PickerCallback<T> = Box<dyn Fn(&mut Context, &T, Action)>;