@effindomv2/fui-rs 0.1.3

package/src/controls/progress_bar.rs

@@ -0,0 +1,287 @@
+use super::*;
+use crate::logger;
+use crate::node::WeakFlexBox;
+use crate::signal::SubscriptionGuard;
+
+#[derive(Clone)]
+pub struct ProgressBar {
+    root: FlexBox,
+    fill: FlexBox,
+    min: Rc<Cell<f32>>,
+    max: Rc<Cell<f32>>,
+    value: Rc<Cell<f32>>,
+    length: Rc<Cell<f32>>,
+    thickness: Rc<Cell<f32>>,
+    track_color_value: Rc<Cell<u32>>,
+    fill_color_value: Rc<Cell<u32>>,
+    track_color_overridden: Rc<Cell<bool>>,
+    fill_color_overridden: Rc<Cell<bool>>,
+    corner_radius_overridden: Rc<Cell<bool>>,
+    weak_root: WeakFlexBox,
+    weak_fill: WeakFlexBox,
+    theme_guard: Rc<RefCell<Option<SubscriptionGuard>>>,
+}
+
+impl Default for ProgressBar {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ProgressBar {
+    pub fn new() -> Self {
+        let root = flex_box();
+        let fill = flex_box();
+        root.semantic_value_range(0.0, 0.0, 100.0).child(&fill);
+        let control = Self {
+            weak_root: root.downgrade(),
+            weak_fill: fill.downgrade(),
+            root,
+            fill,
+            min: Rc::new(Cell::new(0.0)),
+            max: Rc::new(Cell::new(100.0)),
+            value: Rc::new(Cell::new(0.0)),
+            length: Rc::new(Cell::new(PROGRESS_LENGTH)),
+            thickness: Rc::new(Cell::new(PROGRESS_THICKNESS)),
+            track_color_value: Rc::new(Cell::new(0)),
+            fill_color_value: Rc::new(Cell::new(0)),
+            track_color_overridden: Rc::new(Cell::new(false)),
+            fill_color_overridden: Rc::new(Cell::new(false)),
+            corner_radius_overridden: Rc::new(Cell::new(false)),
+            theme_guard: Rc::new(RefCell::new(None)),
+        };
+        control.install_visual_subscriptions();
+        control.set_value(0.0);
+        control.handle_theme_changed();
+        control
+    }
+
+    pub fn min(&self, value: f32) -> &Self {
+        self.min.set(value);
+        if self.max.get() < value {
+            self.max.set(value);
+        }
+        self.set_value(self.value.get());
+        self
+    }
+
+    pub fn max(&self, value: f32) -> &Self {
+        self.max.set(value);
+        if self.min.get() > value {
+            self.min.set(value);
+        }
+        self.set_value(self.value.get());
+        self
+    }
+
+    pub fn value(&self, value: f32) -> &Self {
+        self.set_value(value);
+        self
+    }
+
+    pub fn length(&self, value: f32) -> &Self {
+        if value <= 0.0 {
+            logger::warn(
+                "Layout",
+                &format!("ProgressBar.length() received {value}; clamping to 1.0."),
+            );
+        }
+        self.length.set(if value > 0.0 { value } else { 1.0 });
+        self.sync_geometry();
+        self
+    }
+
+    pub fn thickness(&self, value: f32) -> &Self {
+        if value <= 0.0 {
+            logger::warn(
+                "Layout",
+                &format!("ProgressBar.thickness() received {value}; clamping to 1.0."),
+            );
+        }
+        self.thickness.set(if value > 0.0 { value } else { 1.0 });
+        if !self.corner_radius_overridden.get() {
+            let radius = self.thickness.get() * 0.5;
+            self.root.corner_radius(radius);
+        }
+        self.sync_geometry();
+        self.sync_visual_state();
+        self
+    }
+
+    pub fn track_color(&self, color: u32) -> &Self {
+        self.track_color_overridden.set(true);
+        self.track_color_value.set(color);
+        self.sync_visual_state();
+        self
+    }
+
+    pub fn fill_color(&self, color: u32) -> &Self {
+        self.fill_color_overridden.set(true);
+        self.fill_color_value.set(color);
+        self.sync_visual_state();
+        self
+    }
+
+    pub fn corner_radius(&self, radius: f32) -> &Self {
+        self.corner_radius_overridden.set(true);
+        self.root.corner_radius(radius);
+        self.fill.corner_radius(radius);
+        self
+    }
+
+    pub fn current_value(&self) -> f32 {
+        self.value.get()
+    }
+
+    fn install_visual_subscriptions(&self) {
+        let weak_root = self.weak_root.clone();
+        let weak_fill = self.weak_fill.clone();
+        let min = self.min.clone();
+        let max = self.max.clone();
+        let value = self.value.clone();
+        let length = self.length.clone();
+        let thickness = self.thickness.clone();
+        let track_color_value = self.track_color_value.clone();
+        let fill_color_value = self.fill_color_value.clone();
+        let track_color_overridden = self.track_color_overridden.clone();
+        let fill_color_overridden = self.fill_color_overridden.clone();
+        let corner_radius_overridden = self.corner_radius_overridden.clone();
+        *self.theme_guard.borrow_mut() = Some(subscribe(move |_theme| {
+            let Some(root) = weak_root.upgrade() else {
+                return;
+            };
+            let Some(fill) = weak_fill.upgrade() else {
+                return;
+            };
+            sync_progress_visual_state(
+                &root,
+                &fill,
+                thickness.get(),
+                track_color_value.get(),
+                fill_color_value.get(),
+                track_color_overridden.get(),
+                fill_color_overridden.get(),
+                corner_radius_overridden.get(),
+            );
+            sync_progress_geometry(
+                &root,
+                &fill,
+                min.get(),
+                max.get(),
+                value.get(),
+                length.get(),
+                thickness.get(),
+            );
+        }));
+    }
+
+    fn handle_theme_changed(&self) {
+        self.sync_visual_state();
+        self.sync_geometry();
+    }
+
+    fn set_value(&self, value: f32) {
+        self.value.set(value.clamp(self.min.get(), self.max.get()));
+        self.sync_geometry();
+    }
+
+    fn sync_geometry(&self) {
+        sync_progress_geometry(
+            &self.root,
+            &self.fill,
+            self.min.get(),
+            self.max.get(),
+            self.value.get(),
+            self.length.get(),
+            self.thickness.get(),
+        );
+    }
+
+    fn sync_visual_state(&self) {
+        sync_progress_visual_state(
+            &self.root,
+            &self.fill,
+            self.thickness.get(),
+            self.track_color_value.get(),
+            self.fill_color_value.get(),
+            self.track_color_overridden.get(),
+            self.fill_color_overridden.get(),
+            self.corner_radius_overridden.get(),
+        );
+    }
+}
+
+impl Node for ProgressBar {
+    fn retained_node_ref(&self) -> NodeRef {
+        self.root.retained_node_ref()
+    }
+
+    fn build_self(&self) {
+        self.sync_visual_state();
+        self.sync_geometry();
+        self.root.build_self();
+    }
+}
+
+impl HasFlexBoxRoot for ProgressBar {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.root
+    }
+}
+
+fn sync_progress_geometry(
+    root: &FlexBox,
+    fill: &FlexBox,
+    min: f32,
+    max: f32,
+    current_value: f32,
+    length: f32,
+    thickness: f32,
+) {
+    let range = max - min;
+    let fraction = if range > 0.0 {
+        ((current_value - min) / range).clamp(0.0, 1.0)
+    } else {
+        0.0
+    };
+    let fill_length = length * fraction;
+    root.width(length, Unit::Pixel)
+        .height(thickness, Unit::Pixel)
+        .semantic_value_range(current_value, min, max)
+        .default_semantic_label(format!(
+            "Progress bar, value {}, range {} to {}",
+            current_value, min, max
+        ));
+    fill.width(fill_length, Unit::Pixel)
+        .height(thickness, Unit::Pixel);
+}
+
+fn sync_progress_visual_state(
+    root: &FlexBox,
+    fill: &FlexBox,
+    thickness: f32,
+    track_color_value: u32,
+    fill_color_value: u32,
+    track_color_overridden: bool,
+    fill_color_overridden: bool,
+    corner_radius_overridden: bool,
+) {
+    let theme = current_theme();
+    let track_color = if track_color_overridden {
+        track_color_value
+    } else {
+        theme.colors.scrollbar_track
+    };
+    let fill_color = if fill_color_overridden {
+        fill_color_value
+    } else {
+        theme.colors.accent
+    };
+    if !corner_radius_overridden {
+        let radius = thickness * 0.5;
+        root.corner_radius(radius);
+        fill.corner_radius(radius);
+    }
+    root.bg_color(track_color).border(1.0, theme.colors.border);
+    fill.bg_color(fill_color);
+}

