@effindomv2/fui-rs 0.1.22 → 0.1.24

package/src/node/custom_drawable.rs

@@ -121,6 +121,8 @@ impl ThemeBindable for CustomDrawable {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::app::Application;
+    use crate::ffi::{self, Call};
 
     fn assert_flex_box_surface<T: FlexBoxSurface>() {}
     fn assert_theme_bindable<T: ThemeBindable>() {}
@@ -145,4 +147,22 @@ mod tests {
         drop(drawable);
         invalidator.mark_dirty();
     }
+
+    #[test]
+    fn custom_drawable_requests_focus_through_node_trait() {
+        ffi::test::reset();
+        let drawable = CustomDrawable::new(|_| {});
+        drawable.focusable(true, 0);
+        Application::mount(drawable.clone());
+        let handle = drawable.handle().raw();
+        ffi::test::take_calls();
+
+        drawable.focus_now();
+
+        let calls = ffi::test::take_calls();
+        assert!(calls.iter().any(
+            |call| matches!(call, Call::RequestFocus { handle: requested } if *requested == handle)
+        ));
+        Application::unmount();
+    }
 }

package/src/node/flex_box.rs

@@ -476,18 +476,7 @@ impl FlexBox {
     }
 
     pub fn focusable(&self, enabled: bool, tab_index: i32) -> &Self {
-        if enabled {
-            self.retained_node_ref().require_interactive();
-        }
-        let mut core = self.core.borrow_mut();
-        core.behavior.focusable = Some((enabled, tab_index));
-        let interactive = core.behavior.enabled && core.behavior.inherited_enabled;
-        let has_built_handle = core.handle != NodeHandle::INVALID;
-        drop(core);
-        if has_built_handle {
-            ui::set_focusable(self.handle().raw(), interactive && enabled, tab_index);
-            self.notify_retained_mutation();
-        }
+        Node::focusable(self, enabled, tab_index);
         self
     }
 
@@ -607,54 +596,38 @@ impl FlexBox {
         self
     }
 
