@effindomv2/fui-rs 0.1.14 → 0.1.16

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fui-rs"
-version = "0.1.14"
+version = "0.1.16"
 edition = "2021"
 license = "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effindomv2/fui-rs",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "private": false,
   "license": "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial",
   "description": "EffinDom v2 Rust frontend framework SDK and host generators",

package/src/drawing.rs

@@ -63,36 +63,45 @@ impl Paint {
     }
 }
 
-pub struct Path {
+struct PathResource {
     id: u32,
-    disposed: bool,
+}
+
+impl Drop for PathResource {
+    fn drop(&mut self) {
+        unsafe { ffi::fui_path_destroy(self.id) };
+    }
+}
+
+#[derive(Clone)]
+pub struct Path {
+    resource: Rc<PathResource>,
 }
 
 impl Path {
     pub fn new() -> Self {
         let id = unsafe { ffi::fui_path_create() };
         Self {
-            id,
-            disposed: false,
+            resource: Rc::new(PathResource { id }),
         }
     }
 
     pub fn id(&self) -> u32 {
-        self.id
+        self.resource.id
     }
 
     pub fn move_to(&mut self, x: f32, y: f32) -> &mut Self {
-        unsafe { ffi::fui_path_move_to(self.id, x, y) };
+        unsafe { ffi::fui_path_move_to(self.id(), x, y) };
         self
     }
 
     pub fn line_to(&mut self, x: f32, y: f32) -> &mut Self {
-        unsafe { ffi::fui_path_line_to(self.id, x, y) };
+        unsafe { ffi::fui_path_line_to(self.id(), x, y) };
         self
     }
 
     pub fn quad_to(&mut self, cx: f32, cy: f32, x: f32, y: f32) -> &mut Self {
-        unsafe { ffi::fui_path_quad_to(self.id, cx, cy, x, y) };
+        unsafe { ffi::fui_path_quad_to(self.id(), cx, cy, x, y) };
         self
     }
 
@@ -105,39 +114,31 @@ impl Path {
         x: f32,
         y: f32,
     ) -> &mut Self {
-        unsafe { ffi::fui_path_cubic_to(self.id, cx1, cy1, cx2, cy2, x, y) };
+        unsafe { ffi::fui_path_cubic_to(self.id(), cx1, cy1, cx2, cy2, x, y) };
         self
     }
 
     pub fn close(&mut self) -> &mut Self {
-        unsafe { ffi::fui_path_close(self.id) };
+        unsafe { ffi::fui_path_close(self.id()) };
         self
     }
 
     pub fn add_rect(&mut self, x: f32, y: f32, w: f32, h: f32) -> &mut Self {
-        unsafe { ffi::fui_path_add_rect(self.id, x, y, w, h) };
+        unsafe { ffi::fui_path_add_rect(self.id(), x, y, w, h) };
         self
     }
 
     pub fn add_circle(&mut self, cx: f32, cy: f32, r: f32) -> &mut Self {
-        unsafe { ffi::fui_path_add_circle(self.id, cx, cy, r) };
+        unsafe { ffi::fui_path_add_circle(self.id(), cx, cy, r) };
         self
     }
 }
 
-impl Drop for Path {
-    fn drop(&mut self) {
-        if !self.disposed {
-            unsafe { ffi::fui_path_destroy(self.id) };
-            self.disposed = true;
-        }
-    }
-}
-
 #[derive(Default)]
 struct DrawContextState {
     canvas_ptr: usize,
     words: Vec<u32>,
+    retained_paths: Vec<Path>,
 }
 
 #[derive(Clone, Default)]
@@ -151,6 +152,7 @@ impl DrawContext {
             inner: Rc::new(RefCell::new(DrawContextState {
                 canvas_ptr,
                 words: Vec::new(),
+                retained_paths: Vec::new(),
             })),
         }
     }
@@ -172,6 +174,7 @@ impl DrawContext {
             )
         };
         state.words.clear();