package/src/controls/radio_button.rs

@@ -0,0 +1,348 @@
+use super::internal::pressable_labeled_control::PressableLabeledControlState;
+use super::internal::radio_indicator_presenter::{
+    create_default_radio_indicator_presenter, RadioIndicatorPresenter, RadioIndicatorTemplate,
+    RadioIndicatorVisualState,
+};
+use super::*;
+use crate::bindings::ui;
+use crate::controls::radio_group::RadioGroupEventTarget;
+use crate::ffi::KeyEventType;
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+fn create_indicator_presenter(
+    template: Option<Rc<dyn RadioIndicatorTemplate>>,
+    sizing: Option<LabeledControlSizing>,
+) -> Rc<dyn RadioIndicatorPresenter> {
+    if let Some(template) = template {
+        return template.create(sizing);
+    }
+    if let Some(template_set) = get_control_templates() {
+        if let Some(template) = template_set.radio_indicator {
+            return template.create(sizing);
+        }
+    }
+    create_default_radio_indicator_presenter(sizing)
+}
+
+#[derive(Clone)]
+pub struct RadioButton {
+    base: PressableLabeledControl,
+    root: FlexBox,
+    indicator_presenter: Rc<RefCell<Rc<dyn RadioIndicatorPresenter>>>,
+    template_override: Rc<RefCell<Option<Rc<dyn RadioIndicatorTemplate>>>>,
+    sizing_value: Rc<Cell<Option<LabeledControlSizing>>>,
+    colors_value: Rc<Cell<Option<LabeledControlColors>>>,
+    value_text: String,
+    checked: Rc<Cell<bool>>,
+    changed: Rc<RefCell<Option<RadioButtonChangedCallback>>>,
+    owner_group: Rc<RefCell<Option<WeakRadioGroupEventTarget>>>,
+    weak_root: Rc<WeakNodeRef>,
+}
+
+impl RadioButton {
+    pub fn new(value: impl Into<String>) -> Self {
+        let value = value.into();
+        Self::with_label(value.clone(), value)
+    }
+
+    pub fn with_label(value: impl Into<String>, label: impl Into<String>) -> Self {
+        let value = value.into();
+        let label = label.into();
+        let indicator_presenter = create_indicator_presenter(None, None);
+        let base =
+            PressableLabeledControl::new(SemanticRole::Radio, label, indicator_presenter.root());
+        let root = base.root();
+        let weak_root = Rc::new(root.node_ref().downgrade());
+        let control = Self {
+            base,
+            root,
+            indicator_presenter: Rc::new(RefCell::new(indicator_presenter)),
+            template_override: Rc::new(RefCell::new(None)),
+            sizing_value: Rc::new(Cell::new(None)),
+            colors_value: Rc::new(Cell::new(None)),
+            value_text: value,
+            checked: Rc::new(Cell::new(false)),
+            changed: Rc::new(RefCell::new(None)),
+            owner_group: Rc::new(RefCell::new(None)),
+            weak_root,
+        };
+        control.root.semantic_checked(SemanticCheckedState::False);
+        let activation = RadioEventTarget::from_radio(&control);
+        control.base.set_activation(move |state| {
+            activation.activate(state);
+        });
+        let state_sync = RadioEventTarget::from_radio(&control);
+        control.base.set_state_changed(move |state| {
+            state_sync.sync_visual(state, false, false);
+        });
+        let key_target = RadioEventTarget::from_radio(&control);
+        control
+            .base
+            .set_key_handler(move |event| key_target.handle_key_event(event));
+        control.sync_visual(control.base.snapshot_state(), false, false);
+        control
+    }
+
+    pub fn value(&self) -> &str {
+        &self.value_text
+    }
+
+    pub fn checked(&self, checked: bool) -> &Self {
+        self.check(checked);
+        self
+    }
+
+    pub fn check(&self, checked: bool) -> &Self {
+        self.update_checked(checked, true, false);
+        self
+    }
+
+    pub fn is_checked(&self) -> bool {
+        self.checked.get()
+    }
+
+    pub fn sizing(&self, sizing: Option<LabeledControlSizing>) -> &Self {
+        self.sizing_value.set(sizing);
+        self.base.set_label_font_size_override(
+            sizing
+                .filter(|sizing| sizing.has_label_font_size())
+                .map(|sizing| sizing.label_font_size_px())
+                .unwrap_or(0.0),
+        );
+        self.replace_indicator_presenter(create_indicator_presenter(
+            self.template_override.borrow().clone(),
+            self.sizing_value.get(),
+        ));
+        self.sync_visual(self.base.snapshot_state(), false, false);
+        self
+    }
+
+    pub fn template(&self, template: Option<Rc<dyn RadioIndicatorTemplate>>) -> &Self {
+        self.template_override.replace(template.clone());
+        self.replace_indicator_presenter(create_indicator_presenter(
+            template,
+            self.sizing_value.get(),
+        ));
+        self.sync_visual(self.base.snapshot_state(), false, false);
+        self
+    }
+
+    pub fn colors(&self, colors: Option<LabeledControlColors>) -> &Self {
+        self.colors_value.set(colors);
+        self.base.colors(colors);
+        self.sync_visual(self.base.snapshot_state(), false, false);
+        self
+    }
+
+    pub fn enabled(&self, enabled: bool) -> &Self {
+        self.base.enabled(enabled);
+        self
+    }
+
+    pub fn on_changed(&self, handler: impl Fn(RadioButtonChangedEventArgs) + 'static) -> &Self {
+        *self.changed.borrow_mut() = Some(Rc::new(handler));
+        self
+    }
+
+    pub fn focus_now(&self) {
+        ui::request_focus(self.root.retained_node_ref().handle().raw());
+    }
+
+    pub(crate) fn bind_group(&self, group: WeakRadioGroupEventTarget) {
+        *self.owner_group.borrow_mut() = Some(group);
+    }
+
+    pub(crate) fn is_enabled(&self) -> bool {
+        self.root.retained_node_ref().is_enabled_for_routing()
+    }
+
+    pub(crate) fn update_checked(&self, checked: bool, emit: bool, announce: bool) {
+        apply_radio_checked(
+            &self.indicator_presenter,
+            &self.weak_root,
+            &self.checked,
+            checked,
+            emit,
+            announce,
+            &self.changed,
+            self.colors_value.get(),
+            self.base.snapshot_state(),
+        );
+    }
+
+    fn replace_indicator_presenter(&self, next_presenter: Rc<dyn RadioIndicatorPresenter>) {
+        let previous = self.indicator_presenter.borrow().clone();
+        if Rc::ptr_eq(&previous, &next_presenter) {
+            return;
+        }
+        self.base.replace_indicator_root(next_presenter.root());
+        self.indicator_presenter.replace(next_presenter);
+    }
+
+    fn sync_visual(&self, base_state: PressableLabeledControlState, emit: bool, announce: bool) {
+        apply_radio_checked(
+            &self.indicator_presenter,
+            &self.weak_root,
+            &self.checked,
+            self.checked.get(),
+            emit,
+            announce,
+            &self.changed,
+            self.colors_value.get(),
+            base_state,
+        );
+    }
+}
+
+impl Node for RadioButton {
+    fn retained_node_ref(&self) -> NodeRef {
+        self.root.retained_node_ref()
+    }
+
+    fn build_self(&self) {
+        self.sync_visual(self.base.snapshot_state(), false, false);
+        self.root.build_self();
+    }
+}
+
+impl HasFlexBoxRoot for RadioButton {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.root
+    }
+}
+
+#[derive(Clone)]
+struct RadioEventTarget {
+    presenter: Rc<RefCell<Rc<dyn RadioIndicatorPresenter>>>,
+    checked: Rc<Cell<bool>>,
+    colors_value: Rc<Cell<Option<LabeledControlColors>>>,
+    changed: Rc<RefCell<Option<RadioButtonChangedCallback>>>,
+    owner_group: Rc<RefCell<Option<WeakRadioGroupEventTarget>>>,
+    weak_root: Rc<WeakNodeRef>,
+}
+
+impl RadioEventTarget {
+    fn from_radio(radio: &RadioButton) -> Self {
+        Self {
+            presenter: radio.indicator_presenter.clone(),
+            checked: radio.checked.clone(),
+            colors_value: radio.colors_value.clone(),
+            changed: radio.changed.clone(),
+            owner_group: radio.owner_group.clone(),
+            weak_root: radio.weak_root.clone(),
+        }
+    }
+
+    fn activate(&self, base_state: PressableLabeledControlState) {
+        if let Some(group) = self.owner_group() {
+            if let Some(handle) = upgraded_handle(&self.weak_root) {
+                group.select_radio_handle(handle.raw(), true);
+                return;
+            }
+        }
+        apply_radio_checked(
+            &self.presenter,
+            &self.weak_root,
+            &self.checked,
+            true,
+            true,
+            true,
+            &self.changed,
+            self.colors_value.get(),
+            base_state,
+        );
+    }
+
+    fn handle_key_event(&self, event: &mut KeyEventArgs) -> bool {
+        if event.event_type != KeyEventType::Down || event.modifiers != 0 {
+            return false;
+        }
+        let Some(group) = self.owner_group() else {
+            return false;
+        };
+        let Some(handle) = upgraded_handle(&self.weak_root) else {
+            return false;
+        };
+        match event.key.as_str() {
+            "ArrowLeft" | "ArrowUp" => {
+                group.move_selection_from_handle(handle.raw(), -1);
+                true
+            }
+            "ArrowRight" | "ArrowDown" => {
+                group.move_selection_from_handle(handle.raw(), 1);
+                true
+            }
+            "Home" => {
+                group.select_first_enabled(true);
+                true
+            }
+            "End" => {
+                group.select_last_enabled(true);
+                true
+            }
+            _ => false,
+        }
+    }
+
+    fn sync_visual(&self, base_state: PressableLabeledControlState, emit: bool, announce: bool) {
+        apply_radio_checked(
+            &self.presenter,
+            &self.weak_root,
+            &self.checked,
+            self.checked.get(),
+            emit,
+            announce,
+            &self.changed,
+            self.colors_value.get(),
+            base_state,
+        );
+    }
+
+    fn owner_group(&self) -> Option<Rc<RadioGroupEventTarget>> {
+        self.owner_group
+            .borrow()
+            .as_ref()
+            .and_then(WeakRadioGroupEventTarget::upgrade)
+    }
+}
+
+fn apply_radio_checked(
+    presenter: &Rc<RefCell<Rc<dyn RadioIndicatorPresenter>>>,
+    weak_root: &Rc<WeakNodeRef>,
+    checked_cell: &Rc<Cell<bool>>,
+    checked: bool,
+    emit: bool,
+    announce: bool,
+    changed: &Rc<RefCell<Option<RadioButtonChangedCallback>>>,
+    colors: Option<LabeledControlColors>,
+    base_state: PressableLabeledControlState,
+) {
+    let previous = checked_cell.get();
+    checked_cell.set(checked);
+    update_semantic_checked(
+        weak_root,
+        if checked {
+            SemanticCheckedState::True
+        } else {
+            SemanticCheckedState::False
+        },
+        announce && previous != checked,
+    );
+    presenter.borrow().apply(
+        current_theme(),
+        RadioIndicatorVisualState::new(
+            checked,
+            base_state.hovered,
+            base_state.pressed,
+            base_state.focused,
+            base_state.enabled,
+        ),
+        colors,
+    );
+    if emit && previous != checked {
+        if let Some(callback) = changed.borrow().clone() {
+            callback(RadioButtonChangedEventArgs { checked });
+        }
+    }
+}