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/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 RouteUI::RouteUI (ARDOUR::Session
* sess
)
71 RouteUI::RouteUI (boost::shared_ptr
<ARDOUR::Route
> rt
, ARDOUR::Session
* sess
)
80 _route
.reset (); /* drop reference to route, so that it can be cleaned up */
81 route_connections
.drop_connections ();
96 pre_fader_mute_check
= 0;
97 post_fader_mute_check
= 0;
98 listen_mute_check
= 0;
101 solo_isolated_check
= 0;
102 ignore_toggle
= false;
105 route_active_menu_item
= 0;
106 denormal_menu_item
= 0;
107 multiple_mute_change
= false;
108 multiple_solo_change
= false;
110 invert_button
= manage (new BindableToggleButton ());
111 // mute_button->set_self_managed (true);
112 invert_button
->set_name ("InvertButton");
113 invert_button
->add (invert_button_label
);
114 invert_button_label
.show ();
115 UI::instance()->set_tip (invert_button
, _("Invert (Phase reverse) this track"), "");
117 mute_button
= manage (new BindableToggleButton ());
118 // mute_button->set_self_managed (true);
119 mute_button
->set_name ("MuteButton");
120 mute_button
->add (mute_button_label
);
121 mute_button_label
.show ();
122 UI::instance()->set_tip (mute_button
, _("Mute this track"), "");
124 solo_button
= manage (new BindableToggleButton ());
125 // solo_button->set_self_managed (true);
126 solo_button
->set_name ("SoloButton");
127 solo_button
->add (solo_button_label
);
128 solo_button_label
.show ();
129 UI::instance()->set_tip (solo_button
, _("Mute other (non-soloed) tracks"), "");
130 solo_button
->set_no_show_all (true);
132 rec_enable_button
= manage (new BindableToggleButton ());
133 rec_enable_button
->set_name ("RecordEnableButton");
134 // rec_enable_button->set_self_managed (true);
135 rec_enable_button
->add (rec_enable_button_label
);
136 rec_enable_button_label
.show ();
137 UI::instance()->set_tip (rec_enable_button
, _("Enable recording on this track"), "");
139 show_sends_button
= manage (new BindableToggleButton (""));
140 show_sends_button
->set_name ("SendAlert");
141 // show_sends_button->set_self_managed (true);
142 UI::instance()->set_tip (show_sends_button
, _("make mixer strips show sends to this bus"), "");
144 _session
->SoloChanged
.connect (_session_connections
, invalidator (*this), boost::bind (&RouteUI::solo_changed_so_update_mute
, this), gui_context());
145 _session
->TransportStateChange
.connect (_session_connections
, invalidator (*this), boost::bind (&RouteUI::check_rec_enable_sensitivity
, this), gui_context());
146 _session
->RecordStateChanged
.connect (_session_connections
, invalidator (*this), boost::bind (&RouteUI::session_rec_enable_changed
, this), gui_context());
148 Config
->ParameterChanged
.connect (*this, invalidator (*this), ui_bind (&RouteUI::parameter_changed
, this, _1
), gui_context());
150 rec_enable_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press
), false);
151 rec_enable_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release
), false);
153 show_sends_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_press
), false);
154 show_sends_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release
));
156 solo_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press
), false);
157 solo_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release
), false);
158 mute_button
->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press
), false);
159 mute_button
->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release
), false);
160 invert_button
->signal_toggled().connect (sigc::mem_fun(*this, &RouteUI::invert_toggled
), false);
167 route_connections
.drop_connections ();
176 /* do not delete the node - its owned by the route */
180 route_active_menu_item
= 0;
181 denormal_menu_item
= 0;
185 RouteUI::self_delete ()
187 /* This may be called from a non-GUI thread. Keep it safe */
189 delete_when_idle (this);
193 RouteUI::set_route (boost::shared_ptr
<Route
> rp
)
199 if (set_color_from_route()) {
200 set_color (unique_random_color());
204 rp
->DropReferences
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::self_delete
, this), gui_context());
207 mute_button
->set_controllable (_route
->mute_control());
208 solo_button
->set_controllable (_route
->solo_control());
210 _route
->active_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::route_active_changed
, this), gui_context());
211 _route
->mute_changed
.connect (route_connections
, invalidator (*this), ui_bind (&RouteUI::mute_changed
, this, _1
), gui_context());
213 _route
->solo_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
214 _route
->solo_safe_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
215 _route
->listen_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
216 _route
->solo_isolated_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::update_solo_display
, this), gui_context());
218 _route
->phase_invert_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::polarity_changed
, this), gui_context());
219 _route
->PropertyChanged
.connect (route_connections
, invalidator (*this), ui_bind (&RouteUI::property_changed
, this, _1
), gui_context());
221 if (_session
->writable() && is_track()) {
222 boost::shared_ptr
<Track
> t
= boost::dynamic_pointer_cast
<Track
>(_route
);
224 t
->RecordEnableChanged
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed
, this), gui_context());
226 rec_enable_button
->show();
227 rec_enable_button
->set_controllable (t
->rec_enable_control());
229 update_rec_display ();
232 mute_button
->unset_flags (Gtk::CAN_FOCUS
);
233 solo_button
->unset_flags (Gtk::CAN_FOCUS
);
236 invert_button
->show ();
238 if (_route
->is_monitor()) {
239 solo_button
->hide ();
248 RouteUI::invert_toggled ()
250 _route
->set_phase_invert (invert_button
->get_active());
254 RouteUI::polarity_changed ()
260 if (_route
->phase_invert()) {
261 invert_button
->set_active (true);
263 invert_button
->set_active (false);
268 RouteUI::mute_press (GdkEventButton
* ev
)
270 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
274 multiple_mute_change
= false;
276 if (!ignore_toggle
) {
278 if (Keyboard::is_context_menu_event (ev
)) {
284 mute_menu
->popup(0,ev
->time
);
288 if (Keyboard::is_button2_event (ev
)) {
289 // Primary-button2 click is the midi binding click
290 // button2-click is "momentary"
293 if (mute_button
->on_button_press_event (ev
)) {
297 _mute_release
= new SoloMuteRelease (_route
->muted ());
300 if (ev
->button
== 1 || Keyboard::is_button2_event (ev
)) {
302 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
305 _mute_release
->routes
= _session
->get_routes ();
308 _session
->set_mute (_session
->get_routes(), !_route
->muted());
310 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
312 /* Primary-button1 applies change to the mix group even if it is not active
313 NOTE: Primary-button2 is MIDI learn.
316 if (ev
->button
== 1 && _route
->route_group()) {
318 _mute_release
->routes
= _session
->get_routes ();
321 _session
->set_mute (_session
->get_routes(), !_route
->muted(), Session::rt_cleanup
, true);
326 /* plain click applies change to this route */
328 boost::shared_ptr
<RouteList
> rl (new RouteList
);
329 rl
->push_back (_route
);
332 _mute_release
->routes
= rl
;
335 _session
->set_mute (rl
, !_route
->muted());
347 RouteUI::mute_release (GdkEventButton
*)
349 if (!ignore_toggle
) {
351 _session
->set_mute (_mute_release
->routes
, _mute_release
->active
, Session::rt_cleanup
, true);
352 delete _mute_release
;
361 RouteUI::solo_press(GdkEventButton
* ev
)
363 /* ignore double/triple clicks */
365 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
369 multiple_solo_change
= false;
371 if (!ignore_toggle
) {
373 if (Keyboard::is_context_menu_event (ev
)) {
375 if (solo_menu
== 0) {
379 solo_menu
->popup (1, ev
->time
);
383 if (Keyboard::is_button2_event (ev
)) {
385 // Primary-button2 click is the midi binding click
386 // button2-click is "momentary"
388 if (solo_button
->on_button_press_event (ev
)) {
392 _solo_release
= new SoloMuteRelease (_route
->self_soloed());
395 if (ev
->button
== 1 || Keyboard::is_button2_event (ev
)) {
397 if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
399 /* Primary-Tertiary-click applies change to all routes */
402 _solo_release
->routes
= _session
->get_routes ();
405 if (Config
->get_solo_control_is_listen_control()) {
406 _session
->set_listen (_session
->get_routes(), !_route
->listening(), Session::rt_cleanup
, true);
408 _session
->set_solo (_session
->get_routes(), !_route
->self_soloed(), Session::rt_cleanup
, true);
411 } else if (Keyboard::modifier_state_contains (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::SecondaryModifier
))) {
413 // Primary-Secondary-click: exclusively solo this track
416 _solo_release
->exclusive
= true;
418 boost::shared_ptr
<RouteList
> routes
= _session
->get_routes();
420 for (RouteList::iterator i
= routes
->begin(); i
!= routes
->end(); ++i
) {
421 if ((*i
)->soloed ()) {
422 _solo_release
->routes_on
->push_back (*i
);
424 _solo_release
->routes_off
->push_back (*i
);
429 if (Config
->get_solo_control_is_listen_control()) {
430 /* ??? we need a just_one_listen() method */
432 _session
->set_just_one_solo (_route
, true);
435 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::TertiaryModifier
)) {
437 // shift-click: toggle solo isolated status
439 _route
->set_solo_isolated (!_route
->solo_isolated(), this);
440 delete _solo_release
;
443 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
445 /* Primary-button1: solo mix group.
446 NOTE: Primary-button2 is MIDI learn.
449 if (ev
->button
== 1 && _route
->route_group()) {
452 _solo_release
->routes
= _route
->route_group()->route_list();
455 if (Config
->get_solo_control_is_listen_control()) {
456 _session
->set_listen (_route
->route_group()->route_list(), !_route
->listening(), Session::rt_cleanup
, true);
458 _session
->set_solo (_route
->route_group()->route_list(), !_route
->self_soloed(), Session::rt_cleanup
, true);
464 /* click: solo this route */
466 boost::shared_ptr
<RouteList
> rl (new RouteList
);
467 rl
->push_back (route());
470 _solo_release
->routes
= rl
;
473 if (Config
->get_solo_control_is_listen_control()) {
474 _session
->set_listen (rl
, !_route
->listening());
476 _session
->set_solo (rl
, !_route
->self_soloed());
487 RouteUI::solo_release (GdkEventButton
*)
489 if (!ignore_toggle
) {
493 if (_solo_release
->exclusive
) {
496 if (Config
->get_solo_control_is_listen_control()) {
497 _session
->set_listen (_solo_release
->routes
, _solo_release
->active
, Session::rt_cleanup
, true);
499 _session
->set_solo (_solo_release
->routes
, _solo_release
->active
, Session::rt_cleanup
, true);
503 delete _solo_release
;
512 RouteUI::rec_enable_press(GdkEventButton
* ev
)
514 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
518 if (!_session
->engine().connected()) {
519 MessageDialog
msg (_("Not connected to JACK - cannot engage record"));
524 if (!ignore_toggle
&& is_track() && rec_enable_button
) {
526 if (Keyboard::is_button2_event (ev
)) {
528 // do nothing on midi sigc::bind event
529 return rec_enable_button
->on_button_press_event (ev
);
531 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::ModifierMask (Keyboard::PrimaryModifier
|Keyboard::TertiaryModifier
))) {
533 _session
->set_record_enable (_session
->get_routes(), !rec_enable_button
->get_active());
535 } else if (Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
537 /* Primary-button1 applies change to the route group (even if it is not active)
538 NOTE: Primary-button2 is MIDI learn.
540 if (ev
->button
== 1 && _route
->route_group()) {
541 _session
->set_record_enable (_route
->route_group()->route_list(), !rec_enable_button
->get_active(), Session::rt_cleanup
, true);
544 } else if (Keyboard::is_context_menu_event (ev
)) {
546 /* do this on release */
550 boost::shared_ptr
<RouteList
> rl (new RouteList
);
551 rl
->push_back (route());
552 _session
->set_record_enable (rl
, !rec_enable_button
->get_active());
560 RouteUI::rec_enable_release (GdkEventButton
*)
566 RouteUI::build_sends_menu ()
568 using namespace Menu_Helpers
;
570 sends_menu
= new Menu
;
571 sends_menu
->set_name ("ArdourContextMenu");
572 MenuList
& items
= sends_menu
->items();
574 items
.push_back (MenuElem(_("Assign all tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PreFader
)));
575 items
.push_back (MenuElem(_("Assign all tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends
), PostFader
)));
576 items
.push_back (MenuElem(_("Assign selected tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PreFader
)));
577 items
.push_back (MenuElem(_("Assign selected tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends
), PostFader
)));
578 items
.push_back (MenuElem(_("Copy track gains to sends"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_from_track
)));
579 items
.push_back (MenuElem(_("Set sends gain to -inf"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_zero
)));
580 items
.push_back (MenuElem(_("Set sends gain to 0dB"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_unity
)));
585 RouteUI::create_sends (Placement p
)
587 _session
->globally_add_internal_sends (_route
, p
);
591 RouteUI::create_selected_sends (Placement p
)
593 boost::shared_ptr
<RouteList
> rlist (new RouteList
);
594 TrackSelection
& selected_tracks (ARDOUR_UI::instance()->the_editor().get_selection().tracks
);
596 for (TrackSelection::iterator i
= selected_tracks
.begin(); i
!= selected_tracks
.end(); ++i
) {
597 RouteTimeAxisView
* rtv
;
599 if ((rtv
= dynamic_cast<RouteTimeAxisView
*>(*i
)) != 0) {
600 if ((rui
= dynamic_cast<RouteUI
*>(rtv
)) != 0) {
601 if (boost::dynamic_pointer_cast
<AudioTrack
>(rui
->route())) {
602 rlist
->push_back (rui
->route());
608 _session
->add_internal_sends (_route
, p
, rlist
);
612 RouteUI::set_sends_gain_from_track ()
614 _session
->globally_set_send_gains_from_track (_route
);
618 RouteUI::set_sends_gain_to_zero ()
620 _session
->globally_set_send_gains_to_zero (_route
);
624 RouteUI::set_sends_gain_to_unity ()
626 _session
->globally_set_send_gains_to_unity (_route
);
630 RouteUI::show_sends_press(GdkEventButton
* ev
)
632 if (ev
->type
== GDK_2BUTTON_PRESS
|| ev
->type
== GDK_3BUTTON_PRESS
) {
636 if (!ignore_toggle
&& !is_track() && show_sends_button
) {
638 if (Keyboard::is_button2_event (ev
) && Keyboard::modifier_state_equals (ev
->state
, Keyboard::PrimaryModifier
)) {
640 // do nothing on midi sigc::bind event
643 } else if (Keyboard::is_context_menu_event (ev
)) {
645 if (sends_menu
== 0) {
649 sends_menu
->popup (0, ev
->time
);
653 /* change button state */
655 show_sends_button
->set_active (!show_sends_button
->get_active());
659 if (show_sends_button
->get_active()) {
660 /* show sends to this bus */
661 MixerStrip::SwitchIO (_route
);
662 send_blink_connection
= ARDOUR_UI::instance()->Blink
.connect (sigc::mem_fun(*this, &RouteUI::send_blink
));
664 /* everybody back to normal */
665 send_blink_connection
.disconnect ();
666 MixerStrip::SwitchIO (boost::shared_ptr
<Route
>());
676 RouteUI::show_sends_release (GdkEventButton
*)
682 RouteUI::send_blink (bool onoff
)
684 if (!show_sends_button
) {
689 show_sends_button
->set_state (STATE_ACTIVE
);
691 show_sends_button
->set_state (STATE_NORMAL
);
696 RouteUI::solo_visual_state (boost::shared_ptr
<Route
> r
)
698 if (r
->is_master() || r
->is_monitor()) {
702 if (Config
->get_solo_control_is_listen_control()) {
704 if (r
->listening()) {
720 RouteUI::solo_visual_state_with_isolate (boost::shared_ptr
<Route
> r
)
722 if (r
->is_master() || r
->is_monitor()) {
726 if (Config
->get_solo_control_is_listen_control()) {
728 if (r
->listening()) {
736 if (r
->solo_isolated()) {
738 } else if (r
->soloed()) {
739 if (!r
->self_soloed()) {
750 RouteUI::solo_isolate_visual_state (boost::shared_ptr
<Route
> r
)
752 if (r
->is_master() || r
->is_monitor()) {
756 if (r
->solo_isolated()) {
764 RouteUI::solo_safe_visual_state (boost::shared_ptr
<Route
> r
)
766 if (r
->is_master() || r
->is_monitor()) {
770 if (r
->solo_safe()) {
778 RouteUI::update_solo_display ()
782 if (Config
->get_solo_control_is_listen_control()) {
784 if (solo_button
->get_active() != (x
= _route
->listening())) {
785 ignore_toggle
= true;
786 solo_button
->set_active(x
);
787 ignore_toggle
= false;
792 if (solo_button
->get_active() != (x
= _route
->soloed())) {
793 ignore_toggle
= true;
794 solo_button
->set_active (x
);
795 ignore_toggle
= false;
800 bool yn
= _route
->solo_safe ();
802 if (solo_safe_check
&& solo_safe_check
->get_active() != yn
) {
803 solo_safe_check
->set_active (yn
);
806 yn
= _route
->solo_isolated ();
808 if (solo_isolated_check
&& solo_isolated_check
->get_active() != yn
) {
809 solo_isolated_check
->set_active (yn
);
814 solo_button
->set_visual_state (solo_visual_state_with_isolate (_route
));
818 RouteUI::solo_changed_so_update_mute ()
820 update_mute_display ();
824 RouteUI::mute_changed(void* /*src*/)
826 update_mute_display ();
830 RouteUI::mute_visual_state (Session
* s
, boost::shared_ptr
<Route
> r
)
832 if (r
->is_master() || r
->is_monitor()) {
836 if (Config
->get_show_solo_mutes()) {
841 } else if (s
->soloing() && !r
->soloed() && !r
->solo_isolated()) {
863 RouteUI::update_mute_display ()
869 bool model
= _route
->muted();
870 bool view
= mute_button
->get_active();
872 /* first make sure the button's "depressed" visual
877 ignore_toggle
= true;
878 mute_button
->set_active (model
);
879 ignore_toggle
= false;
882 mute_button
->set_visual_state (mute_visual_state (_session
, _route
));
886 RouteUI::route_rec_enable_changed ()
888 Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&RouteUI::update_rec_display
, this));
892 RouteUI::session_rec_enable_changed ()
894 update_rec_display ();
898 RouteUI::update_rec_display ()
900 if (!rec_enable_button
|| !_route
) {
904 bool model
= _route
->record_enabled();
905 bool view
= rec_enable_button
->get_active();
907 /* first make sure the button's "depressed" visual
912 ignore_toggle
= true;
913 rec_enable_button
->set_active (model
);
914 ignore_toggle
= false;
917 /* now make sure its color state is correct */
921 switch (_session
->record_status ()) {
922 case Session::Recording
:
923 rec_enable_button
->set_visual_state (1);
926 case Session::Disabled
:
927 case Session::Enabled
:
928 rec_enable_button
->set_visual_state (2);
934 rec_enable_button
->set_visual_state (0);
937 check_rec_enable_sensitivity ();
941 RouteUI::build_solo_menu (void)
943 using namespace Menu_Helpers
;
945 solo_menu
= new Menu
;
946 solo_menu
->set_name ("ArdourContextMenu");
947 MenuList
& items
= solo_menu
->items();
948 CheckMenuItem
* check
;
950 check
= new CheckMenuItem(_("Solo Isolate"));
951 check
->set_active (_route
->solo_isolated());
952 check
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated
), check
));
953 items
.push_back (CheckMenuElem(*check
));
954 solo_isolated_check
= dynamic_cast<CheckMenuItem
*>(&items
.back());
957 check
= new CheckMenuItem(_("Solo Safe"));
958 check
->set_active (_route
->solo_safe());
959 check
->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe
), check
));
960 items
.push_back (CheckMenuElem(*check
));
961 solo_safe_check
= dynamic_cast<CheckMenuItem
*>(&items
.back());
964 //items.push_back (SeparatorElem());
965 // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
970 RouteUI::build_mute_menu(void)
972 using namespace Menu_Helpers
;
974 mute_menu
= new Menu
;
975 mute_menu
->set_name ("ArdourContextMenu");
977 MenuList
& items
= mute_menu
->items();
979 pre_fader_mute_check
= manage (new CheckMenuItem(_("Pre Fader")));
980 init_mute_menu(MuteMaster::PreFader
, pre_fader_mute_check
);
981 pre_fader_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::PreFader
, pre_fader_mute_check
));
982 items
.push_back (CheckMenuElem(*pre_fader_mute_check
));
983 pre_fader_mute_check
->show_all();
985 post_fader_mute_check
= manage (new CheckMenuItem(_("Post Fader")));
986 init_mute_menu(MuteMaster::PostFader
, post_fader_mute_check
);
987 post_fader_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::PostFader
, post_fader_mute_check
));
988 items
.push_back (CheckMenuElem(*post_fader_mute_check
));
989 post_fader_mute_check
->show_all();
991 listen_mute_check
= manage (new CheckMenuItem(_("Control Outs")));
992 init_mute_menu(MuteMaster::Listen
, listen_mute_check
);
993 listen_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::Listen
, listen_mute_check
));
994 items
.push_back (CheckMenuElem(*listen_mute_check
));
995 listen_mute_check
->show_all();
997 main_mute_check
= manage (new CheckMenuItem(_("Main Outs")));
998 init_mute_menu(MuteMaster::Main
, main_mute_check
);
999 main_mute_check
->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu
), MuteMaster::Main
, main_mute_check
));
1000 items
.push_back (CheckMenuElem(*main_mute_check
));
1001 main_mute_check
->show_all();
1003 //items.push_back (SeparatorElem());
1004 // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
1006 _route
->mute_points_changed
.connect (route_connections
, invalidator (*this), boost::bind (&RouteUI::muting_change
, this), gui_context());
1010 RouteUI::init_mute_menu(MuteMaster::MutePoint mp
, CheckMenuItem
* check
)
1012 check
->set_active (_route
->mute_points() & mp
);
1016 RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp
, Gtk::CheckMenuItem
* check
)
1018 if (check
->get_active()) {
1019 _route
->set_mute_points (MuteMaster::MutePoint (_route
->mute_points() | mp
));
1021 _route
->set_mute_points (MuteMaster::MutePoint (_route
->mute_points() & ~mp
));
1026 RouteUI::muting_change ()
1028 ENSURE_GUI_THREAD (*this, &RouteUI::muting_change
)
1031 MuteMaster::MutePoint current
= _route
->mute_points ();
1033 yn
= (current
& MuteMaster::PreFader
);
1035 if (pre_fader_mute_check
->get_active() != yn
) {
1036 pre_fader_mute_check
->set_active (yn
);
1039 yn
= (current
& MuteMaster::PostFader
);
1041 if (post_fader_mute_check
->get_active() != yn
) {
1042 post_fader_mute_check
->set_active (yn
);
1045 yn
= (current
& MuteMaster::Listen
);
1047 if (listen_mute_check
->get_active() != yn
) {
1048 listen_mute_check
->set_active (yn
);
1051 yn
= (current
& MuteMaster::Main
);
1053 if (main_mute_check
->get_active() != yn
) {
1054 main_mute_check
->set_active (yn
);
1059 RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem
* check
)
1061 _route
->set_solo_isolated (check
->get_active(), this);
1065 RouteUI::toggle_solo_safe (Gtk::CheckMenuItem
* check
)
1067 _route
->set_solo_safe (check
->get_active(), this);
1071 RouteUI::choose_color()
1076 color
= Gtkmm2ext::UI::instance()->get_color (_("Color Selection"), picked
, &_color
);
1086 RouteUI::set_color (const Gdk::Color
& c
)
1093 snprintf (buf
, sizeof (buf
), "%d:%d:%d", c
.get_red(), c
.get_green(), c
.get_blue());
1094 xml_node
->add_property ("color", buf
);
1096 _route
->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */
1101 RouteUI::ensure_xml_node ()
1103 if (xml_node
== 0) {
1104 if ((xml_node
= _route
->extra_xml ("GUI")) == 0) {
1105 xml_node
= new XMLNode ("GUI");
1106 _route
->add_extra_xml (*xml_node
);
1112 RouteUI::get_automation_child_xml_node (Evoral::Parameter param
)
1116 XMLNodeList kids
= xml_node
->children();
1117 XMLNodeConstIterator iter
;
1119 const string sym
= ARDOUR::EventTypeMap::instance().to_symbol(param
);
1121 for (iter
= kids
.begin(); iter
!= kids
.end(); ++iter
) {
1122 if ((*iter
)->name() == AutomationTimeAxisView::state_node_name
) {
1123 XMLProperty
* type
= (*iter
)->property("automation-id");
1124 if (type
&& type
->value() == sym
)
1129 // Didn't find it, make a new one
1130 XMLNode
* child
= new XMLNode (AutomationTimeAxisView::state_node_name
);
1131 child
->add_property("automation-id", sym
);
1132 xml_node
->add_child_nocopy (*child
);
1138 RouteUI::set_color_from_route ()
1142 RouteUI::ensure_xml_node ();
1144 if ((prop
= xml_node
->property ("color")) != 0) {
1146 sscanf (prop
->value().c_str(), "%d:%d:%d", &r
, &g
, &b
);
1148 _color
.set_green(g
);
1156 RouteUI::remove_this_route ()
1158 vector
<string
> choices
;
1162 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());
1164 prompt
= string_compose (_("Do you really want to remove bus \"%1\" ?\n(this cannot be undone)"), _route
->name());
1167 choices
.push_back (_("No, do nothing."));
1168 choices
.push_back (_("Yes, remove it."));
1172 title
= _("Remove track");
1174 title
= _("Remove bus");
1177 Choice
prompter (title
, prompt
, choices
);
1179 if (prompter
.run () == 1) {
1180 Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route
), this));
1185 RouteUI::idle_remove_this_route (RouteUI
*rui
)
1187 rui
->_session
->remove_route (rui
->_route
);
1192 RouteUI::route_rename ()
1194 ArdourPrompter
name_prompter (true);
1196 name_prompter
.set_prompt (_("New Name: "));
1197 name_prompter
.set_initial_text (_route
->name());
1198 name_prompter
.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT
);
1199 name_prompter
.set_response_sensitive (Gtk::RESPONSE_ACCEPT
, false);
1200 name_prompter
.show_all ();
1202 switch (name_prompter
.run ()) {
1204 case Gtk::RESPONSE_ACCEPT
:
1205 name_prompter
.get_result (result
);
1206 if (result
.length()) {
1207 _route
->set_name (result
);
1217 RouteUI::property_changed (const PropertyChange
& what_changed
)
1219 if (what_changed
.contains (ARDOUR::Properties::name
)) {
1220 name_label
.set_text (_route
->name());
1225 RouteUI::toggle_route_active ()
1229 if (route_active_menu_item
) {
1230 if (route_active_menu_item
->get_active() != (yn
= _route
->active())) {
1231 _route
->set_active (!yn
);
1237 RouteUI::route_active_changed ()
1239 if (route_active_menu_item
) {
1240 Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&CheckMenuItem::set_active
, route_active_menu_item
, _route
->active()));
1246 RouteUI::toggle_denormal_protection ()
1248 if (denormal_menu_item
) {
1252 ENSURE_GUI_THREAD (*this, &RouteUI::toggle_denormal_protection
)
1254 if ((x
= denormal_menu_item
->get_active()) != _route
->denormal_protection()) {
1255 _route
->set_denormal_protection (x
);
1261 RouteUI::denormal_protection_changed ()
1263 if (denormal_menu_item
) {
1264 denormal_menu_item
->set_active (_route
->denormal_protection());
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
);
1317 RouteUI::name() const
1319 return _route
->name();
1323 RouteUI::map_frozen ()
1325 ENSURE_GUI_THREAD (*this, &RouteUI::map_frozen
)
1327 AudioTrack
* at
= dynamic_cast<AudioTrack
*>(_route
.get());
1330 switch (at
->freeze_state()) {
1331 case AudioTrack::Frozen
:
1332 rec_enable_button
->set_sensitive (false);
1335 rec_enable_button
->set_sensitive (true);
1342 RouteUI::adjust_latency ()
1344 LatencyDialog
dialog (_route
->name() + _(" latency"), *(_route
->output()), _session
->frame_rate(), _session
->engine().frames_per_cycle());
1348 RouteUI::save_as_template ()
1351 Glib::ustring safe_name
;
1354 path
= ARDOUR::user_route_template_directory ();
1356 if (g_mkdir_with_parents (path
.to_string().c_str(), 0755)) {
1357 error
<< string_compose (_("Cannot create route template directory %1"), path
.to_string()) << endmsg
;
1361 Prompter
p (true); // modal
1363 p
.set_prompt (_("Template name:"));
1365 case RESPONSE_ACCEPT
:
1372 p
.get_result (name
, true);
1374 safe_name
= legalize_for_path (name
);
1375 safe_name
+= template_suffix
;
1379 _route
->save_as_template (path
.to_string(), name
);
1383 RouteUI::check_rec_enable_sensitivity ()
1385 if (_session
->transport_rolling() && rec_enable_button
->get_active() && Config
->get_disable_disarm_during_roll()) {
1386 rec_enable_button
->set_sensitive (false);
1388 rec_enable_button
->set_sensitive (true);
1393 RouteUI::parameter_changed (string
const & p
)
1395 if (p
== "disable-disarm-during-roll") {
1396 check_rec_enable_sensitivity ();
1397 } else if (p
== "solo-control-is-listen-control") {
1398 set_button_names ();
1399 } else if (p
== "listen-position") {
1400 set_button_names ();
1405 RouteUI::step_gain_up ()
1407 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) + 0.1), this);
1411 RouteUI::page_gain_up ()
1413 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) + 0.5), this);
1417 RouteUI::step_gain_down ()
1419 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) - 0.1), this);
1423 RouteUI::page_gain_down ()
1425 _route
->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route
->gain_control()->get_value()) - 0.5), this);
1429 RouteUI::open_remote_control_id_dialog ()
1431 ArdourDialog
dialog (_("Remote Control ID"));
1433 uint32_t const limit
= _session
->ntracks() + _session
->nbusses () + 4;
1435 HBox
* hbox
= manage (new HBox
);
1436 hbox
->set_spacing (6);
1437 hbox
->pack_start (*manage (new Label (_("Remote control ID:"))));
1438 SpinButton
* spin
= manage (new SpinButton
);
1439 spin
->set_digits (0);
1440 spin
->set_increments (1, 10);
1441 spin
->set_range (0, limit
);
1442 spin
->set_value (_route
->remote_control_id());
1443 hbox
->pack_start (*spin
);
1444 dialog
.get_vbox()->pack_start (*hbox
);
1446 dialog
.add_button (Stock::CANCEL
, RESPONSE_CANCEL
);
1447 dialog
.add_button (Stock::APPLY
, RESPONSE_ACCEPT
);
1450 int const r
= dialog
.run ();
1452 if (r
== RESPONSE_ACCEPT
) {
1453 _route
->set_remote_control_id (spin
->get_value_as_int ());