@effindomv2/fui-rs 0.1.23 → 0.1.24

package/src/node/mod.rs

@@ -2,8 +2,8 @@ use crate::bindings::ui;
 use crate::drawing::DrawContext;
 use crate::event::{
     FocusChangedEventArgs, GestureEventArgs, KeyEventArgs, LongPressEventArgs, PointerEventArgs,
-    PointerType, WheelEventArgs, DEFAULT_LONG_PRESS_MINIMUM_DURATION_MS,
-    DEFAULT_LONG_PRESS_MOVEMENT_TOLERANCE,
+    PointerType, SelectionChangedEventArgs, TextChangedEventArgs, WheelEventArgs,
+    DEFAULT_LONG_PRESS_MINIMUM_DURATION_MS, DEFAULT_LONG_PRESS_MOVEMENT_TOLERANCE,
 };
 use crate::ffi::{
     AlignItems, AlignSelf, BorderStyle, CursorStyle, FlexDirection, FlexWrap, GridUnit,
@@ -13,7 +13,7 @@ use crate::ffi::{
 };
 use crate::theme;
 use crate::transitions::NodeTransitions;
-use crate::typography::{FontFamily, FontStyle, FontWeight};
+use crate::typography::{FontFamily, FontStack, FontStyle, FontWeight};
 use std::any::Any;
 use std::cell::RefCell;
 use std::rc::{Rc, Weak};
@@ -53,15 +53,33 @@ pub use scroll_box::ScrollBox;
 pub use scroll_state::ScrollState;
 pub use scroll_view::ScrollView;
 pub use svg_node::SvgNode;
-pub use text_node::{TextCore, TextNode};
+pub use text_node::TextNode;
 pub use virtual_list::VirtualList;
 
 pub type Image = ImageNode;
+pub type Portal = FlexBox;
 pub type Svg = SvgNode;
 pub type Text = TextNode;
 
 pub trait HasFlexBoxRoot {
     fn flex_box_root(&self) -> &FlexBox;
+
+    #[doc(hidden)]
+    fn set_flex_box_surface_width(&self, value: f32, unit: Unit) {
+        self.flex_box_root().width(value, unit);
+    }
+
+    #[doc(hidden)]
+    fn set_flex_box_surface_height(&self, value: f32, unit: Unit) {
+        self.flex_box_root().height(value, unit);
+    }
+
+    #[doc(hidden)]
+    fn append_flex_box_surface_child(&self, child: NodeRef) {
+        self.flex_box_root()
+            .retained_node_ref()
+            .append_child_ref(&child);
+    }
 }
 
 pub trait ThemeBindable: Sized + 'static {
@@ -102,6 +120,41 @@ impl ThemeBindable for FlexBox {
 
 pub trait HasTextNode {
     fn text_node(&self) -> &TextNode;
+
+    #[doc(hidden)]
+    fn set_text_surface_content(&self, content: String) {
+        self.text_node().text(content);
+    }
+
+    #[doc(hidden)]
+    fn set_text_surface_font_stack(&self, stack: FontStack, size: f32) {
+        self.text_node().font_stack(stack, size);
+    }
+
+    #[doc(hidden)]
+    fn set_text_surface_font_family(&self, family: FontFamily) {
+        self.text_node().font_family(family);
+    }
+
+    #[doc(hidden)]
+    fn set_text_surface_font_weight(&self, weight: FontWeight) {
+        self.text_node().font_weight(weight);
+    }
+
+    #[doc(hidden)]
+    fn set_text_surface_font_style(&self, style: FontStyle) {
+        self.text_node().font_style(style);
+    }
+
+    #[doc(hidden)]
+    fn set_text_surface_font_size(&self, size: f32) {
+        self.text_node().font_size(size);
+    }
+
+    #[doc(hidden)]
+    fn set_text_surface_color(&self, color: u32) {
+        self.text_node().text_color(color);
+    }
 }
 
 pub trait TextLayoutSurface: HasTextNode {
@@ -115,6 +168,18 @@ pub trait TextLayoutSurface: HasTextNode {
         self
     }
 
+    fn width_len(&self, length: Length) -> &Self {
+        let (value, unit) = length;
+        self.text_node().width(value, unit);
+        self
+    }
+
+    fn height_len(&self, length: Length) -> &Self {
+        let (value, unit) = length;
+        self.text_node().height(value, unit);
+        self
+    }
+
     fn fill_width(&self) -> &Self {
         self.text_node().fill_width();
         self
@@ -130,8 +195,33 @@ pub trait TextLayoutSurface: HasTextNode {
         self
     }
 
-    fn line_height(&self, line_height: f32) -> &Self {
-        self.text_node().line_height(line_height);
+    fn fill_width_percent(&self, percent: f32) -> &Self {
+        self.text_node().fill_width_percent(percent);
+        self
+    }
+
+    fn fill_height_percent(&self, percent: f32) -> &Self {
+        self.text_node().fill_height_percent(percent);
+        self
+    }
+
+    fn min_width(&self, value: f32, unit: Unit) -> &Self {
+        self.text_node().min_width(value, unit);
+        self
+    }
+
+    fn max_width(&self, value: f32, unit: Unit) -> &Self {
+        self.text_node().max_width(value, unit);
+        self
+    }
+
+    fn min_height(&self, value: f32, unit: Unit) -> &Self {
+        self.text_node().min_height(value, unit);
+        self
+    }
+
+    fn max_height(&self, value: f32, unit: Unit) -> &Self {
+        self.text_node().max_height(value, unit);
         self
     }
 
@@ -173,165 +263,361 @@ pub trait TextLayoutSurface: HasTextNode {
 
 impl<T: HasTextNode> TextLayoutSurface for T {}
 
+pub trait TextContentSurface: HasTextNode {
+    fn text(&self, content: impl Into<String>) -> &Self {
+        self.set_text_surface_content(content.into());
+        self
+    }
+
+    fn content(&self) -> String {
+        self.text_node().content()
+    }
+}
+
+impl<T: HasTextNode> TextContentSurface for T {}
+
+pub trait TextTypographySurface: HasTextNode {
+    fn font_stack(&self, stack: FontStack, size: f32) -> &Self {
+        self.set_text_surface_font_stack(stack, size);
+        self
+    }
+
+    fn font_family(&self, family: FontFamily) -> &Self {
+        self.set_text_surface_font_family(family);
+        self
+    }
+
+    fn font_weight(&self, weight: FontWeight) -> &Self {
+        self.set_text_surface_font_weight(weight);
+        self
+    }
+
+    fn font_style(&self, style: FontStyle) -> &Self {
+        self.set_text_surface_font_style(style);
+        self
+    }
+
+    fn font_size(&self, size: f32) -> &Self {
+        self.set_text_surface_font_size(size);
+        self
+    }
+
+    fn line_height(&self, line_height: f32) -> &Self {
+        self.text_node().line_height(line_height);
+        self
+    }
+
+    fn text_color(&self, color: u32) -> &Self {
+        self.set_text_surface_color(color);
+        self
+    }
+}
+
+impl<T: HasTextNode> TextTypographySurface for T {}
+
+pub trait TextSelectionSurface: HasTextNode {
+    fn uses_default_selection_behavior(&self) -> bool {
+        self.text_node().uses_default_selection_behavior()
+    }
+
+    fn is_selectable_text(&self) -> bool {
+        self.text_node().is_selectable_text()
+    }
+
+    fn selection_start(&self) -> u32 {
+        self.text_node().selection_start()
+    }
+
+    fn selection_end(&self) -> u32 {
+        self.text_node().selection_end()
+    }
+
+    fn selectable(&self, selectable: bool) -> &Self {
+        self.text_node().selectable(selectable);
+        self
+    }
+
+    fn selection_color(&self, color: u32) -> &Self {
+        self.text_node().selection_color(color);
+        self
+    }
+
+    fn selection_range(&self, start: u32, end: u32) -> &Self {
+        self.text_node().selection_range(start, end);
+        self
+    }
+
+    fn caret_color(&self, color: u32) -> &Self {
+        self.text_node().caret_color(color);
+        self
+    }
+}
+
+impl<T: HasTextNode> TextSelectionSurface for T {}
+
+pub trait TextEditingSurface: HasTextNode {
+    fn is_editable_text(&self) -> bool {
+        self.text_node().is_editable_text()
+    }
+
+    fn editable(&self, editable: bool) -> &Self {
+        self.text_node().editable(editable);
+        self
+    }
+
+    fn obscured(&self, obscured: bool) -> &Self {
+        self.text_node().obscured(obscured);
+        self
+    }
+}
+
+impl<T: HasTextNode> TextEditingSurface for T {}
+
+pub trait TextEventSurface: HasTextNode {
+    fn on_text_changed(&self, handler: impl Fn(TextChangedEventArgs) + 'static) -> &Self {
+        self.text_node().on_text_changed(handler);
+        self
+    }
+
+    fn on_selection_changed(&self, handler: impl Fn(SelectionChangedEventArgs) + 'static) -> &Self {
+        self.text_node().on_selection_changed(handler);
+        self
+    }
+}
+
+impl<T: HasTextNode> TextEventSurface for T {}
+
+pub trait TextSurface:
+    TextLayoutSurface
+    + TextContentSurface
+    + TextTypographySurface
+    + TextSelectionSurface
+    + TextEditingSurface
+    + TextEventSurface
+{
+}
+
+impl<T> TextSurface for T where
+    T: TextLayoutSurface
+        + TextContentSurface
+        + TextTypographySurface
+        + TextSelectionSurface
+        + TextEditingSurface
+        + TextEventSurface
+{
+}
+
 impl HasTextNode for TextNode {
     fn text_node(&self) -> &TextNode {
         self
     }
 }
 
-pub trait FlexBoxSurface: HasFlexBoxRoot {
+pub trait LayoutSurface {
+    #[doc(hidden)]
+    fn layout_surface_root(&self) -> &FlexBox;
+
+    #[doc(hidden)]
+    fn set_layout_surface_width(&self, value: f32, unit: Unit);
+
+    #[doc(hidden)]
+    fn set_layout_surface_height(&self, value: f32, unit: Unit);
+
     fn width(&self, width: f32, unit: Unit) -> &Self {
-        self.flex_box_root().width(width, unit);
+        self.set_layout_surface_width(width, unit);
         self
     }
 
     fn width_len(&self, length: Length) -> &Self {
-        self.flex_box_root().width_len(length);
+        let (value, unit) = length;
+        self.set_layout_surface_width(value, unit);
         self
     }
 
     fn height(&self, height: f32, unit: Unit) -> &Self {
-        self.flex_box_root().height(height, unit);
+        self.set_layout_surface_height(height, unit);
         self
     }
 
     fn height_len(&self, length: Length) -> &Self {
-        self.flex_box_root().height_len(length);
+        let (value, unit) = length;
+        self.set_layout_surface_height(value, unit);
         self
     }
 
     fn fill_width(&self) -> &Self {
-        self.flex_box_root().fill_width();
+        self.layout_surface_root().fill_width();
         self
     }
 
     fn fill_height(&self) -> &Self {
-        self.flex_box_root().fill_height();
+        self.layout_surface_root().fill_height();
         self
     }
 
     fn fill_size(&self) -> &Self {
-        self.flex_box_root().fill_size();
+        self.layout_surface_root().fill_size();
         self
     }
 
     fn fill_width_percent(&self, percent: f32) -> &Self {
-        self.flex_box_root().fill_width_percent(percent);
+        self.layout_surface_root().fill_width_percent(percent);
         self
     }
 
     fn fill_height_percent(&self, percent: f32) -> &Self {
-        self.flex_box_root().fill_height_percent(percent);
+        self.layout_surface_root().fill_height_percent(percent);
         self
     }
 
     fn min_width(&self, value: f32, unit: Unit) -> &Self {
-        self.flex_box_root().min_width(value, unit);
+        self.layout_surface_root().min_width(value, unit);
         self
     }
 
     fn min_width_len(&self, length: Length) -> &Self {
-        self.flex_box_root().min_width_len(length);
+        self.layout_surface_root().min_width_len(length);
         self
     }
 
     fn max_width(&self, value: f32, unit: Unit) -> &Self {
-        self.flex_box_root().max_width(value, unit);
+        self.layout_surface_root().max_width(value, unit);
         self
     }
 
     fn max_width_len(&self, length: Length) -> &Self {
-        self.flex_box_root().max_width_len(length);
+        self.layout_surface_root().max_width_len(length);
         self
     }
 
     fn min_height(&self, value: f32, unit: Unit) -> &Self {
-        self.flex_box_root().min_height(value, unit);
+        self.layout_surface_root().min_height(value, unit);
         self
     }
 
     fn min_height_len(&self, length: Length) -> &Self {
-        self.flex_box_root().min_height_len(length);
+        self.layout_surface_root().min_height_len(length);
         self
     }
 
     fn max_height(&self, value: f32, unit: Unit) -> &Self {
-        self.flex_box_root().max_height(value, unit);
+        self.layout_surface_root().max_height(value, unit);
         self
     }
 
     fn max_height_len(&self, length: Length) -> &Self {
-        self.flex_box_root().max_height_len(length);
+        self.layout_surface_root().max_height_len(length);
         self
     }
 
-    fn padding(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
-        self.flex_box_root().padding(left, top, right, bottom);
+    fn margin(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
+        self.layout_surface_root().margin(left, top, right, bottom);
         self
     }
 
-    fn clear_padding(&self) -> &Self {
-        self.flex_box_root().clear_padding();
+    fn position_type(&self, position_type: PositionType) -> &Self {
+        self.layout_surface_root().position_type(position_type);
         self
     }
 
-    fn margin(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
-        self.flex_box_root().margin(left, top, right, bottom);
+    fn position_absolute(&self) -> &Self {
+        self.layout_surface_root()
+            .position_type(PositionType::Absolute);
+        self
+    }
+
+    fn position(&self, left: f32, top: f32) -> &Self {
+        self.layout_surface_root().position(left, top);
+        self
+    }
+}
+
+impl<T: HasFlexBoxRoot> LayoutSurface for T {
+    fn layout_surface_root(&self) -> &FlexBox {
+        self.flex_box_root()
+    }
+
+    fn set_layout_surface_width(&self, value: f32, unit: Unit) {
+        self.set_flex_box_surface_width(value, unit);
+    }
+
+    fn set_layout_surface_height(&self, value: f32, unit: Unit) {
+        self.set_flex_box_surface_height(value, unit);
+    }
+}
+
+pub trait BoxStyleSurface {
+    #[doc(hidden)]
+    fn box_style_surface_root(&self) -> &FlexBox;
+
+    fn interactive(&self, interactive: bool) -> &Self {
+        self.box_style_surface_root().interactive(interactive);
+        self
+    }
+
+    fn padding(&self, left: f32, top: f32, right: f32, bottom: f32) -> &Self {
+        self.box_style_surface_root()
+            .padding(left, top, right, bottom);
+        self
+    }
+
+    fn clear_padding(&self) -> &Self {
+        self.box_style_surface_root().clear_padding();
         self
     }
 
     fn corner_radius(&self, radius: f32) -> &Self {
-        self.flex_box_root().corner_radius(radius);
+        self.box_style_surface_root().corner_radius(radius);
         self
     }
 
     fn clear_corners(&self) -> &Self {
-        self.flex_box_root().clear_corners();
+        self.box_style_surface_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.box_style_surface_root().corners(tl, tr, br, bl);
         self
     }
 
     fn border(&self, width: f32, color: u32) -> &Self {
-        self.flex_box_root().border(width, color);
+        self.box_style_surface_root().border(width, color);
         self
     }
 
     fn border_config(&self, border: Border) -> &Self {
-        self.flex_box_root().border_config(border);
+        self.box_style_surface_root().border_config(border);
         self
     }
 
     fn clear_border(&self) -> &Self {
-        self.flex_box_root().clear_border();
+        self.box_style_surface_root().clear_border();
         self
     }
 
     fn bg_color(&self, color: u32) -> &Self {
-        self.flex_box_root().bg_color(color);
+        self.box_style_surface_root().bg_color(color);
         self
     }
 
     fn clear_bg_color(&self) -> &Self {
-        self.flex_box_root().clear_bg_color();
+        self.box_style_surface_root().clear_bg_color();
         self
     }
 
     fn opacity(&self, value: f32) -> &Self {
-        self.flex_box_root().opacity(value);
+        self.box_style_surface_root().opacity(value);
         self
     }
 
     fn clear_opacity(&self) -> &Self {
-        self.flex_box_root().clear_opacity();
+        self.box_style_surface_root().clear_opacity();
         self
     }
 
     fn blur(&self, sigma: f32) -> &Self {
-        self.flex_box_root().blur(sigma);
+        self.box_style_surface_root().blur(sigma);
         self
     }
 
@@ -343,18 +629,18 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         blur_sigma: f32,
         spread: f32,
     ) -> &Self {
-        self.flex_box_root()
+        self.box_style_surface_root()
             .drop_shadow(color, offset_x, offset_y, blur_sigma, spread);
         self
     }
 
     fn clear_drop_shadow(&self) -> &Self {
-        self.flex_box_root().clear_drop_shadow();
+        self.box_style_surface_root().clear_drop_shadow();
         self
     }
 
     fn background_blur(&self, sigma: f32) -> &Self {
-        self.flex_box_root().background_blur(sigma);
+        self.box_style_surface_root().background_blur(sigma);
         self
     }
 
@@ -367,7 +653,7 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         offsets: Vec<f32>,
         colors: Vec<u32>,
     ) -> &Self {
-        self.flex_box_root()
+        self.box_style_surface_root()
             .linear_gradient(start_x, start_y, end_x, end_y, offsets, colors);
         self
     }
@@ -380,83 +666,122 @@ pub trait FlexBoxSurface: HasFlexBoxRoot {
         end_y: f32,
         stops: Vec<GradientStop>,
     ) -> &Self {
-        self.flex_box_root()
+        self.box_style_surface_root()
             .linear_gradient_stops(start_x, start_y, end_x, end_y, stops);
         self
     }
 
     fn transitions(&self, transitions: Option<NodeTransitions>) -> &Self {
-        self.flex_box_root().transitions(transitions);
+        self.box_style_surface_root().transitions(transitions);
+        self
+    }
+
+    fn clip_to_bounds(&self, clip: bool) -> &Self {
+        self.box_style_surface_root().clip_to_bounds(clip);
+        self
+    }
+}
+
+impl<T: HasFlexBoxRoot> BoxStyleSurface for T {
+    fn box_style_surface_root(&self) -> &FlexBox {
+        self.flex_box_root()
+    }
+}
+
+pub trait FlexLayoutSurface {
+    #[doc(hidden)]
+    fn flex_layout_surface_root(&self) -> &FlexBox;
+
+    fn flex_direction(&self, direction: FlexDirection) -> &Self {
+        self.flex_layout_surface_root().flex_direction(direction);
         self
     }
 
     fn flex_basis(&self, basis: f32) -> &Self {
-        self.flex_box_root().flex_basis(basis);
+        self.flex_layout_surface_root().flex_basis(basis);
         self
     }
 
     fn justify_content(&self, justify: JustifyContent) -> &Self {
-        self.flex_box_root().justify_content(justify);
+        self.flex_layout_surface_root().justify_content(justify);
         self
     }
 
     fn clear_justify_content(&self) -> &Self {
-        self.flex_box_root().clear_justify_content();
+        self.flex_layout_surface_root().clear_justify_content();
         self
     }
 
     fn align_items(&self, align: AlignItems) -> &Self {
-        self.flex_box_root().align_items(align);
+        self.flex_layout_surface_root().align_items(align);
         self
     }
 
     fn clear_align_items(&self) -> &Self {
-        self.flex_box_root().clear_align_items();
+        self.flex_layout_surface_root().clear_align_items();
         self
     }
 
     fn align_self(&self, align: AlignSelf) -> &Self {
-        self.flex_box_root().align_self(align);
+        self.flex_layout_surface_root().align_self(align);
         self
     }
 
     fn flex_wrap(&self, wrap: FlexWrap) -> &Self {
-        self.flex_box_root().flex_wrap(wrap);
+        self.flex_layout_surface_root().flex_wrap(wrap);
         self
     }
+}
 
-    fn position_type(&self, position_type: PositionType) -> &Self {
-        self.flex_box_root().position_type(position_type);
-        self
+impl<T: HasFlexBoxRoot> FlexLayoutSurface for T {
+    fn flex_layout_surface_root(&self) -> &FlexBox {
+        self.flex_box_root()
     }
+}
 
-    fn position(&self, left: f32, top: f32) -> &Self {
-        self.flex_box_root().position(left, top);
-        self
-    }
+/// Fluent retained-child composition for FlexBox-backed nodes and controls.
+///
+/// Composed controls may install presenter-owned children before user content;
+/// `child` and `children` append without replacing those presenter children.
+/// A caller can remove a child it owns through [`Node::remove_child`] without
+/// disturbing the control-owned prefix. Controls with a distinct public content
+/// surface override the hidden append adapter to match their FUI-AS counterpart.
+pub trait ChildContainerSurface {
+    #[doc(hidden)]
+    fn append_surface_child(&self, child: NodeRef);
 
-    fn clip_to_bounds(&self, clip: bool) -> &Self {
-        self.flex_box_root().clip_to_bounds(clip);
+    fn child<T: Node>(&self, child: &T) -> &Self {
+        self.append_surface_child(child.retained_node_ref());
         self
     }
 
-    fn cursor(&self, style: CursorStyle) -> &Self {
-        self.flex_box_root().cursor(style);
+    fn children<I, C>(&self, children: I) -> &Self
+    where
+        I: IntoIterator<Item = C>,
+        C: Into<Child>,
+    {
+        for child in children {
+            self.append_surface_child(child.into().node_ref);
+        }
         self
     }
+}
 
-    fn clear_cursor(&self) -> &Self {
-        self.flex_box_root().clear_cursor();
-        self
+impl<T: HasFlexBoxRoot> ChildContainerSurface for T {
+    fn append_surface_child(&self, child: NodeRef) {
+        self.append_flex_box_surface_child(child);
     }
+}
 
-    fn visibility(&self, visibility: Visibility) -> &Self {
-        self.flex_box_root().visibility(visibility);
-        self
-    }
+pub trait FlexBoxSurface:
+    LayoutSurface + BoxStyleSurface + FlexLayoutSurface + ChildContainerSurface
+{
 }
 
-impl<T: HasFlexBoxRoot> FlexBoxSurface for T {}
+impl<T> FlexBoxSurface for T where
+    T: LayoutSurface + BoxStyleSurface + FlexLayoutSurface + ChildContainerSurface
+{
+}
 
 #[derive(Clone)]
 pub struct Child {