carnelian/scene/
layout.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::scene::group::{GroupId, GroupMemberData};
6use crate::scene::scene::{GroupBuilder, SceneBuilder};
7use crate::{Coord, Point, Rect, Size};
8use euclid::{point2, size2};
9use std::ops::Deref;
10
11/// Arranger is a trait that defines how groups can be arranged.
12pub trait Arranger: std::fmt::Debug {
13    /// Calculate the size of a group, based on the available size and the sizes
14    /// of the members of the group.
15    fn calculate_size(
16        &self,
17        group_size: Size,
18        member_sizes: &mut [Size],
19        member_data: &[&Option<GroupMemberData>],
20    ) -> Size;
21    /// Return the group-relative positions of the members of this group, based
22    /// on the sizes of the members.
23    fn arrange(
24        &self,
25        group_size: Size,
26        member_sizes: &[Size],
27        member_data: &[&Option<GroupMemberData>],
28    ) -> Vec<Point>;
29}
30
31/// Reference to an arranger.
32pub type ArrangerPtr = Box<dyn Arranger>;
33
34#[derive(Debug, Clone, Copy)]
35/// Alignment as defined by
36///s[Flutter](https://api.flutter.dev/flutter/painting/Alignment-class.html).
37pub struct Alignment {
38    location: Point,
39}
40
41impl Alignment {
42    /// The top left corner.
43    pub fn top_left() -> Self {
44        Self { location: point2(-1.0, -1.0) }
45    }
46
47    /// The center point along the top edge.
48    pub fn top_center() -> Self {
49        Self { location: point2(0.0, -1.0) }
50    }
51
52    /// The top right corner.
53    pub fn top_right() -> Self {
54        Self { location: point2(1.0, -1.0) }
55    }
56
57    /// The center point along the left edge.
58    pub fn center_left() -> Self {
59        Self { location: point2(-1.0, 0.0) }
60    }
61
62    /// The center point, both horizontally and vertically.
63    pub fn center() -> Self {
64        Self { location: Point::zero() }
65    }
66
67    /// The center point along the right edge.
68    pub fn center_right() -> Self {
69        Self { location: point2(1.0, 0.0) }
70    }
71
72    /// The bottom left corner.
73    pub fn bottom_left() -> Self {
74        Self { location: point2(-1.0, 1.0) }
75    }
76
77    /// The center point along the bottom edge.
78    pub fn bottom_center() -> Self {
79        Self { location: point2(0.0, 1.0) }
80    }
81
82    /// The bottom right corner.
83    pub fn bottom_right() -> Self {
84        Self { location: point2(1.0, 1.0) }
85    }
86
87    fn arrange(&self, facet_size: &Size, group_size: &Size) -> Point {
88        let half_delta = (*group_size - *facet_size) / 2.0;
89
90        let x = half_delta.width + self.location.x * half_delta.width;
91        let y = half_delta.height + self.location.y * half_delta.height;
92
93        point2(x, y)
94    }
95}
96
97impl Default for Alignment {
98    fn default() -> Self {
99        Self::top_left()
100    }
101}
102
103#[derive(Default, Debug)]
104/// Options for a stack arranger.
105pub struct StackOptions {
106    /// When true, expand the stack to use all the available space.
107    pub expand: bool,
108    /// How should the stack group members be aligned.
109    pub alignment: Alignment,
110}
111
112#[derive(Default, Debug, Clone)]
113/// Member data for the Stack arranger.
114pub struct StackMemberData {
115    /// The distance by which the member's top edge is inset from the top of the stack.
116    pub top: Option<Coord>,
117    /// The distance by which the member's right edge is inset from the right of the stack.
118    pub right: Option<Coord>,
119    /// The distance by which the member's bottom edge is inset from the bottom of the stack.
120    pub bottom: Option<Coord>,
121    /// The distance by which the member's left edge is inset from the left of the stack.
122    pub left: Option<Coord>,
123    /// The member's width.
124    ///
125    /// Ignored if both left and right are non-null.
126    pub width: Option<Coord>,
127    /// The member's height.
128    ///
129    /// Ignored if both top and bottom are non-null.
130    pub height: Option<Coord>,
131}
132
133impl StackMemberData {
134    fn validate(&self) {
135        assert!(self.top.unwrap_or(0.0) >= 0.0);
136        assert!(self.right.unwrap_or(0.0) >= 0.0);
137        assert!(self.bottom.unwrap_or(0.0) >= 0.0);
138        assert!(self.left.unwrap_or(0.0) >= 0.0);
139        assert!(self.width.unwrap_or(0.0) >= 0.0);
140        assert!(self.height.unwrap_or(0.0) >= 0.0);
141    }
142
143    fn from(data: &Option<GroupMemberData>) -> Option<Self> {
144        data.as_ref().and_then(|has_data| has_data.downcast_ref::<Self>()).cloned()
145    }
146
147    fn from_if_positioned(data: &Option<GroupMemberData>) -> Option<Self> {
148        Self::from(data).and_then(|data| data.is_positioned().then_some(data))
149    }
150
151    fn is_positioned(&self) -> bool {
152        self.top.is_some()
153            || self.right.is_some()
154            || self.bottom.is_some()
155            || self.left.is_some()
156            || self.width.is_some()
157            || self.height.is_some()
158    }
159
160    fn width(&self) -> Option<Coord> {
161        if self.left.is_none() || self.right.is_none() {
162            self.width
163        } else {
164            None
165        }
166    }
167
168    fn height(&self) -> Option<Coord> {
169        if self.top.is_none() || self.bottom.is_none() {
170            self.height
171        } else {
172            None
173        }
174    }
175
176    fn size(&self, calculated: Size, available: Size) -> Size {
177        self.validate();
178
179        let width = if let Some(width) = self.width() {
180            width
181        } else {
182            let left_right_width = self
183                .left
184                .and_then(|left| self.right.and_then(|right| Some(available.width - right - left)));
185            left_right_width.unwrap_or(calculated.width)
186        };
187
188        let height = if let Some(height) = self.height() {
189            height
190        } else {
191            let top_bottom_height = self.top.and_then(|top| {
192                self.bottom.and_then(|bottom| Some(available.height - bottom - top))
193            });
194            top_bottom_height.unwrap_or(calculated.height)
195        };
196
197        size2(width, height)
198    }
199
200    fn position(&self, calculated_position: Point, size: Size, group_size: Size) -> Point {
201        let x = if let Some(left) = self.left {
202            left
203        } else if let Some(right) = self.right {
204            group_size.width - right - size.width
205        } else {
206            calculated_position.x
207        };
208        let y = if let Some(top) = self.top {
209            top
210        } else if let Some(bottom) = self.bottom {
211            group_size.height - bottom - size.height
212        } else {
213            calculated_position.y
214        };
215        point2(x, y)
216    }
217}
218
219/// Builder interface for making stack member data structures.
220pub struct StackMemberDataBuilder {
221    data: StackMemberData,
222}
223
224impl StackMemberDataBuilder {
225    fn allow_only_positive(amount: Coord) -> Option<Coord> {
226        if amount < 0.0 {
227            println!("Warning, negative amounts not allow for StackMemberData");
228            None
229        } else {
230            Some(amount)
231        }
232    }
233
234    /// Create a new builder
235    pub fn new() -> Self {
236        Self { data: StackMemberData::default() }
237    }
238
239    /// Set the top value
240    pub fn top(mut self, amount: Coord) -> Self {
241        self.data.top = Self::allow_only_positive(amount);
242        self
243    }
244
245    /// Set the left value
246    pub fn left(mut self, amount: Coord) -> Self {
247        self.data.left = Self::allow_only_positive(amount);
248        self
249    }
250
251    /// Set the bottom value
252    pub fn bottom(mut self, amount: Coord) -> Self {
253        self.data.bottom = Self::allow_only_positive(amount);
254        self
255    }
256
257    /// Set the right value
258    pub fn right(mut self, amount: Coord) -> Self {
259        self.data.right = Self::allow_only_positive(amount);
260        self
261    }
262
263    /// Set the width
264    pub fn width(mut self, amount: Coord) -> Self {
265        self.data.width = Self::allow_only_positive(amount);
266        self
267    }
268
269    /// Set the height
270    pub fn height(mut self, amount: Coord) -> Self {
271        self.data.height = Self::allow_only_positive(amount);
272        self
273    }
274
275    /// Make the member data
276    pub fn build(self) -> Option<GroupMemberData> {
277        if self.data.is_positioned() {
278            Some(Box::new(self.data))
279        } else {
280            None
281        }
282    }
283}
284
285#[cfg(test)]
286mod tests {
287    use super::*;
288
289    const TEST_SIZE: Size = size2(110.0, 120.0);
290    const TEST_GROUP_SIZE: Size = size2(1000.0, 800.0);
291    const OFFSET_VALUE: Coord = 33.0;
292
293    #[test]
294    fn test_stack_member_width() {
295        const WIDTH_VALUE: Coord = 200.0;
296        // Width only
297        let member_data =
298            StackMemberData { width: Some(WIDTH_VALUE), ..StackMemberData::default() };
299        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
300        assert_eq!(size, size2(WIDTH_VALUE, TEST_SIZE.height));
301
302        // Width with left but not right
303        let member_data = StackMemberData {
304            width: Some(WIDTH_VALUE),
305            left: Some(55.0),
306            ..StackMemberData::default()
307        };
308        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
309        assert_eq!(size, size2(WIDTH_VALUE, TEST_SIZE.height));
310
311        // Width with right but not left
312        let member_data = StackMemberData {
313            width: Some(WIDTH_VALUE),
314            right: Some(25.0),
315            ..StackMemberData::default()
316        };
317        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
318        assert_eq!(size, size2(WIDTH_VALUE, TEST_SIZE.height));
319
320        // Width with left and right, width should be ignored
321        let member_data = StackMemberData {
322            width: Some(200.0),
323            left: Some(OFFSET_VALUE),
324            right: Some(OFFSET_VALUE),
325            ..StackMemberData::default()
326        };
327        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
328        assert_eq!(size, size2(TEST_GROUP_SIZE.width - OFFSET_VALUE * 2.0, TEST_SIZE.height));
329    }
330
331    #[test]
332    fn test_stack_member_height() {
333        const HEIGHT_VALUE: Coord = 200.0;
334        // Width only
335        let member_data =
336            StackMemberData { height: Some(HEIGHT_VALUE), ..StackMemberData::default() };
337        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
338        assert_eq!(size, size2(TEST_SIZE.width, HEIGHT_VALUE));
339
340        // Width with left but not right
341        let member_data = StackMemberData {
342            height: Some(HEIGHT_VALUE),
343            top: Some(55.0),
344            ..StackMemberData::default()
345        };
346        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
347        assert_eq!(size, size2(TEST_SIZE.width, HEIGHT_VALUE));
348
349        // Width with right but not left
350        let member_data = StackMemberData {
351            height: Some(HEIGHT_VALUE),
352            bottom: Some(25.0),
353            ..StackMemberData::default()
354        };
355        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
356        assert_eq!(size, size2(TEST_SIZE.width, HEIGHT_VALUE));
357
358        // Height with top and bottom, height should be ignored
359        let member_data = StackMemberData {
360            height: Some(200.0),
361            top: Some(OFFSET_VALUE),
362            bottom: Some(OFFSET_VALUE),
363            ..StackMemberData::default()
364        };
365        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
366        assert_eq!(size, size2(TEST_SIZE.width, TEST_GROUP_SIZE.height - OFFSET_VALUE * 2.0,));
367    }
368
369    #[test]
370    #[should_panic]
371    fn test_stack_member_negative_value() {
372        let member_data = StackMemberData { height: Some(-10.0), ..StackMemberData::default() };
373        let _size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
374    }
375
376    #[test]
377    fn test_stack_member_negative_value_builder() {
378        let member_data =
379            StackMemberDataBuilder::new().height(-10.0).width(TEST_SIZE.width).build();
380        assert!(member_data.is_some());
381        let member_data = StackMemberData::from(&member_data).unwrap();
382        let size = member_data.size(TEST_SIZE, TEST_GROUP_SIZE);
383        assert_eq!(size, TEST_SIZE);
384    }
385}
386
387#[derive(Debug)]
388/// Stack arranger.
389pub struct Stack {
390    expand: bool,
391    alignment: Alignment,
392}
393
394impl Stack {
395    /// Create a stack with the provided options.
396    pub fn with_options(options: StackOptions) -> Self {
397        Self { expand: options.expand, alignment: options.alignment }
398    }
399
400    /// Create a stack with the the default options.
401    pub fn new() -> Self {
402        Self::with_options(StackOptions::default())
403    }
404
405    /// Create a boxed stack with the provided options.
406    pub fn with_options_ptr(options: StackOptions) -> ArrangerPtr {
407        Box::new(Self::with_options(options))
408    }
409
410    /// Create a boxed stack with the the default options.
411    pub fn new_ptr() -> ArrangerPtr {
412        Box::new(Self::new())
413    }
414}
415
416impl Arranger for Stack {
417    fn calculate_size(
418        &self,
419        group_size: Size,
420        member_sizes: &mut [Size],
421        member_data: &[&Option<GroupMemberData>],
422    ) -> Size {
423        let group_size = if self.expand {
424            group_size
425        } else {
426            let mut desired_size = Rect::zero();
427
428            for (member_size, member_data) in member_sizes.iter().zip(member_data.iter()) {
429                let is_positioned = StackMemberData::from(member_data)
430                    .map(|md| md.is_positioned())
431                    .unwrap_or(false);
432                if !is_positioned {
433                    let r = Rect::from_size(*member_size);
434                    desired_size = desired_size.union(&r);
435                }
436            }
437
438            desired_size.size
439        };
440
441        for (member_size, member_data) in member_sizes.iter_mut().zip(member_data.iter()) {
442            let from_if_positioned = StackMemberData::from_if_positioned(member_data);
443            if let Some(stack_member_data) = from_if_positioned {
444                *member_size = stack_member_data.size(*member_size, group_size);
445            }
446        }
447
448        group_size
449    }
450
451    fn arrange(
452        &self,
453        group_size: Size,
454        member_sizes: &[Size],
455        member_data: &[&Option<GroupMemberData>],
456    ) -> Vec<Point> {
457        member_sizes
458            .iter()
459            .zip(member_data.iter())
460            .map(|(facet_size, member_data)| {
461                let stack_member_data = StackMemberData::from(member_data)
462                    .unwrap_or_else(|| StackMemberData::default());
463                let default_pos = self.alignment.arrange(facet_size, &group_size);
464                if stack_member_data.is_positioned() {
465                    stack_member_data.position(default_pos, *facet_size, group_size)
466                } else {
467                    self.alignment.arrange(facet_size, &group_size)
468                }
469            })
470            .collect()
471    }
472}
473
474/// Fluent builder for stack groups.
475pub struct StackBuilder<'a> {
476    builder: GroupBuilder<'a>,
477    stack_options: StackOptions,
478}
479
480impl<'a> StackBuilder<'a> {
481    pub(crate) fn new(builder: GroupBuilder<'a>) -> Self {
482        Self { builder, stack_options: StackOptions::default() }
483    }
484
485    /// Set the expand option for this group.
486    pub fn expand(mut self) -> Self {
487        self.stack_options.expand = true;
488        self
489    }
490
491    /// Set the center alignment option for this group.
492    pub fn center(mut self) -> Self {
493        self.stack_options.alignment = Alignment::center();
494        self
495    }
496
497    /// Set the alignment option for this group.
498    pub fn align(mut self, align: Alignment) -> Self {
499        self.stack_options.alignment = align;
500        self
501    }
502
503    /// Create the stack group, with contents provided by
504    /// `f`.
505    pub fn contents<F>(self, f: F) -> GroupId
506    where
507        F: FnMut(&mut SceneBuilder),
508    {
509        self.contents_with_member_data(None, f)
510    }
511
512    /// Create the stack group with member data, with contents provided by
513    /// `f`.
514    pub fn contents_with_member_data<F>(
515        mut self,
516        member_data: Option<GroupMemberData>,
517        f: F,
518    ) -> GroupId
519    where
520        F: FnMut(&mut SceneBuilder),
521    {
522        self.builder.arranger = Some(Stack::with_options_ptr(self.stack_options));
523        self.builder.contents_with_member_data(member_data, f)
524    }
525}
526
527#[derive(Debug)]
528/// Direction for Flex.
529pub enum Axis {
530    /// Left to right.
531    Horizontal,
532    /// Top to bottom.
533    Vertical,
534}
535
536impl Axis {
537    /// For a size, return the component along the axis.
538    pub fn span(&self, size: &Size) -> Coord {
539        match self {
540            Self::Horizontal => size.width,
541            Self::Vertical => size.height,
542        }
543    }
544
545    /// For a size, return the component across the axis.
546    pub fn cross_span(&self, size: &Size) -> Coord {
547        match self {
548            Self::Horizontal => size.height,
549            Self::Vertical => size.width,
550        }
551    }
552
553    /// For a point, return the component along the axis.
554    pub fn position(&self, pos: &Point) -> Coord {
555        match self {
556            Self::Horizontal => pos.x,
557            Self::Vertical => pos.y,
558        }
559    }
560
561    /// For a point, return the component across the axis.
562    pub fn cross_position(&self, pos: &Point) -> Coord {
563        match self {
564            Self::Horizontal => pos.y,
565            Self::Vertical => pos.x,
566        }
567    }
568
569    /// Create a point based on this direction.
570    pub fn point2(&self, axis: Coord, cross_axis: Coord) -> Point {
571        match self {
572            Self::Horizontal => point2(axis, cross_axis),
573            Self::Vertical => point2(cross_axis, axis),
574        }
575    }
576
577    /// Create a size based on this direction.
578    pub fn size2(&self, axis: Coord, cross_axis: Coord) -> Size {
579        match self {
580            Self::Horizontal => size2(axis, cross_axis),
581            Self::Vertical => size2(cross_axis, axis),
582        }
583    }
584}
585
586impl Default for Axis {
587    fn default() -> Self {
588        Self::Vertical
589    }
590}
591
592#[derive(Debug, PartialEq, Eq, Clone, Copy)]
593/// Defines how a Flex arranger should arrange group members
594/// along its main axis. Based on
595/// [Flutters's MainAxisAlignment](https://api.flutter.dev/flutter/rendering/MainAxisAlignment-class.html)
596/// but does not currently implement anything related to text direction.
597pub enum MainAxisAlignment {
598    /// Place the group members as close to the start of the main axis as possible.
599    Start,
600    /// Place the group members as close to the end of the main axis as possible.
601    End,
602    /// Place the group members as close to the middle of the main axis as possible.
603    Center,
604    /// Place the free space evenly between the group members.
605    SpaceBetween,
606    /// Place the free space evenly between the group members as well as half of that
607    /// space before and after the first and last member.
608    SpaceAround,
609    /// Place the free space evenly between the group members as well as before and
610    /// after the first and last member.
611    SpaceEvenly,
612}
613
614impl Default for MainAxisAlignment {
615    fn default() -> Self {
616        Self::Start
617    }
618}
619
620#[derive(Debug, PartialEq, Eq, Clone, Copy)]
621/// Defines how a Flex arranger should arrange group members
622/// across its main axis. Based on
623/// [Flutters's CrossAxisAlignment](https://api.flutter.dev/flutter/rendering/CrossAxisAlignment-class.html)
624/// but does not currently implement baseline or stretch.
625pub enum CrossAxisAlignment {
626    /// Place the group members with their start edge aligned with the start side of
627    /// the cross axis.
628    Start,
629    /// Place the group members as close to the end of the cross axis as possible.
630    End,
631    /// Place the group members so that their centers align with the middle of the
632    /// cross axis.
633    Center,
634}
635
636impl Default for CrossAxisAlignment {
637    fn default() -> Self {
638        Self::Center
639    }
640}
641
642#[derive(Debug, PartialEq, Eq, Clone, Copy)]
643/// Defines how much space should be occupied in the main axis for a Flex arranger.
644/// [Flutters's MainAxisSize](https://api.flutter.dev/flutter/rendering/MainAxisSize-class.html).
645pub enum MainAxisSize {
646    /// Minimize the amount of free space along the main axis.
647    Min,
648    /// Maximize the amount of free space along the main axis.
649    Max,
650}
651
652impl Default for MainAxisSize {
653    fn default() -> Self {
654        Self::Min
655    }
656}
657
658#[derive(Default, Debug)]
659/// Options for a flex arranger.
660pub struct FlexOptions {
661    /// The direction to use as the main axis.
662    pub direction: Axis,
663    /// How much space should be occupied in the main axis.
664    pub main_size: MainAxisSize,
665    /// How the group members should be placed along the main axis.
666    pub main_align: MainAxisAlignment,
667    /// How the group members should be placed along the cross axis.
668    pub cross_align: CrossAxisAlignment,
669}
670
671impl FlexOptions {
672    /// Create FlexOptions for a column.
673    pub fn column(
674        main_size: MainAxisSize,
675        main_align: MainAxisAlignment,
676        cross_align: CrossAxisAlignment,
677    ) -> Self {
678        Self { direction: Axis::Vertical, main_size, main_align, cross_align }
679    }
680
681    /// Create FlexOptions for a row.
682    pub fn row(
683        main_size: MainAxisSize,
684        main_align: MainAxisAlignment,
685        cross_align: CrossAxisAlignment,
686    ) -> Self {
687        Self { direction: Axis::Horizontal, main_size, main_align, cross_align }
688    }
689}
690
691#[derive(Clone)]
692/// Member data for the Flex arranger.
693pub struct FlexMemberData {
694    flex: usize,
695}
696
697impl FlexMemberData {
698    /// Create new member data for a member of a flex group.
699    pub fn new(flex: usize) -> Option<GroupMemberData> {
700        Some(Box::new(FlexMemberData { flex }))
701    }
702
703    pub(crate) fn from(data: &Option<GroupMemberData>) -> Option<FlexMemberData> {
704        data.as_ref()
705            .and_then(|has_data| has_data.downcast_ref::<FlexMemberData>())
706            .map(|has_data| has_data.clone())
707    }
708}
709
710#[derive(Debug)]
711/// Flex group arranger.
712pub struct Flex {
713    direction: Axis,
714    main_size: MainAxisSize,
715    main_align: MainAxisAlignment,
716    cross_align: CrossAxisAlignment,
717}
718
719impl Flex {
720    /// Create a flex arranger with the provided options.
721    pub fn with_options(options: FlexOptions) -> Self {
722        Self {
723            direction: options.direction,
724            main_size: options.main_size,
725            main_align: options.main_align,
726            cross_align: options.cross_align,
727        }
728    }
729
730    /// Create a flex arranger with default options.
731    pub fn new() -> Self {
732        Self::with_options(FlexOptions::default())
733    }
734
735    /// Create a boxed flex arranger with the provided options.
736    pub fn with_options_ptr(options: FlexOptions) -> ArrangerPtr {
737        Box::new(Self::with_options(options))
738    }
739
740    /// Create a boxed flex arranger with default options.
741    pub fn new_ptr() -> ArrangerPtr {
742        Box::new(Self::new())
743    }
744}
745
746impl Arranger for Flex {
747    fn calculate_size(
748        &self,
749        group_size: Size,
750        member_sizes: &mut [Size],
751        member_data: &[&Option<GroupMemberData>],
752    ) -> Size {
753        let group_main_span = self.direction.span(&group_size);
754        let weights: Vec<usize> = member_data
755            .iter()
756            .map(|member_data| {
757                FlexMemberData::from(member_data).and_then(|md| Some(md.flex)).unwrap_or(0)
758            })
759            .collect();
760        let total_size: f32 =
761            member_sizes.iter().map(|facet_size| self.direction.span(facet_size)).sum();
762        let sum_of_weights: usize = weights.iter().sum();
763        let weighed_extra = (group_main_span - total_size) / sum_of_weights as f32;
764        let axis_size = if self.main_size == MainAxisSize::Max || sum_of_weights > 0 {
765            self.direction.span(&group_size)
766        } else {
767            member_sizes.iter().map(|s| self.direction.span(s)).sum()
768        };
769        let cross_axis_size = member_sizes
770            .iter()
771            .map(|s| self.direction.cross_span(s))
772            .max_by(|a, b| a.partial_cmp(b).expect("partial_cmp"))
773            .unwrap_or(0.0);
774        for (index, weight) in weights.iter().enumerate() {
775            if *weight > 0 {
776                member_sizes[index] += self.direction.size2(weighed_extra * (*weight as f32), 0.0);
777            }
778        }
779        match self.direction {
780            Axis::Vertical => size2(cross_axis_size, axis_size),
781            Axis::Horizontal => size2(axis_size, cross_axis_size),
782        }
783    }
784
785    fn arrange(
786        &self,
787        group_size: Size,
788        member_sizes: &[Size],
789        _member_data: &[&Option<GroupMemberData>],
790    ) -> Vec<Point> {
791        let item_count = member_sizes.len();
792        let group_main_span = self.direction.span(&group_size);
793        let group_cross_span = self.direction.cross_span(&group_size);
794        let total_size: f32 =
795            member_sizes.iter().map(|facet_size| self.direction.span(facet_size)).sum();
796        let free_space = group_main_span - total_size;
797        let (mut pos, between) = match self.main_align {
798            MainAxisAlignment::Start => (0.0, 0.0),
799            MainAxisAlignment::End => (group_main_span - total_size, 0.0),
800            MainAxisAlignment::Center => (group_main_span / 2.0 - total_size / 2.0, 0.0),
801            MainAxisAlignment::SpaceBetween => (0.0, free_space / (item_count - 1) as Coord),
802            MainAxisAlignment::SpaceAround => {
803                let padding = free_space / item_count as Coord;
804                (padding / 2.0, padding)
805            }
806            MainAxisAlignment::SpaceEvenly => {
807                let padding = free_space / (item_count + 1) as Coord;
808                (padding, padding)
809            }
810        };
811        let mut positions = Vec::new();
812        for member_size in member_sizes {
813            let cross = match self.cross_align {
814                CrossAxisAlignment::Start => 0.0,
815                CrossAxisAlignment::End => {
816                    group_cross_span - self.direction.cross_span(&member_size)
817                }
818                CrossAxisAlignment::Center => {
819                    group_cross_span / 2.0 - self.direction.cross_span(&member_size) / 2.0
820                }
821            };
822            positions.push(self.direction.point2(pos, cross));
823            let direction_span = self.direction.span(member_size) + between;
824            pos += direction_span;
825        }
826        positions
827    }
828}
829
830/// Fluent builder for flex groups
831pub struct FlexBuilder<'a> {
832    builder: GroupBuilder<'a>,
833    flex_options: FlexOptions,
834    member_data: Option<GroupMemberData>,
835}
836
837impl<'a> FlexBuilder<'a> {
838    pub(crate) fn new(
839        builder: GroupBuilder<'a>,
840        direction: Axis,
841        member_data: Option<GroupMemberData>,
842    ) -> Self {
843        let flex_options = FlexOptions { direction, ..FlexOptions::default() };
844        Self { builder, flex_options, member_data }
845    }
846
847    /// Use MainAxisSize::Min for main size.
848    pub fn min_size(mut self) -> Self {
849        self.flex_options.main_size = MainAxisSize::Min;
850        self
851    }
852
853    /// Use MainAxisSize::Max for main size.
854    pub fn max_size(mut self) -> Self {
855        self.flex_options.main_size = MainAxisSize::Max;
856        self
857    }
858
859    /// Use a specific main size.
860    pub fn main_size(mut self, main_size: MainAxisSize) -> Self {
861        self.flex_options.main_size = main_size;
862        self
863    }
864
865    /// Use MainAxisAlignment::SpaceEvenly for main alignment.
866    pub fn space_evenly(mut self) -> Self {
867        self.flex_options.main_align = MainAxisAlignment::SpaceEvenly;
868        self
869    }
870
871    /// Use a particular main axis alignnment.
872    pub fn main_align(mut self, main_align: MainAxisAlignment) -> Self {
873        self.flex_options.main_align = main_align;
874        self
875    }
876
877    /// Use a particular cross axis alignnment.
878    pub fn cross_align(mut self, cross_align: CrossAxisAlignment) -> Self {
879        self.flex_options.cross_align = cross_align;
880        self
881    }
882
883    /// Create the stack group, with contents provided by
884    /// `f`.
885    pub fn contents<F>(mut self, f: F) -> GroupId
886    where
887        F: FnMut(&mut SceneBuilder),
888    {
889        self.builder.arranger = Some(Flex::with_options_ptr(self.flex_options));
890        self.builder.contents_with_member_data(self.member_data, f)
891    }
892}
893
894impl<'a> Deref for FlexBuilder<'a> {
895    type Target = GroupBuilder<'a>;
896
897    fn deref(&self) -> &Self::Target {
898        &self.builder
899    }
900}
carnelian/scene/layout.rs

carnelian/scene/
layout.rs
