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

@@ -3555,23 +3555,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

@@ -2711,21 +2711,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

@@ -184,15 +184,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,
@@ -320,9 +311,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,
@@ -406,10 +394,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

@@ -667,10 +667,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()),
+        }
     }
 }
 
@@ -899,20 +923,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: Some("GridLayoutCellData".into()),
-        node: None,
-        rust_attributes: None,
-    }))
-}
-
 pub(super) fn grid_layout_input_data_ty() -> Type {
     Type::Struct(Rc::new(Struct {
         fields: IntoIterator::into_iter([

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

@@ -362,9 +362,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)),