Use the parley cursor

Author: expenses

internal/renderers/femtovg/fonts.rs

@@ -134,38 +134,6 @@ pub fn layout(text: &str, options: LayoutOptions) -> parley::Layout<sharedfontiq
     layout
 }
 
-pub fn get_cursor_location_and_size(
-    layout: &parley::Layout<sharedfontique::Brush>,
-    cursor_byte_offset: usize,
-    offset: f32,
-) -> Option<(PhysicalPoint, f32)> {
-    let mut cursor_point = None;
-
-    for line in layout.lines() {
-        for item in line.items() {
-            match item {
-                parley::PositionedLayoutItem::GlyphRun(glyph_run) => {
-                    let range = glyph_run.run().text_range();
-                    let size = glyph_run.run().font_size();
-                    if range.contains(&cursor_byte_offset) {
-                        cursor_point = glyph_run
-                            .positioned_glyphs()
-                            .nth(cursor_byte_offset - range.start)
-                            .map(|glyph| (PhysicalPoint::new(glyph.x, glyph.y + offset), size));
-                    } else if cursor_byte_offset == range.end {
-                        cursor_point = glyph_run.positioned_glyphs().last().map(|glyph| {
-                            (PhysicalPoint::new(glyph.x + glyph.advance, glyph.y + offset), size)
-                        });
-                    }
-                }
-                parley::PositionedLayoutItem::InlineBox(_inline_box) => {}
-            };
-        }
-    }
-
-    cursor_point
-}
-
 pub fn get_offset(
     vertical_align: TextVerticalAlignment,
     max_height: PhysicalLength,

internal/renderers/femtovg/itemrenderer.rs

@@ -532,16 +532,21 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
             text_input.selection_background_color(),
         );
 
-        if let Some((cursor_point, cursor_size)) = cursor_visible
-            .then_some(cursor_pos)
-            .and_then(|cursor_pos| fonts::get_cursor_location_and_size(&layout, cursor_pos, offset))
-        {
+        if cursor_visible {
+            let cursor = parley::layout::cursor::Cursor::from_byte_index(
+                &layout,
+                cursor_pos,
+                Default::default(),
+            );
+            let rect = cursor
+                .geometry(&layout, (text_input.text_cursor_width() * self.scale_factor).get());
+
             let mut cursor_rect = femtovg::Path::new();
             cursor_rect.rect(
-                cursor_point.x,
-                cursor_point.y - cursor_size,
-                (text_input.text_cursor_width() * self.scale_factor).get(),
-                cursor_size,
+                rect.center().x as _,
+                rect.center().y as _,
+                rect.width() as _,
+                rect.height() as _,
             );
             canvas.fill_path(
                 &cursor_rect,

internal/renderers/femtovg/lib.rs

@@ -9,7 +9,7 @@ use std::num::NonZeroU32;
 use std::pin::Pin;
 use std::rc::{Rc, Weak};
 
-use i_slint_common::sharedfontique;
+use i_slint_common::sharedfontique::{self, parley};
 use i_slint_core::api::{RenderingNotifier, RenderingState, SetRenderingNotifierError};
 use i_slint_core::graphics::{euclid, rendering_metrics_collector::RenderingMetricsCollector};
 use i_slint_core::graphics::{BorderRadius, Rgba8Pixel};
@@ -332,14 +332,11 @@ impl<B: GraphicsBackend> RendererSealed for FemtoVGRenderer<B> {
                 ..Default::default()
             },
         );
-        let _offset = fonts::get_offset(text_input.vertical_alignment(), height, &layout);
-
-        // TODO
-        let result = text.len();
+        let offset = fonts::get_offset(text_input.vertical_alignment(), height, &layout);
+        let cursor = parley::layout::cursor::Cursor::from_point(&layout, pos.x, pos.y - offset);
 
         let visual_representation = text_input.visual_representation(None);
-
-        visual_representation.map_byte_offset_from_byte_offset_in_visual_text(result)
+        visual_representation.map_byte_offset_from_byte_offset_in_visual_text(cursor.index())
     }
 
     fn text_input_cursor_rect_for_byte_offset(
@@ -366,12 +363,15 @@ impl<B: GraphicsBackend> RendererSealed for FemtoVGRenderer<B> {
             &text,
             fonts::LayoutOptions { max_width: Some(width), ..Default::default() },
         );
-        let cursor_position = fonts::get_cursor_location_and_size(&layout, byte_offset, 0.0)
-            .map(|location| location.0);
-
+        let cursor = parley::layout::cursor::Cursor::from_byte_index(
+            &layout,
+            byte_offset,
+            Default::default(),
+        );
+        let rect = cursor.geometry(&layout, (text_input.text_cursor_width() * scale_factor).get());
         LogicalRect::new(
-            cursor_position.unwrap_or_default() / scale_factor,
-            LogicalSize::from_lengths(LogicalLength::new(1.0), font_size),
+            LogicalPoint::new(rect.min_x() as _, rect.min_y() as _),
+            LogicalSize::new(rect.width() as _, rect.height() as _),
         )
     }