actually use the text library for text editing (fully working I think but code isn't cleanest)

src/core/text_edit.rs

@@ -0,0 +1,203 @@
+use crate::prelude::*;
+use cosmic_text::{Attrs, Cursor, Family, FontSystem, Metrics, Motion, Shaping};
+
+pub struct TextEdit {
+    pub attrs: TextAttrs,
+    /// inner alignment of text region (within where its drawn)
+    pub align: Align,
+    buf: TextBuffer,
+    cursor: Option<Cursor>,
+    size: Vec2,
+}
+
+impl TextEdit {
+    pub fn region(&self) -> UiRegion {
+        UiRegion::from_size_align(self.size, self.align)
+    }
+}
+
+impl Widget for TextEdit {
+    fn draw(&mut self, painter: &mut Painter) {
+        let font_system = &mut painter.text_data().font_system;
+        self.buf.shape_until_scroll(font_system, false);
+        self.attrs.apply(font_system, &mut self.buf);
+        let (handle, offset) = painter.render_text(
+            &mut self.buf,
+            &self.attrs,
+            &match self.cursor {
+                None => VisualCursor::None,
+                Some(cursor) => VisualCursor::Select {
+                    line: cursor.line as isize,
+                    col: cursor.index as isize,
+                },
+            },
+        );
+        let dims = handle.size();
+        self.size = offset.size(&handle);
+        let mut region = self.region();
+        region.top_left.offset += offset.top_left;
+        region.bot_right.offset = region.top_left.offset + dims;
+        painter.draw_texture_within(&handle, region);
+    }
+
+    fn get_size(&mut self, ctx: &mut SizeCtx) -> Vec2 {
+        let (handle, offset) = ctx.draw_text(&mut self.buf, &self.attrs, &VisualCursor::None);
+        offset.size(&handle)
+    }
+}
+
+pub struct TextEditBuilder {
+    pub content: String,
+    pub attrs: TextAttrs,
+    /// inner alignment of text region (within where its drawn)
+    pub align: Align,
+}
+
+impl TextEditBuilder {
+    pub fn font_size(mut self, size: impl UiNum) -> Self {
+        self.attrs.font_size = size.to_f32();
+        self.attrs.line_height = self.attrs.font_size * 1.1;
+        self
+    }
+    pub fn color(mut self, color: UiColor) -> Self {
+        self.attrs.color = color;
+        self
+    }
+    pub fn family(mut self, family: Family<'static>) -> Self {
+        self.attrs.family = family;
+        self
+    }
+    pub fn line_height(mut self, height: f32) -> Self {
+        self.attrs.line_height = height;
+        self
+    }
+}
+
+pub struct TextEditCtx<'a> {
+    pub text: &'a mut TextEdit,
+    pub font_system: &'a mut FontSystem,
+}
+
+impl<'a> TextEditCtx<'a> {
+    pub fn motion(&mut self, motion: Motion) {
+        if let Some(cursor) = self.text.cursor
+            && let Some((cursor, _)) =
+                self.text
+                    .buf
+                    .cursor_motion(self.font_system, cursor, None, motion)
+        {
+            self.text.cursor = Some(cursor);
+        }
+    }
+    pub fn insert(&mut self, text: &str) {
+        if let Some(cursor) = &mut self.text.cursor {
+            let line = &mut self.text.buf.lines[cursor.line];
+            let mut line_text = line.text().to_string();
+            line_text.insert_str(cursor.index, text);
+            line.set_text(line_text, line.ending(), line.attrs_list().clone());
+            for _ in 0..text.len() {
+                self.motion(Motion::Right);
+            }
+        }
+    }
+
+    pub fn newline(&mut self) {
+        if let Some(cursor) = &mut self.text.cursor {
+            let line = &mut self.text.buf.lines[cursor.line];
+            let new = line.split_off(cursor.index);
+            cursor.line += 1;
+            self.text.buf.lines.insert(cursor.line, new);
+            cursor.index = 0;
+        }
+    }
+
+    pub fn backspace(&mut self) {
+        if let Some(cursor) = &mut self.text.cursor {
+            if cursor.index == 0 {
+                if cursor.line == 0 {
+                    return;
+                }
+                let add = self.text.buf.lines.remove(cursor.line).into_text();
+                cursor.line -= 1;
+                let line = &mut self.text.buf.lines[cursor.line];
+                let mut cur = line.text().to_string();
+                cursor.index = cur.len();
+                cur.push_str(&add);
+                line.set_text(cur, line.ending(), line.attrs_list().clone());
+            } else {
+                let line = &mut self.text.buf.lines[cursor.line];
+                let mut text = line.text().to_string();
+                let idx = text.floor_char_boundary(cursor.index - 1);
+                text.remove(idx);
+                line.set_text(text, line.ending(), line.attrs_list().clone());
+                cursor.index = idx;
+            }
+        }
+    }
+
+    pub fn delete(&mut self) {
+        if let Some(cursor) = &mut self.text.cursor {
+            let line = &mut self.text.buf.lines[cursor.line];
+            if cursor.index == line.text().len() {
+                if cursor.line == self.text.buf.lines.len() - 1 {
+                    return;
+                }
+                let add = self.text.buf.lines.remove(cursor.line + 1).into_text();
+                let line = &mut self.text.buf.lines[cursor.line];
+                let mut cur = line.text().to_string();
+                cur.push_str(&add);
+                line.set_text(cur, line.ending(), line.attrs_list().clone());
+            } else {
+                let mut text = line.text().to_string();
+                text.remove(cursor.index);
+                line.set_text(text, line.ending(), line.attrs_list().clone());
+            }
+        }
+        if let Some(cursor) = self.text.cursor {
+            let line = &mut self.text.buf.lines[cursor.line];
+            let mut text = line.text().to_string();
+            text.remove(cursor.index);
+            line.set_text(text, line.ending(), line.attrs_list().clone());
+        }
+    }
+
+    pub fn select(&mut self, pos: Vec2, size: Vec2) {
+        let pos = pos - self.text.region().top_left.to_size(size);
+        self.text.cursor = self.text.buf.hit(pos.x, pos.y);
+    }
+
+    pub fn deselect(&mut self) {
+        self.text.cursor = None;
+    }
+}
+
+impl<Ctx> FnOnce<(&mut Ui<Ctx>,)> for TextEditBuilder {
+    type Output = TextEdit;
+
+    extern "rust-call" fn call_once(self, args: (&mut Ui<Ctx>,)) -> Self::Output {
+        let mut text = TextEdit {
+            buf: TextBuffer::new_empty(Metrics::new(self.attrs.font_size, self.attrs.line_height)),
+            attrs: self.attrs,
+            align: self.align,
+            cursor: None,
+            size: Vec2::ZERO,
+        };
+        text.buf.set_text(
+            &mut args.0.text.font_system,
+            &self.content,
+            &Attrs::new(),
+            Shaping::Advanced,
+        );
+        self.attrs
+            .apply(&mut args.0.text.font_system, &mut text.buf);
+        text
+    }
+}
+
+pub fn text_edit(content: impl Into<String>) -> TextEditBuilder {
+    TextEditBuilder {
+        content: content.into(),
+        attrs: TextAttrs::default(),
+        align: Align::Center,
+    }
+}