@effindomv2/fui-rs 0.1.22 → 0.1.24

package/src/text.rs

@@ -251,6 +251,34 @@ impl HasTextNode for RichText {
     fn text_node(&self) -> &TextNode {
         &self.node
     }
+
+    fn set_text_surface_content(&self, content: String) {
+        self.text(content);
+    }
+
+    fn set_text_surface_font_stack(&self, stack: FontStack, size: f32) {
+        self.font_stack(stack, size);
+    }
+
+    fn set_text_surface_font_family(&self, family: FontFamily) {
+        self.font_family(family);
+    }
+
+    fn set_text_surface_font_weight(&self, weight: FontWeight) {
+        self.font_weight(weight);
+    }
+
+    fn set_text_surface_font_style(&self, style: FontStyle) {
+        self.font_style(style);
+    }
+
+    fn set_text_surface_font_size(&self, size: f32) {
+        self.font_size(size);
+    }
+
+    fn set_text_surface_color(&self, color: u32) {
+        self.text_color(color);
+    }
 }
 
 impl ThemeBindable for RichText {
@@ -1011,6 +1039,37 @@ mod tests {
         )));
     }
 
+    #[test]
+    fn rich_text_shared_surface_preserves_spans_and_rebuilds_base_typography() {
+        ffi::test::reset();
+        let node = RichText::new(vec![span("Bold").bold(), span(" plain")]);
+        crate::node::TextTypographySurface::font_size(&node, 23.0);
+        crate::node::TextLayoutSurface::wrapping(&node, true);
+        crate::node::TextSelectionSurface::selection_range(&node, 1, 4);
+        node.build();
+
+        let calls = ffi::test::take_calls();
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::SetText { text, .. } if text == "Bold plain"
+        )));
+        assert!(calls
+            .iter()
+            .any(|call| matches!(call, Call::SetTextStyleRuns { run_count: 2, .. })));
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::SetFont { size, .. } if (*size - 23.0).abs() < f32::EPSILON
+        )));
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::SetTextSelectionRange {
+                start: 1,
+                end: 4,
+                ..
+            }
+        )));
+    }
+
     #[test]
     fn text_layout_waits_for_loaded_and_fonts_before_reporting_ready() {
         ffi::test::reset();

package/src/text_indices.rs

@@ -0,0 +1,48 @@
+pub(crate) fn scalar_count(text: &str) -> u32 {
+    text.chars().count() as u32
+}
+
+pub(crate) fn scalar_to_byte(text: &str, scalar_index: u32) -> u32 {
+    let target = scalar_index.min(scalar_count(text)) as usize;
+    if target == 0 {
+        return 0;
+    }
+    text.char_indices()
+        .nth(target)
+        .map(|(byte, _)| byte as u32)
+        .unwrap_or(text.len() as u32)
+}
+
+pub(crate) fn byte_to_scalar(text: &str, byte_index: u32) -> u32 {
+    let target = (byte_index as usize).min(text.len());
+    let mut scalar_index = 0;
+    for (byte, character) in text.char_indices() {
+        if target <= byte || target < byte + character.len_utf8() {
+            return scalar_index;
+        }
+        scalar_index += 1;
+    }
+    scalar_index
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scalar_and_utf8_byte_offsets_round_trip_at_character_boundaries() {
+        let text = "A你😀Z";
+        let expected_bytes = [0, 1, 4, 8, 9];
+        for (scalar, byte) in expected_bytes.into_iter().enumerate() {
+            assert_eq!(scalar_to_byte(text, scalar as u32), byte);
+            assert_eq!(byte_to_scalar(text, byte), scalar as u32);
+        }
+    }
+
+    #[test]
+    fn byte_offsets_inside_a_multibyte_scalar_clamp_to_its_leading_boundary() {
+        let text = "A你😀Z";
+        assert_eq!(byte_to_scalar(text, 2), 1);
+        assert_eq!(byte_to_scalar(text, 6), 2);
+    }
+}