@effindomv2/fui-rs 0.1.7 → 0.1.9

package/src/controls/control_tokens.rs

@@ -87,6 +87,44 @@ impl SliderSizing {
     }
 }
 
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct ProgressBarSizing {
+    length: f32,
+    thickness: f32,
+}
+
+impl ProgressBarSizing {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn length(mut self, value: f32) -> Self {
+        self.length = sanitize_positive("ProgressBarSizing", "length", value);
+        self
+    }
+
+    pub fn thickness(mut self, value: f32) -> Self {
+        self.thickness = sanitize_positive("ProgressBarSizing", "thickness", value);
+        self
+    }
+
+    pub fn has_length(&self) -> bool {
+        self.length > 0.0
+    }
+
+    pub fn has_thickness(&self) -> bool {
+        self.thickness > 0.0
+    }
+
+    pub fn length_px(&self) -> f32 {
+        self.length
+    }
+
+    pub fn thickness_px(&self) -> f32 {
+        self.thickness
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct DropdownSizing {
     field_font_size: f32,
@@ -407,6 +445,44 @@ impl SliderColors {
     }
 }
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ProgressBarColors {
+    track: Option<u32>,
+    fill: Option<u32>,
+}
+
+impl ProgressBarColors {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn track(mut self, color: u32) -> Self {
+        self.track = Some(color);
+        self
+    }
+
+    pub fn fill(mut self, color: u32) -> Self {
+        self.fill = Some(color);
+        self
+    }
+
+    pub fn has_track(&self) -> bool {
+        self.track.is_some()
+    }
+
+    pub fn track_color(&self) -> u32 {
+        self.track.unwrap_or(0)
+    }
+
+    pub fn has_fill(&self) -> bool {
+        self.fill.is_some()
+    }
+
+    pub fn fill_color(&self) -> u32 {
+        self.fill.unwrap_or(0)
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub struct DropdownColors {
     pub(crate) background: Option<u32>,

package/src/controls/dialog.rs

@@ -1,3 +1,4 @@
+use super::DialogAppearance;
 use super::{Button, Form};
 use crate::app;
 use crate::bindings::ui;
@@ -5,7 +6,6 @@ use crate::ffi::{
     AlignItems, BorderStyle, FlexDirection, JustifyContent, PositionType, SemanticRole, Unit,
 };
 use crate::node::{flex_box, portal, Border, FlexBox, Node, NodeRef, TextNode, WeakFlexBox};
-use crate::signal::SubscriptionGuard;
 use crate::theme::{current_theme, subscribe, Theme};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -40,7 +40,6 @@ pub struct Dialog {
     card: FlexBox,
     overlay: FlexBox,
     state: Rc<RefCell<DialogState>>,
-    theme_guard: Rc<RefCell<Option<SubscriptionGuard>>>,
 }
 
 #[derive(Clone)]
@@ -69,7 +68,12 @@ struct DialogState {
     card_border_width_value: f32,
     card_border_color_value: u32,
     card_border_style_value: BorderStyle,
-    card_corner_radius_value: f32,
+    card_border_dash_on_value: f32,
+    card_border_dash_off_value: f32,
+    card_corner_top_left_value: f32,
+    card_corner_top_right_value: f32,
+    card_corner_bottom_right_value: f32,
+    card_corner_bottom_left_value: f32,
     backdrop_color_overridden: bool,
     shadow_overridden: bool,
     card_background_overridden: bool,
@@ -96,7 +100,12 @@ impl DialogState {
             card_border_width_value: 1.0,
             card_border_color_value: theme.colors.border,
             card_border_style_value: BorderStyle::Solid,
-            card_corner_radius_value: theme.spacing.md,
+            card_border_dash_on_value: 0.0,
+            card_border_dash_off_value: 0.0,
+            card_corner_top_left_value: theme.spacing.md,
+            card_corner_top_right_value: theme.spacing.md,
+            card_corner_bottom_right_value: theme.spacing.md,
+            card_corner_bottom_left_value: theme.spacing.md,
             backdrop_color_overridden: false,
             shadow_overridden: false,
             card_background_overridden: false,
@@ -184,7 +193,6 @@ impl Dialog {
             .align_items(AlignItems::Center)
             .child(&card);
         let state = Rc::new(RefCell::new(DialogState::from_theme(theme)));
-        let theme_guard = Rc::new(RefCell::new(None));
 
         root.position_type(PositionType::Absolute)
             .position(0.0, 0.0)
@@ -203,7 +211,6 @@ impl Dialog {
             card,
             overlay,
             state,
-            theme_guard,
         };
         dialog.content(title, body);
         dialog.bind_events();
@@ -265,79 +272,51 @@ impl Dialog {
         self.cancel_button.clone()
     }
 
-    pub fn backdrop_color(&self, color: u32) -> &Self {
+    pub fn appearance(&self, appearance: DialogAppearance) -> &Self {
         let mut state = self.state.borrow_mut();
-        state.backdrop_color_overridden = true;
-        state.backdrop_color_value = color;
-        drop(state);
-        self.apply_theme();
-        self
-    }
-
-    pub fn background_blur(&self, sigma: f32) -> &Self {
-        self.state.borrow_mut().dialog_background_blur_sigma_value = sigma.max(0.0);
-        self.apply_theme();
-        self
-    }
-
-    pub fn card_shadow(
-        &self,
-        color: u32,
-        offset_x: f32,
-        offset_y: f32,
-        blur_sigma: f32,
-        spread: f32,
-    ) -> &Self {
-        let mut state = self.state.borrow_mut();
-        state.shadow_overridden = true;
-        state.shadow_color_value = color;
-        state.shadow_offset_x_value = offset_x;
-        state.shadow_offset_y_value = offset_y;
-        state.shadow_blur_sigma_value = blur_sigma;
-        state.shadow_spread_value = spread;
-        drop(state);
-        self.apply_theme();
-        self
-    }
-
-    pub fn card_color(&self, color: u32) -> &Self {
-        let mut state = self.state.borrow_mut();
-        state.card_background_overridden = true;
-        state.card_background_color_value = color;
-        drop(state);
-        self.apply_theme();
-        self
-    }
-
-    pub fn card_border(&self, width: f32, color: u32) -> &Self {
-        let mut state = self.state.borrow_mut();
-        state.card_border_overridden = true;
-        state.card_border_width_value = width;
-        state.card_border_color_value = color;
-        state.card_border_style_value = BorderStyle::Solid;
-        drop(state);
-        self.apply_theme();
-        self
-    }
+        let backdrop = appearance.backdrop.unwrap_or_default();
+        state.backdrop_color_overridden = backdrop.color.is_some();
+        if let Some(color) = backdrop.color {
+            state.backdrop_color_value = color;
+        }
+        state.dialog_background_blur_sigma_value = backdrop.blur.unwrap_or(DIALOG_BACKGROUND_BLUR);
 
-    pub fn card_border_config(&self, border: Border) -> &Self {
-        let mut state = self.state.borrow_mut();
-        state.card_border_overridden = true;
-        state.card_border_width_value = border.width;
-        state.card_border_color_value = border.color;
-        state.card_border_style_value = border.style;
+        let card = appearance.card.unwrap_or_default();
+        state.card_background_overridden = card.background.is_some();
+        if let Some(color) = card.background {
+            state.card_background_color_value = color;
+        }
+        state.card_border_overridden = card.border.is_some();
+        if let Some(border) = card.border {
+            state.card_border_width_value = border.width;
+            state.card_border_color_value = border.color;
+            state.card_border_style_value = border.style;
+            state.card_border_dash_on_value = border.dash_on;
+            state.card_border_dash_off_value = border.dash_off;
+        }
+        state.card_corner_radius_overridden = card.corners.is_some();
+        if let Some(corners) = card.corners {
+            state.card_corner_top_left_value = corners.top_left;
+            state.card_corner_top_right_value = corners.top_right;
+            state.card_corner_bottom_right_value = corners.bottom_right;
+            state.card_corner_bottom_left_value = corners.bottom_left;
+        }
+        state.shadow_overridden = card.shadow.is_some();
+        if let Some(shadow) = card.shadow {
+            state.shadow_color_value = shadow.color;
+            state.shadow_offset_x_value = shadow.offset_x;
+            state.shadow_offset_y_value = shadow.offset_y;
+            state.shadow_blur_sigma_value = shadow.blur_sigma;
+            state.shadow_spread_value = shadow.spread;
+        }
         drop(state);
+        self.event_target().handle_theme_changed(current_theme());
         self.apply_theme();
         self
     }
 
-    pub fn card_corner_radius(&self, radius: f32) -> &Self {
-        let mut state = self.state.borrow_mut();
-        state.card_corner_radius_overridden = true;
-        state.card_corner_radius_value = radius;
-        drop(state);
-        self.apply_theme();
-        self
+    pub fn clear_appearance(&self) -> &Self {
+        self.appearance(DialogAppearance::new())
     }
 
     pub fn content(&self, title: impl Into<String>, body: impl Into<String>) -> &Self {
@@ -401,10 +380,13 @@ impl Dialog {
         let event_target = self.event_target();
         let title = self.title_node.clone();
         let body = self.body_node.clone();
-        *self.theme_guard.borrow_mut() = Some(subscribe(move |theme| {
+        let guard = subscribe(move |theme| {
             event_target.handle_theme_changed(theme);
             event_target.apply_theme(&title, &body);
-        }));
+        });
+        self.root
+            .retained_node_ref()
+            .retain_attachment(Rc::new(guard));
     }
 
     fn apply_theme(&self) {
@@ -428,6 +410,10 @@ impl Node for Dialog {
         self.root.retained_node_ref()
     }
 
+    fn retained_owner_attachment(&self) -> Option<Rc<dyn std::any::Any>> {
+        Some(Rc::new(self.clone()))
+    }
+
     fn build_self(&self) {
         self.apply_theme();
         self.root.build_self();
@@ -442,6 +428,12 @@ impl Node for Dialog {
     }
 }
 
+impl crate::node::HasFlexBoxRoot for Dialog {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.root
+    }
+}
+
 impl DialogEventTarget {
     fn hide(&self) {
         let Some(root) = self.root.upgrade() else {
@@ -524,9 +516,14 @@ impl DialogEventTarget {
             state.card_border_width_value = 1.0;
             state.card_border_color_value = theme.colors.border;
             state.card_border_style_value = BorderStyle::Solid;
+            state.card_border_dash_on_value = 0.0;
+            state.card_border_dash_off_value = 0.0;
         }
         if !state.card_corner_radius_overridden {
-            state.card_corner_radius_value = theme.spacing.md;
+            state.card_corner_top_left_value = theme.spacing.md;
+            state.card_corner_top_right_value = theme.spacing.md;
+            state.card_corner_bottom_right_value = theme.spacing.md;
+            state.card_corner_bottom_left_value = theme.spacing.md;
         }
     }
 
@@ -540,13 +537,18 @@ impl DialogEventTarget {
         }
         if let Some(card) = self.card.upgrade() {
             card.bg_color(state.card_background_color_value)
-                .corner_radius(state.card_corner_radius_value)
+                .corners(
+                    state.card_corner_top_left_value,
+                    state.card_corner_top_right_value,
+                    state.card_corner_bottom_right_value,
+                    state.card_corner_bottom_left_value,
+                )
                 .border_config(Border {
                     width: state.card_border_width_value,
                     color: state.card_border_color_value,
                     style: state.card_border_style_value,
-                    dash_on: 0.0,
-                    dash_off: 0.0,
+                    dash_on: state.card_border_dash_on_value,
+                    dash_off: state.card_border_dash_off_value,
                 })
                 .drop_shadow(
                     state.shadow_color_value,

package/src/controls/dropdown.rs

@@ -238,6 +238,7 @@ impl Dropdown {
         });
         *shared.self_weak.borrow_mut() = Rc::downgrade(&shared);
         *shared_slot.borrow_mut() = Some(Rc::downgrade(&shared));
+        root.retained_node_ref().retain_attachment(shared.clone());
 
         popup_list.popup_presenter.overlay_node().on_click({
             let weak_shared = Rc::downgrade(&shared);
@@ -470,7 +471,15 @@ impl Dropdown {
         self
     }
 
-    pub fn sizing(&self, sizing: Option<DropdownSizing>) -> &Self {
+    pub fn sizing(&self, sizing: DropdownSizing) -> &Self {
+        self.set_sizing(Some(sizing))
+    }
+
+    pub fn clear_sizing(&self) -> &Self {
+        self.set_sizing(None)
+    }
+
+    fn set_sizing(&self, sizing: Option<DropdownSizing>) -> &Self {
         self.shared.close();
         self.shared.sizing_value.set(sizing);
         if self.shared.uses_default_field_presenter() {
@@ -506,14 +515,30 @@ impl Dropdown {
         self
     }
 
-    pub fn colors(&self, colors: Option<DropdownColors>) -> &Self {
+    pub fn colors(&self, colors: DropdownColors) -> &Self {
+        self.set_colors(Some(colors))
+    }
+
+    pub fn clear_colors(&self) -> &Self {
+        self.set_colors(None)
+    }
+
+    fn set_colors(&self, colors: Option<DropdownColors>) -> &Self {
         self.shared.colors_value.set(colors);
         self.shared.popup_list.colors(colors);
         self.shared.handle_theme_changed();
         self
     }
 
-    pub fn field_template(&self, template: Option<Rc<dyn DropdownFieldTemplate>>) -> &Self {
+    pub fn field_template(&self, template: Rc<dyn DropdownFieldTemplate>) -> &Self {
+        self.set_field_template(Some(template))
+    }
+
+    pub fn clear_field_template(&self) -> &Self {
+        self.set_field_template(None)
+    }
+
+    fn set_field_template(&self, template: Option<Rc<dyn DropdownFieldTemplate>>) -> &Self {
         self.shared.close();
         *self.shared.field_template_value.borrow_mut() = template.clone();
         let next_field_presenter = create_field_presenter(template, self.shared.sizing_value.get());
@@ -528,7 +553,15 @@ impl Dropdown {
         self
     }
 
-    pub fn chevron_template(&self, template: Option<Rc<dyn DropdownChevronTemplate>>) -> &Self {
+    pub fn chevron_template(&self, template: Rc<dyn DropdownChevronTemplate>) -> &Self {
+        self.set_chevron_template(Some(template))
+    }
+
+    pub fn clear_chevron_template(&self) -> &Self {
+        self.set_chevron_template(None)
+    }
+
+    fn set_chevron_template(&self, template: Option<Rc<dyn DropdownChevronTemplate>>) -> &Self {
         self.shared.close();
         *self.shared.chevron_template_value.borrow_mut() = template.clone();
         let previous_presenter = self.shared.chevron_presenter.borrow().clone();
@@ -549,7 +582,15 @@ impl Dropdown {
         self
     }
 
-    pub fn option_row_template(
+    pub fn option_row_template(&self, template: Rc<dyn DropdownOptionRowTemplate>) -> &Self {
+        self.set_option_row_template(Some(template))
+    }
+
+    pub fn clear_option_row_template(&self) -> &Self {
+        self.set_option_row_template(None)
+    }
+
+    fn set_option_row_template(
         &self,
         template: Option<Rc<dyn DropdownOptionRowTemplate>>,
     ) -> &Self {

package/src/controls/form.rs

@@ -227,3 +227,9 @@ impl Node for Form {
         self.shared.root.dispose();
     }
 }
+
+impl crate::node::HasFlexBoxRoot for Form {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.shared.root
+    }
+}

package/src/controls/internal/button_presenter.rs

@@ -1,6 +1,8 @@
 use crate::controls::ButtonColors;
 use crate::ffi::{AlignItems, FlexDirection, JustifyContent};
-use crate::node::{flex_box, FlexBox, TextCore};
+use crate::node::{
+    flex_box, Border, Corners, EdgeInsets, FlexBox, PresenterHostStyle, Shadow, TextCore,
+};
 use crate::theme::Theme;
 use crate::{FontStyle, FontWeight};
 use std::rc::Rc;
@@ -16,13 +18,12 @@ pub struct ButtonVisualState {
 pub trait ButtonPresenter {
     fn content_root(&self) -> FlexBox;
     fn label_node(&self) -> TextCore;
-    fn apply(
+    fn present(
         &self,
-        host: &FlexBox,
         theme: Theme,
         state: ButtonVisualState,
         colors: Option<ButtonColors>,
-    );
+    ) -> PresenterHostStyle;
 }
 
 pub trait ButtonTemplate {
@@ -60,13 +61,12 @@ impl ButtonPresenter for DefaultButtonPresenter {
         self.label_node.clone()
     }
 
-    fn apply(
+    fn present(
         &self,
-        host: &FlexBox,
         theme: Theme,
         state: ButtonVisualState,
         colors: Option<ButtonColors>,
-    ) {
+    ) -> PresenterHostStyle {
         let background = if !state.enabled {
             colors
                 .and_then(|colors| colors.background)
@@ -100,19 +100,6 @@ impl ButtonPresenter for DefaultButtonPresenter {
                 .and_then(|colors| colors.text_primary)
                 .unwrap_or(theme.colors.text_on_accent)
         };
-        host.flex_direction(FlexDirection::Row)
-            .justify_content(JustifyContent::Center)
-            .align_items(AlignItems::Center)
-            .corner_radius(theme.spacing.sm)
-            .border(1.0, border)
-            .padding(
-                theme.spacing.md,
-                theme.spacing.sm,
-                theme.spacing.md,
-                theme.spacing.sm,
-            )
-            .drop_shadow(0x00000000, 0.0, 0.0, 0.0, 0.0)
-            .bg_color(background);
         self.content_root
             .flex_direction(FlexDirection::Row)
             .align_items(AlignItems::Center)
@@ -123,6 +110,20 @@ impl ButtonPresenter for DefaultButtonPresenter {
             .font_style(FontStyle::Normal)
             .font_size(theme.fonts.size_body)
             .text_color(text_color);
+        PresenterHostStyle::new()
+            .flex_direction(FlexDirection::Row)
+            .justify_content(JustifyContent::Center)
+            .align_items(AlignItems::Center)
+            .corners(Corners::all(theme.spacing.sm))
+            .border(Border::solid(1.0, border))
+            .padding(EdgeInsets::new(
+                theme.spacing.md,
+                theme.spacing.sm,
+                theme.spacing.md,
+                theme.spacing.sm,
+            ))
+            .shadow(Shadow::new(0x00000000, 0.0, 0.0, 0.0, 0.0))
+            .background(background)
     }
 }
 

package/src/controls/internal/pressable_labeled_control.rs

@@ -4,7 +4,6 @@ use crate::ffi::{
     AlignItems, CursorStyle, FlexDirection, KeyEventType, PointerEventType, SemanticRole, Unit,
 };
 use crate::node::{flex_box, FlexBox, Node, TextCore, WeakFlexBox};
-use crate::signal::SubscriptionGuard;
 use crate::theme::{current_theme, subscribe};
 use crate::{focus_adorner, focus_visibility};
 use std::cell::{Cell, RefCell};
@@ -44,8 +43,6 @@ pub(crate) struct PressableLabeledControl {
     activation: Rc<RefCell<Option<ActivationCallback>>>,
     state_changed: Rc<RefCell<Option<StateCallback>>>,
     key_handler: Rc<RefCell<Option<KeyCallback>>>,
-    theme_guard: Rc<RefCell<Option<SubscriptionGuard>>>,
-    focus_visibility_guard: Rc<RefCell<Option<SubscriptionGuard>>>,
 }
 
 impl PressableLabeledControl {
@@ -87,8 +84,6 @@ impl PressableLabeledControl {
             activation: Rc::new(RefCell::new(None)),
             state_changed: Rc::new(RefCell::new(None)),
             key_handler: Rc::new(RefCell::new(None)),
-            theme_guard: Rc::new(RefCell::new(None)),
-            focus_visibility_guard: Rc::new(RefCell::new(None)),
         };
         control.install_handlers();
         control.install_theme_subscription();
@@ -246,17 +241,22 @@ impl PressableLabeledControl {
 
     fn install_theme_subscription(&self) {
         let target = self.event_target();
-        *self.theme_guard.borrow_mut() = Some(subscribe(move |_theme| {
+        let theme_guard = subscribe(move |_theme| {
             target.sync_base_theme();
             target.notify_state_changed();
             target.sync_focus_chrome();
-        }));
+        });
+        self.root
+            .retained_node_ref()
+            .retain_attachment(Rc::new(theme_guard));
 
         let target = self.event_target();
-        *self.focus_visibility_guard.borrow_mut() =
-            Some(focus_visibility::subscribe(move |_visible| {
-                target.sync_focus_chrome();
-            }));
+        let focus_guard = focus_visibility::subscribe(move |_visible| {
+            target.sync_focus_chrome();
+        });
+        self.root
+            .retained_node_ref()
+            .retain_attachment(Rc::new(focus_guard));
     }
 
     fn event_target(&self) -> PressableLabeledControlEventTarget {