textyle 0.2.0

A text-based declarative UI library inspired by SwiftUI
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#[derive(Clone, Debug)]
pub struct Rect {
    pub x: i64,
    pub y: i64,
    pub width: usize,
    pub height: usize,
}

impl Rect {
    pub fn new(x: i64, y: i64, width: usize, height: usize) -> Self {
        Self {
            x,
            y,
            width,
            height,
        }
    }

    pub fn zero() -> Self {
        Rect {
            x: 0,
            y: 0,
            width: 0,
            height: 0,
        }
    }

    pub fn sized(width: usize, height: usize) -> Self {
        Self {
            x: 0,
            y: 0,
            width,
            height,
        }
    }

    pub fn from_size(size: &Size) -> Self {
        Self { x: 0, y: 0, width: size.width, height: size.height }
    }

    // Utilities
    pub fn max_x(&self) -> i64 {
        self.x + self.width as i64
    }

    pub fn max_y(&self) -> i64 {
        self.y + self.height as i64
    }

    pub fn size(&self) -> Size {
        Size::new(self.width, self.height)
    }
}

impl Default for Rect {
    fn default() -> Self {
        Self::zero()
    }
}

pub struct Vector {
    x: i64,
    y: i64
}

impl Vector {
    pub fn zero() -> Vector {
        Vector { x: 0, y: 0 }
    }
    
    pub fn new(x: i64, y: i64) -> Vector {
        Vector {
            x, y
        }
    }

    pub fn sub(vec1: &Vector, vec2: &Vector) -> Vector {
        Vector { x: vec1.x - vec2.x, y: vec1.y - vec2.y }
    }

    pub fn x(&self) -> i64 { self.x }
    pub fn y(&self) -> i64 { self.y }
}

impl Vector {
    pub fn magnitude(&self) -> f64 {
        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
    }
}

#[derive(Clone)]
pub struct Size {
    pub width: usize,
    pub height: usize
}

impl Size {
    pub fn new(width: usize, height: usize) -> Self {
        Size {
            width,
            height
        }
    }

    pub fn zero() -> Self {
        Size { width: 0, height: 0 }
    }

    pub fn to_vector(&self) -> Vector {
        Vector::new(self.width as i64, self.height as i64)
    }
}

#[derive(Clone, PartialEq, PartialOrd)]
pub struct Matrix<Item: Clone> {
    shape: (usize, usize),
    data: Vec<Item>
}

impl<Item: Clone> Matrix<Item> {
    pub fn with_rows(data: &[Item], row_count: usize) -> Self {
        assert!(data.len() % row_count == 0, "Matrix must completely fill the grid");

        let col_count = data.len() / row_count;
        Matrix { shape: (col_count, row_count), data: data.iter().map(|x| (*x).clone()).collect() }
    }

    pub fn data(&self) -> &[Item] {
        &self.data
    }

    pub fn shape(&self) -> (usize, usize) {
        self.shape
    }

    pub fn get(&self, x: usize, y: usize) -> &Item {
        assert!(x < self.shape.0 && y < self.shape.1);

        let index = y * self.shape.1 + x;

        &self.data[index]
    }

    pub fn get_mut(&mut self, x: usize, y: usize) -> &mut Item {
        assert!(x < self.shape.0 && y < self.shape.1);

        let index = y * self.shape.1 + x;

        &mut self.data[index]
    }
}