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#[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#[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 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 {
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 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 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}