@effindomv2/fui-rs 0.1.23 → 0.1.24

package/src/node/scroll_bar.rs

@@ -151,6 +151,12 @@ struct ScrollBarInner {
 }
 
 #[derive(Clone)]
+/// Scroll chrome helper matching FUI-AS `ScrollBar`.
+///
+/// This is not a retained `Node`; attach [`render`](Self::render) to a retained
+/// tree. It follows the active theme automatically. Per-instance theme
+/// callbacks belong on the rendered `FlexBox`, avoiding a root/state ownership
+/// cycle in this helper.
 pub struct ScrollBar {
     inner: Rc<ScrollBarInner>,
 }

package/src/node/scroll_box.rs

@@ -124,27 +124,6 @@ impl ScrollBox {
         self.inner.horizontal_scrollbar.clone()
     }
 
-    pub fn child<T: Node>(&self, node: &T) -> &Self {
-        self.inner.viewport.child(node);
-        self.bind_content_scroll_proxy_targets();
-        self
-    }
-
-    pub fn children<I, C>(&self, nodes: I) -> &Self
-    where
-        I: IntoIterator<Item = C>,
-        C: Into<Child>,
-    {
-        for node in nodes {
-            self.inner
-                .viewport
-                .retained_node_ref()
-                .append_child_ref(&node.into().node_ref);
-        }
-        self.bind_content_scroll_proxy_targets();
-        self
-    }
-
     pub fn scroll_enabled_x(&self, enabled: bool) -> &Self {
         self.inner.horizontal_scroll_enabled.set(enabled);
         self.inner.viewport.scroll_enabled_x(enabled);
@@ -518,6 +497,14 @@ impl HasFlexBoxRoot for ScrollBox {
     fn flex_box_root(&self) -> &FlexBox {
         &self.inner.root
     }
+
+    fn append_flex_box_surface_child(&self, child: NodeRef) {
+        self.inner
+            .viewport
+            .retained_node_ref()
+            .append_child_ref(&child);
+        self.bind_content_scroll_proxy_targets();
+    }
 }
 
 impl ThemeBindable for ScrollBox {

package/src/node/scroll_view.rs

@@ -36,8 +36,6 @@ impl ScrollView {
             props: Rc::new(RefCell::new(ScrollViewProps {
                 width: None,
                 height: None,
-                bg_color: None,
-                padding: None,
                 enable_scroll_x: true,
                 enable_scroll_y: true,
                 friction: None,
@@ -47,7 +45,7 @@ impl ScrollView {
                 persist_scroll: true,
                 transitions: None,
             })),
-            bound_scroll_state: Rc::new(RefCell::new(None)),
+            bound_scroll_state: Rc::new(RefCell::new(Some(ScrollState::new()))),
             active_animations: Rc::new(RefCell::new(ScrollViewAnimationState::default())),
         }
     }
@@ -76,12 +74,32 @@ impl ScrollView {
         self
     }
 
+    pub fn scroll_state(&self) -> ScrollState {
+        self.bound_scroll_state
+            .borrow()
+            .clone()
+            .expect("ScrollView always owns a scroll state")
+    }
+
+    pub fn is_vertical_scroll_enabled(&self) -> bool {
+        self.props.borrow().enable_scroll_y
+    }
+
+    pub fn is_horizontal_scroll_enabled(&self) -> bool {
+        self.props.borrow().enable_scroll_x
+    }
+
     pub fn width(&self, width: f32, unit: Unit) -> &Self {
         self.props.borrow_mut().width = Some((width, unit));
         self.set_viewport_width_if_pixel(width, unit);
         let mut core = self.core.borrow_mut();
         core.behavior.fill_width = false;
         core.behavior.fill_width_percent = None;
+        drop(core);
+        if self.has_built_handle() {
+            ui::set_width(self.handle().raw(), width, unit as u32);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
@@ -96,6 +114,11 @@ impl ScrollView {
         let mut core = self.core.borrow_mut();
         core.behavior.fill_height = false;
         core.behavior.fill_height_percent = None;
+        drop(core);
+        if self.has_built_handle() {
+            ui::set_height(self.handle().raw(), height, unit as u32);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
@@ -109,6 +132,11 @@ impl ScrollView {
         let mut core = self.core.borrow_mut();
         core.behavior.fill_width = true;
         core.behavior.fill_width_percent = None;
+        drop(core);
+        if self.has_built_handle() {
+            ui::set_fill_width(self.handle().raw(), true);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
@@ -117,6 +145,11 @@ impl ScrollView {
         let mut core = self.core.borrow_mut();
         core.behavior.fill_height = true;
         core.behavior.fill_height_percent = None;
+        drop(core);
+        if self.has_built_handle() {
+            ui::set_fill_height(self.handle().raw(), true);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
@@ -126,13 +159,74 @@ impl ScrollView {
         self
     }
 
-    pub fn bg_color(&self, color: u32) -> &Self {
-        self.props.borrow_mut().bg_color = Some(color);
+    pub fn fill_width_percent(&self, percent: f32) -> &Self {
+        self.props.borrow_mut().width = None;
+        let mut core = self.core.borrow_mut();
+        core.behavior.fill_width = false;
+        core.behavior.fill_width_percent = Some(percent);
+        drop(core);
+        if self.has_built_handle() {
+            ui::set_fill_width_percent(self.handle().raw(), percent);
+            self.notify_retained_layout_mutation();
+        }
+        self
+    }
+
+    pub fn fill_height_percent(&self, percent: f32) -> &Self {
+        self.props.borrow_mut().height = None;
+        let mut core = self.core.borrow_mut();
+        core.behavior.fill_height = false;
+        core.behavior.fill_height_percent = Some(percent);
+        drop(core);
+        if self.has_built_handle() {
+            ui::set_fill_height_percent(self.handle().raw(), percent);
+            self.notify_retained_layout_mutation();
+        }
+        self
+    }
+
+    pub fn min_width(&self, value: f32, unit: Unit) -> &Self {
+        self.core.borrow_mut().behavior.min_width = Some((value, unit));
+        if self.has_built_handle() {
+            ui::set_min_width(self.handle().raw(), value, unit as u32);
+            self.notify_retained_layout_mutation();
+        }
+        self
+    }
+
+    pub fn max_width(&self, value: f32, unit: Unit) -> &Self {
+        self.core.borrow_mut().behavior.max_width = Some((value, unit));
+        if self.has_built_handle() {
+            ui::set_max_width(self.handle().raw(), value, unit as u32);
+            self.notify_retained_layout_mutation();
+        }
+        self
+    }
+
+    pub fn min_height(&self, value: f32, unit: Unit) -> &Self {
+        self.core.borrow_mut().behavior.min_height = Some((value, unit));
+        if self.has_built_handle() {
+            ui::set_min_height(self.handle().raw(), value, unit as u32);
+            self.notify_retained_layout_mutation();
+        }
+        self
+    }
+
+    pub fn max_height(&self, value: f32, unit: Unit) -> &Self {
+        self.core.borrow_mut().behavior.max_height = Some((value, unit));
+        if self.has_built_handle() {
+            ui::set_max_height(self.handle().raw(), value, unit as u32);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
-    pub fn padding(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
-        self.props.borrow_mut().padding = Some((left, top, right, bottom));
+    pub fn flex_basis(&self, value: f32) -> &Self {
+        self.core.borrow_mut().behavior.flex_basis = Some(value);
+        if self.has_built_handle() {
+            ui::set_flex_basis(self.handle().raw(), value);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
@@ -142,6 +236,10 @@ impl ScrollView {
         props.enable_scroll_y = enabled_y;
         self.retained_node_ref()
             .set_scroll_routing_enabled(enabled_x, enabled_y);
+        if self.has_built_handle() {
+            ui::set_scroll_enabled(self.handle().raw(), enabled_x, enabled_y);
+            self.notify_retained_mutation();
+        }
         self
     }
 
@@ -154,6 +252,10 @@ impl ScrollView {
             .unwrap_or(true);
         self.retained_node_ref()
             .set_scroll_routing_enabled(enabled, enabled_y);
+        if self.has_built_handle() {
+            ui::set_scroll_enabled(self.handle().raw(), enabled, enabled_y);
+            self.notify_retained_mutation();
+        }
         self
     }
 
@@ -166,11 +268,19 @@ impl ScrollView {
             .unwrap_or(true);
         self.retained_node_ref()
             .set_scroll_routing_enabled(enabled_x, enabled);
+        if self.has_built_handle() {
+            ui::set_scroll_enabled(self.handle().raw(), enabled_x, enabled);
+            self.notify_retained_mutation();
+        }
         self
     }
 
-    pub fn scroll_friction(&self, friction: f32) -> &Self {
+    pub fn friction(&self, friction: f32) -> &Self {
         self.props.borrow_mut().friction = Some(friction);
+        if self.has_built_handle() {
+            ui::set_scroll_friction(self.handle().raw(), friction);
+            self.notify_retained_mutation();
+        }
         self
     }
 
@@ -204,16 +314,16 @@ impl ScrollView {
         self
     }
 
-    pub fn content_size(&self, width: f32, height: f32) -> &Self {
+    pub fn scroll_content_size(&self, width: f32, height: f32) -> &Self {
         self.props.borrow_mut().content_size = Some((width, height));
         self.set_content_size_metrics(width, height);
+        if self.has_built_handle() {
+            ui::set_scroll_content_size(self.handle().raw(), width, height);
+            self.notify_retained_mutation();
+        }
         self
     }
 
-    pub fn scroll_content_size(&self, width: f32, height: f32) -> &Self {
-        self.content_size(width, height)
-    }
-
     pub fn persist_scroll(&self, persist: bool) -> &Self {
         self.props.borrow_mut().persist_scroll = persist;
         self
@@ -493,6 +603,27 @@ impl Node for ScrollView {
     }
 }
 
+impl ThemeBindable for ScrollView {
+    fn theme_binding_node(&self) -> NodeRef {
+        self.retained_node_ref()
+    }
+
+    fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
+        let core = Rc::downgrade(&self.core);
+        let props = Rc::downgrade(&self.props);
+        let bound_scroll_state = Rc::downgrade(&self.bound_scroll_state);
+        let active_animations = Rc::downgrade(&self.active_animations);
+        Box::new(move || {
+            Some(Self {
+                core: core.upgrade()?,
+                props: props.upgrade()?,
+                bound_scroll_state: bound_scroll_state.upgrade()?,
+                active_animations: active_animations.upgrade()?,
+            })
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/src/node/svg_node.rs

@@ -40,24 +40,23 @@ impl Default for SvgState {
 
 #[derive(Clone)]
 pub struct SvgNode {
-    core: Rc<RefCell<NodeCore>>,
+    base: FlexBox,
     props: Rc<RefCell<SvgProps>>,
     state: Rc<RefCell<SvgState>>,
 }
 
 impl SvgNode {
     pub fn new(svg_id: u32) -> Self {
+        let base = FlexBox::default();
+        base.core.borrow_mut().kind = NodeKind::Svg;
         let node = Self {
-            core: Rc::new(RefCell::new(NodeCore::new(NodeKind::Svg))),
+            base,
             props: Rc::new(RefCell::new(SvgProps {
-                width: None,
-                height: None,
                 svg_id,
                 source_url: None,
                 tint_color: 0,
                 sampling_kind: ImageSamplingKind::Linear,
                 max_aniso: 0,
-                opacity: None,
             })),
             state: Rc::new(RefCell::new(SvgState {
                 requested_width_value: 0.0,
@@ -141,10 +140,6 @@ impl SvgNode {
         self
     }
 
-    pub fn source_url(&self, url: impl Into<String>) -> &Self {
-        self.source(url)
-    }
-
     pub fn clear_source(&self) -> &Self {
         self.release_owned_source_asset();
         {
@@ -166,10 +161,6 @@ impl SvgNode {
         self
     }
 
-    pub fn clear_source_url(&self) -> &Self {
-        self.clear_source()
-    }
-
     pub fn tint(&self, tint_color: u32) -> &Self {
         self.props.borrow_mut().tint_color = tint_color;
         if self.has_built_handle() {
@@ -179,15 +170,6 @@ impl SvgNode {
         self
     }
 
-    pub fn opacity(&self, value: f32) -> &Self {
-        self.props.borrow_mut().opacity = Some(value.clamp(0.0, 1.0));
-        if self.has_built_handle() {
-            self.build_self();
-            self.notify_retained_mutation();
-        }
-        self
-    }
-
     pub fn alt_text(&self, value: impl Into<String>) -> &Self {
         let value = value.into();
         self.semantic_role(SemanticRole::Image);
@@ -207,17 +189,6 @@ impl SvgNode {
         self
     }
 
-    pub fn interactive(&self, interactive: bool) -> &Self {
-        self.core.borrow_mut().behavior.interactive = interactive;
-        self
-    }
-
-    pub fn on_click(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
-        self.core.borrow_mut().handlers.pointer_click = Some(Rc::new(handler));
-        self.retained_node_ref().require_interactive();
-        self
-    }
-
     pub fn asset_state_signal(&self) -> crate::assets::AssetStateSignal {
         get_svg_asset_state(self.props.borrow().svg_id)
     }
@@ -284,8 +255,6 @@ impl SvgNode {
         let asset_width = self.asset_width();
         let asset_height = self.asset_height();
         let has_intrinsic_size = asset_width > 0.0 && asset_height > 0.0;
-        let mut props = self.props.borrow_mut();
-
         if has_requested_width {
             let mut resolved_width_value = requested_width_value;
             let mut resolved_width_unit = requested_width_unit;
@@ -297,14 +266,7 @@ impl SvgNode {
                 }
                 resolved_width_unit = Unit::Pixel;
             }
-            props.width = Some((resolved_width_value, resolved_width_unit));
-            if self.has_built_handle() {
-                ui::set_width(
-                    self.handle().raw(),
-                    resolved_width_value,
-                    resolved_width_unit as u32,
-                );
-            }
+            self.base.width(resolved_width_value, resolved_width_unit);
         }
 
         if has_requested_height {
@@ -318,19 +280,8 @@ impl SvgNode {
                 }
                 resolved_height_unit = Unit::Pixel;
             }
-            props.height = Some((resolved_height_value, resolved_height_unit));
-            if self.has_built_handle() {
-                ui::set_height(
-                    self.handle().raw(),
-                    resolved_height_value,
-                    resolved_height_unit as u32,
-                );
-            }
-        }
-
-        drop(props);
-        if self.has_built_handle() {
-            self.notify_retained_layout_mutation();
+            self.base
+                .height(resolved_height_value, resolved_height_unit);
         }
     }
 
@@ -348,16 +299,16 @@ impl SvgNode {
             }
         }
 
-        let core_weak: Weak<RefCell<NodeCore>> = Rc::downgrade(&self.core);
+        let base_weak = self.base.downgrade();
         let props_weak: Weak<RefCell<SvgProps>> = Rc::downgrade(&self.props);
         let state_weak: Weak<RefCell<SvgState>> = Rc::downgrade(&self.state);
         let callback: Callback = Rc::new(move || {
-            if let (Some(core), Some(props), Some(state)) = (
-                core_weak.upgrade(),
+            if let (Some(base), Some(props), Some(state)) = (
+                base_weak.upgrade(),
                 props_weak.upgrade(),
                 state_weak.upgrade(),
             ) {
-                let node = SvgNode { core, props, state };
+                let node = SvgNode { base, props, state };
                 node.apply_resolved_sizing();
             }
         });
@@ -383,16 +334,46 @@ impl SvgNode {
 
 impl Node for SvgNode {
     fn retained_node_ref(&self) -> NodeRef {
-        NodeRef::from_node(self.core.clone(), self.clone())
+        NodeRef::from_node(self.base.core.clone(), self.clone())
     }
 
     fn build_self(&self) {
         self.apply_resolved_sizing();
-        apply_svg_props(
-            self.handle(),
-            &self.props.borrow(),
-            self.core.borrow().behavior.clone(),
-        );
+        self.base.build_self();
+        apply_svg_props(self.handle(), &self.props.borrow());
+    }
+}
+
+impl HasFlexBoxRoot for SvgNode {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.base
+    }
+
+    fn set_flex_box_surface_width(&self, value: f32, unit: Unit) {
+        self.width(value, unit);
+    }
+
+    fn set_flex_box_surface_height(&self, value: f32, unit: Unit) {
+        self.height(value, unit);
+    }
+}
+
+impl ThemeBindable for SvgNode {
+    fn theme_binding_node(&self) -> NodeRef {
+        self.retained_node_ref()
+    }
+
+    fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
+        let base = self.base.downgrade();
+        let props = Rc::downgrade(&self.props);
+        let state = Rc::downgrade(&self.state);
+        Box::new(move || {
+            Some(Self {
+                base: base.upgrade()?,
+                props: props.upgrade()?,
+                state: state.upgrade()?,
+            })
+        })
     }
 }