Line data Source code
1 : #pragma once
2 :
3 : #include "MIDIInputElementMatchers.hpp"
4 :
5 : BEGIN_CS_NAMESPACE
6 :
7 : // -------------------------------------------------------------------------- //
8 :
9 : /// Generic base class for classes that listen for MIDI Note, Control Change and
10 : /// Key Pressure events on a range of addresses and save their values.
11 : ///
12 : /// @tparam Type
13 : /// The type of MIDI messages to listen for:
14 : /// - @ref MIDIMessageType::NoteOn
15 : /// - @ref MIDIMessageType::ControlChange
16 : /// - @ref MIDIMessageType::KeyPressure
17 : /// @tparam RangeLen
18 : /// The length of the range of addresses to listen to.
19 : template <MIDIMessageType Type, uint8_t RangeLen>
20 : class NoteCCKPRange
21 : : public MatchingMIDIInputElement<Type, TwoByteRangeMIDIMatcher> {
22 : public:
23 : using Matcher = TwoByteRangeMIDIMatcher;
24 :
25 : /// @param address
26 : /// The first address of the range to listen to.
27 1 : NoteCCKPRange(MIDIAddress address)
28 1 : : MatchingMIDIInputElement<Type, Matcher>({address, RangeLen}) {}
29 :
30 : private:
31 4 : bool handleUpdateImpl(typename Matcher::Result match) {
32 4 : bool newdirty = values[match.index] != match.value;
33 4 : values[match.index] = match.value;
34 4 : return newdirty;
35 : }
36 :
37 4 : void handleUpdate(typename Matcher::Result match) override {
38 4 : dirty |= handleUpdateImpl(match);
39 4 : }
40 :
41 : public:
42 : /// @name Data access
43 : /// @{
44 :
45 : /// Get the most recent MIDI value that was received for the given index
46 : /// in the range.
47 10 : uint8_t getValue(uint8_t index) const { return values[index]; }
48 :
49 : /// @}
50 :
51 : /// Reset all values to zero.
52 0 : void reset() override {
53 0 : values = {{}};
54 0 : dirty = true;
55 0 : }
56 :
57 : /// @name Detecting changes
58 : /// @{
59 :
60 : /// Check if the value was updated since the last time the dirty flag was
61 : /// cleared.
62 6 : bool getDirty() const { return dirty; }
63 : /// Clear the dirty flag.
64 4 : void clearDirty() { dirty = false; }
65 :
66 : /// @}
67 :
68 : private:
69 : AH::Array<uint8_t, RangeLen> values = {{}};
70 : bool dirty = true;
71 : };
72 :
73 : /// Class that listen for MIDI Note events on a range of addresses and
74 : /// saves their values.
75 : /// @ingroup MIDIInputElements
76 : template <uint8_t RangeLen>
77 : using NoteRange = NoteCCKPRange<MIDIMessageType::NoteOn, RangeLen>;
78 :
79 : /// Class that listen for MIDI Control Change events on a range of addresses and
80 : /// saves their values.
81 : /// @ingroup MIDIInputElements
82 : template <uint8_t RangeLen>
83 : using CCRange = NoteCCKPRange<MIDIMessageType::ControlChange, RangeLen>;
84 :
85 : /// Class that listen for MIDI Key Pressure events on a range of addresses and
86 : /// saves their values.
87 : /// @ingroup MIDIInputElements
88 : template <uint8_t RangeLen>
89 : using KPRange = NoteCCKPRange<MIDIMessageType::KeyPressure, RangeLen>;
90 :
91 : // -------------------------------------------------------------------------- //
92 :
93 : namespace Bankable {
94 :
95 : /// Generic base class for classes that listen for MIDI Note, Control Change and
96 : /// Key Pressure events on a range of addresses and save their values. This
97 : /// version listens for the range over different banks.
98 : ///
99 : /// @tparam Type
100 : /// The type of MIDI messages to listen for:
101 : /// - @ref MIDIMessageType::NoteOn
102 : /// - @ref MIDIMessageType::ControlChange
103 : /// - @ref MIDIMessageType::KeyPressure
104 : /// @tparam BankSize
105 : /// The number of banks.
106 : /// @tparam RangeLen
107 : /// The length of the range of addresses to listen to.
108 : template <MIDIMessageType Type, uint8_t BankSize, uint8_t RangeLen>
109 : class NoteCCKPRange : public BankableMatchingMIDIInputElement<
110 : Type, BankableTwoByteRangeMIDIMatcher<BankSize>> {
111 : public:
112 : using Matcher = BankableTwoByteRangeMIDIMatcher<BankSize>;
113 :
114 : /// @param config
115 : /// The bank configuration to use.
116 : /// @param address
117 : /// The base address to listen to.
118 6 : NoteCCKPRange(BankConfig<BankSize> config, MIDIAddress address)
119 : : BankableMatchingMIDIInputElement<Type, Matcher>(
120 6 : {config, address, RangeLen}) {}
121 :
122 : protected:
123 12 : bool handleUpdateImpl(typename Matcher::Result match) {
124 24 : bool newdirty = values[match.bankIndex][match.index] != match.value &&
125 12 : match.bankIndex == this->getActiveBank();
126 : // Only mark dirty if the value of the active bank changed
127 12 : values[match.bankIndex][match.index] = match.value;
128 12 : return newdirty;
129 : }
130 :
131 12 : void handleUpdate(typename Matcher::Result match) override {
132 12 : dirty |= handleUpdateImpl(match);
133 12 : }
134 :
135 : public:
136 : /// @name Data access
137 : /// @{
138 :
139 : /// Get the most recent MIDI value that was received for the active bank.
140 168 : uint8_t getValue(uint8_t index) const {
141 168 : return values[this->getActiveBank()][index];
142 : }
143 : /// Get the most recent MIDI value that was received for the given bank.
144 156 : uint8_t getValue(uint8_t bank, uint8_t index) const {
145 156 : return values[bank][index];
146 : }
147 :
148 : /// @}
149 :
150 : /// Reset all values to zero.
151 0 : void reset() override {
152 0 : values = {{{}}};
153 0 : dirty = true;
154 0 : }
155 :
156 : /// @name Detecting changes
157 : /// @{
158 :
159 : /// Check if the value was updated since the last time the dirty flag was
160 : /// cleared.
161 42 : bool getDirty() const { return dirty; }
162 : /// Clear the dirty flag.
163 22 : void clearDirty() { dirty = false; }
164 :
165 : /// @}
166 :
167 : protected:
168 44 : void onBankSettingChange() override { dirty = true; }
169 :
170 : private:
171 : AH::Array2D<uint8_t, BankSize, RangeLen> values = {{{}}};
172 :
173 : protected:
174 : bool dirty = true;
175 : };
176 :
177 : /// Class that listens for MIDI Note events on a range of addresses and
178 : /// saves their values. This version listens for the range over different banks.
179 : /// @ingroup BankableMIDIInputElements
180 : template <uint8_t BankSize, uint8_t RangeLen>
181 : using NoteRange = NoteCCKPRange<MIDIMessageType::NoteOn, BankSize, RangeLen>;
182 :
183 : /// Class that listens for MIDI Control Change events on a range of addresses
184 : /// and saves their values. This version listens for the range over different
185 : /// banks.
186 : /// @ingroup BankableMIDIInputElements
187 : template <uint8_t BankSize, uint8_t RangeLen>
188 : using CCRange =
189 : NoteCCKPRange<MIDIMessageType::ControlChange, BankSize, RangeLen>;
190 :
191 : /// Class that listens for MIDI Key Pressure events on a range of addresses and
192 : /// saves their values. This version listens for the range over different banks.
193 : /// @ingroup BankableMIDIInputElements
194 : template <uint8_t BankSize, uint8_t RangeLen>
195 : using KPRange = NoteCCKPRange<MIDIMessageType::KeyPressure, BankSize, RangeLen>;
196 :
197 : } // namespace Bankable
198 :
199 : END_CS_NAMESPACE
|
