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/stop_signal.h>
22 #include <gtkmm2ext/choice.h>
23 #include <gtkmm2ext/doi.h>
24 #include <gtkmm2ext/bindable_button.h>
25 #include <gtkmm2ext/barcontroller.h>
26 #include <gtkmm2ext/gtk_ui.h>
28 #include "ardour/route_group.h"
29 #include "ardour/dB.h"
30 #include "pbd/memento_command.h"
31 #include "pbd/stacktrace.h"
32 #include "pbd/controllable.h"
33 #include "pbd/enumwriter.h"
35 #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/audio_diskstream.h"
54 #include "ardour/midi_track.h"
55 #include "ardour/midi_diskstream.h"
56 #include "ardour/template_utils.h"
57 #include "ardour/filename_extensions.h"
58 #include "ardour/directory_names.h"
59 #include "ardour/profile.h"
63 using namespace Gtkmm2ext
;
64 using namespace ARDOUR
;
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 ();
98 pre_fader_mute_check
= 0;
99 post_fader_mute_check
= 0;
100 listen_mute_check
= 0;
102 ignore_toggle
= false;
105 route_active_menu_item
= 0;
106 polarity_menu_item
= 0;
107 denormal_menu_item
= 0;
108 multiple_mute_change
= false;
109 multiple_solo_change
= false;
111 mute_button
= manage (new BindableToggleButton ());
112 mute_button
->set_self_managed (true);
113 mute_button
->set_name ("MuteButton");
114 mute_button
->add (mute_button_label
);
115 mute_button_label
.show ();
116 UI::instance()->set_tip (mute_button
, _("Mute this track"), "");
118 solo_button
= manage (new BindableToggleButton ());
119 solo_button
->set_self_managed (true);
120 solo_button
->set_name ("SoloButton");
121 solo_button
->add (solo_button_label
);
122 solo_button_label
.show ();
123 UI::instance()->set_tip (solo_button
, _("Mute other (non-soloed) tracks"), "");
124 solo_button
->set_no_show_all (true);
126 rec_enable_button
= manage (new BindableToggleButton ());
127 rec_enable_button
->set_name ("RecordEnableButton");
128 rec_enable_button
->set_self_managed (true);
129 rec_enable_button
->add (rec_enable_button_label
);
130 rec_enable_button_label
.show ();
131 UI::instance()->set_tip (rec_enable_button
, _("Enable recording on this track"), "");
133 show_sends_button
= manage (new BindableToggleButton (""));
134 show_sends_button
->set_name ("SendAlert");
135 show_sends_button
->set_self_managed (true);
136 UI::instance()->set_tip (show_sends_button
, _("make mixer strips show sends to this bus"), "");
138 _session
->SoloChanged
.connect (_session_connections
, boost::bind (&RouteUI::solo_changed_so_update_mute
, this), gui_context());
139 _session
->TransportStateChange
.connect (_session_connections
, boost::bind (&RouteUI::check_rec_enable_sensitivity
, this), gui_context());
140 _session
->RecordStateChanged
.connect (_session_connections
, boost::bind (&RouteUI::session_rec_enable_changed
, this), gui_context());
142 Config
->ParameterChanged
.connect (*this, ui_bind (&RouteUI::parameter_changed
, this, _1
), gui_context());
144 rec_enable_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press
), false);
145 rec_enable_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release
), false);
147 show_sends_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_press
), false);
148 show_sends_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release
));
150 solo_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press
), false);
151 solo_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release
), false);
152 mute_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press
), false);
153 mute_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release
), false);
159 route_connections
.drop_connections ();
168 /* do not delete the node - its owned by the route */
172 route_active_menu_item
= 0;
173 polarity_menu_item
= 0;
174 denormal_menu_item
= 0;
178 RouteUI::self_delete ()
180 /* This may be called from a non-GUI thread. Keep it safe */
182 delete_when_idle (this);
186 RouteUI::set_route (boost::shared_ptr
<Route
> rp
)
192 if (set_color_from_route()) {
193 set_color (unique_random_color());
197 rp
->DropReferences
.connect (route_connections
, boost::bind (&RouteUI::self_delete
, this), gui_context());
200 mute_button
->set_controllable (_route
->mute_control());
201 solo_button
->set_controllable (_route
->solo_control());
203 _route
->active_changed
.connect (route_connections
, boost::bind (&RouteUI::route_active_changed
, this), gui_context());
204 _route
->mute_changed
.connect (route_connections
, ui_bind (&RouteUI::mute_changed
, this, _1
), gui_context());
205 _route
->solo_changed
.connect (route_connections
, ui_bind (&RouteUI::solo_changed
, this, _1
), gui_context());
206 _route
->listen_changed
.connect (route_connections
, ui_bind (&RouteUI::listen_changed
, this, _1
), gui_context());
207 _route
->solo_isolated_changed
.connect (route_connections
, ui_bind (&RouteUI::solo_changed
, this, _1
), gui_context());
208 _route
->PropertyChanged
.connect (route_connections
, ui_bind (&RouteUI::property_changed
, this, _1
), gui_context());
210 if (_session
->writable() && is_track()) {
211 boost::shared_ptr
<Track
> t
= boost::dynamic_pointer_cast
<Track
>(_route
);
213 t
->diskstream()->RecordEnableChanged
.connect (route_connections
, boost::bind (&RouteUI::route_rec_enable_changed
, this), gui_context());
215 rec_enable_button
->show();
216 rec_enable_button
->set_controllable (t
->rec_enable_control());
218 update_rec_display ();
221 mute_button
->unset_flags (Gtk::CAN_FOCUS
);
222 solo_button
->unset_flags (Gtk::CAN_FOCUS
);
226 if (_route
->is_control()) {
227 solo_button
->hide ();
232 /* map the current state */
241 RouteUI::mute_press (GdkEventButton
* ev
)
243 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
247 multiple_mute_change
= false;
249 if (!ignore_toggle
) {
251 if (Keyboard::is_context_menu_event (ev
)) {
257 mute_menu
->popup(0,ev
->time
);
261 if (Keyboard::is_button2_event (ev
)) {
262 // Primary-button2 click is the midi binding click
263 // button2-click is "momentary"
265 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
))) {
269 _mute_release
= new SoloMuteRelease (_route
->muted ());
272 if (ev
->button
== 1 || Keyboard::is_button2_event (ev
)) {
274 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
277 _mute_release
->routes
= _session
->get_routes ();
280 _session
->set_mute (_session
->get_routes(), !_route
->muted());
282 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
284 /* Primary-button1 applies change to the mix group even if it is not active
285 NOTE: Primary-button2 is MIDI learn.
288 if (ev
->button
== 1 && _route
->route_group()) {
290 _mute_release
->routes
= _session
->get_routes ();
293 _session
->set_mute (_session
->get_routes(), !_route
->muted(), Session::rt_cleanup
, true);
298 /* plain click applies change to this route */
300 boost::shared_ptr
<RouteList
> rl (new RouteList
);
301 rl
->push_back (_route
);
304 _mute_release
->routes
= rl
;
307 _session
->set_mute (rl
, !_route
->muted());
319 RouteUI::mute_release (GdkEventButton
*)
321 if (!ignore_toggle
) {
323 _session
->set_mute (_mute_release
->routes
, _mute_release
->active
, Session::rt_cleanup
, true);
324 delete _mute_release
;
333 RouteUI::solo_press(GdkEventButton
* ev
)
335 /* ignore double/triple clicks */
337 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
341 multiple_solo_change
= false;
343 if (!ignore_toggle
) {
345 if (Keyboard::is_context_menu_event (ev
)) {
347 if (solo_menu
== 0) {
351 solo_menu
->popup (1, ev
->time
);
355 if (Keyboard::is_button2_event (ev
)) {
357 // Primary-button2 click is the midi binding click
358 // button2-click is "momentary"
360 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
))) {
364 _solo_release
= new SoloMuteRelease (_route
->soloed());
367 if (ev
->button
== 1 || Keyboard::is_button2_event (ev
)) {
369 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
371 /* Primary-Tertiary-click applies change to all routes */
374 _solo_release
->routes
= _session
->get_routes ();
377 if (Config
->get_solo_control_is_listen_control()) {
378 _session
->set_listen (_session
->get_routes(), !_route
->listening(), Session::rt_cleanup
, true);
380 _session
->set_solo (_session
->get_routes(), !_route
->soloed(), Session::rt_cleanup
, true);
383 } else if (Keyboard::modifier_state_contains (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::SecondaryModifier
))) {
385 // Primary-Secondary-click: exclusively solo this track
388 _solo_release
->exclusive
= true;
390 boost::shared_ptr
<RouteList
> routes
= _session
->get_routes();
392 for (RouteList::iterator i
= routes
->begin(); i
!= routes
->end(); ++i
) {
393 if ((*i
)->soloed ()) {
394 _solo_release
->routes_on
->push_back (*i
);
396 _solo_release
->routes_off
->push_back (*i
);
401 if (Config
->get_solo_control_is_listen_control()) {
402 /* ??? we need a just_one_listen() method */
404 _session
->set_just_one_solo (_route
, true);
407 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::TertiaryModifier
)) {
409 // shift-click: toggle solo isolated status
411 _route
->set_solo_isolated (!_route
->solo_isolated(), this);
412 delete _solo_release
;
415 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
417 /* Primary-button1: solo mix group.
418 NOTE: Primary-button2 is MIDI learn.
421 if (ev
->button
== 1 && _route
->route_group()) {
424 _solo_release
->routes
= _route
->route_group()->route_list();
427 if (Config
->get_solo_control_is_listen_control()) {
428 _session
->set_listen (_route
->route_group()->route_list(), !_route
->listening(), Session::rt_cleanup
, true);
430 _session
->set_solo (_route
->route_group()->route_list(), !_route
->soloed(), Session::rt_cleanup
, true);
436 /* click: solo this route */
438 boost::shared_ptr
<RouteList
> rl (new RouteList
);
439 rl
->push_back (route());
442 _solo_release
->routes
= rl
;
445 if (Config
->get_solo_control_is_listen_control()) {
446 _session
->set_listen (rl
, !_route
->listening());
448 _session
->set_solo (rl
, !_route
->soloed());
459 RouteUI::solo_release (GdkEventButton
*)
461 if (!ignore_toggle
) {
465 if (_solo_release
->exclusive
) {
468 _session
->set_solo (_solo_release
->routes
, _solo_release
->active
, Session::rt_cleanup
, true);
471 delete _solo_release
;
480 RouteUI::rec_enable_press(GdkEventButton
* ev
)
482 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
486 if (!_session
->engine().connected()) {
487 MessageDialog
msg (_("Not connected to JACK - cannot engage record"));
492 if (!ignore_toggle
&& is_track() && rec_enable_button
) {
494 if (Keyboard::is_button2_event (ev
) && Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
496 // do nothing on midi sigc::bind event
499 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
501 _session
->set_record_enable (_session
->get_routes(), !rec_enable_button
->get_active());
503 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
505 /* Primary-button1 applies change to the route group (even if it is not active)
506 NOTE: Primary-button2 is MIDI learn.
508 if (ev
->button
== 1 && _route
->route_group()) {
509 _session
->set_record_enable (_route
->route_group()->route_list(), !rec_enable_button
->get_active(), Session::rt_cleanup
, true);
512 } else if (Keyboard::is_context_menu_event (ev
)) {
514 /* do this on release */
518 boost::shared_ptr
<RouteList
> rl (new RouteList
);
519 rl
->push_back (route());
520 _session
->set_record_enable (rl
, !rec_enable_button
->get_active());
528 RouteUI::rec_enable_release (GdkEventButton
*)
534 RouteUI::build_sends_menu ()
536 using namespace Menu_Helpers
;
538 sends_menu
= new Menu
;
539 sends_menu
->set_name ("ArdourContextMenu");
540 MenuList
& items
= sends_menu
->items();
542 items
.push_back (MenuElem(_("Assign all tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PreFader
)));
543 items
.push_back (MenuElem(_("Assign all tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PostFader
)));
544 items
.push_back (MenuElem(_("Assign selected tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PreFader
)));
545 items
.push_back (MenuElem(_("Assign selected tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PostFader
)));
546 items
.push_back (MenuElem(_("Copy track gains to sends"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_from_track
)));
547 items
.push_back (MenuElem(_("Set sends gain to -inf"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_zero
)));
548 items
.push_back (MenuElem(_("Set sends gain to 0dB"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_unity
)));
553 RouteUI::create_sends (Placement p
)
555 _session
->globally_add_internal_sends (_route
, p
);
559 RouteUI::create_selected_sends (Placement p
)
561 boost::shared_ptr
<RouteList
> rlist (new RouteList
);
562 TrackSelection
& selected_tracks (ARDOUR_UI::instance()->the_editor().get_selection().tracks
);
564 for (TrackSelection::iterator i
= selected_tracks
.begin(); i
!= selected_tracks
.end(); ++i
) {
565 RouteTimeAxisView
* rtv
;
567 if ((rtv
= dynamic_cast<RouteTimeAxisView
*>(*i
)) != 0) {
568 if ((rui
= dynamic_cast<RouteUI
*>(rtv
)) != 0) {
569 if (boost::dynamic_pointer_cast
<AudioTrack
>(rui
->route())) {
570 rlist
->push_back (rui
->route());
576 _session
->add_internal_sends (_route
, p
, rlist
);
580 RouteUI::set_sends_gain_from_track ()
582 _session
->globally_set_send_gains_from_track (_route
);
586 RouteUI::set_sends_gain_to_zero ()
588 _session
->globally_set_send_gains_to_zero (_route
);
592 RouteUI::set_sends_gain_to_unity ()
594 _session
->globally_set_send_gains_to_unity (_route
);
598 RouteUI::show_sends_press(GdkEventButton
* ev
)
600 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
604 if (!ignore_toggle
&& !is_track() && show_sends_button
) {
606 if (Keyboard::is_button2_event (ev
) && Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
608 // do nothing on midi sigc::bind event
611 } else if (Keyboard::is_context_menu_event (ev
)) {
613 if (sends_menu
== 0) {
617 sends_menu
->popup (0, ev
->time
);
621 /* change button state */
623 show_sends_button
->set_active (!show_sends_button
->get_active());
627 if (show_sends_button
->get_active()) {
628 /* show sends to this bus */
629 MixerStrip::SwitchIO (_route
);
630 send_blink_connection
= ARDOUR_UI::instance()->Blink
.connect (sigc::mem_fun(*this, &RouteUI::send_blink
));
632 /* everybody back to normal */
633 send_blink_connection
.disconnect ();
634 MixerStrip::SwitchIO (boost::shared_ptr
<Route
>());
644 RouteUI::show_sends_release (GdkEventButton
*)
650 RouteUI::send_blink (bool onoff
)
652 if (!show_sends_button
) {
657 show_sends_button
->set_state (STATE_ACTIVE
);
659 show_sends_button
->set_state (STATE_NORMAL
);
664 RouteUI::solo_changed(void* /*src*/)
666 Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_solo_display
, this));
671 RouteUI::listen_changed(void* /*src*/)
673 Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_solo_display
, this));
677 RouteUI::solo_visual_state (boost::shared_ptr
<Route
> r
)
679 if (r
->is_master() || r
->is_control()) {
683 if (Config
->get_solo_control_is_listen_control()) {
685 if (r
->listening()) {
701 RouteUI::solo_visual_state_with_isolate (boost::shared_ptr
<Route
> r
)
703 if (r
->is_master() || r
->is_control()) {
707 if (Config
->get_solo_control_is_listen_control()) {
709 if (r
->listening()) {
717 if (r
->solo_isolated()) {
719 } else if (r
->soloed()) {
727 RouteUI::solo_isolate_visual_state (boost::shared_ptr
<Route
> r
)
729 if (r
->is_master() || r
->is_control()) {
733 if (r
->solo_isolated()) {
741 RouteUI::update_solo_display ()
745 if (Config
->get_solo_control_is_listen_control()) {
747 if (solo_button
->get_active() != (x
= _route
->listening())) {
748 ignore_toggle
= true;
749 solo_button
->set_active(x
);
750 ignore_toggle
= false;
755 if (solo_button
->get_active() != (x
= _route
->soloed())) {
756 ignore_toggle
= true;
757 solo_button
->set_active (x
);
758 ignore_toggle
= false;
763 solo_button
->set_visual_state (solo_visual_state_with_isolate (_route
));
767 RouteUI::solo_changed_so_update_mute ()
769 update_mute_display ();
773 RouteUI::mute_changed(void* /*src*/)
775 update_mute_display ();
779 RouteUI::mute_visual_state (Session
* s
, boost::shared_ptr
<Route
> r
)
781 if (r
->is_master() || r
->is_control()) {
785 if (Config
->get_show_solo_mutes()) {
790 } else if (s
->soloing() && !r
->soloed() && !r
->solo_isolated()) {
791 /* mute-because-not-soloed */
813 RouteUI::update_mute_display ()
819 bool model
= _route
->muted();
820 bool view
= mute_button
->get_active();
822 /* first make sure the button's "depressed" visual
827 ignore_toggle
= true;
828 mute_button
->set_active (model
);
829 ignore_toggle
= false;
832 mute_button
->set_visual_state (mute_visual_state (_session
, _route
));
836 RouteUI::route_rec_enable_changed ()
838 Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_rec_display
, this));
842 RouteUI::session_rec_enable_changed ()
844 update_rec_display ();
848 RouteUI::update_rec_display ()
850 if (!rec_enable_button
|| !_route
) {
854 bool model
= _route
->record_enabled();
855 bool view
= rec_enable_button
->get_active();
857 /* first make sure the button's "depressed" visual
862 ignore_toggle
= true;
863 rec_enable_button
->set_active (model
);
864 ignore_toggle
= false;
867 /* now make sure its color state is correct */
871 switch (_session
->record_status ()) {
872 case Session::Recording
:
873 rec_enable_button
->set_visual_state (1);
876 case Session::Disabled
:
877 case Session::Enabled
:
878 rec_enable_button
->set_visual_state (2);
884 rec_enable_button
->set_visual_state (0);
887 check_rec_enable_sensitivity ();
891 RouteUI::build_solo_menu (void)
893 using namespace Menu_Helpers
;
895 solo_menu
= new Menu
;
896 solo_menu
->set_name ("ArdourContextMenu");
897 MenuList
& items
= solo_menu
->items();
898 CheckMenuItem
* check
;
900 check
= new CheckMenuItem(_("Solo Isolate"));
901 check
->set_active (_route
->solo_isolated());
902 check
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated
), check
));
903 _route
->solo_isolated_changed
.connect (route_connections
, ui_bind (&RouteUI::solo_isolated_toggle
, this, _1
, check
), gui_context());
904 items
.push_back (CheckMenuElem(*check
));
907 check
= new CheckMenuItem(_("Solo Safe"));
908 check
->set_active (_route
->solo_safe());
909 check
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe
), check
));
910 _route
->solo_safe_changed
.connect (route_connections
, ui_bind (&RouteUI::solo_safe_toggle
, this, _1
, check
), gui_context());
911 items
.push_back (CheckMenuElem(*check
));
914 //items.push_back (SeparatorElem());
915 // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
920 RouteUI::build_mute_menu(void)
922 using namespace Menu_Helpers
;
924 mute_menu
= new Menu
;
925 mute_menu
->set_name ("ArdourContextMenu");
927 MenuList
& items
= mute_menu
->items();
929 pre_fader_mute_check
= manage (new CheckMenuItem(_("Pre Fader")));
930 init_mute_menu(MuteMaster::PreFader
, pre_fader_mute_check
);
931 pre_fader_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::PreFader
, pre_fader_mute_check
));
932 items
.push_back (CheckMenuElem(*pre_fader_mute_check
));
933 pre_fader_mute_check
->show_all();
935 post_fader_mute_check
= manage (new CheckMenuItem(_("Post Fader")));
936 init_mute_menu(MuteMaster::PostFader
, post_fader_mute_check
);
937 post_fader_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::PostFader
, post_fader_mute_check
));
938 items
.push_back (CheckMenuElem(*post_fader_mute_check
));
939 post_fader_mute_check
->show_all();
941 listen_mute_check
= manage (new CheckMenuItem(_("Control Outs")));
942 init_mute_menu(MuteMaster::Listen
, listen_mute_check
);
943 listen_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::Listen
, listen_mute_check
));
944 items
.push_back (CheckMenuElem(*listen_mute_check
));
945 listen_mute_check
->show_all();
947 main_mute_check
= manage (new CheckMenuItem(_("Main Outs")));
948 init_mute_menu(MuteMaster::Main
, main_mute_check
);
949 main_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::Main
, main_mute_check
));
950 items
.push_back (CheckMenuElem(*main_mute_check
));
951 main_mute_check
->show_all();
953 //items.push_back (SeparatorElem());
954 // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
956 _route
->mute_points_changed
.connect (route_connections
, boost::bind (&RouteUI::muting_change
, this), gui_context());
960 RouteUI::init_mute_menu(MuteMaster::MutePoint mp
, CheckMenuItem
* check
)
962 check
->set_active (_route
->mute_points() & mp
);
966 RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp
, Gtk::CheckMenuItem
* check
)
968 if (check
->get_active()) {
969 _route
->set_mute_points (MuteMaster::MutePoint (_route
->mute_points() | mp
));
971 _route
->set_mute_points (MuteMaster::MutePoint (_route
->mute_points() & ~mp
));
976 RouteUI::muting_change ()
978 ENSURE_GUI_THREAD (*this, &RouteUI::muting_change
)
981 MuteMaster::MutePoint current
= _route
->mute_points ();
983 yn
= (current
& MuteMaster::PreFader
);
985 if (pre_fader_mute_check
->get_active() != yn
) {
986 pre_fader_mute_check
->set_active (yn
);
989 yn
= (current
& MuteMaster::PostFader
);
991 if (post_fader_mute_check
->get_active() != yn
) {
992 post_fader_mute_check
->set_active (yn
);
995 yn
= (current
& MuteMaster::Listen
);
997 if (listen_mute_check
->get_active() != yn
) {
998 listen_mute_check
->set_active (yn
);
1001 yn
= (current
& MuteMaster::Main
);
1003 if (main_mute_check
->get_active() != yn
) {
1004 main_mute_check
->set_active (yn
);
1009 RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem
* check
)
1011 _route
->set_solo_isolated (check
->get_active(), this);
1015 RouteUI::toggle_solo_safe (Gtk::CheckMenuItem
* check
)
1017 _route
->set_solo_safe (check
->get_active(), this);
1021 RouteUI::choose_color()
1026 color
= Gtkmm2ext::UI::instance()->get_color (_("ardour: color selection"), picked
, &_color
);
1036 RouteUI::set_color (const Gdk::Color
& c
)
1043 snprintf (buf
, sizeof (buf
), "%d:%d:%d", c
.get_red(), c
.get_green(), c
.get_blue());
1044 xml_node
->add_property ("color", buf
);
1046 _route
->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */
1051 RouteUI::ensure_xml_node ()
1053 if (xml_node
== 0) {
1054 if ((xml_node
= _route
->extra_xml ("GUI")) == 0) {
1055 xml_node
= new XMLNode ("GUI");
1056 _route
->add_extra_xml (*xml_node
);
1062 RouteUI::get_automation_child_xml_node (Evoral::Parameter param
)
1066 XMLNodeList kids
= xml_node
->children();
1067 XMLNodeConstIterator iter
;
1069 const string sym
= ARDOUR::EventTypeMap::instance().to_symbol(param
);
1071 for (iter
= kids
.begin(); iter
!= kids
.end(); ++iter
) {
1072 if ((*iter
)->name() == AutomationTimeAxisView::state_node_name
) {
1073 XMLProperty
* type
= (*iter
)->property("automation-id");
1074 if (type
&& type
->value() == sym
)
1079 // Didn't find it, make a new one
1080 XMLNode
* child
= new XMLNode (AutomationTimeAxisView::state_node_name
);
1081 child
->add_property("automation-id", sym
);
1082 xml_node
->add_child_nocopy (*child
);
1088 RouteUI::set_color_from_route ()
1092 RouteUI::ensure_xml_node ();
1094 if ((prop
= xml_node
->property ("color")) != 0) {
1096 sscanf (prop
->value().c_str(), "%d:%d:%d", &r
, &g
, &b
);
1098 _color
.set_green(g
);
1106 RouteUI::remove_this_route ()
1108 vector
<string
> choices
;
1112 prompt
= string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n(this cannot be undone)"), _route
->name());
1114 prompt
= string_compose (_("Do you really want to remove bus \"%1\" ?\n(this cannot be undone)"), _route
->name());
1117 choices
.push_back (_("No, do nothing."));
1118 choices
.push_back (_("Yes, remove it."));
1122 title
= _("Remove track");
1124 title
= _("Remove bus");
1127 Choice
prompter (title
, prompt
, choices
);
1129 if (prompter
.run () == 1) {
1130 Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route
), this));
1135 RouteUI::idle_remove_this_route (RouteUI
*rui
)
1137 rui
->_session
->remove_route (rui
->_route
);
1142 RouteUI::route_rename ()
1144 ArdourPrompter
name_prompter (true);
1146 name_prompter
.set_prompt (_("New Name: "));
1147 name_prompter
.set_initial_text (_route
->name());
1148 name_prompter
.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT
);
1149 name_prompter
.set_response_sensitive (Gtk::RESPONSE_ACCEPT
, false);
1150 name_prompter
.show_all ();
1152 switch (name_prompter
.run ()) {
1154 case Gtk::RESPONSE_ACCEPT
:
1155 name_prompter
.get_result (result
);
1156 if (result
.length()) {
1157 _route
->set_name (result
);
1167 RouteUI::property_changed (const PropertyChange
& what_changed
)
1169 if (what_changed
.contains (ARDOUR::Properties::name
)) {
1170 name_label
.set_text (_route
->name());
1175 RouteUI::toggle_route_active ()
1179 if (route_active_menu_item
) {
1180 if (route_active_menu_item
->get_active() != (yn
= _route
->active())) {
1181 _route
->set_active (!yn
);
1187 RouteUI::route_active_changed ()
1189 if (route_active_menu_item
) {
1190 Gtkmm2ext::UI::instance()->call_slot (boost::bind (&CheckMenuItem::set_active
, route_active_menu_item
, _route
->active()));
1195 RouteUI::toggle_polarity ()
1197 if (polarity_menu_item
) {
1201 ENSURE_GUI_THREAD (*this, &RouteUI::toggle_polarity
)
1203 if ((x
= polarity_menu_item
->get_active()) != _route
->phase_invert()) {
1204 _route
->set_phase_invert (x
);
1206 name_label
.set_text (X_("Ø ") + name_label
.get_text());
1208 name_label
.set_text (_route
->name());
1215 RouteUI::polarity_changed ()
1217 if (_route
->phase_invert()) {
1218 name_label
.set_text (X_("Ø ") + name_label
.get_text());
1220 name_label
.set_text (_route
->name());
1225 RouteUI::toggle_denormal_protection ()
1227 if (denormal_menu_item
) {
1231 ENSURE_GUI_THREAD (*this, &RouteUI::toggle_denormal_protection
)
1233 if ((x
= denormal_menu_item
->get_active()) != _route
->denormal_protection()) {
1234 _route
->set_denormal_protection (x
);
1240 RouteUI::denormal_protection_changed ()
1242 if (denormal_menu_item
) {
1243 denormal_menu_item
->set_active (_route
->denormal_protection());
1248 RouteUI::solo_isolated_toggle(void* /*src*/, Gtk::CheckMenuItem
* check
)
1250 bool yn
= _route
->solo_isolated ();
1252 if (check
->get_active() != yn
) {
1253 check
->set_active (yn
);
1259 RouteUI::solo_safe_toggle(void* /*src*/, Gtk::CheckMenuItem
* check
)
1261 bool yn
= _route
->solo_safe ();
1263 if (check
->get_active() != yn
) {
1264 check
->set_active (yn
);
1269 RouteUI::disconnect_input ()
1271 _route
->input()->disconnect (this);
1275 RouteUI::disconnect_output ()
1277 _route
->output()->disconnect (this);
1281 RouteUI::is_track () const
1283 return boost::dynamic_pointer_cast
<Track
>(_route
) != 0;
1286 boost::shared_ptr
<Track
>
1287 RouteUI::track() const
1289 return boost::dynamic_pointer_cast
<Track
>(_route
);
1293 RouteUI::is_audio_track () const
1295 return boost::dynamic_pointer_cast
<AudioTrack
>(_route
) != 0;
1298 boost::shared_ptr
<AudioTrack
>
1299 RouteUI::audio_track() const
1301 return boost::dynamic_pointer_cast
<AudioTrack
>(_route
);
1305 RouteUI::is_midi_track () const
1307 return boost::dynamic_pointer_cast
<MidiTrack
>(_route
) != 0;
1310 boost::shared_ptr
<MidiTrack
>
1311 RouteUI::midi_track() const
1313 return boost::dynamic_pointer_cast
<MidiTrack
>(_route
);
1316 boost::shared_ptr
<Diskstream
>
1317 RouteUI::get_diskstream () const
1319 boost::shared_ptr
<Track
> t
;
1321 if ((t
= boost::dynamic_pointer_cast
<Track
>(_route
)) != 0) {
1322 return t
->diskstream();
1324 return boost::shared_ptr
<Diskstream
> ((Diskstream
*) 0);
1329 RouteUI::name() const
1331 return _route
->name();
1335 RouteUI::map_frozen ()
1337 ENSURE_GUI_THREAD (*this, &RouteUI::map_frozen
)
1339 AudioTrack
* at
= dynamic_cast<AudioTrack
*>(_route
.get());
1342 switch (at
->freeze_state()) {
1343 case AudioTrack::Frozen
:
1344 rec_enable_button
->set_sensitive (false);
1347 rec_enable_button
->set_sensitive (true);
1354 RouteUI::adjust_latency ()
1356 LatencyDialog
dialog (_route
->name() + _(" latency"), *(_route
->output()), _session
->frame_rate(), _session
->engine().frames_per_cycle());
1360 RouteUI::save_as_template ()
1363 Glib::ustring safe_name
;
1366 path
= ARDOUR::user_route_template_directory ();
1368 if (g_mkdir_with_parents (path
.to_string().c_str(), 0755)) {
1369 error
<< string_compose (_("Cannot create route template directory %1"), path
.to_string()) << endmsg
;
1373 Prompter
p (true); // modal
1375 p
.set_prompt (_("Template name:"));
1377 case RESPONSE_ACCEPT
:
1384 p
.get_result (name
, true);
1386 safe_name
= legalize_for_path (name
);
1387 safe_name
+= template_suffix
;
1391 _route
->save_as_template (path
.to_string(), name
);
1395 RouteUI::check_rec_enable_sensitivity ()
1397 if (_session
->transport_rolling() && rec_enable_button
->get_active() && Config
->get_disable_disarm_during_roll()) {
1398 rec_enable_button
->set_sensitive (false);
1400 rec_enable_button
->set_sensitive (true);
1405 RouteUI::parameter_changed (string
const & p
)
1407 ENSURE_GUI_THREAD (*this, &RouteUI::parameter_changed
, p
)
1409 if (p
== "disable-disarm-during-roll") {
1410 check_rec_enable_sensitivity ();
1411 } else if (p
== "solo-control-is-listen-control") {
1412 set_button_names ();
1413 } else if (p
== "listen-position") {
1414 set_button_names ();
1419 RouteUI::step_gain_up ()
1421 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) + 0.1), this);
1425 RouteUI::page_gain_up ()
1427 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) + 0.5), this);
1431 RouteUI::step_gain_down ()
1433 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) - 0.1), this);
1437 RouteUI::page_gain_down ()
1439 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) - 0.5), this);
1443 RouteUI::open_remote_control_id_dialog ()
1445 ArdourDialog
dialog (_("Remote Control ID"));
1447 uint32_t const limit
= _session
->ntracks() + _session
->nbusses () + 4;
1449 HBox
* hbox
= manage (new HBox
);
1450 hbox
->set_spacing (6);
1451 hbox
->pack_start (*manage (new Label (_("Remote control ID:"))));
1452 SpinButton
* spin
= manage (new SpinButton
);
1453 spin
->set_digits (0);
1454 spin
->set_increments (1, 10);
1455 spin
->set_range (0, limit
);
1456 spin
->set_value (_route
->remote_control_id());
1457 hbox
->pack_start (*spin
);
1458 dialog
.get_vbox()->pack_start (*hbox
);
1460 dialog
.add_button (Stock::CANCEL
, RESPONSE_CANCEL
);
1461 dialog
.add_button (Stock::APPLY
, RESPONSE_ACCEPT
);
1464 int const r
= dialog
.run ();
1466 if (r
== RESPONSE_ACCEPT
) {
1467 _route
->set_remote_control_id (spin
->get_value_as_int ());