refactoring editor.rs

helix-term/src/editor.rs

@@ -4,7 +4,7 @@ use helix_view::{commands, keymap, View};
 
 use std::{
     borrow::Cow,
-    io::{self, stdout, Write},
+    io::{self, stdout, Stdout, Write},
     path::PathBuf,
     time::Duration,
 };
@@ -24,6 +24,8 @@ use crossterm::{
 
 use tui::{backend::CrosstermBackend, buffer::Buffer as Surface, layout::Rect, style::Style};
 
+const OFFSET: u16 = 6; // 5 linenr + 1 gutter
+
 type Terminal = tui::Terminal<CrosstermBackend<std::io::Stdout>>;
 
 static EX: smol::Executor = smol::Executor::new();
@@ -68,19 +70,26 @@ impl Editor {
         use tui::backend::Backend;
         use tui::style::Color;
         // TODO: ideally not mut but highlights require it because of cursor cache
-        match &mut self.view {
+        let viewport = Rect::new(OFFSET, 0, self.size.0, self.size.1 - 1); // - 1 for statusline
-            Some(view) => {
+        let text_color: Style = Style::default().fg(Color::Rgb(219, 191, 239)); // lilac
+
+        self.render_view(viewport);
+
+        self.render_prompt(text_color);
+
+        self.render_cursor(viewport, text_color);
+    }
+
+    pub fn render_view(&mut self, viewport: Rect) {
+        use tui::style::Color;
         let area = Rect::new(0, 0, self.size.0, self.size.1);
-                let mut stdout = stdout();
+        let mut view: &mut View = self.view.as_mut().unwrap();
         self.surface.reset(); // reset is faster than allocating new empty surface
 
         //  clear with background color
         self.surface
             .set_style(area, view.theme.get("ui.background"));
 
-                let offset = 5 + 1; // 5 linenr + 1 gutter
-                let viewport = Rect::new(offset, 0, self.size.0, self.size.1 - 1); // - 1 for statusline
-
         // TODO: inefficient, should feed chunks.iter() to tree_sitter.parse_with(|offset, pos|)
         let source_code = view.state.doc().to_string();
 
@@ -96,7 +105,6 @@ impl Editor {
         };
 
         // 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 view.state.syntax.as_mut() {
@@ -111,12 +119,9 @@ impl Editor {
                 end: range.end,
             })],
         };
-
         let mut spans = Vec::new();
-
         let mut visual_x = 0;
         let mut line = 0u16;
-
         let visible_selections: Vec<Range> = view
             .state
             .selection()
@@ -198,12 +203,8 @@ impl Editor {
 
                             // TODO: paint cursor heads except primary
 
-                                    self.surface.set_string(
+                            self.surface
-                                        offset + visual_x,
+                                .set_string(OFFSET + visual_x, line, grapheme, style);
-                                        line,
-                                        grapheme,
-                                        style,
-                                    );
 
                             visual_x += width;
                         }
@@ -214,15 +215,28 @@ impl Editor {
                 }
             }
         }
+    }
 
