@effindomv2/fui-rs 0.1.18 → 0.1.19

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fui-rs"
-version = "0.1.18"
+version = "0.1.19"
 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.19",
   "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/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,
@@ -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,

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/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;