telar-layout-core 0.1.2

Flexbox and grid layout engine for Telar, built on Taffy.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use taffy::{
    GridTemplateComponent, GridTemplateRepetition, RepetitionCount, TrackSizingFunction,
    style_helpers,
};

pub enum TemplateTrack {
    Single(TrackSizingFunction),
    Repeat(RepetitionCount, TrackSizingFunction),
}

impl TemplateTrack {
    pub fn fr(flex: f32) -> Self {
        TemplateTrack::Single(style_helpers::fr(flex))
    }

    pub fn px(px: f32) -> Self {
        TemplateTrack::Single(style_helpers::length(px))
    }

    pub fn auto() -> Self {
        TemplateTrack::Single(style_helpers::auto())
    }

    pub fn min_content() -> Self {
        TemplateTrack::Single(style_helpers::min_content())
    }

    pub fn max_content() -> Self {
        TemplateTrack::Single(style_helpers::max_content())
    }

    pub fn minmax(min: TemplateTrack, max: TemplateTrack) -> Self {
        let min_fn = match min {
            TemplateTrack::Single(tsf) => tsf.min,
            _ => panic!("minmax min cannot be a repeat track"),
        };
        let max_fn = match max {
            TemplateTrack::Single(tsf) => tsf.max,
            _ => panic!("minmax max cannot be a repeat track"),
        };
        TemplateTrack::Single(style_helpers::minmax(min_fn, max_fn))
    }

    pub fn repeat(count: u16, track: TemplateTrack) -> Self {
        TemplateTrack::Repeat(RepetitionCount::Count(count), track.unwrap_single())
    }

    pub fn fill(track: TemplateTrack) -> Self {
        TemplateTrack::Repeat(RepetitionCount::AutoFill, track.unwrap_single())
    }

    pub fn fit(track: TemplateTrack) -> Self {
        TemplateTrack::Repeat(RepetitionCount::AutoFit, track.unwrap_single())
    }

    fn unwrap_single(self) -> TrackSizingFunction {
        match self {
            TemplateTrack::Single(tsf) => tsf,
            _ => panic!("repeat tracks cannot be nested"),
        }
    }

    pub(crate) fn into_template_component(self) -> GridTemplateComponent<String> {
        match self {
            TemplateTrack::Single(tsf) => GridTemplateComponent::Single(tsf),
            TemplateTrack::Repeat(count, tsf) => {
                GridTemplateComponent::Repeat(GridTemplateRepetition {
                    count,
                    tracks: vec![tsf],
                    line_names: Vec::new(),
                })
            }
        }
    }
}