+    pub fn render_prompt(&mut self, text_color: Style) {
+        use tui::backend::Backend;
+        let view = self.view.as_ref().unwrap();
         let style: Style = view.theme.get("ui.linenr");
+        let last_line = view.last_line();
         for (i, line) in (view.first_line..last_line).enumerate() {
             self.surface
                 .set_stringn(0, i as u16, format!("{:>5}", line + 1), 5, style);
             // lavender
         }
 
+        // let lines = state
+        //     .doc
+        //     .lines_at(self.first_line as usize)
+        //     .take(self.size.1 as usize)
+        //     .map(|x| x.as_str().unwrap());
+
         // // iterate over selections and render them
+        // let select = Style::default().bg(tui::style::Color::LightBlue);
+        // let text = state.doc.slice(..);
         // for range in state.selection.ranges() {
         //     // get terminal coords for x,y for each range pos
         //     // TODO: this won't work with multiline
@@ -235,6 +249,8 @@ impl Editor {
         //         (y2 - y1 + 1) as u16,
         //     );
         //     self.surface.set_style(area, select);
+
+        //     // TODO: don't highlight next char in append mode
         // }
 
         // statusline
@@ -248,31 +264,29 @@ impl Editor {
             Rect::new(0, self.size.1 - 1, self.size.0, 1),
             view.theme.get("ui.statusline"),
         );
-                // TODO: unfocused one with different color
-                let text_color = Style::default().fg(Color::Rgb(219, 191, 239)); // lilac
         self.surface
             .set_string(1, self.size.1 - 1, mode, text_color);
+        self.terminal
+            .backend_mut()
+            .draw(self.cache.diff(&self.surface).into_iter());
+        // swap the buffer
+        std::mem::swap(&mut self.surface, &mut self.cache);
+    }
 
-                // set cursor shape
+    pub fn render_cursor(&mut self, viewport: Rect, text_color: Style) {
+        let mut pos: Position;
+        let view = self.view.as_ref().unwrap();
+        let mut stdout = stdout();
         match view.state.mode() {
             Mode::Insert => write!(stdout, "\x1B[6 q"),
-                    Mode::Normal => write!(stdout, "\x1B[2 q"),
+            mode => write!(stdout, "\x1B[2 q"),
-                    Mode::Goto => write!(stdout, "\x1B[2 q"),
-                    Mode::Command => write!(stdout, "\x1B[2 q"),
         };
-
-                // render the cursor
-                let mut pos: Position;
         if view.state.mode() == Mode::Command {
             pos = Position::new(self.size.0 as usize, 2);
         } else {
             if let Some(path) = view.state.path() {
-                        self.surface.set_string(
+                self.surface
-                            6,
+                    .set_string(6, self.size.1 - 1, path.to_string_lossy(), text_color);
-                            self.size.1 - 1,
-                            path.to_string_lossy(),
-                            text_color,
-                        );
             }
 
             let cursor = view.state.selection().cursor();
@@ -284,17 +298,8 @@ impl Editor {
             pos.row += viewport.y as usize;
         }
 
-                self.terminal
-                    .backend_mut()
-                    .draw(self.cache.diff(&self.surface).into_iter());
-                // swap the buffer
-                std::mem::swap(&mut self.surface, &mut self.cache);
-
         execute!(stdout, cursor::MoveTo(pos.col as u16, pos.row as u16));
     }
-            None => (),
-        }
-    }
 
     pub async fn event_loop(&mut self) {
         let mut reader = EventStream::new();
@@ -331,9 +336,9 @@ impl Editor {
                     // TODO: sequences (`gg`)
                     // TODO: handle count other than 1
                     if let Some(view) = &mut self.view {
+                        let keys = vec![event];
                         match view.state.mode() {
                             Mode::Insert => {
-                                let keys = vec![event];
                                 if let Some(command) = keymap[&Mode::Insert].get(&keys) {
                                     command(view, 1);
                                 } else if let KeyEvent {
@@ -344,44 +349,25 @@ impl Editor {
                                     commands::insert::insert_char(view, c);
                                 }
                                 view.ensure_cursor_in_view();
-
                                 self.render();
                             }
-                            Mode::Normal => {
+                            Mode::Command => {
-                                let keys = vec![event];
+                                if let Some(command) = keymap[&Mode::Command].get(&keys) {
-                                if let Some(command) = keymap[&Mode::Normal].get(&keys) {
                                     command(view, 1);
-
-                                    // TODO: simplistic ensure cursor in view for now
-                                    view.ensure_cursor_in_view();
-
                                     self.render();
                                 }
                             }
-                            Mode::Goto => {
+                            mode => {
-                                // TODO: handle modes and sequences (`gg`)
+                                if let Some(command) = keymap[&mode].get(&keys) {
-                                let keys = vec![event];
-                                if let Some(command) = keymap[&Mode::Goto].get(&keys) {
-                                    // TODO: handle count other than 1
                                     command(view, 1);
 
                                     // TODO: simplistic ensure cursor in view for now
                                     view.ensure_cursor_in_view();
-
-                                    self.render();
-                                }
-                            }
-                            Mode::Command => {
-                                // TODO: handle modes and sequences (`gg`)
-                                let keys = vec![event];
-                                if let Some(command) = keymap[&Mode::Goto].get(&keys) {
-                                    // TODO: handle count other than 1
-                                    command(view, 1);
-
                                     self.render();
                                 }
                             }
                         }
+                        self.render();
                     }
                 }
                 Some(Ok(_)) => {