1// Copyright © SixtyFPS GmbH <info@slint.dev>
2// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
3
4//! Passe that compute the layout constraint
5
6use lyon_path::geom::euclid::approxeq::ApproxEq;
7
8use crate::diagnostics::{BuildDiagnostics, DiagnosticLevel, Spanned};
9use crate::expression_tree::*;
10use crate::langtype::ElementType;
11use crate::langtype::Type;
12use crate::layout::*;
13use crate::object_tree::*;
14use crate::typeloader::TypeLoader;
15use crate::typeregister::{layout_info_type, TypeRegister};
16use smol_str::{format_smolstr, SmolStr};
17use std::cell::RefCell;
18use std::collections::HashSet;
19use std::rc::Rc;
20
21pub fn lower_layouts(
22 component: &Rc<Component>,
23 type_loader: &mut TypeLoader,
24 style_metrics: &Rc<Component>,
25 diag: &mut BuildDiagnostics,
26) {
27 // lower the preferred-{width, height}: 100%;
28 recurse_elem_including_sub_components(component, &(), &mut |elem, _| {
29 if check_preferred_size_100(elem, "preferred-width", diag) {
30 elem.borrow_mut().default_fill_parent.0 = true;
31 }
32 if check_preferred_size_100(elem, "preferred-height", diag) {
33 elem.borrow_mut().default_fill_parent.1 = true;
34 }
35 let base = elem.borrow().sub_component().cloned();
36 if let Some(base) = base {
37 let base = base.root_element.borrow();
38 let mut elem_mut = elem.borrow_mut();
39 elem_mut.default_fill_parent.0 |= base.default_fill_parent.0;
40 elem_mut.default_fill_parent.1 |= base.default_fill_parent.1;
41 }
42 });
43
44 *component.root_constraints.borrow_mut() =
45 LayoutConstraints::new(&component.root_element, diag, DiagnosticLevel::Error);
46
47 recurse_elem_including_sub_components(component, &(), &mut |elem, _| {
48 let component = elem.borrow().enclosing_component.upgrade().unwrap();
49 lower_element_layout(
50 &component,
51 elem,
52 &type_loader.global_type_registry.borrow(),
53 style_metrics,
54 diag,
55 );
56 check_no_layout_properties(elem, diag);
57 });
58}
59
60fn check_preferred_size_100(elem: &ElementRc, prop: &str, diag: &mut BuildDiagnostics) -> bool {
61 let ret: bool = if let Some(p: &RefCell) = elem.borrow().bindings.get(key:prop) {
62 if p.borrow().expression.ty() == Type::Percent {
63 if !matches!(p.borrow().expression.ignore_debug_hooks(), Expression::NumberLiteral(val, _) if *val == 100.)
64 {
65 diag.push_error(
66 message:format!("{prop} must either be a length, or the literal '100%'"),
67 &*p.borrow(),
68 );
69 }
70 true
71 } else {
72 false
73 }
74 } else {
75 false
76 };
77 if ret {
78 elem.borrow_mut().bindings.remove(key:prop).unwrap();
79 return true;
80 }
81 false
82}
83
84fn lower_element_layout(
85 component: &Rc<Component>,
86 elem: &ElementRc,
87 type_register: &TypeRegister,
88 style_metrics: &Rc<Component>,
89 diag: &mut BuildDiagnostics,
90) {
91 let base_type = if let ElementType::Builtin(base_type) = &elem.borrow().base_type {
92 base_type.clone()
93 } else {
94 return;
95 };
96 match base_type.name.as_str() {
97 "Row" => {
98 // We shouldn't lower layout if we have a Row in there. Unless the Row is the root of a repeated item,
99 // in which case another error has been reported
100 assert!(
101 diag.has_errors()
102 && Rc::ptr_eq(&component.root_element, elem)
103 && component
104 .parent_element
105 .upgrade()
106 .is_some_and(|e| e.borrow().repeated.is_some()),
107 "Error should have been caught at element lookup time"
108 );
109 return;
110 }
111 "GridLayout" => lower_grid_layout(component, elem, diag, type_register),
112 "HorizontalLayout" => lower_box_layout(elem, diag, Orientation::Horizontal),
113 "VerticalLayout" => lower_box_layout(elem, diag, Orientation::Vertical),
114 "Dialog" => {
115 lower_dialog_layout(elem, style_metrics, diag);
116 return; // the Dialog stays in the tree as a Dialog
117 }
118 _ => return,
119 };
120
121 {
122 let mut elem = elem.borrow_mut();
123 let elem = &mut *elem;
124 let prev_base = std::mem::replace(&mut elem.base_type, type_register.empty_type());
125 elem.default_fill_parent = (true, true);
126 // Create fake properties for the layout properties
127 for (p, ty) in prev_base.property_list() {
128 if !elem.base_type.lookup_property(&p).is_valid()
129 && !elem.property_declarations.contains_key(&p)
130 {
131 elem.property_declarations.insert(p, ty.into());
132 }
133 }
134 }
135}
136
137fn lower_grid_layout(
138 component: &Rc<Component>,
139 grid_layout_element: &ElementRc,
140 diag: &mut BuildDiagnostics,
141 type_register: &TypeRegister,
142) {
143 let mut grid = GridLayout {
144 elems: Default::default(),
145 geometry: LayoutGeometry::new(grid_layout_element),
146 dialog_button_roles: None,
147 };
148
149 let layout_cache_prop_h = create_new_prop(
150 grid_layout_element,
151 SmolStr::new_static("layout-cache-h"),
152 Type::LayoutCache,
153 );
154 let layout_cache_prop_v = create_new_prop(
155 grid_layout_element,
156 SmolStr::new_static("layout-cache-v"),
157 Type::LayoutCache,
158 );
159 let layout_info_prop_h = create_new_prop(
160 grid_layout_element,
161 SmolStr::new_static("layoutinfo-h"),
162 layout_info_type().into(),
163 );
164 let layout_info_prop_v = create_new_prop(
165 grid_layout_element,
166 SmolStr::new_static("layoutinfo-v"),
167 layout_info_type().into(),
168 );
169
170 let mut row = 0;
171 let mut col = 0;
172
173 let layout_children = std::mem::take(&mut grid_layout_element.borrow_mut().children);
174 let mut collected_children = Vec::new();
175 for layout_child in layout_children {
176 let is_row = if let ElementType::Builtin(be) = &layout_child.borrow().base_type {
177 be.name == "Row"
178 } else {
179 false
180 };
181 if is_row {
182 if col > 0 {
183 row += 1;
184 col = 0;
185 }
186 let row_children = std::mem::take(&mut layout_child.borrow_mut().children);
187 for x in row_children {
188 grid.add_element(
189 &x,
190 (&mut row, &mut col),
191 &layout_cache_prop_h,
192 &layout_cache_prop_v,
193 diag,
194 );
195 col += 1;
196 collected_children.push(x);
197 }
198 if col > 0 {
199 row += 1;
200 col = 0;
201 }
202 if layout_child.borrow().has_popup_child {
203 // We need to keep that element otherwise the popup will malfunction
204 layout_child.borrow_mut().base_type = type_register.empty_type();
205 collected_children.push(layout_child);
206 } else {
207 component.optimized_elements.borrow_mut().push(layout_child);
208 }
209 } else {
210 grid.add_element(
211 &layout_child,
212 (&mut row, &mut col),
213 &layout_cache_prop_h,
214 &layout_cache_prop_v,
215 diag,
216 );
217 col += 1;
218 collected_children.push(layout_child);
219 }
220 }
221 grid_layout_element.borrow_mut().children = collected_children;
222 let span = grid_layout_element.borrow().to_source_location();
223 layout_cache_prop_h.element().borrow_mut().bindings.insert(
224 layout_cache_prop_h.name().clone(),
225 BindingExpression::new_with_span(
226 Expression::SolveLayout(Layout::GridLayout(grid.clone()), Orientation::Horizontal),
227 span.clone(),
228 )
229 .into(),
230 );
231 layout_cache_prop_v.element().borrow_mut().bindings.insert(
232 layout_cache_prop_v.name().clone(),
233 BindingExpression::new_with_span(
234 Expression::SolveLayout(Layout::GridLayout(grid.clone()), Orientation::Vertical),
235 span.clone(),
236 )
237 .into(),
238 );
239 layout_info_prop_h.element().borrow_mut().bindings.insert(
240 layout_info_prop_h.name().clone(),
241 BindingExpression::new_with_span(
242 Expression::ComputeLayoutInfo(
243 Layout::GridLayout(grid.clone()),
244 Orientation::Horizontal,
245 ),
246 span.clone(),
247 )
248 .into(),
249 );
250 layout_info_prop_v.element().borrow_mut().bindings.insert(
251 layout_info_prop_v.name().clone(),
252 BindingExpression::new_with_span(
253 Expression::ComputeLayoutInfo(Layout::GridLayout(grid.clone()), Orientation::Vertical),
254 span,
255 )
256 .into(),
257 );
258 grid_layout_element.borrow_mut().layout_info_prop =
259 Some((layout_info_prop_h, layout_info_prop_v));
260 for d in grid_layout_element.borrow_mut().debug.iter_mut() {
261 d.layout = Some(Layout::GridLayout(grid.clone()));
262 }
263}
264
265impl GridLayout {
266 fn add_element(
267 &mut self,
268 item_element: &ElementRc,
269 (row, col): (&mut u16, &mut u16),
270 layout_cache_prop_h: &NamedReference,
271 layout_cache_prop_v: &NamedReference,
272 diag: &mut BuildDiagnostics,
273 ) {
274 let mut get_const_value = |name: &str| {
275 item_element
276 .borrow_mut()
277 .bindings
278 .remove(name)
279 .and_then(|e| eval_const_expr(&e.borrow().expression, name, &*e.borrow(), diag))
280 };
281 let colspan = get_const_value("colspan").unwrap_or(1);
282 let rowspan = get_const_value("rowspan").unwrap_or(1);
283 if let Some(r) = get_const_value("row") {
284 *row = r;
285 *col = 0;
286 }
287 if let Some(c) = get_const_value("col") {
288 *col = c;
289 }
290
291 self.add_element_with_coord(
292 item_element,
293 (*row, *col),
294 (rowspan, colspan),
295 layout_cache_prop_h,
296 layout_cache_prop_v,
297 diag,
298 )
299 }
300
301 fn add_element_with_coord(
302 &mut self,
303 item_element: &ElementRc,
304 (row, col): (u16, u16),
305 (rowspan, colspan): (u16, u16),
306 layout_cache_prop_h: &NamedReference,
307 layout_cache_prop_v: &NamedReference,
308 diag: &mut BuildDiagnostics,
309 ) {
310 let index = self.elems.len();
311 if let Some(layout_item) = create_layout_item(item_element, diag) {
312 if layout_item.repeater_index.is_some() {
313 diag.push_error(
314 "'if' or 'for' expressions are not currently supported in grid layouts"
315 .to_string(),
316 &*item_element.borrow(),
317 );
318 return;
319 }
320
321 let e = &layout_item.elem;
322 set_prop_from_cache(e, "x", layout_cache_prop_h, index * 2, &None, diag);
323 if !layout_item.item.constraints.fixed_width {
324 set_prop_from_cache(e, "width", layout_cache_prop_h, index * 2 + 1, &None, diag);
325 }
326 set_prop_from_cache(e, "y", layout_cache_prop_v, index * 2, &None, diag);
327 if !layout_item.item.constraints.fixed_height {
328 set_prop_from_cache(e, "height", layout_cache_prop_v, index * 2 + 1, &None, diag);
329 }
330
331 self.elems.push(GridLayoutElement {
332 col,
333 row,
334 colspan,
335 rowspan,
336 item: layout_item.item,
337 });
338 }
339 }
340}
341
342fn lower_box_layout(
343 layout_element: &ElementRc,
344 diag: &mut BuildDiagnostics,
345 orientation: Orientation,
346) {
347 let mut layout = BoxLayout {
348 orientation,
349 elems: Default::default(),
350 geometry: LayoutGeometry::new(layout_element),
351 };
352
353 let layout_cache_prop =
354 create_new_prop(layout_element, SmolStr::new_static("layout-cache"), Type::LayoutCache);
355 let layout_info_prop_v = create_new_prop(
356 layout_element,
357 SmolStr::new_static("layoutinfo-v"),
358 layout_info_type().into(),
359 );
360 let layout_info_prop_h = create_new_prop(
361 layout_element,
362 SmolStr::new_static("layoutinfo-h"),
363 layout_info_type().into(),
364 );
365
366 let layout_children = std::mem::take(&mut layout_element.borrow_mut().children);
367
368 let (begin_padding, end_padding) = match orientation {
369 Orientation::Horizontal => (&layout.geometry.padding.top, &layout.geometry.padding.bottom),
370 Orientation::Vertical => (&layout.geometry.padding.left, &layout.geometry.padding.right),
371 };
372 let (pos, size, pad, ortho) = match orientation {
373 Orientation::Horizontal => ("x", "width", "y", "height"),
374 Orientation::Vertical => ("y", "height", "x", "width"),
375 };
376 let pad_expr = begin_padding.clone().map(Expression::PropertyReference);
377 let mut size_expr = Expression::PropertyReference(NamedReference::new(
378 layout_element,
379 SmolStr::new_static(ortho),
380 ));
381 if let Some(p) = begin_padding {
382 size_expr = Expression::BinaryExpression {
383 lhs: Box::new(std::mem::take(&mut size_expr)),
384 rhs: Box::new(Expression::PropertyReference(p.clone())),
385 op: '-',
386 }
387 }
388 if let Some(p) = end_padding {
389 size_expr = Expression::BinaryExpression {
390 lhs: Box::new(std::mem::take(&mut size_expr)),
391 rhs: Box::new(Expression::PropertyReference(p.clone())),
392 op: '-',
393 }
394 }
395
396 for layout_child in &layout_children {
397 if let Some(item) = create_layout_item(layout_child, diag) {
398 let index = layout.elems.len() * 2;
399 let rep_idx = &item.repeater_index;
400 let (fixed_size, fixed_ortho) = match orientation {
401 Orientation::Horizontal => {
402 (item.item.constraints.fixed_width, item.item.constraints.fixed_height)
403 }
404 Orientation::Vertical => {
405 (item.item.constraints.fixed_height, item.item.constraints.fixed_width)
406 }
407 };
408 let actual_elem = &item.elem;
409 set_prop_from_cache(actual_elem, pos, &layout_cache_prop, index, rep_idx, diag);
410 if !fixed_size {
411 set_prop_from_cache(
412 actual_elem,
413 size,
414 &layout_cache_prop,
415 index + 1,
416 rep_idx,
417 diag,
418 );
419 }
420 if let Some(pad_expr) = pad_expr.clone() {
421 actual_elem.borrow_mut().bindings.insert(pad.into(), RefCell::new(pad_expr.into()));
422 }
423 if !fixed_ortho {
424 actual_elem
425 .borrow_mut()
426 .bindings
427 .insert(ortho.into(), RefCell::new(size_expr.clone().into()));
428 }
429 layout.elems.push(item.item);
430 }
431 }
432 layout_element.borrow_mut().children = layout_children;
433 let span = layout_element.borrow().to_source_location();
434 layout_cache_prop.element().borrow_mut().bindings.insert(
435 layout_cache_prop.name().clone(),
436 BindingExpression::new_with_span(
437 Expression::SolveLayout(Layout::BoxLayout(layout.clone()), orientation),
438 span.clone(),
439 )
440 .into(),
441 );
442 layout_info_prop_h.element().borrow_mut().bindings.insert(
443 layout_info_prop_h.name().clone(),
444 BindingExpression::new_with_span(
445 Expression::ComputeLayoutInfo(
446 Layout::BoxLayout(layout.clone()),
447 Orientation::Horizontal,
448 ),
449 span.clone(),
450 )
451 .into(),
452 );
453 layout_info_prop_v.element().borrow_mut().bindings.insert(
454 layout_info_prop_v.name().clone(),
455 BindingExpression::new_with_span(
456 Expression::ComputeLayoutInfo(Layout::BoxLayout(layout.clone()), Orientation::Vertical),
457 span,
458 )
459 .into(),
460 );
461 layout_element.borrow_mut().layout_info_prop = Some((layout_info_prop_h, layout_info_prop_v));
462 for d in layout_element.borrow_mut().debug.iter_mut() {
463 d.layout = Some(Layout::BoxLayout(layout.clone()));
464 }
465}
466
467fn lower_dialog_layout(
468 dialog_element: &ElementRc,
469 style_metrics: &Rc<Component>,
470 diag: &mut BuildDiagnostics,
471) {
472 let mut grid = GridLayout {
473 elems: Default::default(),
474 geometry: LayoutGeometry::new(dialog_element),
475 dialog_button_roles: None,
476 };
477 let metrics = &style_metrics.root_element;
478 grid.geometry
479 .padding
480 .bottom
481 .get_or_insert(NamedReference::new(metrics, SmolStr::new_static("layout-padding")));
482 grid.geometry
483 .padding
484 .top
485 .get_or_insert(NamedReference::new(metrics, SmolStr::new_static("layout-padding")));
486 grid.geometry
487 .padding
488 .left
489 .get_or_insert(NamedReference::new(metrics, SmolStr::new_static("layout-padding")));
490 grid.geometry
491 .padding
492 .right
493 .get_or_insert(NamedReference::new(metrics, SmolStr::new_static("layout-padding")));
494 grid.geometry
495 .spacing
496 .horizontal
497 .get_or_insert(NamedReference::new(metrics, SmolStr::new_static("layout-spacing")));
498 grid.geometry
499 .spacing
500 .vertical
501 .get_or_insert(NamedReference::new(metrics, SmolStr::new_static("layout-spacing")));
502
503 let layout_cache_prop_h =
504 create_new_prop(dialog_element, SmolStr::new_static("layout-cache-h"), Type::LayoutCache);
505 let layout_cache_prop_v =
506 create_new_prop(dialog_element, SmolStr::new_static("layout-cache-v"), Type::LayoutCache);
507 let layout_info_prop_h = create_new_prop(
508 dialog_element,
509 SmolStr::new_static("layoutinfo-h"),
510 layout_info_type().into(),
511 );
512 let layout_info_prop_v = create_new_prop(
513 dialog_element,
514 SmolStr::new_static("layoutinfo-v"),
515 layout_info_type().into(),
516 );
517
518 let mut main_widget = None;
519 let mut button_roles = vec![];
520 let mut seen_buttons = HashSet::new();
521 let layout_children = std::mem::take(&mut dialog_element.borrow_mut().children);
522 for layout_child in &layout_children {
523 let dialog_button_role_binding =
524 layout_child.borrow_mut().bindings.remove("dialog-button-role");
525 let is_button = if let Some(role_binding) = dialog_button_role_binding {
526 let role_binding = role_binding.into_inner();
527 if let Expression::EnumerationValue(val) =
528 super::ignore_debug_hooks(&role_binding.expression)
529 {
530 let en = &val.enumeration;
531 debug_assert_eq!(en.name, "DialogButtonRole");
532 button_roles.push(en.values[val.value].clone());
533 if val.value == 0 {
534 diag.push_error(
535 "The `dialog-button-role` cannot be set explicitly to none".into(),
536 &role_binding,
537 );
538 }
539 } else {
540 diag.push_error(
541 "The `dialog-button-role` property must be known at compile-time".into(),
542 &role_binding,
543 );
544 }
545 true
546 } else if matches!(&layout_child.borrow().lookup_property("kind").property_type, Type::Enumeration(e) if e.name == "StandardButtonKind")
547 {
548 // layout_child is a StandardButton
549 match layout_child.borrow().bindings.get("kind") {
550 None => diag.push_error(
551 "The `kind` property of the StandardButton in a Dialog must be set".into(),
552 &*layout_child.borrow(),
553 ),
554 Some(binding) => {
555 let binding = &*binding.borrow();
556 if let Expression::EnumerationValue(val) =
557 super::ignore_debug_hooks(&binding.expression)
558 {
559 let en = &val.enumeration;
560 debug_assert_eq!(en.name, "StandardButtonKind");
561 let kind = &en.values[val.value];
562 let role = match kind.as_str() {
563 "ok" => "accept",
564 "cancel" => "reject",
565 "apply" => "apply",
566 "close" => "reject",
567 "reset" => "reset",
568 "help" => "help",
569 "yes" => "accept",
570 "no" => "reject",
571 "abort" => "reject",
572 "retry" => "accept",
573 "ignore" => "accept",
574 _ => unreachable!(),
575 };
576 button_roles.push(role.into());
577 if !seen_buttons.insert(val.value) {
578 diag.push_error("Duplicated `kind`: There are two StandardButton in this Dialog with the same kind".into(), binding);
579 } else if Rc::ptr_eq(
580 dialog_element,
581 &dialog_element
582 .borrow()
583 .enclosing_component
584 .upgrade()
585 .unwrap()
586 .root_element,
587 ) {
588 let clicked_ty =
589 layout_child.borrow().lookup_property("clicked").property_type;
590 if matches!(&clicked_ty, Type::Callback { .. })
591 && layout_child.borrow().bindings.get("clicked").is_none_or(|c| {
592 matches!(c.borrow().expression, Expression::Invalid)
593 })
594 {
595 dialog_element
596 .borrow_mut()
597 .property_declarations
598 .entry(format_smolstr!("{}-clicked", kind))
599 .or_insert_with(|| PropertyDeclaration {
600 property_type: clicked_ty,
601 node: None,
602 expose_in_public_api: true,
603 is_alias: Some(NamedReference::new(
604 layout_child,
605 SmolStr::new_static("clicked"),
606 )),
607 visibility: PropertyVisibility::InOut,
608 pure: None,
609 });
610 }
611 }
612 } else {
613 diag.push_error(
614 "The `kind` property of the StandardButton in a Dialog must be known at compile-time"
615 .into(),
616 binding,
617 );
618 }
619 }
620 }
621 true
622 } else {
623 false
624 };
625
626 if is_button {
627 grid.add_element_with_coord(
628 layout_child,
629 (1, button_roles.len() as u16),
630 (1, 1),
631 &layout_cache_prop_h,
632 &layout_cache_prop_v,
633 diag,
634 );
635 } else if main_widget.is_some() {
636 diag.push_error(
637 "A Dialog can have only one child element that is not a StandardButton".into(),
638 &*layout_child.borrow(),
639 );
640 } else {
641 main_widget = Some(layout_child.clone())
642 }
643 }
644 dialog_element.borrow_mut().children = layout_children;
645
646 if let Some(main_widget) = main_widget {
647 grid.add_element_with_coord(
648 &main_widget,
649 (0, 0),
650 (1, button_roles.len() as u16 + 1),
651 &layout_cache_prop_h,
652 &layout_cache_prop_v,
653 diag,
654 );
655 } else {
656 diag.push_error(
657 "A Dialog must have a single child element that is not StandardButton".into(),
658 &*dialog_element.borrow(),
659 );
660 }
661 grid.dialog_button_roles = Some(button_roles);
662
663 let span = dialog_element.borrow().to_source_location();
664 layout_cache_prop_h.element().borrow_mut().bindings.insert(
665 layout_cache_prop_h.name().clone(),
666 BindingExpression::new_with_span(
667 Expression::SolveLayout(Layout::GridLayout(grid.clone()), Orientation::Horizontal),
668 span.clone(),
669 )
670 .into(),
671 );
672 layout_cache_prop_v.element().borrow_mut().bindings.insert(
673 layout_cache_prop_v.name().clone(),
674 BindingExpression::new_with_span(
675 Expression::SolveLayout(Layout::GridLayout(grid.clone()), Orientation::Vertical),
676 span.clone(),
677 )
678 .into(),
679 );
680 layout_info_prop_h.element().borrow_mut().bindings.insert(
681 layout_info_prop_h.name().clone(),
682 BindingExpression::new_with_span(
683 Expression::ComputeLayoutInfo(
684 Layout::GridLayout(grid.clone()),
685 Orientation::Horizontal,
686 ),
687 span.clone(),
688 )
689 .into(),
690 );
691 layout_info_prop_v.element().borrow_mut().bindings.insert(
692 layout_info_prop_v.name().clone(),
693 BindingExpression::new_with_span(
694 Expression::ComputeLayoutInfo(Layout::GridLayout(grid.clone()), Orientation::Vertical),
695 span,
696 )
697 .into(),
698 );
699 dialog_element.borrow_mut().layout_info_prop = Some((layout_info_prop_h, layout_info_prop_v));
700 for d in dialog_element.borrow_mut().debug.iter_mut() {
701 d.layout = Some(Layout::GridLayout(grid.clone()));
702 }
703}
704
705struct CreateLayoutItemResult {
706 item: LayoutItem,
707 elem: ElementRc,
708 repeater_index: Option<Expression>,
709}
710
711/// Create a LayoutItem for the given `item_element` returns None is the layout is empty
712fn create_layout_item(
713 item_element: &ElementRc,
714 diag: &mut BuildDiagnostics,
715) -> Option<CreateLayoutItemResult> {
716 let fix_explicit_percent = |prop: &str, item: &ElementRc| {
717 if !item.borrow().bindings.get(prop).is_some_and(|b| b.borrow().ty() == Type::Percent) {
718 return;
719 }
720 let min_name = format_smolstr!("min-{}", prop);
721 let max_name = format_smolstr!("max-{}", prop);
722 let mut min_ref = BindingExpression::from(Expression::PropertyReference(
723 NamedReference::new(item, min_name.clone()),
724 ));
725 let mut item = item.borrow_mut();
726 let b = item.bindings.remove(prop).unwrap().into_inner();
727 min_ref.span = b.span.clone();
728 min_ref.priority = b.priority;
729 item.bindings.insert(max_name.clone(), min_ref.into());
730 item.bindings.insert(min_name.clone(), b.into());
731 item.property_declarations.insert(
732 min_name,
733 PropertyDeclaration { property_type: Type::Percent, ..PropertyDeclaration::default() },
734 );
735 item.property_declarations.insert(
736 max_name,
737 PropertyDeclaration { property_type: Type::Percent, ..PropertyDeclaration::default() },
738 );
739 };
740 fix_explicit_percent("width", item_element);
741 fix_explicit_percent("height", item_element);
742
743 item_element.borrow_mut().child_of_layout = true;
744 let (repeater_index, actual_elem) = if let Some(r) = &item_element.borrow().repeated {
745 let rep_comp = item_element.borrow().base_type.as_component().clone();
746 fix_explicit_percent("width", &rep_comp.root_element);
747 fix_explicit_percent("height", &rep_comp.root_element);
748
749 *rep_comp.root_constraints.borrow_mut() =
750 LayoutConstraints::new(&rep_comp.root_element, diag, DiagnosticLevel::Error);
751 rep_comp.root_element.borrow_mut().child_of_layout = true;
752 (
753 Some(if r.is_conditional_element {
754 Expression::NumberLiteral(0., Unit::None)
755 } else {
756 Expression::RepeaterIndexReference { element: Rc::downgrade(item_element) }
757 }),
758 rep_comp.root_element.clone(),
759 )
760 } else {
761 (None, item_element.clone())
762 };
763
764 let constraints = LayoutConstraints::new(&actual_elem, diag, DiagnosticLevel::Error);
765 Some(CreateLayoutItemResult {
766 item: LayoutItem { element: item_element.clone(), constraints },
767 elem: actual_elem,
768 repeater_index,
769 })
770}
771
772fn set_prop_from_cache(
773 elem: &ElementRc,
774 prop: &str,
775 layout_cache_prop: &NamedReference,
776 index: usize,
777 repeater_index: &Option<Expression>,
778 diag: &mut BuildDiagnostics,
779) {
780 let old: Option> = elem.borrow_mut().bindings.insert(
781 key:prop.into(),
782 value:BindingExpression::new_with_span(
783 Expression::LayoutCacheAccess {
784 layout_cache_prop: layout_cache_prop.clone(),
785 index,
786 repeater_index: repeater_index.as_ref().map(|x| Box::new(x.clone())),
787 },
788 span:layout_cache_prop.element().borrow().to_source_location(),
789 )
790 .into(),
791 );
792 if let Some(old: BindingExpression) = old.map(RefCell::into_inner) {
793 diag.push_error(
794 message:format!("The property '{prop}' cannot be set for elements placed in this layout, because the layout is already setting it"),
795 &old,
796 );
797 }
798}
799
800fn eval_const_expr(
801 expression: &Expression,
802 name: &str,
803 span: &dyn crate::diagnostics::Spanned,
804 diag: &mut BuildDiagnostics,
805) -> Option<u16> {
806 match super::ignore_debug_hooks(expr:expression) {
807 Expression::NumberLiteral(v: &f64, Unit::None) => {
808 if *v < 0. || *v > u16::MAX as f64 || !v.trunc().approx_eq(v) {
809 diag.push_error(message:format!("'{name}' must be a positive integer"), source:span);
810 None
811 } else {
812 Some(*v as u16)
813 }
814 }
815 Expression::Cast { from: &Box, .. } => eval_const_expr(expression:from, name, span, diag),
816 _ => {
817 diag.push_error(message:format!("'{name}' must be an integer literal"), source:span);
818 None
819 }
820 }
821}
822
823/// Checks that there is grid-layout specific properties left
824fn check_no_layout_properties(item: &ElementRc, diag: &mut BuildDiagnostics) {
825 for (prop: &SmolStr, expr: &RefCell) in item.borrow().bindings.iter() {
826 if matches!(prop.as_ref(), "col" | "row" | "colspan" | "rowspan") {
827 diag.push_error(message:format!("{prop} used outside of a GridLayout"), &*expr.borrow());
828 }
829 if matches!(prop.as_ref(), "dialog-button-role") {
830 diag.push_error(message:format!("{prop} used outside of a Dialog"), &*expr.borrow());
831 }
832 }
833}
834
835/// For fixed layout, we need to dissociate the width and the height property of the WindowItem from width and height property
836/// in slint such that the width and height property are actually constants.
837///
838/// The Slint runtime will change the width and height property of the native WindowItem to match those of the actual
839/// window, but we don't want that to happen if we have a fixed layout.
840pub fn check_window_layout(component: &Rc<Component>) {
841 if component.root_constraints.borrow().fixed_height {
842 adjust_window_layout(component, prop:"height");
843 }
844 if component.root_constraints.borrow().fixed_width {
845 adjust_window_layout(component, prop:"width");
846 }
847}
848
849fn adjust_window_layout(component: &Rc<Component>, prop: &'static str) {
850 let new_prop = crate::layout::create_new_prop(
851 &component.root_element,
852 format_smolstr!("fixed-{prop}"),
853 Type::LogicalLength,
854 );
855 {
856 let mut root = component.root_element.borrow_mut();
857 if let Some(b) = root.bindings.remove(prop) {
858 root.bindings.insert(new_prop.name().clone(), b);
859 };
860 let mut analysis = root.property_analysis.borrow_mut();
861 if let Some(a) = analysis.remove(prop) {
862 analysis.insert(new_prop.name().clone(), a);
863 };
864 drop(analysis);
865 root.bindings.insert(
866 prop.into(),
867 RefCell::new(Expression::PropertyReference(new_prop.clone()).into()),
868 );
869 }
870
871 let old_prop = NamedReference::new(&component.root_element, SmolStr::new_static(prop));
872 crate::object_tree::visit_all_named_references(component, &mut |nr| {
873 if nr == &old_prop {
874 *nr = new_prop.clone()
875 }
876 });
877}
878