+        state.retained_paths.clear();
     }
 
     pub fn save(&self) {
@@ -289,6 +292,7 @@ impl DrawContext {
         state.words.push(paint.fill_color);
         state.words.push(paint.stroke_color);
         Self::push_float(&mut state.words, paint.stroke_width);
+        state.retained_paths.push(path.clone());
     }
 
     pub fn draw_text_node<T: Node>(&self, node: &T, x: f32, y: f32) {

package/src/lib.rs

@@ -433,6 +433,7 @@ pub mod prelude {
         FileWorkerProcessResult, FileWriteProgress,
     };
     pub use crate::focus_visibility::show_keyboard_focus_for_key_event;
+    pub use crate::frame_scheduler::{mark_needs_commit, on_loaded, LoadedEventArgs};
     pub use crate::fui_component;
     pub use crate::image_sampling::{ImageSampling, ImageSamplingMode};
     pub use crate::logger;
@@ -440,8 +441,8 @@ pub mod prelude {
     pub use crate::node::{
         auto, column, custom_drawable, fill, flex_box, grid, image, pct, portal, px, row,
         scroll_box, scroll_view, svg, text, viewport_height, viewport_width, virtual_list, Border,
-        Child, ContextMenuEventArgs, Corners, CustomDrawable, EdgeInsets, FlexBox, FlexBoxSurface,
-        GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
+        Child, ContextMenuEventArgs, Corners, CustomDrawable, DrawableInvalidator, EdgeInsets,
+        FlexBox, FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
         PresenterHostStyle, ScrollBar, ScrollBarVisibility, ScrollBox, ScrollState, ScrollView,
         Shadow, Svg, SvgNode, Text, TextCore, TextNode, ThemeBindable, VirtualList,
     };
@@ -558,8 +559,8 @@ pub use navigation::*;
 pub use node::{
     auto, column, custom_drawable, fill, flex_box, grid, image, pct, portal, px, row, scroll_box,
     scroll_view, svg, text, viewport_height, viewport_width, virtual_list, Border, Child,
-    ContextMenuEventArgs, Corners, CustomDrawable, EdgeInsets, FlexBox, FlexBoxSurface,
-    GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
+    ContextMenuEventArgs, Corners, CustomDrawable, DrawableInvalidator, EdgeInsets, FlexBox,
+    FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
     PresenterHostStyle, ScrollBar, ScrollBarVisibility, ScrollBox, ScrollState, ScrollView, Shadow,
     Svg, SvgNode, Text, TextCore, TextNode, ThemeBindable, VirtualList,
 };

package/src/node/custom_drawable.rs

@@ -7,6 +7,19 @@ pub struct CustomDrawable {
     draw_callback: DrawCallback,
 }
 
+#[derive(Clone)]
+pub struct DrawableInvalidator {
+    base: WeakFlexBox,
+}
+
+impl DrawableInvalidator {
+    pub fn mark_dirty(&self) {
+        if let Some(base) = self.base.upgrade() {
+            mark_base_dirty(&base);
+        }
+    }
+}
+
 impl CustomDrawable {
     pub fn new(handler: impl Fn(&mut DrawContext) + 'static) -> Self {
         let base = FlexBox::default();
@@ -17,94 +30,28 @@ impl CustomDrawable {
         }
     }
 
-    pub fn width(&self, width: f32, unit: Unit) -> &Self {
-        self.base.width(width, unit);
-        self
-    }
-
-    pub fn width_len(&self, length: Length) -> &Self {
-        self.base.width_len(length);
-        self
-    }
-
-    pub fn height(&self, height: f32, unit: Unit) -> &Self {
-        self.base.height(height, unit);
-        self
-    }
-
-    pub fn height_len(&self, length: Length) -> &Self {
-        self.base.height_len(length);
-        self
-    }
-
-    pub fn bg_color(&self, color: u32) -> &Self {
-        self.base.bg_color(color);
-        self
-    }
-
-    pub fn corner_radius(&self, radius: f32) -> &Self {
-        self.base.corner_radius(radius);
-        self
-    }
-
-    pub fn border(&self, width: f32, color: u32) -> &Self {
-        self.base.border(width, color);
-        self
-    }
-
-    pub fn border_config(&self, border: Border) -> &Self {
-        self.base.border_config(border);
-        self
-    }
-
-    pub fn opacity(&self, value: f32) -> &Self {
-        self.base.opacity(value);
-        self
-    }
-
-    pub fn drop_shadow(
-        &self,
-        color: u32,
-        offset_x: f32,
-        offset_y: f32,
-        blur_sigma: f32,
-        spread: f32,
-    ) -> &Self {
-        self.base
-            .drop_shadow(color, offset_x, offset_y, blur_sigma, spread);
-        self
-    }
-
-    pub fn linear_gradient(
-        &self,
-        sx: f32,
-        sy: f32,
-        ex: f32,
-        ey: f32,
-        offsets: Vec<f32>,
-        colors: Vec<u32>,
-    ) -> &Self {
-        self.base.linear_gradient(sx, sy, ex, ey, offsets, colors);
-        self
+    pub fn mark_dirty(&self) {
+        mark_base_dirty(&self.base);
     }
 
-    pub fn child<T: Node>(&self, child: &T) -> &Self {
-        self.base.child(child);
-        self
+    pub fn invalidator(&self) -> DrawableInvalidator {
+        DrawableInvalidator {
+            base: self.base.downgrade(),
+        }
     }
+}
 
-    pub fn mark_dirty(&self) {
-        let handle = self.handle();
-        if handle != NodeHandle::INVALID {
-            let Some(bounds) = ui::get_visible_bounds(handle.raw()) else {
-                return;
-            };
-            if bounds[2] <= 0.0 || bounds[3] <= 0.0 {
-                return;
-            }
+fn mark_base_dirty(base: &FlexBox) {
+    let handle = base.handle();
+    if handle != NodeHandle::INVALID {
+        let Some(bounds) = ui::get_visible_bounds(handle.raw()) else {
+            return;
+        };
+        if bounds[2] <= 0.0 || bounds[3] <= 0.0 {
+            return;
         }
-        crate::frame_scheduler::mark_needs_commit();
     }
+    crate::frame_scheduler::mark_needs_commit();
 }
 
 impl Node for CustomDrawable {
@@ -147,3 +94,55 @@ impl Node for CustomDrawable {
         }));
     }
 }
+
+impl HasFlexBoxRoot for CustomDrawable {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.base
+    }
+}
+
+impl ThemeBindable for CustomDrawable {
+    fn theme_binding_node(&self) -> NodeRef {
+        self.base.retained_node_ref()
+    }
+
+    fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
+        let weak_base = self.base.downgrade();
+        let draw_callback = self.draw_callback.clone();
+        Box::new(move || {
+            weak_base.upgrade().map(|base| Self {
+                base,
+                draw_callback: draw_callback.clone(),
+            })
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn assert_flex_box_surface<T: FlexBoxSurface>() {}
+    fn assert_theme_bindable<T: ThemeBindable>() {}
+
+    #[test]
+    fn custom_drawable_exposes_generic_retained_visual_surfaces() {
+        assert_flex_box_surface::<CustomDrawable>();
+        assert_theme_bindable::<CustomDrawable>();
+
+        let drawable = CustomDrawable::new(|_| {});
+        drawable
+            .width(300.0, Unit::Pixel)
+            .height(200.0, Unit::Pixel)
+            .min_width(120.0, Unit::Pixel)
+            .margin(1.0, 2.0, 3.0, 4.0)
+            .padding(5.0, 6.0, 7.0, 8.0)
+            .corner_radius(12.0)
+            .bg_color(0x112233FF)
+            .clip_to_bounds(true);
+
+        let invalidator = drawable.invalidator();
+        drop(drawable);
+        invalidator.mark_dirty();
+    }
+}

package/src/node/mod.rs

@@ -37,7 +37,7 @@ mod virtual_list;
 pub use core::NodeRef;
 pub use core::{ContextMenuEventArgs, Node, NodeHandle};
 pub(crate) use core::{WeakFlexBox, WeakNodeRef};
-pub use custom_drawable::CustomDrawable;
+pub use custom_drawable::{CustomDrawable, DrawableInvalidator};
 pub use flex_box::{Border, FlexBox, GradientStop};
 pub use grid::{Grid, GridTrack};
 pub(crate) use helpers::*;