X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Froute_ui.cc;h=fe2adff44985e572ba6b77783679dd7214d94c97;hb=28d7542d23181f82a62c319ff4689fc8cc2b83c0;hp=393ab011f3a1c54de3d41a05f6455017d37b432e;hpb=5a4d340b42ae2485d4bde4421f84c6220b24cab4;p=ardour.git diff --git a/gtk2_ardour/route_ui.cc b/gtk2_ardour/route_ui.cc index 393ab011f3..fe2adff449 100644 --- a/gtk2_ardour/route_ui.cc +++ b/gtk2_ardour/route_ui.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2006 Paul Davis + Copyright (C) 2002-2006 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -26,12 +26,15 @@ #include #include "ardour/route_group.h" +#include "ardour/dB.h" #include "pbd/memento_command.h" #include "pbd/stacktrace.h" #include "pbd/shiva.h" #include "pbd/controllable.h" +#include "pbd/enumwriter.h" #include "ardour_ui.h" +#include "editor.h" #include "route_ui.h" #include "keyboard.h" #include "utils.h" @@ -41,8 +44,10 @@ #include "latency_gui.h" #include "mixer_strip.h" #include "automation_time_axis.h" +#include "route_time_axis.h" #include "ardour/route.h" +#include "ardour/event_type_map.h" #include "ardour/session.h" #include "ardour/audioengine.h" #include "ardour/audio_track.h" @@ -61,19 +66,16 @@ using namespace Gtkmm2ext; using namespace ARDOUR; using namespace PBD; -RouteUI::RouteUI (ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name) +RouteUI::RouteUI (ARDOUR::Session& sess) : AxisView(sess) { init (); - set_button_names (mute_name, solo_name, rec_name); } -RouteUI::RouteUI (boost::shared_ptr rt, - ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name) +RouteUI::RouteUI (boost::shared_ptr rt, ARDOUR::Session& sess) : AxisView(sess) { init (); - set_button_names (mute_name, solo_name, rec_name); set_route (rt); } @@ -82,10 +84,9 @@ RouteUI::~RouteUI() /* derived classes should emit GoingAway so that they receive the signal when the object is still a legal derived instance. */ - + delete solo_menu; delete mute_menu; - delete remote_control_menu; delete sends_menu; } @@ -96,30 +97,39 @@ RouteUI::init () xml_node = 0; mute_menu = 0; solo_menu = 0; - remote_control_menu = 0; sends_menu = 0; + pre_fader_mute_check = 0; + post_fader_mute_check = 0; + listen_mute_check = 0; + main_mute_check = 0; ignore_toggle = false; wait_for_release = false; route_active_menu_item = 0; - was_solo_safe = false; polarity_menu_item = 0; denormal_menu_item = 0; multiple_mute_change = false; multiple_solo_change = false; - mute_button = manage (new BindableToggleButton ("")); + mute_button = manage (new BindableToggleButton ()); mute_button->set_self_managed (true); mute_button->set_name ("MuteButton"); + mute_button->add (mute_button_label); + mute_button_label.show (); UI::instance()->set_tip (mute_button, _("Mute this track"), ""); - solo_button = manage (new BindableToggleButton ("")); + solo_button = manage (new BindableToggleButton ()); solo_button->set_self_managed (true); solo_button->set_name ("SoloButton"); + solo_button->add (solo_button_label); + solo_button_label.show (); UI::instance()->set_tip (solo_button, _("Mute other (non-soloed) tracks"), ""); + solo_button->set_no_show_all (true); - rec_enable_button = manage (new BindableToggleButton ("")); + rec_enable_button = manage (new BindableToggleButton ()); rec_enable_button->set_name ("RecordEnableButton"); rec_enable_button->set_self_managed (true); + rec_enable_button->add (rec_enable_button_label); + rec_enable_button_label.show (); UI::instance()->set_tip (rec_enable_button, _("Enable recording on this track"), ""); show_sends_button = manage (new BindableToggleButton ("")); @@ -128,6 +138,9 @@ RouteUI::init () UI::instance()->set_tip (show_sends_button, _("make mixer strips show sends to this bus"), ""); _session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute)); + _session.TransportStateChange.connect (mem_fun (*this, &RouteUI::check_rec_enable_sensitivity)); + + Config->ParameterChanged.connect (mem_fun (*this, &RouteUI::parameter_changed)); } void @@ -145,7 +158,7 @@ RouteUI::reset () delete mute_menu; mute_menu = 0; - + if (xml_node) { /* do not delete the node - its owned by the route */ xml_node = 0; @@ -156,14 +169,6 @@ RouteUI::reset () denormal_menu_item = 0; } -void -RouteUI::set_button_names (const char* mute, const char* solo, const char* rec) -{ - m_name = mute; - s_name = solo; - r_name = rec; -} - void RouteUI::set_route (boost::shared_ptr rp) { @@ -184,17 +189,15 @@ RouteUI::set_route (boost::shared_ptr rp) } mute_button->set_controllable (_route->mute_control()); - mute_button->set_label (m_name); - solo_button->set_controllable (_route->solo_control()); - solo_button->set_label (s_name); - + connections.push_back (_route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed))); connections.push_back (_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed))); connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed))); - connections.push_back (_route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed))); - - if (is_track()) { + connections.push_back (_route->listen_changed.connect (mem_fun(*this, &RouteUI::listen_changed))); + connections.push_back (_route->solo_isolated_changed.connect (mem_fun(*this, &RouteUI::solo_changed))); + + if (_session.writable() && is_track()) { boost::shared_ptr t = boost::dynamic_pointer_cast(_route); connections.push_back (t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed))); @@ -202,18 +205,20 @@ RouteUI::set_route (boost::shared_ptr rp) rec_enable_button->show(); rec_enable_button->set_controllable (t->rec_enable_control()); - rec_enable_button->set_label (r_name); update_rec_display (); - } + } mute_button->unset_flags (Gtk::CAN_FOCUS); solo_button->unset_flags (Gtk::CAN_FOCUS); - + mute_button->show(); - solo_button->show(); - connections.push_back (_route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu))); + if (_route->is_control()) { + solo_button->hide (); + } else { + solo_button->show(); + } /* map the current state */ @@ -245,7 +250,7 @@ RouteUI::mute_press(GdkEventButton* ev) if (Keyboard::is_button2_event (ev)) { // Primary-button2 click is the midi binding click // button2-click is "momentary" - + if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) { wait_for_release = true; } else { @@ -274,9 +279,9 @@ RouteUI::mute_press(GdkEventButton* ev) */ if (ev->button == 1) { - set_mix_group_mute (_route, !_route->muted()); + set_route_group_mute (_route, !_route->muted()); } - + } else { /* plain click applies change to this route */ @@ -295,7 +300,7 @@ RouteUI::mute_press(GdkEventButton* ev) } bool -RouteUI::mute_release(GdkEventButton* ev) +RouteUI::mute_release(GdkEventButton*) { if (!ignore_toggle) { if (wait_for_release){ @@ -321,102 +326,101 @@ RouteUI::solo_press(GdkEventButton* ev) if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) { return true; } - multiple_solo_change = false; - if (!ignore_toggle) { - if (Keyboard::is_context_menu_event (ev)) { + if (Config->get_solo_control_is_listen_control()) { - if (solo_menu == 0) { - build_solo_menu (); - } + _route->set_listen (!_route->listening(), this); - solo_menu->popup (1, ev->time); + } else { - } else { + multiple_solo_change = false; + if (!ignore_toggle) { - if (Keyboard::is_button2_event (ev)) { + if (Keyboard::is_context_menu_event (ev)) { - // Primary-button2 click is the midi binding click - // button2-click is "momentary" - - if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) { - wait_for_release = true; - } else { - return false; + if (solo_menu == 0) { + build_solo_menu (); } - } - if (ev->button == 1 || Keyboard::is_button2_event (ev)) { + solo_menu->popup (1, ev->time); - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + } else { - /* Primary-Tertiary-click applies change to all routes */ - bool was_not_latched = false; - if (!Config->get_solo_latched ()) { - was_not_latched = true; - /* - XXX it makes no sense to solo all tracks if we're - not in latched mode, but doing nothing feels like a bug, - so do it anyway - */ - Config->set_solo_latched (true); - } - _session.begin_reversible_command (_("solo change")); - Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this); - _session.set_all_solo (!_route->soloed()); - cmd->mark(); - _session.add_command (cmd); - _session.commit_reversible_command (); - multiple_solo_change = true; - if (was_not_latched) { - Config->set_solo_latched (false); - } - - } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { + if (Keyboard::is_button2_event (ev)) { - // Primary-Secondary-click: exclusively solo this track, not a toggle */ + // Primary-button2 click is the midi binding click + // button2-click is "momentary" - _session.begin_reversible_command (_("solo change")); - Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand (_session, this); - _session.set_all_solo (false); - _route->set_solo (true, this); - cmd->mark(); - _session.add_command(cmd); - _session.commit_reversible_command (); + if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) { + wait_for_release = true; + } else { + return false; + } + } - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { + if (ev->button == 1 || Keyboard::is_button2_event (ev)) { - // shift-click: set this route to solo safe + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { - if (Profile->get_sae() && ev->button == 1) { - // button 1 and shift-click: disables solo_latched for this click + /* Primary-Tertiary-click applies change to all routes */ + bool was_not_latched = false; if (!Config->get_solo_latched ()) { + was_not_latched = true; + /* + XXX it makes no sense to solo all tracks if we're + not in latched mode, but doing nothing feels like a bug, + so do it anyway + */ Config->set_solo_latched (true); - reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this); + } + _session.begin_reversible_command (_("solo change")); + Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this); + _session.set_all_solo (!_route->soloed()); + cmd->mark(); + _session.add_command (cmd); + _session.commit_reversible_command (); + multiple_solo_change = true; + if (was_not_latched) { Config->set_solo_latched (false); } - } else { - _route->set_solo_safe (!_route->solo_safe(), this); - wait_for_release = false; - } - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { + } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { - /* Primary-button1: solo mix group. - NOTE: Primary-button2 is MIDI learn. - */ + // Primary-Secondary-click: exclusively solo this track, not a toggle */ - if (ev->button == 1) { - set_mix_group_solo (_route, !_route->soloed()); - } + _session.begin_reversible_command (_("solo change")); + Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand (_session, this); + _session.set_all_solo (false); + _route->set_solo (true, this); + cmd->mark(); + _session.add_command(cmd); + _session.commit_reversible_command (); - } else { + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { + + // shift-click: toggle solo isolated status + + _route->set_solo_isolated (!_route->solo_isolated(), this); + wait_for_release = false; + + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { + + /* Primary-button1: solo mix group. + NOTE: Primary-button2 is MIDI learn. + */ + + if (ev->button == 1) { + set_route_group_solo (_route, !_route->soloed()); + } - /* click: solo this route */ - if (wait_for_release) { - _route->set_solo (!_route->soloed(), this); } else { - reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this); + + /* click: solo this route */ + if (wait_for_release) { + _route->set_solo (!_route->soloed(), this); + } else { + reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this); + } } } } @@ -427,7 +431,7 @@ RouteUI::solo_press(GdkEventButton* ev) } bool -RouteUI::solo_release(GdkEventButton* ev) +RouteUI::solo_release(GdkEventButton*) { if (!ignore_toggle) { if (wait_for_release) { @@ -477,6 +481,7 @@ RouteUI::rec_enable_press(GdkEventButton* ev) _session.record_disenable_all (); } else { _session.record_enable_all (); + check_rec_enable_sensitivity (); } cmd->mark(); @@ -489,11 +494,15 @@ RouteUI::rec_enable_press(GdkEventButton* ev) NOTE: Primary-button2 is MIDI learn. */ - set_mix_group_rec_enable (_route, !_route->record_enabled()); + set_route_group_rec_enable (_route, !_route->record_enabled()); - } else { + } else if (Keyboard::is_context_menu_event (ev)) { + + /* do this on release */ + } else { reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !track()->record_enabled(), this); + check_rec_enable_sensitivity (); } } @@ -501,7 +510,7 @@ RouteUI::rec_enable_press(GdkEventButton* ev) } bool -RouteUI::rec_enable_release (GdkEventButton* ev) +RouteUI::rec_enable_release (GdkEventButton*) { return true; } @@ -510,29 +519,64 @@ void RouteUI::build_sends_menu () { using namespace Menu_Helpers; - + sends_menu = new Menu; sends_menu->set_name ("ArdourContextMenu"); MenuList& items = sends_menu->items(); - + + items.push_back (MenuElem(_("Assign all tracks (prefader)"), bind (mem_fun (*this, &RouteUI::create_sends), PreFader))); + items.push_back (MenuElem(_("Assign all tracks (postfader)"), bind (mem_fun (*this, &RouteUI::create_sends), PostFader))); + items.push_back (MenuElem(_("Assign selected tracks (prefader)"), bind (mem_fun (*this, &RouteUI::create_selected_sends), PreFader))); + items.push_back (MenuElem(_("Assign selected tracks (postfader)"), bind (mem_fun (*this, &RouteUI::create_selected_sends), PostFader))); items.push_back (MenuElem(_("Copy track gains to sends"), mem_fun (*this, &RouteUI::set_sends_gain_from_track))); items.push_back (MenuElem(_("Set sends gain to -inf"), mem_fun (*this, &RouteUI::set_sends_gain_to_zero))); items.push_back (MenuElem(_("Set sends gain to 0dB"), mem_fun (*this, &RouteUI::set_sends_gain_to_unity))); + +} + +void +RouteUI::create_sends (Placement p) +{ + _session.globally_add_internal_sends (_route, p); +} + +void +RouteUI::create_selected_sends (Placement p) +{ + boost::shared_ptr rlist (new RouteList); + TrackSelection& selected_tracks (ARDOUR_UI::instance()->the_editor().get_selection().tracks); + + for (TrackSelection::iterator i = selected_tracks.begin(); i != selected_tracks.end(); ++i) { + RouteTimeAxisView* rtv; + RouteUI* rui; + if ((rtv = dynamic_cast(*i)) != 0) { + if ((rui = dynamic_cast(rtv)) != 0) { + if (boost::dynamic_pointer_cast(rui->route())) { + rlist->push_back (rui->route()); + } + } + } + } + + _session.add_internal_sends (_route, p, rlist); } void RouteUI::set_sends_gain_from_track () { + _session.globally_set_send_gains_from_track (_route); } void RouteUI::set_sends_gain_to_zero () { + _session.globally_set_send_gains_to_zero (_route); } void RouteUI::set_sends_gain_to_unity () { + _session.globally_set_send_gains_to_unity (_route); } bool @@ -582,7 +626,7 @@ RouteUI::show_sends_press(GdkEventButton* ev) } bool -RouteUI::show_sends_release (GdkEventButton* ev) +RouteUI::show_sends_release (GdkEventButton*) { return true; } @@ -593,7 +637,7 @@ RouteUI::send_blink (bool onoff) if (!show_sends_button) { return; } - + if (onoff) { show_sends_button->set_state (STATE_ACTIVE); } else { @@ -602,32 +646,67 @@ RouteUI::send_blink (bool onoff) } void -RouteUI::solo_changed(void* src) +RouteUI::solo_changed(void* /*src*/) { + Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display)); +} + +void +RouteUI::listen_changed(void* /*src*/) +{ Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display)); } +int +RouteUI::solo_visual_state (boost::shared_ptr r) +{ + if (Config->get_solo_control_is_listen_control()) { + + if (r->listening()) { + return 1; + } else { + return 0; + } + + } else { + + if (r->solo_isolated()) { + return 2; + } else if (r->soloed()) { + return 1; + } else { + return 0; + } + } + + return 0; +} + void RouteUI::update_solo_display () { bool x; - vector fg_colors; - Gdk::Color c; - if (solo_button->get_active() != (x = _route->soloed())){ - ignore_toggle = true; - solo_button->set_active(x); - ignore_toggle = false; - } - - if (_route->solo_safe()) { - solo_button->set_visual_state (2); - } else if (_route->soloed()) { - solo_button->set_visual_state (1); + if (Config->get_solo_control_is_listen_control()) { + + if (solo_button->get_active() != (x = _route->listening())) { + ignore_toggle = true; + solo_button->set_active(x); + ignore_toggle = false; + } + } else { - solo_button->set_visual_state (0); + + if (solo_button->get_active() != (x = _route->soloed())) { + ignore_toggle = true; + solo_button->set_active (x); + ignore_toggle = false; + } + } + + solo_button->set_visual_state (solo_visual_state (_route)); } void @@ -637,11 +716,41 @@ RouteUI::solo_changed_so_update_mute () } void -RouteUI::mute_changed(void* src) +RouteUI::mute_changed(void* /*src*/) { Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_mute_display)); } +int +RouteUI::mute_visual_state (Session& s, boost::shared_ptr r) +{ + if (Config->get_show_solo_mutes()) { + + if (r->muted ()) { + /* full mute */ + return 2; + } else if (s.soloing() && !r->soloed() && !r->solo_isolated()) { + /* mute-because-not-soloed */ + return 1; + } else { + /* no mute at all */ + return 0; + } + + } else { + + if (r->muted()) { + /* full mute */ + return 2; + } else { + /* no mute at all */ + return 0; + } + } + + return 0; +} + void RouteUI::update_mute_display () { @@ -658,25 +767,7 @@ RouteUI::update_mute_display () ignore_toggle = false; } - /* now attend to visual state */ - - if (Config->get_show_solo_mutes()) { - if (_route->muted()) { - mute_button->set_visual_state (2); - } else if (!_route->soloed() && _route->solo_muted()) { - - mute_button->set_visual_state (1); - } else { - mute_button->set_visual_state (0); - } - } else { - if (_route->muted()) { - mute_button->set_visual_state (2); - } else { - mute_button->set_visual_state (0); - } - } - + mute_button->set_visual_state (mute_visual_state (_session, _route)); } void @@ -706,7 +797,7 @@ RouteUI::update_rec_display () rec_enable_button->set_active (model); ignore_toggle = false; } - + /* now make sure its color state is correct */ if (model) { @@ -728,83 +819,24 @@ RouteUI::update_rec_display () } } -void -RouteUI::build_remote_control_menu () -{ - remote_control_menu = new Menu; - refresh_remote_control_menu (); -} - -void -RouteUI::refresh_remote_control_menu () -{ - ENSURE_GUI_THREAD (mem_fun (*this, &RouteUI::refresh_remote_control_menu)); - - // only refresh the menu if it has been instantiated - - if (remote_control_menu == 0) { - return; - } - - using namespace Menu_Helpers; - - RadioMenuItem::Group rc_group; - CheckMenuItem* rc_active; - uint32_t limit = _session.ntracks() + _session.nbusses(); - char buf[32]; - - MenuList& rc_items = remote_control_menu->items(); - rc_items.clear (); - - /* note that this menu list starts at zero, not 1, because zero - is a valid, if useless, ID. - */ - - limit += 4; /* leave some breathing room */ - - rc_items.push_back (RadioMenuElem (rc_group, _("None"))); - if (_route->remote_control_id() == 0) { - rc_active = dynamic_cast (&rc_items.back()); - rc_active->set_active (); - } - - for (uint32_t i = 1; i < limit; ++i) { - snprintf (buf, sizeof (buf), "%u", i); - rc_items.push_back (RadioMenuElem (rc_group, buf)); - rc_active = dynamic_cast(&rc_items.back()); - if (_route->remote_control_id() == i) { - rc_active = dynamic_cast (&rc_items.back()); - rc_active->set_active (); - } - rc_active->signal_activate().connect (bind (mem_fun (*this, &RouteUI::set_remote_control_id), i, rc_active)); - } -} - -void -RouteUI::set_remote_control_id (uint32_t id, CheckMenuItem* item) -{ - /* this is called when the radio menu item is toggled, and so - is actually invoked twice per menu selection. we only - care about the invocation for the item that was being - marked active. - */ - - if (item->get_active()) { - _route->set_remote_control_id (id); - } -} - void RouteUI::build_solo_menu (void) { using namespace Menu_Helpers; - + solo_menu = new Menu; solo_menu->set_name ("ArdourContextMenu"); MenuList& items = solo_menu->items(); CheckMenuItem* check; - check = new CheckMenuItem(_("Solo Lock")); + check = new CheckMenuItem(_("Solo Isolate")); + check->set_active (_route->solo_isolated()); + check->signal_toggled().connect (bind (mem_fun (*this, &RouteUI::toggle_solo_isolated), check)); + _route->solo_isolated_changed.connect(bind (mem_fun (*this, &RouteUI::solo_isolated_toggle), check)); + items.push_back (CheckMenuElem(*check)); + check->show_all(); + + check = new CheckMenuItem(_("Solo Safe")); check->set_active (_route->solo_safe()); check->signal_toggled().connect (bind (mem_fun (*this, &RouteUI::toggle_solo_safe), check)); _route->solo_safe_changed.connect(bind (mem_fun (*this, &RouteUI::solo_safe_toggle), check)); @@ -813,63 +845,102 @@ RouteUI::build_solo_menu (void) //items.push_back (SeparatorElem()); // items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn))); - + } void RouteUI::build_mute_menu(void) { using namespace Menu_Helpers; - + mute_menu = new Menu; mute_menu->set_name ("ArdourContextMenu"); - MenuList& items = mute_menu->items(); - CheckMenuItem* check; - - check = new CheckMenuItem(_("Pre Fader")); - init_mute_menu(PRE_FADER, check); - check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), PRE_FADER, check)); - _route->pre_fader_changed.connect(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), check)); - items.push_back (CheckMenuElem(*check)); - check->show_all(); - check = new CheckMenuItem(_("Post Fader")); - init_mute_menu(POST_FADER, check); - check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), POST_FADER, check)); - _route->post_fader_changed.connect(bind (mem_fun (*this, &RouteUI::post_fader_toggle), check)); - items.push_back (CheckMenuElem(*check)); - check->show_all(); - - check = new CheckMenuItem(_("Control Outs")); - init_mute_menu(CONTROL_OUTS, check); - check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), CONTROL_OUTS, check)); - _route->control_outs_changed.connect(bind (mem_fun (*this, &RouteUI::control_outs_toggle), check)); - items.push_back (CheckMenuElem(*check)); - check->show_all(); + MenuList& items = mute_menu->items(); - check = new CheckMenuItem(_("Main Outs")); - init_mute_menu(MAIN_OUTS, check); - check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MAIN_OUTS, check)); - _route->main_outs_changed.connect(bind (mem_fun (*this, &RouteUI::main_outs_toggle), check)); - items.push_back (CheckMenuElem(*check)); - check->show_all(); + pre_fader_mute_check = manage (new CheckMenuItem(_("Pre Fader"))); + init_mute_menu(MuteMaster::PreFader, pre_fader_mute_check); + pre_fader_mute_check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PreFader, pre_fader_mute_check)); + items.push_back (CheckMenuElem(*pre_fader_mute_check)); + pre_fader_mute_check->show_all(); + + post_fader_mute_check = manage (new CheckMenuItem(_("Post Fader"))); + init_mute_menu(MuteMaster::PostFader, post_fader_mute_check); + post_fader_mute_check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PostFader, post_fader_mute_check)); + items.push_back (CheckMenuElem(*post_fader_mute_check)); + post_fader_mute_check->show_all(); + + listen_mute_check = manage (new CheckMenuItem(_("Control Outs"))); + init_mute_menu(MuteMaster::Listen, listen_mute_check); + listen_mute_check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::Listen, listen_mute_check)); + items.push_back (CheckMenuElem(*listen_mute_check)); + listen_mute_check->show_all(); + + main_mute_check = manage (new CheckMenuItem(_("Main Outs"))); + init_mute_menu(MuteMaster::Main, main_mute_check); + main_mute_check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::Main, main_mute_check)); + items.push_back (CheckMenuElem(*main_mute_check)); + main_mute_check->show_all(); //items.push_back (SeparatorElem()); // items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn))); + + _route->mute_points_changed.connect (mem_fun (*this, &RouteUI::muting_change)); } void -RouteUI::init_mute_menu(mute_type type, CheckMenuItem* check) +RouteUI::init_mute_menu(MuteMaster::MutePoint mp, CheckMenuItem* check) { - if (_route->get_mute_config (type)) { - check->set_active (true); + check->set_active (_route->mute_points() & mp); +} + +void +RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp, Gtk::CheckMenuItem* check) +{ + if (check->get_active()) { + _route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() | mp)); + } else { + _route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() & ~mp)); + } +} + +void +RouteUI::muting_change () +{ + ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::muting_change)); + + bool yn; + MuteMaster::MutePoint current = _route->mute_points (); + + yn = (current & MuteMaster::PreFader); + + if (pre_fader_mute_check->get_active() != yn) { + pre_fader_mute_check->set_active (yn); + } + + yn = (current & MuteMaster::PostFader); + + if (post_fader_mute_check->get_active() != yn) { + post_fader_mute_check->set_active (yn); + } + + yn = (current & MuteMaster::Listen); + + if (listen_mute_check->get_active() != yn) { + listen_mute_check->set_active (yn); + } + + yn = (current & MuteMaster::Main); + + if (main_mute_check->get_active() != yn) { + main_mute_check->set_active (yn); } } void -RouteUI::toggle_mute_menu(mute_type type, Gtk::CheckMenuItem* check) +RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem* check) { - _route->set_mute_config(type, check->get_active(), this); + _route->set_solo_isolated (check->get_active(), this); } void @@ -879,14 +950,14 @@ RouteUI::toggle_solo_safe (Gtk::CheckMenuItem* check) } void -RouteUI::set_mix_group_solo(boost::shared_ptr route, bool yn) +RouteUI::set_route_group_solo(boost::shared_ptr route, bool yn) { - RouteGroup* mix_group; + RouteGroup* route_group; - if((mix_group = route->mix_group()) != 0){ + if((route_group = route->route_group()) != 0){ _session.begin_reversible_command (_("mix group solo change")); Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this); - mix_group->apply(&Route::set_solo, yn, this); + route_group->apply(&Route::set_solo, yn, this); cmd->mark(); _session.add_command (cmd); _session.commit_reversible_command (); @@ -918,14 +989,14 @@ RouteUI::reversibly_apply_track_boolean (string name, void (Track::*func)(bool, } void -RouteUI::set_mix_group_mute(boost::shared_ptr route, bool yn) +RouteUI::set_route_group_mute(boost::shared_ptr route, bool yn) { - RouteGroup* mix_group; + RouteGroup* route_group; - if((mix_group = route->mix_group()) != 0){ + if((route_group = route->route_group()) != 0){ _session.begin_reversible_command (_("mix group mute change")); Session::GlobalMuteStateCommand *cmd = new Session::GlobalMuteStateCommand (_session, this); - mix_group->apply(&Route::set_mute, yn, this); + route_group->apply(&Route::set_mute, yn, this); cmd->mark(); _session.add_command(cmd); _session.commit_reversible_command (); @@ -935,14 +1006,14 @@ RouteUI::set_mix_group_mute(boost::shared_ptr route, bool yn) } void -RouteUI::set_mix_group_rec_enable(boost::shared_ptr route, bool yn) +RouteUI::set_route_group_rec_enable(boost::shared_ptr route, bool yn) { - RouteGroup* mix_group; + RouteGroup* route_group; - if((mix_group = route->mix_group()) != 0){ + if((route_group = route->route_group()) != 0){ _session.begin_reversible_command (_("mix group rec-enable change")); Session::GlobalRecordEnableStateCommand *cmd = new Session::GlobalRecordEnableStateCommand(_session, this); - mix_group->apply (&Route::set_record_enable, yn, this); + route_group->apply (&Route::set_record_enable, yn, this); cmd->mark(); _session.add_command(cmd); _session.commit_reversible_command (); @@ -971,9 +1042,9 @@ void RouteUI::set_color (const Gdk::Color & c) { char buf[64]; - + _color = c; - + ensure_xml_node (); snprintf (buf, sizeof (buf), "%d:%d:%d", c.get_red(), c.get_green(), c.get_blue()); xml_node->add_property ("color", buf); @@ -997,7 +1068,7 @@ XMLNode* RouteUI::get_automation_child_xml_node (Evoral::Parameter param) { ensure_xml_node (); - + XMLNodeList kids = xml_node->children(); XMLNodeConstIterator iter; @@ -1023,7 +1094,7 @@ int RouteUI::set_color_from_route () { XMLProperty *prop; - + RouteUI::ensure_xml_node (); if ((prop = xml_node->property ("color")) != 0) { @@ -1033,7 +1104,7 @@ RouteUI::set_color_from_route () _color.set_green(g); _color.set_blue(b); return 0; - } + } return 1; } @@ -1083,12 +1154,12 @@ RouteUI::route_rename () name_prompter.get_result (result); if (result.length()) { _route->set_name (result); - } + } break; } return; - + } void @@ -1127,9 +1198,9 @@ RouteUI::toggle_polarity () bool x; ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::toggle_polarity)); - + if ((x = polarity_menu_item->get_active()) != _route->phase_invert()) { - _route->set_phase_invert (x, this); + _route->set_phase_invert (x); if (x) { name_label.set_text (X_("Ø ") + name_label.get_text()); } else { @@ -1142,7 +1213,11 @@ RouteUI::toggle_polarity () void RouteUI::polarity_changed () { - /* no signal for this yet */ + if (_route->phase_invert()) { + name_label.set_text (X_("Ø ") + name_label.get_text()); + } else { + name_label.set_text (_route->name()); + } } void @@ -1153,9 +1228,9 @@ RouteUI::toggle_denormal_protection () bool x; ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::toggle_denormal_protection)); - + if ((x = denormal_menu_item->get_active()) != _route->denormal_protection()) { - _route->set_denormal_protection (x, this); + _route->set_denormal_protection (x); } } } @@ -1163,58 +1238,27 @@ RouteUI::toggle_denormal_protection () void RouteUI::denormal_protection_changed () { - /* no signal for this yet */ + if (denormal_menu_item) { + denormal_menu_item->set_active (_route->denormal_protection()); + } } - void -RouteUI::solo_safe_toggle(void* src, Gtk::CheckMenuItem* check) +RouteUI::solo_isolated_toggle(void* /*src*/, Gtk::CheckMenuItem* check) { - bool yn = _route->solo_safe (); + bool yn = _route->solo_isolated (); if (check->get_active() != yn) { check->set_active (yn); } } -void -RouteUI::pre_fader_toggle(void* src, Gtk::CheckMenuItem* check) -{ - ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), src, check)); - - bool yn = _route->get_mute_config(PRE_FADER); - if (check->get_active() != yn) { - check->set_active (yn); - } -} -void -RouteUI::post_fader_toggle(void* src, Gtk::CheckMenuItem* check) -{ - ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::post_fader_toggle), src, check)); - - bool yn = _route->get_mute_config(POST_FADER); - if (check->get_active() != yn) { - check->set_active (yn); - } -} void -RouteUI::control_outs_toggle(void* src, Gtk::CheckMenuItem* check) +RouteUI::solo_safe_toggle(void* /*src*/, Gtk::CheckMenuItem* check) { - ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::control_outs_toggle), src, check)); - - bool yn = _route->get_mute_config(CONTROL_OUTS); - if (check->get_active() != yn) { - check->set_active (yn); - } -} + bool yn = _route->solo_safe (); -void -RouteUI::main_outs_toggle(void* src, Gtk::CheckMenuItem* check) -{ - ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::main_outs_toggle), src, check)); - - bool yn = _route->get_mute_config(MAIN_OUTS); if (check->get_active() != yn) { check->set_active (yn); } @@ -1223,13 +1267,13 @@ RouteUI::main_outs_toggle(void* src, Gtk::CheckMenuItem* check) void RouteUI::disconnect_input () { - _route->disconnect_inputs (this); + _route->input()->disconnect (this); } void RouteUI::disconnect_output () { - _route->disconnect_outputs (this); + _route->output()->disconnect (this); } bool @@ -1308,7 +1352,7 @@ RouteUI::map_frozen () void RouteUI::adjust_latency () { - LatencyDialog dialog (_route->name() + _("latency"), *(_route.get()), _session.frame_rate(), _session.engine().frames_per_cycle()); + LatencyDialog dialog (_route->name() + _(" latency"), *(_route->output()), _session.frame_rate(), _session.engine().frames_per_cycle()); } void @@ -1317,16 +1361,16 @@ RouteUI::save_as_template () sys::path path; Glib::ustring safe_name; string name; - + path = ARDOUR::user_route_template_directory (); - + if (g_mkdir_with_parents (path.to_string().c_str(), 0755)) { error << string_compose (_("Cannot create route template directory %1"), path.to_string()) << endmsg; return; } - + Prompter p (true); // modal - + p.set_prompt (_("Template name:")); switch (p.run()) { case RESPONSE_ACCEPT: @@ -1334,14 +1378,91 @@ RouteUI::save_as_template () default: return; } - + p.hide (); p.get_result (name, true); - + safe_name = legalize_for_path (name); safe_name += template_suffix; - + path /= safe_name; - + _route->save_as_template (path.to_string(), name); } + +void +RouteUI::check_rec_enable_sensitivity () +{ + if (_session.transport_rolling() && rec_enable_button->get_active() && Config->get_disable_disarm_during_roll()) { + rec_enable_button->set_sensitive (false); + } else { + rec_enable_button->set_sensitive (true); + } +} + +void +RouteUI::parameter_changed (string const & p) +{ + ENSURE_GUI_THREAD (bind (mem_fun (*this, &RouteUI::parameter_changed), p)); + + if (p == "disable-disarm-during-roll") { + check_rec_enable_sensitivity (); + } else if (p == "solo-control-is-listen-control") { + set_button_names (); + } else if (p == "listen-position") { + set_button_names (); + } +} + +void +RouteUI::step_gain_up () +{ + _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), this); +} + +void +RouteUI::page_gain_up () +{ + _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), this); +} + +void +RouteUI::step_gain_down () +{ + _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), this); +} + +void +RouteUI::page_gain_down () +{ + _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.5), this); +} + +void +RouteUI::open_remote_control_id_dialog () +{ + ArdourDialog dialog (_("Remote Control ID")); + + uint32_t const limit = _session.ntracks() + _session.nbusses () + 4; + + HBox* hbox = manage (new HBox); + hbox->set_spacing (6); + hbox->pack_start (*manage (new Label (_("Remote control ID:")))); + SpinButton* spin = manage (new SpinButton); + spin->set_digits (0); + spin->set_increments (1, 10); + spin->set_range (0, limit); + spin->set_value (_route->remote_control_id()); + hbox->pack_start (*spin); + dialog.get_vbox()->pack_start (*hbox); + + dialog.add_button (Stock::CANCEL, RESPONSE_CANCEL); + dialog.add_button (Stock::APPLY, RESPONSE_ACCEPT); + + dialog.show_all (); + int const r = dialog.run (); + + if (r == RESPONSE_ACCEPT) { + _route->set_remote_control_id (spin->get_value_as_int ()); + } +}