mirx 0.46.0

MIRX binary image format — flat & chunk-based container for ahead-of-time UI assets
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

use alloc::borrow::Cow;

use crate::types::{Color, Fixed, Point, Transform};

#[derive(Clone, Debug, PartialEq)]
pub enum Paint {
    Color(Color),
    LinearGradient(LinearGradient),
    RadialGradient(RadialGradient),
}

#[derive(Clone, Debug, PartialEq)]
pub struct LinearGradient {
    pub start: Point,
    pub end: Point,
    pub stops: Cow<'static, [GradientStop]>,
    pub spread: SpreadMode,
    pub units: GradientUnits,
    pub transform: Transform,
}

#[derive(Clone, Debug, PartialEq)]
pub struct RadialGradient {
    pub center: Point,
    pub radius: Fixed,
    pub focal: Point,
    pub focal_radius: Fixed,
    pub stops: Cow<'static, [GradientStop]>,
    pub spread: SpreadMode,
    pub units: GradientUnits,
    pub transform: Transform,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct GradientStop {
    pub offset: Fixed,
    pub color: Color,
}

impl GradientStop {
    pub(crate) fn offset_follows(previous: Fixed, offset: Fixed) -> bool {
        offset >= previous && offset <= Fixed::ONE
    }

    /// Checks a nonempty stop sequence for ascending offsets within 0..=1.
    pub fn sequence_is_valid(stops: &[Self]) -> bool {
        let mut previous = Fixed::ZERO;
        !stops.is_empty()
            && stops.iter().all(|stop| {
                let valid = Self::offset_follows(previous, stop.offset);
                previous = stop.offset;
                valid
            })
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SpreadMode {
    Pad,
    Reflect,
    Repeat,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GradientUnits {
    UserSpaceOnUse,
    ObjectBoundingBox,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn stop_sequence_requires_bounded_ascending_offsets() {
        let stop = |offset| GradientStop {
            offset,
            color: Color::rgba(0, 0, 0, 255),
        };
        let negative = Fixed::from_int(-1);
        let too_large = Fixed::from_int(2);
        assert!(!GradientStop::sequence_is_valid(&[]));
        assert!(GradientStop::sequence_is_valid(&[
            stop(Fixed::ZERO),
            stop(Fixed::ONE),
        ]));
        assert!(GradientStop::sequence_is_valid(&[
            stop(Fixed::ZERO),
            stop(Fixed::ZERO),
        ]));
        assert!(!GradientStop::sequence_is_valid(&[
            stop(Fixed::ONE),
            stop(Fixed::ZERO),
        ]));
        assert!(!GradientStop::sequence_is_valid(&[stop(negative)]));
        assert!(!GradientStop::sequence_is_valid(&[stop(too_large)]));
    }
}