rui 0.6.1

Experimental Declarative UI library
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

pub enum StackItem {
    Fixed(f32),
    Flexible,
}

/// 1-D stack layout to make the algorithm clear.
///
/// Returns length used to express the layout. If there are any
/// flexible items, will return `total`, since the flexible items
/// will expand to fill the available space.
pub fn stack_layout(
    total: f32,
    sizes: &[StackItem],
    intervals: &mut [(f32, f32)],
    flex_length: &mut f32,
) -> f32 {
    assert_eq!(sizes.len(), intervals.len());

    // Count the number of flexible items and total of fixed sizes.
    let mut flex_count = 0;
    let mut sizes_sum = 0.0;
    for sz in sizes {
        match sz {
            StackItem::Flexible => flex_count += 1,
            StackItem::Fixed(s) => sizes_sum += s,
        }
    }

    // length of flexible items is remaining size divided equally
    *flex_length = (total - sizes_sum) / (flex_count as f32);

    let mut x = 0.0;
    for i in 0..sizes.len() {
        let sz = match sizes[i] {
            StackItem::Flexible => *flex_length,
            StackItem::Fixed(s) => s,
        };

        intervals[i] = (x, x + sz);
        x += sz;
    }

    x
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_layout_basic() {
        use StackItem::Fixed;
        use StackItem::Flexible;
        {
            let sizes = [Fixed(1.0), Fixed(1.0)];
            let mut intervals = [(0.0, 0.0); 2];

            let mut flex_length = 0.0;
            let length = stack_layout(4.0, &sizes, &mut intervals, &mut flex_length);

            assert!(flex_length.is_infinite());
            assert_eq!(length, 2.0);
            println!("intervals: {:?}", intervals);
        }

        {
            let sizes = [Fixed(1.0), Flexible, Fixed(1.0)];
            let mut intervals = [(0.0, 0.0); 3];

            let mut flex_length = 0.0;
            let length = stack_layout(4.0, &sizes, &mut intervals, &mut flex_length);

            assert_eq!(flex_length, 2.0);
            assert_eq!(length, 4.0);
            println!("intervals: {:?}", intervals);
        }

        {
            let sizes = [Fixed(1.0), Fixed(1.0), Flexible];
            let mut intervals = [(0.0, 0.0); 3];

            let mut flex_length = 0.0;
            let length = stack_layout(4.0, &sizes, &mut intervals, &mut flex_length);

            assert_eq!(flex_length, 2.0);
            assert_eq!(length, 4.0);
            println!("intervals: {:?}", intervals);
        }
    }
}