Start combining stuff WIP

expenses · expenses · commit 2405d419ac0b · 2025-09-24T09:55:31.000+02:00
diff --git a/internal/renderers/femtovg/fonts.rs b/internal/renderers/femtovg/fonts.rs
@@ -47,8 +47,10 @@ thread_local! {
 }
 
 pub struct LayoutOptions {
-    pub max_width: Option<PhysicalLength>,
+    pub max_width: Option<LogicalLength>,
+    pub max_height: Option<LogicalLength>,
     pub horizontal_align: TextHorizontalAlignment,
+    pub vertical_align: TextVerticalAlignment,
     pub stroke: Option<sharedfontique::BrushTextStrokeStyle>,
     pub selection: Option<std::ops::Range<usize>>,
     pub font_request: Option<FontRequest>,
@@ -59,7 +61,9 @@ impl Default for LayoutOptions {
     fn default() -> Self {
         Self {
             max_width: None,
+            max_height: None,
             horizontal_align: TextHorizontalAlignment::Left,
+            vertical_align: TextVerticalAlignment::Top,
             stroke: None,
             selection: None,
             font_request: None,
@@ -68,11 +72,11 @@ impl Default for LayoutOptions {
     }
 }
 
-pub fn layout(text: &str, options: LayoutOptions) -> parley::Layout<sharedfontique::Brush> {
+pub fn layout(text: &str, scale_factor: f32, options: LayoutOptions) -> Layout {
     let mut font_context = sharedfontique::font_context();
     let mut layout_context = sharedfontique::layout_context();
 
-    let mut builder = layout_context.ranged_builder(&mut font_context, text, 1.0, true);
+    let mut builder = layout_context.ranged_builder(&mut font_context, text, scale_factor, true);
     if let Some(ref font_request) = options.font_request {
         if let Some(family) = &font_request.family {
             builder.push_default(parley::StyleProperty::FontStack(
@@ -131,17 +135,19 @@ pub fn layout(text: &str, options: LayoutOptions) -> parley::Layout<sharedfontiq
         },
         parley::AlignmentOptions::default(),
     );
-    layout
+
+    let y_offset = match (options.max_height, options.vertical_align) {
+        (Some(max_height), TextVerticalAlignment::Center) => {
+            (max_height.get() - layout.height()) / 2.0
+        }
+        (Some(max_height), TextVerticalAlignment::Bottom) => max_height.get() - layout.height(),
+        (None, _) | (Some(_), TextVerticalAlignment::Top) => 0.0,
+    };
+
+    Layout { inner: layout, y_offset }
 }
 
-pub fn get_offset(
-    vertical_align: TextVerticalAlignment,
-    max_height: PhysicalLength,
-    layout: &parley::Layout<sharedfontique::Brush>,
-) -> f32 {
-    match vertical_align {
-        TextVerticalAlignment::Top => 0.0,
-        TextVerticalAlignment::Center => (max_height.get() - layout.height()) / 2.0,
-        TextVerticalAlignment::Bottom => max_height.get() - layout.height(),
-    }
+pub struct Layout {
+    pub inner: parley::Layout<sharedfontique::Brush>,
+    pub y_offset: f32,
 }
diff --git a/internal/renderers/femtovg/itemrenderer.rs b/internal/renderers/femtovg/itemrenderer.rs
@@ -196,14 +196,13 @@ impl<'a, R: femtovg::Renderer + TextureImporter> GLItemRenderer<'a, R> {
 }
 
 fn draw_glyphs<R: femtovg::Renderer + TextureImporter>(
-    layout: &parley::Layout<sharedfontique::Brush>,
+    layout: &fonts::Layout,
     canvas: &mut Canvas<R>,
     paint: &femtovg::Paint,
-    offset: f32,
     selection_foreground_color: Color,
     selection_background_color: Color,
 ) {
-    for line in layout.lines() {
+    for line in layout.inner.lines() {
         for item in line.items() {
             match item {
                 parley::PositionedLayoutItem::GlyphRun(glyph_run) => {
@@ -220,9 +219,12 @@ fn draw_glyphs<R: femtovg::Renderer + TextureImporter>(
                             let selection_rect = PhysicalRect::new(
                                 PhysicalPoint::new(
                                     start.x,
-                                    start.y + offset - glyph_run.run().font_size(),
+                                    start.y + layout.y_offset - run.font_size(),
+                                ),
+                                PhysicalSize::new(
+                                    glyph_run.advance(),
+                                    run.font_size() + run.metrics().descent,
                                 ),
-                                PhysicalSize::new(glyph_run.advance(), glyph_run.run().font_size()),
                             );
                             canvas.fill_path(
                                 &rect_to_path(selection_rect),
@@ -238,7 +240,7 @@ fn draw_glyphs<R: femtovg::Renderer + TextureImporter>(
                     let glyphs = glyph_run.positioned_glyphs().map(|glyph: parley::Glyph| {
                         femtovg::PositionedGlyph {
                             x: glyph.x,
-                            y: glyph.y + offset,
+                            y: glyph.y + layout.y_offset,
                             font_id,
                             glyph_id: glyph.id,
                         }
@@ -399,8 +401,8 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
         size: LogicalSize,
         _cache: &CachedRenderingData,
     ) {
-        let max_width = size.width_length() * self.scale_factor;
-        let max_height = size.height_length() * self.scale_factor;
+        let max_width = size.width_length();
+        let max_height = size.height_length();
 
         if max_width.get() <= 0. || max_height.get() <= 0. {
             return;
@@ -450,8 +452,11 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
 
         let layout = fonts::layout(
             text.text().as_str(),
+            self.scale_factor.get(),
             fonts::LayoutOptions {
                 horizontal_align,
+                vertical_align,
+                max_height: Some(max_height),
                 max_width: Some(max_width),
                 stroke: stroke_paint.is_some().then_some(stroke_style).map(|style| match style {
                     TextStrokeStyle::Outside => sharedfontique::BrushTextStrokeStyle::Outside,
@@ -464,9 +469,8 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
         );
 
         let mut canvas = self.canvas.borrow_mut();
-        let offset = fonts::get_offset(vertical_align, max_height, &layout);
 
-        draw_glyphs(&layout, &mut canvas, &paint, offset, Color::default(), Color::default());
+        draw_glyphs(&layout, &mut canvas, &paint, Color::default(), Color::default());
     }
 
     fn draw_text_input(
@@ -475,8 +479,8 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
         self_rc: &ItemRc,
         size: LogicalSize,
     ) {
-        let width = size.width_length() * self.scale_factor;
-        let height = size.height_length() * self.scale_factor;
+        let width = size.width_length();
+        let height = size.height_length();
         if width.get() <= 0. || height.get() <= 0. {
             return;
         }
@@ -515,36 +519,36 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
 
         let layout = fonts::layout(
             &text,
+            self.scale_factor.get(),
             fonts::LayoutOptions {
                 max_width: Some(width),
+                max_height: Some(height),
+                vertical_align: text_input.vertical_alignment(),
                 selection: Some(min_select..max_select),
                 font_request: Some(font_request),
                 ..Default::default()
             },
         );
-        let offset = fonts::get_offset(text_input.vertical_alignment(), height, &layout);
         draw_glyphs(
             &layout,
             &mut canvas,
             &paint,
-            offset,
             text_input.selection_foreground_color(),
             text_input.selection_background_color(),
         );
 
         if cursor_visible {
             let cursor = parley::layout::cursor::Cursor::from_byte_index(
-                &layout,
+                &layout.inner,
                 cursor_pos,
                 Default::default(),
             );
-            let rect = cursor
-                .geometry(&layout, (text_input.text_cursor_width() * self.scale_factor).get());
+            let rect = cursor.geometry(&layout.inner, (text_input.text_cursor_width()).get());
 
             let mut cursor_rect = femtovg::Path::new();
             cursor_rect.rect(
-                rect.center().x as _,
-                rect.center().y as _,
+                rect.min_x() as _,
+                rect.min_y() as f32 + layout.y_offset,
                 rect.width() as _,
                 rect.height() as _,
             );
@@ -980,10 +984,10 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
     }
 
     fn draw_string(&mut self, string: &str, color: Color) {
-        let layout = fonts::layout(string, Default::default());
+        let layout = fonts::layout(string, self.scale_factor.get(), Default::default());
         let paint = femtovg::Paint::color(to_femtovg_color(&color));
         let mut canvas = self.canvas.borrow_mut();
-        draw_glyphs(&layout, &mut canvas, &paint, 0.0, color, color);
+        draw_glyphs(&layout, &mut canvas, &paint, color, color);
     }
 
     fn draw_image_direct(&mut self, image: i_slint_core::graphics::Image) {
diff --git a/internal/renderers/femtovg/lib.rs b/internal/renderers/femtovg/lib.rs
@@ -289,14 +289,15 @@ impl<B: GraphicsBackend> RendererSealed for FemtoVGRenderer<B> {
     ) -> LogicalSize {
         let layout = fonts::layout(
             text,
+            scale_factor.get(),
             fonts::LayoutOptions {
-                max_width: max_width.map(|max_width| max_width * scale_factor),
+                max_width,
                 text_wrap,
                 font_request: Some(font_request),
                 ..Default::default()
             },
         );
-        LogicalSize::new(layout.width(), layout.height())
+        LogicalSize::new(layout.inner.width(), layout.inner.height())
     }
 
     fn font_metrics(
@@ -317,23 +318,29 @@ impl<B: GraphicsBackend> RendererSealed for FemtoVGRenderer<B> {
         let pos = pos * scale_factor;
         let text = text_input.text();
 
-        let width = text_input.width() * scale_factor;
-        let height = text_input.height() * scale_factor;
+        let width = text_input.width();
+        let height = text_input.height();
         if width.get() <= 0. || height.get() <= 0. || pos.y < 0. {
             return 0;
         }
 
         let layout = fonts::layout(
             &text,
+            scale_factor.get(),
             fonts::LayoutOptions {
                 font_request: Some(font_request),
                 max_width: Some(width),
+                max_height: Some(height),
+                vertical_align: text_input.vertical_alignment(),
 
                 ..Default::default()
             },
         );
-        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 cursor = parley::layout::cursor::Cursor::from_point(
+            &layout.inner,
+            pos.x,
+            pos.y - layout.y_offset,
+        );
 
         let visual_representation = text_input.visual_representation(None);
         visual_representation.map_byte_offset_from_byte_offset_in_visual_text(cursor.index())
@@ -350,8 +357,8 @@ impl<B: GraphicsBackend> RendererSealed for FemtoVGRenderer<B> {
 
         let font_size = font_request.pixel_size.unwrap_or(fonts::DEFAULT_FONT_SIZE);
 
-        let width = text_input.width() * scale_factor;
-        let height = text_input.height() * scale_factor;
+        let width = text_input.width();
+        let height = text_input.height();
         if width.get() <= 0. || height.get() <= 0. {
             return LogicalRect::new(
                 LogicalPoint::default(),
@@ -361,16 +368,21 @@ impl<B: GraphicsBackend> RendererSealed for FemtoVGRenderer<B> {
 
         let layout = fonts::layout(
             &text,
-            fonts::LayoutOptions { max_width: Some(width), ..Default::default() },
+            scale_factor.get(),
+            fonts::LayoutOptions {
+                max_width: Some(width),
+                max_height: Some(height),
+                ..Default::default()
+            },
         );
         let cursor = parley::layout::cursor::Cursor::from_byte_index(
-            &layout,
+            &layout.inner,
             byte_offset,
             Default::default(),
         );
-        let rect = cursor.geometry(&layout, (text_input.text_cursor_width() * scale_factor).get());
+        let rect = cursor.geometry(&layout.inner, (text_input.text_cursor_width()).get());
         LogicalRect::new(
-            LogicalPoint::new(rect.min_x() as _, rect.min_y() as _),
+            LogicalPoint::new(rect.min_x() as _, rect.min_y() as f32 + layout.y_offset),
             LogicalSize::new(rect.width() as _, rect.height() as _),
         )
     }
