TudbuT/helix-mods
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

popup: wip work on completion popups

Browse source
This commit is contained in:
Blaž Hrastnik 2021-02-09 15:40:30 +09:00
parent 755632f231
commit d4b85ce18d
10 changed files with 272 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
helix-term/src/application.rs
View file

@ -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!(),
};

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

@ -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));
},
));

42
helix-term/src/compositor.rs
View file

@ -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;
}
}

4
helix-term/src/ui/editor.rs
View file

@ -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
View 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 },
);
}
}
}

2
helix-term/src/ui/mod.rs
View file

@ -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};

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

@ -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)
}
}

2
helix-term/src/ui/prompt.rs
View file

@ -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,

1
helix-view/src/theme.rs
View file

@ -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)),
};

1
helix-view/src/view.rs
View file

@ -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> {