Skip to main content

sui_layout/
lib.rs

1#![forbid(unsafe_code)]
2
3mod grid;
4
5pub use grid::{
6    GridItem, GridItemLayout, GridLayout, GridPlacement, GridStyle, GridTrack, GridTrackMax,
7    grid_layout,
8};
9
10use std::sync::Arc;
11
12use sui_core::{DpiInfo, ImageHandle, Point, Rect, Size};
13use sui_scene::ImageRegistry;
14use sui_text::{
15    FontRegistry, PersistentTextLayout, TextDocument, TextLayout, TextLayoutHandle,
16    TextLayoutRequest, TextMeasurement, TextStyle, TextSystem,
17};
18
19const FLEX_EPSILON: f32 = 0.001;
20
21#[derive(Debug, Clone, Copy, PartialEq, Eq)]
22pub enum Axis {
23    Horizontal,
24    Vertical,
25}
26
27/// Minimum and preferred content extents reported by a widget along one axis.
28///
29/// The minimum is the smallest readable/unbreakable extent. The natural value
30/// is the extent the widget prefers when it is not asked to wrap or shrink.
31#[derive(Debug, Clone, Copy, Default, PartialEq)]
32pub struct IntrinsicSize {
33    pub minimum: f32,
34    pub natural: f32,
35}
36
37impl IntrinsicSize {
38    pub fn new(minimum: f32, natural: f32) -> Self {
39        let minimum = finite_non_negative(minimum);
40        Self {
41            minimum,
42            natural: finite_non_negative(natural).max(minimum),
43        }
44    }
45
46    pub fn fixed(extent: f32) -> Self {
47        Self::new(extent, extent)
48    }
49}
50
51#[derive(Debug, Clone, Copy, PartialEq, Eq)]
52pub enum Alignment {
53    Start,
54    Center,
55    End,
56    Stretch,
57}
58
59#[derive(Debug, Clone, Copy, PartialEq, Eq)]
60pub enum FlexWrap {
61    NoWrap,
62    Wrap,
63}
64
65#[derive(Debug, Clone, Copy, PartialEq, Eq)]
66pub enum FlexJustify {
67    Start,
68    Center,
69    End,
70    SpaceBetween,
71    SpaceAround,
72    SpaceEvenly,
73}
74
75#[derive(Debug, Clone, Copy, PartialEq, Eq)]
76pub enum FlexAlignContent {
77    Start,
78    Center,
79    End,
80    Stretch,
81    SpaceBetween,
82    SpaceAround,
83    SpaceEvenly,
84}
85
86#[derive(Debug, Clone, Copy, PartialEq)]
87pub enum FlexBasis {
88    Auto,
89    Points(f32),
90    Fraction(f32),
91    GapAwareFraction(f32),
92}
93
94#[derive(Debug, Clone, Copy, PartialEq)]
95pub struct FlexStyle {
96    pub axis: Axis,
97    pub wrap: FlexWrap,
98    pub main_gap: f32,
99    pub cross_gap: f32,
100    pub justify: FlexJustify,
101    pub align_items: Alignment,
102    pub align_content: FlexAlignContent,
103}
104
105impl FlexStyle {
106    pub const fn new(axis: Axis) -> Self {
107        Self {
108            axis,
109            wrap: FlexWrap::NoWrap,
110            main_gap: 0.0,
111            cross_gap: 0.0,
112            justify: FlexJustify::Start,
113            align_items: Alignment::Start,
114            align_content: FlexAlignContent::Start,
115        }
116    }
117
118    pub const fn horizontal() -> Self {
119        Self::new(Axis::Horizontal)
120    }
121
122    pub const fn vertical() -> Self {
123        Self::new(Axis::Vertical)
124    }
125
126    pub fn wrap(mut self, wrap: FlexWrap) -> Self {
127        self.wrap = wrap;
128        self
129    }
130
131    pub fn gap(mut self, gap: f32) -> Self {
132        let gap = finite_non_negative(gap);
133        self.main_gap = gap;
134        self.cross_gap = gap;
135        self
136    }
137
138    pub fn main_gap(mut self, gap: f32) -> Self {
139        self.main_gap = finite_non_negative(gap);
140        self
141    }
142
143    pub fn cross_gap(mut self, gap: f32) -> Self {
144        self.cross_gap = finite_non_negative(gap);
145        self
146    }
147
148    pub fn justify(mut self, justify: FlexJustify) -> Self {
149        self.justify = justify;
150        self
151    }
152
153    pub fn align_items(mut self, alignment: Alignment) -> Self {
154        self.align_items = alignment;
155        self
156    }
157
158    pub fn align_content(mut self, alignment: FlexAlignContent) -> Self {
159        self.align_content = alignment;
160        self
161    }
162}
163
164impl Default for FlexStyle {
165    fn default() -> Self {
166        Self::horizontal()
167    }
168}
169
170#[derive(Debug, Clone, Copy, PartialEq)]
171pub struct FlexItem {
172    pub grow: f32,
173    pub shrink: f32,
174    pub basis: FlexBasis,
175    pub min_size: Size,
176    pub max_size: Size,
177    pub align_self: Option<Alignment>,
178}
179
180impl FlexItem {
181    pub const fn new() -> Self {
182        Self {
183            grow: 0.0,
184            shrink: 1.0,
185            basis: FlexBasis::Auto,
186            min_size: Size::ZERO,
187            max_size: Size::new(f32::INFINITY, f32::INFINITY),
188            align_self: None,
189        }
190    }
191
192    pub const fn fill() -> Self {
193        Self {
194            grow: 1.0,
195            shrink: 1.0,
196            basis: FlexBasis::Points(0.0),
197            min_size: Size::ZERO,
198            max_size: Size::new(f32::INFINITY, f32::INFINITY),
199            align_self: None,
200        }
201    }
202
203    pub fn flex(grow: f32) -> Self {
204        Self::fill().grow(grow)
205    }
206
207    pub fn fixed(basis: f32) -> Self {
208        Self::new().basis(basis).no_shrink()
209    }
210
211    pub fn grow(mut self, grow: f32) -> Self {
212        self.grow = finite_non_negative(grow);
213        self
214    }
215
216    pub fn shrink(mut self, shrink: f32) -> Self {
217        self.shrink = finite_non_negative(shrink);
218        self
219    }
220
221    pub fn no_shrink(mut self) -> Self {
222        self.shrink = 0.0;
223        self
224    }
225
226    pub fn basis(mut self, basis: f32) -> Self {
227        self.basis = FlexBasis::Points(finite_non_negative(basis));
228        self
229    }
230
231    pub fn basis_fraction(mut self, fraction: f32) -> Self {
232        self.basis = FlexBasis::Fraction(finite_non_negative(fraction));
233        self
234    }
235
236    pub fn basis_gap_aware_fraction(mut self, fraction: f32) -> Self {
237        self.basis = FlexBasis::GapAwareFraction(finite_non_negative(fraction));
238        self
239    }
240
241    pub fn auto_basis(mut self) -> Self {
242        self.basis = FlexBasis::Auto;
243        self
244    }
245
246    pub fn min_size(mut self, min_size: Size) -> Self {
247        self.min_size = Size::new(
248            finite_non_negative(min_size.width),
249            finite_non_negative(min_size.height),
250        );
251        self
252    }
253
254    pub fn min_width(mut self, min_width: f32) -> Self {
255        self.min_size.width = finite_non_negative(min_width);
256        self
257    }
258
259    pub fn min_height(mut self, min_height: f32) -> Self {
260        self.min_size.height = finite_non_negative(min_height);
261        self
262    }
263
264    pub fn max_size(mut self, max_size: Size) -> Self {
265        self.max_size = Size::new(
266            non_negative_or_infinity(max_size.width),
267            non_negative_or_infinity(max_size.height),
268        );
269        self
270    }
271
272    pub fn max_width(mut self, max_width: f32) -> Self {
273        self.max_size.width = non_negative_or_infinity(max_width);
274        self
275    }
276
277    pub fn max_height(mut self, max_height: f32) -> Self {
278        self.max_size.height = non_negative_or_infinity(max_height);
279        self
280    }
281
282    pub fn align_self(mut self, alignment: Alignment) -> Self {
283        self.align_self = Some(alignment);
284        self
285    }
286
287    pub fn inherit_alignment(mut self) -> Self {
288        self.align_self = None;
289        self
290    }
291}
292
293impl Default for FlexItem {
294    fn default() -> Self {
295        Self::new()
296    }
297}
298
299#[derive(Debug, Clone, PartialEq)]
300pub struct FlexLayout {
301    pub size: Size,
302    pub items: Vec<FlexItemLayout>,
303    pub lines: Vec<FlexLineLayout>,
304}
305
306impl FlexLayout {
307    pub fn empty(size: Size) -> Self {
308        Self {
309            size,
310            items: Vec::new(),
311            lines: Vec::new(),
312        }
313    }
314}
315
316#[derive(Debug, Clone, Copy, PartialEq)]
317pub struct FlexItemLayout {
318    pub rect: Rect,
319    pub measured_size: Size,
320    pub line: usize,
321}
322
323#[derive(Debug, Clone, Copy, PartialEq)]
324pub struct FlexLineLayout {
325    pub item_start: usize,
326    pub item_end: usize,
327    pub rect: Rect,
328}
329
330pub fn flex_layout<F>(
331    style: FlexStyle,
332    items: &[FlexItem],
333    constraints: Constraints,
334    mut measure_child: F,
335) -> FlexLayout
336where
337    F: FnMut(usize, Constraints) -> Size,
338{
339    flex_layout_impl(style, items, constraints, false, |index, constraints, _| {
340        measure_child(index, constraints)
341    })
342}
343
344/// The initial flex-basis query only needs a size. The resolved query commits
345/// each child's layout, even when its constraints equal those of the probe.
346#[derive(Debug, Clone, Copy, PartialEq, Eq)]
347pub enum FlexMeasurePhase {
348    Probe,
349    Commit,
350}
351
352pub fn flex_layout_with_probes<F>(
353    style: FlexStyle,
354    items: &[FlexItem],
355    constraints: Constraints,
356    measure_child: F,
357) -> FlexLayout
358where
359    F: FnMut(usize, Constraints, FlexMeasurePhase) -> Size,
360{
361    flex_layout_impl(style, items, constraints, true, measure_child)
362}
363
364fn flex_layout_impl<F>(
365    style: FlexStyle,
366    items: &[FlexItem],
367    constraints: Constraints,
368    commit_unchanged: bool,
369    mut measure_child: F,
370) -> FlexLayout
371where
372    F: FnMut(usize, Constraints, FlexMeasurePhase) -> Size,
373{
374    let initial_measurements = items
375        .iter()
376        .enumerate()
377        .map(|(index, item)| {
378            let child_constraints = flex_child_constraints(style, *item, constraints);
379            let measured_size = clamp_item_size(
380                *item,
381                measure_child(index, child_constraints, FlexMeasurePhase::Probe),
382            );
383            (child_constraints, measured_size)
384        })
385        .collect::<Vec<_>>();
386    let measured_sizes = initial_measurements
387        .iter()
388        .map(|(_, measured_size)| *measured_size)
389        .collect::<Vec<_>>();
390    let initial_layout = flex_layout_from_measured(style, items, constraints, &measured_sizes);
391
392    // Flex basis and grow/shrink resolution can assign a child a very different
393    // main-axis extent from the one used for its intrinsic measurement. Text is
394    // the important example: `FlexItem::flex(1.0)` has a zero-point basis, so an
395    // initial width of zero produces a one-glyph-per-line layout even though the
396    // item is then grown across the row. Measure again at the resolved allocation
397    // so width-dependent children can rebuild wrapping and report the resulting
398    // cross-axis size before the final line layout is computed.
399    let resolved_sizes = items
400        .iter()
401        .enumerate()
402        .map(|(index, item)| {
403            let resolved_main = initial_layout
404                .items
405                .get(index)
406                .map(|layout| axis_main(style.axis, layout.rect.size))
407                .unwrap_or(0.0);
408            let child_constraints =
409                resolved_flex_child_constraints(style, *item, constraints, resolved_main);
410            let (initial_constraints, initial_size) = initial_measurements[index];
411            if !commit_unchanged && child_constraints == initial_constraints {
412                initial_size
413            } else {
414                clamp_item_size(
415                    *item,
416                    measure_child(index, child_constraints, FlexMeasurePhase::Commit),
417                )
418            }
419        })
420        .collect::<Vec<_>>();
421
422    flex_layout_from_measured(style, items, constraints, &resolved_sizes)
423}
424
425pub fn arrange_flex(
426    style: FlexStyle,
427    items: &[FlexItem],
428    container_size: Size,
429    measured_sizes: &[Size],
430) -> FlexLayout {
431    flex_layout_from_measured(
432        style,
433        items,
434        Constraints::tight(Size::new(
435            finite_non_negative(container_size.width),
436            finite_non_negative(container_size.height),
437        )),
438        measured_sizes,
439    )
440}
441
442#[derive(Debug, Clone, Copy, PartialEq, Default)]
443pub struct Padding {
444    pub left: f32,
445    pub top: f32,
446    pub right: f32,
447    pub bottom: f32,
448}
449
450impl Padding {
451    pub const ZERO: Self = Self::all(0.0);
452
453    pub const fn all(value: f32) -> Self {
454        Self {
455            left: value,
456            top: value,
457            right: value,
458            bottom: value,
459        }
460    }
461
462    pub fn inset(self, size: Size) -> Size {
463        Size::new(
464            (size.width - (self.left + self.right)).max(0.0),
465            (size.height - (self.top + self.bottom)).max(0.0),
466        )
467    }
468
469    pub const fn offset(self) -> Point {
470        Point::new(self.left, self.top)
471    }
472}
473
474#[derive(Debug, Clone, Copy, PartialEq)]
475pub struct Constraints {
476    pub min: Size,
477    pub max: Size,
478}
479
480impl Constraints {
481    pub const UNBOUNDED: Self = Self {
482        min: Size::ZERO,
483        max: Size::new(f32::INFINITY, f32::INFINITY),
484    };
485
486    pub const fn new(min: Size, max: Size) -> Self {
487        Self { min, max }
488    }
489
490    pub const fn tight(size: Size) -> Self {
491        Self {
492            min: size,
493            max: size,
494        }
495    }
496
497    pub fn loosen(self) -> Self {
498        Self {
499            min: Size::ZERO,
500            max: self.max,
501        }
502    }
503
504    pub fn clamp(self, size: Size) -> Size {
505        Size::new(
506            size.width.clamp(self.min.width, self.max.width),
507            size.height.clamp(self.min.height, self.max.height),
508        )
509    }
510}
511
512#[derive(Debug, Clone)]
513pub struct LayoutContext {
514    dpi_info: DpiInfo,
515    text_system: Arc<TextSystem>,
516    font_registry: Arc<FontRegistry>,
517    image_registry: Arc<ImageRegistry>,
518}
519
520impl LayoutContext {
521    pub fn new(
522        dpi_info: DpiInfo,
523        text_system: Arc<TextSystem>,
524        font_registry: Arc<FontRegistry>,
525        image_registry: Arc<ImageRegistry>,
526    ) -> Self {
527        Self {
528            dpi_info,
529            text_system,
530            font_registry,
531            image_registry,
532        }
533    }
534
535    pub const fn dpi(&self) -> DpiInfo {
536        self.dpi_info
537    }
538
539    pub fn measure_text(
540        &self,
541        text: impl Into<String>,
542        style: TextStyle,
543    ) -> sui_core::Result<TextMeasurement> {
544        self.text_system
545            .measure_text(text, style, self.font_registry.as_ref())
546    }
547
548    pub fn measure_document(&self, document: TextDocument) -> sui_core::Result<TextMeasurement> {
549        self.text_system
550            .measure_document(document, self.font_registry.as_ref())
551    }
552
553    /// Advance width and natural line-box height, without materializing text geometry.
554    pub fn measure_text_size(
555        &self,
556        text: impl Into<String>,
557        style: TextStyle,
558    ) -> sui_core::Result<Size> {
559        self.text_system
560            .measure_text_size(text, style, self.font_registry.as_ref())
561    }
562
563    /// Size-only document layout using the same line breaker as layout_document.
564    pub fn measure_document_size(&self, request: TextLayoutRequest) -> sui_core::Result<Size> {
565        self.text_system
566            .measure_document_size(request, self.font_registry.as_ref())
567    }
568
569    pub fn shape_text(
570        &self,
571        text: impl Into<String>,
572        box_size: Size,
573        style: TextStyle,
574    ) -> sui_core::Result<TextLayout> {
575        self.text_system
576            .shape_text(text, box_size, style, self.font_registry.as_ref())
577    }
578
579    pub fn shape_text_persistent(
580        &self,
581        handle: Option<TextLayoutHandle>,
582        text: impl Into<String>,
583        box_size: Size,
584        style: TextStyle,
585    ) -> sui_core::Result<PersistentTextLayout> {
586        self.text_system.shape_text_persistent(
587            handle,
588            text,
589            box_size,
590            style,
591            self.font_registry.as_ref(),
592        )
593    }
594
595    pub fn layout_document(&self, request: TextLayoutRequest) -> sui_core::Result<TextLayout> {
596        self.text_system
597            .layout_document(request, self.font_registry.as_ref())
598    }
599
600    pub fn layout_document_persistent(
601        &self,
602        handle: Option<TextLayoutHandle>,
603        request: TextLayoutRequest,
604    ) -> sui_core::Result<PersistentTextLayout> {
605        self.text_system
606            .layout_document_persistent(handle, request, self.font_registry.as_ref())
607    }
608
609    pub fn image_size(&self, image: ImageHandle) -> Option<Size> {
610        self.image_registry
611            .dimensions(image)
612            .map(|(width, height)| Size::new(width as f32, height as f32))
613    }
614}
615
616impl Default for Constraints {
617    fn default() -> Self {
618        Self::UNBOUNDED
619    }
620}
621
622#[derive(Debug, Clone, Copy)]
623struct ResolvedFlexItem {
624    measured_size: Size,
625    base_size: Size,
626}
627
628#[derive(Debug, Clone, Copy)]
629struct FlexLine {
630    start: usize,
631    end: usize,
632    main: f32,
633    cross: f32,
634}
635
636fn flex_layout_from_measured(
637    style: FlexStyle,
638    items: &[FlexItem],
639    constraints: Constraints,
640    measured_sizes: &[Size],
641) -> FlexLayout {
642    if items.is_empty() {
643        return FlexLayout::empty(constraints.clamp(Size::ZERO));
644    }
645
646    let (_, initial_lines) = resolve_flex_lines(style, items, constraints, measured_sizes);
647    let natural_size = natural_flex_size(style, &initial_lines);
648    let size = constraints.clamp(natural_size);
649    let arrange_constraints = Constraints::tight(size);
650    let (resolved, lines) = resolve_flex_lines(style, items, arrange_constraints, measured_sizes);
651
652    arrange_resolved_flex(style, items, size, &resolved, &lines)
653}
654
655fn resolve_flex_lines(
656    style: FlexStyle,
657    items: &[FlexItem],
658    constraints: Constraints,
659    measured_sizes: &[Size],
660) -> (Vec<ResolvedFlexItem>, Vec<FlexLine>) {
661    let main_gap = finite_non_negative(style.main_gap);
662    let available_main = axis_main(style.axis, constraints.max);
663    let wrap_limit = if style.wrap == FlexWrap::Wrap && available_main.is_finite() {
664        available_main.max(0.0)
665    } else {
666        f32::INFINITY
667    };
668
669    let resolved = items
670        .iter()
671        .enumerate()
672        .map(|(index, item)| {
673            let measured = measured_sizes.get(index).copied().unwrap_or(Size::ZERO);
674            resolve_flex_item(style.axis, style.main_gap, *item, constraints, measured)
675        })
676        .collect::<Vec<_>>();
677
678    let mut lines = Vec::new();
679    let mut start = 0usize;
680    let mut main = 0.0f32;
681    let mut cross = 0.0f32;
682
683    for (index, item) in resolved.iter().enumerate() {
684        let item_main = axis_main(style.axis, item.base_size);
685        let item_cross = axis_cross(style.axis, item.base_size);
686        let spacing_before = if index == start { 0.0 } else { main_gap };
687
688        if style.wrap == FlexWrap::Wrap
689            && index > start
690            && main + spacing_before + item_main > wrap_limit + FLEX_EPSILON
691        {
692            lines.push(FlexLine {
693                start,
694                end: index,
695                main,
696                cross,
697            });
698            start = index;
699            main = item_main;
700            cross = item_cross;
701        } else {
702            main += spacing_before + item_main;
703            cross = cross.max(item_cross);
704        }
705    }
706
707    lines.push(FlexLine {
708        start,
709        end: resolved.len(),
710        main,
711        cross,
712    });
713
714    (resolved, lines)
715}
716
717fn resolve_flex_item(
718    axis: Axis,
719    main_gap: f32,
720    item: FlexItem,
721    constraints: Constraints,
722    measured_size: Size,
723) -> ResolvedFlexItem {
724    let measured_size = clamp_item_size(item, measured_size);
725    let min_main = item_min_main(axis, item);
726    let max_main = item_max_main(axis, item);
727    let min_cross = item_min_cross(axis, item);
728    let max_cross = item_max_cross(axis, item);
729
730    let base_main = basis_main_size(axis, main_gap, item.basis, constraints, measured_size)
731        .clamp(min_main, max_main);
732    let base_cross = axis_cross(axis, measured_size).clamp(min_cross, max_cross);
733
734    ResolvedFlexItem {
735        measured_size,
736        base_size: axis_size(axis, base_main, base_cross),
737    }
738}
739
740fn natural_flex_size(style: FlexStyle, lines: &[FlexLine]) -> Size {
741    let main = lines.iter().map(|line| line.main).fold(0.0f32, f32::max);
742    let cross_gap = finite_non_negative(style.cross_gap);
743    let cross = lines
744        .iter()
745        .enumerate()
746        .map(|(index, line)| line.cross + if index == 0 { 0.0 } else { cross_gap })
747        .sum();
748
749    axis_size(style.axis, main, cross)
750}
751
752fn arrange_resolved_flex(
753    style: FlexStyle,
754    items: &[FlexItem],
755    size: Size,
756    resolved: &[ResolvedFlexItem],
757    lines: &[FlexLine],
758) -> FlexLayout {
759    if lines.is_empty() {
760        return FlexLayout::empty(size);
761    }
762
763    let main_gap = finite_non_negative(style.main_gap);
764    let cross_gap = finite_non_negative(style.cross_gap);
765    let container_main = axis_main(style.axis, size);
766    let container_cross = axis_cross(style.axis, size);
767    let natural_cross = lines
768        .iter()
769        .enumerate()
770        .map(|(index, line)| line.cross + if index == 0 { 0.0 } else { cross_gap })
771        .sum::<f32>();
772    let extra_cross = (container_cross - natural_cross).max(0.0);
773    let line_count = lines.len();
774    let (cross_start, arranged_cross_gap, stretch_cross) =
775        cross_distribution(style.align_content, line_count, cross_gap, extra_cross);
776
777    let mut item_layouts = Vec::with_capacity(resolved.len());
778    let mut line_layouts = Vec::with_capacity(lines.len());
779    let mut cross_cursor = cross_start;
780
781    for (line_index, line) in lines.iter().enumerate() {
782        let count = line.end - line.start;
783        let line_cross = line.cross + stretch_cross;
784        let line_items = &resolved[line.start..line.end];
785        let target_mains = flex_line_main_sizes(
786            style.axis,
787            &items[line.start..line.end],
788            line_items,
789            container_main,
790            main_gap,
791        );
792        let used_main = target_mains.iter().sum::<f32>();
793        let gap_total = main_gap * count.saturating_sub(1) as f32;
794        let leftover_main = (container_main - used_main - gap_total).max(0.0);
795        let (main_start, arranged_main_gap) =
796            main_distribution(style.justify, count, main_gap, leftover_main);
797        let mut main_cursor = main_start;
798
799        for (offset, target_main) in target_mains.into_iter().enumerate() {
800            let index = line.start + offset;
801            let item = items[index];
802            let resolved_item = resolved[index];
803            let alignment = item.align_self.unwrap_or(style.align_items);
804            let item_cross = arranged_cross_size(
805                style.axis,
806                item,
807                alignment,
808                resolved_item.base_size,
809                line_cross,
810            );
811            let cross_offset = aligned_offset(alignment, line_cross - item_cross);
812            let rect = axis_rect(
813                style.axis,
814                main_cursor,
815                cross_cursor + cross_offset,
816                target_main,
817                item_cross,
818            );
819
820            item_layouts.push(FlexItemLayout {
821                rect,
822                measured_size: resolved_item.measured_size,
823                line: line_index,
824            });
825            main_cursor += target_main + arranged_main_gap;
826        }
827
828        line_layouts.push(FlexLineLayout {
829            item_start: line.start,
830            item_end: line.end,
831            rect: axis_rect(style.axis, 0.0, cross_cursor, container_main, line_cross),
832        });
833        cross_cursor += line_cross + arranged_cross_gap;
834    }
835
836    FlexLayout {
837        size,
838        items: item_layouts,
839        lines: line_layouts,
840    }
841}
842
843fn flex_line_main_sizes(
844    axis: Axis,
845    items: &[FlexItem],
846    line_items: &[ResolvedFlexItem],
847    container_main: f32,
848    main_gap: f32,
849) -> Vec<f32> {
850    let count = line_items.len();
851    let gap_total = finite_non_negative(main_gap) * count.saturating_sub(1) as f32;
852    let available_for_items = if container_main.is_finite() {
853        (container_main - gap_total).max(0.0)
854    } else {
855        line_items
856            .iter()
857            .map(|item| axis_main(axis, item.base_size))
858            .sum()
859    };
860    let base_sum = line_items
861        .iter()
862        .map(|item| axis_main(axis, item.base_size))
863        .sum::<f32>();
864    let free = available_for_items - base_sum;
865
866    if free > 0.0 {
867        if items
868            .iter()
869            .any(|item| finite_non_negative(item.grow) > 0.0)
870        {
871            return distribute_grow_space(axis, items, line_items, available_for_items);
872        }
873    } else if free < 0.0 {
874        let deficit = -free;
875        let total_shrink = items
876            .iter()
877            .zip(line_items.iter())
878            .map(|(item, resolved)| {
879                finite_non_negative(item.shrink) * axis_main(axis, resolved.base_size)
880            })
881            .sum::<f32>();
882        if total_shrink > 0.0 {
883            return items
884                .iter()
885                .zip(line_items.iter())
886                .map(|(item, resolved)| {
887                    let base = axis_main(axis, resolved.base_size);
888                    let weight = finite_non_negative(item.shrink) * base;
889                    let min = item_min_main(axis, *item);
890                    (base - (deficit * weight / total_shrink)).max(min)
891                })
892                .collect();
893        }
894    }
895
896    line_items
897        .iter()
898        .map(|item| axis_main(axis, item.base_size))
899        .collect()
900}
901
902fn distribute_grow_space(
903    axis: Axis,
904    items: &[FlexItem],
905    line_items: &[ResolvedFlexItem],
906    available_for_items: f32,
907) -> Vec<f32> {
908    let mut sizes = line_items
909        .iter()
910        .map(|item| axis_main(axis, item.base_size))
911        .collect::<Vec<_>>();
912    let mut frozen = vec![false; sizes.len()];
913
914    loop {
915        let remaining = available_for_items - sizes.iter().sum::<f32>();
916        if remaining <= FLEX_EPSILON {
917            break;
918        }
919
920        let total_grow = items
921            .iter()
922            .zip(frozen.iter())
923            .filter(|(_, frozen)| !**frozen)
924            .map(|(item, _)| finite_non_negative(item.grow))
925            .sum::<f32>();
926        if total_grow <= FLEX_EPSILON {
927            break;
928        }
929
930        let mut clamped = false;
931        for index in 0..sizes.len() {
932            if frozen[index] {
933                continue;
934            }
935
936            let grow = finite_non_negative(items[index].grow);
937            if grow <= 0.0 {
938                frozen[index] = true;
939                continue;
940            }
941
942            let proposed = sizes[index] + (remaining * grow / total_grow);
943            let max = item_max_main(axis, items[index]);
944            if proposed >= max - FLEX_EPSILON {
945                sizes[index] = max;
946                frozen[index] = true;
947                clamped = true;
948            } else {
949                sizes[index] = proposed;
950            }
951        }
952
953        if !clamped {
954            break;
955        }
956    }
957
958    sizes
959}
960
961fn flex_child_constraints(
962    style: FlexStyle,
963    item: FlexItem,
964    constraints: Constraints,
965) -> Constraints {
966    let min_main = item_min_main(style.axis, item);
967    let max_main = match item.basis {
968        FlexBasis::Auto => axis_main(style.axis, constraints.max),
969        FlexBasis::Points(points) => finite_non_negative(points),
970        FlexBasis::Fraction(fraction) => flex_fraction_constraint_main_size(
971            style.axis,
972            constraints,
973            finite_non_negative(fraction),
974        ),
975        FlexBasis::GapAwareFraction(fraction) => flex_gap_aware_fraction_constraint_main_size(
976            style.axis,
977            constraints,
978            style.main_gap,
979            finite_non_negative(fraction),
980        ),
981    }
982    .min(item_max_main(style.axis, item))
983    .max(min_main);
984    let max_cross = axis_cross(style.axis, constraints.max)
985        .min(item_max_cross(style.axis, item))
986        .max(0.0);
987    let alignment = item.align_self.unwrap_or(style.align_items);
988    let min_cross = if alignment == Alignment::Stretch && max_cross.is_finite() {
989        max_cross
990    } else {
991        item_min_cross(style.axis, item).min(max_cross)
992    };
993
994    axis_constraints(style.axis, min_main, max_main, min_cross, max_cross)
995}
996
997fn resolved_flex_child_constraints(
998    style: FlexStyle,
999    item: FlexItem,
1000    constraints: Constraints,
1001    resolved_main: f32,
1002) -> Constraints {
1003    let intrinsic = flex_child_constraints(style, item, constraints);
1004    let min_cross = axis_cross(style.axis, intrinsic.min);
1005    let max_cross = axis_cross(style.axis, intrinsic.max);
1006    let resolved_main = finite_non_negative(resolved_main).clamp(
1007        item_min_main(style.axis, item),
1008        item_max_main(style.axis, item),
1009    );
1010
1011    axis_constraints(
1012        style.axis,
1013        resolved_main,
1014        resolved_main,
1015        min_cross,
1016        max_cross,
1017    )
1018}
1019
1020fn arranged_cross_size(
1021    axis: Axis,
1022    item: FlexItem,
1023    alignment: Alignment,
1024    base_size: Size,
1025    line_cross: f32,
1026) -> f32 {
1027    let min = item_min_cross(axis, item);
1028    let max = item_max_cross(axis, item);
1029    if alignment == Alignment::Stretch {
1030        line_cross.clamp(min, max)
1031    } else {
1032        axis_cross(axis, base_size).min(line_cross).clamp(min, max)
1033    }
1034}
1035
1036fn basis_main_size(
1037    axis: Axis,
1038    main_gap: f32,
1039    basis: FlexBasis,
1040    constraints: Constraints,
1041    measured_size: Size,
1042) -> f32 {
1043    match basis {
1044        FlexBasis::Auto => axis_main(axis, measured_size),
1045        FlexBasis::Points(points) => finite_non_negative(points),
1046        FlexBasis::Fraction(fraction) => {
1047            let available = axis_main(axis, constraints.max);
1048            if available.is_finite() {
1049                available.max(0.0) * finite_non_negative(fraction)
1050            } else {
1051                axis_main(axis, measured_size)
1052            }
1053        }
1054        FlexBasis::GapAwareFraction(fraction) => {
1055            let available = axis_main(axis, constraints.max);
1056            if available.is_finite() {
1057                gap_aware_fraction_basis(
1058                    available.max(0.0),
1059                    main_gap,
1060                    finite_non_negative(fraction),
1061                )
1062            } else {
1063                axis_main(axis, measured_size)
1064            }
1065        }
1066    }
1067}
1068
1069fn flex_fraction_constraint_main_size(axis: Axis, constraints: Constraints, fraction: f32) -> f32 {
1070    let available = axis_main(axis, constraints.max);
1071    if available.is_finite() {
1072        available.max(0.0) * fraction
1073    } else {
1074        available
1075    }
1076}
1077
1078fn flex_gap_aware_fraction_constraint_main_size(
1079    axis: Axis,
1080    constraints: Constraints,
1081    main_gap: f32,
1082    fraction: f32,
1083) -> f32 {
1084    let available = axis_main(axis, constraints.max);
1085    if available.is_finite() {
1086        gap_aware_fraction_basis(available.max(0.0), main_gap, fraction)
1087    } else {
1088        available
1089    }
1090}
1091
1092fn gap_aware_fraction_basis(available: f32, gap: f32, fraction: f32) -> f32 {
1093    let gap_share = (1.0 - fraction).max(0.0);
1094    (available * fraction - finite_non_negative(gap) * gap_share).max(0.0)
1095}
1096
1097fn cross_distribution(
1098    alignment: FlexAlignContent,
1099    count: usize,
1100    gap: f32,
1101    extra: f32,
1102) -> (f32, f32, f32) {
1103    if count == 0 || extra <= 0.0 {
1104        return (0.0, gap, 0.0);
1105    }
1106
1107    match alignment {
1108        FlexAlignContent::Start => (0.0, gap, 0.0),
1109        FlexAlignContent::Center => (extra * 0.5, gap, 0.0),
1110        FlexAlignContent::End => (extra, gap, 0.0),
1111        FlexAlignContent::Stretch => (0.0, gap, extra / count as f32),
1112        FlexAlignContent::SpaceBetween if count > 1 => {
1113            (0.0, gap + (extra / (count - 1) as f32), 0.0)
1114        }
1115        FlexAlignContent::SpaceAround => {
1116            let distributed = extra / count as f32;
1117            (distributed * 0.5, gap + distributed, 0.0)
1118        }
1119        FlexAlignContent::SpaceEvenly => {
1120            let distributed = extra / (count + 1) as f32;
1121            (distributed, gap + distributed, 0.0)
1122        }
1123        FlexAlignContent::SpaceBetween => (0.0, gap, 0.0),
1124    }
1125}
1126
1127fn main_distribution(justify: FlexJustify, count: usize, gap: f32, leftover: f32) -> (f32, f32) {
1128    if count == 0 || leftover <= 0.0 {
1129        return (0.0, gap);
1130    }
1131
1132    match justify {
1133        FlexJustify::Start => (0.0, gap),
1134        FlexJustify::Center => (leftover * 0.5, gap),
1135        FlexJustify::End => (leftover, gap),
1136        FlexJustify::SpaceBetween if count > 1 => (0.0, gap + (leftover / (count - 1) as f32)),
1137        FlexJustify::SpaceAround => {
1138            let distributed = leftover / count as f32;
1139            (distributed * 0.5, gap + distributed)
1140        }
1141        FlexJustify::SpaceEvenly => {
1142            let distributed = leftover / (count + 1) as f32;
1143            (distributed, gap + distributed)
1144        }
1145        FlexJustify::SpaceBetween => (0.0, gap),
1146    }
1147}
1148
1149fn clamp_item_size(item: FlexItem, size: Size) -> Size {
1150    Size::new(
1151        size.width.clamp(
1152            finite_non_negative(item.min_size.width),
1153            item_max_width(item),
1154        ),
1155        size.height.clamp(
1156            finite_non_negative(item.min_size.height),
1157            item_max_height(item),
1158        ),
1159    )
1160}
1161
1162fn axis_constraints(
1163    axis: Axis,
1164    min_main: f32,
1165    max_main: f32,
1166    min_cross: f32,
1167    max_cross: f32,
1168) -> Constraints {
1169    match axis {
1170        Axis::Horizontal => Constraints::new(
1171            Size::new(min_main, min_cross),
1172            Size::new(max_main, max_cross),
1173        ),
1174        Axis::Vertical => Constraints::new(
1175            Size::new(min_cross, min_main),
1176            Size::new(max_cross, max_main),
1177        ),
1178    }
1179}
1180
1181fn axis_main(axis: Axis, size: Size) -> f32 {
1182    match axis {
1183        Axis::Horizontal => size.width,
1184        Axis::Vertical => size.height,
1185    }
1186}
1187
1188fn axis_cross(axis: Axis, size: Size) -> f32 {
1189    match axis {
1190        Axis::Horizontal => size.height,
1191        Axis::Vertical => size.width,
1192    }
1193}
1194
1195fn axis_size(axis: Axis, main: f32, cross: f32) -> Size {
1196    match axis {
1197        Axis::Horizontal => Size::new(main, cross),
1198        Axis::Vertical => Size::new(cross, main),
1199    }
1200}
1201
1202fn axis_rect(axis: Axis, main: f32, cross: f32, main_size: f32, cross_size: f32) -> Rect {
1203    match axis {
1204        Axis::Horizontal => Rect::new(main, cross, main_size, cross_size),
1205        Axis::Vertical => Rect::new(cross, main, cross_size, main_size),
1206    }
1207}
1208
1209fn aligned_offset(alignment: Alignment, remaining: f32) -> f32 {
1210    let remaining = remaining.max(0.0);
1211    match alignment {
1212        Alignment::Start | Alignment::Stretch => 0.0,
1213        Alignment::Center => remaining * 0.5,
1214        Alignment::End => remaining,
1215    }
1216}
1217
1218fn item_min_main(axis: Axis, item: FlexItem) -> f32 {
1219    axis_main(axis, item.min_size).max(0.0)
1220}
1221
1222fn item_max_main(axis: Axis, item: FlexItem) -> f32 {
1223    axis_main(axis, Size::new(item_max_width(item), item_max_height(item)))
1224        .max(item_min_main(axis, item))
1225}
1226
1227fn item_min_cross(axis: Axis, item: FlexItem) -> f32 {
1228    axis_cross(axis, item.min_size).max(0.0)
1229}
1230
1231fn item_max_cross(axis: Axis, item: FlexItem) -> f32 {
1232    axis_cross(axis, Size::new(item_max_width(item), item_max_height(item)))
1233        .max(item_min_cross(axis, item))
1234}
1235
1236fn item_max_width(item: FlexItem) -> f32 {
1237    non_negative_or_infinity(item.max_size.width).max(finite_non_negative(item.min_size.width))
1238}
1239
1240fn item_max_height(item: FlexItem) -> f32 {
1241    non_negative_or_infinity(item.max_size.height).max(finite_non_negative(item.min_size.height))
1242}
1243
1244fn finite_non_negative(value: f32) -> f32 {
1245    if value.is_finite() {
1246        value.max(0.0)
1247    } else {
1248        0.0
1249    }
1250}
1251
1252fn non_negative_or_infinity(value: f32) -> f32 {
1253    if value.is_nan() || value < 0.0 {
1254        0.0
1255    } else {
1256        value
1257    }
1258}
1259
1260#[cfg(test)]
1261mod tests {
1262    use std::sync::Arc;
1263
1264    use super::{
1265        Alignment, Constraints, FlexAlignContent, FlexItem, FlexJustify, FlexStyle, FlexWrap,
1266        LayoutContext, arrange_flex, flex_layout,
1267    };
1268    use sui_core::{Color, DpiInfo, ImageHandle, Rect, Size};
1269    use sui_scene::{ImageRegistry, RegisteredImage};
1270    use sui_text::{FontRegistry, TextStyle, TextSystem};
1271
1272    fn assert_rect_approx_eq(actual: Rect, expected: Rect) {
1273        assert!((actual.x() - expected.x()).abs() < 0.001);
1274        assert!((actual.y() - expected.y()).abs() < 0.001);
1275        assert!((actual.width() - expected.width()).abs() < 0.001);
1276        assert!((actual.height() - expected.height()).abs() < 0.001);
1277    }
1278
1279    #[test]
1280    fn layout_context_measures_text_and_images_without_runtime_widget_state() {
1281        let mut images = ImageRegistry::new();
1282        images.insert(
1283            ImageHandle::new(7),
1284            RegisteredImage::from_rgba8(4, 2, vec![255; 4 * 2 * 4]).unwrap(),
1285        );
1286
1287        let layout = LayoutContext::new(
1288            DpiInfo::new(
1289                2.0,
1290                Some(192.0),
1291                Size::new(320.0, 180.0),
1292                Size::new(640.0, 360.0),
1293            ),
1294            Arc::new(TextSystem::new()),
1295            Arc::new(FontRegistry::new()),
1296            Arc::new(images),
1297        );
1298
1299        let measurement = layout
1300            .measure_text("hello", TextStyle::new(Color::WHITE))
1301            .unwrap();
1302
1303        assert!(measurement.width > 0.0);
1304        assert_eq!(layout.dpi().effective_dpi(), 192.0);
1305        assert_eq!(
1306            layout.image_size(ImageHandle::new(7)),
1307            Some(Size::new(4.0, 2.0))
1308        );
1309    }
1310
1311    #[test]
1312    fn phased_flex_commits_even_when_probe_constraints_are_unchanged() {
1313        use super::{FlexMeasurePhase, flex_layout_with_probes};
1314        let items = [FlexItem::fill()];
1315        let constraints = Constraints::tight(Size::ZERO);
1316        let mut phases = Vec::new();
1317        let layout = flex_layout_with_probes(
1318            FlexStyle::horizontal(),
1319            &items,
1320            constraints,
1321            |_, c, phase| {
1322                phases.push((phase, c));
1323                Size::ZERO
1324            },
1325        );
1326        assert_eq!(phases.len(), 2);
1327        assert_eq!(phases[0].0, FlexMeasurePhase::Probe);
1328        assert_eq!(phases[1].0, FlexMeasurePhase::Commit);
1329        assert_eq!(phases[0].1, phases[1].1);
1330        assert_eq!(
1331            layout,
1332            flex_layout(FlexStyle::horizontal(), &items, constraints, |_, _| {
1333                Size::ZERO
1334            })
1335        );
1336    }
1337
1338    #[test]
1339    fn flex_layout_distributes_grow_space() {
1340        let items = [
1341            FlexItem::new(),
1342            FlexItem::new().grow(1.0),
1343            FlexItem::new().grow(2.0),
1344        ];
1345        let measured = [
1346            Size::new(20.0, 10.0),
1347            Size::new(10.0, 10.0),
1348            Size::new(10.0, 10.0),
1349        ];
1350        let layout = flex_layout(
1351            FlexStyle::horizontal(),
1352            &items,
1353            Constraints::tight(Size::new(100.0, 20.0)),
1354            |index, _| measured[index],
1355        );
1356
1357        assert_eq!(layout.size, Size::new(100.0, 20.0));
1358        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 10.0));
1359        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 30.0, 10.0));
1360        assert_rect_approx_eq(layout.items[2].rect, Rect::new(50.0, 0.0, 50.0, 10.0));
1361    }
1362
1363    #[test]
1364    fn flex_item_fill_creates_equal_columns() {
1365        let items = [FlexItem::fill(), FlexItem::fill()];
1366        let layout = flex_layout(
1367            FlexStyle::horizontal(),
1368            &items,
1369            Constraints::tight(Size::new(100.0, 12.0)),
1370            |_, _| Size::new(20.0, 10.0),
1371        );
1372
1373        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 50.0, 10.0));
1374        assert_rect_approx_eq(layout.items[1].rect, Rect::new(50.0, 0.0, 50.0, 10.0));
1375    }
1376
1377    #[test]
1378    fn flex_layout_remeasures_grown_children_at_their_resolved_main_size() {
1379        let items = [FlexItem::flex(1.0)];
1380        let mut seen = Vec::new();
1381        let layout = flex_layout(
1382            FlexStyle::horizontal(),
1383            &items,
1384            Constraints::new(Size::new(240.0, 0.0), Size::new(240.0, 200.0)),
1385            |_, constraints| {
1386                seen.push(constraints);
1387                if constraints.max.width <= 1.0 {
1388                    Size::new(constraints.max.width, 160.0)
1389                } else {
1390                    Size::new(constraints.max.width, 20.0)
1391                }
1392            },
1393        );
1394
1395        assert_eq!(seen.len(), 2);
1396        assert_eq!(seen[0].max.width, 0.0);
1397        assert_eq!(seen[1].min.width, 240.0);
1398        assert_eq!(seen[1].max.width, 240.0);
1399        assert_eq!(layout.size, Size::new(240.0, 20.0));
1400        assert_eq!(layout.items[0].measured_size, Size::new(240.0, 20.0));
1401        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 240.0, 20.0));
1402    }
1403
1404    #[test]
1405    fn flex_layout_supports_fraction_basis() {
1406        let items = [
1407            FlexItem::new().basis_fraction(0.25),
1408            FlexItem::new().basis_fraction(0.75),
1409        ];
1410        let layout = flex_layout(
1411            FlexStyle::horizontal(),
1412            &items,
1413            Constraints::tight(Size::new(200.0, 12.0)),
1414            |_, _| Size::new(10.0, 10.0),
1415        );
1416
1417        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 50.0, 10.0));
1418        assert_rect_approx_eq(layout.items[1].rect, Rect::new(50.0, 0.0, 150.0, 10.0));
1419    }
1420
1421    #[test]
1422    fn flex_layout_supports_gap_aware_fraction_basis() {
1423        let items = [
1424            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1425            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1426            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1427        ];
1428        let layout = flex_layout(
1429            FlexStyle::horizontal().gap(10.0),
1430            &items,
1431            Constraints::tight(Size::new(320.0, 12.0)),
1432            |_, _| Size::new(10.0, 10.0),
1433        );
1434
1435        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 100.0, 10.0));
1436        assert_rect_approx_eq(layout.items[1].rect, Rect::new(110.0, 0.0, 100.0, 10.0));
1437        assert_rect_approx_eq(layout.items[2].rect, Rect::new(220.0, 0.0, 100.0, 10.0));
1438    }
1439
1440    #[test]
1441    fn flex_layout_wraps_gap_aware_fraction_lines_after_full_rows() {
1442        let items = [
1443            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1444            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1445            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1446            FlexItem::new().basis_gap_aware_fraction(0.5),
1447            FlexItem::new().basis_gap_aware_fraction(0.5),
1448        ];
1449        let layout = flex_layout(
1450            FlexStyle::horizontal().wrap(FlexWrap::Wrap).gap(10.0),
1451            &items,
1452            Constraints::tight(Size::new(320.0, 100.0)),
1453            |_, _| Size::new(10.0, 10.0),
1454        );
1455
1456        assert_eq!(layout.lines.len(), 2);
1457        assert_eq!(layout.items[0].line, 0);
1458        assert_eq!(layout.items[2].line, 0);
1459        assert_eq!(layout.items[3].line, 1);
1460        assert_eq!(layout.items[4].line, 1);
1461        assert_rect_approx_eq(layout.items[3].rect, Rect::new(0.0, 20.0, 155.0, 10.0));
1462        assert_rect_approx_eq(layout.items[4].rect, Rect::new(165.0, 20.0, 155.0, 10.0));
1463    }
1464
1465    #[test]
1466    fn flex_layout_redistributes_grow_space_after_max_clamp() {
1467        let items = [FlexItem::fill().max_width(20.0), FlexItem::fill()];
1468        let layout = flex_layout(
1469            FlexStyle::horizontal(),
1470            &items,
1471            Constraints::tight(Size::new(100.0, 12.0)),
1472            |_, _| Size::new(0.0, 10.0),
1473        );
1474
1475        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 10.0));
1476        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 80.0, 10.0));
1477    }
1478
1479    #[test]
1480    fn flex_layout_shrinks_items_when_space_is_tight() {
1481        let items = [
1482            FlexItem::new().min_width(20.0),
1483            FlexItem::new().min_width(20.0),
1484        ];
1485        let layout = flex_layout(
1486            FlexStyle::horizontal(),
1487            &items,
1488            Constraints::tight(Size::new(100.0, 12.0)),
1489            |index, _| {
1490                if index == 0 {
1491                    Size::new(80.0, 10.0)
1492                } else {
1493                    Size::new(40.0, 10.0)
1494                }
1495            },
1496        );
1497
1498        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 66.666664, 10.0));
1499        assert_rect_approx_eq(
1500            layout.items[1].rect,
1501            Rect::new(66.666664, 0.0, 33.333332, 10.0),
1502        );
1503    }
1504
1505    #[test]
1506    fn flex_layout_wraps_lines_with_cross_gap() {
1507        let items = [FlexItem::new(), FlexItem::new(), FlexItem::new()];
1508        let measured = [
1509            Size::new(30.0, 10.0),
1510            Size::new(30.0, 10.0),
1511            Size::new(30.0, 10.0),
1512        ];
1513        let layout = flex_layout(
1514            FlexStyle::horizontal().wrap(FlexWrap::Wrap).gap(5.0),
1515            &items,
1516            Constraints::tight(Size::new(50.0, 40.0)),
1517            |index, _| measured[index],
1518        );
1519
1520        assert_eq!(layout.lines.len(), 3);
1521        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 30.0, 10.0));
1522        assert_rect_approx_eq(layout.items[1].rect, Rect::new(0.0, 15.0, 30.0, 10.0));
1523        assert_rect_approx_eq(layout.items[2].rect, Rect::new(0.0, 30.0, 30.0, 10.0));
1524    }
1525
1526    #[test]
1527    fn flex_layout_justifies_remaining_space_between_items() {
1528        let items = [FlexItem::new(), FlexItem::new(), FlexItem::new()];
1529        let layout = flex_layout(
1530            FlexStyle::horizontal().justify(FlexJustify::SpaceBetween),
1531            &items,
1532            Constraints::tight(Size::new(100.0, 10.0)),
1533            |_, _| Size::new(10.0, 10.0),
1534        );
1535
1536        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 10.0, 10.0));
1537        assert_rect_approx_eq(layout.items[1].rect, Rect::new(45.0, 0.0, 10.0, 10.0));
1538        assert_rect_approx_eq(layout.items[2].rect, Rect::new(90.0, 0.0, 10.0, 10.0));
1539    }
1540
1541    #[test]
1542    fn flex_layout_stretches_items_and_lines_on_cross_axis() {
1543        let items = [FlexItem::new(), FlexItem::new()];
1544        let layout = flex_layout(
1545            FlexStyle::horizontal()
1546                .align_items(Alignment::Stretch)
1547                .align_content(FlexAlignContent::Stretch),
1548            &items,
1549            Constraints::tight(Size::new(60.0, 20.0)),
1550            |_, _| Size::new(20.0, 8.0),
1551        );
1552
1553        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 20.0));
1554        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 20.0, 20.0));
1555    }
1556
1557    #[test]
1558    fn arrange_flex_uses_existing_measured_sizes() {
1559        let items = [FlexItem::new(), FlexItem::new().grow(1.0)];
1560        let layout = arrange_flex(
1561            FlexStyle::horizontal(),
1562            &items,
1563            Size::new(80.0, 12.0),
1564            &[Size::new(20.0, 8.0), Size::new(10.0, 8.0)],
1565        );
1566
1567        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 8.0));
1568        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 60.0, 8.0));
1569    }
1570}