@effindomv2/fui-rs 0.1.8 → 0.1.9

package/src/node/mod.rs

@@ -24,6 +24,7 @@ mod flex_box;
 mod grid;
 mod helpers;
 mod image;
+mod presenter_host_style;
 mod scroll_bar;
 mod scroll_box;
 mod scroll_state;
@@ -45,6 +46,8 @@ pub use helpers::{
     scroll_view, svg, text, viewport_height, viewport_width, virtual_list, Length,
 };
 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_box::ScrollBox;
 pub use scroll_state::ScrollState;
@@ -170,6 +173,11 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         self
     }
 
+    fn clear_padding(&self) -> &Self {
+        self.flex_box_root().clear_padding();
+        self
+    }
+
     fn margin(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
         self.flex_box_root().margin(left, top, right, bottom);
         self
@@ -180,6 +188,11 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         self
     }
 
+    fn clear_corners(&self) -> &Self {
+        self.flex_box_root().clear_corners();
+        self
+    }
+
     fn corners(&self, tl: f32, tr: f32, br: f32, bl: f32) -> &Self {
         self.flex_box_root().corners(tl, tr, br, bl);
         self
@@ -195,16 +208,31 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         self
     }
 
+    fn clear_border(&self) -> &Self {
+        self.flex_box_root().clear_border();
+        self
+    }
+
     fn bg_color(&self, color: u32) -> &Self {
         self.flex_box_root().bg_color(color);
         self
     }
 
+    fn clear_bg_color(&self) -> &Self {
+        self.flex_box_root().clear_bg_color();
+        self
+    }
+
     fn opacity(&self, value: f32) -> &Self {
         self.flex_box_root().opacity(value);
         self
     }
 
+    fn clear_opacity(&self) -> &Self {
+        self.flex_box_root().clear_opacity();
+        self
+    }
+
     fn blur(&self, sigma: f32) -> &Self {
         self.flex_box_root().blur(sigma);
         self
@@ -223,6 +251,11 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         self
     }
 
+    fn clear_drop_shadow(&self) -> &Self {
+        self.flex_box_root().clear_drop_shadow();
+        self
+    }
+
     fn background_blur(&self, sigma: f32) -> &Self {
         self.flex_box_root().background_blur(sigma);
         self
@@ -270,11 +303,21 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         self
     }
 
+    fn clear_justify_content(&self) -> &Self {
+        self.flex_box_root().clear_justify_content();
+        self
+    }
+
     fn align_items(&self, align: AlignItems) -> &Self {
         self.flex_box_root().align_items(align);
         self
     }
 
+    fn clear_align_items(&self) -> &Self {
+        self.flex_box_root().clear_align_items();
+        self
+    }
+
     fn align_self(&self, align: AlignSelf) -> &Self {
         self.flex_box_root().align_self(align);
         self
@@ -305,6 +348,11 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         self
     }
 
