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
//!
//! User interface geometry
//!
//! The 2D coordinate system in X-Plane has its origin in the lower left corner of the window.
//! Its units are pixels. [More information about X-Plane's coordinate systems is available here]
//! (http://www.xsquawkbox.net/xpsdk/mediawiki/ScreenCoordinates)
//!
/// A 2-dimensional rectangle
#[derive(Debug, Copy, Clone)]
pub struct Rect<N> {
/// The top coordinate
top: N,
/// The bottom coordinate
bottom: N,
/// The left coordinate
left: N,
/// The right coordinate
right: N,
}
impl<N> Rect<N> {
/// Creates a rectangle from left, top, right, and bottom coordinates
pub fn from_left_top_right_bottom(left: N, top: N, right: N, bottom: N) -> Self {
Rect {
top,
bottom,
left,
right,
}
}
/// Creates a rectangle from a top left corner and a bottom right corner
pub fn from_corners(top_left: Point<N>, bottom_right: Point<N>) -> Self {
let (left, top) = top_left.into_xy();
let (bottom, right) = bottom_right.into_xy();
Rect {
top,
bottom,
left,
right,
}
}
/// Consumes this rectangle and returns its left, top, bottom, and right coordinates
pub fn into_left_top_bottom_right(self) -> (N, N, N, N) {
(self.left, self.top, self.bottom, self.right)
}
pub fn set_top(&mut self, top: N) {
self.top = top;
}
pub fn set_left(&mut self, left: N) {
self.left = left;
}
pub fn set_bottom(&mut self, bottom: N) {
self.bottom = bottom;
}
pub fn set_right(&mut self, right: N) {
self.right = right;
}
/// Determines whether this rectangle contains a point
///
/// For this calculation, the bottom and left edges are inside the rectangle, while the
/// top and right edges are outside.
pub fn contains(&self, point: Point<N>) -> bool
where
N: PartialOrd,
{
let (x, y) = point.into_xy();
x >= self.left && x < self.right && y >= self.bottom && y < self.top
}
}
impl<N: Clone> Rect<N> {
pub fn top(&self) -> N {
self.top.clone()
}
pub fn bottom(&self) -> N {
self.bottom.clone()
}
pub fn left(&self) -> N {
self.left.clone()
}
pub fn right(&self) -> N {
self.right.clone()
}
}
/// A 2D point
#[derive(Debug, Copy, Clone)]
pub struct Point<N> {
/// The X coordinate
x: N,
/// The Y coordinate
y: N,
}
impl<N> Point<N> {
/// Creates a point from X and Y coordinates
pub fn from_xy(x: N, y: N) -> Self {
Point { x, y }
}
pub fn set_x(&mut self, x: N) {
self.x = x;
}
pub fn set_y(&mut self, y: N) {
self.y = y;
}
pub fn into_xy(self) -> (N, N) {
(self.x, self.y)
}
}
impl<N: Clone> Point<N> {
pub fn x(&self) -> N {
self.x.clone()
}
pub fn y(&self) -> N {
self.y.clone()
}
}
impl<N> From<(N, N)> for Point<N> {
/// Converts an (x, y) pair into a point
fn from((x, y): (N, N)) -> Self {
Point::from_xy(x, y)
}
}