@effindomv2/fui-rs 0.1.16 → 0.1.18

package/src/node/virtual_list.rs

@@ -4,6 +4,7 @@ use crate::controls::selection_area;
 use crate::controls::SelectionArea;
 use crate::frame_scheduler::mark_needs_commit;
 use crate::signal::Subscription;
+use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 
@@ -11,9 +12,9 @@ const FULL_SIZE: f32 = 100.0;
 const DEFAULT_MAX_VISIBLE_ITEMS: i32 = 20;
 const POOL_OVERSCAN_ITEMS: i32 = 2;
 const MISSING_BIND_ITEM_MESSAGE: &str =
-    "VirtualList: item renderer not configured. Call .onBindItem() after construction.";
+    "VirtualList: item renderer not configured. Call .on_bind_item() after construction.";
 
-type VirtualListBinder = Rc<dyn Fn(&FlexBox, i32)>;
+type VirtualListBinder = Rc<dyn Fn(usize, i32)>;
 
 struct VirtualListInner {
     root: FlexBox,
@@ -27,18 +28,28 @@ struct VirtualListInner {
     pool_size: i32,
     pool_rows: Vec<SelectionArea>,
     pool_containers: Vec<FlexBox>,
+    row_state_owner: RefCell<Option<Rc<dyn Any>>>,
     pool_item_index_by_row: RefCell<Vec<i32>>,
     subscriptions: RefCell<Vec<Subscription>>,
     current_first_visible_index: Cell<i32>,
     current_last_visible_index: Cell<i32>,
 }
 
-#[derive(Clone)]
-pub struct VirtualList {
+pub struct VirtualList<T = FlexBox> {
     inner: Rc<VirtualListInner>,
+    row_states: Rc<Vec<T>>,
 }
 
-impl VirtualList {
+impl<T> Clone for VirtualList<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            row_states: self.row_states.clone(),
+        }
+    }
+}
+
+impl VirtualList<FlexBox> {
     pub fn new(total_items: i32, item_height: f32) -> Self {
         Self::with_max_visible(total_items, item_height, DEFAULT_MAX_VISIBLE_ITEMS)
     }
@@ -105,13 +116,43 @@ impl VirtualList {
             bottom_spacer,
             pool_size,
             pool_rows,
-            pool_containers,
+            pool_containers: pool_containers.clone(),
+            row_state_owner: RefCell::new(None),
             pool_item_index_by_row: RefCell::new(pool_item_index_by_row),
             subscriptions: RefCell::new(Vec::new()),
             current_first_visible_index: Cell::new(-1),
             current_last_visible_index: Cell::new(-1),
         });
-        let list = Self { inner };
+        let row_states = Rc::new(pool_containers);
+        inner
+            .row_state_owner
+            .replace(Some(row_states.clone() as Rc<dyn Any>));
+        let list = Self { inner, row_states };
+        list.attach_listeners();
+        list
+    }
+}
+
+impl<T: 'static> VirtualList<T> {
+    pub fn item_template<U: 'static>(self, template: impl Fn(&FlexBox) -> U) -> VirtualList<U> {
+        let row_states = Rc::new(
+            self.inner
+                .pool_containers
+                .iter()
+                .map(template)
+                .collect::<Vec<_>>(),
+        );
+        self.inner
+            .row_state_owner
+            .replace(Some(row_states.clone() as Rc<dyn Any>));
+        *self.inner.bind_item.borrow_mut() = Rc::new(|_, _| panic!("{MISSING_BIND_ITEM_MESSAGE}"));
+        self.inner.current_first_visible_index.set(-1);
+        self.inner.current_last_visible_index.set(-1);
+        self.inner.subscriptions.borrow_mut().clear();
+        let list = VirtualList {
+            inner: self.inner,
+            row_states,
+        };
         list.attach_listeners();
         list
     }
@@ -181,19 +222,17 @@ impl VirtualList {
         self
     }
 