+    fn clear_cursor(&self) -> &Self {
+        self.flex_box_root().clear_cursor();
+        self
+    }
+
     fn visibility(&self, visibility: Visibility) -> &Self {
         self.flex_box_root().visibility(visibility);
         self

package/src/node/presenter_host_style.rs

@@ -0,0 +1,177 @@
+use crate::ffi::{AlignItems, CursorStyle, FlexDirection, JustifyContent};
+use crate::node::Border;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EdgeInsets {
+    pub left: f32,
+    pub top: f32,
+    pub right: f32,
+    pub bottom: f32,
+}
+
+impl EdgeInsets {
+    pub const fn new(left: f32, top: f32, right: f32, bottom: f32) -> Self {
+        Self {
+            left,
+            top,
+            right,
+            bottom,
+        }
+    }
+
+    pub const fn all(value: f32) -> Self {
+        Self::new(value, value, value, value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Corners {
+    pub top_left: f32,
+    pub top_right: f32,
+    pub bottom_right: f32,
+    pub bottom_left: f32,
+}
+
+impl Corners {
+    pub const fn new(top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32) -> Self {
+        Self {
+            top_left,
+            top_right,
+            bottom_right,
+            bottom_left,
+        }
+    }
+
+    pub const fn all(value: f32) -> Self {
+        Self::new(value, value, value, value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Shadow {
+    pub color: u32,
+    pub offset_x: f32,
+    pub offset_y: f32,
+    pub blur_sigma: f32,
+    pub spread: f32,
+}
+
+impl Shadow {
+    pub fn new(color: u32, offset_x: f32, offset_y: f32, blur_sigma: f32, spread: f32) -> Self {
+        Self {
+            color,
+            offset_x,
+            offset_y,
+            blur_sigma: blur_sigma.max(0.0),
+            spread,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct PresenterHostStyle {
+    pub flex_direction: Option<FlexDirection>,
+    pub justify_content: Option<JustifyContent>,
+    pub align_items: Option<AlignItems>,
+    pub background: Option<u32>,
+    pub padding: Option<EdgeInsets>,
+    pub corners: Option<Corners>,
+    pub border: Option<Border>,
+    pub shadow: Option<Shadow>,
+    pub cursor: Option<CursorStyle>,
+    pub opacity: Option<f32>,
+}
+
+impl PresenterHostStyle {
+    pub const fn new() -> Self {
+        Self {
+            flex_direction: None,
+            justify_content: None,
+            align_items: None,
+            background: None,
+            padding: None,
+            corners: None,
+            border: None,
+            shadow: None,
+            cursor: None,
+            opacity: None,
+        }
+    }
+
+    pub fn flex_direction(mut self, value: FlexDirection) -> Self {
+        self.flex_direction = Some(value);
+        self
+    }
+
+    pub fn justify_content(mut self, value: JustifyContent) -> Self {
+        self.justify_content = Some(value);
+        self
+    }
+
+    pub fn align_items(mut self, value: AlignItems) -> Self {
+        self.align_items = Some(value);
+        self
+    }
+
+    pub fn background(mut self, value: u32) -> Self {
+        self.background = Some(value);
+        self
+    }
+
+    pub fn padding(mut self, value: EdgeInsets) -> Self {
+        self.padding = Some(value);
+        self
+    }
+
+    pub fn corners(mut self, value: Corners) -> Self {
+        self.corners = Some(value);
+        self
+    }
+
+    pub fn border(mut self, value: Border) -> Self {
+        self.border = Some(value);
+        self
+    }
+
+    pub fn shadow(mut self, value: Shadow) -> Self {
+        self.shadow = Some(value);
+        self
+    }
+
+    pub fn cursor(mut self, value: CursorStyle) -> Self {
+        self.cursor = Some(value);
+        self
+    }
+
+    pub fn opacity(mut self, value: f32) -> Self {
+        self.opacity = Some(value.clamp(0.0, 1.0));
+        self
+    }
+
+    pub(crate) fn overlay(self, fallback: Self) -> Self {
+        Self {
+            flex_direction: self.flex_direction.or(fallback.flex_direction),
+            justify_content: self.justify_content.or(fallback.justify_content),
+            align_items: self.align_items.or(fallback.align_items),
+            background: self.background.or(fallback.background),
+            padding: self.padding.or(fallback.padding),
+            corners: self.corners.or(fallback.corners),
+            border: self.border.or(fallback.border),
+            shadow: self.shadow.or(fallback.shadow),
+            cursor: self.cursor.or(fallback.cursor),
+            opacity: self.opacity.or(fallback.opacity),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub(crate) struct HostStyleLayers {
+    pub local: PresenterHostStyle,
+    pub presenter: PresenterHostStyle,
+}
+
+impl HostStyleLayers {
+    pub fn resolved(self) -> PresenterHostStyle {
+        self.local.overlay(self.presenter)
+    }
+}

package/src/node/text_node.rs

@@ -648,6 +648,9 @@ impl Node for TextNode {
     }
 
     fn build_self(&self) {
+        if self.props.borrow().has_font {
+            self.resolve_font_id();
+        }
         apply_text_props(
             self.handle(),
             &self.props.borrow(),
@@ -655,3 +658,35 @@ impl Node for TextNode {
         );
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ffi::{self, Call};
+    use crate::Application;
+
+    #[test]
+    fn prebuild_font_family_weight_and_style_are_resolved_during_build() {
+        ffi::test::reset();
+        let theme = theme::current_theme();
+        let label = TextCore::new("Bold before build");
+        label
+            .font_family(theme.fonts.body_family)
+            .font_weight(FontWeight::Bold)
+            .font_style(FontStyle::Normal)
+            .font_size(17.0);
+
+        Application::mount(label.clone());
+        let handle = label.handle().raw();
+        let calls = ffi::test::take_calls();
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::SetFont {
+                handle: call_handle,
+                font_id: 2,
+                size,
+            } if *call_handle == handle && (*size - 17.0).abs() < f32::EPSILON
+        )));
+        Application::unmount();
+    }
+}

package/src/popup_presenter.rs

@@ -322,6 +322,38 @@ impl PopupPresenter {
 }
 
 impl PopupPresenterEventTarget {
+    pub(crate) fn is_open(&self) -> bool {
+        self.state.borrow().open
+    }
+
+    pub(crate) fn surface_x(&self) -> f32 {
+        self.state.borrow().surface_x
+    }
+
+    pub(crate) fn surface_y(&self) -> f32 {
+        self.state.borrow().surface_y
+    }
+
+    pub(crate) fn backdrop_color(&self, color: u32) {
+        self.state.borrow_mut().backdrop_color = color;
+        self.apply_backdrop_style();
+    }
+
+    pub(crate) fn background_blur(&self, sigma: f32) {
+        self.state.borrow_mut().background_blur_sigma = sigma.max(0.0);
+        self.apply_backdrop_style();
+    }
+
+    fn apply_backdrop_style(&self) {
+        let Some(overlay) = self.overlay_node.upgrade() else {
+            return;
+        };
+        let state = *self.state.borrow();
+        overlay
+            .bg_color(state.backdrop_color)
+            .background_blur(state.background_blur_sigma);
+    }
+
     pub(crate) fn hide(&self) {
         let Some(root) = self.root.upgrade() else {
             return;