Add cross-axis extent, stub implementations for ColoredBox and List

crates/yakui-core/src/layout/mod.rs

@@ -201,12 +201,12 @@ impl LayoutDom {
     }
 
     /// Calculates the intrinsic size of the given widget along the given axis.
-    pub fn intrinsic_size(&self, dom: &Dom, id: WidgetId, axis: Axis) -> f32 {
+    pub fn intrinsic_size(&self, dom: &Dom, id: WidgetId, axis: Axis, extent: f32) -> f32 {
         dom.enter(id);
         let dom_node = dom.get(id).unwrap();
 
         let context = IntrinsicSizeContext { dom, layout: self };
-        let size = dom_node.widget.intrinsic_size(context, axis);
+        let size = dom_node.widget.intrinsic_size(context, axis, extent);
 
         dom.exit(id);
         size

crates/yakui-core/src/types.rs

@@ -273,4 +273,15 @@ impl Axis {
             Axis::Y => v.y,
         }
     }
+
+    /// Tells whether this axis indicates the same axis as a given [`Direction`].
+    pub fn is_direction(self, dir: Direction) -> bool {
+        match (self, dir) {
+            (Axis::X, Direction::Right) => true,
+            (Axis::Y, Direction::Down) => true,
+
+            (Axis::X, Direction::Down) => false,
+            (Axis::Y, Direction::Right) => false,
+        }
+    }
 }

crates/yakui-core/src/widget.rs

@@ -41,8 +41,8 @@ impl<'dom> LayoutContext<'dom> {
     }
 
     /// Calculates the intrinsic size for the given widget on the given axis.
-    pub fn intrinsic_size(&self, widget: WidgetId, axis: Axis) -> f32 {
-        self.layout.intrinsic_size(self.dom, widget, axis)
+    pub fn intrinsic_size(&self, widget: WidgetId, axis: Axis, extent: f32) -> f32 {
+        self.layout.intrinsic_size(self.dom, widget, axis, extent)
     }
 }
 
@@ -56,8 +56,8 @@ pub struct IntrinsicSizeContext<'dom> {
 
 impl<'dom> IntrinsicSizeContext<'dom> {
     /// Calculates the intrinsic size for the given widget on the given axis.
-    pub fn intrinsic_size(&self, widget: WidgetId, axis: Axis) -> f32 {
-        self.layout.intrinsic_size(self.dom, widget, axis)
+    pub fn intrinsic_size(&self, widget: WidgetId, axis: Axis, extent: f32) -> f32 {
+        self.layout.intrinsic_size(self.dom, widget, axis, extent)
     }
 }
 
@@ -156,14 +156,14 @@ pub trait Widget: 'static + fmt::Debug {
     }
 
     /// Tells the intrinsic size on one axis of the object, which is its size
-    /// along that axis if the widget were given unbounded constraints on the
-    /// other axis.
-    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis) -> f32 {
+    /// along that axis if the widget is provided the given `extent` as the max
+    /// size along the other axis.
+    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis, extent: f32) -> f32 {
         let node = ctx.dom.get_current();
         let mut size: f32 = 0.0;
 
         for &child in &node.children {
-            let child_size = ctx.intrinsic_size(child, axis);
+            let child_size = ctx.intrinsic_size(child, axis, extent);
             size = size.max(child_size);
         }
 
@@ -217,7 +217,7 @@ pub trait ErasedWidget: Any + fmt::Debug {
     fn layout(&self, ctx: LayoutContext<'_>, constraints: Constraints) -> Vec2;
 
     /// See [`Widget::intrinsic_size`].
-    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis) -> f32;
+    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis, extent: f32) -> f32;
 
     /// See [`Widget::flex`].
     fn flex(&self) -> (u32, FlexFit);
@@ -246,8 +246,8 @@ where
         <T as Widget>::layout(self, ctx, constraints)
     }
 
-    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis) -> f32 {
-        <T as Widget>::intrinsic_size(self, ctx, axis)
+    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis, extent: f32) -> f32 {
+        <T as Widget>::intrinsic_size(self, ctx, axis, extent)
     }
 
     fn flex(&self) -> (u32, FlexFit) {

crates/yakui-widgets/src/widgets/colored_box.rs

@@ -1,7 +1,7 @@
 use yakui_core::geometry::{Color, Constraints, Vec2};
 use yakui_core::paint::PaintRect;
-use yakui_core::widget::{LayoutContext, PaintContext, Widget};
-use yakui_core::Response;
+use yakui_core::widget::{IntrinsicSizeContext, LayoutContext, PaintContext, Widget};
+use yakui_core::{Axis, Response};
 
 use crate::util::{widget, widget_children};
 
@@ -82,6 +82,17 @@ impl Widget for ColoredBoxWidget {
         input.constrain_min(size)
     }
 
+    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis, extent: f32) -> f32 {
+        let node = ctx.dom.get_current();
+        let mut size = axis.select(self.props.min_size);
+
+        for &child in &node.children {
+            size = size.max(ctx.intrinsic_size(child, axis, extent));
+        }
+
+        size
+    }
+
     fn paint(&self, mut ctx: PaintContext<'_>) {
         let node = ctx.dom.get_current();
         let layout_node = ctx.layout.get(ctx.dom.current()).unwrap();

crates/yakui-widgets/src/widgets/list.rs

@@ -1,6 +1,8 @@
 use yakui_core::geometry::{Constraints, FlexFit, Vec2};
-use yakui_core::widget::{LayoutContext, Widget};
-use yakui_core::{CrossAxisAlignment, Direction, Flow, MainAxisAlignment, MainAxisSize, Response};
+use yakui_core::widget::{IntrinsicSizeContext, LayoutContext, Widget};
+use yakui_core::{
+    Axis, CrossAxisAlignment, Direction, Flow, MainAxisAlignment, MainAxisSize, Response,
+};
 
 use crate::util::widget_children;
 
@@ -285,4 +287,39 @@ impl Widget for ListWidget {
 
         container_size
     }
+
+    fn intrinsic_size(&self, ctx: IntrinsicSizeContext<'_>, axis: Axis, extent: f32) -> f32 {
+        let node = ctx.dom.get_current();
+
+        if axis.is_direction(self.props.direction) {
+            // main axis layout
+            let mut total_flex = 0.0;
+            let mut inflexible_space = 0.0;
+
+            for &child_id in &node.children {
+                let child_size = ctx.intrinsic_size(child_id, axis, extent);
+                let child = ctx.dom.get(child_id).unwrap();
+
+                let (flex, _) = child.widget.flex();
+
+                if flex > 0 {
+                    // TODO
+                } else {
+                    inflexible_space += child_size;
+                }
+            }
+
+            inflexible_space
+        } else {
+            // cross axis layout
+            let mut max_size: f32 = 0.0;
+
+            for &child_id in &node.children {
+                let child_size = ctx.intrinsic_size(child_id, axis, extent);
+                max_size = max_size.max(child_size);
+            }
+
+            max_size
+        }
+    }
 }