kaolin 0.1.10

A Rust library for flexible layouts, inspired by Clay
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

/// Represents the padding values for a UI element.
///
/// Padding can be set individually for each side (left, right, top, bottom).
///
/// This struct implements different constructors for ease of use.
///
/// For more info on Styling, see [`kaolin::style`]
#[derive(Default, Clone, Copy)]
pub struct Padding {
    pub left: f64,
    pub right: f64,
    pub top: f64,
    pub bottom: f64,
}

impl Padding {
    /// Creates a new `Padding` instance with the specified values.
    pub fn new(left: f64, right: f64, top: f64, bottom: f64) -> Self {
        Padding {
            left,
            right,
            top,
            bottom,
        }
    }

    /// Creates a new `Padding` instance with the same value for all sides.
    pub fn all(value: f64) -> Self {
        Padding {
            left: value,
            right: value,
            top: value,
            bottom: value,
        }
    }

    /// Creates a new `Padding` instance with the same value for the horizontal sides (left and right).
    pub fn horizontal(value: f64) -> Self {
        Padding {
            left: value,
            right: value,
            top: 0.0,
            bottom: 0.0,
        }
    }

    /// Creates a new `Padding` instance with the same value for the vertical sides (top and bottom).
    pub fn vertical(value: f64) -> Self {
        Padding {
            left: 0.0,
            right: 0.0,
            top: value,
            bottom: value,
        }
    }

    /// Creates a new `Padding` with the same value for the horizontal sides (left and right) and the vertical sides (top and bottom).
    pub fn hor_ver(hor: f64, ver: f64) -> Self {
        Padding {
            left: hor,
            right: hor,
            top: ver,
            bottom: ver,
        }
    }

    /// Creates a new `Padding` with only the left value set, all others sides set to 0.
    pub fn left(value: f64) -> Self {
        Padding {
            left: value,
            right: 0.0,
            top: 0.0,
            bottom: 0.0,
        }
    }

    /// Creates a new `Padding` with only the right value set, all others sides set to 0.
    pub fn right(value: f64) -> Self {
        Padding {
            left: 0.0,
            right: value,
            top: 0.0,
            bottom: 0.0,
        }
    }

    /// Creates a new `Padding` with only the top value set, all others sides set to 0.
    pub fn top(value: f64) -> Self {
        Padding {
            left: 0.0,
            right: 0.0,
            top: value,
            bottom: 0.0,
        }
    }

    /// Creates a new `Padding` with only the bottom value set, all others sides set to 0.
    pub fn bottom(value: f64) -> Self {
        Padding {
            left: 0.0,
            right: 0.0,
            top: 0.0,
            bottom: value,
        }
    }

    /// Returns the total horizontal padding (left + right). Used internally to calculate layout positions.
    pub fn x(&self) -> f64 {
        self.left + self.right
    }

    /// Returns the total vertical padding (top + bottom). Used internally to calculate layout positions.
    pub fn y(&self) -> f64 {
        self.top + self.bottom
    }
}