-    pub(crate) fn semantic_disabled(&self, disabled: bool) -> &Self {
-        self.core.borrow_mut().behavior.semantic_disabled = Some(disabled);
-        if self.has_built_handle() {
-            ui::set_semantic_disabled(self.handle().raw(), true, disabled);
-            self.notify_retained_mutation();
-        }
+    pub fn semantic_disabled(&self, disabled: bool) -> &Self {
+        Node::semantic_disabled(self, disabled);
         self
     }
 
     pub fn semantic_checked(&self, state: SemanticCheckedState) -> &Self {
-        self.core.borrow_mut().behavior.semantic_checked = Some(state);
+        Node::semantic_checked(self, state);
         self
     }
 
-    pub(crate) fn semantic_selected(&self, selected: bool) -> &Self {
-        self.core.borrow_mut().behavior.semantic_selected = Some(selected);
-        if self.has_built_handle() {
-            ui::set_semantic_selected(self.handle().raw(), true, selected);
-            self.notify_retained_mutation();
-        }
+    pub fn semantic_selected(&self, selected: bool) -> &Self {
+        Node::semantic_selected(self, selected);
         self
     }
 
     pub fn semantic_value_range(&self, value_now: f32, value_min: f32, value_max: f32) -> &Self {
-        self.core.borrow_mut().behavior.semantic_value_range =
-            Some((value_now, value_min, value_max));
+        Node::semantic_value_range(self, value_now, value_min, value_max);
         self
     }
 
     pub fn semantic_orientation(&self, orientation: Orientation) -> &Self {
-        self.core.borrow_mut().behavior.semantic_orientation = Some(orientation);
+        Node::semantic_orientation(self, orientation);
         self
     }
 
     pub fn request_semantic_announcement(&self) -> &Self {
-        self.core
-            .borrow_mut()
-            .behavior
-            .request_semantic_announcement = true;
+        Node::request_semantic_announcement(self);
         self
     }
 
     pub fn visibility(&self, visibility: Visibility) -> &Self {
-        self.core.borrow_mut().behavior.visibility = Some(visibility);
-        if self.has_built_handle() {
-            ui::set_visibility(self.handle().raw(), visibility as u32);
-            self.notify_retained_layout_mutation();
-        }
+        Node::visibility(self, visibility);
         self
     }
 
@@ -725,28 +698,48 @@ impl FlexBox {
 
     pub fn flex_basis(&self, basis: f32) -> &Self {
         self.core.borrow_mut().behavior.flex_basis = Some(basis);
+        if self.has_built_handle() {
+            ui::set_flex_basis(self.handle().raw(), basis);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
     pub fn justify_content(&self, justify: JustifyContent) -> &Self {
         self.host_style_layers.borrow_mut().local.justify_content = Some(justify);
         self.core.borrow_mut().behavior.justify_content = Some(justify);
+        if self.has_built_handle() {
+            ui::set_justify_content(self.handle().raw(), justify as u32);
+            self.notify_retained_mutation();
+        }
         self
     }
 
     pub fn align_items(&self, align: AlignItems) -> &Self {
         self.host_style_layers.borrow_mut().local.align_items = Some(align);
         self.core.borrow_mut().behavior.align_items = Some(align);
+        if self.has_built_handle() {
+            ui::set_align_items(self.handle().raw(), align as u32);
+            self.notify_retained_mutation();
+        }
         self
     }
 
     pub fn align_self(&self, align: AlignSelf) -> &Self {
         self.core.borrow_mut().behavior.align_self = Some(align);
+        if self.has_built_handle() {
+            ui::set_align_self(self.handle().raw(), align as u32);
+            self.notify_retained_mutation();
+        }
         self
     }
 
     pub fn margin(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
         self.core.borrow_mut().behavior.margin = Some((left, top, right, bottom));
+        if self.has_built_handle() {
+            ui::set_margin(self.handle().raw(), left, top, right, bottom);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
@@ -989,11 +982,19 @@ impl FlexBox {
 
     pub fn flex_wrap(&self, wrap: FlexWrap) -> &Self {
         self.core.borrow_mut().behavior.flex_wrap = Some(wrap);
+        if self.has_built_handle() {
+            ui::set_flex_wrap(self.handle().raw(), wrap as u32);
+            self.notify_retained_layout_mutation();
+        }
         self
     }
 
     pub fn clip_to_bounds(&self, clip: bool) -> &Self {
         self.core.borrow_mut().behavior.clip_to_bounds = Some(clip);
+        if self.has_built_handle() {
+            ui::set_clip_to_bounds(self.handle().raw(), clip);
+            self.notify_retained_mutation();
+        }
         self
     }
 
@@ -1007,16 +1008,7 @@ impl FlexBox {
         self
     }
 
-    pub fn shared_size_scope(&self, enabled: bool) -> &Self {
-        self.core.borrow_mut().behavior.is_shared_size_scope = enabled;
-        if self.has_built_handle() {
-            ui::set_is_shared_size_scope(self.handle().raw(), enabled);
-            self.notify_retained_layout_mutation();
-        }
-        self
-    }
-
-    pub fn on_click(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
+    pub fn on_pointer_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

package/src/node/grid.rs

@@ -55,11 +55,8 @@ impl Node for Grid {
     }
 
     fn build_self(&self) {
-        apply_grid_props(
-            self.handle(),
-            &self.props.borrow(),
-            self.base.core.borrow().behavior.clone(),
-        );
+        self.base.build_self();
+        apply_grid_props(self.handle(), &self.props.borrow());
     }
 
     fn build_children(&self) {
@@ -69,6 +66,14 @@ impl Node for Grid {
 }
 
 impl Grid {
+    pub fn shared_size_scope<T: Node>(target: &T, enabled: bool) {
+        let node = target.retained_node_ref();
+        node.set_shared_size_scope(enabled);
+        if target.has_built_handle() {
+            target.notify_retained_layout_mutation();
+        }
+    }
+
     pub(crate) fn downgrade(&self) -> WeakFlexBox {
         self.base.downgrade()
     }
@@ -88,112 +93,6 @@ impl Grid {
         }
     }
 
-    pub fn width(&self, width: f32, unit: Unit) -> &Self {
-        self.props.borrow_mut().width = Some((width, unit));
-        if self.has_built_handle() {
-            ui::set_width(self.handle().raw(), width, unit as u32);
-            self.notify_retained_layout_mutation();
-        }
-        self
-    }
-
-    pub fn width_len(&self, length: Length) -> &Self {
-        let (width, unit) = length;
-        self.width(width, unit)
-    }
-
-    pub fn height(&self, height: f32, unit: Unit) -> &Self {
-        self.props.borrow_mut().height = Some((height, unit));
-        if self.has_built_handle() {
-            ui::set_height(self.handle().raw(), height, unit as u32);
-            self.notify_retained_layout_mutation();
-        }
-        self
-    }
-
-    pub fn height_len(&self, length: Length) -> &Self {
-        let (height, unit) = length;
-        self.height(height, unit)
-    }
-
-    pub fn bg_color(&self, color: u32) -> &Self {
-        self.props.borrow_mut().bg_color = Some(color);
-        if self.has_built_handle() {
-            ui::set_bg_color(self.handle().raw(), color);
-            self.notify_retained_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));
-        if self.has_built_handle() {
-            ui::set_padding(self.handle().raw(), left, top, right, bottom);
-            self.notify_retained_layout_mutation();
-        }
-        self
-    }
-
-    pub fn corner_radius(&self, radius: f32) -> &Self {
-        self.base.corner_radius(radius);
-        self
-    }
-
-    pub fn corners(&self, tl: f32, tr: f32, br: f32, bl: f32) -> &Self {
-        self.base.corners(tl, tr, br, bl);
-        self
-    }
-
-    pub fn cursor(&self, style: CursorStyle) -> &Self {
-        self.base.cursor(style);
-        self
-    }
-
-    pub fn interactive(&self, interactive: bool) -> &Self {
-        self.base.interactive(interactive);
-        self
-    }
-
-    pub fn semantic_role(&self, role: SemanticRole) -> &Self {
-        self.base.semantic_role(role);
-        self
-    }
-
-    pub fn semantic_label(&self, label: impl Into<String>) -> &Self {
-        self.base.semantic_label(label);
-        self
-    }
-
-    pub(crate) fn semantic_disabled(&self, disabled: bool) -> &Self {
-        self.base.semantic_disabled(disabled);
-        self
-    }
-
-    pub fn on_pointer_down(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
-        self.base.on_pointer_down(handler);
-        self
-    }
-
-    pub fn on_pointer_up(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
-        self.base.on_pointer_up(handler);
-        self
-    }
-
-    pub fn on_pointer_enter(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
-        self.base.on_pointer_enter(handler);
-        self
-    }
-
-    pub fn on_pointer_leave(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
-        self.base.on_pointer_leave(handler);
-        self
-    }
-
-    pub fn on_pointer_cancel(&self, handler: impl Fn(&mut PointerEventArgs) + 'static) -> &Self {
-        self.base.on_pointer_cancel(handler);
-        self
-    }
-
     pub fn columns<I>(&self, tracks: I) -> &Self
     where
         I: IntoIterator<Item = GridTrack>,
@@ -226,23 +125,6 @@ impl Grid {
         self
     }
 
-    pub fn child<T: Node>(&self, child: &T) -> &Self {
-        self.append_child(child);
-        self
-    }
-
-    pub fn children<I, C>(&self, children: I) -> &Self
-    where
-        I: IntoIterator<Item = C>,
-        C: Into<Child>,
-    {
-        for child in children {
-            self.retained_node_ref()
-                .append_child_ref(&child.into().node_ref);
-        }
-        self
-    }
-
     pub fn column_shared_size_group(&self, index: u32, group: impl Into<String>) -> &Self {
         let group = group.into();
         let mut props = self.props.borrow_mut();
@@ -263,6 +145,10 @@ impl Grid {
         self
     }
 
+    pub fn clear_column_shared_size_group(&self, index: u32) -> &Self {
+        self.column_shared_size_group(index, "")
+    }
+
     pub fn row_shared_size_group(&self, index: u32, group: impl Into<String>) -> &Self {
         let group = group.into();
         let mut props = self.props.borrow_mut();
@@ -283,6 +169,10 @@ impl Grid {
         self
     }
 
+    pub fn clear_row_shared_size_group(&self, index: u32) -> &Self {
+        self.row_shared_size_group(index, "")
+    }
+
     pub fn place_child<T: Node>(
         &self,
         child: &T,
@@ -307,3 +197,28 @@ impl Grid {
         self
     }
 }
+
+impl HasFlexBoxRoot for Grid {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.base
+    }
+}
+
+impl ThemeBindable for Grid {
+    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 placements = Rc::downgrade(&self.placements);
+        Box::new(move || {
+            Some(Self {
+                base: base.upgrade()?,
+                props: props.upgrade()?,
+                placements: placements.upgrade()?,
+            })
+        })
+    }
+}

package/src/node/helpers.rs

@@ -47,7 +47,7 @@ pub fn column() -> FlexBox {
     root
 }
 
-pub fn portal() -> FlexBox {
+pub fn portal() -> Portal {
     let root = FlexBox::default();
     root.clip_to_bounds(false).portal(true);
     root
@@ -100,6 +100,18 @@ pub(crate) fn apply_flex_box_props(
     if let Some((height, unit)) = props.height {
         ui::set_height(handle.raw(), height, unit as u32);
     }
+    if let Some((value, unit)) = props.min_width {
+        ui::set_min_width(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = props.max_width {
+        ui::set_max_width(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = props.min_height {
+        ui::set_min_height(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = props.max_height {
+        ui::set_max_height(handle.raw(), value, unit as u32);
+    }
     if let Some(style) = props.box_style {
         ui::set_box_style(
             handle.raw(),
@@ -175,6 +187,18 @@ pub(crate) fn apply_text_props(handle: NodeHandle, props: &TextProps, behavior:
     if let Some((height, unit)) = props.height {
         ui::set_height(handle.raw(), height, unit as u32);
     }
+    if let Some((value, unit)) = props.min_width {
+        ui::set_min_width(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = props.max_width {
+        ui::set_max_width(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = props.min_height {
+        ui::set_min_height(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = props.max_height {
+        ui::set_max_height(handle.raw(), value, unit as u32);
+    }
     if props.has_font {
         ui::set_font(handle.raw(), props.font_id, props.font_size);
     }
@@ -226,21 +250,12 @@ pub(crate) fn apply_text_props(handle: NodeHandle, props: &TextProps, behavior:
     if let Some(caret_color) = props.caret_color {
         ui::set_caret_color(handle.raw(), caret_color);
     }
+    if let Some((start, end)) = props.selection_range_bytes {
+        ui::set_text_selection_range(handle.raw(), start, end);
+    }
 }
 
-pub(crate) fn apply_grid_props(handle: NodeHandle, props: &GridProps, behavior: NodeBehavior) {
-    if let Some((width, unit)) = props.width {
-        ui::set_width(handle.raw(), width, unit as u32);
-    }
-    if let Some((height, unit)) = props.height {
-        ui::set_height(handle.raw(), height, unit as u32);
-    }
-    if let Some(color) = props.bg_color {
-        ui::set_bg_color(handle.raw(), color);
-    }
-    if let Some((left, top, right, bottom)) = props.padding {
-        ui::set_padding(handle.raw(), left, top, right, bottom);
-    }
+pub(crate) fn apply_grid_props(handle: NodeHandle, props: &GridProps) {
     ui::grid_set_columns(handle.raw(), &props.columns, &props.column_types);
     ui::grid_set_rows(handle.raw(), &props.rows, &props.row_types);
     for (index, group) in &props.column_shared_size_groups {
@@ -249,16 +264,9 @@ pub(crate) fn apply_grid_props(handle: NodeHandle, props: &GridProps, behavior:
     for (index, group) in &props.row_shared_size_groups {
         ui::grid_set_row_shared_size_group(handle.raw(), *index, group);
     }
-    apply_behavior(handle, behavior);
 }
 
-pub(crate) fn apply_image_props(handle: NodeHandle, props: &ImageProps, behavior: NodeBehavior) {
-    if let Some((width, unit)) = props.width {
-        ui::set_width(handle.raw(), width, unit as u32);
-    }
-    if let Some((height, unit)) = props.height {
-        ui::set_height(handle.raw(), height, unit as u32);
-    }
+pub(crate) fn apply_image_props(handle: NodeHandle, props: &ImageProps) {
     if let Some((left, top, right, bottom)) = props.image_nine {
         ui::set_image_nine(
             handle.raw(),
@@ -279,16 +287,9 @@ pub(crate) fn apply_image_props(handle: NodeHandle, props: &ImageProps, behavior
             props.max_aniso,
         );
     }
-    apply_behavior(handle, behavior);
 }
 
-pub(crate) fn apply_svg_props(handle: NodeHandle, props: &SvgProps, behavior: NodeBehavior) {
-    if let Some((width, unit)) = props.width {
-        ui::set_width(handle.raw(), width, unit as u32);
-    }
-    if let Some((height, unit)) = props.height {
-        ui::set_height(handle.raw(), height, unit as u32);
-    }
+pub(crate) fn apply_svg_props(handle: NodeHandle, props: &SvgProps) {
     ui::set_svg(
         handle.raw(),
         props.svg_id,
@@ -296,10 +297,6 @@ pub(crate) fn apply_svg_props(handle: NodeHandle, props: &SvgProps, behavior: No
         props.sampling_kind,
         props.max_aniso,
     );
-    if let Some(opacity) = props.opacity {
-        ui::set_layer_effect(handle.raw(), opacity, 0.0, 0);
-    }
-    apply_behavior(handle, behavior);
 }
 
 pub(crate) fn apply_scroll_view_props(
@@ -321,12 +318,6 @@ pub(crate) fn apply_scroll_view_props(
     if let Some((height, unit)) = props.height {
         ui::set_height(handle.raw(), height, unit as u32);
     }
-    if let Some(color) = props.bg_color {
-        ui::set_bg_color(handle.raw(), color);
-    }
-    if let Some((left, top, right, bottom)) = props.padding {
-        ui::set_padding(handle.raw(), left, top, right, bottom);
-    }
     ui::set_scroll_enabled(handle.raw(), props.enable_scroll_x, props.enable_scroll_y);
     ui::set_smooth_scrolling(handle.raw(), props.smooth_scrolling);
     if let Some(friction) = props.friction {
@@ -365,6 +356,9 @@ pub(crate) fn apply_behavior(handle: NodeHandle, behavior: NodeBehavior) {
     if let Some(selected) = behavior.semantic_selected {
         ui::set_semantic_selected(handle.raw(), true, selected);
     }
+    if let Some(expanded) = behavior.semantic_expanded {
+        ui::set_semantic_expanded(handle.raw(), true, expanded);
+    }
     if let Some((value_now, value_min, value_max)) = behavior.semantic_value_range {
         ui::set_semantic_value_range(handle.raw(), true, value_now, value_min, value_max);
     }
@@ -435,7 +429,4 @@ pub(crate) fn apply_behavior(handle: NodeHandle, behavior: NodeBehavior) {
     if behavior.track_semantic_disabled_from_enabled {
         ui::set_semantic_disabled(handle.raw(), true, !effective_enabled);
     }
-    if behavior.request_semantic_announcement {
-        ui::request_semantic_announcement(handle.raw());
-    }
 }