@effindomv2/fui-rs 0.1.3

package/src/node/helpers.rs

@@ -0,0 +1,442 @@
+use super::core::*;
+use super::*;
+
+pub type Length = (f32, Unit);
+
+pub fn flex_box() -> FlexBox {
+    FlexBox::default()
+}
+
+pub fn text(content: &str) -> TextNode {
+    TextNode::new(content)
+}
+
+pub fn grid() -> Grid {
+    Grid::default()
+}
+
+pub fn image(texture_id: u32) -> ImageNode {
+    ImageNode::new(texture_id)
+}
+
+pub fn svg(svg_id: u32) -> SvgNode {
+    SvgNode::new(svg_id)
+}
+
+pub fn scroll_view() -> ScrollView {
+    ScrollView::new()
+}
+
+pub fn scroll_box() -> ScrollBox {
+    ScrollBox::new()
+}
+
+pub fn virtual_list(total_items: i32, item_height: f32) -> VirtualList {
+    VirtualList::new(total_items, item_height)
+}
+
+pub fn row() -> FlexBox {
+    let root = FlexBox::default();
+    root.flex_direction(FlexDirection::Row);
+    root
+}
+
+pub fn column() -> FlexBox {
+    let root = FlexBox::default();
+    root.flex_direction(FlexDirection::Column);
+    root
+}
+
+pub fn portal() -> FlexBox {
+    let root = FlexBox::default();
+    root.clip_to_bounds(false).portal(true);
+    root
+}
+
+pub fn custom_drawable(handler: impl Fn(&mut DrawContext) + 'static) -> CustomDrawable {
+    CustomDrawable::new(handler)
+}
+
+pub fn viewport_width() -> f32 {
+    ui::get_viewport_width()
+}
+
+pub fn viewport_height() -> f32 {
+    ui::get_viewport_height()
+}
+
+pub fn px(value: f32) -> Length {
+    (value, Unit::Pixel)
+}
+
+pub fn pct(value: f32) -> Length {
+    (value, Unit::Percent)
+}
+
+pub fn auto() -> Length {
+    (0.0, Unit::Auto)
+}
+
+pub fn fill() -> Length {
+    (100.0, Unit::Percent)
+}
+
+pub(crate) fn apply_flex_box_props(
+    handle: NodeHandle,
+    props: &FlexBoxProps,
+    behavior: NodeBehavior,
+) {
+    ui::set_width(handle.raw(), 0.0, Unit::Auto as u32);
+    ui::set_height(handle.raw(), 0.0, Unit::Auto as u32);
+    ui::set_fill_width(handle.raw(), behavior.fill_width);
+    ui::set_fill_height(handle.raw(), behavior.fill_height);
+    if let Some(percent) = behavior.fill_width_percent {
+        ui::set_fill_width_percent(handle.raw(), percent);
+    }
+    if let Some(percent) = behavior.fill_height_percent {
+        ui::set_fill_height_percent(handle.raw(), percent);
+    }
+    if let Some((width, unit)) = props.width {
+        ui::set_width(handle.raw(), width, unit as u32);
+    }
+    if let Some((height, unit)) = props.height {
+        ui::set_height(handle.raw(), height, unit as u32);
+    }
+    if let Some(style) = props.box_style {
+        ui::set_box_style(
+            handle.raw(),
+            props.bg_color.unwrap_or(0),
+            style.radius_tl,
+            style.radius_tr,
+            style.radius_br,
+            style.radius_bl,
+            style.border_width,
+            style.border_color,
+            style.border_style as u32,
+            style.border_dash_on,
+            style.border_dash_off,
+        );
+    } else if let Some(color) = props.bg_color {
+        ui::set_bg_color(handle.raw(), color);
+    }
+    if let Some((left, top, right, bottom)) = props.padding {
+        ui::set_padding(handle.raw(), left, top, right, bottom);
+    }
+    if let Some(direction) = props.flex_direction {
+        ui::set_flex_direction(handle.raw(), direction as u32);
+    }
+    if props.opacity.is_some() || props.blur_sigma.is_some() {
+        ui::set_layer_effect(
+            handle.raw(),
+            props.opacity.unwrap_or(1.0),
+            props.blur_sigma.unwrap_or(0.0),
+            0,
+        );
+    }
+    if let Some(shadow) = props.drop_shadow {
+        ui::set_drop_shadow(
+            handle.raw(),
+            shadow.color,
+            shadow.offset_x,
+            shadow.offset_y,
+            shadow.blur_sigma,
+            shadow.spread,
+        );
+    }
+    if let Some(sigma) = props.background_blur_sigma {
+        ui::set_background_blur(handle.raw(), sigma);
+    }
+    if let Some(gradient) = props.linear_gradient.as_ref() {
+        ui::set_linear_gradient(
+            handle.raw(),
+            gradient.sx,
+            gradient.sy,
+            gradient.ex,
+            gradient.ey,
+            &gradient.offsets,
+            &gradient.colors,
+        );
+    }
+    apply_behavior(handle, behavior);
+}
+
+pub(crate) fn apply_text_props(handle: NodeHandle, props: &TextProps, behavior: NodeBehavior) {
+    ui::set_text(handle.raw(), &props.content);
+    ui::set_fill_width(handle.raw(), behavior.fill_width);
+    ui::set_fill_height(handle.raw(), behavior.fill_height);
+    if let Some(percent) = behavior.fill_width_percent {
+        ui::set_fill_width_percent(handle.raw(), percent);
+    }
+    if let Some(percent) = behavior.fill_height_percent {
+        ui::set_fill_height_percent(handle.raw(), percent);
+    }
+    apply_behavior(handle, behavior);
+    if let Some((width, unit)) = props.width {
+        ui::set_width(handle.raw(), width, unit as u32);
+    }
+    if let Some((height, unit)) = props.height {
+        ui::set_height(handle.raw(), height, unit as u32);
+    }
+    if props.has_font {
+        ui::set_font(handle.raw(), props.font_id, props.font_size);
+    }
+    if props.has_style_runs {
+        ui::set_text_style_runs(handle.raw(), &props.style_runs);
+    }
+    if let Some(color) = props.text_color {
+        ui::set_text_color(handle.raw(), color);
+    }
+    if let Some(line_height) = props.line_height {
+        ui::set_line_height(handle.raw(), line_height);
+    }
+    if let Some(text_align) = props.text_align {
+        ui::set_text_align(handle.raw(), text_align as u32);
+    }
+    if let Some(text_vertical_align) = props.text_vertical_align {
+        ui::set_text_vertical_align(handle.raw(), text_vertical_align as u32);
+    }
+    if let Some((max_chars, max_lines)) = props.text_limits {
+        ui::set_text_limits(handle.raw(), max_chars, max_lines);
+    }
+    if let Some(wrapping) = props.wrapping {
+        ui::set_text_wrapping(handle.raw(), wrapping);
+    }
+    if let Some(overflow) = props.overflow {
+        ui::set_text_overflow(handle.raw(), overflow as u32);
+    }
+    if let Some((horizontal, vertical)) = props.overflow_fade {
+        ui::set_text_overflow_fade(handle.raw(), horizontal, vertical);
+    }
+    if let Some((selectable, selection_color)) = props.selectable {
+        ui::set_selectable(handle.raw(), selectable, selection_color);
+    }
+    if let Some(editable) = props.editable {
+        ui::set_editable(handle.raw(), editable);
+    }
+    if let Some(enabled) = props.editor_command_keys {
+        ui::set_editor_command_keys(handle.raw(), enabled);
+    }
+    if let Some(enabled) = props.editor_accepts_tab {
+        ui::set_editor_accepts_tab(handle.raw(), enabled);
+    }
+    if let Some(obscured) = props.obscured {
+        ui::set_text_obscured(handle.raw(), obscured);
+    }
+    if let Some(caret_color) = props.caret_color {
+        ui::set_caret_color(handle.raw(), caret_color);
+    }
+}
+
+pub(crate) fn apply_grid_props(handle: NodeHandle, props: &GridProps, behavior: NodeBehavior) {
+    if let Some((width, unit)) = props.width {
+        ui::set_width(handle.raw(), width, unit as u32);
+    }
+    if let Some((height, unit)) = props.height {
+        ui::set_height(handle.raw(), height, unit as u32);
+    }
+    if let Some(color) = props.bg_color {
+        ui::set_bg_color(handle.raw(), color);
+    }
+    if let Some((left, top, right, bottom)) = props.padding {
+        ui::set_padding(handle.raw(), left, top, right, bottom);
+    }
+    ui::grid_set_columns(handle.raw(), &props.columns, &props.column_types);
+    ui::grid_set_rows(handle.raw(), &props.rows, &props.row_types);
+    for (index, group) in &props.column_shared_size_groups {
+        ui::grid_set_column_shared_size_group(handle.raw(), *index, group);
+    }
+    for (index, group) in &props.row_shared_size_groups {
+        ui::grid_set_row_shared_size_group(handle.raw(), *index, group);
+    }
+    apply_behavior(handle, behavior);
+}
+
+pub(crate) fn apply_image_props(handle: NodeHandle, props: &ImageProps, behavior: NodeBehavior) {
+    if let Some((width, unit)) = props.width {
+        ui::set_width(handle.raw(), width, unit as u32);
+    }
+    if let Some((height, unit)) = props.height {
+        ui::set_height(handle.raw(), height, unit as u32);
+    }
+    if let Some((left, top, right, bottom)) = props.image_nine {
+        ui::set_image_nine(
+            handle.raw(),
+            props.texture_id,
+            left,
+            top,
+            right,
+            bottom,
+            props.sampling_kind,
+            props.max_aniso,
+        );
+    } else {
+        ui::set_image(
+            handle.raw(),
+            props.texture_id,
+            props.object_fit as u32,
+            props.sampling_kind,
+            props.max_aniso,
+        );
+    }
+    apply_behavior(handle, behavior);
+}
+
+pub(crate) fn apply_svg_props(handle: NodeHandle, props: &SvgProps, behavior: NodeBehavior) {
+    if let Some((width, unit)) = props.width {
+        ui::set_width(handle.raw(), width, unit as u32);
+    }
+    if let Some((height, unit)) = props.height {
+        ui::set_height(handle.raw(), height, unit as u32);
+    }
+    ui::set_svg(
+        handle.raw(),
+        props.svg_id,
+        props.tint_color,
+        props.sampling_kind,
+        props.max_aniso,
+    );
+    if let Some(opacity) = props.opacity {
+        ui::set_layer_effect(handle.raw(), opacity, 0.0, 0);
+    }
+    apply_behavior(handle, behavior);
+}
+
+pub(crate) fn apply_scroll_view_props(
+    handle: NodeHandle,
+    props: &ScrollViewProps,
+    behavior: NodeBehavior,
+) {
+    ui::set_width(handle.raw(), 0.0, Unit::Auto as u32);
+    ui::set_height(handle.raw(), 0.0, Unit::Auto as u32);
+    ui::set_fill_width(handle.raw(), behavior.fill_width);
+    ui::set_fill_height(handle.raw(), behavior.fill_height);
+    if let Some(percent) = behavior.fill_width_percent {
+        ui::set_fill_width_percent(handle.raw(), percent);
+    }
+    if let Some(percent) = behavior.fill_height_percent {
+        ui::set_fill_height_percent(handle.raw(), percent);
+    }
+    if let Some((width, unit)) = props.width {
+        ui::set_width(handle.raw(), width, unit as u32);
+    }
+    if let Some((height, unit)) = props.height {
+        ui::set_height(handle.raw(), height, unit as u32);
+    }
+    if let Some(color) = props.bg_color {
+        ui::set_bg_color(handle.raw(), color);
+    }
+    if let Some((left, top, right, bottom)) = props.padding {
+        ui::set_padding(handle.raw(), left, top, right, bottom);
+    }
+    ui::set_scroll_enabled(handle.raw(), props.enable_scroll_x, props.enable_scroll_y);
+    ui::set_smooth_scrolling(handle.raw(), props.smooth_scrolling);
+    if let Some(friction) = props.friction {
+        ui::set_scroll_friction(handle.raw(), friction);
+    }
+    if let Some((offset_x, offset_y)) = props.scroll_offset {
+        ui::set_scroll_offset(handle.raw(), offset_x, offset_y);
+    }
+    if let Some((content_width, content_height)) = props.content_size {
+        ui::set_scroll_content_size(handle.raw(), content_width, content_height);
+    }
+    apply_behavior(handle, behavior);
+}
+
+pub(crate) fn apply_behavior(handle: NodeHandle, behavior: NodeBehavior) {
+    let effective_enabled = behavior.enabled && behavior.inherited_enabled;
+    if let Some(node_id) = behavior.node_id.as_deref() {
+        ui::set_node_id(handle.raw(), node_id);
+    }
+    if let Some(role) = behavior.semantic_role {
+        ui::set_semantic_role(handle.raw(), role as u32);
+    }
+    if let Some(label) = behavior
+        .semantic_label
+        .as_deref()
+        .or(behavior.default_semantic_label.as_deref())
+    {
+        ui::set_semantic_label(handle.raw(), label);
+    }
+    if let Some(disabled) = behavior.semantic_disabled {
+        ui::set_semantic_disabled(handle.raw(), true, disabled);
+    }
+    if let Some(state) = behavior.semantic_checked {
+        ui::set_semantic_checked(handle.raw(), state as u32);
+    }
+    if let Some(selected) = behavior.semantic_selected {
+        ui::set_semantic_selected(handle.raw(), true, selected);
+    }
+    if let Some((value_now, value_min, value_max)) = behavior.semantic_value_range {
+        ui::set_semantic_value_range(handle.raw(), true, value_now, value_min, value_max);
+    }
+    if let Some(orientation) = behavior.semantic_orientation {
+        ui::set_semantic_orientation(handle.raw(), orientation as u32);
+    }
+    if let Some(visibility) = behavior.visibility {
+        ui::set_visibility(handle.raw(), visibility as u32);
+    }
+    ui::set_is_portal(handle.raw(), behavior.is_portal);
+    if let Some((value, unit)) = behavior.min_width {
+        ui::set_min_width(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = behavior.max_width {
+        ui::set_max_width(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = behavior.min_height {
+        ui::set_min_height(handle.raw(), value, unit as u32);
+    }
+    if let Some((value, unit)) = behavior.max_height {
+        ui::set_max_height(handle.raw(), value, unit as u32);
+    }
+    if let Some(basis) = behavior.flex_basis {
+        ui::set_flex_basis(handle.raw(), basis);
+    }
+    if let Some(justify) = behavior.justify_content {
+        ui::set_justify_content(handle.raw(), justify as u32);
+    }
+    if let Some(align) = behavior.align_items {
+        ui::set_align_items(handle.raw(), align as u32);
+    }
+    if let Some(align) = behavior.align_self {
+        ui::set_align_self(handle.raw(), align as u32);
+    }
+    if let Some((left, top, right, bottom)) = behavior.margin {
+        ui::set_margin(handle.raw(), left, top, right, bottom);
+    }
+    if let Some(position_type) = behavior.position_type {
+        ui::set_position_type(handle.raw(), position_type as u32);
+    }
+    if let Some((left, top, right, bottom)) = behavior.position {
+        ui::set_position(handle.raw(), left, top, right, bottom);
+    }
+    ui::set_is_shared_size_scope(handle.raw(), behavior.is_shared_size_scope);
+    ui::set_custom_drawable(handle.raw(), behavior.custom_drawable);
+    if let Some(wrap) = behavior.flex_wrap {
+        ui::set_flex_wrap(handle.raw(), wrap as u32);
+    }
+    if let Some(clip) = behavior.clip_to_bounds {
+        ui::set_clip_to_bounds(handle.raw(), clip);
+    }
+    if behavior.selection_area {
+        ui::set_selection_area(handle.raw(), true);
+    }
+    if behavior.selection_area_barrier {
+        ui::set_selection_area_barrier(handle.raw(), true);
+    }
+    if behavior.preserve_selection_on_pointer_down {
+        ui::set_preserve_selection_on_pointer_down(handle.raw(), true);
+    }
+    if let Some(scroll_handle) = behavior.scroll_proxy_target {
+        ui::set_scroll_proxy_target(handle.raw(), scroll_handle);
+    }
+    ui::set_interactive(handle.raw(), effective_enabled && behavior.interactive);
+    if let Some((enabled, tab_index)) = behavior.focusable {
+        ui::set_focusable(handle.raw(), effective_enabled && enabled, tab_index);
+    }
+    if behavior.track_semantic_disabled_from_enabled {
+        ui::set_semantic_disabled(handle.raw(), true, !effective_enabled);
+    }
+    if behavior.request_semantic_announcement {
+        ui::request_semantic_announcement(handle.raw());
+    }
+}