Prepare cargo release

Author: ErikMcClure

Cargo.lock

@@ -32,6 +32,6 @@ tracing = "0.1.40"
 feather-ui = { path = "feather-ui" }
 alicorn = "0.1.2"
 feather-macro = { version = "0.2", path = "feather-macro" }
-cosmic-text = { git = "https://github.com/pop-os/cosmic-text" }  # TODO: change back to a proper release once fixes we need make it into stable
+cosmic-text = { version = "0.14.2", git = "https://github.com/pop-os/cosmic-text", rev = "d15011fba547ae6bd2cbc7591991ff74424c6db7" } # TODO: change back to a proper release once fixes we need make it into stable
 
 [workspace.lints]

Cargo.toml

@@ -13,6 +13,173 @@ use cosmic_text::{
 
 use crate::text::Change;
 
+// Temporary hack until cosmic-text deploys a new version with this fix: https://github.com/pop-os/cosmic-text/pull/396
+#[derive(Debug)]
+pub struct FixedRunIter<'b> {
+    buffer: &'b cosmic_text::Buffer,
+    line_i: usize,
+    layout_i: usize,
+    total_height: f32,
+    line_top: f32,
+}
+
+impl<'b> FixedRunIter<'b> {
+    pub fn new(buffer: &'b cosmic_text::Buffer) -> Self {
+        Self {
+            buffer,
+            line_i: buffer.scroll().line,
+            layout_i: 0,
+            total_height: 0.0,
+            line_top: 0.0,
+        }
+    }
+}
+
+impl<'b> Iterator for FixedRunIter<'b> {
+    type Item = cosmic_text::LayoutRun<'b>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(line) = self.buffer.lines.get(self.line_i) {
+            let shape = line.shape_opt()?;
+            let layout = line.layout_opt()?;
+            while let Some(layout_line) = layout.get(self.layout_i) {
+                self.layout_i += 1;
+
+                let line_height = layout_line
+                    .line_height_opt
+                    .unwrap_or(self.buffer.metrics().line_height);
+                self.total_height += line_height;
+
+                let line_top = self.line_top - self.buffer.scroll().vertical;
+                let glyph_height = layout_line.max_ascent + layout_line.max_descent;
+                let centering_offset = (line_height - glyph_height) / 2.0;
+                let line_y = line_top + centering_offset + layout_line.max_ascent;
+                if let Some(height) = self.buffer.size().1 {
+                    if line_y - layout_line.max_ascent > height {
+                        return None;
+                    }
+                }
+                self.line_top += line_height;
+                if line_y + layout_line.max_descent < 0.0 {
+                    continue;
+                }
+
+                return Some(cosmic_text::LayoutRun {
+                    line_i: self.line_i,
+                    text: line.text(),
+                    rtl: shape.rtl,
+                    glyphs: &layout_line.glyphs,
+                    line_y,
+                    line_top,
+                    line_height,
+                    line_w: layout_line.w,
+                });
+            }
+            self.line_i += 1;
+            self.layout_i = 0;
+        }
+
+        None
+    }
+}
+
+// Reimplementation of hit() using our FixedRunIter
+fn hit_fixed(buffer: &Buffer, x: f32, y: f32) -> Option<Cursor> {
+    let mut new_cursor_opt = None;
+
+    let mut runs = FixedRunIter::new(buffer).peekable();
+    let mut first_run = true;
+    while let Some(run) = runs.next() {
+        let line_top = run.line_top;
+        let line_height = run.line_height;
+
+        if first_run && y < line_top {
+            first_run = false;
+            let new_cursor = Cursor::new(run.line_i, 0);
+            new_cursor_opt = Some(new_cursor);
+        } else if y >= line_top && y < line_top + line_height {
+            let mut new_cursor_glyph = run.glyphs.len();
+            let mut new_cursor_char = 0;
+            let mut new_cursor_affinity = cosmic_text::Affinity::After;
+
+            let mut first_glyph = true;
+
+            'hit: for (glyph_i, glyph) in run.glyphs.iter().enumerate() {
+                if first_glyph {
+                    first_glyph = false;
+                    if (run.rtl && x > glyph.x) || (!run.rtl && x < 0.0) {
+                        new_cursor_glyph = 0;
+                        new_cursor_char = 0;
+                    }
+                }
+                if x >= glyph.x && x <= glyph.x + glyph.w {
+                    new_cursor_glyph = glyph_i;
+
+                    let cluster = &run.text[glyph.start..glyph.end];
+                    let total = cluster.grapheme_indices(true).count();
+                    let mut egc_x = glyph.x;
+                    let egc_w = glyph.w / (total as f32);
+                    for (egc_i, egc) in cluster.grapheme_indices(true) {
+                        if x >= egc_x && x <= egc_x + egc_w {
+                            new_cursor_char = egc_i;
+
+                            let right_half = x >= egc_x + egc_w / 2.0;
+                            if right_half != glyph.level.is_rtl() {
+                                // If clicking on last half of glyph, move cursor past glyph
+                                new_cursor_char += egc.len();
+                                new_cursor_affinity = cosmic_text::Affinity::Before;
+                            }
+                            break 'hit;
+                        }
+                        egc_x += egc_w;
+                    }
+
+                    let right_half = x >= glyph.x + glyph.w / 2.0;
+                    if right_half != glyph.level.is_rtl() {
+                        // If clicking on last half of glyph, move cursor past glyph
+                        new_cursor_char = cluster.len();
+                        new_cursor_affinity = cosmic_text::Affinity::Before;
+                    }
+                    break 'hit;
+                }
+            }
+
+            let mut new_cursor = Cursor::new(run.line_i, 0);
+
+            match run.glyphs.get(new_cursor_glyph) {
+                Some(glyph) => {
+                    // Position at glyph
+                    new_cursor.index = glyph.start + new_cursor_char;
+                    new_cursor.affinity = new_cursor_affinity;
+                }
+                None => {
+                    if let Some(glyph) = run.glyphs.last() {
+                        // Position at end of line
+                        new_cursor.index = glyph.end;
+                        new_cursor.affinity = cosmic_text::Affinity::Before;
+                    }
+                }
+            }
+
+            new_cursor_opt = Some(new_cursor);
+
+            break;
+        } else if runs.peek().is_none() && y > run.line_y {
+            let mut new_cursor = Cursor::new(run.line_i, 0);
+            if let Some(glyph) = run.glyphs.last() {
+                new_cursor = if run.rtl {
+                    Cursor::new_with_affinity(run.line_i, glyph.start, cosmic_text::Affinity::After)
+                } else {
+                    Cursor::new_with_affinity(run.line_i, glyph.end, cosmic_text::Affinity::Before)
+                }
+            }
+            new_cursor_opt = Some(new_cursor);
+        }
+    }
+
+    new_cursor_opt
+}
+
 /// A wrapper of [`Buffer`] for easy editing. Modified to use an external Rc<RefCell<Buffer>> reference
 /// to work better with our immutable framework
 #[derive(Debug, Clone)]
