2 Copyright (C) 2008 Paul Davis
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "midi_channel_selector.h"
22 #include "gtkmm/separator.h"
24 #include "rgb_macros.h"
28 using namespace ARDOUR
;
30 MidiChannelSelector::MidiChannelSelector(int n_rows
, int n_columns
, int start_row
, int start_column
)
31 : Table(n_rows
, n_columns
, true)
32 , _recursion_counter(0)
35 assert(n_rows
>= start_row
+ 4);
36 assert(n_columns
>=4);
37 assert(n_columns
>= start_column
+ 4);
39 property_column_spacing() = 0;
40 property_row_spacing() = 0;
42 uint8_t channel_nr
= 0;
43 for (int row
= 0; row
< 4; ++row
) {
44 for (int column
= 0; column
< 4; ++column
) {
45 ostringstream channel
;
46 channel
<< int(++channel_nr
);
47 _button_labels
[row
][column
].set_text(channel
.str());
48 _button_labels
[row
][column
].set_justify(JUSTIFY_RIGHT
);
49 _buttons
[row
][column
].add(_button_labels
[row
][column
]);
50 _buttons
[row
][column
].signal_toggled().connect(
52 sigc::mem_fun(this, &MidiChannelSelector::button_toggled
),
53 &_buttons
[row
][column
],
56 _buttons
[row
][column
].signal_button_release_event().connect(
57 sigc::mem_fun(this, &MidiChannelSelector::was_clicked
), false);
60 int table_row
= start_row
+ row
;
61 int table_column
= start_column
+ column
;
62 attach(_buttons
[row
][column
], table_column
, table_column
+ 1, table_row
, table_row
+ 1);
67 MidiChannelSelector::~MidiChannelSelector()
72 MidiChannelSelector::was_clicked (GdkEventButton
*)
79 MidiChannelSelector::set_channel_colors(const uint32_t new_channel_colors
[16])
81 for (int row
= 0; row
< 4; ++row
) {
82 for (int column
= 0; column
< 4; ++column
) {
85 snprintf(color_normal
, 8, "#%x", UINT_INTERPOLATE(new_channel_colors
[row
* 4 + column
], 0x000000ff, 0.6));
86 snprintf(color_active
, 8, "#%x", new_channel_colors
[row
* 4 + column
]);
87 _buttons
[row
][column
].modify_bg(STATE_NORMAL
, Gdk::Color(color_normal
));
88 _buttons
[row
][column
].modify_bg(STATE_ACTIVE
, Gdk::Color(color_active
));
94 MidiChannelSelector::set_default_channel_color()
96 for (int row
= 0; row
< 4; ++row
) {
97 for (int column
= 0; column
< 4; ++column
) {
98 _buttons
[row
][column
].unset_bg(STATE_NORMAL
);
99 _buttons
[row
][column
].unset_bg(STATE_ACTIVE
);
104 SingleMidiChannelSelector::SingleMidiChannelSelector(uint8_t active_channel
)
105 : MidiChannelSelector()
107 _last_active_button
= 0;
108 ToggleButton
* button
= &_buttons
[active_channel
/ 4][active_channel
% 4];
109 _active_channel
= active_channel
;
110 button
->set_active(true);
111 _last_active_button
= button
;
115 SingleMidiChannelSelector::button_toggled(ToggleButton
* button
, uint8_t channel
)
117 ++_recursion_counter
;
118 if (_recursion_counter
== 1) {
119 // if the current button is active it must
120 // be different from the first one
121 if (button
->get_active()) {
122 if (_last_active_button
) {
123 _last_active_button
->set_active(false);
124 _active_channel
= channel
;
125 _last_active_button
= button
;
126 channel_selected
.emit(channel
);
129 // if not, the user pressed the already active button
130 button
->set_active(true);
131 _active_channel
= channel
;
134 --_recursion_counter
;
137 MidiMultipleChannelSelector::MidiMultipleChannelSelector(ChannelMode mode
, uint16_t mask
)
138 : MidiChannelSelector(4, 6, 0, 0)
139 , _channel_mode(mode
)
141 _select_all
.add(*manage(new Label(_("All"))));
142 _select_all
.signal_clicked().connect(
143 sigc::bind(sigc::mem_fun(this, &MidiMultipleChannelSelector::select_all
), true));
145 _select_none
.add(*manage(new Label(_("None"))));
146 _select_none
.signal_clicked().connect(
147 sigc::bind(sigc::mem_fun(this, &MidiMultipleChannelSelector::select_all
), false));
149 _invert_selection
.add(*manage(new Label(_("Invert"))));
150 _invert_selection
.signal_clicked().connect(
151 sigc::mem_fun(this, &MidiMultipleChannelSelector::invert_selection
));
153 _force_channel
.add(*manage(new Label(_("Force"))));
154 _force_channel
.signal_toggled().connect(
155 sigc::mem_fun(this, &MidiMultipleChannelSelector::force_channels_button_toggled
));
157 set_homogeneous(false);
158 attach(*manage(new VSeparator()), 4, 5, 0, 4, SHRINK
, FILL
, 0, 0);
159 //set_row_spacing(4, -5);
160 attach(_select_all
, 5, 6, 0, 1);
161 attach(_select_none
, 5, 6, 1, 2);
162 attach(_invert_selection
, 5, 6, 2, 3);
163 attach(_force_channel
, 5, 6, 3, 4);
165 set_selected_channels(mask
);
168 MidiMultipleChannelSelector::~MidiMultipleChannelSelector()
170 mode_changed
.clear();
174 MidiMultipleChannelSelector::set_channel_mode(ChannelMode mode
, uint16_t mask
)
178 _force_channel
.set_active(false);
179 set_selected_channels(0xFFFF);
182 _force_channel
.set_active(false);
183 set_selected_channels(mask
);
186 _force_channel
.set_active(true);
187 for (uint16_t i
= 0; i
< 16; i
++) {
188 ToggleButton
* button
= &_buttons
[i
/ 4][i
% 4];
189 button
->set_active(i
== mask
);
195 MidiMultipleChannelSelector::get_selected_channels() const
197 uint16_t selected_channels
= 0;
198 for (uint16_t i
= 0; i
< 16; i
++) {
199 const ToggleButton
* button
= &_buttons
[i
/ 4][i
% 4];
200 if (button
->get_active()) {
201 selected_channels
|= (1L << i
);
205 return selected_channels
;
209 MidiMultipleChannelSelector::set_selected_channels(uint16_t selected_channels
)
211 for (uint16_t i
= 0; i
< 16; i
++) {
212 ToggleButton
* button
= &_buttons
[i
/ 4][i
% 4];
213 if (selected_channels
& (1L << i
)) {
214 button
->set_active(true);
216 button
->set_active(false);
222 MidiMultipleChannelSelector::button_toggled(ToggleButton */
*button*/
, uint8_t channel
)
224 ++_recursion_counter
;
225 if (_recursion_counter
== 1) {
226 if (_channel_mode
== ForceChannel
) {
227 mode_changed
.emit(_channel_mode
, channel
);
228 set_selected_channels(1 << channel
);
230 mode_changed
.emit(_channel_mode
, get_selected_channels());
233 --_recursion_counter
;
237 MidiMultipleChannelSelector::force_channels_button_toggled()
239 if (_force_channel
.get_active()) {
240 _channel_mode
= ForceChannel
;
241 bool found_first_active
= false;
242 // leave only the first button enabled
243 uint16_t active_channel
= 0;
244 for (int i
= 0; i
<= 15; i
++) {
245 ToggleButton
* button
= &_buttons
[i
/ 4][i
% 4];
246 if (button
->get_active()) {
247 if (found_first_active
) {
248 ++_recursion_counter
;
249 button
->set_active(false);
250 --_recursion_counter
;
252 found_first_active
= true;
258 if (!found_first_active
) {
259 _buttons
[0][0].set_active(true);
262 _select_all
.set_sensitive(false);
263 _select_none
.set_sensitive(false);
264 _invert_selection
.set_sensitive(false);
265 mode_changed
.emit(_channel_mode
, active_channel
);
267 _channel_mode
= FilterChannels
;
268 _select_all
.set_sensitive(true);
269 _select_none
.set_sensitive(true);
270 _invert_selection
.set_sensitive(true);
271 mode_changed
.emit(FilterChannels
, get_selected_channels());
276 MidiMultipleChannelSelector::select_all(bool on
)
278 if (_channel_mode
== ForceChannel
)
281 ++_recursion_counter
;
282 for (uint16_t i
= 0; i
< 16; i
++) {
283 ToggleButton
* button
= &_buttons
[i
/ 4][i
% 4];
284 button
->set_active(on
);
286 --_recursion_counter
;
287 mode_changed
.emit(_channel_mode
, get_selected_channels());
291 MidiMultipleChannelSelector::invert_selection(void)
293 if (_channel_mode
== ForceChannel
)
296 ++_recursion_counter
;
297 for (uint16_t i
= 0; i
< 16; i
++) {
298 ToggleButton
* button
= &_buttons
[i
/ 4][i
% 4];
299 if (button
->get_active()) {
300 button
->set_active(false);
302 button
->set_active(true);
305 --_recursion_counter
;
306 mode_changed
.emit(_channel_mode
, get_selected_channels());