Skip to main content

sui_layout/
grid.rs

1use sui_core::{Point, Rect, Size};
2
3use crate::{Alignment, Constraints};
4
5#[derive(Debug, Clone, Copy, PartialEq)]
6pub enum GridTrackMax {
7    Auto,
8    Points(f32),
9    Fraction(f32),
10}
11
12#[derive(Debug, Clone, Copy, PartialEq)]
13pub enum GridTrack {
14    Fixed(f32),
15    Auto,
16    Fraction(f32),
17    MinMax { min: f32, max: GridTrackMax },
18}
19
20impl GridTrack {
21    pub const fn fixed(points: f32) -> Self {
22        Self::Fixed(points)
23    }
24
25    pub const fn auto() -> Self {
26        Self::Auto
27    }
28
29    pub const fn fraction(weight: f32) -> Self {
30        Self::Fraction(weight)
31    }
32
33    pub const fn minmax(min: f32, max: GridTrackMax) -> Self {
34        Self::MinMax { min, max }
35    }
36}
37
38#[derive(Debug, Clone, Copy, PartialEq, Eq)]
39pub struct GridPlacement {
40    pub row: usize,
41    pub column: usize,
42    pub row_span: usize,
43    pub column_span: usize,
44}
45
46impl GridPlacement {
47    pub const fn new(row: usize, column: usize) -> Self {
48        Self {
49            row,
50            column,
51            row_span: 1,
52            column_span: 1,
53        }
54    }
55
56    pub const fn span(mut self, rows: usize, columns: usize) -> Self {
57        self.row_span = if rows == 0 { 1 } else { rows };
58        self.column_span = if columns == 0 { 1 } else { columns };
59        self
60    }
61}
62
63impl Default for GridPlacement {
64    fn default() -> Self {
65        Self::new(0, 0)
66    }
67}
68
69#[derive(Debug, Clone, Copy, PartialEq)]
70pub struct GridItem {
71    pub placement: GridPlacement,
72    pub minimum_size: Size,
73    pub natural_size: Size,
74    pub horizontal_alignment: Alignment,
75    pub vertical_alignment: Alignment,
76}
77
78impl GridItem {
79    pub fn new(placement: GridPlacement, natural_size: Size) -> Self {
80        let natural_size = sanitize_size(natural_size);
81        Self {
82            placement,
83            minimum_size: natural_size,
84            natural_size,
85            horizontal_alignment: Alignment::Stretch,
86            vertical_alignment: Alignment::Stretch,
87        }
88    }
89
90    pub fn minimum_size(mut self, minimum_size: Size) -> Self {
91        self.minimum_size = sanitize_size(minimum_size);
92        self
93    }
94
95    pub const fn align(mut self, horizontal: Alignment, vertical: Alignment) -> Self {
96        self.horizontal_alignment = horizontal;
97        self.vertical_alignment = vertical;
98        self
99    }
100}
101
102#[derive(Debug, Clone, PartialEq)]
103pub struct GridStyle {
104    pub columns: Vec<GridTrack>,
105    pub rows: Vec<GridTrack>,
106    pub column_gap: f32,
107    pub row_gap: f32,
108}
109
110impl GridStyle {
111    pub fn new(columns: impl IntoIterator<Item = GridTrack>) -> Self {
112        Self {
113            columns: columns.into_iter().collect(),
114            rows: Vec::new(),
115            column_gap: 0.0,
116            row_gap: 0.0,
117        }
118    }
119
120    pub fn rows(mut self, rows: impl IntoIterator<Item = GridTrack>) -> Self {
121        self.rows = rows.into_iter().collect();
122        self
123    }
124
125    pub fn gap(mut self, gap: f32) -> Self {
126        let gap = finite_non_negative(gap);
127        self.column_gap = gap;
128        self.row_gap = gap;
129        self
130    }
131
132    pub fn column_gap(mut self, gap: f32) -> Self {
133        self.column_gap = finite_non_negative(gap);
134        self
135    }
136
137    pub fn row_gap(mut self, gap: f32) -> Self {
138        self.row_gap = finite_non_negative(gap);
139        self
140    }
141}
142
143impl Default for GridStyle {
144    fn default() -> Self {
145        Self::new([GridTrack::Auto])
146    }
147}
148
149#[derive(Debug, Clone, Copy, PartialEq)]
150pub struct GridItemLayout {
151    pub cell: Rect,
152    pub rect: Rect,
153}
154
155#[derive(Debug, Clone, PartialEq)]
156pub struct GridLayout {
157    pub size: Size,
158    pub column_offsets: Vec<f32>,
159    pub column_widths: Vec<f32>,
160    pub row_offsets: Vec<f32>,
161    pub row_heights: Vec<f32>,
162    pub items: Vec<GridItemLayout>,
163}
164
165pub fn grid_layout(style: &GridStyle, items: &[GridItem], constraints: Constraints) -> GridLayout {
166    let column_count = items
167        .iter()
168        .map(|item| item.placement.column + item.placement.column_span.max(1))
169        .max()
170        .unwrap_or(0)
171        .max(style.columns.len())
172        .max(1);
173    let row_count = items
174        .iter()
175        .map(|item| item.placement.row + item.placement.row_span.max(1))
176        .max()
177        .unwrap_or(0)
178        .max(style.rows.len())
179        .max(1);
180
181    let columns = padded_tracks(&style.columns, column_count);
182    let rows = padded_tracks(&style.rows, row_count);
183    let (column_widths, width) = resolve_tracks(
184        &columns,
185        style.column_gap,
186        constraints.min.width,
187        constraints.max.width,
188        items.iter().map(|item| AxisItem {
189            start: item.placement.column,
190            span: item.placement.column_span.max(1),
191            minimum: item.minimum_size.width,
192            natural: item.natural_size.width,
193        }),
194    );
195    let (row_heights, height) = resolve_tracks(
196        &rows,
197        style.row_gap,
198        constraints.min.height,
199        constraints.max.height,
200        items.iter().map(|item| AxisItem {
201            start: item.placement.row,
202            span: item.placement.row_span.max(1),
203            minimum: item.minimum_size.height,
204            natural: item.natural_size.height,
205        }),
206    );
207    let column_offsets = track_offsets(&column_widths, style.column_gap);
208    let row_offsets = track_offsets(&row_heights, style.row_gap);
209    let item_layouts = items
210        .iter()
211        .map(|item| {
212            let cell = span_rect(
213                item.placement,
214                &column_offsets,
215                &column_widths,
216                &row_offsets,
217                &row_heights,
218                style.column_gap,
219                style.row_gap,
220            );
221            let child_size = Size::new(
222                aligned_extent(
223                    item.horizontal_alignment,
224                    cell.width(),
225                    item.natural_size.width,
226                ),
227                aligned_extent(
228                    item.vertical_alignment,
229                    cell.height(),
230                    item.natural_size.height,
231                ),
232            );
233            let origin = Point::new(
234                aligned_origin(
235                    item.horizontal_alignment,
236                    cell.x(),
237                    cell.width(),
238                    child_size.width,
239                ),
240                aligned_origin(
241                    item.vertical_alignment,
242                    cell.y(),
243                    cell.height(),
244                    child_size.height,
245                ),
246            );
247            GridItemLayout {
248                cell,
249                rect: Rect::from_origin_size(origin, child_size),
250            }
251        })
252        .collect();
253
254    GridLayout {
255        size: constraints.clamp(Size::new(width, height)),
256        column_offsets,
257        column_widths,
258        row_offsets,
259        row_heights,
260        items: item_layouts,
261    }
262}
263
264#[derive(Clone, Copy)]
265struct AxisItem {
266    start: usize,
267    span: usize,
268    minimum: f32,
269    natural: f32,
270}
271
272fn padded_tracks(tracks: &[GridTrack], count: usize) -> Vec<GridTrack> {
273    let mut result = tracks.to_vec();
274    result.resize(count, GridTrack::Auto);
275    result
276}
277
278fn resolve_tracks(
279    tracks: &[GridTrack],
280    gap: f32,
281    minimum_container: f32,
282    maximum_container: f32,
283    items: impl Iterator<Item = AxisItem> + Clone,
284) -> (Vec<f32>, f32) {
285    let gap = finite_non_negative(gap);
286    let gap_total = gap * tracks.len().saturating_sub(1) as f32;
287    let mut minimums = tracks.iter().map(track_minimum).collect::<Vec<_>>();
288    let mut sizes = minimums.clone();
289
290    for item in items.clone().filter(|item| item.span == 1) {
291        if let Some(track) = tracks.get(item.start) {
292            let minimum = finite_non_negative(item.minimum);
293            let natural = finite_non_negative(item.natural).max(minimum);
294            if !matches!(track, GridTrack::Fixed(_)) {
295                minimums[item.start] = minimums[item.start].max(minimum);
296                sizes[item.start] = sizes[item.start].max(track_natural_target(*track, natural));
297            }
298        }
299    }
300    for item in items.filter(|item| item.span > 1) {
301        distribute_span_shortfall(
302            tracks,
303            &mut minimums,
304            item.start,
305            item.span,
306            finite_non_negative(item.minimum),
307            gap,
308        );
309        distribute_span_shortfall(
310            tracks,
311            &mut sizes,
312            item.start,
313            item.span,
314            finite_non_negative(item.natural).max(finite_non_negative(item.minimum)),
315            gap,
316        );
317    }
318    for (size, minimum) in sizes.iter_mut().zip(&minimums) {
319        *size = size.max(*minimum);
320    }
321    for ((track, minimum), size) in tracks.iter().zip(&mut minimums).zip(&mut sizes) {
322        let cap = track_maximum(*track);
323        *minimum = minimum.min(cap);
324        *size = size.min(cap).max(*minimum);
325    }
326
327    let target = if maximum_container.is_finite() {
328        maximum_container.max(0.0)
329    } else {
330        finite_non_negative(minimum_container).max(sum_tracks(&sizes, gap_total))
331    };
332    let available_tracks = (target - gap_total).max(0.0);
333    let current_tracks = sizes.iter().sum::<f32>();
334    if current_tracks < available_tracks {
335        distribute_fractional_space(tracks, &mut sizes, available_tracks - current_tracks);
336    } else if current_tracks > available_tracks {
337        shrink_to_fit(&mut sizes, &minimums, current_tracks - available_tracks);
338    }
339
340    let natural = sum_tracks(&sizes, gap_total);
341    let resolved =
342        natural
343            .max(finite_non_negative(minimum_container))
344            .min(if maximum_container.is_finite() {
345                maximum_container.max(0.0)
346            } else {
347                f32::INFINITY
348            });
349    (sizes, resolved)
350}
351
352fn track_minimum(track: &GridTrack) -> f32 {
353    match *track {
354        GridTrack::Fixed(points) => finite_non_negative(points),
355        GridTrack::MinMax { min, .. } => finite_non_negative(min),
356        GridTrack::Auto | GridTrack::Fraction(_) => 0.0,
357    }
358}
359
360fn track_natural_target(track: GridTrack, natural: f32) -> f32 {
361    match track {
362        GridTrack::Fixed(points) => finite_non_negative(points),
363        GridTrack::Auto | GridTrack::Fraction(_) => natural,
364        GridTrack::MinMax { min, max } => match max {
365            GridTrackMax::Auto | GridTrackMax::Fraction(_) => natural.max(min),
366            GridTrackMax::Points(max) => natural.clamp(min.max(0.0), max.max(min).max(0.0)),
367        },
368    }
369}
370
371fn track_maximum(track: GridTrack) -> f32 {
372    match track {
373        GridTrack::Fixed(points) => finite_non_negative(points),
374        GridTrack::MinMax {
375            min,
376            max: GridTrackMax::Points(max),
377        } => finite_non_negative(max).max(finite_non_negative(min)),
378        GridTrack::Auto
379        | GridTrack::Fraction(_)
380        | GridTrack::MinMax {
381            max: GridTrackMax::Auto | GridTrackMax::Fraction(_),
382            ..
383        } => f32::INFINITY,
384    }
385}
386
387fn fractional_weight(track: GridTrack) -> f32 {
388    match track {
389        GridTrack::Fraction(weight) => finite_non_negative(weight),
390        GridTrack::MinMax {
391            max: GridTrackMax::Fraction(weight),
392            ..
393        } => finite_non_negative(weight),
394        _ => 0.0,
395    }
396}
397
398fn distribute_fractional_space(tracks: &[GridTrack], sizes: &mut [f32], extra: f32) {
399    let weight = tracks.iter().copied().map(fractional_weight).sum::<f32>();
400    if weight <= 0.0 || extra <= 0.0 {
401        return;
402    }
403    for (track, size) in tracks.iter().copied().zip(sizes) {
404        let track_weight = fractional_weight(track);
405        if track_weight > 0.0 {
406            *size += extra * track_weight / weight;
407        }
408    }
409}
410
411fn shrink_to_fit(sizes: &mut [f32], minimums: &[f32], mut overflow: f32) {
412    while overflow > 0.001 {
413        let shrinkable = sizes
414            .iter()
415            .zip(minimums)
416            .filter(|(size, minimum)| **size > **minimum + 0.001)
417            .count();
418        if shrinkable == 0 {
419            break;
420        }
421        let share = overflow / shrinkable as f32;
422        let mut consumed = 0.0;
423        for (size, minimum) in sizes.iter_mut().zip(minimums) {
424            let amount = (*size - *minimum).max(0.0).min(share);
425            *size -= amount;
426            consumed += amount;
427        }
428        if consumed <= 0.001 {
429            break;
430        }
431        overflow -= consumed;
432    }
433}
434
435fn distribute_span_shortfall(
436    tracks: &[GridTrack],
437    sizes: &mut [f32],
438    start: usize,
439    span: usize,
440    target: f32,
441    gap: f32,
442) {
443    let end = (start + span).min(sizes.len());
444    if start >= end {
445        return;
446    }
447    let current = sizes[start..end].iter().sum::<f32>() + gap * (end - start - 1) as f32;
448    let shortfall = (target - current).max(0.0);
449    if shortfall <= 0.0 {
450        return;
451    }
452    let eligible = (start..end)
453        .filter(|index| !matches!(tracks[*index], GridTrack::Fixed(_)))
454        .collect::<Vec<_>>();
455    if eligible.is_empty() {
456        return;
457    }
458    let share = shortfall / eligible.len() as f32;
459    for index in eligible {
460        sizes[index] += share;
461    }
462}
463
464fn track_offsets(sizes: &[f32], gap: f32) -> Vec<f32> {
465    let mut offset = 0.0;
466    sizes
467        .iter()
468        .map(|size| {
469            let current = offset;
470            offset += *size + gap;
471            current
472        })
473        .collect()
474}
475
476#[allow(clippy::too_many_arguments)]
477fn span_rect(
478    placement: GridPlacement,
479    column_offsets: &[f32],
480    column_widths: &[f32],
481    row_offsets: &[f32],
482    row_heights: &[f32],
483    column_gap: f32,
484    row_gap: f32,
485) -> Rect {
486    let column = placement.column.min(column_widths.len().saturating_sub(1));
487    let row = placement.row.min(row_heights.len().saturating_sub(1));
488    let column_end = (column + placement.column_span.max(1)).min(column_widths.len());
489    let row_end = (row + placement.row_span.max(1)).min(row_heights.len());
490    let width = column_widths[column..column_end].iter().sum::<f32>()
491        + column_gap * column_end.saturating_sub(column + 1) as f32;
492    let height = row_heights[row..row_end].iter().sum::<f32>()
493        + row_gap * row_end.saturating_sub(row + 1) as f32;
494    Rect::new(column_offsets[column], row_offsets[row], width, height)
495}
496
497fn aligned_extent(alignment: Alignment, available: f32, natural: f32) -> f32 {
498    if alignment == Alignment::Stretch {
499        available
500    } else {
501        finite_non_negative(natural).min(available)
502    }
503}
504
505fn aligned_origin(alignment: Alignment, start: f32, available: f32, child_extent: f32) -> f32 {
506    match alignment {
507        Alignment::Start | Alignment::Stretch => start,
508        Alignment::Center => start + (available - child_extent).max(0.0) * 0.5,
509        Alignment::End => start + (available - child_extent).max(0.0),
510    }
511}
512
513fn sum_tracks(sizes: &[f32], gap_total: f32) -> f32 {
514    sizes.iter().sum::<f32>() + gap_total
515}
516
517fn finite_non_negative(value: f32) -> f32 {
518    if value.is_finite() {
519        value.max(0.0)
520    } else {
521        0.0
522    }
523}
524
525fn sanitize_size(size: Size) -> Size {
526    Size::new(
527        finite_non_negative(size.width),
528        finite_non_negative(size.height),
529    )
530}
531
532#[cfg(test)]
533mod tests {
534    use super::*;
535
536    #[test]
537    fn fraction_tracks_share_remaining_width_after_auto_content() {
538        let style = GridStyle::new([
539            GridTrack::Auto,
540            GridTrack::Fraction(1.0),
541            GridTrack::Fraction(2.0),
542        ])
543        .column_gap(10.0);
544        let items = [GridItem::new(
545            GridPlacement::new(0, 0),
546            Size::new(80.0, 20.0),
547        )];
548        let layout = grid_layout(&style, &items, Constraints::tight(Size::new(380.0, 40.0)));
549
550        assert_eq!(layout.column_widths[0], 80.0);
551        assert!((layout.column_widths[1] - 93.333_336).abs() < 0.001);
552        assert!((layout.column_widths[2] - 186.666_67).abs() < 0.001);
553    }
554
555    #[test]
556    fn spanning_item_grows_auto_tracks_and_alignment_uses_cell() {
557        let style = GridStyle::new([GridTrack::Auto, GridTrack::Auto]).gap(8.0);
558        let item = GridItem::new(GridPlacement::new(0, 0).span(1, 2), Size::new(208.0, 24.0))
559            .minimum_size(Size::new(120.0, 20.0))
560            .align(Alignment::Center, Alignment::Center);
561        let layout = grid_layout(
562            &style,
563            &[item],
564            Constraints::new(Size::ZERO, Size::new(240.0, 80.0)),
565        );
566
567        assert_eq!(layout.column_widths, vec![100.0, 100.0]);
568        assert_eq!(layout.items[0].cell.width(), 208.0);
569        assert_eq!(layout.items[0].rect.width(), 208.0);
570    }
571}