cranpose-ui 0.1.164

UI primitives 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
129
130
131
132
133
134
135
136

use super::*;

#[test]
fn normalized_enforces_minimum_one_line() {
    let options = TextLayoutOptions {
        min_lines: 0,
        max_lines: 0,
        ..Default::default()
    }
    .normalized();

    assert_eq!(options.min_lines, 1);
    assert_eq!(options.max_lines, 1);
}

#[test]
fn normalized_ensures_max_not_smaller_than_min() {
    let options = TextLayoutOptions {
        min_lines: 3,
        max_lines: 1,
        ..Default::default()
    }
    .normalized();

    assert_eq!(options.min_lines, 3);
    assert_eq!(options.max_lines, 3);
}

#[test]
fn normalized_limits_unwrapped_ellipsis_text_to_one_line() {
    for overflow in [
        TextOverflow::Ellipsis,
        TextOverflow::StartEllipsis,
        TextOverflow::MiddleEllipsis,
    ] {
        let options = TextLayoutOptions {
            overflow,
            soft_wrap: false,
            max_lines: 4,
            min_lines: 2,
        }
        .normalized();

        assert_eq!(options.max_lines, 1, "{overflow:?}");
        assert_eq!(options.min_lines, 2, "{overflow:?}");
    }
}

#[test]
fn normalized_keeps_max_lines_of_wrapped_or_non_ellipsis_text() {
    for (overflow, soft_wrap) in [
        (TextOverflow::Ellipsis, true),
        (TextOverflow::Clip, false),
        (TextOverflow::Visible, false),
        (
            TextOverflow::ScaleDown {
                min_font_size_sp: 9.0,
            },
            false,
        ),
    ] {
        let options = TextLayoutOptions {
            overflow,
            soft_wrap,
            max_lines: 4,
            min_lines: 1,
        }
        .normalized();

        assert_eq!(options.max_lines, 4, "{overflow:?} soft_wrap={soft_wrap}");
    }
}

#[test]
fn normalized_sanitizes_scale_down_min_font_size() {
    let options = TextLayoutOptions {
        overflow: TextOverflow::ScaleDown {
            min_font_size_sp: f32::NAN,
        },
        ..Default::default()
    }
    .normalized();

    assert_eq!(
        options.overflow,
        TextOverflow::ScaleDown {
            min_font_size_sp: 1.0
        }
    );
}

#[test]
fn text_options_default_maps_to_unlimited_layout() {
    let layout = TextLayoutOptions::from(TextOptions::default());

    assert_eq!(layout.overflow, TextOverflow::Clip);
    assert!(layout.soft_wrap);
    assert_eq!(layout.max_lines, usize::MAX);
    assert_eq!(layout.min_lines, 1);
}

#[test]
fn text_options_maps_optional_max_lines_to_layout_limit() {
    let layout = TextLayoutOptions::from(TextOptions {
        overflow: TextOverflow::Ellipsis,
        soft_wrap: false,
        max_lines: Some(1),
        min_lines: 1,
    });

    assert_eq!(layout.overflow, TextOverflow::Ellipsis);
    assert!(!layout.soft_wrap);
    assert_eq!(layout.max_lines, 1);
    assert_eq!(layout.min_lines, 1);
}

#[test]
fn text_options_preserve_scale_down_overflow() {
    let layout = TextLayoutOptions::from(TextOptions {
        overflow: TextOverflow::ScaleDown {
            min_font_size_sp: 9.0,
        },
        soft_wrap: false,
        max_lines: Some(1),
        min_lines: 1,
    });

    assert_eq!(
        layout.overflow,
        TextOverflow::ScaleDown {
            min_font_size_sp: 9.0
        }
    );
    assert!(!layout.soft_wrap);
    assert_eq!(layout.max_lines, 1);
}