Files
qbz/crates/vendor/i-slint-core-1.16.1/layout.rs
T
vicrodh 7401d2c3fd fix(text): always draw the first line under overflow: elide
Vendor i-slint-core 1.16.1 with a one-rule patch in sharedparley's
line culling: with overflow: elide, every line whose bottom edge
exceeded max_height was dropped — INCLUDING the first one, eliding the
text to literally nothing. CJK fallback fonts report line metrics
taller than snug fixed-height boxes (Hiragino at 14px measures ~21px
inside TrackRow's 20px title line), so on macOS every CJK track title
rendered blank while Latin titles fit; Linux survived because Noto's
metrics fit the box. Root-caused with a headless render matrix on the
Mac Mini: the verbatim TrackRow structure reproduced the blank title,
removing elide rendered it, and the patched core renders all variants.
The first line still receives the ellipsis treatment as the last
visible line.

This is the real #543 mechanism. The earlier femtovg render_glyph
retry (3a1c367d) addressed a different, hypothesized layer and stays
as harmless defense in depth.

Fixes #543

cc
2026-07-05 18:53:02 -06:00

2772 lines
106 KiB
Rust

// Copyright © SixtyFPS GmbH <info@slint.dev>
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
//! Runtime support for layouts.
// cspell:ignore coord
use crate::items::{
DialogButtonRole, FlexboxLayoutAlignContent, FlexboxLayoutAlignItems, FlexboxLayoutAlignSelf,
FlexboxLayoutDirection, FlexboxLayoutWrap, LayoutAlignment,
};
use crate::{Coord, SharedVector, slice::Slice};
use alloc::format;
use alloc::string::String;
use alloc::vec::Vec;
use num_traits::Float;
pub use crate::items::Orientation;
/// The constraint that applies to a layout
// Also, the field needs to be in alphabetical order because how the generated code sort fields for struct
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct LayoutInfo {
/// The maximum size for the item.
pub max: Coord,
/// The maximum size in percentage of the parent (value between 0 and 100).
pub max_percent: Coord,
/// The minimum size for this item.
pub min: Coord,
/// The minimum size in percentage of the parent (value between 0 and 100).
pub min_percent: Coord,
/// the preferred size
pub preferred: Coord,
/// the stretch factor
pub stretch: f32,
}
impl Default for LayoutInfo {
fn default() -> Self {
LayoutInfo {
min: 0 as _,
max: Coord::MAX,
min_percent: 0 as _,
max_percent: 100 as _,
preferred: 0 as _,
stretch: 0 as _,
}
}
}
impl LayoutInfo {
// Note: This "logic" is duplicated in the cpp generator's generated code for merging layout infos.
#[must_use]
pub fn merge(&self, other: &LayoutInfo) -> Self {
Self {
min: self.min.max(other.min),
max: self.max.min(other.max),
min_percent: self.min_percent.max(other.min_percent),
max_percent: self.max_percent.min(other.max_percent),
preferred: self.preferred.max(other.preferred),
stretch: self.stretch.min(other.stretch),
}
}
/// Helper function to return a preferred size which is within the min/max constraints
#[must_use]
pub fn preferred_bounded(&self) -> Coord {
self.preferred.min(self.max).max(self.min)
}
}
impl core::ops::Add for LayoutInfo {
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
self.merge(&rhs)
}
}
/// Returns the logical min and max sizes given the provided layout constraints.
pub fn min_max_size_for_layout_constraints(
constraints_horizontal: LayoutInfo,
constraints_vertical: LayoutInfo,
) -> (Option<crate::api::LogicalSize>, Option<crate::api::LogicalSize>) {
let min_width = constraints_horizontal.min.min(constraints_horizontal.max) as f32;
let min_height = constraints_vertical.min.min(constraints_vertical.max) as f32;
let max_width = constraints_horizontal.max.max(constraints_horizontal.min) as f32;
let max_height = constraints_vertical.max.max(constraints_vertical.min) as f32;
//cfg!(target_arch = "wasm32") is there because wasm32 winit don't like when max size is None:
// panicked at 'Property is read only: JsValue(NoModificationAllowedError: CSSStyleDeclaration.removeProperty: Can't remove property 'max-width' from computed style
let min_size = if min_width > 0. || min_height > 0. || cfg!(target_arch = "wasm32") {
Some(crate::api::LogicalSize::new(min_width, min_height))
} else {
None
};
let max_size = if (max_width > 0.
&& max_height > 0.
&& (max_width < i32::MAX as f32 || max_height < i32::MAX as f32))
|| cfg!(target_arch = "wasm32")
{
// maximum widget size for Qt and a workaround for the winit api not allowing partial constraints
let window_size_max = 16_777_215.;
Some(crate::api::LogicalSize::new(
max_width.min(window_size_max),
max_height.min(window_size_max),
))
} else {
None
};
(min_size, max_size)
}
/// Implement a saturating_add version for both possible value of Coord.
/// So that adding the max value does not overflow
trait Saturating {
fn add(_: Self, _: Self) -> Self;
}
impl Saturating for i32 {
#[inline]
fn add(a: Self, b: Self) -> Self {
a.saturating_add(b)
}
}
impl Saturating for f32 {
#[inline]
fn add(a: Self, b: Self) -> Self {
a + b
}
}
mod grid_internal {
use super::*;
fn order_coord<T: PartialOrd>(a: &T, b: &T) -> core::cmp::Ordering {
a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal)
}
#[derive(Debug, Clone)]
pub struct LayoutData {
// inputs
pub min: Coord,
pub max: Coord,
pub pref: Coord,
pub stretch: f32,
// outputs
pub pos: Coord,
pub size: Coord,
}
impl Default for LayoutData {
fn default() -> Self {
LayoutData {
min: 0 as _,
max: Coord::MAX,
pref: 0 as _,
stretch: f32::MAX,
pos: 0 as _,
size: 0 as _,
}
}
}
trait Adjust {
fn can_grow(_: &LayoutData) -> Coord;
fn to_distribute(expected_size: Coord, current_size: Coord) -> Coord;
fn distribute(_: &mut LayoutData, val: Coord);
}
struct Grow;
impl Adjust for Grow {
fn can_grow(it: &LayoutData) -> Coord {
it.max - it.size
}
fn to_distribute(expected_size: Coord, current_size: Coord) -> Coord {
expected_size - current_size
}
fn distribute(it: &mut LayoutData, val: Coord) {
it.size += val;
}
}
struct Shrink;
impl Adjust for Shrink {
fn can_grow(it: &LayoutData) -> Coord {
it.size - it.min
}
fn to_distribute(expected_size: Coord, current_size: Coord) -> Coord {
current_size - expected_size
}
fn distribute(it: &mut LayoutData, val: Coord) {
it.size -= val;
}
}
#[allow(clippy::unnecessary_cast)] // Coord
fn adjust_items<A: Adjust>(data: &mut [LayoutData], size_without_spacing: Coord) -> Option<()> {
loop {
let size_cannot_grow: Coord = data
.iter()
.filter(|it| A::can_grow(it) <= 0 as _)
.map(|it| it.size)
.fold(0 as Coord, Saturating::add);
let total_stretch: f32 =
data.iter().filter(|it| A::can_grow(it) > 0 as _).map(|it| it.stretch).sum();
let actual_stretch = |s: f32| if total_stretch <= 0. { 1. } else { s };
let max_grow = data
.iter()
.filter(|it| A::can_grow(it) > 0 as _)
.map(|it| A::can_grow(it) as f32 / actual_stretch(it.stretch))
.min_by(order_coord)?;
let current_size: Coord = data
.iter()
.filter(|it| A::can_grow(it) > 0 as _)
.map(|it| it.size)
.fold(0 as _, Saturating::add);
//let to_distribute = size_without_spacing - (size_cannot_grow + current_size);
let to_distribute =
A::to_distribute(size_without_spacing, size_cannot_grow + current_size) as f32;
if to_distribute <= 0. || max_grow <= 0. {
return Some(());
}
let grow = if total_stretch <= 0. {
to_distribute
/ (data.iter().filter(|it| A::can_grow(it) > 0 as _).count() as Coord) as f32
} else {
to_distribute / total_stretch
}
.min(max_grow);
let mut distributed = 0 as Coord;
for it in data.iter_mut().filter(|it| A::can_grow(it) > 0 as Coord) {
let val = (grow * actual_stretch(it.stretch)) as Coord;
A::distribute(it, val);
distributed += val;
}
if distributed <= 0 as Coord {
// This can happen when Coord is integer and there is less then a pixel to add to each elements
// just give the pixel to the one with the bigger stretch
if let Some(it) = data
.iter_mut()
.filter(|it| A::can_grow(it) > 0 as _)
.max_by(|a, b| actual_stretch(a.stretch).total_cmp(&b.stretch))
{
A::distribute(it, to_distribute as Coord);
}
return Some(());
}
}
}
pub fn layout_items(data: &mut [LayoutData], start_pos: Coord, size: Coord, spacing: Coord) {
let size_without_spacing = size - spacing * (data.len() - 1) as Coord;
let mut pref = 0 as Coord;
for it in data.iter_mut() {
it.size = it.pref;
pref += it.pref;
}
if size_without_spacing >= pref {
adjust_items::<Grow>(data, size_without_spacing);
} else if size_without_spacing < pref {
adjust_items::<Shrink>(data, size_without_spacing);
}
let mut pos = start_pos;
for it in data.iter_mut() {
it.pos = pos;
pos = Saturating::add(pos, Saturating::add(it.size, spacing));
}
}
#[test]
#[allow(clippy::float_cmp)] // We want bit-wise equality here
fn test_layout_items() {
let my_items = &mut [
LayoutData { min: 100., max: 200., pref: 100., stretch: 1., ..Default::default() },
LayoutData { min: 50., max: 300., pref: 100., stretch: 1., ..Default::default() },
LayoutData { min: 50., max: 150., pref: 100., stretch: 1., ..Default::default() },
];
layout_items(my_items, 100., 650., 0.);
assert_eq!(my_items[0].size, 200.);
assert_eq!(my_items[1].size, 300.);
assert_eq!(my_items[2].size, 150.);
layout_items(my_items, 100., 200., 0.);
assert_eq!(my_items[0].size, 100.);
assert_eq!(my_items[1].size, 50.);
assert_eq!(my_items[2].size, 50.);
layout_items(my_items, 100., 300., 0.);
assert_eq!(my_items[0].size, 100.);
assert_eq!(my_items[1].size, 100.);
assert_eq!(my_items[2].size, 100.);
}
/// Create a vector of LayoutData (e.g. one per row if Vertical) based on the constraints and organized data
/// Used by both solve_grid_layout() and grid_layout_info()
pub fn to_layout_data(
organized_data: &GridLayoutOrganizedData,
constraints: Slice<LayoutItemInfo>,
orientation: Orientation,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
spacing: Coord,
size: Option<Coord>,
) -> Vec<LayoutData> {
assert!(organized_data.len().is_multiple_of(4));
let num = organized_data.max_value(
constraints.len(),
orientation,
&repeater_indices,
&repeater_steps,
) as usize;
if num < 1 {
return Default::default();
}
let marker_for_empty = -1.;
let mut layout_data = alloc::vec![grid_internal::LayoutData { max: 0 as Coord, stretch: marker_for_empty, ..Default::default() }; num];
let mut has_spans = false;
for (idx, cell_data) in constraints.iter().enumerate() {
let constraint = &cell_data.constraint;
let mut max = constraint.max;
if let Some(size) = size {
max = max.min(size * constraint.max_percent / 100 as Coord);
}
let (col_or_row, span) = organized_data.col_or_row_and_span(
idx,
orientation,
&repeater_indices,
&repeater_steps,
);
for c in 0..(span as usize) {
let cdata = &mut layout_data[col_or_row as usize + c];
// Initialize max/stretch to proper defaults on first item in this row/col
// so that empty rows/columns don't stretch.
if cdata.stretch == marker_for_empty {
cdata.max = Coord::MAX;
cdata.stretch = 1.;
}
cdata.max = cdata.max.min(max);
}
if span == 1 {
let mut min = constraint.min;
if let Some(size) = size {
min = min.max(size * constraint.min_percent / 100 as Coord);
}
let pref = constraint.preferred.min(max).max(min);
let cdata = &mut layout_data[col_or_row as usize];
cdata.min = cdata.min.max(min);
cdata.pref = cdata.pref.max(pref);
cdata.stretch = cdata.stretch.min(constraint.stretch);
} else {
has_spans = true;
}
}
if has_spans {
for (idx, cell_data) in constraints.iter().enumerate() {
let constraint = &cell_data.constraint;
let (col_or_row, span) = organized_data.col_or_row_and_span(
idx,
orientation,
&repeater_indices,
&repeater_steps,
);
if span > 1 {
let span_data =
&mut layout_data[(col_or_row as usize)..(col_or_row + span) as usize];
// Adjust minimum sizes
let mut min = constraint.min;
if let Some(size) = size {
min = min.max(size * constraint.min_percent / 100 as Coord);
}
grid_internal::layout_items(span_data, 0 as _, min, spacing);
for cdata in span_data.iter_mut() {
if cdata.min < cdata.size {
cdata.min = cdata.size;
}
}
// Adjust maximum sizes
let mut max = constraint.max;
if let Some(size) = size {
max = max.min(size * constraint.max_percent / 100 as Coord);
}
grid_internal::layout_items(span_data, 0 as _, max, spacing);
for cdata in span_data.iter_mut() {
if cdata.max > cdata.size {
cdata.max = cdata.size;
}
}
// Adjust preferred sizes
grid_internal::layout_items(span_data, 0 as _, constraint.preferred, spacing);
for cdata in span_data.iter_mut() {
cdata.pref = cdata.pref.max(cdata.size).min(cdata.max).max(cdata.min);
}
// Adjust stretches
let total_stretch: f32 = span_data.iter().map(|c| c.stretch).sum();
if total_stretch > constraint.stretch {
for cdata in span_data.iter_mut() {
cdata.stretch *= constraint.stretch / total_stretch;
}
}
}
}
}
for cdata in layout_data.iter_mut() {
if cdata.stretch == marker_for_empty {
cdata.stretch = 0.;
}
}
layout_data
}
}
#[repr(C)]
pub struct Constraint {
pub min: Coord,
pub max: Coord,
}
impl Default for Constraint {
fn default() -> Self {
Constraint { min: 0 as Coord, max: Coord::MAX }
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug, Default)]
pub struct Padding {
pub begin: Coord,
pub end: Coord,
}
#[repr(C)]
#[derive(Debug)]
/// The horizontal or vertical data for all cells of a GridLayout, used as input to solve_grid_layout()
pub struct GridLayoutData {
pub size: Coord,
pub spacing: Coord,
pub padding: Padding,
pub organized_data: GridLayoutOrganizedData,
}
/// The input data for a cell of a GridLayout, before row/col determination and before H/V split
/// Used as input to organize_grid_layout()
#[repr(C)]
#[derive(Debug, Clone)]
pub struct GridLayoutInputData {
/// whether this cell is the first one in a Row element
pub new_row: bool,
/// col and row number.
/// Only ROW_COL_AUTO and the u16 range are valid, values outside of
/// that will be clamped with a warning at runtime
pub col: f32,
pub row: f32,
/// colspan and rowspan
/// Only the u16 range is valid, values outside of that will be clamped with a warning at runtime
pub colspan: f32,
pub rowspan: f32,
}
impl Default for GridLayoutInputData {
fn default() -> Self {
Self {
new_row: false,
col: i_slint_common::ROW_COL_AUTO,
row: i_slint_common::ROW_COL_AUTO,
colspan: 1.0,
rowspan: 1.0,
}
}
}
/// The organized layout data for a GridLayout, after row/col determination:
/// For each cell, stores col, colspan, row, rowspan
pub type GridLayoutOrganizedData = SharedVector<u16>;
impl GridLayoutOrganizedData {
fn push_cell(&mut self, col: u16, colspan: u16, row: u16, rowspan: u16) {
self.push(col);
self.push(colspan);
self.push(row);
self.push(rowspan);
}
fn col_or_row_and_span(
&self,
cell_number: usize,
orientation: Orientation,
repeater_indices: &Slice<u32>,
repeater_steps: &Slice<u32>,
) -> (u16, u16) {
// For every cell, we have 4 entries, each at their own index
// But we also need to take into account indirections for repeated items
// Two-level indirection for repeated items:
// jump_pos = (ri_start_cell - cell_nr_adj) * 4
// data_base = self[jump_pos] (base of this repeater's data)
// stride = self[jump_pos + 1] (u16 entries per row = step * 4)
// data_idx = data_base + row_in_rep * stride + col_in_rep * 4
let mut final_idx = 0;
let mut cell_nr_adj = 0i32; // needs to be signed in case we start with an empty repeater
let cell_number = cell_number as i32;
// repeater_indices is a list of (start_cell, count) pairs
for rep_idx in 0..(repeater_indices.len() / 2) {
let ri_start_cell = repeater_indices[rep_idx * 2] as i32;
if cell_number < ri_start_cell {
break;
}
let ri_cell_count = repeater_indices[rep_idx * 2 + 1] as i32;
let step = repeater_steps.get(rep_idx).copied().unwrap_or(1) as i32;
let cells_in_repeater = ri_cell_count * step;
if cells_in_repeater > 0
&& cell_number >= ri_start_cell
&& cell_number < ri_start_cell + cells_in_repeater
{
let cell_in_rep = cell_number - ri_start_cell;
let row_in_rep = cell_in_rep / step;
let col_in_rep = cell_in_rep % step;
let jump_pos = (ri_start_cell - cell_nr_adj) as usize * 4;
let data_base = self[jump_pos] as usize;
let stride = self[jump_pos + 1] as usize;
final_idx = data_base + row_in_rep as usize * stride + col_in_rep as usize * 4;
break;
}
// Each repeater occupies 1 jump cell in the static area but cells_in_repeater cells logically
// Note: -1 is correct for an empty repeater (e.g. if false), which occupies 1 jump cell, for 0 real cells
cell_nr_adj += cells_in_repeater - 1;
}
if final_idx == 0 {
final_idx = ((cell_number - cell_nr_adj) * 4) as usize;
}
let offset = if orientation == Orientation::Horizontal { 0 } else { 2 };
(self[final_idx + offset], self[final_idx + offset + 1])
}
fn max_value(
&self,
num_cells: usize,
orientation: Orientation,
repeater_indices: &Slice<u32>,
repeater_steps: &Slice<u32>,
) -> u16 {
let mut max = 0;
// This could be rewritten more efficiently to avoid a loop calling a loop, by keeping track of the repeaters we saw until now
// Not sure it's worth the complexity though
for idx in 0..num_cells {
let (col_or_row, span) =
self.col_or_row_and_span(idx, orientation, repeater_indices, repeater_steps);
max = max.max(col_or_row + span.max(1));
}
max
}
}
/// Two-level indirection organized data generator for grid layouts with repeaters.
/// Uses 2-level indirection: cache[cache[jump_pos] + ri * stride + col * 4]
/// Each jump cell stores [data_base, stride, 0, 0] where stride = step * 4.
///
/// Layout: [static_cells (4 u16 each)] [jump_cells (4 u16 each, 1 per repeater)]
/// [row_data (rep_count * step * 4 u16)] ... (repeated for each repeater)
struct OrganizedDataGenerator<'a> {
// Input
repeater_indices: &'a [u32],
repeater_steps: &'a [u32],
// An always increasing counter, the index of the cell being added
counter: usize,
// The u16 position in result for the next repeater's data section
repeat_u16_offset: usize,
// The index/2 in repeater_indices (i.e. which repeater we're looking at next)
next_rep: usize,
// The cell index in result for the next non-repeated item (each cell = 4 u16)
current_offset: usize,
// Output
result: &'a mut GridLayoutOrganizedData,
}
impl<'a> OrganizedDataGenerator<'a> {
fn new(
repeater_indices: &'a [u32],
repeater_steps: &'a [u32],
static_cells: usize,
num_repeaters: usize,
total_repeated_cells_count: usize,
result: &'a mut GridLayoutOrganizedData,
) -> Self {
result.resize((static_cells + num_repeaters + total_repeated_cells_count) * 4, 0 as _);
let repeat_u16_offset = (static_cells + num_repeaters) * 4;
Self {
repeater_indices,
repeater_steps,
counter: 0,
repeat_u16_offset,
next_rep: 0,
current_offset: 0,
result,
}
}
fn add(&mut self, col: u16, colspan: u16, row: u16, rowspan: u16) {
let res = self.result.make_mut_slice();
loop {
if let Some(nr) = self.repeater_indices.get(self.next_rep * 2) {
let nr = *nr as usize;
let step = self.repeater_steps.get(self.next_rep).copied().unwrap_or(1) as usize;
let rep_count = self.repeater_indices[self.next_rep * 2 + 1] as usize;
if nr == self.counter {
// First cell of this repeater
let data_u16_start = self.repeat_u16_offset;
let stride = step * 4;
// Write jump cell: [data_base, stride, 0, 0]
res[self.current_offset * 4] = data_u16_start as _;
res[self.current_offset * 4 + 1] = stride as _;
self.current_offset += 1;
}
if self.counter >= nr {
let cells_in_repeater = rep_count * step;
if self.counter - nr == cells_in_repeater {
// Past the end of this repeater — advance past data
self.repeat_u16_offset += cells_in_repeater * 4;
self.next_rep += 1;
continue;
}
// Write data at the position determined by row/col within repeater
let cell_in_rep = self.counter - nr;
let row_in_rep = cell_in_rep / step;
let col_in_rep = cell_in_rep % step;
let data_u16_start = self.repeat_u16_offset;
let u16_pos = data_u16_start + row_in_rep * step * 4 + col_in_rep * 4;
res[u16_pos] = col;
res[u16_pos + 1] = colspan;
res[u16_pos + 2] = row;
res[u16_pos + 3] = rowspan;
self.counter += 1;
return;
}
}
// Non-repeated cell
res[self.current_offset * 4] = col;
res[self.current_offset * 4 + 1] = colspan;
res[self.current_offset * 4 + 2] = row;
res[self.current_offset * 4 + 3] = rowspan;
self.current_offset += 1;
self.counter += 1;
return;
}
}
}
/// Given the cells of a layout of a Dialog, re-order the buttons according to the platform
/// This function assume that the `roles` contains the roles of the button which are the first cells in `input_data`
pub fn organize_dialog_button_layout(
input_data: Slice<GridLayoutInputData>,
dialog_button_roles: Slice<DialogButtonRole>,
) -> GridLayoutOrganizedData {
let mut organized_data = GridLayoutOrganizedData::default();
organized_data.reserve(input_data.len() * 4);
#[cfg(feature = "std")]
fn is_kde() -> bool {
// assume some Unix, check if XDG_CURRENT_DESKTOP starts with K
std::env::var("XDG_CURRENT_DESKTOP")
.ok()
.and_then(|v| v.as_bytes().first().copied())
.is_some_and(|x| x.eq_ignore_ascii_case(&b'K'))
}
#[cfg(not(feature = "std"))]
let is_kde = || true;
let expected_order: &[DialogButtonRole] = match crate::detect_operating_system() {
crate::items::OperatingSystemType::Windows => {
&[
DialogButtonRole::Reset,
DialogButtonRole::None, // spacer
DialogButtonRole::Accept,
DialogButtonRole::Action,
DialogButtonRole::Reject,
DialogButtonRole::Apply,
DialogButtonRole::Help,
]
}
crate::items::OperatingSystemType::Macos | crate::items::OperatingSystemType::Ios => {
&[
DialogButtonRole::Help,
DialogButtonRole::Reset,
DialogButtonRole::Apply,
DialogButtonRole::Action,
DialogButtonRole::None, // spacer
DialogButtonRole::Reject,
DialogButtonRole::Accept,
]
}
_ if is_kde() => {
// KDE variant
&[
DialogButtonRole::Help,
DialogButtonRole::Reset,
DialogButtonRole::None, // spacer
DialogButtonRole::Action,
DialogButtonRole::Accept,
DialogButtonRole::Apply,
DialogButtonRole::Reject,
]
}
_ => {
// GNOME variant and fallback for WASM build
&[
DialogButtonRole::Help,
DialogButtonRole::Reset,
DialogButtonRole::None, // spacer
DialogButtonRole::Action,
DialogButtonRole::Accept,
DialogButtonRole::Apply,
DialogButtonRole::Reject,
]
}
};
// Reorder the actual buttons according to expected_order
let mut column_for_input: Vec<usize> = Vec::with_capacity(dialog_button_roles.len());
for role in expected_order.iter() {
if role == &DialogButtonRole::None {
column_for_input.push(usize::MAX); // empty column, ensure nothing will match
continue;
}
for (idx, r) in dialog_button_roles.as_slice().iter().enumerate() {
if *r == *role {
column_for_input.push(idx);
}
}
}
for (input_index, cell) in input_data.as_slice().iter().enumerate() {
let col = column_for_input.iter().position(|&x| x == input_index);
if let Some(col) = col {
organized_data.push_cell(col as _, cell.colspan as _, cell.row as _, cell.rowspan as _);
} else {
// This is used for the main window (which is the only cell which isn't a button)
// Given lower_dialog_layout(), this will always be a single cell at 0,0 with a colspan of number_of_buttons
organized_data.push_cell(
cell.col as _,
cell.colspan as _,
cell.row as _,
cell.rowspan as _,
);
}
}
organized_data
}
// GridLayout-specific
fn total_repeated_cells<'a>(repeater_indices: &'a [u32], repeater_steps: &'a [u32]) -> usize {
repeater_indices
.chunks(2)
.enumerate()
.map(|(i, chunk)| {
let count = chunk.get(1).copied().unwrap_or(0) as usize;
let step = repeater_steps.get(i).copied().unwrap_or(1) as usize;
count * step
})
.sum()
}
type Errors = Vec<String>;
pub fn organize_grid_layout(
input_data: Slice<GridLayoutInputData>,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
) -> GridLayoutOrganizedData {
let (organized_data, errors) =
organize_grid_layout_impl(input_data, repeater_indices, repeater_steps);
for error in errors {
crate::debug_log!("Slint layout error: {}", error);
}
organized_data
}
// Implement "auto" behavior for row/col numbers (unless specified in the slint file).
fn organize_grid_layout_impl(
input_data: Slice<GridLayoutInputData>,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
) -> (GridLayoutOrganizedData, Errors) {
let mut organized_data = GridLayoutOrganizedData::default();
// Cache size: static_cells * 4 + num_repeaters * 4 (jump cells)
// + per repeater: rep_count * step * 4 (data)
let num_repeaters = repeater_indices.len() / 2;
let total_repeated_cells =
total_repeated_cells(repeater_indices.as_slice(), repeater_steps.as_slice());
let static_cells = input_data.len() - total_repeated_cells;
let mut generator = OrganizedDataGenerator::new(
repeater_indices.as_slice(),
repeater_steps.as_slice(),
static_cells,
num_repeaters,
total_repeated_cells,
&mut organized_data,
);
let mut errors = Vec::new();
fn clamp_to_u16(value: f32, field_name: &str, errors: &mut Vec<String>) -> u16 {
if value < 0.0 {
errors.push(format!("cell {field_name} {value} is negative, clamping to 0"));
0
} else if value > u16::MAX as f32 {
errors
.push(format!("cell {field_name} {value} is too large, clamping to {}", u16::MAX));
u16::MAX
} else {
value as u16
}
}
let mut row = 0;
let mut col = 0;
let mut first = true;
for cell in input_data.as_slice().iter() {
if cell.new_row && !first {
row += 1;
col = 0;
}
first = false;
if cell.row != i_slint_common::ROW_COL_AUTO {
let cell_row = clamp_to_u16(cell.row, "row", &mut errors);
if row != cell_row {
row = cell_row;
col = 0;
}
}
if cell.col != i_slint_common::ROW_COL_AUTO {
col = clamp_to_u16(cell.col, "col", &mut errors);
}
let colspan = clamp_to_u16(cell.colspan, "colspan", &mut errors);
let rowspan = clamp_to_u16(cell.rowspan, "rowspan", &mut errors);
col = col.min(u16::MAX - colspan); // ensure col + colspan doesn't overflow
generator.add(col, colspan, row, rowspan);
col += colspan;
}
(organized_data, errors)
}
/// Layout cache generator for box layouts.
/// The layout cache generator inserts the pos and size into the result array (which becomes the layout cache property),
/// including the indirections for repeated items (so that the x,y,width,height properties for repeated items
/// can point to indices known at compile time, those that contain the indirections)
/// Example: for repeater_indices=[1,4] (meaning that item at index 1 is repeated 4 times),
/// result=[0.0, 80.0, 4.0, 5.0, 80.0, 80.0, 160.0, 80.0, 240.0, 80.0, 320.0, 80.0]
/// i.e. pos1, width1, jump to idx 4, jump to idx 5, pos2, width2, pos3, width3, pos4, width4, pos5, width5
struct LayoutCacheGenerator<'a> {
// Input
repeater_indices: &'a [u32],
// An always increasing counter, the index of the cell being added
counter: usize,
// The index/2 in result in which we should add the next repeated item
repeat_offset: usize,
// The index/2 in repeater_indices
next_rep: usize,
// The index/2 in result in which we should add the next non-repeated item
current_offset: usize,
// Output
result: &'a mut SharedVector<Coord>,
}
impl<'a> LayoutCacheGenerator<'a> {
fn new(repeater_indices: &'a [u32], result: &'a mut SharedVector<Coord>) -> Self {
let total_repeated_cells: usize = repeater_indices
.chunks(2)
.map(|chunk| chunk.get(1).copied().unwrap_or(0) as usize)
.sum();
assert!(result.len() >= total_repeated_cells * 2);
let repeat_offset = result.len() / 2 - total_repeated_cells;
Self { repeater_indices, counter: 0, repeat_offset, next_rep: 0, current_offset: 0, result }
}
fn add(&mut self, pos: Coord, size: Coord) {
let res = self.result.make_mut_slice();
let o = loop {
if let Some(nr) = self.repeater_indices.get(self.next_rep * 2) {
let nr = *nr as usize;
if nr == self.counter {
// Write jump entry
for o in 0..2 {
res[self.current_offset * 2 + o] = (self.repeat_offset * 2 + o) as _;
}
self.current_offset += 1;
}
if self.counter >= nr {
let rep_count = self.repeater_indices[self.next_rep * 2 + 1] as usize;
if self.counter - nr == rep_count {
self.repeat_offset += rep_count;
self.next_rep += 1;
continue;
}
let offset = self.repeat_offset + (self.counter - nr);
break offset;
}
}
self.current_offset += 1;
break self.current_offset - 1;
};
res[o * 2] = pos;
res[o * 2 + 1] = size;
self.counter += 1;
}
}
/// Two-level indirection layout cache generator for grid layouts with repeaters.
/// Uses 2-level indirection: cache[cache[jump] + ri * stride + child_offset]
/// Each jump cell stores [data_base, stride] where stride = step * 2.
struct GridLayoutCacheGenerator<'a> {
// Input
repeater_indices: &'a [u32],
repeater_steps: &'a [u32],
// An always increasing counter, the index of the cell being added
counter: usize,
// The f32 position in result for the next repeater's dynamic data section
repeat_f32_offset: usize,
// The index/2 in repeater_indices
next_rep: usize,
// The cell index (index/2) in result for the next non-repeated item
current_offset: usize,
// Output
result: &'a mut SharedVector<Coord>,
}
impl<'a> GridLayoutCacheGenerator<'a> {
fn new(
repeater_indices: &'a [u32],
repeater_steps: &'a [u32],
static_cells: usize,
num_repeaters: usize,
total_repeated_cells_count: usize,
result: &'a mut SharedVector<Coord>,
) -> Self {
result.resize((static_cells + num_repeaters + total_repeated_cells_count) * 2, 0 as _);
let repeat_f32_offset = (static_cells + num_repeaters) * 2;
Self {
repeater_indices,
repeater_steps,
counter: 0,
repeat_f32_offset,
next_rep: 0,
current_offset: 0,
result,
}
}
fn add(&mut self, pos: Coord, size: Coord) {
let res = self.result.make_mut_slice();
loop {
if let Some(nr) = self.repeater_indices.get(self.next_rep * 2) {
let nr = *nr as usize;
let step = self.repeater_steps.get(self.next_rep).copied().unwrap_or(1) as usize;
let rep_count = self.repeater_indices[self.next_rep * 2 + 1] as usize;
if nr == self.counter {
// First cell of this repeater
let data_f32_start = self.repeat_f32_offset;
let stride = step * 2;
// Write 1 jump cell (2 f32): [data_base, stride]
res[self.current_offset * 2] = data_f32_start as _;
res[self.current_offset * 2 + 1] = stride as _;
self.current_offset += 1;
}
if self.counter >= nr {
let cells_in_repeater = rep_count * step;
if self.counter - nr == cells_in_repeater {
// Past the end of this repeater — advance past data
self.repeat_f32_offset += cells_in_repeater * 2;
self.next_rep += 1;
continue;
}
// Write data at the position determined by row/col within repeater
let cell_in_rep = self.counter - nr;
let row_in_rep = cell_in_rep / step;
let col_in_rep = cell_in_rep % step;
let data_f32_start = self.repeat_f32_offset;
let f32_pos = data_f32_start + row_in_rep * step * 2 + col_in_rep * 2;
res[f32_pos] = pos;
res[f32_pos + 1] = size;
self.counter += 1;
return;
}
}
// Non-repeated cell
res[self.current_offset * 2] = pos;
res[self.current_offset * 2 + 1] = size;
self.current_offset += 1;
self.counter += 1;
return;
}
}
}
/// return, an array which is of size `data.cells.len() * 2` which for each cell stores:
/// pos (x or y), size (width or height)
pub fn solve_grid_layout(
data: &GridLayoutData,
constraints: Slice<LayoutItemInfo>,
orientation: Orientation,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
) -> SharedVector<Coord> {
let mut layout_data = grid_internal::to_layout_data(
&data.organized_data,
constraints,
orientation,
repeater_indices,
repeater_steps,
data.spacing,
Some(data.size),
);
if layout_data.is_empty() {
return Default::default();
}
grid_internal::layout_items(
&mut layout_data,
data.padding.begin,
data.size - (data.padding.begin + data.padding.end),
data.spacing,
);
let mut result = SharedVector::<Coord>::default();
let num_repeaters = repeater_indices.len() / 2;
let total_repeated_cells =
total_repeated_cells(repeater_indices.as_slice(), repeater_steps.as_slice());
let static_cells = constraints.len() - total_repeated_cells;
let mut generator = GridLayoutCacheGenerator::new(
repeater_indices.as_slice(),
repeater_steps.as_slice(),
static_cells,
num_repeaters,
total_repeated_cells,
&mut result,
);
for idx in 0..constraints.len() {
let (col_or_row, span) = data.organized_data.col_or_row_and_span(
idx,
orientation,
&repeater_indices,
&repeater_steps,
);
let cdata = &layout_data[col_or_row as usize];
let size = if span > 0 {
let last_cell = &layout_data[col_or_row as usize + span as usize - 1];
last_cell.pos + last_cell.size - cdata.pos
} else {
0 as Coord
};
generator.add(cdata.pos, size);
}
result
}
pub fn grid_layout_info(
organized_data: GridLayoutOrganizedData, // not & because the code generator doesn't support it in ExtraBuiltinFunctionCall
constraints: Slice<LayoutItemInfo>,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
spacing: Coord,
padding: &Padding,
orientation: Orientation,
) -> LayoutInfo {
let layout_data = grid_internal::to_layout_data(
&organized_data,
constraints,
orientation,
repeater_indices,
repeater_steps,
spacing,
None,
);
if layout_data.is_empty() {
let mut info = LayoutInfo::default();
info.min = padding.begin + padding.end;
info.preferred = info.min;
info.max = info.min;
return info;
}
let spacing_w = spacing * (layout_data.len() - 1) as Coord + padding.begin + padding.end;
let min = layout_data.iter().map(|data| data.min).sum::<Coord>() + spacing_w;
let max = layout_data.iter().map(|data| data.max).fold(spacing_w, Saturating::add);
let preferred = layout_data.iter().map(|data| data.pref).sum::<Coord>() + spacing_w;
let stretch = layout_data.iter().map(|data| data.stretch).sum::<f32>();
LayoutInfo { min, max, min_percent: 0 as _, max_percent: 100 as _, preferred, stretch }
}
#[repr(C)]
#[derive(Debug)]
/// The BoxLayoutData is used to represent both a Horizontal and Vertical layout.
/// The width/height x/y correspond to that of a horizontal layout.
/// For vertical layout, they are inverted
pub struct BoxLayoutData<'a> {
pub size: Coord,
pub spacing: Coord,
pub padding: Padding,
pub alignment: LayoutAlignment,
pub cells: Slice<'a, LayoutItemInfo>,
}
#[repr(C)]
#[derive(Debug)]
/// The FlexboxLayoutData is used for a flex layout.
pub struct FlexboxLayoutData<'a> {
pub width: Coord,
pub height: Coord,
pub spacing_h: Coord,
pub spacing_v: Coord,
pub padding_h: Padding,
pub padding_v: Padding,
pub alignment: LayoutAlignment,
pub direction: FlexboxLayoutDirection,
pub align_content: FlexboxLayoutAlignContent,
pub align_items: FlexboxLayoutAlignItems,
pub flex_wrap: FlexboxLayoutWrap,
/// Horizontal constraints (width) for each cell
pub cells_h: Slice<'a, FlexboxLayoutItemInfo>,
/// Vertical constraints (height) for each cell
pub cells_v: Slice<'a, FlexboxLayoutItemInfo>,
}
#[repr(C)]
#[derive(Debug, Clone, Default)]
/// The information about a single item in a box or grid layout
pub struct LayoutItemInfo {
pub constraint: LayoutInfo,
}
#[repr(C)]
#[derive(Debug, Clone)]
/// The information about a single item in a flexbox layout
pub struct FlexboxLayoutItemInfo {
pub constraint: LayoutInfo,
/// Flex grow factor (0 = don't grow, default)
pub flex_grow: f32,
/// Flex shrink factor (0 = don't shrink, default)
pub flex_shrink: f32,
/// Flex basis in logical pixels (-1 = auto, meaning use preferred size; default)
pub flex_basis: Coord,
/// Per-item cross-axis alignment override (Auto = use container's align-items)
pub flex_align_self: FlexboxLayoutAlignSelf,
/// Visual ordering of flex items (lower values appear first, default 0)
pub flex_order: i32,
}
impl Default for FlexboxLayoutItemInfo {
fn default() -> Self {
Self {
constraint: LayoutInfo::default(),
flex_grow: 0.0,
flex_shrink: 1.0,
flex_basis: -1 as _,
flex_align_self: FlexboxLayoutAlignSelf::Auto,
flex_order: 0,
}
}
}
impl From<LayoutItemInfo> for FlexboxLayoutItemInfo {
fn from(info: LayoutItemInfo) -> Self {
Self { constraint: info.constraint, ..Default::default() }
}
}
/// Solve a BoxLayout
pub fn solve_box_layout(data: &BoxLayoutData, repeater_indices: Slice<u32>) -> SharedVector<Coord> {
let mut result = SharedVector::<Coord>::default();
// One element results into two coordinates in the result vector. 1. Position, 2. Size
result.resize(data.cells.len() * 2 + repeater_indices.len(), 0 as _);
if data.cells.is_empty() {
return result;
}
let size_without_padding = data.size - data.padding.begin - data.padding.end;
let num_spacings = (data.cells.len() - 1) as Coord;
let spacings = data.spacing * num_spacings;
let content_size = size_without_padding - spacings; // The size the cells can occupy without going outside of the layout
let mut layout_data: Vec<_> = data
.cells
.iter()
.map(|c| {
let min = c.constraint.min.max(c.constraint.min_percent * content_size / 100 as Coord);
let max = c.constraint.max.min(c.constraint.max_percent * content_size / 100 as Coord);
grid_internal::LayoutData {
min,
max,
pref: c.constraint.preferred.min(max).max(min),
stretch: c.constraint.stretch,
..Default::default()
}
})
.collect();
let pref_size: Coord = layout_data.iter().map(|it| it.pref).sum();
let align = match data.alignment {
LayoutAlignment::Stretch => {
grid_internal::layout_items(
&mut layout_data,
data.padding.begin,
size_without_padding,
data.spacing,
);
None
}
_ if size_without_padding <= pref_size + spacings => {
grid_internal::layout_items(
&mut layout_data,
data.padding.begin,
size_without_padding,
data.spacing,
);
None
}
LayoutAlignment::Center => Some((
data.padding.begin + (size_without_padding - pref_size - spacings) / 2 as Coord,
data.spacing,
)),
LayoutAlignment::Start => Some((data.padding.begin, data.spacing)),
LayoutAlignment::End => {
Some((data.padding.begin + (size_without_padding - pref_size - spacings), data.spacing))
}
LayoutAlignment::SpaceBetween => {
Some((data.padding.begin, (size_without_padding - pref_size) / num_spacings))
}
LayoutAlignment::SpaceAround => {
let spacing = (size_without_padding - pref_size) / (num_spacings + 1 as Coord);
Some((data.padding.begin + spacing / 2 as Coord, spacing))
}
LayoutAlignment::SpaceEvenly => {
let spacing = (size_without_padding - pref_size) / (num_spacings + 2 as Coord);
Some((data.padding.begin + spacing, spacing))
}
};
if let Some((mut pos, spacing)) = align {
for it in &mut layout_data {
it.pos = pos;
it.size = it.pref;
pos += spacing + it.size;
}
}
let mut generator = LayoutCacheGenerator::new(&repeater_indices, &mut result);
for layout in layout_data.iter() {
generator.add(layout.pos, layout.size);
}
result
}
/// Return the LayoutInfo for a BoxLayout with the given cells.
pub fn box_layout_info(
cells: Slice<LayoutItemInfo>,
spacing: Coord,
padding: &Padding,
alignment: LayoutAlignment,
) -> LayoutInfo {
let count = cells.len();
let is_stretch = alignment == LayoutAlignment::Stretch;
if count < 1 {
let mut info = LayoutInfo::default();
info.min = padding.begin + padding.end;
info.preferred = info.min;
if is_stretch {
info.max = info.min;
}
return info;
};
let extra_w = padding.begin + padding.end + spacing * (count - 1) as Coord;
let min = cells.iter().map(|c| c.constraint.min).sum::<Coord>() + extra_w; // Minimum size of the complete layout
let max = if is_stretch {
(cells.iter().map(|c| c.constraint.max).fold(extra_w, Saturating::add)).max(min)
} else {
Coord::MAX
}; // Maximum size of the complete layout
let preferred = cells.iter().map(|c| c.constraint.preferred_bounded()).sum::<Coord>() + extra_w;
let stretch = cells.iter().map(|c| c.constraint.stretch).sum::<f32>();
LayoutInfo { min, max, min_percent: 0 as _, max_percent: 100 as _, preferred, stretch }
}
pub fn box_layout_info_ortho(cells: Slice<LayoutItemInfo>, padding: &Padding) -> LayoutInfo {
let extra_w = padding.begin + padding.end;
let mut fold =
cells.iter().fold(LayoutInfo { stretch: f32::MAX, ..Default::default() }, |a, b| {
a.merge(&b.constraint)
});
fold.max = fold.max.max(fold.min);
fold.preferred = fold.preferred.clamp(fold.min, fold.max);
fold.min += extra_w;
fold.max = Saturating::add(fold.max, extra_w);
fold.preferred += extra_w;
fold
}
/// Helper module for taffy-based flexbox layout
mod flexbox_taffy {
use super::{
Coord, FlexboxLayoutAlignContent, FlexboxLayoutAlignItems, FlexboxLayoutAlignSelf,
FlexboxLayoutItemInfo, FlexboxLayoutWrap as SlintFlexboxLayoutWrap, LayoutAlignment,
Padding, Slice,
};
use alloc::vec::Vec;
pub use taffy::prelude::FlexDirection as TaffyFlexDirection;
use taffy::prelude::*;
/// Parameters for FlexboxTaffyBuilder::new
pub struct FlexboxLayoutParams<'a> {
pub cells_h: &'a Slice<'a, FlexboxLayoutItemInfo>,
pub cells_v: &'a Slice<'a, FlexboxLayoutItemInfo>,
pub spacing_h: Coord,
pub spacing_v: Coord,
pub padding_h: &'a Padding,
pub padding_v: &'a Padding,
pub alignment: LayoutAlignment,
pub align_content: FlexboxLayoutAlignContent,
pub align_items: FlexboxLayoutAlignItems,
pub flex_wrap: SlintFlexboxLayoutWrap,
pub flex_direction: TaffyFlexDirection,
pub container_width: Option<Coord>,
pub container_height: Option<Coord>,
/// When true, set the cross-axis dimension to `auto` for all items
/// so that the measure callback can compute it dynamically (height-for-width).
pub use_measure_for_cross_axis: bool,
}
/// Build a taffy tree from Slint layout constraints.
/// The NodeContext (usize) stores the original child index for measure callbacks.
pub struct FlexboxTaffyBuilder {
pub taffy: TaffyTree<usize>,
pub children: Vec<NodeId>,
pub container: NodeId,
/// Maps taffy child position -> original cell index (empty if no reordering needed)
pub order_map: Vec<usize>,
}
impl FlexboxTaffyBuilder {
/// Create a new flexbox layout tree from item constraints
pub fn new(params: FlexboxLayoutParams) -> Self {
let mut taffy = TaffyTree::<usize>::new();
// Create child nodes from Slint constraints
let mut children: Vec<NodeId> = params
.cells_h
.iter()
.enumerate()
.map(|(idx, cell_h)| {
let cell_v = params.cells_v.get(idx);
let h_constraint = &cell_h.constraint;
let v_constraint = cell_v.map(|c| &c.constraint);
// Use preferred_bounded() which clamps preferred to min/max bounds
let preferred_width = h_constraint.preferred_bounded();
let preferred_height =
v_constraint.map(|vc| vc.preferred_bounded()).unwrap_or(0 as Coord);
// flex_basis: use explicit value if set (>= 0), otherwise use preferred size
let flex_basis = if cell_h.flex_basis >= 0 as Coord {
Dimension::length(cell_h.flex_basis as _)
} else {
match params.flex_direction {
TaffyFlexDirection::Row | TaffyFlexDirection::RowReverse => {
Dimension::length(preferred_width as _)
}
TaffyFlexDirection::Column | TaffyFlexDirection::ColumnReverse => {
Dimension::length(preferred_height as _)
}
}
};
taffy
.new_leaf_with_context(
Style {
flex_basis,
size: Size {
width: match params.flex_direction {
TaffyFlexDirection::Column
| TaffyFlexDirection::ColumnReverse => {
if let Some(cw) = params.container_width {
Dimension::length(cw as _)
} else if preferred_width > 0 as Coord {
Dimension::length(preferred_width as _)
} else {
Dimension::auto()
}
}
_ => Dimension::auto(),
},
height: match params.flex_direction {
TaffyFlexDirection::Row
| TaffyFlexDirection::RowReverse => {
// Cross-axis for row: use auto when measure
// callback will compute it dynamically
if params.use_measure_for_cross_axis {
Dimension::auto()
} else if preferred_height > 0 as Coord {
Dimension::length(preferred_height as _)
} else {
Dimension::auto()
}
}
_ => Dimension::auto(),
},
},
min_size: Size {
width: Dimension::length(h_constraint.min as _),
height: Dimension::length(
v_constraint.map(|vc| vc.min as f32).unwrap_or(0.0),
),
},
max_size: Size {
width: if h_constraint.max < Coord::MAX {
Dimension::length(h_constraint.max as _)
} else {
Dimension::auto()
},
height: if let Some(vc) = v_constraint {
if vc.max < Coord::MAX {
Dimension::length(vc.max as _)
} else {
Dimension::auto()
}
} else {
Dimension::auto()
},
},
flex_grow: cell_h.flex_grow,
flex_shrink: cell_h.flex_shrink,
align_self: match cell_h.flex_align_self {
FlexboxLayoutAlignSelf::Auto => None,
FlexboxLayoutAlignSelf::Stretch => Some(AlignSelf::Stretch),
FlexboxLayoutAlignSelf::Start => Some(AlignSelf::FlexStart),
FlexboxLayoutAlignSelf::End => Some(AlignSelf::FlexEnd),
FlexboxLayoutAlignSelf::Center => Some(AlignSelf::Center),
},
..Default::default()
},
idx,
)
.unwrap() // cannot fail
})
.collect();
// Sort children by CSS `order` property if any item has a non-zero order.
// Build a mapping from sorted position -> original index.
let has_order = params.cells_h.iter().any(|c| c.flex_order != 0);
let order_map: Vec<usize> = if has_order {
let mut indices: Vec<usize> = (0..children.len()).collect();
// sort_by_key is a stable sort, as required by CSS
indices.sort_by_key(|&i| params.cells_h.get(i).map_or(0, |c| c.flex_order));
let sorted_children: Vec<NodeId> = indices.iter().map(|&i| children[i]).collect();
children = sorted_children;
indices
} else {
Vec::new()
};
// Create container node
let container = taffy
.new_with_children(
Style {
display: Display::Flex,
flex_direction: params.flex_direction,
flex_wrap: match params.flex_wrap {
SlintFlexboxLayoutWrap::Wrap => FlexWrap::Wrap,
SlintFlexboxLayoutWrap::NoWrap => FlexWrap::NoWrap,
SlintFlexboxLayoutWrap::WrapReverse => FlexWrap::WrapReverse,
},
justify_content: Some(match params.alignment {
// Start/End map to FlexStart/FlexEnd to respect flex direction (including reverse)
// AlignContent::Start/End would ignore direction and always use writing mode
LayoutAlignment::Start => AlignContent::FlexStart,
LayoutAlignment::End => AlignContent::FlexEnd,
LayoutAlignment::Center => AlignContent::Center,
LayoutAlignment::Stretch => AlignContent::Stretch,
LayoutAlignment::SpaceBetween => AlignContent::SpaceBetween,
LayoutAlignment::SpaceAround => AlignContent::SpaceAround,
LayoutAlignment::SpaceEvenly => AlignContent::SpaceEvenly,
}),
align_items: Some(match params.align_items {
FlexboxLayoutAlignItems::Stretch => AlignItems::Stretch,
FlexboxLayoutAlignItems::Start => AlignItems::FlexStart,
FlexboxLayoutAlignItems::End => AlignItems::FlexEnd,
FlexboxLayoutAlignItems::Center => AlignItems::Center,
}),
align_content: Some(match params.align_content {
FlexboxLayoutAlignContent::Stretch => AlignContent::Stretch,
FlexboxLayoutAlignContent::Start => AlignContent::FlexStart,
FlexboxLayoutAlignContent::End => AlignContent::FlexEnd,
FlexboxLayoutAlignContent::Center => AlignContent::Center,
FlexboxLayoutAlignContent::SpaceBetween => AlignContent::SpaceBetween,
FlexboxLayoutAlignContent::SpaceAround => AlignContent::SpaceAround,
FlexboxLayoutAlignContent::SpaceEvenly => AlignContent::SpaceEvenly,
}),
gap: Size {
width: LengthPercentage::length(params.spacing_h as _),
height: LengthPercentage::length(params.spacing_v as _),
},
padding: Rect {
left: LengthPercentage::length(params.padding_h.begin as _),
right: LengthPercentage::length(params.padding_h.end as _),
top: LengthPercentage::length(params.padding_v.begin as _),
bottom: LengthPercentage::length(params.padding_v.end as _),
},
size: Size {
width: params
.container_width
.map(|w| Dimension::length(w as _))
.unwrap_or(Dimension::auto()),
height: params
.container_height
.map(|h| Dimension::length(h as _))
.unwrap_or(Dimension::auto()),
},
..Default::default()
},
&children,
)
.unwrap(); // cannot fail
Self { taffy, children, container, order_map }
}
/// Compute the layout with the given available space.
///
/// The optional `measure` callback is called by taffy for leaf nodes
/// that need dynamic height-for-width (or width-for-height) measurement.
/// It receives `(child_index, known_width, known_height)` where `known_width`
/// / `known_height` are `Some` if taffy has already determined that dimension,
/// and returns `(width, height)`.
pub fn compute_layout(
&mut self,
available_width: Coord,
available_height: Coord,
mut measure: Option<
&mut dyn FnMut(usize, Option<Coord>, Option<Coord>) -> (Coord, Coord),
>,
) {
let available_space = taffy::prelude::Size {
width: if available_width < Coord::MAX {
AvailableSpace::Definite(available_width as _)
} else {
AvailableSpace::MaxContent
},
height: if available_height < Coord::MAX {
AvailableSpace::Definite(available_height as _)
} else {
AvailableSpace::MaxContent
},
};
self.taffy
.compute_layout_with_measure(
self.container,
available_space,
|known_dimensions, _available_space, _node_id, node_context, _style| {
if let (Some(measure), Some(&mut child_index)) =
(measure.as_deref_mut(), node_context)
{
let known_w = known_dimensions.width.map(|w| w as Coord);
let known_h = known_dimensions.height.map(|h| h as Coord);
let (w, h) = measure(child_index, known_w, known_h);
taffy::prelude::Size { width: w as f32, height: h as f32 }
} else {
taffy::prelude::Size::ZERO
}
},
)
.unwrap_or_else(|e| {
crate::debug_log!("FlexboxLayout computation error: {}", e);
});
}
/// Get the computed container size
pub fn container_size(&self) -> (Coord, Coord) {
let layout = self.taffy.layout(self.container).unwrap();
(layout.size.width as Coord, layout.size.height as Coord)
}
/// Get the geometry for a specific child
pub fn child_geometry(&self, idx: usize) -> (Coord, Coord, Coord, Coord) {
let layout = self.taffy.layout(self.children[idx]).unwrap();
(
layout.location.x as Coord,
layout.location.y as Coord,
layout.size.width as Coord,
layout.size.height as Coord,
)
}
/// Map a taffy child index to the original cell index (accounting for `order` sorting).
pub fn original_index(&self, taffy_idx: usize) -> usize {
if self.order_map.is_empty() { taffy_idx } else { self.order_map[taffy_idx] }
}
}
}
/// A cache generator for FlexboxLayout that handles 4 values per item (x, y, width, height)
struct FlexboxLayoutCacheGenerator<'a> {
// Input
repeater_indices: &'a [u32],
// An always increasing counter, the index of the cell being added
counter: usize,
// The index/4 in result in which we should add the next repeated item
repeat_offset: usize,
// The index/4 in repeater_indices
next_rep: usize,
// The index/4 in result in which we should add the next non-repeated item
current_offset: usize,
// Output
result: &'a mut SharedVector<Coord>,
}
impl<'a> FlexboxLayoutCacheGenerator<'a> {
fn new(repeater_indices: &'a [u32], result: &'a mut SharedVector<Coord>) -> Self {
// Calculate total repeated cells (count for each repeater)
let total_repeated_cells: usize = repeater_indices
.chunks(2)
.map(|chunk| chunk.get(1).copied().unwrap_or(0) as usize)
.sum();
assert!(result.len() >= total_repeated_cells * 4);
let repeat_offset = result.len() / 4 - total_repeated_cells;
Self { repeater_indices, counter: 0, repeat_offset, next_rep: 0, current_offset: 0, result }
}
fn add(&mut self, x: Coord, y: Coord, w: Coord, h: Coord) {
let res = self.result.make_mut_slice();
let o = loop {
if let Some(nr) = self.repeater_indices.get(self.next_rep * 2) {
let nr = *nr as usize;
if nr == self.counter {
// Write jump entries for repeater start
// Store the base offset (index into the repeated data region)
res[self.current_offset * 4] = (self.repeat_offset * 4) as Coord;
res[self.current_offset * 4 + 1] = (self.repeat_offset * 4 + 1) as Coord;
res[self.current_offset * 4 + 2] = (self.repeat_offset * 4 + 2) as Coord;
res[self.current_offset * 4 + 3] = (self.repeat_offset * 4 + 3) as Coord;
self.current_offset += 1;
}
if self.counter >= nr {
let rep_count = self.repeater_indices[self.next_rep * 2 + 1] as usize;
if self.counter - nr == rep_count {
// Advance repeat_offset past this repeater's data before moving to next
self.repeat_offset += rep_count;
self.next_rep += 1;
continue;
}
// Calculate offset into repeated data
let cell_in_rep = self.counter - nr;
let offset = self.repeat_offset + cell_in_rep;
break offset;
}
}
self.current_offset += 1;
break self.current_offset - 1;
};
res[o * 4] = x;
res[o * 4 + 1] = y;
res[o * 4 + 2] = w;
res[o * 4 + 3] = h;
self.counter += 1;
}
}
/// Measure callback for height-for-width items in a FlexboxLayout.
///
/// Called by taffy during the flex solve for items that need dynamic sizing.
/// Receives `(child_index, known_width, known_height)` where `known_width`/`known_height`
/// are `Some` if taffy has already determined that dimension.
/// Returns `(width, height)`.
pub type FlexboxMeasureFn<'a> =
Option<&'a mut dyn FnMut(usize, Option<Coord>, Option<Coord>) -> (Coord, Coord)>;
pub fn solve_flexbox_layout(
data: &FlexboxLayoutData,
repeater_indices: Slice<u32>,
) -> SharedVector<Coord> {
// Build a simple measure callback from the pre-computed cells data.
// This enables height-for-width: taffy calls back with the actual
// assigned width, and we return the pre-computed height from cells_v.
// The cells_v heights were computed with the horizontal preferred size
// as constraint, which is a good approximation.
let mut measure = |child_index: usize,
known_w: Option<Coord>,
known_h: Option<Coord>|
-> (Coord, Coord) {
let w = known_w.unwrap_or_else(|| {
data.cells_h.get(child_index).map_or(0 as Coord, |c| c.constraint.preferred_bounded())
});
let h = known_h.unwrap_or_else(|| {
data.cells_v.get(child_index).map_or(0 as Coord, |c| c.constraint.preferred_bounded())
});
(w, h)
};
solve_flexbox_layout_with_measure(data, repeater_indices, Some(&mut measure))
}
/// Solve a FlexboxLayout using Taffy
/// Returns: [x1, y1, w1, h1, x2, y2, w2, h2, ...] for each item
pub fn solve_flexbox_layout_with_measure(
data: &FlexboxLayoutData,
repeater_indices: Slice<u32>,
measure: FlexboxMeasureFn<'_>,
) -> SharedVector<Coord> {
// 4 values per item: x, y, width, height
let mut result = SharedVector::<Coord>::default();
result.resize(data.cells_h.len() * 4 + repeater_indices.len() * 2, 0 as _);
if data.cells_h.is_empty() {
return result;
}
let taffy_direction = match data.direction {
FlexboxLayoutDirection::Row => flexbox_taffy::TaffyFlexDirection::Row,
FlexboxLayoutDirection::RowReverse => flexbox_taffy::TaffyFlexDirection::RowReverse,
FlexboxLayoutDirection::Column => flexbox_taffy::TaffyFlexDirection::Column,
FlexboxLayoutDirection::ColumnReverse => flexbox_taffy::TaffyFlexDirection::ColumnReverse,
};
let (container_width, container_height) = (
if data.width > 0 as Coord { Some(data.width) } else { None },
if data.height > 0 as Coord { Some(data.height) } else { None },
);
let use_measure = measure.is_some();
let mut builder = flexbox_taffy::FlexboxTaffyBuilder::new(flexbox_taffy::FlexboxLayoutParams {
cells_h: &data.cells_h,
cells_v: &data.cells_v,
spacing_h: data.spacing_h,
spacing_v: data.spacing_v,
padding_h: &data.padding_h,
padding_v: &data.padding_v,
alignment: data.alignment,
align_content: data.align_content,
align_items: data.align_items,
flex_wrap: data.flex_wrap,
flex_direction: taffy_direction,
container_width,
container_height,
use_measure_for_cross_axis: use_measure,
});
let (available_width, available_height) = match data.direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => {
(data.width, Coord::MAX)
}
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => {
(Coord::MAX, data.height)
}
};
builder.compute_layout(available_width, available_height, measure);
// Extract results using the cache generator to handle repeaters.
// If `order` sorting was applied, we need to collect results by original index first,
// because the cache generator expects items in their original declaration order.
if builder.order_map.is_empty() {
let mut generator = FlexboxLayoutCacheGenerator::new(&repeater_indices, &mut result);
for idx in 0..data.cells_h.len() {
let (x, y, w, h) = builder.child_geometry(idx);
generator.add(x, y, w, h);
}
} else {
let count = data.cells_h.len();
let mut geom = alloc::vec![(0 as Coord, 0 as Coord, 0 as Coord, 0 as Coord); count];
for taffy_idx in 0..count {
let orig_idx = builder.original_index(taffy_idx);
geom[orig_idx] = builder.child_geometry(taffy_idx);
}
let mut generator = FlexboxLayoutCacheGenerator::new(&repeater_indices, &mut result);
for (x, y, w, h) in geom {
generator.add(x, y, w, h);
}
}
result
}
/// Return main-axis LayoutInfo for a FlexboxLayout.
/// Only needs the same-axis cells, avoiding a cross-axis binding loop.
pub fn flexbox_layout_info_main_axis(
cells: Slice<FlexboxLayoutItemInfo>,
spacing: Coord,
padding: &Padding,
flex_wrap: FlexboxLayoutWrap,
) -> LayoutInfo {
let extra_pad = padding.begin + padding.end;
if cells.is_empty() {
return LayoutInfo {
min: extra_pad,
preferred: extra_pad,
max: extra_pad,
..Default::default()
};
}
let num_spacings = cells.len().saturating_sub(1) as Coord;
let min = if matches!(flex_wrap, FlexboxLayoutWrap::NoWrap) {
cells.iter().map(|c| c.constraint.min).sum::<Coord>() + spacing * num_spacings + extra_pad
} else {
// Wrapping: the widest single item must fit
cells.iter().map(|c| c.constraint.min).fold(0.0 as Coord, |a, b| a.max(b)) + extra_pad
};
let preferred = if matches!(flex_wrap, FlexboxLayoutWrap::NoWrap) {
// No wrapping: all items on one line
cells.iter().map(|c| c.constraint.preferred_bounded()).sum::<Coord>()
+ spacing * num_spacings
+ extra_pad
} else {
// Wrapping: estimate a roughly square layout using only main-axis sizes.
// Approximate total area assuming each item is square (width == height),
// then take sqrt to get a reasonable main-axis extent.
let total_area: Coord = cells
.iter()
.map(|c| {
let w = c.constraint.preferred_bounded();
w * w
})
.sum();
let count = cells.len();
Float::sqrt(total_area as f32) as Coord + spacing * (count - 1) as Coord + extra_pad
};
let stretch = cells.iter().map(|c| c.constraint.stretch).sum::<f32>();
LayoutInfo {
min,
max: Coord::MAX,
min_percent: 0 as _,
max_percent: 100 as _,
preferred,
stretch,
}
}
/// Return cross-axis LayoutInfo for a FlexboxLayout.
///
/// `constraint_size` is the main-axis container dimension (width for row,
/// height for column). When valid (> 0 and < MAX), it's used as the taffy
/// constraint for accurate wrapping. When invalid (e.g. 0, negative, or
/// MAX — which can happen due to circular dependencies in nested
/// perpendicular flexboxes), falls back to a heuristic based on
/// `flexbox_layout_info_main_axis`.
pub fn flexbox_layout_info_cross_axis(
cells_h: Slice<FlexboxLayoutItemInfo>,
cells_v: Slice<FlexboxLayoutItemInfo>,
spacing_h: Coord,
spacing_v: Coord,
padding_h: &Padding,
padding_v: &Padding,
direction: FlexboxLayoutDirection,
flex_wrap: FlexboxLayoutWrap,
constraint_size: Coord,
) -> LayoutInfo {
if cells_h.is_empty() {
assert!(cells_v.is_empty());
let orientation = match direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => {
Orientation::Vertical
}
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => {
Orientation::Horizontal
}
};
let padding = match orientation {
Orientation::Horizontal => padding_h,
Orientation::Vertical => padding_v,
};
let pad = padding.begin + padding.end;
return LayoutInfo { min: pad, preferred: pad, max: pad, ..Default::default() };
}
// Determine which axis is cross
let cross_cells = match direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => &cells_v,
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => &cells_h,
};
// Compute the main-axis preferred size to use as the constraint for taffy,
// using the same heuristic as flexbox_layout_info_main_axis.
let (main_cells, main_spacing, main_padding) = match direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => {
(&cells_h, spacing_h, padding_h)
}
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => {
(&cells_v, spacing_v, padding_v)
}
};
let main_extra_pad = main_padding.begin + main_padding.end;
let main_axis_constraint = if constraint_size > 0 as Coord && constraint_size < Coord::MAX {
// Use the actual container main-axis dimension (accurate)
constraint_size
} else if matches!(flex_wrap, FlexboxLayoutWrap::NoWrap) {
Coord::MAX
} else {
// Use actual item areas (main * cross) for the heuristic, since both
// axes' cells are available here (unlike flexbox_layout_info_main_axis).
let total_area: Coord = main_cells
.iter()
.zip(cross_cells.iter())
.map(|(m, c)| m.constraint.preferred_bounded() * c.constraint.preferred_bounded())
.sum();
let count = main_cells.len();
Float::sqrt(total_area as f32) as Coord
+ main_spacing * (count - 1) as Coord
+ main_extra_pad
};
let taffy_direction = match direction {
FlexboxLayoutDirection::Row => flexbox_taffy::TaffyFlexDirection::Row,
FlexboxLayoutDirection::RowReverse => flexbox_taffy::TaffyFlexDirection::RowReverse,
FlexboxLayoutDirection::Column => flexbox_taffy::TaffyFlexDirection::Column,
FlexboxLayoutDirection::ColumnReverse => flexbox_taffy::TaffyFlexDirection::ColumnReverse,
};
let (container_width, container_height) = match direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => {
(Some(main_axis_constraint), None)
}
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => {
(None, Some(main_axis_constraint))
}
};
let mut builder = flexbox_taffy::FlexboxTaffyBuilder::new(flexbox_taffy::FlexboxLayoutParams {
cells_h: &cells_h,
cells_v: &cells_v,
spacing_h,
spacing_v,
padding_h,
padding_v,
alignment: LayoutAlignment::Start,
align_content: FlexboxLayoutAlignContent::Stretch,
align_items: FlexboxLayoutAlignItems::Stretch,
flex_wrap,
flex_direction: taffy_direction,
container_width,
container_height,
use_measure_for_cross_axis: false,
});
let (available_width, available_height) = match direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => {
(main_axis_constraint, Coord::MAX)
}
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => {
(Coord::MAX, main_axis_constraint)
}
};
builder.compute_layout(available_width, available_height, None);
let (total_width, total_height) = builder.container_size();
let cross_size = match direction {
FlexboxLayoutDirection::Row | FlexboxLayoutDirection::RowReverse => total_height,
FlexboxLayoutDirection::Column | FlexboxLayoutDirection::ColumnReverse => total_width,
};
LayoutInfo {
min: cross_size,
max: Coord::MAX,
min_percent: 0 as _,
max_percent: 100 as _,
preferred: cross_size,
stretch: 0.0,
}
}
#[cfg(feature = "ffi")]
pub(crate) mod ffi {
#![allow(unsafe_code)]
use super::*;
#[unsafe(no_mangle)]
pub extern "C" fn slint_organize_grid_layout(
input_data: Slice<GridLayoutInputData>,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
result: &mut GridLayoutOrganizedData,
) {
*result = super::organize_grid_layout(input_data, repeater_indices, repeater_steps);
}
#[unsafe(no_mangle)]
pub extern "C" fn slint_organize_dialog_button_layout(
input_data: Slice<GridLayoutInputData>,
dialog_button_roles: Slice<DialogButtonRole>,
result: &mut GridLayoutOrganizedData,
) {
*result = super::organize_dialog_button_layout(input_data, dialog_button_roles);
}
#[unsafe(no_mangle)]
pub extern "C" fn slint_solve_grid_layout(
data: &GridLayoutData,
constraints: Slice<LayoutItemInfo>,
orientation: Orientation,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
result: &mut SharedVector<Coord>,
) {
*result = super::solve_grid_layout(
data,
constraints,
orientation,
repeater_indices,
repeater_steps,
)
}
#[unsafe(no_mangle)]
pub extern "C" fn slint_grid_layout_info(
organized_data: &GridLayoutOrganizedData,
constraints: Slice<LayoutItemInfo>,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
spacing: Coord,
padding: &Padding,
orientation: Orientation,
) -> LayoutInfo {
super::grid_layout_info(
organized_data.clone(),
constraints,
repeater_indices,
repeater_steps,
spacing,
padding,
orientation,
)
}
#[unsafe(no_mangle)]
pub extern "C" fn slint_solve_box_layout(
data: &BoxLayoutData,
repeater_indices: Slice<u32>,
result: &mut SharedVector<Coord>,
) {
*result = super::solve_box_layout(data, repeater_indices)
}
#[unsafe(no_mangle)]
/// Return the LayoutInfo for a BoxLayout with the given cells.
pub extern "C" fn slint_box_layout_info(
cells: Slice<LayoutItemInfo>,
spacing: Coord,
padding: &Padding,
alignment: LayoutAlignment,
) -> LayoutInfo {
super::box_layout_info(cells, spacing, padding, alignment)
}
#[unsafe(no_mangle)]
/// Return the LayoutInfo for a BoxLayout with the given cells.
pub extern "C" fn slint_box_layout_info_ortho(
cells: Slice<LayoutItemInfo>,
padding: &Padding,
) -> LayoutInfo {
super::box_layout_info_ortho(cells, padding)
}
/// The measure callback for C FFI. Returns (width, height) via out pointers.
/// `known_width`/`known_height` are negative if not determined yet.
/// A null function pointer means no measure callback.
pub type FlexboxMeasureFnC = unsafe extern "C" fn(
user_data: *mut core::ffi::c_void,
child_index: usize,
known_width: Coord,
known_height: Coord,
out_width: *mut Coord,
out_height: *mut Coord,
);
#[unsafe(no_mangle)]
#[allow(unsafe_code)]
pub extern "C" fn slint_solve_flexbox_layout(
data: &FlexboxLayoutData,
repeater_indices: Slice<u32>,
result: &mut SharedVector<Coord>,
measure_fn: *const core::ffi::c_void,
measure_user_data: *mut core::ffi::c_void,
) {
// Safety: measure_fn, when non-null, is a valid FlexboxMeasureFnC function pointer
// passed as *const c_void because cbindgen can't represent Option<fn pointer> in C++.
const {
assert!(
core::mem::size_of::<*const core::ffi::c_void>()
== core::mem::size_of::<FlexboxMeasureFnC>()
);
}
let measure_fn: Option<FlexboxMeasureFnC> = if measure_fn.is_null() {
None
} else {
Some(unsafe {
core::mem::transmute::<*const core::ffi::c_void, FlexboxMeasureFnC>(measure_fn)
})
};
if let Some(c_measure) = measure_fn {
let mut measure = |child_index: usize,
known_w: Option<Coord>,
known_h: Option<Coord>|
-> (Coord, Coord) {
let mut out_w: Coord = 0 as _;
let mut out_h: Coord = 0 as _;
// Safety: c_measure is a valid function pointer provided by the caller,
// and out_w/out_h are valid mutable pointers.
unsafe {
c_measure(
measure_user_data,
child_index,
known_w.unwrap_or(-1 as _),
known_h.unwrap_or(-1 as _),
&mut out_w,
&mut out_h,
);
}
(out_w, out_h)
};
*result = super::solve_flexbox_layout_with_measure(
data,
repeater_indices,
Some(&mut measure),
);
} else {
*result = super::solve_flexbox_layout(data, repeater_indices);
}
}
#[unsafe(no_mangle)]
/// Return main-axis LayoutInfo for a FlexboxLayout (single-axis, no cross-axis dependency).
pub extern "C" fn slint_flexbox_layout_info_main_axis(
cells: Slice<FlexboxLayoutItemInfo>,
spacing: Coord,
padding: &Padding,
flex_wrap: FlexboxLayoutWrap,
) -> LayoutInfo {
super::flexbox_layout_info_main_axis(cells, spacing, padding, flex_wrap)
}
#[unsafe(no_mangle)]
/// Return cross-axis LayoutInfo for a FlexboxLayout.
pub extern "C" fn slint_flexbox_layout_info_cross_axis(
cells_h: Slice<FlexboxLayoutItemInfo>,
cells_v: Slice<FlexboxLayoutItemInfo>,
spacing_h: Coord,
spacing_v: Coord,
padding_h: &Padding,
padding_v: &Padding,
direction: FlexboxLayoutDirection,
flex_wrap: FlexboxLayoutWrap,
constraint_size: Coord,
) -> LayoutInfo {
super::flexbox_layout_info_cross_axis(
cells_h,
cells_v,
spacing_h,
spacing_v,
padding_h,
padding_v,
direction,
flex_wrap,
constraint_size,
)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn collect_from_organized_data(
organized_data: &GridLayoutOrganizedData,
num_cells: usize,
repeater_indices: Slice<u32>,
repeater_steps: Slice<u32>,
) -> Vec<(u16, u16, u16, u16)> {
let mut result = Vec::new();
for i in 0..num_cells {
let col_and_span = organized_data.col_or_row_and_span(
i,
Orientation::Horizontal,
&repeater_indices,
&repeater_steps,
);
let row_and_span = organized_data.col_or_row_and_span(
i,
Orientation::Vertical,
&repeater_indices,
&repeater_steps,
);
result.push((col_and_span.0, col_and_span.1, row_and_span.0, row_and_span.1));
}
result
}
#[test]
fn test_organized_data_generator_2_fixed_cells() {
// 2 fixed cells
let mut result = GridLayoutOrganizedData::default();
let num_cells = 2;
let mut generator = OrganizedDataGenerator::new(&[], &[], num_cells, 0, 0, &mut result);
generator.add(0, 1, 0, 1);
generator.add(1, 2, 0, 3);
assert_eq!(result.as_slice(), &[0, 1, 0, 1, 1, 2, 0, 3]);
let repeater_indices = Slice::from_slice(&[]);
let empty_steps = Slice::from_slice(&[]);
let collected_data =
collect_from_organized_data(&result, num_cells, repeater_indices, empty_steps);
assert_eq!(collected_data.as_slice(), &[(0, 1, 0, 1), (1, 2, 0, 3)]);
assert_eq!(
result.max_value(num_cells, Orientation::Horizontal, &repeater_indices, &empty_steps),
3
);
assert_eq!(
result.max_value(num_cells, Orientation::Vertical, &repeater_indices, &empty_steps),
3
);
}
#[test]
fn test_organized_data_generator_1_fixed_cell_1_repeater() {
// 4 cells: 1 fixed cell, 1 repeater with 3 repeated cells
let mut result = GridLayoutOrganizedData::default();
let num_cells = 4;
let repeater_indices = &[1u32, 3u32];
let mut generator =
OrganizedDataGenerator::new(repeater_indices, &[], 1, 1, 3, &mut result);
generator.add(0, 1, 0, 2); // fixed
generator.add(1, 2, 1, 3); // repeated
generator.add(1, 1, 2, 4);
generator.add(2, 2, 3, 5);
assert_eq!(
result.as_slice(),
&[
0, 1, 0, 2, // fixed cell
8, 4, 0, 0, // jump cell: data_base=8, stride=4 (step=1, epi=4)
1, 2, 1, 3, // repeated cell 1
1, 1, 2, 4, // repeated cell 2
2, 2, 3, 5, // repeated cell 3
]
);
let repeater_indices = Slice::from_slice(repeater_indices);
let empty_steps = Slice::from_slice(&[]);
let collected_data =
collect_from_organized_data(&result, num_cells, repeater_indices, empty_steps);
assert_eq!(
collected_data.as_slice(),
&[(0, 1, 0, 2), (1, 2, 1, 3), (1, 1, 2, 4), (2, 2, 3, 5)]
);
assert_eq!(
result.max_value(num_cells, Orientation::Horizontal, &repeater_indices, &empty_steps),
4
);
assert_eq!(
result.max_value(num_cells, Orientation::Vertical, &repeater_indices, &empty_steps),
8
);
}
#[test]
fn test_organize_data_with_auto_and_spans() {
let auto = i_slint_common::ROW_COL_AUTO;
let input = std::vec![
GridLayoutInputData { new_row: true, col: auto, row: auto, colspan: 2., rowspan: -1. },
GridLayoutInputData { new_row: false, col: auto, row: auto, colspan: 1., rowspan: 2. },
GridLayoutInputData { new_row: true, col: auto, row: auto, colspan: 2., rowspan: 1. },
GridLayoutInputData { new_row: true, col: -2., row: 80000., colspan: 2., rowspan: 1. },
];
let repeater_indices = Slice::from_slice(&[]);
let (organized_data, errors) = organize_grid_layout_impl(
Slice::from_slice(&input),
repeater_indices,
Slice::from_slice(&[]),
);
assert_eq!(
organized_data.as_slice(),
&[
0, 2, 0, 0, // row 0, col 0, rowspan 0 (see below)
2, 1, 0, 2, // row 0, col 2 (due to colspan of first cell)
0, 2, 1, 1, // row 1, col 0
0, 2, 65535, 1, // row 65535, col 0
]
);
assert_eq!(errors.len(), 3);
// Note that a rowspan of 0 is valid, it means the cell doesn't occupy any row
assert_eq!(errors[0], "cell rowspan -1 is negative, clamping to 0");
assert_eq!(errors[1], "cell row 80000 is too large, clamping to 65535");
assert_eq!(errors[2], "cell col -2 is negative, clamping to 0");
let empty_steps = Slice::from_slice(&[]);
let collected_data = collect_from_organized_data(
&organized_data,
input.len(),
repeater_indices,
empty_steps,
);
assert_eq!(
collected_data.as_slice(),
&[(0, 2, 0, 0), (2, 1, 0, 2), (0, 2, 1, 1), (0, 2, 65535, 1)]
);
assert_eq!(
organized_data.max_value(3, Orientation::Horizontal, &repeater_indices, &empty_steps),
3
);
assert_eq!(
organized_data.max_value(3, Orientation::Vertical, &repeater_indices, &empty_steps),
2
);
}
#[test]
fn test_organize_data_1_empty_repeater() {
// Row { Text {} if false: Text {} }, this test shows why we need i32 for cell_nr_adj
let auto = i_slint_common::ROW_COL_AUTO;
let cell =
GridLayoutInputData { new_row: true, col: auto, row: auto, colspan: 1., rowspan: 1. };
let input = std::vec![cell];
let repeater_indices = Slice::from_slice(&[1u32, 0u32]);
let (organized_data, errors) = organize_grid_layout_impl(
Slice::from_slice(&input),
repeater_indices,
Slice::from_slice(&[]),
);
assert_eq!(
organized_data.as_slice(),
&[
0, 1, 0, 1, // fixed
0, 0, 0, 0
] // jump to repeater data (not used)
);
assert_eq!(errors.len(), 0);
let empty_steps = Slice::from_slice(&[]);
let collected_data = collect_from_organized_data(
&organized_data,
input.len(),
repeater_indices,
empty_steps,
);
assert_eq!(collected_data.as_slice(), &[(0, 1, 0, 1)]);
assert_eq!(
organized_data.max_value(1, Orientation::Horizontal, &repeater_indices, &empty_steps),
1
);
}
#[test]
fn test_organize_data_4_repeaters() {
let auto = i_slint_common::ROW_COL_AUTO;
let mut cell =
GridLayoutInputData { new_row: true, col: auto, row: auto, colspan: 1., rowspan: 1. };
let mut input = std::vec![cell.clone()];
for _ in 0..8 {
cell.new_row = false;
input.push(cell.clone());
}
let repeater_indices = Slice::from_slice(&[0u32, 0u32, 1u32, 4u32, 6u32, 2u32, 8u32, 0u32]);
let (organized_data, errors) = organize_grid_layout_impl(
Slice::from_slice(&input),
repeater_indices,
Slice::from_slice(&[]),
);
assert_eq!(
organized_data.as_slice(),
&[
28, 4, 0, 0, // rep0 jump: data at 28, stride=4 (empty)
0, 1, 0, 1, // fixed cell (col=0)
28, 4, 0, 0, // rep1 jump: data at 28, stride=4 (4 rows)
5, 1, 0, 1, // fixed cell (col=5)
44, 4, 0, 0, // rep2 jump: data at 44, stride=4 (2 rows)
52, 4, 0, 0, // rep3 jump: data at 52, stride=4 (empty)
8, 1, 0, 1, // fixed cell (col=8)
1, 1, 0, 1, // rep1 row 0
2, 1, 0, 1, // rep1 row 1
3, 1, 0, 1, // rep1 row 2
4, 1, 0, 1, // rep1 row 3
6, 1, 0, 1, // rep2 row 0
7, 1, 0, 1, // rep2 row 1
]
);
assert_eq!(errors.len(), 0);
let empty_steps = Slice::from_slice(&[]);
let collected_data = collect_from_organized_data(
&organized_data,
input.len(),
repeater_indices,
empty_steps,
);
assert_eq!(
collected_data.as_slice(),
&[
(0, 1, 0, 1),
(1, 1, 0, 1),
(2, 1, 0, 1),
(3, 1, 0, 1),
(4, 1, 0, 1),
(5, 1, 0, 1),
(6, 1, 0, 1),
(7, 1, 0, 1),
(8, 1, 0, 1),
]
);
let empty_steps = Slice::from_slice(&[]);
assert_eq!(
organized_data.max_value(
input.len(),
Orientation::Horizontal,
&repeater_indices,
&empty_steps
),
9
);
}
#[test]
fn test_organize_data_repeated_rows() {
let auto = i_slint_common::ROW_COL_AUTO;
let mut input = Vec::new();
let num_rows: u32 = 3;
let num_columns: u32 = 2;
// 3 rows of 2 columns each
for _ in 0..num_rows {
let mut cell = GridLayoutInputData {
new_row: true,
col: auto,
row: auto,
colspan: 1.,
rowspan: 1.,
};
input.push(cell.clone());
cell.new_row = false;
input.push(cell.clone());
}
// Repeater 0: starts at index 0, has 3 instances of 2 elements
let repeater_indices_arr = [0_u32, num_rows];
let repeater_steps_arr = [num_columns];
let repeater_steps = Slice::from_slice(&repeater_steps_arr);
let repeater_indices = Slice::from_slice(&repeater_indices_arr);
let (organized_data, errors) =
organize_grid_layout_impl(Slice::from_slice(&input), repeater_indices, repeater_steps);
assert_eq!(
organized_data.as_slice(),
&[
4, 8, 0, 0, // jump cell: data at u16 idx 4, stride=8 (=step*4=2*4)
0, 1, 0, 1, 1, 1, 0, 1, // row 0: col 0, col 1
0, 1, 1, 1, 1, 1, 1, 1, // row 1: col 0, col 1
0, 1, 2, 1, 1, 1, 2, 1, // row 2: col 0, col 1
]
);
assert_eq!(errors.len(), 0);
let collected_data = collect_from_organized_data(
&organized_data,
input.len(),
repeater_indices,
repeater_steps,
);
assert_eq!(
collected_data.as_slice(),
// (col, colspan, row, rowspan) for each cell in input order
&[(0, 1, 0, 1), (1, 1, 0, 1), (0, 1, 1, 1), (1, 1, 1, 1), (0, 1, 2, 1), (1, 1, 2, 1),]
);
assert_eq!(
organized_data.max_value(
input.len(),
Orientation::Horizontal,
&repeater_indices,
&repeater_steps
),
2
);
assert_eq!(
organized_data.max_value(
input.len(),
Orientation::Vertical,
&repeater_indices,
&repeater_steps
),
3
);
// Now test GridLayoutCacheGenerator
let mut layout_cache_v = SharedVector::<Coord>::default();
let mut generator = GridLayoutCacheGenerator::new(
repeater_indices.as_slice(),
repeater_steps.as_slice(),
0, // static_cells
1, // num_repeaters
6, // total_repeated_cells (3 rows * 2 columns)
&mut layout_cache_v,
);
// Row 0
generator.add(0., 50.);
generator.add(0., 50.);
// Row 1
generator.add(50., 50.);
generator.add(50., 50.);
// Row 2
generator.add(100., 50.);
generator.add(100., 50.);
assert_eq!(
layout_cache_v.as_slice(),
&[
2., 4., // jump cell: data at pos 2, stride=4 (=step*2=2*2)
0., 50., 0., 50., // row 0
50., 50., 50., 50., // row 1
100., 50., 100., 50., // row 2
]
);
// GridRepeaterCacheAccess: cache[cache[jump_index] + ri * stride + child_offset]
let layout_cache_v_access = |jump_index: usize,
repeater_index: usize,
stride: usize,
child_offset: usize|
-> Coord {
let base = layout_cache_v[jump_index] as usize;
let data_idx = base + repeater_index * stride + child_offset;
layout_cache_v[data_idx]
};
// stride=4 (step=2, entries_per_item=2)
// Y pos for child 0 (child_offset=0)
assert_eq!(layout_cache_v_access(0, 0, 4, 0), 0.);
assert_eq!(layout_cache_v_access(0, 1, 4, 0), 50.);
assert_eq!(layout_cache_v_access(0, 2, 4, 0), 100.);
// Y pos for child 1 (child_offset=2)
assert_eq!(layout_cache_v_access(0, 0, 4, 2), 0.);
assert_eq!(layout_cache_v_access(0, 1, 4, 2), 50.);
assert_eq!(layout_cache_v_access(0, 2, 4, 2), 100.);
}
#[test]
fn test_organize_data_repeated_rows_multiple_repeaters() {
let auto = i_slint_common::ROW_COL_AUTO;
let mut input = Vec::new();
let num_rows: u32 = 5;
let mut cell =
GridLayoutInputData { new_row: true, col: auto, row: auto, colspan: 1., rowspan: 1. };
// 3 rows of 2 columns each
for _ in 0..3 {
cell.new_row = true;
input.push(cell.clone());
cell.new_row = false;
input.push(cell.clone());
}
// 2 rows of 3 columns each
for _ in 0..2 {
cell.new_row = true;
input.push(cell.clone());
cell.new_row = false;
input.push(cell.clone());
cell.new_row = false;
input.push(cell.clone());
}
// Repeater 0: starts at index 0, has 3 instances of 2 elements
// Repeater 1: starts at index 6 (after repeater 0's 3*2=6 cells), has 2 instances of 3 elements
let repeater_indices_arr = [0_u32, 3, 6, 2];
let repeater_steps_arr = [2, 3];
let repeater_steps = Slice::from_slice(&repeater_steps_arr);
let repeater_indices = Slice::from_slice(&repeater_indices_arr);
let (organized_data, errors) =
organize_grid_layout_impl(Slice::from_slice(&input), repeater_indices, repeater_steps);
assert_eq!(
organized_data.as_slice(),
&[
8, 8, 0, 0, // repeater 0 jump: data at 8, stride=8 (=step*4=2*4)
32, 12, 0, 0, // repeater 1 jump: data at 32, stride=12 (=step*4=3*4)
// Repeater 0 data
0, 1, 0, 1, 1, 1, 0, 1, // row 0: col 0, col 1
0, 1, 1, 1, 1, 1, 1, 1, // row 1: col 0, col 1
0, 1, 2, 1, 1, 1, 2, 1, // row 2: col 0, col 1
// Repeater 1 data
0, 1, 3, 1, 1, 1, 3, 1, 2, 1, 3, 1, // row 0: col 0, col 1, col 2
0, 1, 4, 1, 1, 1, 4, 1, 2, 1, 4, 1, // row 1: col 0, col 1, col 2
]
);
assert_eq!(errors.len(), 0);
let collected_data = collect_from_organized_data(
&organized_data,
input.len(),
repeater_indices,
repeater_steps,
);
assert_eq!(
collected_data.as_slice(),
// (col, colspan, row, rowspan) for each cell in input order
&[
(0, 1, 0, 1),
(1, 1, 0, 1),
(0, 1, 1, 1),
(1, 1, 1, 1),
(0, 1, 2, 1),
(1, 1, 2, 1),
(0, 1, 3, 1),
(1, 1, 3, 1),
(2, 1, 3, 1),
(0, 1, 4, 1),
(1, 1, 4, 1),
(2, 1, 4, 1)
]
);
assert_eq!(
organized_data.max_value(
input.len(),
Orientation::Horizontal,
&repeater_indices,
&repeater_steps
),
3 // max col (2) + colspan (1) = 3
);
assert_eq!(
organized_data.max_value(
input.len(),
Orientation::Vertical,
&repeater_indices,
&repeater_steps
),
num_rows as u16 // max row (4) + rowspan (1) = 5
);
// Now test GridLayoutCacheGenerator
let mut layout_cache_v = SharedVector::<Coord>::default();
let mut generator = GridLayoutCacheGenerator::new(
repeater_indices.as_slice(),
repeater_steps.as_slice(),
0, // static_cells
2, // num_repeaters
12, // total_repeated_cells (3*2 + 2*3)
&mut layout_cache_v,
);
// Row 0
generator.add(0., 50.);
generator.add(0., 50.);
// Row 1
generator.add(50., 50.);
generator.add(50., 50.);
// Row 2
generator.add(100., 50.);
generator.add(100., 50.);
// Row 3
generator.add(150., 50.);
generator.add(150., 50.);
generator.add(150., 50.);
// Row 4
generator.add(200., 50.);
generator.add(200., 50.);
generator.add(200., 50.);
assert_eq!(
layout_cache_v.as_slice(),
&[
4., 4., // repeater 0 jump: data at pos 4, stride=4 (=step*2=2*2)
16., 6., // repeater 1 jump: data at pos 16, stride=6 (=step*2=3*2)
0., 50., 0., 50., // repeater 0 row 0 data
50., 50., 50., 50., // repeater 0 row 1 data
100., 50., 100., 50., // repeater 0 row 2 data
150., 50., 150., 50., 150., 50., // repeater 1 row 3 data
200., 50., 200., 50., 200., 50., // repeater 1 row 4 data
]
);
// GridRepeaterCacheAccess: cache[cache[jump_index] + ri * stride + child_offset]
let layout_cache_v_access = |jump_index: usize,
repeater_index: usize,
stride: usize,
child_offset: usize|
-> Coord {
let base = layout_cache_v[jump_index] as usize;
let data_idx = base + repeater_index * stride + child_offset;
layout_cache_v[data_idx]
};
// Repeater 0: Y pos for child 0 (child_offset=0), stride=4
assert_eq!(layout_cache_v_access(0, 0, 4, 0), 0.);
assert_eq!(layout_cache_v_access(0, 1, 4, 0), 50.);
assert_eq!(layout_cache_v_access(0, 2, 4, 0), 100.);
// Repeater 0: Y pos for child 1 (child_offset=2), stride=4
assert_eq!(layout_cache_v_access(0, 0, 4, 2), 0.);
assert_eq!(layout_cache_v_access(0, 1, 4, 2), 50.);
assert_eq!(layout_cache_v_access(0, 2, 4, 2), 100.);
// Repeater 1: Y pos for child 0 (child_offset=0), jump at index 2, stride=6
assert_eq!(layout_cache_v_access(2, 0, 6, 0), 150.);
assert_eq!(layout_cache_v_access(2, 1, 6, 0), 200.);
// Repeater 1: Y pos for child 2 (child_offset=4), jump at index 2, stride=6
assert_eq!(layout_cache_v_access(2, 0, 6, 4), 150.);
assert_eq!(layout_cache_v_access(2, 1, 6, 4), 200.);
}
#[test]
fn test_layout_cache_generator_2_fixed_cells() {
// 2 fixed cells
let mut result = SharedVector::<Coord>::default();
result.resize(2 * 2, 0 as _);
let mut generator = LayoutCacheGenerator::new(&[], &mut result);
generator.add(0., 50.); // fixed
generator.add(80., 50.); // fixed
assert_eq!(result.as_slice(), &[0., 50., 80., 50.]);
}
#[test]
fn test_layout_cache_generator_1_fixed_cell_1_repeater() {
// 4 cells: 1 fixed cell, 1 repeater with 3 repeated cells
let mut result = SharedVector::<Coord>::default();
let repeater_indices = &[1, 3];
result.resize(4 * 2 + repeater_indices.len(), 0 as _);
let mut generator = LayoutCacheGenerator::new(repeater_indices, &mut result);
generator.add(0., 50.); // fixed
generator.add(80., 50.); // repeated
generator.add(160., 50.);
generator.add(240., 50.);
assert_eq!(
result.as_slice(),
&[
0., 50., // fixed
4., 5., // jump to repeater data
80., 50., 160., 50., 240., 50. // repeater data
]
);
}
#[test]
fn test_layout_cache_generator_4_repeaters() {
// 8 cells: 1 fixed cell, 1 empty repeater, 1 repeater with 4 repeated cells, 1 fixed cell, 1 repeater with 2 repeated cells, 1 empty repeater
let mut result = SharedVector::<Coord>::default();
let repeater_indices = &[1, 0, 1, 4, 6, 2, 8, 0];
result.resize(8 * 2 + repeater_indices.len(), 0 as _);
let mut generator = LayoutCacheGenerator::new(repeater_indices, &mut result);
generator.add(0., 50.); // fixed
generator.add(80., 10.); // repeated
generator.add(160., 10.);
generator.add(240., 10.);
generator.add(320., 10.); // end of second repeater
generator.add(400., 80.); // fixed
generator.add(500., 20.); // repeated
generator.add(600., 20.); // end of third repeater
assert_eq!(
result.as_slice(),
&[
0., 50., // fixed
12., 13., // jump to first (empty) repeater (not used)
12., 13., // jump to second repeater data
400., 80., // fixed
20., 21., // jump to third repeater data
0., 0., // slot for jumping to fourth repeater (currently empty)
80., 10., 160., 10., 240., 10., 320., 10., // first repeater data
500., 20., 600., 20. // second repeater data
]
);
}
}