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}