Make editor a widget

src/ui/widgets/editor.rs

@@ -0,0 +1,291 @@
+use std::iter;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use parking_lot::Mutex;
+use toss::frame::{Frame, Pos, Size};
+use toss::styled::Styled;
+use unicode_segmentation::UnicodeSegmentation;
+
+use super::Widget;
+
+///////////
+// State //
+///////////
+
+struct InnerEditorState {
+    text: String,
+
+    /// Index of the cursor in the text.
+    ///
+    /// Must point to a valid grapheme boundary.
+    idx: usize,
+
+    /// Width of the text when the editor was last rendered.
+    ///
+    /// Does not include additional column for cursor.
+    last_width: usize,
+}
+
+impl InnerEditorState {
+    fn new() -> Self {
+        Self {
+            text: String::new(),
+            idx: 0,
+            last_width: 0,
+        }
+    }
+
+    fn grapheme_boundaries(&self) -> Vec<usize> {
+        self.text
+            .grapheme_indices(true)
+            .map(|(i, _)| i)
+            .chain(iter::once(self.text.len()))
+            .collect()
+    }
+
+    /// Ensure the cursor index lies on a grapheme boundary.
+    ///
+    /// If it doesn't, it is moved to the next grapheme boundary.
+    fn move_cursor_to_grapheme_boundary(&mut self) {
+        for i in self.grapheme_boundaries() {
+            #[allow(clippy::comparison_chain)]
+            if i == self.idx {
+                // We're at a valid grapheme boundary already
+                return;
+            } else if i > self.idx {
+                // There was no valid grapheme boundary at our cursor index, so
+                // we'll take the next one we can get.
+                self.idx = i;
+                return;
+            }
+        }
+
+        // This loop should always return since the index behind the last
+        // grapheme is included in the grapheme boundary iterator.
+        panic!("cursor index out of bounds");
+    }
+
+    /// Insert a character at the current cursor position and move the cursor
+    /// accordingly.
+    fn insert_char(&mut self, ch: char) {
+        self.text.insert(self.idx, ch);
+        self.idx += 1;
+        self.move_cursor_to_grapheme_boundary();
+    }
+
+    /// Delete the grapheme before the cursor position.
+    fn backspace(&mut self) {
+        let boundaries = self.grapheme_boundaries();
+        for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) {
+            if *end == self.idx {
+                self.text.replace_range(start..end, "");
+                self.idx = *start;
+                break;
+            }
+        }
+    }
+
+    /// Delete the grapheme after the cursor position.
+    fn delete(&mut self) {
+        let boundaries = self.grapheme_boundaries();
+        for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) {
+            if *start == self.idx {
+                self.text.replace_range(start..end, "");
+                break;
+            }
+        }
+    }
+
+    fn move_cursor_left(&mut self) {
+        let boundaries = self.grapheme_boundaries();
+        for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) {
+            if *end == self.idx {
+                self.idx = *start;
+                break;
+            }
+        }
+    }
+
+    fn move_cursor_right(&mut self) {
+        let boundaries = self.grapheme_boundaries();
+        for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) {
+            if *start == self.idx {
+                self.idx = *end;
+                break;
+            }
+        }
+    }
+
+    /*
+    fn wrap(&self, frame: &mut Frame, width: usize) -> Vec<Range<usize>> {
+        let mut rows = vec![];
+        let mut start = 0;
+        let mut col = 0;
+        for (i, g) in self.text.grapheme_indices(true) {
+            let grapheme_width = if g == "\t" {
+                frame.tab_width_at_column(col)
+            } else {
+                frame.grapheme_width(g)
+            } as usize;
+
+            if col + grapheme_width > width {
+                rows.push(start..i);
+                start = i;
+                col = grapheme_width;
+            } else {
+                col += grapheme_width;
+            }
+        }
+        rows.push(start..self.text.len());
+        rows
+    }
+
+    pub fn render_highlighted<F>(&self, frame: &mut Frame, pos: Pos, width: usize, highlight: F)
+    where
+        F: Fn(&str) -> Styled,
+    {
+        let text = highlight(&self.text);
+        let row_ranges = self.wrap(frame, width);
+        let breakpoints = row_ranges
+            .iter()
+            .skip(1)
+            .map(|r| r.start)
+            .collect::<Vec<_>>();
+        let rows = text.split_at_indices(&breakpoints);
+        for (i, row) in rows.into_iter().enumerate() {
+            let pos = pos + Pos::new(0, i as i32);
+            frame.write(pos, row);
+        }
+    }
+
+    pub fn render_with_style(
+        &self,
+        frame: &mut Frame,
+        pos: Pos,
+        width: usize,
+        style: ContentStyle,
+    ) {
+        self.render_highlighted(frame, pos, width, |s| Styled::new((s, style)));
+    }
+
+    pub fn render(&self, frame: &mut Frame, pos: Pos, width: usize) {
+        self.render_highlighted(frame, pos, width, |s| Styled::new(s));
+    }
+    */
+}
+
+pub struct EditorState(Arc<Mutex<InnerEditorState>>);
+
+impl EditorState {
+    pub fn new() -> Self {
+        Self(Arc::new(Mutex::new(InnerEditorState::new())))
+    }
+
+    pub fn widget(&self) -> Editor {
+        let guard = self.0.lock();
+        let text = Styled::new(guard.text.clone());
+        let idx = guard.idx;
+        Editor {
+            state: self.0.clone(),
+            text,
+            idx,
+        }
+    }
+
+    fn insert_char(&self, ch: char) {
+        self.0.lock().insert_char(ch);
+    }
+
+    /// Delete the grapheme before the cursor position.
+    fn backspace(&self) {
+        self.0.lock().backspace();
+    }
+
+    /// Delete the grapheme after the cursor position.
+    fn delete(&self) {
+        self.0.lock().delete();
+    }
+
+    // TODO Un-mut
+    fn move_cursor_left(&mut self) {
+        self.0.lock().move_cursor_left();
+    }
+
+    fn move_cursor_right(&self) {
+        self.0.lock().move_cursor_right();
+    }
+}
+
+////////////
+// Widget //
+////////////
+
+pub struct Editor {
+    state: Arc<Mutex<InnerEditorState>>,
+    text: Styled,
+    idx: usize,
+}
+
+impl Editor {
+    pub fn highlight<F>(mut self, f: F) -> Self
+    where
+        F: FnOnce(&str) -> Styled,
+    {
+        let text = self.text.text();
+        let new_text = f(&text);
+        assert_eq!(text, new_text.text());
+        self.text = new_text;
+        self
+    }
+
+    fn wrapped_cursor(cursor_idx: usize, break_indices: &[usize]) -> (usize, usize) {
+        let mut row = 0;
+        let mut line_idx = cursor_idx;
+
+        for break_idx in break_indices {
+            if cursor_idx < *break_idx {
+                break;
+            } else {
+                row += 1;
+                line_idx = cursor_idx - break_idx;
+            }
+        }
+
+        (row, line_idx)
+    }
+}
+
+#[async_trait]
+impl Widget for Editor {
+    fn size(&self, frame: &mut Frame, max_width: Option<u16>, _max_height: Option<u16>) -> Size {
+        let max_width = max_width.map(|w| w as usize).unwrap_or(usize::MAX).max(1);
+        let max_text_width = max_width - 1;
+        let indices = frame.wrap(&self.text.text(), max_text_width);
+        let lines = self.text.clone().split_at_indices(&indices);
+
+        let min_width = lines
+            .iter()
+            .map(|l| frame.width_styled(l))
+            .max()
+            .unwrap_or(0)
+            + 1;
+        let min_height = lines.len();
+        Size::new(min_width as u16, min_height as u16)
+    }
+
+    async fn render(self: Box<Self>, frame: &mut Frame) {
+        let width = frame.size().width.max(1);
+        let text_width = (width - 1) as usize;
+        let indices = frame.wrap(&self.text.text(), text_width);
+        let lines = self.text.split_at_indices(&indices);
+
+        let (cursor_row, cursor_line_idx) = Self::wrapped_cursor(self.idx, &indices);
+        let cursor_col = frame.width(lines[cursor_row].text().split_at(cursor_line_idx).0);
+        frame.set_cursor(Some(Pos::new(cursor_row as i32, cursor_col as i32)));
+
+        for (i, line) in lines.into_iter().enumerate() {
+            frame.write(Pos::new(0, i as i32), line);
+        }
+    }
+}