launchy 0.1.0

Low-level bindings and high-level abstractions for the Novation Launchpad MIDI devices
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

// use super::*;


/// A 2d point that represents a single pad on a grid of pads. For convenience, the coordinates can
/// be negative.
/// 
/// [`Pad`] implements various mathematical operator traits for the `(i32, i32)` tuple. Therefore it's
/// possible move a pad around by adding or subtracting (x, y) coordinate tuples:
/// 
/// ```rust
/// let pad = Pad { x: 3, y: 6 };
/// 
/// assert_eq!(pad + (4, 4), Pad { x: 7, y: 10 });
/// assert_eq!(pad - (4, 4), Pad { x: -1, y: 2 });
/// ```
#[derive(Copy, Clone, PartialEq, Eq, Debug, Default, Hash)]
pub struct Pad {
	pub x: i32,
	pub y: i32,
}

impl Pad {
	/// Return a copy of this [`Pad`], moved upwards by a certain number of steps
	pub fn up(self, steps: i32) -> Self {
		Self { x: self.x, y: self.y - steps }
	}

	/// Return a copy of this [`Pad`], moved downwards by a certain number of steps
	pub fn down(self, steps: i32) -> Self {
		Self { x: self.x, y: self.y + steps }
	}

	/// Return a copy of this [`Pad`], moved left by a certain number of steps
	pub fn left(self, steps: i32) -> Self {
		Self { x: self.x - steps, y: self.y }
	}

	/// Return a copy of this [`Pad`], moved right by a certain number of steps
	pub fn right(self, steps: i32) -> Self {
		Self { x: self.x + steps, y: self.y }
	}

	/// Returns an array of the four surrounding neighbors of this pad
	pub fn neighbors_4(self) -> [Self; 4] {
		[
			self.up(1),
			self.right(1),
			self.down(1),
			self.left(1),
		]
	}

	/// Returns an array of the four surrounding neighbors of this pad, plus itself
	pub fn neighbors_5(self) -> [Self; 5] {
		[
			self,
			self.up(1),
			self.right(1),
			self.down(1),
			self.left(1),
		]
	}

	/// Returns an array of the eight surrounding neighbors of this pad
	pub fn neighbors_8(self) -> [Self; 8] {
		[
			self.up(1),
			self.up(1).right(1),
			self.right(1),
			self.right(1).down(1),
			self.down(1),
			self.down(1).left(1),
			self.left(1),
			self.left(1).up(1),
		]
	}

	/// Returns an array of the eight surrounding neighbors of this pad, plus itself
	pub fn neighbors_9(self) -> [Self; 9] {
		[
			self,
			self.up(1),
			self.up(1).right(1),
			self.right(1),
			self.right(1).down(1),
			self.down(1),
			self.down(1).left(1),
			self.left(1),
			self.left(1).up(1),
		]
	}
}

impl std::ops::Add<(i32, i32)> for Pad {
	type Output = Self;

	fn add(self, offset: (i32, i32)) -> Self {
		let (x_offset, y_offset) = offset;
		Self {
			x: self.x + x_offset,
			y: self.y + y_offset,
		}
	}
}

impl std::ops::AddAssign<(i32, i32)> for Pad {
	fn add_assign(&mut self, offset: (i32, i32)) {
		let (x_offset, y_offset) = offset;
		self.x += x_offset;
		self.y += y_offset;
	}
}

impl std::ops::Sub<(i32, i32)> for Pad {
	type Output = Self;

	fn sub(self, offset: (i32, i32)) -> Self {
		let (x_offset, y_offset) = offset;
		Self {
			x: self.x - x_offset,
			y: self.y - y_offset,
		}
	}
}

impl std::ops::SubAssign<(i32, i32)> for Pad {
	fn sub_assign(&mut self, offset: (i32, i32)) {
		let (x_offset, y_offset) = offset;
		self.x -= x_offset;
		self.y -= y_offset;
	}
}