cranpose-ui-layout 0.9.5

Layout contracts & policies for Cranpose
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use super::{Arrangement, LinearArrangement};

fn arranged(arrangement: LinearArrangement, density: f32, total: f32, sizes: &[f32]) -> Vec<f32> {
    let mut positions = vec![0.0; sizes.len()];
    arrangement.arrange(density, total, sizes, &mut positions);
    positions
}

#[test]
fn space_evenly_rounds_each_position_to_a_device_pixel() {
    let sizes = [10.0, 10.0, 10.0];
    assert_eq!(
        arranged(LinearArrangement::SpaceEvenly, 1.0, 100.0, &sizes),
        [18.0, 45.0, 73.0]
    );
    assert_eq!(
        arranged(LinearArrangement::SpaceEvenly, 2.0, 100.0, &sizes),
        [17.5, 45.0, 72.5]
    );
}

#[test]
fn center_sends_a_half_pixel_up_as_kotlin_does() {
    assert_eq!(
        arranged(LinearArrangement::Center, 1.0, 101.0, &[10.0]),
        [46.0]
    );
    assert_eq!(
        arranged(LinearArrangement::Center, 1.0, 9.0, &[10.0]),
        [0.0]
    );
}

#[test]
fn space_between_puts_a_lone_child_at_the_start() {
    assert_eq!(
        arranged(LinearArrangement::SpaceBetween, 1.0, 100.0, &[10.0]),
        [0.0]
    );
    assert_eq!(
        arranged(LinearArrangement::SpaceBetween, 1.0, 100.0, &[10.0, 10.0]),
        [0.0, 90.0]
    );
}

#[test]
fn space_around_and_end_follow_the_remaining_space() {
    assert_eq!(
        arranged(LinearArrangement::SpaceAround, 1.0, 100.0, &[10.0, 10.0]),
        [20.0, 70.0]
    );
    assert_eq!(
        arranged(LinearArrangement::End, 1.0, 100.0, &[10.0, 10.0]),
        [80.0, 90.0]
    );
    assert_eq!(
        arranged(LinearArrangement::Start, 1.0, 100.0, &[10.0, 10.0]),
        [0.0, 10.0]
    );
}

#[test]
fn spaced_by_puts_a_device_pixel_spacing_between_children() {
    assert_eq!(
        arranged(LinearArrangement::spaced_by(5.0), 1.0, 40.0, &[10.0, 10.0]),
        [0.0, 15.0]
    );
    assert_eq!(
        arranged(
            LinearArrangement::spaced_by(12.4),
            1.0,
            100.0,
            &[10.0, 10.0]
        ),
        [0.0, 22.0]
    );
    assert_eq!(LinearArrangement::spaced_by(12.4).spacing(1.0), 12.0);
    assert_eq!(LinearArrangement::spaced_by(-3.0).spacing(1.0), 0.0);
    assert_eq!(LinearArrangement::Center.spacing(1.0), 0.0);
}

#[test]
fn spaced_by_keeps_every_child_inside_the_container() {
    assert_eq!(
        arranged(
            LinearArrangement::spaced_by(12.0),
            1.0,
            100.0,
            &[95.0, 10.0]
        ),
        [0.0, 90.0]
    );
    assert_eq!(
        arranged(LinearArrangement::spaced_by(12.0), 1.0, 100.0, &[95.0, 0.0]),
        [0.0, 100.0]
    );
}

#[test]
fn spaced_by_aligned_places_the_spaced_block_by_its_alignment() {
    let arrange = |arrangement: LinearArrangement, total: f32| {
        let mut positions = [0.0; 3];
        arrangement.arrange(1.0, total, &[10.0, 20.0, 5.0], &mut positions);
        positions
    };
    // 10 + 4 + 20 + 4 + 5 = 43 of 100: 57 left over.
    let end = LinearArrangement::spaced_by_aligned(4.0, crate::HorizontalAlignment::End);
    assert_eq!(arrange(end, 100.0), [57.0, 71.0, 95.0]);
    let center =
        LinearArrangement::spaced_by_aligned(4.0, crate::VerticalAlignment::CenterVertically);
    assert_eq!(
        arrange(center, 100.0),
        [29.0, 43.0, 67.0],
        "57 / 2 rounds half up"
    );
    let start = LinearArrangement::spaced_by_aligned(4.0, crate::HorizontalAlignment::Start);
    assert_eq!(
        arrange(start, 100.0),
        arrange(LinearArrangement::spaced_by(4.0), 100.0)
    );
    // A block that overflows is placed as plain spacing places it.
    assert_eq!(
        arrange(end, 30.0),
        arrange(LinearArrangement::spaced_by(4.0), 30.0)
    );
    assert!(end.is_spaced());
    assert_eq!(end.spacing(2.0), 4.0);
}