2 Copyright (C) 2002-2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #include <gtkmm2ext/gtk_ui.h>
21 #include <gtkmm2ext/choice.h>
22 #include <gtkmm2ext/doi.h>
23 #include <gtkmm2ext/bindable_button.h>
24 #include <gtkmm2ext/barcontroller.h>
25 #include <gtkmm2ext/gtk_ui.h>
27 #include "ardour/route_group.h"
28 #include "ardour/dB.h"
29 #include "pbd/memento_command.h"
30 #include "pbd/stacktrace.h"
31 #include "pbd/controllable.h"
32 #include "pbd/enumwriter.h"
34 #include "ardour_ui.h"
41 #include "gui_thread.h"
42 #include "ardour_dialog.h"
43 #include "latency_gui.h"
44 #include "mixer_strip.h"
45 #include "automation_time_axis.h"
46 #include "route_time_axis.h"
48 #include "ardour/route.h"
49 #include "ardour/event_type_map.h"
50 #include "ardour/session.h"
51 #include "ardour/audioengine.h"
52 #include "ardour/audio_track.h"
53 #include "ardour/midi_track.h"
54 #include "ardour/template_utils.h"
55 #include "ardour/filename_extensions.h"
56 #include "ardour/directory_names.h"
57 #include "ardour/profile.h"
61 using namespace Gtkmm2ext
;
62 using namespace ARDOUR
;
65 uint32_t RouteUI::_max_invert_buttons
= 3;
67 RouteUI::RouteUI (ARDOUR::Session
* sess
)
73 RouteUI::RouteUI (boost::shared_ptr
<ARDOUR::Route
> rt
, ARDOUR::Session
* sess
)
82 _route
.reset (); /* drop reference to route, so that it can be cleaned up */
83 route_connections
.drop_connections ();
102 pre_fader_mute_check
= 0;
103 post_fader_mute_check
= 0;
104 listen_mute_check
= 0;
107 solo_isolated_check
= 0;
108 solo_isolated_led
= 0;
112 route_active_menu_item
= 0;
113 denormal_menu_item
= 0;
115 multiple_mute_change
= false;
116 multiple_solo_change
= false;
117 _i_am_the_modifier
= 0;
119 setup_invert_buttons ();
121 mute_button
= manage (new BindableToggleButton ());
122 // mute_button->set_self_managed (true);
123 mute_button
->set_name ("MuteButton");
124 mute_button
->add (mute_button_label
);
125 mute_button_label
.show ();
126 UI::instance()->set_tip (mute_button
, _("Mute this track"), "");
128 solo_button
= manage (new BindableToggleButton ());
129 // solo_button->set_self_managed (true);
130 solo_button
->set_name ("SoloButton");
131 solo_button
->add (solo_button_label
);
132 solo_button_label
.show ();
133 UI::instance()->set_tip (solo_button
, _("Mute other (non-soloed) tracks"), "");
134 solo_button
->set_no_show_all (true);
136 rec_enable_button
= manage (new BindableToggleButton ());
137 rec_enable_button
->set_name ("RecordEnableButton");
138 // rec_enable_button->set_self_managed (true);
139 rec_enable_button
->add (rec_enable_button_label
);
140 rec_enable_button_label
.show ();
141 UI::instance()->set_tip (rec_enable_button
, _("Enable recording on this track"), "");
143 show_sends_button
= manage (new BindableToggleButton (""));
144 show_sends_button
->set_name ("SendAlert");
145 // show_sends_button->set_self_managed (true);
146 UI::instance()->set_tip (show_sends_button
, _("make mixer strips show sends to this bus"), "");
148 _session
->SoloChanged
.connect (_session_connections
, invalidator (*this), boost::bind (&RouteUI::solo_changed_so_update_mute
, this), gui_context());
149 _session
->TransportStateChange
.connect (_session_connections
, invalidator (*this), boost::bind (&RouteUI::check_rec_enable_sensitivity
, this), gui_context());
150 _session
->RecordStateChanged
.connect (_session_connections
, invalidator (*this), boost::bind (&RouteUI::session_rec_enable_changed
, this), gui_context());
152 Config
->ParameterChanged
.connect (*this, invalidator (*this), ui_bind (&RouteUI::parameter_changed
, this, _1
), gui_context());
154 rec_enable_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press
), false);
155 rec_enable_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release
), false);
157 show_sends_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_press
), false);
158 show_sends_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release
));
160 solo_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press
), false);
161 solo_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release
), false);
162 mute_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press
), false);
163 mute_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release
), false);
169 route_connections
.drop_connections ();
178 /* do not delete the node - its owned by the route */
182 route_active_menu_item
= 0;
183 denormal_menu_item
= 0;
187 RouteUI::self_delete ()
189 /* This may be called from a non-GUI thread. Keep it safe */
191 delete_when_idle (this);
195 RouteUI::set_route (boost::shared_ptr
<Route
> rp
)
201 if (set_color_from_route()) {
202 set_color (unique_random_color());
206 rp
->DropReferences
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::self_delete
, this), gui_context());
209 mute_button
->set_controllable (_route
->mute_control());
210 solo_button
->set_controllable (_route
->solo_control());
212 _route
->active_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::route_active_changed
, this), gui_context());
213 _route
->mute_changed
.connect (route_connections
, invalidator (*this), ui_bind (&RouteUI::mute_changed
, this, _1
), gui_context());
215 _route
->solo_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
216 _route
->solo_safe_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
217 _route
->listen_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
218 _route
->solo_isolated_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
220 _route
->phase_invert_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::polarity_changed
, this), gui_context());
221 _route
->PropertyChanged
.connect (route_connections
, invalidator (*this), ui_bind (&RouteUI::property_changed
, this, _1
), gui_context());
223 _route
->io_changed
.connect (route_connections
, invalidator (*this), ui_bind (&RouteUI::setup_invert_buttons
, this), gui_context ());
225 if (_session
->writable() && is_track()) {
226 boost::shared_ptr
<Track
> t
= boost::dynamic_pointer_cast
<Track
>(_route
);
228 t
->RecordEnableChanged
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed
, this), gui_context());
230 rec_enable_button
->show();
231 rec_enable_button
->set_controllable (t
->rec_enable_control());
233 update_rec_display ();
235 if (is_midi_track()) {
236 midi_track()->StepEditStatusChange
.connect (route_connections
, invalidator (*this),
237 ui_bind (&RouteUI::step_edit_changed
, this, _1
), gui_context());
242 mute_button
->unset_flags (Gtk::CAN_FOCUS
);
243 solo_button
->unset_flags (Gtk::CAN_FOCUS
);
247 if (_route
->is_monitor()) {
248 solo_button
->hide ();
255 setup_invert_buttons ();
256 set_invert_button_state ();
260 RouteUI::polarity_changed ()
266 set_invert_button_state ();
270 RouteUI::mute_press (GdkEventButton
* ev
)
272 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
276 multiple_mute_change
= false;
278 if (!_i_am_the_modifier
) {
280 if (Keyboard::is_context_menu_event (ev
)) {
286 mute_menu
->popup(0,ev
->time
);
290 if (Keyboard::is_button2_event (ev
)) {
291 // Primary-button2 click is the midi binding click
292 // button2-click is "momentary"
295 if (mute_button
->on_button_press_event (ev
)) {
299 _mute_release
= new SoloMuteRelease (_route
->muted ());
302 if (ev
->button
== 1 || Keyboard::is_button2_event (ev
)) {
304 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
307 _mute_release
->routes
= _session
->get_routes ();
310 _session
->set_mute (_session
->get_routes(), !_route
->muted());
312 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
314 /* Primary-button1 applies change to the mix group even if it is not active
315 NOTE: Primary-button2 is MIDI learn.
318 if (ev
->button
== 1 && _route
->route_group()) {
320 _mute_release
->routes
= _session
->get_routes ();
323 _session
->set_mute (_session
->get_routes(), !_route
->muted(), Session::rt_cleanup
, true);
328 /* plain click applies change to this route */
330 boost::shared_ptr
<RouteList
> rl (new RouteList
);
331 rl
->push_back (_route
);
334 _mute_release
->routes
= rl
;
337 _session
->set_mute (rl
, !_route
->muted());
349 RouteUI::mute_release (GdkEventButton
*)
351 if (!_i_am_the_modifier
) {
353 _session
->set_mute (_mute_release
->routes
, _mute_release
->active
, Session::rt_cleanup
, true);
354 delete _mute_release
;
363 RouteUI::solo_press(GdkEventButton
* ev
)
365 /* ignore double/triple clicks */
367 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
371 multiple_solo_change
= false;
373 if (!_i_am_the_modifier
) {
375 if (Keyboard::is_context_menu_event (ev
)) {
377 if (!solo_isolated_led
) {
379 if (solo_menu
== 0) {
383 solo_menu
->popup (1, ev
->time
);
388 if (Keyboard::is_button2_event (ev
)) {
390 // Primary-button2 click is the midi binding click
391 // button2-click is "momentary"
393 if (solo_button
->on_button_press_event (ev
)) {
397 _solo_release
= new SoloMuteRelease (_route
->self_soloed());
400 if (ev
->button
== 1 || Keyboard::is_button2_event (ev
)) {
402 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
404 /* Primary-Tertiary-click applies change to all routes */
407 _solo_release
->routes
= _session
->get_routes ();
410 if (Config
->get_solo_control_is_listen_control()) {
411 _session
->set_listen (_session
->get_routes(), !_route
->listening_via_monitor(), Session::rt_cleanup
, true);
413 _session
->set_solo (_session
->get_routes(), !_route
->self_soloed(), Session::rt_cleanup
, true);
416 } else if (Keyboard::modifier_state_contains (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::SecondaryModifier
))) {
418 // Primary-Secondary-click: exclusively solo this track
421 _solo_release
->exclusive
= true;
423 boost::shared_ptr
<RouteList
> routes
= _session
->get_routes();
425 for (RouteList::iterator i
= routes
->begin(); i
!= routes
->end(); ++i
) {
426 if ((*i
)->soloed ()) {
427 _solo_release
->routes_on
->push_back (*i
);
429 _solo_release
->routes_off
->push_back (*i
);
434 if (Config
->get_solo_control_is_listen_control()) {
435 /* ??? we need a just_one_listen() method */
437 _session
->set_just_one_solo (_route
, true);
440 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::TertiaryModifier
)) {
442 // shift-click: toggle solo isolated status
444 _route
->set_solo_isolated (!_route
->solo_isolated(), this);
445 delete _solo_release
;
448 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
450 /* Primary-button1: solo mix group.
451 NOTE: Primary-button2 is MIDI learn.
454 if (ev
->button
== 1 && _route
->route_group()) {
457 _solo_release
->routes
= _route
->route_group()->route_list();
460 if (Config
->get_solo_control_is_listen_control()) {
461 _session
->set_listen (_route
->route_group()->route_list(), !_route
->listening_via_monitor(), Session::rt_cleanup
, true);
463 _session
->set_solo (_route
->route_group()->route_list(), !_route
->self_soloed(), Session::rt_cleanup
, true);
469 /* click: solo this route */
471 boost::shared_ptr
<RouteList
> rl (new RouteList
);
472 rl
->push_back (route());
475 _solo_release
->routes
= rl
;
478 if (Config
->get_solo_control_is_listen_control()) {
479 _session
->set_listen (rl
, !_route
->listening_via_monitor());
481 _session
->set_solo (rl
, !_route
->self_soloed());
492 RouteUI::solo_release (GdkEventButton
*)
494 if (!_i_am_the_modifier
) {
498 if (_solo_release
->exclusive
) {
501 if (Config
->get_solo_control_is_listen_control()) {
502 _session
->set_listen (_solo_release
->routes
, _solo_release
->active
, Session::rt_cleanup
, true);
504 _session
->set_solo (_solo_release
->routes
, _solo_release
->active
, Session::rt_cleanup
, true);
508 delete _solo_release
;
517 RouteUI::rec_enable_press(GdkEventButton
* ev
)
519 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
523 if (!_session
->engine().connected()) {
524 MessageDialog
msg (_("Not connected to JACK - cannot engage record"));
529 if (is_midi_track()) {
531 /* cannot rec-enable while step-editing */
533 if (midi_track()->step_editing()) {
538 if (!_i_am_the_modifier
&& is_track() && rec_enable_button
) {
540 if (Keyboard::is_button2_event (ev
)) {
542 // do nothing on midi sigc::bind event
543 return rec_enable_button
->on_button_press_event (ev
);
545 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
547 _session
->set_record_enabled (_session
->get_routes(), !rec_enable_button
->get_active());
549 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
551 /* Primary-button1 applies change to the route group (even if it is not active)
552 NOTE: Primary-button2 is MIDI learn.
554 if (ev
->button
== 1 && _route
->route_group()) {
555 _session
->set_record_enabled (_route
->route_group()->route_list(), !rec_enable_button
->get_active(), Session::rt_cleanup
, true);
558 } else if (Keyboard::is_context_menu_event (ev
)) {
560 /* do this on release */
564 boost::shared_ptr
<RouteList
> rl (new RouteList
);
565 rl
->push_back (route());
566 _session
->set_record_enabled (rl
, !rec_enable_button
->get_active());
574 RouteUI::build_record_menu ()
580 /* no rec-button context menu for non-MIDI tracks
583 if (is_midi_track()) {
584 record_menu
= new Menu
;
585 record_menu
->set_name ("ArdourContextMenu");
587 using namespace Menu_Helpers
;
588 MenuList
& items
= record_menu
->items();
590 items
.push_back (CheckMenuElem (_("Step Entry"), sigc::mem_fun (*this, &RouteUI::toggle_step_edit
)));
591 step_edit_item
= dynamic_cast<CheckMenuItem
*> (&items
.back());
593 if (_route
->record_enabled()) {
594 step_edit_item
->set_sensitive (false);
597 step_edit_item
->set_active (midi_track()->step_editing());
602 RouteUI::toggle_step_edit ()
604 if (!is_midi_track() || _route
->record_enabled()) {
608 midi_track()->set_step_editing (step_edit_item
->get_active());
612 RouteUI::step_edit_changed (bool yn
)
615 if (rec_enable_button
) {
616 rec_enable_button
->set_visual_state (3);
619 start_step_editing ();
621 if (step_edit_item
) {
622 step_edit_item
->set_active (true);
627 if (rec_enable_button
) {
628 rec_enable_button
->set_visual_state (0);
631 stop_step_editing ();
633 if (step_edit_item
) {
634 step_edit_item
->set_active (false);
640 RouteUI::rec_enable_release (GdkEventButton
* ev
)
642 if (Keyboard::is_context_menu_event (ev
)) {
643 build_record_menu ();
645 record_menu
->popup (1, ev
->time
);
654 RouteUI::build_sends_menu ()
656 using namespace Menu_Helpers
;
658 sends_menu
= new Menu
;
659 sends_menu
->set_name ("ArdourContextMenu");
660 MenuList
& items
= sends_menu
->items();
663 MenuElem(_("Assign all tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PreFader
, false))
667 MenuElem(_("Assign all tracks and buses (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PreFader
, true))
671 MenuElem(_("Assign all tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PostFader
, false))
675 MenuElem(_("Assign all tracks and buses (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PostFader
, true))
679 MenuElem(_("Assign selected tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PreFader
, false))
683 MenuElem(_("Assign selected tracks and buses (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PreFader
, true)));
686 MenuElem(_("Assign selected tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PostFader
, false))
690 MenuElem(_("Assign selected tracks and buses (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PostFader
, true))
693 items
.push_back (MenuElem(_("Copy track/bus gains to sends"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_from_track
)));
694 items
.push_back (MenuElem(_("Set sends gain to -inf"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_zero
)));
695 items
.push_back (MenuElem(_("Set sends gain to 0dB"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_unity
)));
700 RouteUI::create_sends (Placement p
, bool include_buses
)
702 _session
->globally_add_internal_sends (_route
, p
, include_buses
);
706 RouteUI::create_selected_sends (Placement p
, bool include_buses
)
708 boost::shared_ptr
<RouteList
> rlist (new RouteList
);
709 TrackSelection
& selected_tracks (ARDOUR_UI::instance()->the_editor().get_selection().tracks
);
711 for (TrackSelection::iterator i
= selected_tracks
.begin(); i
!= selected_tracks
.end(); ++i
) {
712 RouteTimeAxisView
* rtv
;
714 if ((rtv
= dynamic_cast<RouteTimeAxisView
*>(*i
)) != 0) {
715 if ((rui
= dynamic_cast<RouteUI
*>(rtv
)) != 0) {
716 if (include_buses
|| boost::dynamic_pointer_cast
<AudioTrack
>(rui
->route())) {
717 rlist
->push_back (rui
->route());
723 _session
->add_internal_sends (_route
, p
, rlist
);
727 RouteUI::set_sends_gain_from_track ()
729 _session
->globally_set_send_gains_from_track (_route
);
733 RouteUI::set_sends_gain_to_zero ()
735 _session
->globally_set_send_gains_to_zero (_route
);
739 RouteUI::set_sends_gain_to_unity ()
741 _session
->globally_set_send_gains_to_unity (_route
);
745 RouteUI::show_sends_press(GdkEventButton
* ev
)
747 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
751 if (!_i_am_the_modifier
&& !is_track() && show_sends_button
) {
753 if (Keyboard::is_button2_event (ev
) && Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
755 // do nothing on midi sigc::bind event
758 } else if (Keyboard::is_context_menu_event (ev
)) {
760 if (sends_menu
== 0) {
764 sends_menu
->popup (0, ev
->time
);
768 /* change button state */
770 show_sends_button
->set_active (!show_sends_button
->get_active());
774 if (show_sends_button
->get_active()) {
775 /* show sends to this bus */
776 MixerStrip::SwitchIO (_route
);
777 send_blink_connection
= ARDOUR_UI::instance()->Blink
.connect (sigc::mem_fun(*this, &RouteUI::send_blink
));
779 /* everybody back to normal */
780 send_blink_connection
.disconnect ();
781 MixerStrip::SwitchIO (boost::shared_ptr
<Route
>());
791 RouteUI::show_sends_release (GdkEventButton
*)
797 RouteUI::send_blink (bool onoff
)
799 if (!show_sends_button
) {
804 show_sends_button
->set_state (STATE_ACTIVE
);
806 show_sends_button
->set_state (STATE_NORMAL
);
811 RouteUI::solo_visual_state (boost::shared_ptr
<Route
> r
)
813 if (r
->is_master() || r
->is_monitor()) {
817 if (Config
->get_solo_control_is_listen_control()) {
819 if (r
->listening_via_monitor()) {
828 if (!r
->self_soloed()) {
839 RouteUI::solo_visual_state_with_isolate (boost::shared_ptr
<Route
> r
)
841 if (r
->is_master() || r
->is_monitor()) {
845 if (Config
->get_solo_control_is_listen_control()) {
847 if (r
->listening_via_monitor()) {
855 if (r
->solo_isolated()) {
857 } else if (r
->soloed()) {
858 if (!r
->self_soloed()) {
869 RouteUI::solo_isolate_visual_state (boost::shared_ptr
<Route
> r
)
871 if (r
->is_master() || r
->is_monitor()) {
875 if (r
->solo_isolated()) {
883 RouteUI::solo_safe_visual_state (boost::shared_ptr
<Route
> r
)
885 if (r
->is_master() || r
->is_monitor()) {
889 if (r
->solo_safe()) {
897 RouteUI::update_solo_display ()
901 if (Config
->get_solo_control_is_listen_control()) {
903 if (solo_button
->get_active() != (x
= _route
->listening_via_monitor())) {
904 ++_i_am_the_modifier
;
905 solo_button
->set_active(x
);
906 --_i_am_the_modifier
;
911 if (solo_button
->get_active() != (x
= _route
->soloed())) {
912 ++_i_am_the_modifier
;
913 solo_button
->set_active (x
);
914 --_i_am_the_modifier
;
919 bool yn
= _route
->solo_safe ();
921 if (solo_safe_check
&& solo_safe_check
->get_active() != yn
) {
922 solo_safe_check
->set_active (yn
);
925 yn
= _route
->solo_isolated ();
927 if (solo_isolated_check
&& solo_isolated_check
->get_active() != yn
) {
928 solo_isolated_check
->set_active (yn
);
933 if (solo_isolated_led
) {
934 solo_isolated_led
->set_visual_state (_route
->solo_isolated() ? 1 : 0);
938 solo_safe_led
->set_visual_state (_route
->solo_safe() ? 1 : 0);
941 solo_button
->set_visual_state (solo_visual_state (_route
));
943 /* some changes to solo status can affect mute display, so catch up
946 update_mute_display ();
950 RouteUI::solo_changed_so_update_mute ()
952 update_mute_display ();
956 RouteUI::mute_changed(void* /*src*/)
958 update_mute_display ();
962 RouteUI::mute_visual_state (Session
* s
, boost::shared_ptr
<Route
> r
)
964 if (r
->is_master() || r
->is_monitor()) {
969 if (Config
->get_show_solo_mutes() && !Config
->get_solo_control_is_listen_control ()) {
974 } else if (s
->soloing() && !r
->soloed() && !r
->solo_isolated()) {
996 RouteUI::update_mute_display ()
1002 bool model
= _route
->muted();
1003 bool view
= mute_button
->get_active();
1005 /* first make sure the button's "depressed" visual
1009 if (model
!= view
) {
1010 ++_i_am_the_modifier
;
1011 mute_button
->set_active (model
);
1012 --_i_am_the_modifier
;
1015 mute_button
->set_visual_state (mute_visual_state (_session
, _route
));
1019 RouteUI::route_rec_enable_changed ()
1021 update_rec_display ();
1025 RouteUI::session_rec_enable_changed ()
1027 update_rec_display ();
1031 RouteUI::update_rec_display ()
1033 if (!rec_enable_button
|| !_route
) {
1037 bool model
= _route
->record_enabled();
1038 bool view
= rec_enable_button
->get_active();
1040 /* first make sure the button's "depressed" visual
1044 if (model
!= view
) {
1045 ++_i_am_the_modifier
;
1046 rec_enable_button
->set_active (model
);
1047 --_i_am_the_modifier
;
1050 /* now make sure its color state is correct */
1053 switch (_session
->record_status ()) {
1054 case Session::Recording
:
1055 rec_enable_button
->set_visual_state (1);
1058 case Session::Disabled
:
1059 case Session::Enabled
:
1060 rec_enable_button
->set_visual_state (2);
1065 if (step_edit_item
) {
1066 step_edit_item
->set_sensitive (false);
1070 rec_enable_button
->set_visual_state (0);
1072 if (step_edit_item
) {
1073 step_edit_item
->set_sensitive (true);
1078 check_rec_enable_sensitivity ();
1082 RouteUI::build_solo_menu (void)
1084 using namespace Menu_Helpers
;
1086 solo_menu
= new Menu
;
1087 solo_menu
->set_name ("ArdourContextMenu");
1088 MenuList
& items
= solo_menu
->items();
1089 CheckMenuItem
* check
;
1091 check
= new CheckMenuItem(_("Solo Isolate"));
1092 check
->set_active (_route
->solo_isolated());
1093 check
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated
), check
));
1094 items
.push_back (CheckMenuElem(*check
));
1095 solo_isolated_check
= dynamic_cast<CheckMenuItem
*>(&items
.back());
1098 check
= new CheckMenuItem(_("Solo Safe"));
1099 check
->set_active (_route
->solo_safe());
1100 check
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe
), check
));
1101 items
.push_back (CheckMenuElem(*check
));
1102 solo_safe_check
= dynamic_cast<CheckMenuItem
*>(&items
.back());
1105 //items.push_back (SeparatorElem());
1106 // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
1111 RouteUI::build_mute_menu(void)
1113 using namespace Menu_Helpers
;
1115 mute_menu
= new Menu
;
1116 mute_menu
->set_name ("ArdourContextMenu");
1118 MenuList
& items
= mute_menu
->items();
1120 pre_fader_mute_check
= manage (new CheckMenuItem(_("Pre Fader")));
1121 init_mute_menu(MuteMaster::PreFader
, pre_fader_mute_check
);
1122 pre_fader_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::PreFader
, pre_fader_mute_check
));
1123 items
.push_back (CheckMenuElem(*pre_fader_mute_check
));
1124 pre_fader_mute_check
->show_all();
1126 post_fader_mute_check
= manage (new CheckMenuItem(_("Post Fader")));
1127 init_mute_menu(MuteMaster::PostFader
, post_fader_mute_check
);
1128 post_fader_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::PostFader
, post_fader_mute_check
));
1129 items
.push_back (CheckMenuElem(*post_fader_mute_check
));
1130 post_fader_mute_check
->show_all();
1132 listen_mute_check
= manage (new CheckMenuItem(_("Control Outs")));
1133 init_mute_menu(MuteMaster::Listen
, listen_mute_check
);
1134 listen_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::Listen
, listen_mute_check
));
1135 items
.push_back (CheckMenuElem(*listen_mute_check
));
1136 listen_mute_check
->show_all();
1138 main_mute_check
= manage (new CheckMenuItem(_("Main Outs")));
1139 init_mute_menu(MuteMaster::Main
, main_mute_check
);
1140 main_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::Main
, main_mute_check
));
1141 items
.push_back (CheckMenuElem(*main_mute_check
));
1142 main_mute_check
->show_all();
1144 //items.push_back (SeparatorElem());
1145 // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
1147 _route
->mute_points_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::muting_change
, this), gui_context());
1151 RouteUI::init_mute_menu(MuteMaster::MutePoint mp
, CheckMenuItem
* check
)
1153 check
->set_active (_route
->mute_points() & mp
);
1157 RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp
, Gtk::CheckMenuItem
* check
)
1159 if (check
->get_active()) {
1160 _route
->set_mute_points (MuteMaster::MutePoint (_route
->mute_points() | mp
));
1162 _route
->set_mute_points (MuteMaster::MutePoint (_route
->mute_points() & ~mp
));
1167 RouteUI::muting_change ()
1169 ENSURE_GUI_THREAD (*this, &RouteUI::muting_change
)
1172 MuteMaster::MutePoint current
= _route
->mute_points ();
1174 yn
= (current
& MuteMaster::PreFader
);
1176 if (pre_fader_mute_check
->get_active() != yn
) {
1177 pre_fader_mute_check
->set_active (yn
);
1180 yn
= (current
& MuteMaster::PostFader
);
1182 if (post_fader_mute_check
->get_active() != yn
) {
1183 post_fader_mute_check
->set_active (yn
);
1186 yn
= (current
& MuteMaster::Listen
);
1188 if (listen_mute_check
->get_active() != yn
) {
1189 listen_mute_check
->set_active (yn
);
1192 yn
= (current
& MuteMaster::Main
);
1194 if (main_mute_check
->get_active() != yn
) {
1195 main_mute_check
->set_active (yn
);
1200 RouteUI::solo_isolate_button_release (GdkEventButton
* ev
)
1202 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
1206 bool view
= (solo_isolated_led
->visual_state() != 0);
1207 bool model
= _route
->solo_isolated();
1209 /* called BEFORE the view has changed */
1211 if (ev
->button
== 1) {
1212 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
1215 /* disable isolate for all routes */
1216 _session
->set_solo_isolated (_session
->get_routes(), false, Session::rt_cleanup
, true);
1220 if (model
== view
) {
1222 /* flip just this route */
1224 boost::shared_ptr
<RouteList
> rl (new RouteList
);
1225 rl
->push_back (_route
);
1226 _session
->set_solo_isolated (rl
, !view
, Session::rt_cleanup
, true);
1235 RouteUI::solo_safe_button_release (GdkEventButton
*)
1237 _route
->set_solo_safe (!(solo_safe_led
->visual_state() > 0), this);
1242 RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem
* check
)
1244 bool view
= check
->get_active();
1245 bool model
= _route
->solo_isolated();
1247 /* called AFTER the view has changed */
1249 if (model
!= view
) {
1250 _route
->set_solo_isolated (view
, this);
1255 RouteUI::toggle_solo_safe (Gtk::CheckMenuItem
* check
)
1257 _route
->set_solo_safe (check
->get_active(), this);
1260 /** Ask the user to choose a colour, and then set all selected tracks
1264 RouteUI::choose_color ()
1267 Gdk::Color
const color
= Gtkmm2ext::UI::instance()->get_color (_("Color Selection"), picked
, &_color
);
1270 ARDOUR_UI::instance()->the_editor().get_selection().tracks
.foreach_route_ui (
1271 boost::bind (&RouteUI::set_color
, _1
, color
)
1277 RouteUI::set_color (const Gdk::Color
& c
)
1284 snprintf (buf
, sizeof (buf
), "%d:%d:%d", c
.get_red(), c
.get_green(), c
.get_blue());
1285 xml_node
->add_property ("color", buf
);
1287 _route
->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */
1292 RouteUI::ensure_xml_node ()
1294 if (xml_node
== 0) {
1295 if ((xml_node
= _route
->extra_xml ("GUI")) == 0) {
1296 xml_node
= new XMLNode ("GUI");
1297 _route
->add_extra_xml (*xml_node
);
1299 /* the Route has one; it may have been loaded */
1300 if (Stateful::loading_state_version
!= 0 && Stateful::loading_state_version
< 3000) {
1301 /* the GUI extra XML is in 2.X format; we must convert it to the new
1302 format to avoid problems later
1305 XMLNode
* new_xml_node
= new XMLNode (X_("GUI"));
1306 XMLPropertyList old_gui_props
= xml_node
->properties ();
1307 for (XMLPropertyIterator i
= old_gui_props
.begin(); i
!= old_gui_props
.end(); ++i
) {
1308 new_xml_node
->add_property ((*i
)->name().c_str (), (*i
)->value().c_str ());
1311 XMLNodeList old_children
= xml_node
->children ();
1312 for (XMLNodeConstIterator i
= old_children
.begin(); i
!= old_children
.end(); ++i
) {
1313 XMLNode
* new_child
= new XMLNode (AutomationTimeAxisView::state_node_name
);
1314 new_child
->add_property (X_("automation-id"), (*i
)->name());
1316 XMLPropertyList old_props
= (*i
)->properties ();
1317 for (XMLPropertyIterator j
= old_props
.begin(); j
!= old_props
.end(); ++j
) {
1318 new_child
->add_property ((*j
)->name().c_str (), (*j
)->value().c_str ());
1321 new_xml_node
->add_child_nocopy (*new_child
);
1324 _route
->add_extra_xml (*new_xml_node
);
1325 xml_node
= new_xml_node
;
1332 RouteUI::get_automation_child_xml_node (Evoral::Parameter param
)
1336 XMLNodeList kids
= xml_node
->children();
1337 XMLNodeConstIterator iter
;
1339 const string sym
= ARDOUR::EventTypeMap::instance().to_symbol(param
);
1341 for (iter
= kids
.begin(); iter
!= kids
.end(); ++iter
) {
1343 if ((*iter
)->name() == AutomationTimeAxisView::state_node_name
) {
1344 XMLProperty
* type
= (*iter
)->property("automation-id");
1345 if (type
&& type
->value() == sym
) {
1351 // Didn't find it, make a new one
1352 XMLNode
* child
= new XMLNode (AutomationTimeAxisView::state_node_name
);
1353 child
->add_property("automation-id", sym
);
1354 xml_node
->add_child_nocopy (*child
);
1360 RouteUI::set_color_from_route ()
1364 RouteUI::ensure_xml_node ();
1366 if ((prop
= xml_node
->property ("color")) != 0) {
1368 sscanf (prop
->value().c_str(), "%d:%d:%d", &r
, &g
, &b
);
1370 _color
.set_green(g
);
1378 RouteUI::remove_this_route ()
1380 if ((route()->is_master() || route()->is_monitor()) &&
1381 !Config
->get_allow_special_bus_removal()) {
1382 MessageDialog
msg (_("That would be bad news ...."),
1386 msg
.set_secondary_text (string_compose (_(
1387 "Removing the master or monitor bus is such a bad idea\n\
1388 that %1 is not going to allow it.\n\
1390 If you really want to do this sort of thing\n\
1391 edit your ardour.rc file to set the\n\
1392 \"allow-special-bus-removal\" option to be \"yes\""), PROGRAM_NAME
));
1399 vector
<string
> choices
;
1403 prompt
= string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n\n(This action cannot be undone, and the session file will be overwritten)"), _route
->name());
1405 prompt
= string_compose (_("Do you really want to remove bus \"%1\" ?\n\nYou may also lose the playlist used by this track.\n\n(This action cannot be undone, and the session file will be overwritten)"), _route
->name());
1408 choices
.push_back (_("No, do nothing."));
1409 choices
.push_back (_("Yes, remove it."));
1413 title
= _("Remove track");
1415 title
= _("Remove bus");
1418 Choice
prompter (title
, prompt
, choices
);
1420 if (prompter
.run () == 1) {
1421 Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route
), this));
1426 RouteUI::idle_remove_this_route (RouteUI
*rui
)
1428 rui
->_session
->remove_route (rui
->route());
1433 RouteUI::route_rename ()
1435 ArdourPrompter
name_prompter (true);
1438 name_prompter
.set_title (_("Rename Track"));
1440 name_prompter
.set_title (_("Rename Bus"));
1442 name_prompter
.set_prompt (_("New name:"));
1443 name_prompter
.set_initial_text (_route
->name());
1444 name_prompter
.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT
);
1445 name_prompter
.set_response_sensitive (Gtk::RESPONSE_ACCEPT
, false);
1446 name_prompter
.show_all ();
1448 switch (name_prompter
.run ()) {
1449 case Gtk::RESPONSE_ACCEPT
:
1450 name_prompter
.get_result (result
);
1451 if (result
.length()) {
1452 _route
->set_name (result
);
1462 RouteUI::property_changed (const PropertyChange
& what_changed
)
1464 if (what_changed
.contains (ARDOUR::Properties::name
)) {
1465 name_label
.set_text (_route
->name());
1470 RouteUI::toggle_route_active ()
1474 if (route_active_menu_item
) {
1475 if (route_active_menu_item
->get_active() != (yn
= _route
->active())) {
1476 _route
->set_active (!yn
, this);
1482 RouteUI::route_active_changed ()
1484 if (route_active_menu_item
) {
1485 Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&CheckMenuItem::set_active
, route_active_menu_item
, _route
->active()));
1491 RouteUI::toggle_denormal_protection ()
1493 if (denormal_menu_item
) {
1497 ENSURE_GUI_THREAD (*this, &RouteUI::toggle_denormal_protection
)
1499 if ((x
= denormal_menu_item
->get_active()) != _route
->denormal_protection()) {
1500 _route
->set_denormal_protection (x
);
1506 RouteUI::denormal_protection_changed ()
1508 if (denormal_menu_item
) {
1509 denormal_menu_item
->set_active (_route
->denormal_protection());
1514 RouteUI::disconnect_input ()
1516 _route
->input()->disconnect (this);
1520 RouteUI::disconnect_output ()
1522 _route
->output()->disconnect (this);
1526 RouteUI::is_track () const
1528 return boost::dynamic_pointer_cast
<Track
>(_route
) != 0;
1531 boost::shared_ptr
<Track
>
1532 RouteUI::track() const
1534 return boost::dynamic_pointer_cast
<Track
>(_route
);
1538 RouteUI::is_audio_track () const
1540 return boost::dynamic_pointer_cast
<AudioTrack
>(_route
) != 0;
1543 boost::shared_ptr
<AudioTrack
>
1544 RouteUI::audio_track() const
1546 return boost::dynamic_pointer_cast
<AudioTrack
>(_route
);
1550 RouteUI::is_midi_track () const
1552 return boost::dynamic_pointer_cast
<MidiTrack
>(_route
) != 0;
1555 boost::shared_ptr
<MidiTrack
>
1556 RouteUI::midi_track() const
1558 return boost::dynamic_pointer_cast
<MidiTrack
>(_route
);
1562 RouteUI::has_audio_outputs () const
1564 return (_route
->n_outputs().n_audio() > 0);
1568 RouteUI::name() const
1570 return _route
->name();
1574 RouteUI::map_frozen ()
1576 ENSURE_GUI_THREAD (*this, &RouteUI::map_frozen
)
1578 AudioTrack
* at
= dynamic_cast<AudioTrack
*>(_route
.get());
1581 switch (at
->freeze_state()) {
1582 case AudioTrack::Frozen
:
1583 rec_enable_button
->set_sensitive (false);
1586 rec_enable_button
->set_sensitive (true);
1593 RouteUI::adjust_latency ()
1595 LatencyDialog
dialog (_route
->name() + _(" latency"), *(_route
->output()), _session
->frame_rate(), _session
->engine().frames_per_cycle());
1599 RouteUI::save_as_template ()
1602 std::string safe_name
;
1605 path
= ARDOUR::user_route_template_directory ();
1607 if (g_mkdir_with_parents (path
.to_string().c_str(), 0755)) {
1608 error
<< string_compose (_("Cannot create route template directory %1"), path
.to_string()) << endmsg
;
1612 Prompter
p (true); // modal
1614 p
.set_title (_("Save As Template"));
1615 p
.set_prompt (_("Template name:"));
1616 p
.add_button (Gtk::Stock::SAVE
, Gtk::RESPONSE_ACCEPT
);
1618 case RESPONSE_ACCEPT
:
1625 p
.get_result (name
, true);
1627 safe_name
= legalize_for_path (name
);
1628 safe_name
+= template_suffix
;
1632 _route
->save_as_template (path
.to_string(), name
);
1636 RouteUI::check_rec_enable_sensitivity ()
1638 if (_session
->transport_rolling() && rec_enable_button
->get_active() && Config
->get_disable_disarm_during_roll()) {
1639 rec_enable_button
->set_sensitive (false);
1641 rec_enable_button
->set_sensitive (true);
1646 RouteUI::parameter_changed (string
const & p
)
1648 if (p
== "disable-disarm-during-roll") {
1649 check_rec_enable_sensitivity ();
1650 } else if (p
== "use-monitor-bus" || p
== "solo-control-is-listen-control" || p
== "listen-position") {
1651 set_button_names ();
1656 RouteUI::step_gain_up ()
1658 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) + 0.1), this);
1662 RouteUI::page_gain_up ()
1664 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) + 0.5), this);
1668 RouteUI::step_gain_down ()
1670 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) - 0.1), this);
1674 RouteUI::page_gain_down ()
1676 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) - 0.5), this);
1680 RouteUI::open_remote_control_id_dialog ()
1682 ArdourDialog
dialog (_("Remote Control ID"));
1684 uint32_t const limit
= _session
->ntracks() + _session
->nbusses () + 4;
1686 HBox
* hbox
= manage (new HBox
);
1687 hbox
->set_spacing (6);
1688 hbox
->pack_start (*manage (new Label (_("Remote control ID:"))));
1689 SpinButton
* spin
= manage (new SpinButton
);
1690 spin
->set_digits (0);
1691 spin
->set_increments (1, 10);
1692 spin
->set_range (0, limit
);
1693 spin
->set_value (_route
->remote_control_id());
1694 hbox
->pack_start (*spin
);
1695 dialog
.get_vbox()->pack_start (*hbox
);
1697 dialog
.add_button (Stock::CANCEL
, RESPONSE_CANCEL
);
1698 dialog
.add_button (Stock::APPLY
, RESPONSE_ACCEPT
);
1701 int const r
= dialog
.run ();
1703 if (r
== RESPONSE_ACCEPT
) {
1704 _route
->set_remote_control_id (spin
->get_value_as_int ());
1709 RouteUI::setup_invert_buttons ()
1711 /* remove old invert buttons */
1712 for (list
<BindableToggleButton
*>::iterator i
= _invert_buttons
.begin(); i
!= _invert_buttons
.end(); ++i
) {
1713 _invert_button_box
.remove (**i
);
1716 _invert_buttons
.clear ();
1718 if (!_route
|| !_route
->input()) {
1722 uint32_t const N
= _route
->input()->n_ports().n_audio ();
1724 uint32_t const to_add
= (N
<= _max_invert_buttons
) ? N
: 1;
1726 for (uint32_t i
= 0; i
< to_add
; ++i
) {
1727 BindableToggleButton
* b
= manage (new BindableToggleButton
);
1728 b
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::invert_toggled
), i
, b
));
1729 b
->signal_button_press_event().connect (sigc::mem_fun (*this, &RouteUI::invert_press
));
1731 b
->set_name (X_("MixerInvertButton"));
1733 b
->add (*manage (new Label (X_("Ø"))));
1735 b
->add (*manage (new Label (string_compose (X_("Ø%1"), i
+ 1))));
1739 UI::instance()->set_tip (*b
, string_compose (_("Left-click to invert (phase reverse) channel %1 of this track. Right-click to show menu."), i
+ 1));
1741 UI::instance()->set_tip (*b
, string_compose (_("Left-click to invert (phase reverse) all channels of this track. Right-click to show menu."), i
+ 1));
1744 _invert_buttons
.push_back (b
);
1745 _invert_button_box
.pack_start (*b
);
1748 _invert_button_box
.show_all ();
1752 RouteUI::set_invert_button_state ()
1754 ++_i_am_the_modifier
;
1756 uint32_t const N
= _route
->input()->n_ports().n_audio();
1757 if (N
> _max_invert_buttons
) {
1758 _invert_buttons
.front()->set_active (_route
->phase_invert().any());
1759 --_i_am_the_modifier
;
1764 for (list
<BindableToggleButton
*>::iterator i
= _invert_buttons
.begin(); i
!= _invert_buttons
.end(); ++i
, ++j
) {
1765 (*i
)->set_active (_route
->phase_invert (j
));
1768 --_i_am_the_modifier
;
1772 RouteUI::invert_toggled (uint32_t i
, BindableToggleButton
* b
)
1774 if (_i_am_the_modifier
) {
1778 uint32_t const N
= _route
->input()->n_ports().n_audio();
1779 if (N
<= _max_invert_buttons
) {
1780 _route
->set_phase_invert (i
, b
->get_active ());
1782 boost::dynamic_bitset
<> p (N
);
1783 if (b
->get_active ()) {
1786 _route
->set_phase_invert (p
);
1791 RouteUI::invert_press (GdkEventButton
* ev
)
1793 using namespace Menu_Helpers
;
1795 if (ev
->button
!= 3) {
1799 delete _invert_menu
;
1800 _invert_menu
= new Menu
;
1801 _invert_menu
->set_name ("ArdourContextMenu");
1802 MenuList
& items
= _invert_menu
->items ();
1804 uint32_t const N
= _route
->input()->n_ports().n_audio();
1805 for (uint32_t i
= 0; i
< N
; ++i
) {
1806 items
.push_back (CheckMenuElem (string_compose (X_("Ø%1"), i
+ 1), sigc::bind (sigc::mem_fun (*this, &RouteUI::invert_menu_toggled
), i
)));
1807 CheckMenuItem
* e
= dynamic_cast<CheckMenuItem
*> (&items
.back ());
1808 ++_i_am_the_modifier
;
1809 e
->set_active (_route
->phase_invert (i
));
1810 --_i_am_the_modifier
;
1813 _invert_menu
->popup (0, ev
->time
);
1819 RouteUI::invert_menu_toggled (uint32_t c
)
1821 if (_i_am_the_modifier
) {
1825 _route
->set_phase_invert (c
, !_route
->phase_invert (c
));
1829 RouteUI::set_invert_sensitive (bool yn
)
1831 for (list
<BindableToggleButton
*>::iterator b
= _invert_buttons
.begin(); b
!= _invert_buttons
.end(); ++b
) {
1832 (*b
)->set_sensitive (yn
);