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    MAX_GRID_TRACKS, 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    /// `size` within these constraints, as [`Size::clamp`] describes:
505    /// constraints that cannot hold a size don't panic.
506    pub fn clamp(self, size: Size) -> Size {
507        size.clamp(self.min, self.max)
508    }
509}
510
511#[derive(Debug, Clone)]
512pub struct LayoutContext {
513    dpi_info: DpiInfo,
514    text_system: Arc<TextSystem>,
515    font_registry: Arc<FontRegistry>,
516    image_registry: Arc<ImageRegistry>,
517}
518
519impl LayoutContext {
520    pub fn new(
521        dpi_info: DpiInfo,
522        text_system: Arc<TextSystem>,
523        font_registry: Arc<FontRegistry>,
524        image_registry: Arc<ImageRegistry>,
525    ) -> Self {
526        Self {
527            dpi_info,
528            text_system,
529            font_registry,
530            image_registry,
531        }
532    }
533
534    pub const fn dpi(&self) -> DpiInfo {
535        self.dpi_info
536    }
537
538    pub fn measure_text(
539        &self,
540        text: impl Into<String>,
541        style: TextStyle,
542    ) -> sui_core::Result<TextMeasurement> {
543        self.text_system
544            .measure_text(text, style, self.font_registry.as_ref())
545    }
546
547    pub fn measure_document(&self, document: TextDocument) -> sui_core::Result<TextMeasurement> {
548        self.text_system
549            .measure_document(document, self.font_registry.as_ref())
550    }
551
552    /// Advance width and natural line-box height, without materializing text geometry.
553    pub fn measure_text_size(
554        &self,
555        text: impl Into<String>,
556        style: TextStyle,
557    ) -> sui_core::Result<Size> {
558        self.text_system
559            .measure_text_size(text, style, self.font_registry.as_ref())
560    }
561
562    /// Size-only document layout using the same line breaker as layout_document.
563    pub fn measure_document_size(&self, request: TextLayoutRequest) -> sui_core::Result<Size> {
564        self.text_system
565            .measure_document_size(request, self.font_registry.as_ref())
566    }
567
568    pub fn shape_text(
569        &self,
570        text: impl Into<String>,
571        box_size: Size,
572        style: TextStyle,
573    ) -> sui_core::Result<TextLayout> {
574        self.text_system
575            .shape_text(text, box_size, style, self.font_registry.as_ref())
576    }
577
578    pub fn shape_text_persistent(
579        &self,
580        handle: Option<TextLayoutHandle>,
581        text: impl Into<String>,
582        box_size: Size,
583        style: TextStyle,
584    ) -> sui_core::Result<PersistentTextLayout> {
585        self.text_system.shape_text_persistent(
586            handle,
587            text,
588            box_size,
589            style,
590            self.font_registry.as_ref(),
591        )
592    }
593
594    pub fn layout_document(&self, request: TextLayoutRequest) -> sui_core::Result<TextLayout> {
595        self.text_system
596            .layout_document(request, self.font_registry.as_ref())
597    }
598
599    pub fn layout_document_persistent(
600        &self,
601        handle: Option<TextLayoutHandle>,
602        request: TextLayoutRequest,
603    ) -> sui_core::Result<PersistentTextLayout> {
604        self.text_system
605            .layout_document_persistent(handle, request, self.font_registry.as_ref())
606    }
607
608    pub fn image_size(&self, image: ImageHandle) -> Option<Size> {
609        self.image_registry
610            .dimensions(image)
611            .map(|(width, height)| Size::new(width as f32, height as f32))
612    }
613}
614
615impl Default for Constraints {
616    fn default() -> Self {
617        Self::UNBOUNDED
618    }
619}
620
621#[derive(Debug, Clone, Copy)]
622struct ResolvedFlexItem {
623    measured_size: Size,
624    base_size: Size,
625}
626
627#[derive(Debug, Clone, Copy)]
628struct FlexLine {
629    start: usize,
630    end: usize,
631    main: f32,
632    cross: f32,
633}
634
635fn flex_layout_from_measured(
636    style: FlexStyle,
637    items: &[FlexItem],
638    constraints: Constraints,
639    measured_sizes: &[Size],
640) -> FlexLayout {
641    if items.is_empty() {
642        return FlexLayout::empty(constraints.clamp(Size::ZERO));
643    }
644
645    let (_, initial_lines) = resolve_flex_lines(style, items, constraints, measured_sizes);
646    let natural_size = natural_flex_size(style, &initial_lines);
647    let size = constraints.clamp(natural_size);
648    let arrange_constraints = Constraints::tight(size);
649    let (resolved, lines) = resolve_flex_lines(style, items, arrange_constraints, measured_sizes);
650
651    arrange_resolved_flex(style, items, size, &resolved, &lines)
652}
653
654fn resolve_flex_lines(
655    style: FlexStyle,
656    items: &[FlexItem],
657    constraints: Constraints,
658    measured_sizes: &[Size],
659) -> (Vec<ResolvedFlexItem>, Vec<FlexLine>) {
660    let main_gap = finite_non_negative(style.main_gap);
661    let available_main = axis_main(style.axis, constraints.max);
662    let wrap_limit = if style.wrap == FlexWrap::Wrap && available_main.is_finite() {
663        available_main.max(0.0)
664    } else {
665        f32::INFINITY
666    };
667
668    let resolved = items
669        .iter()
670        .enumerate()
671        .map(|(index, item)| {
672            let measured = measured_sizes.get(index).copied().unwrap_or(Size::ZERO);
673            resolve_flex_item(style.axis, style.main_gap, *item, constraints, measured)
674        })
675        .collect::<Vec<_>>();
676
677    let mut lines = Vec::new();
678    let mut start = 0usize;
679    let mut main = 0.0f32;
680    let mut cross = 0.0f32;
681
682    for (index, item) in resolved.iter().enumerate() {
683        let item_main = axis_main(style.axis, item.base_size);
684        let item_cross = axis_cross(style.axis, item.base_size);
685        let spacing_before = if index == start { 0.0 } else { main_gap };
686
687        if style.wrap == FlexWrap::Wrap
688            && index > start
689            && main + spacing_before + item_main > wrap_limit + FLEX_EPSILON
690        {
691            lines.push(FlexLine {
692                start,
693                end: index,
694                main,
695                cross,
696            });
697            start = index;
698            main = item_main;
699            cross = item_cross;
700        } else {
701            main += spacing_before + item_main;
702            cross = cross.max(item_cross);
703        }
704    }
705
706    lines.push(FlexLine {
707        start,
708        end: resolved.len(),
709        main,
710        cross,
711    });
712
713    (resolved, lines)
714}
715
716fn resolve_flex_item(
717    axis: Axis,
718    main_gap: f32,
719    item: FlexItem,
720    constraints: Constraints,
721    measured_size: Size,
722) -> ResolvedFlexItem {
723    let measured_size = clamp_item_size(item, measured_size);
724    let min_main = item_min_main(axis, item);
725    let max_main = item_max_main(axis, item);
726    let min_cross = item_min_cross(axis, item);
727    let max_cross = item_max_cross(axis, item);
728
729    let base_main = basis_main_size(axis, main_gap, item.basis, constraints, measured_size)
730        .clamp(min_main, max_main);
731    let base_cross = axis_cross(axis, measured_size).clamp(min_cross, max_cross);
732
733    ResolvedFlexItem {
734        measured_size,
735        base_size: axis_size(axis, base_main, base_cross),
736    }
737}
738
739fn natural_flex_size(style: FlexStyle, lines: &[FlexLine]) -> Size {
740    let main = lines.iter().map(|line| line.main).fold(0.0f32, f32::max);
741    let cross_gap = finite_non_negative(style.cross_gap);
742    let cross = lines
743        .iter()
744        .enumerate()
745        .map(|(index, line)| line.cross + if index == 0 { 0.0 } else { cross_gap })
746        .sum();
747
748    axis_size(style.axis, main, cross)
749}
750
751fn arrange_resolved_flex(
752    style: FlexStyle,
753    items: &[FlexItem],
754    size: Size,
755    resolved: &[ResolvedFlexItem],
756    lines: &[FlexLine],
757) -> FlexLayout {
758    if lines.is_empty() {
759        return FlexLayout::empty(size);
760    }
761
762    let main_gap = finite_non_negative(style.main_gap);
763    let cross_gap = finite_non_negative(style.cross_gap);
764    let container_main = axis_main(style.axis, size);
765    let container_cross = axis_cross(style.axis, size);
766    let natural_cross = lines
767        .iter()
768        .enumerate()
769        .map(|(index, line)| line.cross + if index == 0 { 0.0 } else { cross_gap })
770        .sum::<f32>();
771    let extra_cross = (container_cross - natural_cross).max(0.0);
772    let line_count = lines.len();
773    let (cross_start, arranged_cross_gap, stretch_cross) =
774        cross_distribution(style.align_content, line_count, cross_gap, extra_cross);
775
776    let mut item_layouts = Vec::with_capacity(resolved.len());
777    let mut line_layouts = Vec::with_capacity(lines.len());
778    let mut cross_cursor = cross_start;
779
780    for (line_index, line) in lines.iter().enumerate() {
781        let count = line.end - line.start;
782        let line_cross = line.cross + stretch_cross;
783        let line_items = &resolved[line.start..line.end];
784        let target_mains = flex_line_main_sizes(
785            style.axis,
786            &items[line.start..line.end],
787            line_items,
788            container_main,
789            main_gap,
790        );
791        let used_main = target_mains.iter().sum::<f32>();
792        let gap_total = main_gap * count.saturating_sub(1) as f32;
793        let leftover_main = (container_main - used_main - gap_total).max(0.0);
794        let (main_start, arranged_main_gap) =
795            main_distribution(style.justify, count, main_gap, leftover_main);
796        let mut main_cursor = main_start;
797
798        for (offset, target_main) in target_mains.into_iter().enumerate() {
799            let index = line.start + offset;
800            let item = items[index];
801            let resolved_item = resolved[index];
802            let alignment = item.align_self.unwrap_or(style.align_items);
803            let item_cross = arranged_cross_size(
804                style.axis,
805                item,
806                alignment,
807                resolved_item.base_size,
808                line_cross,
809            );
810            let cross_offset = aligned_offset(alignment, line_cross - item_cross);
811            let rect = axis_rect(
812                style.axis,
813                main_cursor,
814                cross_cursor + cross_offset,
815                target_main,
816                item_cross,
817            );
818
819            item_layouts.push(FlexItemLayout {
820                rect,
821                measured_size: resolved_item.measured_size,
822                line: line_index,
823            });
824            main_cursor += target_main + arranged_main_gap;
825        }
826
827        line_layouts.push(FlexLineLayout {
828            item_start: line.start,
829            item_end: line.end,
830            rect: axis_rect(style.axis, 0.0, cross_cursor, container_main, line_cross),
831        });
832        cross_cursor += line_cross + arranged_cross_gap;
833    }
834
835    FlexLayout {
836        size,
837        items: item_layouts,
838        lines: line_layouts,
839    }
840}
841
842fn flex_line_main_sizes(
843    axis: Axis,
844    items: &[FlexItem],
845    line_items: &[ResolvedFlexItem],
846    container_main: f32,
847    main_gap: f32,
848) -> Vec<f32> {
849    let count = line_items.len();
850    let gap_total = finite_non_negative(main_gap) * count.saturating_sub(1) as f32;
851    let available_for_items = if container_main.is_finite() {
852        (container_main - gap_total).max(0.0)
853    } else {
854        line_items
855            .iter()
856            .map(|item| axis_main(axis, item.base_size))
857            .sum()
858    };
859    let base_sum = line_items
860        .iter()
861        .map(|item| axis_main(axis, item.base_size))
862        .sum::<f32>();
863    let free = available_for_items - base_sum;
864
865    if free > 0.0 {
866        if items
867            .iter()
868            .any(|item| finite_non_negative(item.grow) > 0.0)
869        {
870            return distribute_grow_space(axis, items, line_items, available_for_items);
871        }
872    } else if free < 0.0 {
873        let deficit = -free;
874        let total_shrink = items
875            .iter()
876            .zip(line_items.iter())
877            .map(|(item, resolved)| {
878                finite_non_negative(item.shrink) * axis_main(axis, resolved.base_size)
879            })
880            .sum::<f32>();
881        if total_shrink > 0.0 {
882            return items
883                .iter()
884                .zip(line_items.iter())
885                .map(|(item, resolved)| {
886                    let base = axis_main(axis, resolved.base_size);
887                    let weight = finite_non_negative(item.shrink) * base;
888                    let min = item_min_main(axis, *item);
889                    (base - (deficit * weight / total_shrink)).max(min)
890                })
891                .collect();
892        }
893    }
894
895    line_items
896        .iter()
897        .map(|item| axis_main(axis, item.base_size))
898        .collect()
899}
900
901fn distribute_grow_space(
902    axis: Axis,
903    items: &[FlexItem],
904    line_items: &[ResolvedFlexItem],
905    available_for_items: f32,
906) -> Vec<f32> {
907    let mut sizes = line_items
908        .iter()
909        .map(|item| axis_main(axis, item.base_size))
910        .collect::<Vec<_>>();
911    let mut frozen = vec![false; sizes.len()];
912
913    loop {
914        let remaining = available_for_items - sizes.iter().sum::<f32>();
915        if remaining <= FLEX_EPSILON {
916            break;
917        }
918
919        let total_grow = items
920            .iter()
921            .zip(frozen.iter())
922            .filter(|(_, frozen)| !**frozen)
923            .map(|(item, _)| finite_non_negative(item.grow))
924            .sum::<f32>();
925        if total_grow <= FLEX_EPSILON {
926            break;
927        }
928
929        let mut clamped = false;
930        for index in 0..sizes.len() {
931            if frozen[index] {
932                continue;
933            }
934
935            let grow = finite_non_negative(items[index].grow);
936            if grow <= 0.0 {
937                frozen[index] = true;
938                continue;
939            }
940
941            let proposed = sizes[index] + (remaining * grow / total_grow);
942            let max = item_max_main(axis, items[index]);
943            if proposed >= max - FLEX_EPSILON {
944                sizes[index] = max;
945                frozen[index] = true;
946                clamped = true;
947            } else {
948                sizes[index] = proposed;
949            }
950        }
951
952        if !clamped {
953            break;
954        }
955    }
956
957    sizes
958}
959
960fn flex_child_constraints(
961    style: FlexStyle,
962    item: FlexItem,
963    constraints: Constraints,
964) -> Constraints {
965    let min_main = item_min_main(style.axis, item);
966    let max_main = match item.basis {
967        FlexBasis::Auto => axis_main(style.axis, constraints.max),
968        FlexBasis::Points(points) => finite_non_negative(points),
969        FlexBasis::Fraction(fraction) => flex_fraction_constraint_main_size(
970            style.axis,
971            constraints,
972            finite_non_negative(fraction),
973        ),
974        FlexBasis::GapAwareFraction(fraction) => flex_gap_aware_fraction_constraint_main_size(
975            style.axis,
976            constraints,
977            style.main_gap,
978            finite_non_negative(fraction),
979        ),
980    }
981    .min(item_max_main(style.axis, item))
982    .max(min_main);
983    let max_cross = axis_cross(style.axis, constraints.max)
984        .min(item_max_cross(style.axis, item))
985        .max(0.0);
986    let alignment = item.align_self.unwrap_or(style.align_items);
987    let min_cross = if alignment == Alignment::Stretch && max_cross.is_finite() {
988        max_cross
989    } else {
990        item_min_cross(style.axis, item).min(max_cross)
991    };
992
993    axis_constraints(style.axis, min_main, max_main, min_cross, max_cross)
994}
995
996fn resolved_flex_child_constraints(
997    style: FlexStyle,
998    item: FlexItem,
999    constraints: Constraints,
1000    resolved_main: f32,
1001) -> Constraints {
1002    let intrinsic = flex_child_constraints(style, item, constraints);
1003    let min_cross = axis_cross(style.axis, intrinsic.min);
1004    let max_cross = axis_cross(style.axis, intrinsic.max);
1005    let resolved_main = finite_non_negative(resolved_main).clamp(
1006        item_min_main(style.axis, item),
1007        item_max_main(style.axis, item),
1008    );
1009
1010    axis_constraints(
1011        style.axis,
1012        resolved_main,
1013        resolved_main,
1014        min_cross,
1015        max_cross,
1016    )
1017}
1018
1019fn arranged_cross_size(
1020    axis: Axis,
1021    item: FlexItem,
1022    alignment: Alignment,
1023    base_size: Size,
1024    line_cross: f32,
1025) -> f32 {
1026    let min = item_min_cross(axis, item);
1027    let max = item_max_cross(axis, item);
1028    if alignment == Alignment::Stretch {
1029        line_cross.clamp(min, max)
1030    } else {
1031        axis_cross(axis, base_size).min(line_cross).clamp(min, max)
1032    }
1033}
1034
1035fn basis_main_size(
1036    axis: Axis,
1037    main_gap: f32,
1038    basis: FlexBasis,
1039    constraints: Constraints,
1040    measured_size: Size,
1041) -> f32 {
1042    match basis {
1043        FlexBasis::Auto => axis_main(axis, measured_size),
1044        FlexBasis::Points(points) => finite_non_negative(points),
1045        FlexBasis::Fraction(fraction) => {
1046            let available = axis_main(axis, constraints.max);
1047            if available.is_finite() {
1048                available.max(0.0) * finite_non_negative(fraction)
1049            } else {
1050                axis_main(axis, measured_size)
1051            }
1052        }
1053        FlexBasis::GapAwareFraction(fraction) => {
1054            let available = axis_main(axis, constraints.max);
1055            if available.is_finite() {
1056                gap_aware_fraction_basis(
1057                    available.max(0.0),
1058                    main_gap,
1059                    finite_non_negative(fraction),
1060                )
1061            } else {
1062                axis_main(axis, measured_size)
1063            }
1064        }
1065    }
1066}
1067
1068fn flex_fraction_constraint_main_size(axis: Axis, constraints: Constraints, fraction: f32) -> f32 {
1069    let available = axis_main(axis, constraints.max);
1070    if available.is_finite() {
1071        available.max(0.0) * fraction
1072    } else {
1073        available
1074    }
1075}
1076
1077fn flex_gap_aware_fraction_constraint_main_size(
1078    axis: Axis,
1079    constraints: Constraints,
1080    main_gap: f32,
1081    fraction: f32,
1082) -> f32 {
1083    let available = axis_main(axis, constraints.max);
1084    if available.is_finite() {
1085        gap_aware_fraction_basis(available.max(0.0), main_gap, fraction)
1086    } else {
1087        available
1088    }
1089}
1090
1091fn gap_aware_fraction_basis(available: f32, gap: f32, fraction: f32) -> f32 {
1092    let gap_share = (1.0 - fraction).max(0.0);
1093    (available * fraction - finite_non_negative(gap) * gap_share).max(0.0)
1094}
1095
1096fn cross_distribution(
1097    alignment: FlexAlignContent,
1098    count: usize,
1099    gap: f32,
1100    extra: f32,
1101) -> (f32, f32, f32) {
1102    if count == 0 || extra <= 0.0 {
1103        return (0.0, gap, 0.0);
1104    }
1105
1106    match alignment {
1107        FlexAlignContent::Start => (0.0, gap, 0.0),
1108        FlexAlignContent::Center => (extra * 0.5, gap, 0.0),
1109        FlexAlignContent::End => (extra, gap, 0.0),
1110        FlexAlignContent::Stretch => (0.0, gap, extra / count as f32),
1111        FlexAlignContent::SpaceBetween if count > 1 => {
1112            (0.0, gap + (extra / (count - 1) as f32), 0.0)
1113        }
1114        FlexAlignContent::SpaceAround => {
1115            let distributed = extra / count as f32;
1116            (distributed * 0.5, gap + distributed, 0.0)
1117        }
1118        FlexAlignContent::SpaceEvenly => {
1119            let distributed = extra / (count + 1) as f32;
1120            (distributed, gap + distributed, 0.0)
1121        }
1122        FlexAlignContent::SpaceBetween => (0.0, gap, 0.0),
1123    }
1124}
1125
1126fn main_distribution(justify: FlexJustify, count: usize, gap: f32, leftover: f32) -> (f32, f32) {
1127    if count == 0 || leftover <= 0.0 {
1128        return (0.0, gap);
1129    }
1130
1131    match justify {
1132        FlexJustify::Start => (0.0, gap),
1133        FlexJustify::Center => (leftover * 0.5, gap),
1134        FlexJustify::End => (leftover, gap),
1135        FlexJustify::SpaceBetween if count > 1 => (0.0, gap + (leftover / (count - 1) as f32)),
1136        FlexJustify::SpaceAround => {
1137            let distributed = leftover / count as f32;
1138            (distributed * 0.5, gap + distributed)
1139        }
1140        FlexJustify::SpaceEvenly => {
1141            let distributed = leftover / (count + 1) as f32;
1142            (distributed, gap + distributed)
1143        }
1144        FlexJustify::SpaceBetween => (0.0, gap),
1145    }
1146}
1147
1148fn clamp_item_size(item: FlexItem, size: Size) -> Size {
1149    Size::new(
1150        size.width.clamp(
1151            finite_non_negative(item.min_size.width),
1152            item_max_width(item),
1153        ),
1154        size.height.clamp(
1155            finite_non_negative(item.min_size.height),
1156            item_max_height(item),
1157        ),
1158    )
1159}
1160
1161fn axis_constraints(
1162    axis: Axis,
1163    min_main: f32,
1164    max_main: f32,
1165    min_cross: f32,
1166    max_cross: f32,
1167) -> Constraints {
1168    match axis {
1169        Axis::Horizontal => Constraints::new(
1170            Size::new(min_main, min_cross),
1171            Size::new(max_main, max_cross),
1172        ),
1173        Axis::Vertical => Constraints::new(
1174            Size::new(min_cross, min_main),
1175            Size::new(max_cross, max_main),
1176        ),
1177    }
1178}
1179
1180fn axis_main(axis: Axis, size: Size) -> f32 {
1181    match axis {
1182        Axis::Horizontal => size.width,
1183        Axis::Vertical => size.height,
1184    }
1185}
1186
1187fn axis_cross(axis: Axis, size: Size) -> f32 {
1188    match axis {
1189        Axis::Horizontal => size.height,
1190        Axis::Vertical => size.width,
1191    }
1192}
1193
1194fn axis_size(axis: Axis, main: f32, cross: f32) -> Size {
1195    match axis {
1196        Axis::Horizontal => Size::new(main, cross),
1197        Axis::Vertical => Size::new(cross, main),
1198    }
1199}
1200
1201fn axis_rect(axis: Axis, main: f32, cross: f32, main_size: f32, cross_size: f32) -> Rect {
1202    match axis {
1203        Axis::Horizontal => Rect::new(main, cross, main_size, cross_size),
1204        Axis::Vertical => Rect::new(cross, main, cross_size, main_size),
1205    }
1206}
1207
1208fn aligned_offset(alignment: Alignment, remaining: f32) -> f32 {
1209    let remaining = remaining.max(0.0);
1210    match alignment {
1211        Alignment::Start | Alignment::Stretch => 0.0,
1212        Alignment::Center => remaining * 0.5,
1213        Alignment::End => remaining,
1214    }
1215}
1216
1217fn item_min_main(axis: Axis, item: FlexItem) -> f32 {
1218    axis_main(axis, item.min_size).max(0.0)
1219}
1220
1221fn item_max_main(axis: Axis, item: FlexItem) -> f32 {
1222    axis_main(axis, Size::new(item_max_width(item), item_max_height(item)))
1223        .max(item_min_main(axis, item))
1224}
1225
1226fn item_min_cross(axis: Axis, item: FlexItem) -> f32 {
1227    axis_cross(axis, item.min_size).max(0.0)
1228}
1229
1230fn item_max_cross(axis: Axis, item: FlexItem) -> f32 {
1231    axis_cross(axis, Size::new(item_max_width(item), item_max_height(item)))
1232        .max(item_min_cross(axis, item))
1233}
1234
1235fn item_max_width(item: FlexItem) -> f32 {
1236    non_negative_or_infinity(item.max_size.width).max(finite_non_negative(item.min_size.width))
1237}
1238
1239fn item_max_height(item: FlexItem) -> f32 {
1240    non_negative_or_infinity(item.max_size.height).max(finite_non_negative(item.min_size.height))
1241}
1242
1243fn finite_non_negative(value: f32) -> f32 {
1244    if value.is_finite() {
1245        value.max(0.0)
1246    } else {
1247        0.0
1248    }
1249}
1250
1251fn non_negative_or_infinity(value: f32) -> f32 {
1252    if value.is_nan() || value < 0.0 {
1253        0.0
1254    } else {
1255        value
1256    }
1257}
1258
1259#[cfg(test)]
1260mod tests {
1261    use std::sync::Arc;
1262
1263    use super::{
1264        Alignment, Constraints, FlexAlignContent, FlexItem, FlexJustify, FlexStyle, FlexWrap,
1265        LayoutContext, arrange_flex, flex_layout,
1266    };
1267    use sui_core::{Color, DpiInfo, ImageHandle, Rect, Size};
1268    use sui_scene::{ImageRegistry, RegisteredImage};
1269    use sui_text::{FontRegistry, TextStyle, TextSystem};
1270
1271    fn assert_rect_approx_eq(actual: Rect, expected: Rect) {
1272        assert!((actual.x() - expected.x()).abs() < 0.001);
1273        assert!((actual.y() - expected.y()).abs() < 0.001);
1274        assert!((actual.width() - expected.width()).abs() < 0.001);
1275        assert!((actual.height() - expected.height()).abs() < 0.001);
1276    }
1277
1278    #[test]
1279    fn layout_context_measures_text_and_images_without_runtime_widget_state() {
1280        let mut images = ImageRegistry::new();
1281        images.insert(
1282            ImageHandle::new(7),
1283            RegisteredImage::from_rgba8(4, 2, vec![255; 4 * 2 * 4]).unwrap(),
1284        );
1285
1286        let layout = LayoutContext::new(
1287            DpiInfo::new(
1288                2.0,
1289                Some(192.0),
1290                Size::new(320.0, 180.0),
1291                Size::new(640.0, 360.0),
1292            ),
1293            Arc::new(TextSystem::new()),
1294            Arc::new(FontRegistry::new()),
1295            Arc::new(images),
1296        );
1297
1298        let measurement = layout
1299            .measure_text("hello", TextStyle::new(Color::WHITE))
1300            .unwrap();
1301
1302        assert!(measurement.width > 0.0);
1303        assert_eq!(layout.dpi().effective_dpi(), 192.0);
1304        assert_eq!(
1305            layout.image_size(ImageHandle::new(7)),
1306            Some(Size::new(4.0, 2.0))
1307        );
1308    }
1309
1310    #[test]
1311    fn phased_flex_commits_even_when_probe_constraints_are_unchanged() {
1312        use super::{FlexMeasurePhase, flex_layout_with_probes};
1313        let items = [FlexItem::fill()];
1314        let constraints = Constraints::tight(Size::ZERO);
1315        let mut phases = Vec::new();
1316        let layout = flex_layout_with_probes(
1317            FlexStyle::horizontal(),
1318            &items,
1319            constraints,
1320            |_, c, phase| {
1321                phases.push((phase, c));
1322                Size::ZERO
1323            },
1324        );
1325        assert_eq!(phases.len(), 2);
1326        assert_eq!(phases[0].0, FlexMeasurePhase::Probe);
1327        assert_eq!(phases[1].0, FlexMeasurePhase::Commit);
1328        assert_eq!(phases[0].1, phases[1].1);
1329        assert_eq!(
1330            layout,
1331            flex_layout(FlexStyle::horizontal(), &items, constraints, |_, _| {
1332                Size::ZERO
1333            })
1334        );
1335    }
1336
1337    #[test]
1338    fn flex_layout_distributes_grow_space() {
1339        let items = [
1340            FlexItem::new(),
1341            FlexItem::new().grow(1.0),
1342            FlexItem::new().grow(2.0),
1343        ];
1344        let measured = [
1345            Size::new(20.0, 10.0),
1346            Size::new(10.0, 10.0),
1347            Size::new(10.0, 10.0),
1348        ];
1349        let layout = flex_layout(
1350            FlexStyle::horizontal(),
1351            &items,
1352            Constraints::tight(Size::new(100.0, 20.0)),
1353            |index, _| measured[index],
1354        );
1355
1356        assert_eq!(layout.size, Size::new(100.0, 20.0));
1357        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 10.0));
1358        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 30.0, 10.0));
1359        assert_rect_approx_eq(layout.items[2].rect, Rect::new(50.0, 0.0, 50.0, 10.0));
1360    }
1361
1362    #[test]
1363    fn flex_layout_keeps_going_under_constraints_that_cannot_hold_a_size() {
1364        let items = [FlexItem::default(), FlexItem::fill()];
1365        for constraints in [
1366            Constraints::new(Size::new(80.0, 30.0), Size::new(40.0, 10.0)),
1367            Constraints::new(Size::new(f32::NAN, 0.0), Size::new(100.0, f32::NAN)),
1368        ] {
1369            let layout = flex_layout(FlexStyle::horizontal(), &items, constraints, |_, _| {
1370                Size::new(f32::NAN, 12.0)
1371            });
1372            assert!(!layout.size.width.is_nan() && !layout.size.height.is_nan());
1373        }
1374    }
1375
1376    #[test]
1377    fn flex_item_fill_creates_equal_columns() {
1378        let items = [FlexItem::fill(), FlexItem::fill()];
1379        let layout = flex_layout(
1380            FlexStyle::horizontal(),
1381            &items,
1382            Constraints::tight(Size::new(100.0, 12.0)),
1383            |_, _| Size::new(20.0, 10.0),
1384        );
1385
1386        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 50.0, 10.0));
1387        assert_rect_approx_eq(layout.items[1].rect, Rect::new(50.0, 0.0, 50.0, 10.0));
1388    }
1389
1390    #[test]
1391    fn flex_layout_remeasures_grown_children_at_their_resolved_main_size() {
1392        let items = [FlexItem::flex(1.0)];
1393        let mut seen = Vec::new();
1394        let layout = flex_layout(
1395            FlexStyle::horizontal(),
1396            &items,
1397            Constraints::new(Size::new(240.0, 0.0), Size::new(240.0, 200.0)),
1398            |_, constraints| {
1399                seen.push(constraints);
1400                if constraints.max.width <= 1.0 {
1401                    Size::new(constraints.max.width, 160.0)
1402                } else {
1403                    Size::new(constraints.max.width, 20.0)
1404                }
1405            },
1406        );
1407
1408        assert_eq!(seen.len(), 2);
1409        assert_eq!(seen[0].max.width, 0.0);
1410        assert_eq!(seen[1].min.width, 240.0);
1411        assert_eq!(seen[1].max.width, 240.0);
1412        assert_eq!(layout.size, Size::new(240.0, 20.0));
1413        assert_eq!(layout.items[0].measured_size, Size::new(240.0, 20.0));
1414        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 240.0, 20.0));
1415    }
1416
1417    #[test]
1418    fn flex_layout_supports_fraction_basis() {
1419        let items = [
1420            FlexItem::new().basis_fraction(0.25),
1421            FlexItem::new().basis_fraction(0.75),
1422        ];
1423        let layout = flex_layout(
1424            FlexStyle::horizontal(),
1425            &items,
1426            Constraints::tight(Size::new(200.0, 12.0)),
1427            |_, _| Size::new(10.0, 10.0),
1428        );
1429
1430        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 50.0, 10.0));
1431        assert_rect_approx_eq(layout.items[1].rect, Rect::new(50.0, 0.0, 150.0, 10.0));
1432    }
1433
1434    #[test]
1435    fn flex_layout_supports_gap_aware_fraction_basis() {
1436        let items = [
1437            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1438            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1439            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1440        ];
1441        let layout = flex_layout(
1442            FlexStyle::horizontal().gap(10.0),
1443            &items,
1444            Constraints::tight(Size::new(320.0, 12.0)),
1445            |_, _| Size::new(10.0, 10.0),
1446        );
1447
1448        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 100.0, 10.0));
1449        assert_rect_approx_eq(layout.items[1].rect, Rect::new(110.0, 0.0, 100.0, 10.0));
1450        assert_rect_approx_eq(layout.items[2].rect, Rect::new(220.0, 0.0, 100.0, 10.0));
1451    }
1452
1453    #[test]
1454    fn flex_layout_wraps_gap_aware_fraction_lines_after_full_rows() {
1455        let items = [
1456            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1457            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1458            FlexItem::new().basis_gap_aware_fraction(1.0 / 3.0),
1459            FlexItem::new().basis_gap_aware_fraction(0.5),
1460            FlexItem::new().basis_gap_aware_fraction(0.5),
1461        ];
1462        let layout = flex_layout(
1463            FlexStyle::horizontal().wrap(FlexWrap::Wrap).gap(10.0),
1464            &items,
1465            Constraints::tight(Size::new(320.0, 100.0)),
1466            |_, _| Size::new(10.0, 10.0),
1467        );
1468
1469        assert_eq!(layout.lines.len(), 2);
1470        assert_eq!(layout.items[0].line, 0);
1471        assert_eq!(layout.items[2].line, 0);
1472        assert_eq!(layout.items[3].line, 1);
1473        assert_eq!(layout.items[4].line, 1);
1474        assert_rect_approx_eq(layout.items[3].rect, Rect::new(0.0, 20.0, 155.0, 10.0));
1475        assert_rect_approx_eq(layout.items[4].rect, Rect::new(165.0, 20.0, 155.0, 10.0));
1476    }
1477
1478    #[test]
1479    fn flex_layout_redistributes_grow_space_after_max_clamp() {
1480        let items = [FlexItem::fill().max_width(20.0), FlexItem::fill()];
1481        let layout = flex_layout(
1482            FlexStyle::horizontal(),
1483            &items,
1484            Constraints::tight(Size::new(100.0, 12.0)),
1485            |_, _| Size::new(0.0, 10.0),
1486        );
1487
1488        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 10.0));
1489        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 80.0, 10.0));
1490    }
1491
1492    #[test]
1493    fn flex_layout_shrinks_items_when_space_is_tight() {
1494        let items = [
1495            FlexItem::new().min_width(20.0),
1496            FlexItem::new().min_width(20.0),
1497        ];
1498        let layout = flex_layout(
1499            FlexStyle::horizontal(),
1500            &items,
1501            Constraints::tight(Size::new(100.0, 12.0)),
1502            |index, _| {
1503                if index == 0 {
1504                    Size::new(80.0, 10.0)
1505                } else {
1506                    Size::new(40.0, 10.0)
1507                }
1508            },
1509        );
1510
1511        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 66.666664, 10.0));
1512        assert_rect_approx_eq(
1513            layout.items[1].rect,
1514            Rect::new(66.666664, 0.0, 33.333332, 10.0),
1515        );
1516    }
1517
1518    #[test]
1519    fn flex_layout_wraps_lines_with_cross_gap() {
1520        let items = [FlexItem::new(), FlexItem::new(), FlexItem::new()];
1521        let measured = [
1522            Size::new(30.0, 10.0),
1523            Size::new(30.0, 10.0),
1524            Size::new(30.0, 10.0),
1525        ];
1526        let layout = flex_layout(
1527            FlexStyle::horizontal().wrap(FlexWrap::Wrap).gap(5.0),
1528            &items,
1529            Constraints::tight(Size::new(50.0, 40.0)),
1530            |index, _| measured[index],
1531        );
1532
1533        assert_eq!(layout.lines.len(), 3);
1534        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 30.0, 10.0));
1535        assert_rect_approx_eq(layout.items[1].rect, Rect::new(0.0, 15.0, 30.0, 10.0));
1536        assert_rect_approx_eq(layout.items[2].rect, Rect::new(0.0, 30.0, 30.0, 10.0));
1537    }
1538
1539    #[test]
1540    fn flex_layout_justifies_remaining_space_between_items() {
1541        let items = [FlexItem::new(), FlexItem::new(), FlexItem::new()];
1542        let layout = flex_layout(
1543            FlexStyle::horizontal().justify(FlexJustify::SpaceBetween),
1544            &items,
1545            Constraints::tight(Size::new(100.0, 10.0)),
1546            |_, _| Size::new(10.0, 10.0),
1547        );
1548
1549        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 10.0, 10.0));
1550        assert_rect_approx_eq(layout.items[1].rect, Rect::new(45.0, 0.0, 10.0, 10.0));
1551        assert_rect_approx_eq(layout.items[2].rect, Rect::new(90.0, 0.0, 10.0, 10.0));
1552    }
1553
1554    #[test]
1555    fn flex_layout_stretches_items_and_lines_on_cross_axis() {
1556        let items = [FlexItem::new(), FlexItem::new()];
1557        let layout = flex_layout(
1558            FlexStyle::horizontal()
1559                .align_items(Alignment::Stretch)
1560                .align_content(FlexAlignContent::Stretch),
1561            &items,
1562            Constraints::tight(Size::new(60.0, 20.0)),
1563            |_, _| Size::new(20.0, 8.0),
1564        );
1565
1566        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 20.0));
1567        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 20.0, 20.0));
1568    }
1569
1570    #[test]
1571    fn arrange_flex_uses_existing_measured_sizes() {
1572        let items = [FlexItem::new(), FlexItem::new().grow(1.0)];
1573        let layout = arrange_flex(
1574            FlexStyle::horizontal(),
1575            &items,
1576            Size::new(80.0, 12.0),
1577            &[Size::new(20.0, 8.0), Size::new(10.0, 8.0)],
1578        );
1579
1580        assert_rect_approx_eq(layout.items[0].rect, Rect::new(0.0, 0.0, 20.0, 8.0));
1581        assert_rect_approx_eq(layout.items[1].rect, Rect::new(20.0, 0.0, 60.0, 8.0));
1582    }
1583}