@effindomv2/fui-rs 0.1.17 → 0.1.18

package/src/node/core.rs

@@ -262,7 +262,7 @@ pub(crate) struct LinearGradient {
     pub(crate) offsets: Vec<f32>,
     pub(crate) colors: Vec<u32>,
 }
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub(crate) struct FlexBoxProps {
     pub(crate) width: Option<(f32, Unit)>,
     pub(crate) height: Option<(f32, Unit)>,
@@ -278,25 +278,6 @@ pub(crate) struct FlexBoxProps {
     pub(crate) transitions: Option<NodeTransitions>,
 }
 
-impl Default for FlexBoxProps {
-    fn default() -> Self {
-        Self {
-            width: None,
-            height: None,
-            bg_color: None,
-            padding: None,
-            flex_direction: None,
-            box_style: None,
-            opacity: None,
-            blur_sigma: None,
-            drop_shadow: None,
-            background_blur_sigma: None,
-            linear_gradient: None,
-            transitions: None,
-        }
-    }
-}
-
 #[derive(Clone, Default)]
 pub(crate) struct TextProps {
     pub(crate) content: String,
@@ -2219,7 +2200,7 @@ pub trait Node: Clone {
     }
 }
 
-impl<T: Node + ?Sized> Node for &T {
+impl<T: Node> Node for &T {
     fn retained_node_ref(&self) -> NodeRef {
         (*self).retained_node_ref()
     }

package/src/node/helpers.rs

@@ -31,7 +31,7 @@ pub fn scroll_box() -> ScrollBox {
     ScrollBox::new()
 }
 
-pub fn virtual_list(total_items: i32, item_height: f32) -> VirtualList {
+pub fn virtual_list(total_items: i32, item_height: f32) -> VirtualList<FlexBox> {
     VirtualList::new(total_items, item_height)
 }
 

package/src/node/mod.rs

@@ -48,7 +48,7 @@ pub use helpers::{
 pub use image::ImageNode;
 pub(crate) use presenter_host_style::HostStyleLayers;
 pub use presenter_host_style::{Corners, EdgeInsets, PresenterHostStyle, Shadow};
-pub use scroll_bar::{ScrollBar, ScrollBarVisibility};
+pub use scroll_bar::{ScrollBar, ScrollBarStyle, ScrollBarVisibility};
 pub use scroll_box::ScrollBox;
 pub use scroll_state::ScrollState;
 pub use scroll_view::ScrollView;

package/src/node/scroll_bar.rs

@@ -12,6 +12,91 @@ const DEFAULT_TRACK_THICKNESS: f32 = 8.0;
 const DEFAULT_THUMB_THICKNESS: f32 = 8.0;
 const DEFAULT_MIN_THUMB_SIZE: f32 = 18.0;
 
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ScrollBarStyle {
+    track_width: f32,
+    thumb_width: f32,
+    thumb_min_height: f32,
+    track_corner_radius: f32,
+    thumb_corner_radius: f32,
+    track_color: Option<u32>,
+    thumb_color: Option<u32>,
+}
+
+impl ScrollBarStyle {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn track_width(mut self, value: f32) -> Self {
+        self.track_width = value;
+        self
+    }
+
+    pub fn thumb_width(mut self, value: f32) -> Self {
+        self.thumb_width = value;
+        self
+    }
+
+    pub fn thumb_min_height(mut self, value: f32) -> Self {
+        self.thumb_min_height = value;
+        self
+    }
+
+    pub fn track_corner_radius(mut self, value: f32) -> Self {
+        self.track_corner_radius = value;
+        self
+    }
+
+    pub fn thumb_corner_radius(mut self, value: f32) -> Self {
+        self.thumb_corner_radius = value;
+        self
+    }
+
+    pub fn track_color(mut self, value: u32) -> Self {
+        self.track_color = Some(value);
+        self
+    }
+
+    pub fn thumb_color(mut self, value: u32) -> Self {
+        self.thumb_color = Some(value);
+        self
+    }
+
+    pub(crate) fn apply_to(self, scroll_bar: &ScrollBar) {
+        scroll_bar
+            .track_width(self.track_width)
+            .thumb_width(self.thumb_width)
+            .thumb_min_height(self.thumb_min_height)
+            .track_corner_radius(self.track_corner_radius)
+            .thumb_corner_radius(self.thumb_corner_radius);
+        if let Some(color) = self.track_color {
+            scroll_bar.track_color(color);
+        } else {
+            scroll_bar.clear_track_color();
+        }
+        if let Some(color) = self.thumb_color {
+            scroll_bar.thumb_color(color);
+        } else {
+            scroll_bar.clear_thumb_color();
+        }
+    }
+}
+
+impl Default for ScrollBarStyle {
+    fn default() -> Self {
+        Self {
+            track_width: DEFAULT_TRACK_THICKNESS,
+            thumb_width: DEFAULT_THUMB_THICKNESS,
+            thumb_min_height: DEFAULT_MIN_THUMB_SIZE,
+            track_corner_radius: 0.0,
+            thumb_corner_radius: 0.0,
+            track_color: None,
+            thumb_color: None,
+        }
+    }
+}
+
 fn clamp(value: f32, min: f32, max: f32) -> f32 {
     if value < min {
         return min;
@@ -237,6 +322,14 @@ impl ScrollBar {
         self
     }
 
+    fn clear_track_color(&self) {
+        self.inner.track_color_overridden.set(false);
+        self.inner
+            .track_color
+            .set(current_theme().colors.scrollbar_track);
+        self.apply_color_style();
+    }
+
     pub fn thumb_color(&self, color: u32) -> &Self {
         self.inner.thumb_color_overridden.set(true);
         self.inner.thumb_color.set(color);
@@ -244,6 +337,14 @@ impl ScrollBar {
         self
     }
 
+    fn clear_thumb_color(&self) {
+        self.inner.thumb_color_overridden.set(false);
+        self.inner
+            .thumb_color
+            .set(current_theme().colors.scrollbar_thumb);
+        self.apply_color_style();
+    }
+
     pub fn bind_scroll_handle(&self, handle: u64) {
         self.inner.target_handle.set(handle);
         self.inner

package/src/node/scroll_box.rs

@@ -219,6 +219,13 @@ impl ScrollBox {
         self
     }
 
+    pub fn scrollbar_style(&self, style: ScrollBarStyle) -> &Self {
+        style.apply_to(&self.inner.vertical_scrollbar);
+        style.apply_to(&self.inner.horizontal_scrollbar);
+        self.refresh_chrome();
+        self
+    }
+
     fn attach_listeners(&self) {
         let weak = Rc::downgrade(&self.inner);
         self.inner

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

@@ -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,
@@ -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,