-    pub fn on_bind_item(&self, renderer: impl Fn(&FlexBox, i32) + 'static) -> &Self {
-        *self.inner.bind_item.borrow_mut() = Rc::new(renderer);
+    pub fn on_bind_item(&self, renderer: impl Fn(&T, i32) + 'static) -> &Self {
+        let row_states = self.row_states.clone();
+        *self.inner.bind_item.borrow_mut() = Rc::new(move |pool_index, item_index| {
+            renderer(&row_states[pool_index], item_index);
+        });
         self.inner.current_first_visible_index.set(-1);
         self.inner.current_last_visible_index.set(-1);
         self.rebuild_visible_range(true);
         self
     }
 
-    #[allow(non_snake_case)]
-    pub fn onBindItem(&self, renderer: impl Fn(&FlexBox, i32) + 'static) -> &Self {
-        self.on_bind_item(renderer)
-    }
-
     pub fn update_item_count(&self, next: i32) {
         self.inner.total_items.set(next.max(0));
         self.inner
@@ -217,27 +256,33 @@ impl VirtualList {
 
     fn attach_listeners(&self) {
         let weak = Rc::downgrade(&self.inner);
+        let weak_row_states = Rc::downgrade(&self.row_states);
         self.inner
             .subscriptions
             .borrow_mut()
             .push(self.inner.scroll_state.subscribe_offset_y(move || {
-                if let Some(inner) = weak.upgrade() {
-                    VirtualList { inner }.handle_scroll_offset_changed();
+                if let (Some(inner), Some(row_states)) = (weak.upgrade(), weak_row_states.upgrade())
+                {
+                    VirtualList { inner, row_states }.handle_scroll_offset_changed();
                 }
             }));
         let weak = Rc::downgrade(&self.inner);
+        let weak_row_states = Rc::downgrade(&self.row_states);
         self.inner.subscriptions.borrow_mut().push(
             self.inner.scroll_state.subscribe_viewport_height(move || {
-                if let Some(inner) = weak.upgrade() {
-                    VirtualList { inner }.handle_metrics_changed();
+                if let (Some(inner), Some(row_states)) = (weak.upgrade(), weak_row_states.upgrade())
+                {
+                    VirtualList { inner, row_states }.handle_metrics_changed();
                 }
             }),
         );
         let weak = Rc::downgrade(&self.inner);
+        let weak_row_states = Rc::downgrade(&self.row_states);
         self.inner.subscriptions.borrow_mut().push(
             self.inner.scroll_state.subscribe_content_height(move || {
-                if let Some(inner) = weak.upgrade() {
-                    VirtualList { inner }.handle_metrics_changed();
+                if let (Some(inner), Some(row_states)) = (weak.upgrade(), weak_row_states.upgrade())
+                {
+                    VirtualList { inner, row_states }.handle_metrics_changed();
                 }
             }),
         );
@@ -325,8 +370,12 @@ impl VirtualList {
         let previous_item_index_by_row = self.inner.pool_item_index_by_row.borrow().clone();
         let visible_items = (last_visible_index - first_visible_index) as usize;
 
-        for pool_index in 0..self.inner.pool_size as usize {
-            let previous_item_index = previous_item_index_by_row[pool_index];
+        for (pool_index, previous_item_index) in previous_item_index_by_row
+            .iter()
+            .copied()
+            .enumerate()
+            .take(self.inner.pool_size as usize)
+        {
             if previous_item_index != -1
                 && (previous_item_index < first_visible_index
                     || previous_item_index >= last_visible_index)
@@ -340,8 +389,7 @@ impl VirtualList {
             if pool_index < visible_items {
                 let next_item_index = first_visible_index + pool_index as i32;
                 row_area.height(self.inner.item_height, Unit::Pixel);
-                let container = &self.inner.pool_containers[pool_index];
-                self.render_item(container, next_item_index);
+                self.render_item(pool_index, next_item_index);
                 self.inner.pool_item_index_by_row.borrow_mut()[pool_index] = next_item_index;
             } else {
                 self.hide_pool_item(pool_index);
@@ -450,9 +498,9 @@ impl VirtualList {
         mark_needs_commit();
     }
 
-    fn render_item(&self, container: &FlexBox, index: i32) {
+    fn render_item(&self, pool_index: usize, index: i32) {
         let binder = self.inner.bind_item.borrow().clone();
-        binder(container, index);
+        binder(pool_index, index);
     }
 
     fn max_offset_for_current_viewport(&self) -> f32 {
@@ -478,7 +526,7 @@ impl VirtualList {
     }
 }
 
-impl Node for VirtualList {
+impl<T: 'static> Node for VirtualList<T> {
     fn retained_node_ref(&self) -> NodeRef {
         let list = self.clone();
         self.inner
@@ -507,22 +555,24 @@ impl Node for VirtualList {
     }
 }
 
-impl HasFlexBoxRoot for VirtualList {
+impl<T: 'static> HasFlexBoxRoot for VirtualList<T> {
     fn flex_box_root(&self) -> &FlexBox {
         &self.inner.root
     }
 }
 
-impl ThemeBindable for VirtualList {
+impl<T: 'static> ThemeBindable for VirtualList<T> {
     fn theme_binding_node(&self) -> NodeRef {
         self.inner.root.retained_node_ref()
     }
 
     fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
         let weak = Rc::downgrade(&self.inner);
+        let weak_row_states = Rc::downgrade(&self.row_states);
         Box::new(move || {
             Some(VirtualList {
                 inner: weak.upgrade()?,
+                row_states: weak_row_states.upgrade()?,
             })
         })
     }
@@ -583,7 +633,7 @@ mod tests {
         let list = VirtualList::new(10_000, 20.0);
         let captured_indices = rendered_indices.clone();
         let captured_labels = labels.clone();
-        list.onBindItem(move |container, index| {
+        list.on_bind_item(move |container, index| {
             tracked_bind_virtual_list_item(&captured_indices, &captured_labels, container, index);
         });
         list.width(180.0, Unit::Pixel);
@@ -608,7 +658,7 @@ mod tests {
         let list = VirtualList::new(10_000, 20.0);
         let captured_indices = rendered_indices.clone();
         let captured_labels = labels.clone();
-        list.onBindItem(move |container, index| {
+        list.on_bind_item(move |container, index| {
             tracked_bind_virtual_list_item(&captured_indices, &captured_labels, container, index);
         });
         list.width(180.0, Unit::Pixel);
@@ -653,7 +703,7 @@ mod tests {
         let labels = Rc::new(RefCell::new(HashMap::new()));
         let list = VirtualList::new(10_000, 24.0);
         let captured_labels = labels.clone();
-        list.onBindItem(move |container, index| {
+        list.on_bind_item(move |container, index| {
             static_bind_virtual_list_item(&captured_labels, container, index);
         });
         list.height(120.0, Unit::Pixel);
@@ -676,7 +726,7 @@ mod tests {
         let list = VirtualList::new(10_000, 20.0);
         let captured_indices = rendered_indices.clone();
         let captured_labels = labels.clone();
-        list.onBindItem(move |container, index| {
+        list.on_bind_item(move |container, index| {
             tracked_bind_virtual_list_item(&captured_indices, &captured_labels, container, index);
         });
         list.width(180.0, Unit::Pixel);
@@ -690,4 +740,41 @@ mod tests {
         assert_eq!(rendered[rendered.len() - 1], 5);
         list.dispose();
     }
+
+    #[test]
+    fn typed_item_template_creates_one_retained_state_per_pool_row_and_rebinds_it() {
+        #[derive(Clone)]
+        struct Row {
+            label: TextNode,
+        }
+
+        ffi::test::reset();
+        let template_count = Rc::new(Cell::new(0));
+        let captured_template_count = template_count.clone();
+        let list = VirtualList::with_max_visible(10_000, 20.0, 4).item_template(move |container| {
+            captured_template_count.set(captured_template_count.get() + 1);
+            let label = text("");
+            container.child(&label);
+            Row { label }
+        });
+        let bound_indices = Rc::new(RefCell::new(Vec::new()));
+        let captured_indices = bound_indices.clone();
+        list.on_bind_item(move |row, index| {
+            captured_indices.borrow_mut().push(index);
+            row.label.text(format!("typed item {index}"));
+        });
+        list.height(60.0, Unit::Pixel);
+        Application::mount(list.clone());
+
+        assert_eq!(template_count.get(), 6);
+        bound_indices.borrow_mut().clear();
+        ffi::test::reset();
+        list.scroll_state().set_offset_y(40.0);
+
+        assert_eq!(&*bound_indices.borrow(), &[2, 3, 4, 5]);
+        assert!(!ffi::test::take_calls()
+            .iter()
+            .any(|call| matches!(call, Call::CreateNode { .. } | Call::DeleteNode { .. })));
+        Application::unmount();
+    }
 }

package/src/platform.rs

@@ -260,6 +260,9 @@ pub fn show_open_folder_dialog(
 }
 
 #[cfg(feature = "native-runtime")]
+/// # Safety
+/// `payload` must reference at least `payload_length` readable bytes when
+/// `payload_length` is non-zero.
 #[no_mangle]
 pub unsafe extern "C" fn __fui_complete_native_file_dialog(
     request_id: u64,

package/src/popup_presenter.rs

@@ -189,6 +189,7 @@ impl PopupPresenter {
         );
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn show_anchored_with_placement(
         &self,
         anchor_x: f32,

package/src/text.rs

@@ -255,6 +255,10 @@ impl Node for RichText {
     fn build_self(&self) {
         self.node.build_self();
     }
+
+    fn required_font_ids_for_preparation(&self) -> Vec<u32> {
+        self.node.required_font_ids()
+    }
 }
 
 fn compile_rich_text_state(state: &RichTextState) -> CompiledRichText {
@@ -781,6 +785,8 @@ impl DynamicTextLayout {
         layout.set_text(value);
         if was_ready {
             layout.prepare_or_wait();
+        } else {
+            layout.schedule_ready();
         }
         true
     }
@@ -853,12 +859,15 @@ impl DynamicTextLayout {
         value.chars().all(|ch| charset.contains(ch))
     }
 
-    fn include_in_charset(state: &mut DynamicTextLayoutState, value: &str) {
+    fn include_in_charset(state: &mut DynamicTextLayoutState, value: &str) -> bool {
+        let mut changed = false;
         for ch in value.chars() {
             if !state.charset.contains(ch) {
                 state.charset.push(ch);
+                changed = true;
             }
         }
+        changed
     }
 
     fn refresh_numeric_text(&self) {
@@ -880,12 +889,14 @@ impl DynamicTextLayout {
         let mut state = self.inner.borrow_mut();
         let prefix = state.numeric_prefix.clone();
         let suffix = state.numeric_suffix.clone();
-        Self::include_in_charset(&mut state, &prefix);
-        Self::include_in_charset(&mut state, &suffix);
+        let charset_changed = Self::include_in_charset(&mut state, &prefix)
+            | Self::include_in_charset(&mut state, &suffix);
         let charset = state.charset.clone();
         let layout = state.layout.clone();
         drop(state);
-        layout.set_dynamic_charset_internal(charset);
+        if charset_changed {
+            layout.set_dynamic_charset_internal(charset);
+        }
         format!("{prefix}{}{suffix}", self.format_numeric_value(value))
     }
 
@@ -1077,4 +1088,30 @@ mod tests {
             .iter()
             .any(|call| matches!(call, Call::SetDynamicTextCharset { charset, .. } if charset == "0123456789")));
     }
+
+    #[test]
+    fn numeric_dynamic_text_layout_stays_ready_across_value_updates() {
+        ffi::test::reset();
+        frame_scheduler::reset_commit_state();
+        assets::test_reset();
+
+        let layout = DynamicTextLayout::numeric();
+        layout
+            .precision(0)
+            .font_stack(crate::typography::FontStack::from_id(1), 16.0)
+            .width(120.0, Unit::Pixel)
+            .height(24.0, Unit::Pixel)
+            .on_ready(|_| {});
+        frame_scheduler::fire_loaded_callbacks();
+        assert!(layout.is_ready());
+        ffi::test::take_calls();
+
+        assert!(layout.set_value(42.0));
+        assert!(layout.is_ready());
+        assert_eq!(layout.current_text(), "42");
+        let calls = ffi::test::take_calls();
+        assert!(calls
+            .iter()
+            .any(|call| matches!(call, Call::PrepareNode { .. })));
+    }
 }

package/src/theme.rs

@@ -517,12 +517,12 @@ trait Pipe: Sized {
 
 impl<T> Pipe for T {}
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_system_dark_mode_changed(is_dark: bool) {
     handle_system_dark_mode_changed(is_dark);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_system_accent_color_changed(color: u32) {
     handle_system_accent_color_changed(color);
 }

package/src/timers.rs

@@ -58,7 +58,7 @@ pub fn cancel_all_timers() {
     ACTIVE_TIMERS.with(|timers| timers.borrow_mut().clear());
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_timer(timer_id: u32) {
     let callback = ACTIVE_TIMERS.with(|timers| timers.borrow_mut().remove(&timer_id));
     if let Some(callback) = callback {

package/src/typography.rs

@@ -15,32 +15,22 @@ thread_local! {
     static REGISTERED_FONT_FALLBACKS: RefCell<Vec<(u32, u32)>> = const { RefCell::new(Vec::new()) };
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum FontStyle {
+    #[default]
     Normal = 0,
     Italic = 1,
 }
 
-impl Default for FontStyle {
-    fn default() -> Self {
-        Self::Normal
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum FontWeight {
+    #[default]
     Regular = 400,
     Medium = 500,
     Semibold = 600,
     Bold = 700,
 }
 
-impl Default for FontWeight {
-    fn default() -> Self {
-        Self::Regular
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct FontFaceLoadedEventArgs {
     pub font: FontFace,
@@ -158,7 +148,7 @@ impl FontFace {
     }
 
     pub(crate) fn is_font_loaded(font_id: u32) -> bool {
-        font_id == 0 || assets::is_font_loaded(font_id)
+        font_id == 0 || (1..=6).contains(&font_id) || assets::is_font_loaded(font_id)
     }
 
     pub fn on_loaded(&self, callback: impl Fn(FontFaceLoadedEventArgs) + 'static) -> Self {
@@ -308,6 +298,7 @@ pub struct FontFamily {
 }
 
 impl FontFamily {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         regular_stack: FontStack,
         bold_stack: Option<FontStack>,
@@ -331,6 +322,7 @@ impl FontFamily {
     }
 
     #[cfg(test)]
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn from_ids(
         regular: u32,
         bold: u32,
@@ -502,6 +494,14 @@ mod tests {
         assert_eq!(fired.get(), 1);
     }
 
+    #[test]
+    fn built_in_font_faces_are_preloaded_like_fui_as() {
+        assets::test_reset();
+        for font_id in 1..=6 {
+            assert!(FontFace::new(font_id).is_loaded());
+        }
+    }
+
     #[test]
     fn font_stack_reports_required_font_ids() {
         let stack = FontStack::from_id(1)

package/src/worker.rs

@@ -108,7 +108,7 @@ impl Worker {
         if already_started {
             return self;
         }
-        if input.as_bytes().len() > MAX_WORKER_START_INPUT_BYTES {
+        if input.len() > MAX_WORKER_START_INPUT_BYTES {
             let (worker_id, callback) = {
                 let mut inner = self.inner.borrow_mut();
                 inner.started = true;
@@ -186,8 +186,14 @@ fn with_active_worker(worker_id: u32, callback: impl FnOnce(&mut WorkerInner)) {
     callback(&mut inner);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_worker_progress(worker_id: u32, text_ptr: *const u8, text_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `text_ptr` must be null for an empty message or point to `text_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_worker_progress(
+    worker_id: u32,
+    text_ptr: *const u8,
+    text_len: u32,
+) {
     let message = if text_ptr.is_null() || text_len == 0 {
         String::new()
     } else {
@@ -204,8 +210,14 @@ pub extern "C" fn __fui_on_worker_progress(worker_id: u32, text_ptr: *const u8,
     });
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_worker_complete(worker_id: u32, text_ptr: *const u8, text_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `text_ptr` must be null for an empty result or point to `text_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_worker_complete(
+    worker_id: u32,
+    text_ptr: *const u8,
+    text_len: u32,
+) {
     let result = if text_ptr.is_null() || text_len == 0 {
         String::new()
     } else {
@@ -228,8 +240,10 @@ pub extern "C" fn __fui_on_worker_complete(worker_id: u32, text_ptr: *const u8,
     }
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_worker_error(worker_id: u32, text_ptr: *const u8, text_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `text_ptr` must be null for an empty message or point to `text_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_worker_error(worker_id: u32, text_ptr: *const u8, text_len: u32) {
     let message = if text_ptr.is_null() || text_len == 0 {
         String::new()
     } else {
@@ -300,8 +314,10 @@ mod tests {
                 result_clone.replace(event.result);
             })
             .start("hello");
-        super::__fui_on_worker_progress(1, b"25%".as_ptr(), 3);
-        super::__fui_on_worker_complete(1, b"done".as_ptr(), 4);
+        unsafe {
+            super::__fui_on_worker_progress(1, b"25%".as_ptr(), 3);
+            super::__fui_on_worker_complete(1, b"done".as_ptr(), 4);
+        }
         assert_eq!(&*progress.borrow(), "25%");
         assert_eq!(&*result.borrow(), "done");
     }