@@ -718,7 +885,7 @@ impl Editor {
             Action::Click { x, y } => {
                 self.set_selection(buffer, Selection::None);
 
-                if let Some(new_cursor) = buffer.hit(x as f32, y as f32) {
+                if let Some(new_cursor) = hit_fixed(buffer, x as f32, y as f32) {
                     if new_cursor != self.cursor {
                         self.set_cursor(buffer, new_cursor);
                         buffer.set_redraw(true);
@@ -729,7 +896,7 @@ impl Editor {
             Action::DoubleClick { x, y } => {
                 self.set_selection(buffer, Selection::None);
 
-                if let Some(new_cursor) = buffer.hit(x as f32, y as f32) {
+                if let Some(new_cursor) = hit_fixed(buffer, x as f32, y as f32) {
                     if new_cursor != self.cursor {
                         self.set_cursor(buffer, new_cursor);
                         buffer.set_redraw(true);
@@ -740,7 +907,7 @@ impl Editor {
                 SmallVec::new()
             }
             Action::Drag { x, y } => {
-                if let Some(new_cursor) = buffer.hit(x as f32, y as f32) {
+                if let Some(new_cursor) = hit_fixed(buffer, x as f32, y as f32) {
                     // We do not trigger a selection if only the affinity changes, because it's not visible and ends up being confusing.
                     if new_cursor.index != self.cursor.index || new_cursor.line != self.cursor.line
                     {
@@ -757,7 +924,7 @@ impl Editor {
             Action::Scroll { lines } => {
                 let mut scroll = buffer.scroll();
                 //TODO: align to layout lines
-                scroll.vertical += lines as f32 * buffer.metrics().line_height;
+                scroll.vertical += lines as f32 * buffer.metrics().line_height + 0.0001; // temporary hack until cosmic-text deploys a new version with this fix: https://github.com/pop-os/cosmic-text/pull/401
                 buffer.set_scroll(scroll);
                 SmallVec::new()
             }

feather-ui/src/editor.rs

@@ -36,7 +36,7 @@ impl Instance {
         context: &mut ScaleContext,
         cache_key: CacheKey,
     ) -> Option<Image> {
-        let font = match font_system.get_font(cache_key.font_id, cache_key.font_weight) {
+        let font = match font_system.get_font(cache_key.font_id) {
             Some(some) => some,
             None => {
                 debug_assert!(false, "did not find font {:?}", cache_key.font_id);