@effindomv2/fui-rs 0.1.17 → 0.1.19

package/src/node/scroll_view.rs

@@ -16,6 +16,12 @@ pub struct ScrollView {
     active_animations: Rc<RefCell<ScrollViewAnimationState>>,
 }
 
+impl Default for ScrollView {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ScrollView {
     pub fn new() -> Self {
         let core = Rc::new(RefCell::new(NodeCore::new(NodeKind::ScrollView)));
@@ -473,6 +479,20 @@ impl ScrollView {
     }
 }
 
+impl Node for ScrollView {
+    fn retained_node_ref(&self) -> NodeRef {
+        NodeRef::from_node(self.core.clone(), self.clone())
+    }
+
+    fn build_self(&self) {
+        apply_scroll_view_props(
+            self.handle(),
+            &self.props.borrow(),
+            self.core.borrow().behavior.clone(),
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -544,17 +564,3 @@ mod tests {
         )));
     }
 }
-
-impl Node for ScrollView {
-    fn retained_node_ref(&self) -> NodeRef {
-        NodeRef::from_node(self.core.clone(), self.clone())
-    }
-
-    fn build_self(&self) {
-        apply_scroll_view_props(
-            self.handle(),
-            &self.props.borrow(),
-            self.core.borrow().behavior.clone(),
-        );
-    }
-}

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/theme.rs

@@ -1,12 +1,15 @@
 use crate::generated::framework_host_services;
+use crate::color::{
+    color_alpha, color_blue, color_green, color_red, mix_color, rgb, rgba, with_alpha,
+};
 use crate::signal::{Callback, Signal, SubscriptionGuard};
 use crate::typography::{FontFamily, FontStack};
 use std::cell::RefCell;
 use std::rc::Rc;
 
-const DEFAULT_ACCENT_COLOR: u32 = 0x2563EBFF;
-const WHITE: u32 = 0xFFFFFFFF;
-const BLACK: u32 = 0x000000FF;
+const DEFAULT_ACCENT_COLOR: u32 = rgb(0x25, 0x63, 0xeb);
+const WHITE: u32 = rgb(0xff, 0xff, 0xff);
+const BLACK: u32 = rgb(0x00, 0x00, 0x00);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Colors {
@@ -166,49 +169,6 @@ fn default_fonts() -> Fonts {
     }
 }
 
-const fn rgba(r: u32, g: u32, b: u32, a: u32) -> u32 {
-    (r << 24) | (g << 16) | (b << 8) | a
-}
-
-fn color_red(color: u32) -> u32 {
-    (color >> 24) & 0xff
-}
-fn color_green(color: u32) -> u32 {
-    (color >> 16) & 0xff
-}
-fn color_blue(color: u32) -> u32 {
-    (color >> 8) & 0xff
-}
-fn color_alpha(color: u32) -> u32 {
-    color & 0xff
-}
-fn clamp_unit(value: f32) -> f32 {
-    value.clamp(0.0, 1.0)
-}
-
-fn mix_channel(from: u32, to: u32, amount: f32) -> u32 {
-    let weight = clamp_unit(amount);
-    (from as f32 + ((to as f32 - from as f32) * weight)).round() as u32
-}
-
-fn mix_color(from: u32, to: u32, amount: f32) -> u32 {
-    rgba(
-        mix_channel(color_red(from), color_red(to), amount),
-        mix_channel(color_green(from), color_green(to), amount),
-        mix_channel(color_blue(from), color_blue(to), amount),
-        mix_channel(color_alpha(from), color_alpha(to), amount),
-    )
-}
-
-fn with_alpha(color: u32, alpha: u32) -> u32 {
-    rgba(
-        color_red(color),
-        color_green(color),
-        color_blue(color),
-        alpha,
-    )
-}
-
 fn normalize_accent_color(color: u32) -> u32 {
     if color == 0 {
         return DEFAULT_ACCENT_COLOR;
@@ -517,12 +477,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,
@@ -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,

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");
     }