feature/fontique: switch femtovg to parley

internal/common/sharedfontique.rs

@@ -7,7 +7,7 @@ pub use ttf_parser;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-static COLLECTION: std::sync::LazyLock<Collection> = std::sync::LazyLock::new(|| {
+pub static COLLECTION: std::sync::LazyLock<Collection> = std::sync::LazyLock::new(|| {
     let mut collection = fontique::Collection::new(fontique::CollectionOptions {
         shared: true,
         ..Default::default()
@@ -55,8 +55,8 @@ pub fn get_collection() -> Collection {
 
 #[derive(Clone)]
 pub struct Collection {
-    inner: fontique::Collection,
-    source_cache: fontique::SourceCache,
+    pub inner: fontique::Collection,
+    pub source_cache: fontique::SourceCache,
     pub default_fonts: Arc<HashMap<std::path::PathBuf, fontique::QueryFont>>,
 }
 

internal/compiler/passes/embed_glyphs.rs

@@ -137,15 +137,11 @@ pub fn embed_glyphs<'a>(
             let font = {
                 let mut query = collection.query();
 
-                if let Some(ref family) = family {
-                    query.set_families(std::iter::once(fontique::QueryFamily::from(
-                        family.as_str(),
-                    )));
+                query.set_families(std::iter::once(if let Some(ref family) = family {
+                    fontique::QueryFamily::from(family.as_str())
                 } else {
-                    query.set_families(std::iter::once(fontique::QueryFamily::Generic(
-                        fontique::GenericFamily::SansSerif,
-                    )));
-                }
+                    fontique::QueryFamily::Generic(fontique::GenericFamily::SansSerif)
+                }));
 
                 let mut font = None;
 

internal/core/Cargo.toml

@@ -67,6 +67,8 @@ unstable-wgpu-26 = ["dep:wgpu-26"]
 
 default = ["std", "unicode"]
 
+shared-parley = ["shared-fontique", "dep:parley"]
+
 [dependencies]
 i-slint-common = { workspace = true, features = ["default"] }
 i-slint-core-macros = { workspace = true, features = ["default"] }
@@ -100,6 +102,7 @@ unicode-script = { version = "0.5.7", optional = true }
 integer-sqrt = { version = "0.1.5" }
 bytemuck = { workspace = true, optional = true, features = ["derive"] }
 sys-locale = { version = "0.3.2", optional = true }
+parley = { version = "0.5.0", optional = true }
 
 image = { workspace = true, optional = true, default-features = false }
 clru = { workspace = true, optional = true }

internal/core/graphics.rs

@@ -164,9 +164,11 @@ impl FontRequest {
         let mut collection = sharedfontique::get_collection();
 
         let mut query = collection.query();
-        query.set_families(
-            self.family.as_ref().map(|family| fontique::QueryFamily::from(family.as_str())),
-        );
+        query.set_families(std::iter::once(if let Some(family) = self.family.as_ref() {
+            fontique::QueryFamily::from(family.as_str())
+        } else {
+            fontique::QueryFamily::Generic(fontique::GenericFamily::SansSerif)
+        }));
 
         query.set_attributes(fontique::Attributes {
             weight: self

internal/core/textlayout.rs

@@ -40,6 +40,9 @@ use linebreak_simple::{BreakOpportunity, LineBreakIterator};
 mod fragments;
 mod glyphclusters;
 mod shaping;
+#[cfg(feature = "shared-parley")]
+/// cbindgen:ignore
+pub mod sharedparley;
 use shaping::ShapeBuffer;
 pub use shaping::{AbstractFont, FontMetrics, Glyph, TextShaper};
 

internal/core/textlayout/sharedparley.rs

@@ -0,0 +1,153 @@
+// Copyright © SixtyFPS GmbH <[email protected]>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
+
+pub use parley;
+
+use std::boxed::Box;
+use std::cell::RefCell;
+
+use crate::{
+    graphics::FontRequest,
+    items::TextStrokeStyle,
+    lengths::{LogicalLength, ScaleFactor},
+    textlayout::{TextHorizontalAlignment, TextOverflow, TextVerticalAlignment, TextWrap},
+};
+use i_slint_common::sharedfontique;
+
+pub const DEFAULT_FONT_SIZE: LogicalLength = LogicalLength::new(12.);
+
+struct Contexts {
+    layout: parley::LayoutContext<Brush>,
+    font: parley::FontContext,
+}
+
+impl Default for Contexts {
+    fn default() -> Self {
+        Self {
+            font: parley::FontContext {
+                collection: sharedfontique::COLLECTION.inner.clone(),
+                source_cache: sharedfontique::COLLECTION.source_cache.clone(),
+            },
+            layout: Default::default(),
+        }
+    }
+}
+
+std::thread_local! {
+    static CONTEXTS: RefCell<Box<Contexts>> = Default::default();
+}
+
+#[derive(Debug, Default, PartialEq, Clone, Copy)]
+pub struct Brush {
+    pub stroke: Option<TextStrokeStyle>,
+}
+
+pub struct LayoutOptions {
+    pub max_width: Option<LogicalLength>,
+    pub max_height: Option<LogicalLength>,
+    pub horizontal_align: TextHorizontalAlignment,
+    pub vertical_align: TextVerticalAlignment,
+    pub stroke: Option<TextStrokeStyle>,
+    pub font_request: Option<FontRequest>,
+    pub text_wrap: TextWrap,
+    pub text_overflow: TextOverflow,
+}
+
+impl Default for LayoutOptions {
+    fn default() -> Self {
+        Self {
+            max_width: None,
+            max_height: None,
+            horizontal_align: TextHorizontalAlignment::Left,
+            vertical_align: TextVerticalAlignment::Top,
+            stroke: None,
+            font_request: None,
+            text_wrap: TextWrap::WordWrap,
+            text_overflow: TextOverflow::Clip,
+        }
+    }
+}
+
+pub fn layout(text: &str, scale_factor: ScaleFactor, options: LayoutOptions) -> Layout {
+    let max_physical_width = options.max_width.map(|max_width| (max_width * scale_factor).get());
+    let max_physical_height = options.max_height.map(|max_height| max_height * scale_factor);
+    let pixel_size = options
+        .font_request
+        .as_ref()
+        .and_then(|font_request| font_request.pixel_size)
+        .unwrap_or(DEFAULT_FONT_SIZE);
+
+    let mut layout = CONTEXTS.with_borrow_mut(move |contexts| {
+        let mut builder =
+            contexts.layout.ranged_builder(&mut contexts.font, text, scale_factor.get(), true);
+        if let Some(ref font_request) = options.font_request {
+            if let Some(family) = &font_request.family {
+                builder.push_default(parley::StyleProperty::FontStack(
+                    parley::style::FontStack::Single(parley::style::FontFamily::Named(
+                        family.as_str().into(),
+                    )),
+                ));
+            }
+            if let Some(weight) = font_request.weight {
+                builder.push_default(parley::StyleProperty::FontWeight(
+                    parley::style::FontWeight::new(weight as f32),
+                ));
+            }
+            if let Some(letter_spacing) = font_request.letter_spacing {
+                builder.push_default(parley::StyleProperty::LetterSpacing(letter_spacing.get()));
+            }
+            builder.push_default(parley::StyleProperty::FontStyle(if font_request.italic {
+                parley::style::FontStyle::Italic
+            } else {
+                parley::style::FontStyle::Normal
+            }));
+        }
+        builder.push_default(parley::StyleProperty::FontSize(pixel_size.get()));
+        builder.push_default(parley::StyleProperty::WordBreak(match options.text_wrap {
+            TextWrap::NoWrap => parley::style::WordBreakStrength::KeepAll,
+            TextWrap::WordWrap => parley::style::WordBreakStrength::Normal,
+            TextWrap::CharWrap => parley::style::WordBreakStrength::BreakAll,
+        }));
+        if options.text_overflow == TextOverflow::Elide {
+            todo!();
+        }
+
+        builder.push_default(parley::StyleProperty::Brush(Brush { stroke: options.stroke }));
+
+        builder.build(text)
+    });
+
+    layout.break_all_lines(max_physical_width);
+    layout.align(
+        max_physical_width,
+        match options.horizontal_align {
+            TextHorizontalAlignment::Left => parley::Alignment::Left,
+            TextHorizontalAlignment::Center => parley::Alignment::Middle,
+            TextHorizontalAlignment::Right => parley::Alignment::Right,
+        },
+        parley::AlignmentOptions::default(),
+    );
+
+    let y_offset = match (max_physical_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 struct Layout {
+    inner: parley::Layout<Brush>,
+    pub y_offset: f32,
+}
+
+impl std::ops::Deref for Layout {
+    type Target = parley::Layout<Brush>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

internal/renderers/femtovg/Cargo.toml

@@ -23,7 +23,7 @@ wgpu-26 = ["dep:wgpu-26", "femtovg/wgpu", "i-slint-core/unstable-wgpu-26"]
 unstable-wgpu-26 = ["wgpu-26"]
 
 [dependencies]
-i-slint-core = { workspace = true, features = ["default", "box-shadow-cache", "shared-fontique"] }
+i-slint-core = { workspace = true, features = ["default", "box-shadow-cache", "shared-fontique", "shared-parley"] }
 i-slint-core-macros = { workspace = true, features = ["default"] }
 i-slint-common = { workspace = true, features = ["default", "shared-fontique"] }
 
@@ -34,7 +34,7 @@ derive_more = { workspace = true }
 lyon_path = "1.0"
 pin-weak = "1"
 scoped-tls-hkt = "0.1"
-femtovg = { version = "0.17.0" }
+femtovg = { version = "0.18.1" }
 ttf-parser = { workspace = true }
 unicode-script = { version = "0.5.4" } # Use the same version was femtovg's rustybuzz, to avoid duplicate crates
 imgref = { version = "1.6.1" }

internal/renderers/femtovg/font_cache.rs

@@ -0,0 +1,39 @@
+// Copyright © SixtyFPS GmbH <[email protected]>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
+
+// cspell:ignore Noto fontconfig
+
+use core::num::NonZeroUsize;
+use femtovg::TextContext;
+use i_slint_core::textlayout::sharedparley::parley;
+use std::cell::RefCell;
+use std::collections::HashMap;
+
+pub struct FontCache {
+    pub(crate) text_context: femtovg::TextContext,
+    fonts: HashMap<(u64, u32), femtovg::FontId>,
+}
+
+impl Default for FontCache {
+    fn default() -> Self {
+        let text_context = TextContext::default();
+        text_context.resize_shaped_words_cache(NonZeroUsize::new(10_000_000).unwrap());
+        text_context.resize_shaping_run_cache(NonZeroUsize::new(1_000_000).unwrap());
+
+        Self { text_context, fonts: Default::default() }
+    }
+}
+
+impl FontCache {
+    pub fn font(&mut self, font: &parley::Font) -> femtovg::FontId {
+        let text_context = self.text_context.clone();
+
+        *self.fonts.entry((font.data.id(), font.index)).or_insert_with(move || {
+            text_context.add_shared_font_with_index(font.data.clone(), font.index).unwrap()
+        })
+    }
+}
+
+thread_local! {
+    pub static FONT_CACHE: RefCell<FontCache> = RefCell::new(Default::default())
+}