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>, status_msg: Option, last_insert: (commands::Command, Vec), completion: Option, } 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); // cursor if let Some(end) = end { surface.set_style( Rect::new( viewport.x + end.col as u16, viewport.y + end.row as u16, 1, 1, ), cursor_style, ); } 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, ), 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, ); } } } // 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, 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 { // 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 } }