popup: wip work on completion popups
This commit is contained in:
parent
755632f231
commit
d4b85ce18d
10 changed files with 272 additions and 67 deletions
|
@ -70,7 +70,7 @@ impl Application {
|
|||
let area = self.terminal.size().unwrap();
|
||||
|
||||
compositor.render(area, self.terminal.current_buffer_mut(), &mut cx);
|
||||
let pos = compositor.cursor_position(area, &mut cx);
|
||||
let pos = compositor.cursor_position(area, &editor);
|
||||
|
||||
self.terminal.draw();
|
||||
self.terminal.set_cursor(pos.col as u16, pos.row as u16);
|
||||
|
@ -112,7 +112,7 @@ impl Application {
|
|||
.handle_event(Event::Resize(width, height), &mut cx)
|
||||
}
|
||||
Some(Ok(event)) => self.compositor.handle_event(event, &mut cx),
|
||||
Some(Err(x)) => panic!(x),
|
||||
Some(Err(x)) => panic!("{}", x),
|
||||
None => panic!(),
|
||||
};
|
||||
|
||||
|
|
|
@ -910,7 +910,8 @@ pub fn completion(cx: &mut Context) {
|
|||
|
||||
// TODO: if no completion, show some message or something
|
||||
if !res.is_empty() {
|
||||
let picker = ui::Picker::new(
|
||||
let snapshot = cx.doc().state.clone();
|
||||
let mut menu = ui::Menu::new(
|
||||
res,
|
||||
|item| {
|
||||
// format_fn
|
||||
|
@ -918,40 +919,75 @@ pub fn completion(cx: &mut Context) {
|
|||
|
||||
// TODO: use item.filter_text for filtering
|
||||
},
|
||||
|editor: &mut Editor, item| {
|
||||
use helix_lsp::{lsp, util};
|
||||
// determine what to insert: text_edit | insert_text | label
|
||||
let edit = if let Some(edit) = &item.text_edit {
|
||||
match edit {
|
||||
lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
|
||||
lsp::CompletionTextEdit::InsertAndReplace(item) => {
|
||||
unimplemented!("completion: insert_and_replace {:?}", item)
|
||||
move |editor: &mut Editor, item, event| {
|
||||
match event {
|
||||
PromptEvent::Abort => {
|
||||
// revert state
|
||||
let doc = &mut editor.view_mut().doc;
|
||||
doc.state = snapshot.clone();
|
||||
}
|
||||
PromptEvent::Validate => {
|
||||
let doc = &mut editor.view_mut().doc;
|
||||
|
||||
// revert state to what it was before the last update
|
||||
doc.state = snapshot.clone();
|
||||
|
||||
// extract as fn(doc, item):
|
||||
|
||||
// TODO: need to apply without composing state...
|
||||
// TODO: need to update lsp on accept/cancel by diffing the snapshot with
|
||||
// the final state?
|
||||
// -> on update simply update the snapshot, then on accept redo the call,
|
||||
// finally updating doc.changes + notifying lsp.
|
||||
//
|
||||
// or we could simply use doc.undo + apply when changing between options
|
||||
|
||||
let item = item.unwrap();
|
||||
|
||||
use helix_lsp::{lsp, util};
|
||||
// determine what to insert: text_edit | insert_text | label
|
||||
let edit = if let Some(edit) = &item.text_edit {
|
||||
match edit {
|
||||
lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
|
||||
lsp::CompletionTextEdit::InsertAndReplace(item) => {
|
||||
unimplemented!("completion: insert_and_replace {:?}", item)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
item.insert_text.as_ref().unwrap_or(&item.label);
|
||||
unimplemented!();
|
||||
// lsp::TextEdit::new(); TODO: calculate a TextEdit from insert_text
|
||||
// and we insert at position.
|
||||
};
|
||||
|
||||
// TODO: merge edit with additional_text_edits
|
||||
if let Some(additional_edits) = &item.additional_text_edits {
|
||||
if !additional_edits.is_empty() {
|
||||
unimplemented!(
|
||||
"completion: additional_text_edits: {:?}",
|
||||
additional_edits
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
let transaction =
|
||||
util::generate_transaction_from_edits(&doc.state, vec![edit]);
|
||||
doc.apply(&transaction);
|
||||
// TODO: append_changes_to_history(cx); if not in insert mode?
|
||||
}
|
||||
} else {
|
||||
item.insert_text.as_ref().unwrap_or(&item.label);
|
||||
unimplemented!();
|
||||
// lsp::TextEdit::new(); TODO: calculate a TextEdit from insert_text
|
||||
// and we insert at position.
|
||||
_ => (),
|
||||
};
|
||||
|
||||
// TODO: merge edit with additional_text_edits
|
||||
if let Some(additional_edits) = &item.additional_text_edits {
|
||||
if !additional_edits.is_empty() {
|
||||
unimplemented!("completion: additional_text_edits: {:?}", additional_edits);
|
||||
}
|
||||
}
|
||||
|
||||
let doc = &mut editor.view_mut().doc;
|
||||
let transaction = util::generate_transaction_from_edits(&doc.state, vec![edit]);
|
||||
doc.apply(&transaction);
|
||||
// TODO: append_changes_to_history(cx); if not in insert mode?
|
||||
},
|
||||
);
|
||||
|
||||
cx.callback = Some(Box::new(
|
||||
move |compositor: &mut Compositor, editor: &mut Editor| {
|
||||
compositor.push(Box::new(picker));
|
||||
let area = tui::layout::Rect::default(); // TODO: unused remove from cursor_position
|
||||
let mut pos = compositor.cursor_position(area, editor);
|
||||
pos.row += 1; // shift down by one row
|
||||
menu.set_position(pos);
|
||||
|
||||
compositor.push(Box::new(menu));
|
||||
},
|
||||
));
|
||||
|
||||
|
|
|
@ -54,13 +54,11 @@ pub trait Component {
|
|||
|
||||
fn render(&self, area: Rect, frame: &mut Surface, ctx: &mut Context);
|
||||
|
||||
fn cursor_position(&self, area: Rect, ctx: &mut Context) -> Option<Position> {
|
||||
fn cursor_position(&self, area: Rect, ctx: &Editor) -> Option<Position> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// struct Editor { };
|
||||
|
||||
// For v1:
|
||||
// Child views are something each view needs to handle on it's own for now, positioning and sizing
|
||||
// options, focus tracking. In practice this is simple: we only will need special solving for
|
||||
|
@ -83,29 +81,6 @@ pub trait Component {
|
|||
// - a popup panel / dialog with it's own interactions
|
||||
// - an autocomplete popup that doesn't change focus
|
||||
|
||||
//fn main() {
|
||||
// let root = Editor::new();
|
||||
// let compositor = Compositor::new();
|
||||
|
||||
// compositor.push(root);
|
||||
|
||||
// // pos: clip to bottom of screen
|
||||
// compositor.push_at(pos, Prompt::new(
|
||||
// ":",
|
||||
// (),
|
||||
// |input: &str| match input {}
|
||||
// )); // TODO: this Prompt needs to somehow call compositor.pop() on close, but it can't refer to parent
|
||||
// // Cursive solves this by allowing to return a special result on process_event
|
||||
// // that's either Ignore | Consumed(Opt<C>) where C: fn (Compositor) -> ()
|
||||
|
||||
// // TODO: solve popup focus: we want to push autocomplete popups on top of the current layer
|
||||
// // but retain the focus where it was. The popup will also need to update as we type into the
|
||||
// // textarea. It should also capture certain input, such as tab presses etc
|
||||
// //
|
||||
// // 1) This could be faked by the top layer pushing down edits into the previous layer.
|
||||
// // 2) Alternatively,
|
||||
//}
|
||||
|
||||
pub struct Compositor {
|
||||
layers: Vec<Box<dyn Component>>,
|
||||
}
|
||||
|
@ -124,14 +99,15 @@ impl Compositor {
|
|||
}
|
||||
|
||||
pub fn handle_event(&mut self, event: Event, cx: &mut Context) -> bool {
|
||||
// TODO: custom focus
|
||||
if let Some(layer) = self.layers.last_mut() {
|
||||
return match layer.handle_event(event, cx) {
|
||||
// propagate events through the layers until we either find a layer that consumes it or we
|
||||
// run out of layers (event bubbling)
|
||||
for layer in self.layers.iter_mut().rev() {
|
||||
match layer.handle_event(event, cx) {
|
||||
EventResult::Consumed(Some(callback)) => {
|
||||
callback(self, cx.editor);
|
||||
true
|
||||
return true;
|
||||
}
|
||||
EventResult::Consumed(None) => true,
|
||||
EventResult::Consumed(None) => return true,
|
||||
EventResult::Ignored => false,
|
||||
};
|
||||
}
|
||||
|
@ -144,9 +120,9 @@ impl Compositor {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn cursor_position(&self, area: Rect, cx: &mut Context) -> Position {
|
||||
pub fn cursor_position(&self, area: Rect, editor: &Editor) -> Position {
|
||||
for layer in self.layers.iter().rev() {
|
||||
if let Some(pos) = layer.cursor_position(area, cx) {
|
||||
if let Some(pos) = layer.cursor_position(area, editor) {
|
||||
return pos;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -365,12 +365,12 @@ impl Component for EditorView {
|
|||
// TODO: drop unwrap
|
||||
}
|
||||
|
||||
fn cursor_position(&self, area: Rect, ctx: &mut Context) -> Option<Position> {
|
||||
fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {
|
||||
// match view.doc.mode() {
|
||||
// Mode::Insert => write!(stdout, "\x1B[6 q"),
|
||||
// mode => write!(stdout, "\x1B[2 q"),
|
||||
// };
|
||||
let view = ctx.editor.view();
|
||||
let view = editor.view();
|
||||
let cursor = view.doc.state.selection().cursor();
|
||||
|
||||
let mut pos = view
|
||||
|
|
189
helix-term/src/ui/menu.rs
Normal file
189
helix-term/src/ui/menu.rs
Normal file
|
@ -0,0 +1,189 @@
|
|||
use crate::compositor::{Component, Compositor, Context, EventResult};
|
||||
use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
|
||||
use tui::buffer::Buffer as Surface;
|
||||
use tui::{
|
||||
layout::Rect,
|
||||
style::{Color, Style},
|
||||
widgets::{Block, Borders},
|
||||
};
|
||||
|
||||
use std::borrow::Cow;
|
||||
|
||||
use helix_core::Position;
|
||||
use helix_view::Editor;
|
||||
|
||||
// TODO: factor out a popup component that we can reuse for displaying docs on autocomplete,
|
||||
// diagnostics popups, etc.
|
||||
|
||||
pub struct Menu<T> {
|
||||
options: Vec<T>,
|
||||
|
||||
cursor: usize,
|
||||
|
||||
position: Position,
|
||||
|
||||
format_fn: Box<dyn Fn(&T) -> Cow<str>>,
|
||||
callback_fn: Box<dyn Fn(&mut Editor, Option<&T>, MenuEvent)>,
|
||||
}
|
||||
|
||||
impl<T> Menu<T> {
|
||||
// TODO: it's like a slimmed down picker, share code? (picker = menu + prompt with different
|
||||
// rendering)
|
||||
pub fn new(
|
||||
options: Vec<T>,
|
||||
format_fn: impl Fn(&T) -> Cow<str> + 'static,
|
||||
callback_fn: impl Fn(&mut Editor, Option<&T>, MenuEvent) + 'static,
|
||||
) -> Self {
|
||||
Self {
|
||||
options,
|
||||
cursor: 0,
|
||||
position: Position::default(),
|
||||
format_fn: Box::new(format_fn),
|
||||
callback_fn: Box::new(callback_fn),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_position(&mut self, pos: Position) {
|
||||
self.position = pos;
|
||||
}
|
||||
|
||||
pub fn move_up(&mut self) {
|
||||
self.cursor = self.cursor.saturating_sub(1);
|
||||
}
|
||||
|
||||
pub fn move_down(&mut self) {
|
||||
// TODO: len - 1
|
||||
if self.cursor < self.options.len() {
|
||||
self.cursor += 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn selection(&self) -> Option<&T> {
|
||||
self.options.get(self.cursor)
|
||||
}
|
||||
}
|
||||
|
||||
use super::PromptEvent as MenuEvent;
|
||||
|
||||
impl<T> Component for Menu<T> {
|
||||
fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
|
||||
let event = match event {
|
||||
Event::Key(event) => event,
|
||||
_ => return EventResult::Ignored,
|
||||
};
|
||||
|
||||
let close_fn = EventResult::Consumed(Some(Box::new(
|
||||
|compositor: &mut Compositor, editor: &mut Editor| {
|
||||
// remove the layer
|
||||
compositor.pop();
|
||||
},
|
||||
)));
|
||||
|
||||
match event {
|
||||
// esc or ctrl-c aborts the completion and closes the menu
|
||||
KeyEvent {
|
||||
code: KeyCode::Esc, ..
|
||||
}
|
||||
| KeyEvent {
|
||||
code: KeyCode::Char('c'),
|
||||
modifiers: KeyModifiers::CONTROL,
|
||||
} => {
|
||||
(self.callback_fn)(cx.editor, self.selection(), MenuEvent::Abort);
|
||||
return close_fn;
|
||||
}
|
||||
// arrow up/ctrl-p/shift-tab prev completion choice (including updating the doc)
|
||||
KeyEvent {
|
||||
code: KeyCode::Tab,
|
||||
modifiers: KeyModifiers::SHIFT,
|
||||
}
|
||||
| KeyEvent {
|
||||
code: KeyCode::Up, ..
|
||||
}
|
||||
| KeyEvent {
|
||||
code: KeyCode::Char('p'),
|
||||
modifiers: KeyModifiers::CONTROL,
|
||||
} => {
|
||||
self.move_up();
|
||||
(self.callback_fn)(cx.editor, self.selection(), MenuEvent::Update);
|
||||
return EventResult::Consumed(None);
|
||||
}
|
||||
// arrow down/ctrl-n/tab advances completion choice (including updating the doc)
|
||||
KeyEvent {
|
||||
code: KeyCode::Tab,
|
||||
modifiers: KeyModifiers::NONE,
|
||||
}
|
||||
| KeyEvent {
|
||||
code: KeyCode::Down,
|
||||
..
|
||||
}
|
||||
| KeyEvent {
|
||||
code: KeyCode::Char('n'),
|
||||
modifiers: KeyModifiers::CONTROL,
|
||||
} => {
|
||||
self.move_down();
|
||||
(self.callback_fn)(cx.editor, self.selection(), MenuEvent::Update);
|
||||
return EventResult::Consumed(None);
|
||||
}
|
||||
KeyEvent {
|
||||
code: KeyCode::Enter,
|
||||
..
|
||||
} => {
|
||||
(self.callback_fn)(cx.editor, self.selection(), MenuEvent::Validate);
|
||||
return close_fn;
|
||||
}
|
||||
// KeyEvent {
|
||||
// code: KeyCode::Char(c),
|
||||
// modifiers: KeyModifiers::NONE,
|
||||
// } => {
|
||||
// self.insert_char(c);
|
||||
// (self.callback_fn)(cx.editor, &self.line, MenuEvent::Update);
|
||||
// }
|
||||
|
||||
// / -> edit_filter?
|
||||
//
|
||||
// enter confirms the match and closes the menu
|
||||
// typing filters the menu
|
||||
// if we run out of options the menu closes itself
|
||||
_ => (),
|
||||
}
|
||||
// for some events, we want to process them but send ignore, specifically all input except
|
||||
// tab/enter/ctrl-k or whatever will confirm the selection/ ctrl-n/ctrl-p for scroll.
|
||||
// EventResult::Consumed(None)
|
||||
EventResult::Ignored
|
||||
}
|
||||
fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
|
||||
// render a box at x, y. Width equal to max width of item.
|
||||
// initially limit to n items, add support for scrolling
|
||||
//
|
||||
const MAX: usize = 5;
|
||||
let rows = std::cmp::min(self.options.len(), MAX) as u16;
|
||||
let area = Rect::new(self.position.col as u16, self.position.row as u16, 30, rows);
|
||||
|
||||
// clear area
|
||||
let background = cx.editor.theme.get("ui.popup");
|
||||
for y in area.top()..area.bottom() {
|
||||
for x in area.left()..area.right() {
|
||||
let cell = surface.get_mut(x, y);
|
||||
cell.reset();
|
||||
// cell.symbol.clear();
|
||||
cell.set_style(background);
|
||||
}
|
||||
}
|
||||
|
||||
// -- Render the contents:
|
||||
|
||||
let style = Style::default().fg(Color::Rgb(164, 160, 232)); // lavender
|
||||
let selected = Style::default().fg(Color::Rgb(255, 255, 255));
|
||||
|
||||
for (i, option) in self.options.iter().take(rows as usize).enumerate() {
|
||||
// TODO: set bg for the whole row if selected
|
||||
surface.set_stringn(
|
||||
area.x,
|
||||
area.y + i as u16,
|
||||
(self.format_fn)(option),
|
||||
area.width as usize - 1,
|
||||
if i == self.cursor { selected } else { style },
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,8 +1,10 @@
|
|||
mod editor;
|
||||
mod menu;
|
||||
mod picker;
|
||||
mod prompt;
|
||||
|
||||
pub use editor::EditorView;
|
||||
pub use menu::Menu;
|
||||
pub use picker::Picker;
|
||||
pub use prompt::{Prompt, PromptEvent};
|
||||
|
||||
|
|
|
@ -257,7 +257,7 @@ impl<T> Component for Picker<T> {
|
|||
}
|
||||
}
|
||||
|
||||
fn cursor_position(&self, area: Rect, ctx: &mut Context) -> Option<Position> {
|
||||
self.prompt.cursor_position(area, ctx)
|
||||
fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {
|
||||
self.prompt.cursor_position(area, editor)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -235,7 +235,7 @@ impl Component for Prompt {
|
|||
self.render_prompt(area, surface, &cx.editor.theme)
|
||||
}
|
||||
|
||||
fn cursor_position(&self, area: Rect, ctx: &mut Context) -> Option<Position> {
|
||||
fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {
|
||||
Some(Position::new(
|
||||
area.height as usize,
|
||||
area.x as usize + self.prompt.len() + self.cursor,
|
||||
|
|
|
@ -157,6 +157,7 @@ impl Default for Theme {
|
|||
"ui.background" => Style::default().bg(Color::Rgb(59, 34, 76)), // midnight
|
||||
"ui.linenr" => Style::default().fg(Color::Rgb(90, 89, 119)), // comet
|
||||
"ui.statusline" => Style::default().bg(Color::Rgb(40, 23, 51)), // revolver
|
||||
"ui.popup" => Style::default().bg(Color::Rgb(40, 23, 51)), // revolver
|
||||
|
||||
"warning" => Style::default().fg(Color::Rgb(255, 205, 28)),
|
||||
};
|
||||
|
|
|
@ -19,6 +19,7 @@ pub struct View {
|
|||
pub first_line: usize,
|
||||
pub area: Rect,
|
||||
}
|
||||
// TODO: popups should be a thing on the view with a rect + text
|
||||
|
||||
impl View {
|
||||
pub fn new(doc: Document) -> Result<Self, Error> {
|
||||
|
|
Loading…
Reference in a new issue