Move reordering of dialog buttons to the organize step

This repairs the feature of reordering buttons, which was
temporarily left out in the previous commit.

Author: dfaure-kdab

api/cpp/include/slint.h

@@ -131,6 +131,15 @@ organize_grid_layout(cbindgen_private::Slice<cbindgen_private::GridLayoutInputDa
     return result;
 }
 
+inline SharedVector<float> organize_dialog_button_layout(
+        cbindgen_private::Slice<cbindgen_private::GridLayoutInputData> input_data,
+        cbindgen_private::Slice<DialogButtonRole> dialog_button_roles)
+{
+    SharedVector<float> result;
+    cbindgen_private::slint_organize_dialog_button_layout(input_data, dialog_button_roles, &result);
+    return result;
+}
+
 inline SharedVector<float>
 solve_grid_layout(const cbindgen_private::GridLayoutData &data,
                   cbindgen_private::Slice<cbindgen_private::LayoutInfo> constraints,

internal/compiler/generator/cpp.rs

@@ -3664,23 +3664,6 @@ fn compile_expression(expr: &llr::Expression, ctx: &EvaluationContext) -> String
             sub_expression,
             ctx,
         ),
-        Expression::ComputeDialogLayoutCells { cells_variable, roles, unsorted_cells } => {
-            let cells_variable = ident(cells_variable);
-            let mut cells = match &**unsorted_cells {
-                Expression::Array { values, .. } => {
-                    values.iter().map(|v| compile_expression(v, ctx))
-                }
-                _ => panic!("dialog layout unsorted cells not an array"),
-            };
-            format!(
-                "slint::cbindgen_private::GridLayoutCellData {cv}_array [] = {{ {c} }};\
-                    slint::cbindgen_private::slint_reorder_dialog_button_layout({cv}_array, {r});\
-                    slint::cbindgen_private::Slice<slint::cbindgen_private::GridLayoutCellData> {cv} = slint::private_api::make_slice(std::span({cv}_array))",
-                r = compile_expression(roles, ctx),
-                cv = cells_variable,
-                c = cells.join(", "),
-            )
-        }
         Expression::MinMax { ty, op, lhs, rhs } => {
             let ident = match op {
                 MinMaxOp::Min => "min",

internal/compiler/generator/rust.rs

@@ -2710,21 +2710,6 @@ fn compile_expression(expr: &Expression, ctx: &EvaluationContext) -> TokenStream
             sub_expression,
             ctx,
         ),
-        Expression::ComputeDialogLayoutCells { cells_variable, roles, unsorted_cells } => {
-            let cells_variable = ident(cells_variable);
-            let roles = compile_expression(roles, ctx);
-            let cells = match &**unsorted_cells {
-                Expression::Array { values, .. } => {
-                    values.iter().map(|v| compile_expression(v, ctx))
-                }
-                _ => panic!("dialog layout unsorted cells not an array"),
-            };
-            quote! {
-                let mut #cells_variable = [#(#cells),*];
-                sp::reorder_dialog_button_layout(&mut #cells_variable, &#roles);
-                let #cells_variable = sp::Slice::from_slice(&#cells_variable);
-            }
-        }
         Expression::MinMax { ty, op, lhs, rhs } => {
             let lhs = compile_expression(lhs, ctx);
             let t = rust_primitive_type(ty);

internal/compiler/llr/expression.rs

@@ -186,15 +186,6 @@ pub enum Expression {
         orientation: Orientation,
         sub_expression: Box<Expression>,
     },
-
-    ComputeDialogLayoutCells {
-        /// The local variable where the slice of cells is going to be stored
-        cells_variable: String,
-        roles: Box<Expression>,
-        /// This is an Expression::Array
-        unsorted_cells: Box<Expression>,
-    },
-
     MinMax {
         ty: Type,
         op: MinMaxOp,
@@ -322,9 +313,6 @@ impl Expression {
             Self::EnumerationValue(e) => Type::Enumeration(e.enumeration.clone()),
             Self::LayoutCacheAccess { .. } => Type::LogicalLength,
             Self::BoxLayoutFunction { sub_expression, .. } => sub_expression.ty(ctx),
-            Self::ComputeDialogLayoutCells { .. } => {
-                Type::Array(super::lower_expression::grid_layout_cell_data_ty().into())
-            }
             Self::MinMax { ty, .. } => ty.clone(),
             Self::EmptyComponentFactory => Type::ComponentFactory,
             Self::TranslationReference { .. } => Type::String,
@@ -409,10 +397,6 @@ macro_rules! visit_impl {
                 $visitor(sub_expression);
                 elements.$iter().filter_map(|x| x.$as_ref().left()).for_each($visitor);
             }
-            Expression::ComputeDialogLayoutCells { roles, unsorted_cells, .. } => {
-                $visitor(roles);
-                $visitor(unsorted_cells);
-            }
             Expression::MinMax { ty: _, op: _, lhs, rhs } => {
                 $visitor(lhs);
                 $visitor(rhs);

internal/compiler/llr/lower_expression.rs

@@ -664,10 +664,34 @@ fn organize_grid_layout(
     ctx: &mut ExpressionLoweringCtx,
 ) -> llr_Expression {
     let cells = grid_layout_input_data(layout, ctx);
-    llr_Expression::ExtraBuiltinFunctionCall {
-        function: "organize_grid_layout".into(),
-        arguments: vec![cells],
-        return_ty: Type::Array(Type::Int32.into()),
+
+    if let Some(button_roles) = &layout.dialog_button_roles {
+        let e = crate::typeregister::BUILTIN.with(|e| e.enums.DialogButtonRole.clone());
+        let roles = button_roles
+            .iter()
+            .map(|r| {
+                llr_Expression::EnumerationValue(EnumerationValue {
+                    value: e.values.iter().position(|x| x == r).unwrap() as _,
+                    enumeration: e.clone(),
+                })
+            })
+            .collect();
+        let roles_expr = llr_Expression::Array {
+            element_ty: Type::Enumeration(e),
+            values: roles,
+            as_model: false,
+        };
+        llr_Expression::ExtraBuiltinFunctionCall {
+            function: "organize_dialog_button_layout".into(),
+            arguments: vec![cells, roles_expr],
+            return_ty: Type::Array(Type::Int32.into()),
+        }
+    } else {
+        llr_Expression::ExtraBuiltinFunctionCall {
+            function: "organize_grid_layout".into(),
+            arguments: vec![cells],
+            return_ty: Type::Array(Type::Int32.into()),
+        }
     }
 }
 
@@ -896,18 +920,6 @@ fn grid_layout_input_data(
     }
 }
 
-pub(super) fn grid_layout_cell_data_ty() -> Type {
-    Type::Struct(Rc::new(Struct {
-        fields: IntoIterator::into_iter([
-            (SmolStr::new_static("col_or_row"), Type::Int32),
-            (SmolStr::new_static("span"), Type::Int32),
-            (SmolStr::new_static("constraint"), crate::typeregister::layout_info_type().into()),
-        ])
-        .collect(),
-        name: BuiltinPrivateStruct::GridLayoutCellData.into(),
-    }))
-}
-
 pub(super) fn grid_layout_input_data_ty() -> Type {
     Type::Struct(Rc::new(Struct {
         fields: IntoIterator::into_iter([
@@ -919,7 +931,6 @@ pub(super) fn grid_layout_input_data_ty() -> Type {
         ])
         .collect(),
         name: BuiltinPrivateStruct::GridLayoutInputData.into(),
-        rust_attributes: None,
     }))
 }
 

internal/compiler/llr/optim_passes/inline_expressions.rs

@@ -67,7 +67,6 @@ fn expression_cost(exp: &Expression, ctx: &EvaluationContext) -> isize {
         Expression::EnumerationValue(_) => 0,
         Expression::LayoutCacheAccess { .. } => PROPERTY_ACCESS_COST,
         Expression::BoxLayoutFunction { .. } => return isize::MAX,
-        Expression::ComputeDialogLayoutCells { .. } => return isize::MAX,
         Expression::MinMax { .. } => 10,
         Expression::EmptyComponentFactory => 10,
         Expression::TranslationReference { .. } => PROPERTY_ACCESS_COST + 2 * ALLOC_COST,

internal/compiler/llr/pretty_print.rs

@@ -403,9 +403,6 @@ impl<'a, T> Display for DisplayExpression<'a, T> {
                 write!(f, "{}[{} % {}]", DisplayPropertyRef(layout_cache_prop, ctx), index, e(ri))
             }
             Expression::BoxLayoutFunction { .. } => write!(f, "BoxLayoutFunction(TODO)",),
-            Expression::ComputeDialogLayoutCells { .. } => {
-                write!(f, "ComputeDialogLayoutCells(TODO)",)
-            }
             Expression::MinMax { ty: _, op, lhs, rhs } => match op {
                 MinMaxOp::Min => write!(f, "min({}, {})", e(lhs), e(rhs)),
                 MinMaxOp::Max => write!(f, "max({}, {})", e(lhs), e(rhs)),

internal/compiler/typeregister.rs

@@ -153,7 +153,6 @@ impl BuiltinTypes {
                 ])
                 .collect(),
                 name: BuiltinPrivateStruct::GridLayoutInputData.into(),
-                rust_attributes: None,
             })),
         }
     }