You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
helix-plus/helix-term/src/ui/editor.rs

618 lines
22 KiB
Rust

use crate::{
commands,
compositor::{Component, Compositor, Context, EventResult},
key,
keymap::{self, Keymaps},
ui::{text_color, Completion},
};
use helix_core::{
syntax::{self, HighlightEvent},
Position, Range,
};
use helix_view::{document::Mode, Document, Editor, Theme, View};
use std::borrow::Cow;
use crossterm::{
cursor,
event::{read, Event, EventStream, KeyCode, KeyEvent, KeyModifiers},
};
use tui::{
backend::CrosstermBackend,
buffer::Buffer as Surface,
layout::Rect,
style::{Color, Modifier, Style},
};
pub struct EditorView {
keymap: Keymaps,
on_next_key: Option<Box<dyn FnOnce(&mut commands::Context, KeyEvent)>>,
status_msg: Option<String>,
last_insert: (commands::Command, Vec<KeyEvent>),
completion: Option<Completion>,
}
const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter
impl EditorView {
pub fn new() -> Self {
Self {
keymap: keymap::default(),
on_next_key: None,
status_msg: None,
last_insert: (commands::normal_mode, Vec::new()),
completion: None,
}
}
pub fn render_view(
&self,
doc: &Document,
view: &View,
viewport: Rect,
surface: &mut Surface,
theme: &Theme,
is_focused: bool,
) {
let area = Rect::new(
viewport.x + OFFSET,
viewport.y,
viewport.width - OFFSET,
viewport.height.saturating_sub(1),
); // - 1 for statusline
self.render_buffer(doc, view, area, surface, theme, is_focused);
// clear with background color
// TODO: this seems to prevent setting style later
// surface.set_style(viewport, theme.get("ui.background"));
self.render_diagnostics(doc, view, area, surface, theme, is_focused);
let area = Rect::new(
viewport.x,
viewport.y + viewport.height.saturating_sub(1),
viewport.width,
1,
);
self.render_statusline(doc, area, surface, theme, is_focused);
// render status
if let Some(status_msg) = &self.status_msg {
let style = Style::default().fg(Color::Rgb(164, 160, 232)); // lavender
surface.set_string(viewport.x, viewport.y + viewport.height, status_msg, style);
}
}
pub fn render_buffer(
&self,
doc: &Document,
view: &View,
viewport: Rect,
surface: &mut Surface,
theme: &Theme,
is_focused: bool,
) {
let text = doc.text().slice(..);
let last_line = view.last_line(doc);
let range = {
// calculate viewport byte ranges
let start = text.line_to_byte(view.first_line);
let end = text.line_to_byte(last_line + 1);
start..end
};
// TODO: range doesn't actually restrict source, just highlight range
// TODO: cache highlight results
// TODO: only recalculate when state.doc is actually modified
let highlights: Vec<_> = match doc.syntax() {
Some(syntax) => {
syntax
.highlight_iter(text.slice(..), Some(range), None, |_| None)
.collect() // TODO: we collect here to avoid holding the lock, fix later
}
None => vec![Ok(HighlightEvent::Source {
start: range.start,
end: range.end,
})],
};
let mut spans = Vec::new();
let mut visual_x = 0;
let mut line = 0u16;
let tab_width = doc.tab_width();
'outer: for event in highlights {
match event.unwrap() {
HighlightEvent::HighlightStart(span) => {
spans.push(span);
}
HighlightEvent::HighlightEnd => {
spans.pop();
}
HighlightEvent::Source { start, end } => {
// TODO: filter out spans out of viewport for now..
// TODO: do these before iterating
let start = text.byte_to_char(start);
let end = text.byte_to_char(end);
let text = text.slice(start..end);
use helix_core::graphemes::{grapheme_width, RopeGraphemes};
// TODO: scope matching: biggest union match? [string] & [html, string], [string, html] & [ string, html]
// can do this by sorting our theme matches based on array len (longest first) then stopping at the
// first rule that matches (rule.all(|scope| scopes.contains(scope)))
let style = match spans.first() {
Some(span) => theme.get(theme.scopes()[span.0].as_str()),
None => Style::default().fg(Color::Rgb(164, 160, 232)), // lavender
};
// TODO: we could render the text to a surface, then cache that, that
// way if only the selection/cursor changes we can copy from cache
// and paint the new cursor.
// We could keep a single resizable surface on the View for that.
let mut char_index = start;
// iterate over range char by char
for grapheme in RopeGraphemes::new(text) {
if grapheme == "\n" {
visual_x = 0;
line += 1;
// TODO: with proper iter this shouldn't be necessary
if line >= viewport.height {
break 'outer;
}
} else if grapheme == "\t" {
visual_x += (tab_width as u16);
} else {
if visual_x >= viewport.width {
// if we're offscreen just keep going until we hit a new line
// TODO: will need tweaking when we also take into account
// horizontal scrolling
continue;
}
// Cow will prevent allocations if span contained in a single slice
// which should really be the majority case
let grapheme = Cow::from(grapheme);
let width = grapheme_width(&grapheme) as u16;
// ugh,interleave highlight spans with diagnostic spans
let is_diagnostic = doc.diagnostics.iter().any(|diagnostic| {
diagnostic.range.start <= char_index
&& diagnostic.range.end > char_index
});
let style = if is_diagnostic {
style.clone().add_modifier(Modifier::UNDERLINED)
} else {
style
};
surface.set_string(
viewport.x + visual_x,
viewport.y + line,
grapheme,
style,
);
visual_x += width;
}
char_index += 1;
}
}
}
}
// render selections
if is_focused {
let screen = {
let start = text.line_to_char(view.first_line);
let end = text.line_to_char(last_line + 1);
Range::new(start, end)
};
let cursor_style = Style::default()
// .bg(Color::Rgb(255, 255, 255))
.add_modifier(Modifier::REVERSED);
// let selection_style = Style::default().bg(Color::Rgb(94, 0, 128));
let selection_style = Style::default().bg(Color::Rgb(84, 0, 153));
for selection in doc
.selection(view.id)
.iter()
.filter(|range| range.overlaps(&screen))
{
// TODO: render also if only one of the ranges is in viewport
let mut start = view.screen_coords_at_pos(doc, text, selection.anchor);
let mut end = view.screen_coords_at_pos(doc, text, selection.head);
let head = end;
if selection.head < selection.anchor {
std::mem::swap(&mut start, &mut end);
}
let start = start.unwrap_or_else(|| Position::new(0, 0));
let end = end.unwrap_or_else(|| {
Position::new(viewport.height as usize, viewport.width as usize)
});
if start.row == end.row {
surface.set_style(
Rect::new(
viewport.x + start.col as u16,
viewport.y + start.row as u16,
(end.col - start.col) as u16 + 1,
1,
),
selection_style,
);
} else {
surface.set_style(
Rect::new(
viewport.x + start.col as u16,
viewport.y + start.row as u16,
// text.line(view.first_line).len_chars() as u16 - start.col as u16,
viewport.width - start.col as u16,
1,
),
selection_style,
);
for i in start.row + 1..end.row {
surface.set_style(
Rect::new(
viewport.x,
viewport.y + i as u16,
// text.line(view.first_line + i).len_chars() as u16,
viewport.width,
1,
),
selection_style,
);
}
surface.set_style(
Rect::new(viewport.x, viewport.y + end.row as u16, end.col as u16, 1),
selection_style,
);
}
// cursor
if let Some(head) = head {
surface.set_style(
Rect::new(
viewport.x + head.col as u16,
viewport.y + head.row as u16,
1,
1,
),
cursor_style,
);
}
}
}
// render gutters
let style: Style = theme.get("ui.linenr");
let warning: Style = theme.get("warning");
let error: Style = theme.get("error");
let info: Style = theme.get("info");
let hint: Style = theme.get("hint");
for (i, line) in (view.first_line..last_line).enumerate() {
use helix_core::diagnostic::Severity;
if let Some(diagnostic) = doc.diagnostics.iter().find(|d| d.line == line) {
surface.set_stringn(
viewport.x - OFFSET,
viewport.y + i as u16,
"●",
1,
match diagnostic.severity {
Some(Severity::Error) => error,
Some(Severity::Warning) | None => warning,
Some(Severity::Info) => info,
Some(Severity::Hint) => hint,
},
);
}
surface.set_stringn(
viewport.x + 1 - OFFSET,
viewport.y + i as u16,
format!("{:>5}", line + 1),
5,
style,
);
}
}
pub fn render_diagnostics(
&self,
doc: &Document,
view: &View,
viewport: Rect,
surface: &mut Surface,
theme: &Theme,
is_focused: bool,
) {
use helix_core::diagnostic::Severity;
use tui::{
layout::Alignment,
text::Text,
widgets::{Paragraph, Widget},
};
let cursor = doc.selection(view.id).cursor();
let line = doc.text().char_to_line(cursor);
let diagnostics = doc.diagnostics.iter().filter(|diagnostic| {
diagnostic.range.start <= cursor && diagnostic.range.end >= cursor
});
let warning: Style = theme.get("warning");
let error: Style = theme.get("error");
let info: Style = theme.get("info");
let hint: Style = theme.get("hint");
// Vec::with_capacity(diagnostics.len()); // rough estimate
let mut lines = Vec::new();
for diagnostic in diagnostics {
let text = Text::styled(
&diagnostic.message,
match diagnostic.severity {
Some(Severity::Error) => error,
Some(Severity::Warning) | None => warning,
Some(Severity::Info) => info,
Some(Severity::Hint) => hint,
},
);
lines.extend(text.lines);
}
let paragraph = Paragraph::new(lines).alignment(Alignment::Right);
let width = 80.min(viewport.width);
let height = 15.min(viewport.height);
paragraph.render(
Rect::new(
viewport.right() - width,
viewport.y as u16 + 1,
width,
height,
),
surface,
);
}
pub fn render_statusline(
&self,
doc: &Document,
viewport: Rect,
surface: &mut Surface,
theme: &Theme,
is_focused: bool,
) {
let mode = match doc.mode() {
Mode::Insert => "INS",
Mode::Select => "SEL",
Mode::Normal => "NOR",
};
// TODO: share text_color styles inside theme
let text_color = if is_focused {
Style::default().fg(Color::Rgb(219, 191, 239)) // lilac
} else {
Style::default().fg(Color::Rgb(164, 160, 232)) // lavender
};
// statusline
surface.set_style(
Rect::new(viewport.x, viewport.y, viewport.width, 1),
theme.get("ui.statusline"),
);
if is_focused {
surface.set_string(viewport.x + 1, viewport.y, mode, text_color);
}
if let Some(path) = doc.relative_path() {
let path = path.to_string_lossy();
let title = format!("{}{}", path, if doc.modified() { "[+]" } else { "" });
surface.set_stringn(
viewport.x + 6,
viewport.y,
title,
viewport.width.saturating_sub(6) as usize,
text_color,
);
}
surface.set_string(
viewport.x + viewport.width.saturating_sub(10),
viewport.y,
format!("{}", doc.diagnostics.len()),
text_color,
);
}
fn insert_mode(&self, cx: &mut commands::Context, event: KeyEvent) {
if let Some(command) = self.keymap[&Mode::Insert].get(&event) {
command(cx);
} else if let KeyEvent {
code: KeyCode::Char(ch),
..
} = event
{
commands::insert::insert_char(cx, ch);
}
}
fn command_mode(&self, mode: Mode, cxt: &mut commands::Context, event: KeyEvent) {
match event {
// count handling
key!(i @ '0'..='9') => {
let i = i.to_digit(10).unwrap() as usize;
cxt.editor.count = Some(cxt.editor.count.map_or(i, |c| c * 10 + i));
}
// special handling for repeat operator
key!('.') => {
// first execute whatever put us into insert mode
(self.last_insert.0)(cxt);
// then replay the inputs
for key in &self.last_insert.1 {
self.insert_mode(cxt, *key)
}
}
_ => {
// set the count
cxt.count = cxt.editor.count.take().unwrap_or(1);
// TODO: edge case: 0j -> reset to 1
// if this fails, count was Some(0)
// debug_assert!(cxt.count != 0);
if let Some(command) = self.keymap[&mode].get(&event) {
command(cxt);
}
}
}
}
pub fn set_completion(
&mut self,
items: Vec<helix_lsp::lsp::CompletionItem>,
trigger_offset: usize,
size: Rect,
) {
let mut completion = Completion::new(items, trigger_offset);
// TODO : propagate required size on resize to completion too
completion.required_size((size.width, size.height));
self.completion = Some(completion);
}
}
impl Component for EditorView {
fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
match event {
Event::Resize(width, height) => {
// HAXX: offset the render area height by 1 to account for prompt/commandline
cx.editor.resize(Rect::new(0, 0, width, height - 1));
EventResult::Consumed(None)
}
Event::Key(key) => {
let (view, doc) = cx.editor.current();
let mode = doc.mode();
let mut cxt = commands::Context {
view_id: view.id,
editor: &mut cx.editor,
count: 1,
callback: None,
callbacks: cx.callbacks,
on_next_key_callback: None,
status_msg: None,
};
// clear status
self.status_msg = None;
if let Some(on_next_key) = self.on_next_key.take() {
// if there's a command waiting input, do that first
on_next_key(&mut cxt, key);
} else {
match mode {
Mode::Insert => {
// record last_insert key
self.last_insert.1.push(key);
// let completion swallow the event if necessary
let mut consumed = false;
if let Some(completion) = &mut self.completion {
// use a fake context here
let mut cx = Context {
editor: cxt.editor,
callbacks: cxt.callbacks,
executor: cx.executor,
scroll: None,
};
let res = completion.handle_event(event, &mut cx);
if let EventResult::Consumed(callback) = res {
consumed = true;
if callback.is_some() {
// assume close_fn
self.completion = None;
}
}
}
// if completion didn't take the event, we pass it onto commands
if !consumed {
self.insert_mode(&mut cxt, key);
// lastly we recalculate completion
if let Some(completion) = &mut self.completion {
completion.update(&mut cxt);
if completion.is_empty() {
self.completion = None;
}
// TODO: if exiting InsertMode, remove completion
}
}
}
mode => self.command_mode(mode, &mut cxt, key),
}
}
self.on_next_key = cxt.on_next_key_callback.take();
self.status_msg = cxt.status_msg.take();
// appease borrowck
let callback = cxt.callback.take();
let (view, doc) = cx.editor.current();
view.ensure_cursor_in_view(doc);
if mode == Mode::Normal && doc.mode() == Mode::Insert {
// HAXX: if we just entered insert mode from normal, clear key buf
// and record the command that got us into this mode.
// how we entered insert mode is important, and we should track that so
// we can repeat the side effect.
self.last_insert.0 = self.keymap[&mode][&key];
self.last_insert.1.clear();
};
EventResult::Consumed(callback)
}
Event::Mouse(_) => EventResult::Ignored,
}
}
fn render(&self, mut area: Rect, surface: &mut Surface, cx: &mut Context) {
for (view, is_focused) in cx.editor.tree.views() {
let doc = cx.editor.document(view.doc).unwrap();
self.render_view(doc, view, view.area, surface, &cx.editor.theme, is_focused);
}
if let Some(completion) = &self.completion {
completion.render(area, surface, cx)
// render completion here
}
}
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"),
// };
// return editor.cursor_position()
// It's easier to just not render the cursor and use selection rendering instead.
None
}
}