GridLayout: introduce an Organize step to compute row/col

This allows to store the result into a different cache property
than the one that comes out of solve_grid_layout, which fixes
a binding loop when the text of a widget depends on its row or col
value.

Author: dfaure-kdab

api/cpp/include/slint.h

@@ -123,19 +123,32 @@ inline SharedVector<float> solve_box_layout(const cbindgen_private::BoxLayoutDat
     return result;
 }
 
-inline SharedVector<float> solve_grid_layout(const cbindgen_private::GridLayoutData &data,
-                                             cbindgen_private::Orientation orientation)
+inline SharedVector<float>
+organize_grid_layout(cbindgen_private::Slice<cbindgen_private::GridLayoutInputData> input_data)
 {
     SharedVector<float> result;
-    cbindgen_private::slint_solve_grid_layout(&data, orientation, &result);
+    cbindgen_private::slint_organize_grid_layout(input_data, &result);
+    return result;
+}
+
+inline SharedVector<float>
+solve_grid_layout(const cbindgen_private::GridLayoutData &data,
+                  cbindgen_private::Slice<cbindgen_private::LayoutInfo> constraints,
+                  cbindgen_private::Orientation orientation)
+{
+    SharedVector<float> result;
+    cbindgen_private::slint_solve_grid_layout(&data, constraints, orientation, &result);
     return result;
 }
 
 inline cbindgen_private::LayoutInfo
-grid_layout_info(cbindgen_private::Slice<cbindgen_private::GridLayoutCellData> cells, float spacing,
-                 const cbindgen_private::Padding &padding, cbindgen_private::Orientation o)
+grid_layout_info(const cbindgen_private::GridLayoutOrganizedData &organized_data,
+                 cbindgen_private::Slice<cbindgen_private::LayoutInfo> constraints, float spacing,
+                 const cbindgen_private::Padding &padding,
+                 cbindgen_private::Orientation orientation)
 {
-    return cbindgen_private::slint_grid_layout_info(cells, spacing, &padding, o);
+    return cbindgen_private::slint_grid_layout_info(&organized_data, constraints, spacing, &padding,
+                                                    orientation);
 }
 
 inline cbindgen_private::LayoutInfo

internal/compiler/expression_tree.rs

@@ -754,10 +754,24 @@ pub enum Expression {
         /// So this looks like `layout_cache_prop[layout_cache_prop[index] + repeater_index]`
         repeater_index: Option<Box<Expression>>,
     },
+
+    /// Organize a grid layout, i.e. decide what goes where
+    OrganizeGridLayout(crate::layout::GridLayout),
+
     /// Compute the LayoutInfo for the given layout.
     /// The orientation is the orientation of the cache, not the orientation of the layout
     ComputeLayoutInfo(crate::layout::Layout, crate::layout::Orientation),
+    ComputeGridLayoutInfo {
+        layout_organized_data_prop: NamedReference,
+        layout: crate::layout::GridLayout,
+        orientation: crate::layout::Orientation,
+    },
     SolveLayout(crate::layout::Layout, crate::layout::Orientation),
+    SolveGridLayout {
+        layout_organized_data_prop: NamedReference,
+        layout: crate::layout::GridLayout,
+        orientation: crate::layout::Orientation,
+    },
 
     MinMax {
         ty: Type,
@@ -889,8 +903,11 @@ impl Expression {
             // invalid because the expression is unreachable
             Expression::ReturnStatement(_) => Type::Invalid,
             Expression::LayoutCacheAccess { .. } => Type::LogicalLength,
+            Expression::OrganizeGridLayout(..) => typeregister::organized_layout_type().into(),
             Expression::ComputeLayoutInfo(..) => typeregister::layout_info_type().into(),
+            Expression::ComputeGridLayoutInfo { .. } => typeregister::layout_info_type().into(),
             Expression::SolveLayout(..) => Type::LayoutCache,
+            Expression::SolveGridLayout { .. } => Type::LayoutCache,
             Expression::MinMax { ty, .. } => ty.clone(),
             Expression::EmptyComponentFactory => Type::ComponentFactory,
             Expression::DebugHook { expression, .. } => expression.ty(),
@@ -987,8 +1004,11 @@ impl Expression {
             Expression::LayoutCacheAccess { repeater_index, .. } => {
                 repeater_index.as_deref().map(visitor);
             }
+            Expression::OrganizeGridLayout(..) => {}
             Expression::ComputeLayoutInfo(..) => {}
+            Expression::ComputeGridLayoutInfo { .. } => {}
             Expression::SolveLayout(..) => {}
+            Expression::SolveGridLayout { .. } => {}
             Expression::MinMax { lhs, rhs, .. } => {
                 visitor(lhs);
                 visitor(rhs);
@@ -1090,8 +1110,11 @@ impl Expression {
             Expression::LayoutCacheAccess { repeater_index, .. } => {
                 repeater_index.as_deref_mut().map(visitor);
             }
+            Expression::OrganizeGridLayout(..) => {}
             Expression::ComputeLayoutInfo(..) => {}
+            Expression::ComputeGridLayoutInfo { .. } => {}
             Expression::SolveLayout(..) => {}
+            Expression::SolveGridLayout { .. } => {}
             Expression::MinMax { lhs, rhs, .. } => {
                 visitor(lhs);
                 visitor(rhs);
@@ -1183,8 +1206,11 @@ impl Expression {
             }
             // TODO:  detect constant property within layouts
             Expression::LayoutCacheAccess { .. } => false,
+            Expression::OrganizeGridLayout { .. } => false,
             Expression::ComputeLayoutInfo(..) => false,
+            Expression::ComputeGridLayoutInfo { .. } => false,
             Expression::SolveLayout(..) => false,
+            Expression::SolveGridLayout { .. } => false,
             Expression::MinMax { lhs, rhs, .. } => lhs.is_constant(ga) && rhs.is_constant(ga),
             Expression::EmptyComponentFactory => true,
             Expression::DebugHook { .. } => false,
@@ -1858,8 +1884,11 @@ pub fn pretty_print(f: &mut dyn std::fmt::Write, expression: &Expression) -> std
                 if repeater_index.is_some() { " + $index" } else { "" }
             )
         }
+        Expression::OrganizeGridLayout(..) => write!(f, "organize_grid_layout(..)"),
         Expression::ComputeLayoutInfo(..) => write!(f, "layout_info(..)"),
+        Expression::ComputeGridLayoutInfo { .. } => write!(f, "grid_layout_info(..)"),
         Expression::SolveLayout(..) => write!(f, "solve_layout(..)"),
+        Expression::SolveGridLayout { .. } => write!(f, "solve_grid_layout(..)"),
         Expression::MinMax { ty: _, op, lhs, rhs } => {
             match op {
                 MinMaxOp::Min => write!(f, "min(")?,

internal/compiler/layout.rs

@@ -465,7 +465,7 @@ pub struct GridLayout {
 }
 
 impl GridLayout {
-    fn visit_named_references(&mut self, visitor: &mut impl FnMut(&mut NamedReference)) {
+    pub fn visit_named_references(&mut self, visitor: &mut impl FnMut(&mut NamedReference)) {
         for cell in &mut self.elems {
             cell.item.constraints.visit_named_references(visitor);
         }