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