@effindomv2/fui-rs 0.1.18 → 0.1.20

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fui-rs"
-version = "0.1.18"
+version = "0.1.20"
 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.18",
+  "version": "0.1.20",
   "private": false,
   "license": "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial",
   "description": "EffinDom v2 Rust frontend framework SDK and host generators",

package/src/color.rs

@@ -0,0 +1,112 @@
+pub const fn rgba(red: u32, green: u32, blue: u32, alpha: u32) -> u32 {
+    ((red & 0xff) << 24) | ((green & 0xff) << 16) | ((blue & 0xff) << 8) | (alpha & 0xff)
+}
+
+pub const fn rgb(red: u32, green: u32, blue: u32) -> u32 {
+    rgba(red, green, blue, 0xff)
+}
+
+pub const fn with_alpha(color: u32, alpha: u32) -> u32 {
+    (color & 0xffff_ff00) | (alpha & 0xff)
+}
+
+pub(crate) fn color_red(color: u32) -> u32 {
+    (color >> 24) & 0xff
+}
+
+pub(crate) fn color_green(color: u32) -> u32 {
+    (color >> 16) & 0xff
+}
+
+pub(crate) fn color_blue(color: u32) -> u32 {
+    (color >> 8) & 0xff
+}
+
+pub(crate) fn color_alpha(color: u32) -> u32 {
+    color & 0xff
+}
+
+fn clamp_unit(value: f32) -> f32 {
+    value.clamp(0.0, 1.0)
+}
+
+fn hue_to_rgb(p: f32, q: f32, mut t: f32) -> f32 {
+    if t < 0.0 {
+        t += 1.0;
+    }
+    if t > 1.0 {
+        t -= 1.0;
+    }
+    if t < 1.0 / 6.0 {
+        return p + (q - p) * 6.0 * t;
+    }
+    if t < 0.5 {
+        return q;
+    }
+    if t < 2.0 / 3.0 {
+        return p + (q - p) * ((2.0 / 3.0) - t) * 6.0;
+    }
+    p
+}
+
+pub fn hsl_to_color(hue: f32, saturation: f32, lightness: f32) -> u32 {
+    let normalized_hue = hue % 360.0;
+    let hue = if normalized_hue < 0.0 {
+        normalized_hue + 360.0
+    } else {
+        normalized_hue
+    };
+    let saturation = clamp_unit(saturation);
+    let lightness = clamp_unit(lightness);
+    if saturation <= 0.0 {
+        let channel = (lightness * 255.0) as u32;
+        return rgb(channel, channel, channel);
+    }
+
+    let hue_fraction = hue / 360.0;
+    let q = if lightness < 0.5 {
+        lightness * (1.0 + saturation)
+    } else {
+        lightness + saturation - (lightness * saturation)
+    };
+    let p = 2.0 * lightness - q;
+    rgba(
+        (clamp_unit(hue_to_rgb(p, q, hue_fraction + 1.0 / 3.0)) * 255.0) as u32,
+        (clamp_unit(hue_to_rgb(p, q, hue_fraction)) * 255.0) as u32,
+        (clamp_unit(hue_to_rgb(p, q, hue_fraction - 1.0 / 3.0)) * 255.0) as u32,
+        0xff,
+    )
+}
+
+fn mix_channel(from: u32, to: u32, amount: f32) -> u32 {
+    let weight = clamp_unit(amount);
+    (from as f32 + ((to as f32 - from as f32) * weight)).round() as u32
+}
+
+pub fn mix_color(from: u32, to: u32, amount: f32) -> u32 {
+    rgba(
+        mix_channel(color_red(from), color_red(to), amount),
+        mix_channel(color_green(from), color_green(to), amount),
+        mix_channel(color_blue(from), color_blue(to), amount),
+        mix_channel(color_alpha(from), color_alpha(to), amount),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn color_helpers_match_effindom_rgba_packing() {
+        assert_eq!(rgb(0x12, 0x34, 0x56), 0x123456ff);
+        assert_eq!(rgba(0x12, 0x34, 0x56, 0x78), 0x12345678);
+        assert_eq!(with_alpha(0x123456ff, 0x78), 0x12345678);
+    }
+
+    #[test]
+    fn color_helpers_mask_channels_and_interpolate() {
+        assert_eq!(rgba(0x112, 0x134, 0x156, 0x178), 0x12345678);
+        assert_eq!(mix_color(rgb(0, 0, 0), rgb(255, 255, 255), 0.5), rgba(128, 128, 128, 255));
+        assert_eq!(hsl_to_color(0.0, 1.0, 0.5), rgb(255, 0, 0));
+    }
+}

package/src/controls/nav_link.rs

@@ -59,6 +59,8 @@ impl NavLink {
         label_node
             .font_family(theme.fonts.body_family.clone())
             .font_size(15.0)
+            .text_color(theme.colors.accent)
+            .selectable(false)
             .cursor(CursorStyle::Pointer);
         root.justify_content(JustifyContent::Start)
             .align_items(AlignItems::Center)
@@ -440,10 +442,7 @@ impl NavLinkEventTarget {
         let color = if self.hovered.get() {
             theme.colors.accent_hovered
         } else {
-            self.text_color_override
-                .get()
-                .or_else(|| self.label.configured_text_color())
-                .unwrap_or(theme.colors.accent)
+            self.text_color_override.get().unwrap_or(theme.colors.accent)
         };
         if self.label.handle() != NodeHandle::INVALID {
             ui::set_text_color(self.label.handle().raw(), color);

package/src/controls/shared.rs

@@ -59,10 +59,7 @@ pub(crate) fn update_semantic_checked(
     state: SemanticCheckedState,
     announce: bool,
 ) {
-    if let Some(handle) = upgraded_handle(weak_root) {
-        ui::set_semantic_checked(handle.raw(), state as u32);
-        if announce {
-            ui::request_semantic_announcement(handle.raw());
-        }
+    if let Some(root) = weak_root.upgrade() {
+        root.set_semantic_checked(state, announce);
     }
 }

package/src/controls/tests.rs

@@ -2927,6 +2927,23 @@ fn checkbox_user_activation_emits_changed_and_semantic_announcement() {
     Application::unmount();
 }
 
+#[test]
+fn checkbox_prebuild_state_is_retained_into_semantic_build_state() {
+    ffi::test::reset();
+    let checkbox = checkbox("Agree");
+    checkbox.check(true);
+
+    Application::mount(checkbox.clone());
+    let handle = checkbox.retained_node_ref().handle().raw();
+    let calls = ffi::test::take_calls();
+    assert!(calls.iter().any(|call| matches!(
+        call,
+        Call::SetSemanticChecked { handle: checked_handle, checked_state_enum }
+            if *checked_handle == handle && *checked_state_enum == SemanticCheckedState::True as u32
+    )));
+    Application::unmount();
+}
+
 #[test]
 fn radio_and_switch_programmatic_changes_emit_without_semantic_announcement() {
     ffi::test::reset();

package/src/lib.rs

@@ -4,6 +4,7 @@ pub mod assets;
 #[doc(hidden)]
 pub mod bindings;
 pub mod bitmap;
+pub mod color;
 #[doc(hidden)]
 pub mod bridge_callbacks;
 pub(crate) mod context_menu_manager;
@@ -408,6 +409,7 @@ pub mod prelude {
     pub use crate::app::{Application, ApplicationRegistration, ManagedApplication};
     pub use crate::bitmap::{Bitmap, BitmapTextReadyEventArgs};
     pub use crate::bridge_callbacks::current_route;
+    pub use crate::color::{hsl_to_color, mix_color, rgb, rgba, with_alpha};
     pub use crate::controls::{
         anti_selection_area, button, checkbox, clear_control_templates, combo_box, context_menu,
         create_default_button_presenter, create_default_checkbox_indicator_presenter,
@@ -486,10 +488,10 @@ pub mod prelude {
         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, DrawableInvalidator, EdgeInsets,
-        FlexBox, FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode,
-        Length, Node, PresenterHostStyle, ScrollBar, ScrollBarStyle, ScrollBarVisibility,
-        ScrollBox, ScrollState, ScrollView, Shadow, Svg, SvgNode, Text, TextCore, TextNode,
-        ThemeBindable, VirtualList,
+        FlexBox, FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, HasTextNode, Image,
+        ImageNode, Length, Node, PresenterHostStyle, ScrollBar, ScrollBarStyle,
+        ScrollBarVisibility, ScrollBox, ScrollState, ScrollView, Shadow, Svg, SvgNode, Text,
+        TextCore, TextLayoutSurface, TextNode, ThemeBindable, VirtualList,
     };
     pub use crate::persisted;
     pub use crate::platform;
@@ -534,6 +536,7 @@ pub use app::{Application, ApplicationRegistration, ManagedApplication};
 pub use assets::*;
 pub use bitmap::{Bitmap, BitmapTextReadyEventArgs};
 pub use bridge_callbacks::current_route;
+pub use color::{hsl_to_color, mix_color, rgb, rgba, with_alpha};
 pub use controls::{
     anti_selection_area, button, checkbox, clear_control_templates, combo_box, context_menu,
     create_default_button_presenter, create_default_checkbox_indicator_presenter,
@@ -606,9 +609,10 @@ 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, DrawableInvalidator, EdgeInsets, FlexBox,
-    FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
-    PresenterHostStyle, ScrollBar, ScrollBarStyle, ScrollBarVisibility, ScrollBox, ScrollState,
-    ScrollView, Shadow, Svg, SvgNode, Text, TextCore, TextNode, ThemeBindable, VirtualList,
+    FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, HasTextNode, Image, ImageNode,
+    Length, Node, PresenterHostStyle, ScrollBar, ScrollBarStyle, ScrollBarVisibility, ScrollBox,
+    ScrollState, ScrollView, Shadow, Svg, SvgNode, Text, TextCore, TextLayoutSurface, TextNode,
+    ThemeBindable, VirtualList,
 };
 pub use persisted::*;
 pub use platform::*;

package/src/node/core.rs

@@ -513,6 +513,26 @@ impl NodeRef {
         self.inner.borrow().handle
     }
 
+    pub(crate) fn set_semantic_checked(
+        &self,
+        state: SemanticCheckedState,
+        announce: bool,
+    ) {
+        let handle = {
+            let mut core = self.inner.borrow_mut();
+            core.behavior.semantic_checked = Some(state);
+            core.handle
+        };
+        if handle == NodeHandle::INVALID {
+            return;
+        }
+        ui::set_semantic_checked(handle.raw(), state as u32);
+        if announce {
+            ui::request_semantic_announcement(handle.raw());
+        }
+        crate::frame_scheduler::mark_needs_commit();
+    }
+
     pub(crate) fn ptr_eq(&self, other: &Self) -> bool {
         Rc::ptr_eq(&self.inner, &other.inner)
     }

package/src/node/mod.rs

@@ -100,6 +100,85 @@ impl ThemeBindable for FlexBox {
     }
 }
 
+pub trait HasTextNode {
+    fn text_node(&self) -> &TextNode;
+}
+
+pub trait TextLayoutSurface: HasTextNode {
+    fn width(&self, width: f32, unit: Unit) -> &Self {
+        self.text_node().width(width, unit);
+        self
+    }
+
+    fn height(&self, height: f32, unit: Unit) -> &Self {
+        self.text_node().height(height, unit);
+        self
+    }
+
+    fn fill_width(&self) -> &Self {
+        self.text_node().fill_width();
+        self
+    }
+
+    fn fill_height(&self) -> &Self {
+        self.text_node().fill_height();
+        self
+    }
+
+    fn fill_size(&self) -> &Self {
+        self.text_node().fill_size();
+        self
+    }
+
+    fn line_height(&self, line_height: f32) -> &Self {
+        self.text_node().line_height(line_height);
+        self
+    }
+
+    fn text_align(&self, align: TextAlign) -> &Self {
+        self.text_node().text_align(align);
+        self
+    }
+
+    fn text_vertical_align(&self, align: TextVerticalAlign) -> &Self {
+        self.text_node().text_vertical_align(align);
+        self
+    }
+
+    fn text_limits(&self, max_chars: i32, max_lines: i32) -> &Self {
+        self.text_node().text_limits(max_chars, max_lines);
+        self
+    }
+
+    fn max_lines(&self, max_lines: i32) -> &Self {
+        self.text_node().max_lines(max_lines);
+        self
+    }
+
+    fn wrapping(&self, wrap: bool) -> &Self {
+        self.text_node().wrapping(wrap);
+        self
+    }
+
+    fn text_overflow(&self, overflow: TextOverflow) -> &Self {
+        self.text_node().text_overflow(overflow);
+        self
+    }
+
+    fn text_overflow_fade(&self, horizontal: bool, vertical: bool) -> &Self {
+        self.text_node().text_overflow_fade(horizontal, vertical);
+        self
+    }
+}
+
+impl<T: HasTextNode> TextLayoutSurface for T {}
+
+impl HasTextNode for TextNode {
+    fn text_node(&self) -> &TextNode {
+        self
+    }
+}
+
 pub trait FlexBoxSurface: HasFlexBoxRoot {
     fn width(&self, width: f32, unit: Unit) -> &Self {
         self.flex_box_root().width(width, unit);

package/src/node/text_node.rs

@@ -164,10 +164,6 @@ impl TextNode {
         self
     }
 
-    pub(crate) fn configured_text_color(&self) -> Option<u32> {
-        self.props.borrow().text_color
-    }
-
     pub fn style_runs(&self, words: Vec<u32>) -> &Self {
         {
             let mut props = self.props.borrow_mut();

package/src/text.rs

@@ -3,7 +3,7 @@ use crate::bindings::ui;
 use crate::ffi::{TextAlign, TextOverflow, TextVerticalAlign, Unit};
 use crate::frame_scheduler::on_loaded;
 use crate::logger::error;
-use crate::node::{Node, TextNode};
+use crate::node::{HasTextNode, Node, TextNode, ThemeBindable};
 use crate::theme;
 use crate::typography::{FontFamily, FontStack, FontStyle, FontWeight};
 use std::cell::RefCell;
@@ -247,6 +247,29 @@ impl Deref for RichText {
     }
 }
 
+impl HasTextNode for RichText {
+    fn text_node(&self) -> &TextNode {
+        &self.node
+    }
+}
+
+impl ThemeBindable for RichText {
+    fn theme_binding_node(&self) -> crate::node::NodeRef {
+        self.node.retained_node_ref()
+    }
+
+    fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
+        let weak_node = self.node.weak_theme_target();
+        let weak_state = Rc::downgrade(&self.state);
+        Box::new(move || {
+            Some(Self {
+                node: weak_node()?,
+                state: weak_state.upgrade()?,
+            })
+        })
+    }
+}
+
 impl Node for RichText {
     fn retained_node_ref(&self) -> crate::node::NodeRef {
         self.node.retained_node_ref()

package/src/theme.rs

@@ -1,12 +1,15 @@
 use crate::generated::framework_host_services;
+use crate::color::{
+    color_alpha, color_blue, color_green, color_red, mix_color, rgb, rgba, with_alpha,
+};
 use crate::signal::{Callback, Signal, SubscriptionGuard};
 use crate::typography::{FontFamily, FontStack};
 use std::cell::RefCell;
 use std::rc::Rc;
 
-const DEFAULT_ACCENT_COLOR: u32 = 0x2563EBFF;
-const WHITE: u32 = 0xFFFFFFFF;
-const BLACK: u32 = 0x000000FF;
+const DEFAULT_ACCENT_COLOR: u32 = rgb(0x25, 0x63, 0xeb);
+const WHITE: u32 = rgb(0xff, 0xff, 0xff);
+const BLACK: u32 = rgb(0x00, 0x00, 0x00);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Colors {
@@ -166,49 +169,6 @@ fn default_fonts() -> Fonts {
     }
 }
 
-const fn rgba(r: u32, g: u32, b: u32, a: u32) -> u32 {
-    (r << 24) | (g << 16) | (b << 8) | a
-}
-
-fn color_red(color: u32) -> u32 {
-    (color >> 24) & 0xff
-}
-fn color_green(color: u32) -> u32 {
-    (color >> 16) & 0xff
-}
-fn color_blue(color: u32) -> u32 {
-    (color >> 8) & 0xff
-}
-fn color_alpha(color: u32) -> u32 {
-    color & 0xff
-}
-fn clamp_unit(value: f32) -> f32 {
-    value.clamp(0.0, 1.0)
-}
-
-fn mix_channel(from: u32, to: u32, amount: f32) -> u32 {
-    let weight = clamp_unit(amount);
-    (from as f32 + ((to as f32 - from as f32) * weight)).round() as u32
-}
-
-fn mix_color(from: u32, to: u32, amount: f32) -> u32 {
-    rgba(
-        mix_channel(color_red(from), color_red(to), amount),
-        mix_channel(color_green(from), color_green(to), amount),
-        mix_channel(color_blue(from), color_blue(to), amount),
-        mix_channel(color_alpha(from), color_alpha(to), amount),
-    )
-}
-
-fn with_alpha(color: u32, alpha: u32) -> u32 {
-    rgba(
-        color_red(color),
-        color_green(color),
-        color_blue(color),
-        alpha,
-    )
-}
-
 fn normalize_accent_color(color: u32) -> u32 {
     if color == 0 {
         return DEFAULT_ACCENT_COLOR;