X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Froute_ui.cc;h=cceb71dd5fd58a513cf18ee02fec0127205b4f8c;hb=80fa696564a2b261b6cf751ff61e4d885d3a2dc0;hp=424e59aee4c4b32965958550519431b79fe3ce8d;hpb=f4b5f4c72ee60b6f509e307c5bfd164108d1f30b;p=ardour.git diff --git a/gtk2_ardour/route_ui.cc b/gtk2_ardour/route_ui.cc index 424e59aee4..cceb71dd5f 100644 --- a/gtk2_ardour/route_ui.cc +++ b/gtk2_ardour/route_ui.cc @@ -17,74 +17,123 @@ */ +#include +#include + #include #include #include #include #include #include +#include -#include "ardour/route_group.h" -#include "ardour/dB.h" #include "pbd/memento_command.h" #include "pbd/stacktrace.h" #include "pbd/controllable.h" #include "pbd/enumwriter.h" -#include "ardour_ui.h" -#include "editor.h" -#include "route_ui.h" -#include "ardour_button.h" -#include "keyboard.h" -#include "utils.h" -#include "prompter.h" -#include "gui_thread.h" -#include "ardour_dialog.h" -#include "latency_gui.h" -#include "mixer_strip.h" -#include "automation_time_axis.h" -#include "route_time_axis.h" -#include "group_tabs.h" - +#include "ardour/dB.h" +#include "ardour/route_group.h" +#include "ardour/solo_isolate_control.h" +#include "ardour/vca.h" +#include "ardour/vca_manager.h" #include "ardour/audio_track.h" +#include "ardour/audio_port.h" #include "ardour/audioengine.h" #include "ardour/filename_extensions.h" #include "ardour/midi_track.h" +#include "ardour/monitor_control.h" +#include "ardour/internal_send.h" +#include "ardour/panner_shell.h" +#include "ardour/profile.h" +#include "ardour/phase_control.h" +#include "ardour/send.h" #include "ardour/route.h" #include "ardour/session.h" #include "ardour/template_utils.h" -#include "i18n.h" +#include "ardour_button.h" +#include "ardour_dialog.h" +#include "ardour_ui.h" +#include "automation_time_axis.h" +#include "editor.h" +#include "group_tabs.h" +#include "gui_object.h" +#include "gui_thread.h" +#include "keyboard.h" +#include "latency_gui.h" +#include "mixer_strip.h" +#include "plugin_pin_dialog.h" +#include "prompter.h" +#include "rgb_macros.h" +#include "route_time_axis.h" +#include "route_ui.h" +#include "timers.h" +#include "ui_config.h" +#include "utils.h" + + +#include "pbd/i18n.h" using namespace Gtk; using namespace Gtkmm2ext; using namespace ARDOUR; +using namespace ARDOUR_UI_UTILS; using namespace PBD; +using namespace std; uint32_t RouteUI::_max_invert_buttons = 3; PBD::Signal1 > RouteUI::BusSendDisplayChanged; boost::weak_ptr RouteUI::_showing_sends_to; +std::string RouteUI::program_port_prefix; RouteUI::RouteUI (ARDOUR::Session* sess) - : AxisView(sess) + : monitor_input_button (0) + , monitor_disk_button (0) , mute_menu(0) , solo_menu(0) , sends_menu(0) , record_menu(0) + , comment_window(0) + , comment_area(0) + , input_selector (0) + , output_selector (0) , _invert_menu(0) { - if (sess) init (); + if (program_port_prefix.empty()) { + // compare to gtk2_ardour/port_group.cc + string lpn (PROGRAM_NAME); + boost::to_lower (lpn); + program_port_prefix = lpn + ":"; // e.g. "ardour:" + } + + if (sess) { + init (); + } } RouteUI::~RouteUI() { + if (_route) { + ARDOUR_UI::instance()->gui_object_state->remove_node (route_state_id()); + } + _route.reset (); /* drop reference to route, so that it can be cleaned up */ route_connections.drop_connections (); delete solo_menu; delete mute_menu; delete sends_menu; - delete record_menu; + delete record_menu; + delete comment_window; + delete input_selector; + delete output_selector; + delete monitor_input_button; + delete monitor_disk_button; delete _invert_menu; + + send_blink_connection.disconnect (); + rec_blink_connection.disconnect (); } void @@ -94,24 +143,28 @@ RouteUI::init () mute_menu = 0; solo_menu = 0; sends_menu = 0; - record_menu = 0; + record_menu = 0; _invert_menu = 0; pre_fader_mute_check = 0; post_fader_mute_check = 0; listen_mute_check = 0; main_mute_check = 0; - solo_safe_check = 0; - solo_isolated_check = 0; - solo_isolated_led = 0; - solo_safe_led = 0; + solo_safe_check = 0; + solo_isolated_check = 0; + solo_isolated_led = 0; + solo_safe_led = 0; _solo_release = 0; _mute_release = 0; denormal_menu_item = 0; - step_edit_item = 0; + step_edit_item = 0; + rec_safe_item = 0; multiple_mute_change = false; multiple_solo_change = false; _i_am_the_modifier = 0; + input_selector = 0; + output_selector = 0; + setup_invert_buttons (); mute_button = manage (new ArdourButton); @@ -125,20 +178,24 @@ RouteUI::init () rec_enable_button = manage (new ArdourButton); rec_enable_button->set_name ("record enable button"); - rec_enable_button->set_tweaks (ArdourButton::ImplicitUsesSolidColor); + rec_enable_button->set_icon (ArdourIcon::RecButton); UI::instance()->set_tip (rec_enable_button, _("Enable recording on this track"), ""); + if (UIConfiguration::instance().get_blink_rec_arm()) { + rec_blink_connection = Timers::blink_connect (sigc::mem_fun (*this, &RouteUI::blink_rec_display)); + } + show_sends_button = manage (new ArdourButton); show_sends_button->set_name ("send alert button"); UI::instance()->set_tip (show_sends_button, _("make mixer strips show sends to this bus"), ""); - monitor_input_button = manage (new ArdourButton (ArdourButton::default_elements)); + monitor_input_button = new ArdourButton (ArdourButton::default_elements); monitor_input_button->set_name ("monitor button"); monitor_input_button->set_text (_("In")); UI::instance()->set_tip (monitor_input_button, _("Monitor input"), ""); monitor_input_button->set_no_show_all (true); - - monitor_disk_button = manage (new ArdourButton (ArdourButton::default_elements)); + + monitor_disk_button = new ArdourButton (ArdourButton::default_elements); monitor_disk_button->set_name ("monitor button"); monitor_disk_button->set_text (_("Disk")); UI::instance()->set_tip (monitor_disk_button, _("Monitor playback"), ""); @@ -150,26 +207,27 @@ RouteUI::init () _session->config.ParameterChanged.connect (*this, invalidator (*this), boost::bind (&RouteUI::parameter_changed, this, _1), gui_context()); Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&RouteUI::parameter_changed, this, _1), gui_context()); + UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (this, &RouteUI::parameter_changed)); rec_enable_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press), false); rec_enable_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release), false); show_sends_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_press), false); - show_sends_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release)); + show_sends_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release), false); solo_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press), false); solo_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release), false); mute_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press), false); mute_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release), false); - + monitor_input_button->set_distinct_led_click (false); monitor_disk_button->set_distinct_led_click (false); - monitor_input_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_input_press)); - monitor_input_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_input_release)); + monitor_input_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_input_press), false); + monitor_input_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_input_release), false); - monitor_disk_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_disk_press)); - monitor_disk_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_disk_release)); + monitor_disk_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_disk_press), false); + monitor_disk_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::monitor_disk_release), false); BusSendDisplayChanged.connect_same_thread (*this, boost::bind(&RouteUI::bus_send_display_changed, this, _1)); } @@ -202,54 +260,67 @@ RouteUI::set_route (boost::shared_ptr rp) _route = rp; if (set_color_from_route()) { - set_color (unique_random_color()); + set_color (gdk_color_to_rgba (AxisView::unique_random_color ())); } if (self_destruct) { rp->DropReferences.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::self_delete, this), gui_context()); } + delete input_selector; + input_selector = 0; + + delete output_selector; + output_selector = 0; + mute_button->set_controllable (_route->mute_control()); solo_button->set_controllable (_route->solo_control()); _route->active_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_active_changed, this), gui_context()); - _route->mute_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::mute_changed, this, _1), gui_context()); - _route->solo_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); - _route->solo_safe_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); - _route->listen_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); - _route->solo_isolated_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); + _route->comment_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::comment_changed, this), gui_context()); + + _route->mute_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_mute_display, this), gui_context()); + _route->solo_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); + _route->solo_safe_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); + _route->solo_isolate_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context()); + _route->phase_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::polarity_changed, this), gui_context()); + + if (is_track()) { + track()->FreezeChange.connect (*this, invalidator (*this), boost::bind (&RouteUI::map_frozen, this), gui_context()); + track()->TrackModeChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::track_mode_changed, this), gui_context()); + track_mode_changed(); + } - _route->phase_invert_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::polarity_changed, this), gui_context()); - _route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::property_changed, this, _1), gui_context()); + + _route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_property_changed, this, _1), gui_context()); + _route->presentation_info().PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_gui_changed, this, _1), gui_context ()); _route->io_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::setup_invert_buttons, this), gui_context ()); - _route->gui_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_gui_changed, this, _1), gui_context ()); if (_session->writable() && is_track()) { boost::shared_ptr t = boost::dynamic_pointer_cast(_route); - t->RecordEnableChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed, this), gui_context()); - + t->rec_enable_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed, this), gui_context()); + t->rec_safe_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed, this), gui_context()); + rec_enable_button->show(); - rec_enable_button->set_controllable (t->rec_enable_control()); + rec_enable_button->set_controllable (t->rec_enable_control()); if (is_midi_track()) { midi_track()->StepEditStatusChange.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::step_edit_changed, this, _1), gui_context()); } - } + } /* this will work for busses and tracks, and needs to be called to set up the name entry/name label display. */ - update_rec_display (); - if (is_track()) { boost::shared_ptr t = boost::dynamic_pointer_cast(_route); - t->MonitoringChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::monitoring_changed, this), gui_context()); + t->monitoring_control()->Changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_monitoring_display, this), gui_context()); update_monitoring_display (); } @@ -275,6 +346,15 @@ RouteUI::set_route (boost::shared_ptr rp) update_mute_display (); update_solo_display (); + + if (!UIConfiguration::instance().get_blink_rec_arm()) { + blink_rec_display(true); // set initial rec-en button state + } + + check_rec_enable_sensitivity (); + maybe_add_route_print_mgr (); + route_color_changed(); + route_gui_changed (PropertyChange (Properties::selected)); } void @@ -294,121 +374,167 @@ RouteUI::mute_press (GdkEventButton* ev) return true; } - multiple_mute_change = false; - - if (!_i_am_the_modifier) { + //if this is a binding action, let the ArdourButton handle it + if ( BindingProxy::is_bind_action(ev) ) + return false; - if (Keyboard::is_context_menu_event (ev)) { + multiple_mute_change = false; - if (mute_menu == 0){ - build_mute_menu(); - } + if (Keyboard::is_context_menu_event (ev)) { - mute_menu->popup(0,ev->time); + if (mute_menu == 0){ + build_mute_menu(); + } - } else { + mute_menu->popup(0,ev->time); - if (Keyboard::is_button2_event (ev)) { - // Primary-button2 click is the midi binding click - // button2-click is "momentary" + return true; + } else { - if (mute_button->on_button_press_event (ev)) { - return true; - } + if (Keyboard::is_button2_event (ev)) { + // button2-click is "momentary" - _mute_release = new SoloMuteRelease (_route->muted ()); - } + _mute_release = new SoloMuteRelease (_route->mute_control()->muted ()); + } - if (ev->button == 1 || Keyboard::is_button2_event (ev)) { + if (ev->button == 1 || Keyboard::is_button2_event (ev)) { - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { - /* toggle mute on everything (but - * exclude the master and monitor) - * - * because we are going to erase - * elements of the list we need to work - * on a copy. - */ - - boost::shared_ptr copy (new RouteList); + /* toggle mute on everything (but + * exclude the master and monitor) + * + * because we are going to erase + * elements of the list we need to work + * on a copy. + */ - *copy = *_session->get_routes (); + boost::shared_ptr copy (new RouteList); - for (RouteList::iterator i = copy->begin(); i != copy->end(); ) { - if ((*i)->is_master() || (*i)->is_monitor()) { - i = copy->erase (i); - } else { - ++i; - } - } + *copy = *_session->get_routes (); - if (_mute_release) { - _mute_release->routes = copy; + for (RouteList::iterator i = copy->begin(); i != copy->end(); ) { + if ((*i)->is_master() || (*i)->is_monitor()) { + i = copy->erase (i); + } else { + ++i; } + } - _session->set_mute (copy, !_route->muted()); - - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - - /* Primary-button1 applies change to the mix group even if it is not active - NOTE: Primary-button2 is MIDI learn. - */ + if (_mute_release) { + _mute_release->routes = copy; + } - boost::shared_ptr rl; + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (copy, &Stripable::mute_control), _route->muted_by_self() ? 0.0 : 1.0, Controllable::UseGroup); - if (ev->button == 1) { + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - if (_route->route_group()) { - - rl = _route->route_group()->route_list(); - - if (_mute_release) { - _mute_release->routes = rl; - } - } else { - rl.reset (new RouteList); - rl->push_back (_route); - } + /* Primary-button1 inverts the implication of + the group being active. If the group is + active (for mute), then this modifier means + "do not apply to mute". If the group is + inactive (for mute), then this modifier + means "apply to route". This is all + accomplished by passing just the actual + route, along with the InverseGroup group + control disposition. - _session->set_mute (rl, !_route->muted(), Session::rt_cleanup, true); - } + NOTE: Primary-button2 is MIDI learn. + */ - } else { + boost::shared_ptr rl; - /* plain click applies change to this route */ + if (ev->button == 1) { - boost::shared_ptr rl (new RouteList); + rl.reset (new RouteList); rl->push_back (_route); - + if (_mute_release) { _mute_release->routes = rl; } - _session->set_mute (rl, !_route->muted()); + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (rl, &Stripable::mute_control), _route->muted_by_self() ? 0.0 : 1.0, Controllable::InverseGroup); + } + + } else { + + /* plain click applies change to this route */ + boost::shared_ptr rl (new RouteList); + rl->push_back (_route); + + if (_mute_release) { + _mute_release->routes = rl; } + + _route->mute_control()->set_value (!_route->muted_by_self(), Controllable::UseGroup); } } - } - return true; + return false; } bool -RouteUI::mute_release (GdkEventButton*) +RouteUI::mute_release (GdkEventButton* /*ev*/) +{ + if (_mute_release){ + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (_mute_release->routes, &Stripable::mute_control), _mute_release->active, Controllable::UseGroup); + delete _mute_release; + _mute_release = 0; + } + + return false; +} + +void +RouteUI::edit_output_configuration () { - if (!_i_am_the_modifier) { - if (_mute_release){ - _session->set_mute (_mute_release->routes, _mute_release->active, Session::rt_cleanup, true); - delete _mute_release; - _mute_release = 0; + if (output_selector == 0) { + + boost::shared_ptr send; + boost::shared_ptr output; + + if ((send = boost::dynamic_pointer_cast(_current_delivery)) != 0) { + if (!boost::dynamic_pointer_cast(send)) { + output = send->output(); + } else { + output = _route->output (); + } + } else { + output = _route->output (); } + + output_selector = new IOSelectorWindow (_session, output); } - return true; + if (output_selector->is_visible()) { + output_selector->get_toplevel()->get_window()->raise(); + } else { + output_selector->present (); + } + + //output_selector->set_keep_above (true); +} + +void +RouteUI::edit_input_configuration () +{ + if (input_selector == 0) { + input_selector = new IOSelectorWindow (_session, _route->input()); + } + + if (input_selector->is_visible()) { + input_selector->get_toplevel()->get_window()->raise(); + } else { + input_selector->present (); + } + + //input_selector->set_keep_above (true); } bool @@ -420,164 +546,157 @@ RouteUI::solo_press(GdkEventButton* ev) return true; } + //if this is a binding action, let the ArdourButton handle it + if ( BindingProxy::is_bind_action(ev) ) + return false; + multiple_solo_change = false; - if (!_i_am_the_modifier) { + if (Keyboard::is_context_menu_event (ev)) { - if (Keyboard::is_context_menu_event (ev)) { + if (! (solo_isolated_led && solo_isolated_led->is_visible()) || + ! (solo_safe_led && solo_safe_led->is_visible())) { - if (! (solo_isolated_led && solo_isolated_led->is_visible()) || - ! (solo_safe_led && solo_safe_led->is_visible())) { + if (solo_menu == 0) { + build_solo_menu (); + } - if (solo_menu == 0) { - build_solo_menu (); - } + solo_menu->popup (1, ev->time); + } - solo_menu->popup (1, ev->time); - } + } else { - } else { + if (Keyboard::is_button2_event (ev)) { - if (Keyboard::is_button2_event (ev)) { + // button2-click is "momentary" + _solo_release = new SoloMuteRelease (_route->self_soloed()); + } - // Primary-button2 click is the midi binding click - // button2-click is "momentary" + if (ev->button == 1 || Keyboard::is_button2_event (ev)) { - if (solo_button->on_button_press_event (ev)) { - return true; - } + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { - _solo_release = new SoloMuteRelease (_route->self_soloed()); - } + /* Primary-Tertiary-click applies change to all routes */ - if (ev->button == 1 || Keyboard::is_button2_event (ev)) { + if (_solo_release) { + _solo_release->routes = _session->get_routes (); + } - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (_session->get_routes(), &Stripable::solo_control), !_route->solo_control()->get_value(), Controllable::UseGroup); - /* Primary-Tertiary-click applies change to all routes */ + } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { - if (_solo_release) { - _solo_release->routes = _session->get_routes (); - } + // Primary-Secondary-click: exclusively solo this track - if (Config->get_solo_control_is_listen_control()) { - _session->set_listen (_session->get_routes(), !_route->listening_via_monitor(), Session::rt_cleanup, true); - } else { - _session->set_solo (_session->get_routes(), !_route->self_soloed(), Session::rt_cleanup, true); - } + if (_solo_release) { + _solo_release->exclusive = true; + + boost::shared_ptr routes = _session->get_routes(); - } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { + for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) { + if ((*i)->soloed ()) { + _solo_release->routes_on->push_back (*i); + } else { + _solo_release->routes_off->push_back (*i); + } + } + } - // Primary-Secondary-click: exclusively solo this track + if (Config->get_solo_control_is_listen_control()) { + /* ??? we need a just_one_listen() method */ + } else { + DisplaySuspender ds; + _route->solo_control()->set_value (1.0, Controllable::NoGroup); + } - if (_solo_release) { - _solo_release->exclusive = true; + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { - boost::shared_ptr routes = _session->get_routes(); + // shift-click: toggle solo isolated status - for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) { - if ((*i)->soloed ()) { - _solo_release->routes_on->push_back (*i); - } else { - _solo_release->routes_off->push_back (*i); - } - } - } + _route->solo_isolate_control()->set_value (_route->solo_isolate_control()->get_value() ? 0.0 : 1.0, Controllable::UseGroup); + delete _solo_release; + _solo_release = 0; - if (Config->get_solo_control_is_listen_control()) { - /* ??? we need a just_one_listen() method */ - } else { - _session->set_just_one_solo (_route, true); - } + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { + /* Primary-button1: solo mix group. + NOTE: Primary-button2 is MIDI learn. + */ - // shift-click: toggle solo isolated status + /* Primary-button1 applies change to the mix group even if it is not active + NOTE: Primary-button2 is MIDI learn. + */ - _route->set_solo_isolated (!_route->solo_isolated(), this); - delete _solo_release; - _solo_release = 0; + boost::shared_ptr rl; - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { + if (ev->button == 1) { - /* Primary-button1: solo mix group. - NOTE: Primary-button2 is MIDI learn. - */ + /* Primary-button1 inverts the implication of + the group being active. If the group is + active (for solo), then this modifier means + "do not apply to solo". If the group is + inactive (for mute), then this modifier + means "apply to route". This is all + accomplished by passing just the actual + route, along with the InverseGroup group + control disposition. - /* Primary-button1 applies change to the mix group even if it is not active NOTE: Primary-button2 is MIDI learn. */ - boost::shared_ptr rl; + rl.reset (new RouteList); + rl->push_back (_route); - if (ev->button == 1) { + if (_solo_release) { + _solo_release->routes = rl; + } - if (_route->route_group()) { - - rl = _route->route_group()->route_list(); - - if (_solo_release) { - _solo_release->routes = rl; - } - } else { - rl.reset (new RouteList); - rl->push_back (_route); - } + DisplaySuspender ds; - if (Config->get_solo_control_is_listen_control()) { - _session->set_listen (rl, !_route->listening_via_monitor(), Session::rt_cleanup, true); - } else { - _session->set_solo (rl, !_route->self_soloed(), Session::rt_cleanup, true); - } - } + _session->set_controls (route_list_to_control_list (rl, &Stripable::solo_control), !_route->self_soloed(), Controllable::InverseGroup); + } - } else { + delete _solo_release; + _solo_release = 0; - /* click: solo this route */ + } else { - boost::shared_ptr rl (new RouteList); - rl->push_back (route()); + /* click: solo this route */ - if (_solo_release) { - _solo_release->routes = rl; - } + boost::shared_ptr rl (new RouteList); + rl->push_back (route()); - if (Config->get_solo_control_is_listen_control()) { - _session->set_listen (rl, !_route->listening_via_monitor()); - } else { - _session->set_solo (rl, !_route->self_soloed()); - } + if (_solo_release) { + _solo_release->routes = rl; } + + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (rl, &Stripable::solo_control), !_route->self_soloed(), Controllable::UseGroup); } } } - return true; + return false; } bool -RouteUI::solo_release (GdkEventButton*) +RouteUI::solo_release (GdkEventButton* /*ev*/) { - if (!_i_am_the_modifier) { - - if (_solo_release) { + if (_solo_release) { - if (_solo_release->exclusive) { - - } else { - if (Config->get_solo_control_is_listen_control()) { - _session->set_listen (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true); - } else { - _session->set_solo (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true); - } - } + if (_solo_release->exclusive) { - delete _solo_release; - _solo_release = 0; + } else { + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (_solo_release->routes, &Stripable::solo_control), _solo_release->active ? 1.0 : 0.0, Controllable::UseGroup); } + + delete _solo_release; + _solo_release = 0; } - return true; + return false; } bool @@ -587,32 +706,37 @@ RouteUI::rec_enable_press(GdkEventButton* ev) return true; } + //if this is a binding action, let the ArdourButton handle it + if ( BindingProxy::is_bind_action(ev) ) + return false; + if (!_session->engine().connected()) { - MessageDialog msg (_("Not connected to JACK - cannot engage record")); + MessageDialog msg (_("Not connected to AudioEngine - cannot engage record")); msg.run (); - return true; + return false; } - if (is_midi_track()) { + if (is_midi_track()) { - /* rec-enable button exits from step editing */ + /* rec-enable button exits from step editing */ - if (midi_track()->step_editing()) { + if (midi_track()->step_editing()) { midi_track()->set_step_editing (false); - return true; - } - } + return false; + } + } - if (!_i_am_the_modifier && is_track() && rec_enable_button) { + if (is_track() && rec_enable_button) { if (Keyboard::is_button2_event (ev)) { - // do nothing on midi sigc::bind event - return rec_enable_button->on_button_press_event (ev); + //rec arm does not have a momentary mode + return false; } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { - _session->set_record_enabled (_session->get_routes(), !rec_enable_button->active_state()); + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (_session->get_routes(), &Stripable::rec_enable_control), !track()->rec_enable_control()->get_value(), Controllable::NoGroup); } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { @@ -623,17 +747,12 @@ RouteUI::rec_enable_press(GdkEventButton* ev) if (ev->button == 1) { boost::shared_ptr rl; - - if (_route->route_group()) { - - rl = _route->route_group()->route_list(); - - } else { - rl.reset (new RouteList); - rl->push_back (_route); - } - - _session->set_record_enabled (rl, !rec_enable_button->active_state(), Session::rt_cleanup, true); + + rl.reset (new RouteList); + rl->push_back (_route); + + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), !track()->rec_enable_control()->get_value(), Controllable::InverseGroup); } } else if (Keyboard::is_context_menu_event (ev)) { @@ -642,19 +761,12 @@ RouteUI::rec_enable_press(GdkEventButton* ev) } else { - boost::shared_ptr rl (new RouteList); - rl->push_back (route()); - _session->set_record_enabled (rl, !rec_enable_button->active_state()); + boost::shared_ptr trk = track(); + trk->rec_enable_control()->set_value (!trk->rec_enable_control()->get_value(), Controllable::UseGroup); } } - return true; -} - -void -RouteUI::monitoring_changed () -{ - update_monitoring_display (); + return false; } void @@ -672,7 +784,7 @@ RouteUI::update_monitoring_display () MonitorState ms = t->monitoring_state(); - if (t->monitoring_choice() & MonitorInput) { + if (t->monitoring_control()->monitoring_choice() & MonitorInput) { monitor_input_button->set_active_state (Gtkmm2ext::ExplicitActive); } else { if (ms & MonitoringInput) { @@ -682,7 +794,7 @@ RouteUI::update_monitoring_display () } } - if (t->monitoring_choice() & MonitorDisk) { + if (t->monitoring_control()->monitoring_choice() & MonitorDisk) { monitor_disk_button->set_active_state (Gtkmm2ext::ExplicitActive); } else { if (ms & MonitoringDisk) { @@ -696,7 +808,7 @@ RouteUI::update_monitoring_display () bool RouteUI::monitor_input_press(GdkEventButton*) { - return true; + return false; } bool @@ -708,7 +820,7 @@ RouteUI::monitor_input_release(GdkEventButton* ev) bool RouteUI::monitor_disk_press (GdkEventButton*) { - return true; + return false; } bool @@ -719,7 +831,7 @@ RouteUI::monitor_disk_release (GdkEventButton* ev) bool RouteUI::monitor_release (GdkEventButton* ev, MonitorChoice monitor_choice) -{ +{ if (ev->button != 1) { return false; } @@ -732,21 +844,21 @@ RouteUI::monitor_release (GdkEventButton* ev, MonitorChoice monitor_choice) MonitorChoice mc; boost::shared_ptr rl; - - /* XXX for now, monitoring choices are orthogonal. cue monitoring + + /* XXX for now, monitoring choices are orthogonal. cue monitoring will follow in 3.X but requires mixing the input and playback (disk) signal together, which requires yet more buffers. */ - if (t->monitoring_choice() & monitor_choice) { - mc = MonitorChoice (t->monitoring_choice() & ~monitor_choice); + if (t->monitoring_control()->monitoring_choice() & monitor_choice) { + mc = MonitorChoice (t->monitoring_control()->monitoring_choice() & ~monitor_choice); } else { /* this line will change when the options are non-orthogonal */ // mc = MonitorChoice (t->monitoring_choice() | monitor_choice); mc = monitor_choice; } - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { rl = _session->get_routes (); } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { @@ -761,89 +873,113 @@ RouteUI::monitor_release (GdkEventButton* ev, MonitorChoice monitor_choice) rl->push_back (route()); } - _session->set_monitoring (rl, mc, Session::rt_cleanup, true); + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (rl, &Stripable::monitoring_control), (double) mc, Controllable::UseGroup); - return true; + return false; } void RouteUI::build_record_menu () { - if (record_menu) { - return; - } + if (!record_menu) { + record_menu = new Menu; + record_menu->set_name ("ArdourContextMenu"); + using namespace Menu_Helpers; + MenuList& items = record_menu->items(); - /* no rec-button context menu for non-MIDI tracks - */ - - if (is_midi_track()) { - record_menu = new Menu; - record_menu->set_name ("ArdourContextMenu"); + items.push_back (CheckMenuElem (_("Rec-Safe"), sigc::mem_fun (*this, &RouteUI::toggle_rec_safe))); + rec_safe_item = dynamic_cast (&items.back()); - using namespace Menu_Helpers; - MenuList& items = record_menu->items(); + if (is_midi_track()) { + items.push_back (SeparatorElem()); + items.push_back (CheckMenuElem (_("Step Entry"), sigc::mem_fun (*this, &RouteUI::toggle_step_edit))); + step_edit_item = dynamic_cast (&items.back()); + } + } - items.push_back (CheckMenuElem (_("Step Entry"), sigc::mem_fun (*this, &RouteUI::toggle_step_edit))); - step_edit_item = dynamic_cast (&items.back()); + if (step_edit_item) { + if (track()->rec_enable_control()->get_value()) { + step_edit_item->set_sensitive (false); + } + step_edit_item->set_active (midi_track()->step_editing()); + } + if (rec_safe_item) { + rec_safe_item->set_sensitive (!_route->rec_enable_control()->get_value()); + rec_safe_item->set_active (_route->rec_safe_control()->get_value()); + } +} - if (_route->record_enabled()) { - step_edit_item->set_sensitive (false); - } +void +RouteUI::toggle_step_edit () +{ + if (!is_midi_track() || track()->rec_enable_control()->get_value()) { + return; + } - step_edit_item->set_active (midi_track()->step_editing()); - } + midi_track()->set_step_editing (step_edit_item->get_active()); } void -RouteUI::toggle_step_edit () +RouteUI::toggle_rec_safe () { - if (!is_midi_track() || _route->record_enabled()) { - return; - } + boost::shared_ptr rs = _route->rec_safe_control(); + + if (!rs) { + return; + } + + /* This check is made inside the control too, but dong it here can't + * hurt. + */ - midi_track()->set_step_editing (step_edit_item->get_active()); + if (_route->rec_enable_control()->get_value()) { + return; + } + + rs->set_value (rec_safe_item->get_active (), Controllable::UseGroup); } void RouteUI::step_edit_changed (bool yn) { - if (yn) { - if (rec_enable_button) { - rec_enable_button->set_active_state (Gtkmm2ext::ExplicitActive); - } + if (yn) { + if (rec_enable_button) { + rec_enable_button->set_active_state (Gtkmm2ext::ExplicitActive); + } - start_step_editing (); + start_step_editing (); - if (step_edit_item) { - step_edit_item->set_active (true); - } + if (step_edit_item) { + step_edit_item->set_active (true); + } - } else { + } else { - if (rec_enable_button) { - rec_enable_button->unset_active_state (); - } + if (rec_enable_button) { + rec_enable_button->unset_active_state (); + } - stop_step_editing (); + stop_step_editing (); - if (step_edit_item) { - step_edit_item->set_active (false); - } - } + if (step_edit_item) { + step_edit_item->set_active (false); + } + } } bool RouteUI::rec_enable_release (GdkEventButton* ev) { - if (Keyboard::is_context_menu_event (ev)) { - build_record_menu (); - if (record_menu) { - record_menu->popup (1, ev->time); - } - return true; - } + if (Keyboard::is_context_menu_event (ev)) { + build_record_menu (); + if (record_menu) { + record_menu->popup (1, ev->time); + } + return false; + } - return true; + return false; } void @@ -944,7 +1080,7 @@ RouteUI::show_sends_press(GdkEventButton* ev) return true; } - if (!_i_am_the_modifier && !is_track() && show_sends_button) { + if (!is_track() && show_sends_button) { if (Keyboard::is_button2_event (ev) && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { @@ -995,41 +1131,42 @@ RouteUI::send_blink (bool onoff) } Gtkmm2ext::ActiveState -RouteUI::solo_active_state (boost::shared_ptr r) +RouteUI::solo_active_state (boost::shared_ptr s) { - if (r->is_master() || r->is_monitor()) { + boost::shared_ptr sc = s->solo_control(); + + if (!sc) { return Gtkmm2ext::Off; } - if (Config->get_solo_control_is_listen_control()) { - - if (r->listening_via_monitor()) { - return Gtkmm2ext::ExplicitActive; - } else { - return Gtkmm2ext::Off; - } - + if (!sc->can_solo()) { + return Gtkmm2ext::Off; } - if (r->soloed()) { - if (!r->self_soloed()) { - return Gtkmm2ext::ImplicitActive; - } else { - return Gtkmm2ext::ExplicitActive; - } + + if (sc->self_soloed()) { + return Gtkmm2ext::ExplicitActive; + } else if (sc->soloed_by_others()) { + return Gtkmm2ext::ImplicitActive; } else { return Gtkmm2ext::Off; } } Gtkmm2ext::ActiveState -RouteUI::solo_isolate_active_state (boost::shared_ptr r) +RouteUI::solo_isolate_active_state (boost::shared_ptr s) { - if (r->is_master() || r->is_monitor()) { + boost::shared_ptr sc = s->solo_isolate_control(); + + if (!sc) { + return Gtkmm2ext::Off; + } + + if (s->is_master() || s->is_monitor()) { return Gtkmm2ext::Off; } - if (r->solo_isolated()) { + if (sc->solo_isolated()) { return Gtkmm2ext::ExplicitActive; } else { return Gtkmm2ext::Off; @@ -1037,13 +1174,19 @@ RouteUI::solo_isolate_active_state (boost::shared_ptr r) } Gtkmm2ext::ActiveState -RouteUI::solo_safe_active_state (boost::shared_ptr r) +RouteUI::solo_safe_active_state (boost::shared_ptr s) { - if (r->is_master() || r->is_monitor()) { + boost::shared_ptr sc = s->solo_safe_control(); + + if (!sc) { + return Gtkmm2ext::Off; + } + + if (s->is_master() || s->is_monitor()) { return Gtkmm2ext::Off; } - if (r->solo_safe()) { + if (sc->solo_safe()) { return Gtkmm2ext::ExplicitActive; } else { return Gtkmm2ext::Off; @@ -1053,13 +1196,13 @@ RouteUI::solo_safe_active_state (boost::shared_ptr r) void RouteUI::update_solo_display () { - bool yn = _route->solo_safe (); + bool yn = _route->solo_safe_control()->solo_safe (); if (solo_safe_check && solo_safe_check->get_active() != yn) { solo_safe_check->set_active (yn); } - yn = _route->solo_isolated (); + yn = _route->solo_isolate_control()->solo_isolated (); if (solo_isolated_check && solo_isolated_check->get_active() != yn) { solo_isolated_check->set_active (yn); @@ -1068,7 +1211,7 @@ RouteUI::update_solo_display () set_button_names (); if (solo_isolated_led) { - if (_route->solo_isolated()) { + if (_route->solo_isolate_control()->solo_isolated()) { solo_isolated_led->set_active_state (Gtkmm2ext::ExplicitActive); } else { solo_isolated_led->unset_active_state (); @@ -1076,7 +1219,7 @@ RouteUI::update_solo_display () } if (solo_safe_led) { - if (_route->solo_safe()) { + if (_route->solo_safe_control()->solo_safe()) { solo_safe_led->set_active_state (Gtkmm2ext::ExplicitActive); } else { solo_safe_led->unset_active_state (); @@ -1088,36 +1231,35 @@ RouteUI::update_solo_display () /* some changes to solo status can affect mute display, so catch up */ - update_mute_display (); -} - -void -RouteUI::solo_changed_so_update_mute () -{ update_mute_display (); } void -RouteUI::mute_changed(void* /*src*/) +RouteUI::solo_changed_so_update_mute () { update_mute_display (); } ActiveState -RouteUI::mute_active_state (Session* s, boost::shared_ptr r) +RouteUI::mute_active_state (Session*, boost::shared_ptr s) { - if (r->is_monitor()) { - return ActiveState(0); + boost::shared_ptr mc = s->mute_control(); + + if (s->is_monitor()) { + return Gtkmm2ext::Off; } + if (!mc) { + return Gtkmm2ext::Off; + } if (Config->get_show_solo_mutes() && !Config->get_solo_control_is_listen_control ()) { - if (r->muted ()) { + if (mc->muted_by_self ()) { /* full mute */ return Gtkmm2ext::ExplicitActive; - } else if (!r->is_master() && s->soloing() && !r->soloed() && !r->solo_isolated()) { - /* master is NEVER muted by others */ + } else if (mc->muted_by_others_soloing () || mc->muted_by_masters ()) { + /* this will reflect both solo mutes AND master mutes */ return Gtkmm2ext::ImplicitActive; } else { /* no mute at all */ @@ -1126,9 +1268,12 @@ RouteUI::mute_active_state (Session* s, boost::shared_ptr r) } else { - if (r->muted()) { + if (mc->muted_by_self()) { /* full mute */ return Gtkmm2ext::ExplicitActive; + } else if (mc->muted_by_masters ()) { + /* this shows only master mutes, not mute-by-others-soloing */ + return Gtkmm2ext::ImplicitActive; } else { /* no mute at all */ return Gtkmm2ext::Off; @@ -1148,28 +1293,35 @@ RouteUI::update_mute_display () mute_button->set_active_state (mute_active_state (_session, _route)); } + void RouteUI::route_rec_enable_changed () { - update_rec_display (); - update_monitoring_display (); + blink_rec_display (true); //this lets the button change "immediately" rather than wait for the next blink } void RouteUI::session_rec_enable_changed () { - update_rec_display (); - update_monitoring_display (); + blink_rec_display (true); //this lets the button change "immediately" rather than wait for the next blink } void -RouteUI::update_rec_display () +RouteUI::blink_rec_display (bool blinkOn) { if (!rec_enable_button || !_route) { return; } - if (_route->record_enabled()) { + if (boost::dynamic_pointer_cast(_current_delivery)) { + return; + } + + if (!is_track()) { + return; + } + + if (track()->rec_enable_control()->get_value()) { switch (_session->record_status ()) { case Session::Recording: rec_enable_button->set_active_state (Gtkmm2ext::ExplicitActive); @@ -1177,9 +1329,12 @@ RouteUI::update_rec_display () case Session::Disabled: case Session::Enabled: - rec_enable_button->set_active_state (Gtkmm2ext::ImplicitActive); + if (UIConfiguration::instance().get_blink_rec_arm()) { + rec_enable_button->set_active_state ( blinkOn ? Gtkmm2ext::ExplicitActive : Gtkmm2ext::Off ); + } else { + rec_enable_button->set_active_state ( ImplicitActive ); + } break; - } if (step_edit_item) { @@ -1194,7 +1349,6 @@ RouteUI::update_rec_display () } } - check_rec_enable_sensitivity (); } @@ -1209,14 +1363,14 @@ RouteUI::build_solo_menu (void) Gtk::CheckMenuItem* check; check = new Gtk::CheckMenuItem(_("Solo Isolate")); - check->set_active (_route->solo_isolated()); + check->set_active (_route->solo_isolate_control()->solo_isolated()); check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated), check)); items.push_back (CheckMenuElem(*check)); solo_isolated_check = dynamic_cast(&items.back()); check->show_all(); check = new Gtk::CheckMenuItem(_("Solo Safe")); - check->set_active (_route->solo_safe()); + check->set_active (_route->solo_safe_control()->solo_safe()); check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe), check)); items.push_back (CheckMenuElem(*check)); solo_safe_check = dynamic_cast(&items.back()); @@ -1237,13 +1391,13 @@ RouteUI::build_mute_menu(void) MenuList& items = mute_menu->items(); - pre_fader_mute_check = manage (new Gtk::CheckMenuItem(_("Pre Fader"))); + pre_fader_mute_check = manage (new Gtk::CheckMenuItem(_("Pre Fader Sends"))); init_mute_menu(MuteMaster::PreFader, pre_fader_mute_check); pre_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::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 Gtk::CheckMenuItem(_("Post Fader"))); + post_fader_mute_check = manage (new Gtk::CheckMenuItem(_("Post Fader Sends"))); init_mute_menu(MuteMaster::PostFader, post_fader_mute_check); post_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PostFader, post_fader_mute_check)); items.push_back (CheckMenuElem(*post_fader_mute_check)); @@ -1270,16 +1424,16 @@ RouteUI::build_mute_menu(void) void RouteUI::init_mute_menu(MuteMaster::MutePoint mp, Gtk::CheckMenuItem* check) { - check->set_active (_route->mute_points() & mp); + check->set_active (_route->mute_control()->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)); + _route->mute_control()->set_mute_points (MuteMaster::MutePoint (_route->mute_control()->mute_points() | mp)); } else { - _route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() & ~mp)); + _route->mute_control()->set_mute_points (MuteMaster::MutePoint (_route->mute_control()->mute_points() & ~mp)); } } @@ -1289,7 +1443,7 @@ RouteUI::muting_change () ENSURE_GUI_THREAD (*this, &RouteUI::muting_change) bool yn; - MuteMaster::MutePoint current = _route->mute_points (); + MuteMaster::MutePoint current = _route->mute_control()->mute_points (); yn = (current & MuteMaster::PreFader); @@ -1319,45 +1473,80 @@ RouteUI::muting_change () bool RouteUI::solo_isolate_button_release (GdkEventButton* ev) { - if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) { - return true; - } + if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) { + return true; + } - bool view = solo_isolated_led->active_state(); - bool model = _route->solo_isolated(); + bool view = solo_isolated_led->active_state(); + bool model = _route->solo_isolate_control()->solo_isolated(); - /* called BEFORE the view has changed */ + /* called BEFORE the view has changed */ - if (ev->button == 1) { - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + if (ev->button == 1) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { - if (model) { - /* disable isolate for all routes */ - _session->set_solo_isolated (_session->get_routes(), false, Session::rt_cleanup, true); - } + if (model) { + /* disable isolate for all routes */ + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (_session->get_routes(), &Stripable::solo_isolate_control), 0.0, Controllable::NoGroup); + } else { + /* enable isolate for all routes */ + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (_session->get_routes(), &Stripable::solo_isolate_control), 1.0, Controllable::NoGroup); + } - } else { - if (model == view) { + } else { - /* flip just this route */ + if (model == view) { - boost::shared_ptr rl (new RouteList); - rl->push_back (_route); - _session->set_solo_isolated (rl, !view, Session::rt_cleanup, true); - } - } - } + /* flip just this route */ + + boost::shared_ptr rl (new RouteList); + rl->push_back (_route); + DisplaySuspender ds; + _session->set_controls (route_list_to_control_list (rl, &Stripable::solo_isolate_control), view ? 0.0 : 1.0, Controllable::NoGroup); + } + } + } - return true; + return false; } bool RouteUI::solo_safe_button_release (GdkEventButton* ev) { - if (ev->button == 1) { - _route->set_solo_safe (!solo_safe_led->active_state(), this); + if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) { return true; } + + bool view = solo_safe_led->active_state(); + bool model = _route->solo_safe_control()->solo_safe(); + + if (ev->button == 1) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + boost::shared_ptr rl (_session->get_routes()); + if (model) { + /* disable solo safe for all routes */ + DisplaySuspender ds; + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + (*i)->solo_safe_control()->set_value (0.0, Controllable::NoGroup); + } + } else { + /* enable solo safe for all routes */ + DisplaySuspender ds; + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + (*i)->solo_safe_control()->set_value (1.0, Controllable::NoGroup); + } + } + } + else { + if (model == view) { + /* flip just this route */ + _route->solo_safe_control()->set_value (view ? 0.0 : 1.0, Controllable::NoGroup); + } + } + } + return false; } @@ -1365,34 +1554,32 @@ void RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem* check) { bool view = check->get_active(); - bool model = _route->solo_isolated(); + bool model = _route->solo_isolate_control()->solo_isolated(); /* called AFTER the view has changed */ if (model != view) { - _route->set_solo_isolated (view, this); + _route->solo_isolate_control()->set_value (view ? 1.0 : 0.0, Controllable::UseGroup); } } void RouteUI::toggle_solo_safe (Gtk::CheckMenuItem* check) { - _route->set_solo_safe (check->get_active(), this); + _route->solo_safe_control()->set_value (check->get_active() ? 1.0 : 0.0, Controllable::UseGroup); } -/** Ask the user to choose a colour, and then set all selected tracks - * to that colour. +/** Ask the user to choose a colour, and then apply that color to my route */ void RouteUI::choose_color () { bool picked; - Gdk::Color const color = Gtkmm2ext::UI::instance()->get_color (_("Color Selection"), picked, &_color); + Gdk::Color c (gdk_color_from_rgb (_route->presentation_info().color())); + Gdk::Color const color = Gtkmm2ext::UI::instance()->get_color (_("Color Selection"), picked, &c); if (picked) { - ARDOUR_UI::instance()->the_editor().get_selection().tracks.foreach_route_ui ( - boost::bind (&RouteUI::set_color, _1, color) - ); + set_color (gdk_color_to_rgba (color)); } } @@ -1400,22 +1587,9 @@ RouteUI::choose_color () * the route is in a group which shares its color with its routes. */ void -RouteUI::set_color (const Gdk::Color & c) +RouteUI::set_color (uint32_t c) { - /* leave _color alone in the group case so that tracks can retain their - * own pre-group colors. - */ - - char buf[64]; - _color = c; - snprintf (buf, sizeof (buf), "%d:%d:%d", c.get_red(), c.get_green(), c.get_blue()); - - /* note: we use the route state ID here so that color is the same for both - the time axis view and the mixer strip - */ - - gui_object_state().set_property (route_state_id(), X_("color"), buf); - _route->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */ + _route->presentation_info().set_color (c); } /** @return GUI state ID for things that are common to the route in all its representations */ @@ -1428,80 +1602,11 @@ RouteUI::route_state_id () const int RouteUI::set_color_from_route () { - const string str = gui_object_state().get_string (route_state_id(), X_("color")); - - if (str.empty()) { - return 1; - } - - int r, g, b; - - sscanf (str.c_str(), "%d:%d:%d", &r, &g, &b); - - _color.set_red (r); - _color.set_green (g); - _color.set_blue (b); - - return 0; -} - -void -RouteUI::remove_this_route (bool apply_to_selection) -{ - if (apply_to_selection) { - ARDOUR_UI::instance()->the_editor().get_selection().tracks.foreach_route_ui (boost::bind (&RouteUI::remove_this_route, _1, false)); - } else { - if ((route()->is_master() || route()->is_monitor()) && - !Config->get_allow_special_bus_removal()) { - MessageDialog msg (_("That would be bad news ...."), - false, - Gtk::MESSAGE_INFO, - Gtk::BUTTONS_OK); - msg.set_secondary_text (string_compose (_( -"Removing the master or monitor bus is such a bad idea\n\ -that %1 is not going to allow it.\n\ -\n\ -If you really want to do this sort of thing\n\ -edit your ardour.rc file to set the\n\ -\"allow-special-bus-removal\" option to be \"yes\""), PROGRAM_NAME)); - - msg.present (); - msg.run (); - return; - } - - vector choices; - string prompt; - - if (is_track()) { - prompt = string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n\n(This action cannot be undone, and the session file will be overwritten)"), _route->name()); - } else { - prompt = string_compose (_("Do you really want to remove bus \"%1\" ?\n\n(This action cannot be undone, and the session file will be overwritten)"), _route->name()); - } - - choices.push_back (_("No, do nothing.")); - choices.push_back (_("Yes, remove it.")); - - string title; - if (is_track()) { - title = _("Remove track"); - } else { - title = _("Remove bus"); - } - - Choice prompter (title, prompt, choices); - - if (prompter.run () == 1) { - Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this)); - } + if (_route->presentation_info().color_set()) { + return 0; /* nothing to do */ } -} -gint -RouteUI::idle_remove_this_route (RouteUI *rui) -{ - rui->_session->remove_route (rui->route()); - return false; + return 1; /* pick a color */ } /** @return true if this name should be used for the route, otherwise false */ @@ -1511,12 +1616,12 @@ RouteUI::verify_new_route_name (const std::string& name) if (name.find (':') == string::npos) { return true; } - + MessageDialog colon_msg ( _("The use of colons (':') is discouraged in track and bus names.\nDo you want to use this new name?"), false, MESSAGE_QUESTION, BUTTONS_NONE ); - + colon_msg.add_button (_("Use the new name"), Gtk::RESPONSE_ACCEPT); colon_msg.add_button (_("Re-edit the name"), Gtk::RESPONSE_CANCEL); @@ -1570,11 +1675,74 @@ RouteUI::route_rename () } void -RouteUI::property_changed (const PropertyChange& what_changed) +RouteUI::toggle_comment_editor () +{ +// if (ignore_toggle) { +// return; +// } + + if (comment_window && comment_window->is_visible ()) { + comment_window->hide (); + } else { + open_comment_editor (); + } +} + + +void +RouteUI::open_comment_editor () +{ + if (comment_window == 0) { + setup_comment_editor (); + } + + string title; + title = _route->name(); + title += _(": comment editor"); + + comment_window->set_title (title); + comment_window->present(); +} + +void +RouteUI::setup_comment_editor () +{ + comment_window = new ArdourWindow (""); // title will be reset to show route + comment_window->set_skip_taskbar_hint (true); + comment_window->signal_hide().connect (sigc::mem_fun(*this, &MixerStrip::comment_editor_done_editing)); + comment_window->set_default_size (400, 200); + + comment_area = manage (new TextView()); + comment_area->set_name ("MixerTrackCommentArea"); + comment_area->set_wrap_mode (WRAP_WORD); + comment_area->set_editable (true); + comment_area->get_buffer()->set_text (_route->comment()); + comment_area->show (); + + comment_window->add (*comment_area); +} + +void +RouteUI::comment_changed () +{ + ignore_comment_edit = true; + if (comment_area) { + comment_area->get_buffer()->set_text (_route->comment()); + } + ignore_comment_edit = false; +} + +void +RouteUI::comment_editor_done_editing () { - if (what_changed.contains (ARDOUR::Properties::name)) { - name_label.set_text (_route->name()); + ENSURE_GUI_THREAD (*this, &MixerStrip::comment_editor_done_editing, src) + + string const str = comment_area->get_buffer()->get_text(); + if (str == _route->comment ()) { + return; } + + _route->set_comment (str, this); } void @@ -1587,6 +1755,12 @@ RouteUI::set_route_active (bool a, bool apply_to_selection) } } +void +RouteUI::duplicate_selected_routes () +{ + ARDOUR_UI::instance()->start_duplicate_routes(); +} + void RouteUI::toggle_denormal_protection () { @@ -1664,28 +1838,15 @@ RouteUI::has_audio_outputs () const return (_route->n_outputs().n_audio() > 0); } -string -RouteUI::name() const -{ - return _route->name(); -} - void RouteUI::map_frozen () { ENSURE_GUI_THREAD (*this, &RouteUI::map_frozen) - AudioTrack* at = dynamic_cast(_route.get()); + AudioTrack* at = dynamic_cast(_route.get()); if (at) { - switch (at->freeze_state()) { - case AudioTrack::Frozen: - rec_enable_button->set_sensitive (false); - break; - default: - rec_enable_button->set_sensitive (true); - break; - } + check_rec_enable_sensitivity (); } } @@ -1695,52 +1856,90 @@ RouteUI::adjust_latency () LatencyDialog dialog (_route->name() + _(" latency"), *(_route->output()), _session->frame_rate(), AudioEngine::instance()->samples_per_cycle()); } -void -RouteUI::save_as_template () +bool +RouteUI::process_save_template_prompter (ArdourPrompter& prompter, const std::string& dir) { std::string path; std::string safe_name; - string name; + std::string name; - path = ARDOUR::user_route_template_directory (); + prompter.get_result (name, true); - if (g_mkdir_with_parents (path.c_str(), 0755)) { - error << string_compose (_("Cannot create route template directory %1"), path) << endmsg; - return; + safe_name = legalize_for_path (name); + safe_name += template_suffix; + + path = Glib::build_filename (dir, safe_name); + + if (Glib::file_test (path, Glib::FILE_TEST_EXISTS)) { + bool overwrite = overwrite_file_dialog (prompter, + _("Confirm Template Overwrite"), + _("A template already exists with that name. Do you want to overwrite it?")); + + if (!overwrite) { + return false; + } } - Prompter p (true); // modal + _route->save_as_template (path, name); - p.set_title (_("Save As Template")); - p.set_prompt (_("Template name:")); - p.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT); - switch (p.run()) { - case RESPONSE_ACCEPT: - break; - default: + return true; +} + +void +RouteUI::save_as_template () +{ + std::string dir; + + dir = ARDOUR::user_route_template_directory (); + + if (g_mkdir_with_parents (dir.c_str(), 0755)) { + error << string_compose (_("Cannot create route template directory %1"), dir) << endmsg; return; } - p.hide (); - p.get_result (name, true); - - safe_name = legalize_for_path (name); - safe_name += template_suffix; + ArdourPrompter prompter (true); // modal - path = Glib::build_filename (path, safe_name); + prompter.set_title (_("Save As Template")); + prompter.set_prompt (_("Template name:")); + prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT); - _route->save_as_template (path, name); + bool finished = false; + while (!finished) { + switch (prompter.run()) { + case RESPONSE_ACCEPT: + finished = process_save_template_prompter (prompter, dir); + break; + default: + finished = true; + break; + } + } } void RouteUI::check_rec_enable_sensitivity () { + if (!rec_enable_button) { + assert (0); // This should not happen + return; + } + if (!_session->writable()) { + rec_enable_button->set_sensitive (false); + return; + } + if (_session->transport_rolling() && rec_enable_button->active_state() && Config->get_disable_disarm_during_roll()) { rec_enable_button->set_sensitive (false); + } else if (is_audio_track () && track()->freeze_state() == AudioTrack::Frozen) { + rec_enable_button->set_sensitive (false); } else { rec_enable_button->set_sensitive (true); } - + if (_route && _route->rec_safe_control () && _route->rec_safe_control()->get_value()) { + rec_enable_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive)); + } else { + rec_enable_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive)); + } update_monitoring_display (); } @@ -1755,85 +1954,39 @@ RouteUI::parameter_changed (string const & p) set_button_names (); } else if (p == "auto-input") { update_monitoring_display (); + } else if (p == "blink-rec-arm") { + if (UIConfiguration::instance().get_blink_rec_arm()) { + rec_blink_connection.disconnect (); + rec_blink_connection = Timers::blink_connect (sigc::mem_fun (*this, &RouteUI::blink_rec_display)); + } else { + rec_blink_connection.disconnect (); + RouteUI::blink_rec_display(false); + } } } void RouteUI::step_gain_up () { - _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), this); + _route->gain_control()->set_value (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), Controllable::UseGroup); } void RouteUI::page_gain_up () { - _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), this); + _route->gain_control()->set_value (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), Controllable::UseGroup); } void RouteUI::step_gain_down () { - _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), this); + _route->gain_control()->set_value (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), Controllable::UseGroup); } 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")); - SpinButton* spin = 0; - - dialog.get_vbox()->set_border_width (18); - - if (Config->get_remote_model() == UserOrdered) { - 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:")))); - 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); - } else { - Label* l = manage (new Label()); - if (_route->is_master() || _route->is_monitor()) { - l->set_markup (string_compose (_("The remote control ID of %1 is: %2\n\n\n" - "The remote control ID of %3 cannot be changed."), - Glib::Markup::escape_text (_route->name()), - _route->remote_control_id(), - (_route->is_master() ? _("the master bus") : _("the monitor bus")))); - } else { - l->set_markup (string_compose (_("The remote control ID of %5 is: %2\n\n\n" - "Remote Control IDs are currently determined by track/bus ordering in Ardour.\n\n" - "%3Use the User Interaction tab of the Preferences window if you want to change this%4"), - (is_track() ? _("track") : _("bus")), - _route->remote_control_id(), - "", - "", - Glib::Markup::escape_text (_route->name()))); - } - dialog.get_vbox()->pack_start (*l); - dialog.add_button (Stock::OK, RESPONSE_CANCEL); - } - - dialog.show_all (); - int const r = dialog.run (); - - if (r == RESPONSE_ACCEPT && spin) { - _route->set_remote_control_id (spin->get_value_as_int ()); - } + _route->gain_control()->set_value (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.5), Controllable::UseGroup); } void @@ -1856,9 +2009,8 @@ RouteUI::setup_invert_buttons () for (uint32_t i = 0; i < to_add; ++i) { ArdourButton* b = manage (new ArdourButton); - b->set_size_request(20,20); - b->signal_button_press_event().connect (sigc::mem_fun (*this, &RouteUI::invert_press)); - b->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::invert_release), i)); + b->signal_button_press_event().connect (sigc::mem_fun (*this, &RouteUI::invert_press), false); + b->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::invert_release), i), false); b->set_name (X_("invert button")); if (to_add == 1) { @@ -1872,9 +2024,9 @@ RouteUI::setup_invert_buttons () } if (N <= _max_invert_buttons) { - UI::instance()->set_tip (*b, string_compose (_("Left-click to invert (phase reverse) channel %1 of this track. Right-click to show menu."), i + 1)); + UI::instance()->set_tip (*b, string_compose (_("Left-click to invert polarity of channel %1 of this track. Right-click to show menu."), i + 1)); } else { - UI::instance()->set_tip (*b, _("Click to show a menu of channels for inversion (phase reverse)")); + UI::instance()->set_tip (*b, _("Click to show a menu of channels to invert polarity")); } _invert_buttons.push_back (b); @@ -1888,8 +2040,6 @@ RouteUI::setup_invert_buttons () void RouteUI::set_invert_button_state () { - ++_i_am_the_modifier; - uint32_t const N = _route->input()->n_ports().n_audio(); if (N > _max_invert_buttons) { @@ -1898,10 +2048,10 @@ RouteUI::set_invert_button_state () */ ArdourButton* b = _invert_buttons.front (); - - if (_route->phase_invert().count() == _route->phase_invert().size()) { + + if (_route->phase_control()->count() == _route->phase_control()->size()) { b->set_active_state (Gtkmm2ext::ExplicitActive); - } else if (_route->phase_invert().any()) { + } else if (_route->phase_control()->any()) { b->set_active_state (Gtkmm2ext::ImplicitActive); } else { b->set_active_state (Gtkmm2ext::Off); @@ -1913,12 +2063,10 @@ RouteUI::set_invert_button_state () int j = 0; for (vector::iterator i = _invert_buttons.begin(); i != _invert_buttons.end(); ++i, ++j) { - (*i)->set_active (_route->phase_invert (j)); + (*i)->set_active (_route->phase_control()->inverted (j)); } - - } - --_i_am_the_modifier; + } } bool @@ -1928,8 +2076,8 @@ RouteUI::invert_release (GdkEventButton* ev, uint32_t i) uint32_t const N = _route->input()->n_ports().n_audio (); if (N <= _max_invert_buttons) { /* left-click inverts phase so long as we have a button per channel */ - _route->set_phase_invert (i, !_invert_buttons[i]->get_active()); - return true; + _route->phase_control()->set_phase_invert (i, !_invert_buttons[i]->get_active()); + return false; } } return false; @@ -1947,9 +2095,9 @@ RouteUI::invert_press (GdkEventButton* ev) up a menu on right-click; left click is handled on release. */ - return true; + return false; } - + delete _invert_menu; _invert_menu = new Menu; _invert_menu->set_name ("ArdourContextMenu"); @@ -1959,13 +2107,13 @@ RouteUI::invert_press (GdkEventButton* ev) items.push_back (CheckMenuElem (string_compose (X_("Ø%1"), i + 1), sigc::bind (sigc::mem_fun (*this, &RouteUI::invert_menu_toggled), i))); Gtk::CheckMenuItem* e = dynamic_cast (&items.back ()); ++_i_am_the_modifier; - e->set_active (_route->phase_invert (i)); + e->set_active (_route->phase_control()->inverted (i)); --_i_am_the_modifier; } _invert_menu->popup (0, ev->time); - return false; + return true; } void @@ -1975,7 +2123,8 @@ RouteUI::invert_menu_toggled (uint32_t c) return; } - _route->set_phase_invert (c, !_route->phase_invert (c)); + + _route->phase_control()->set_phase_invert (c, !_route->phase_control()->inverted (c)); } void @@ -1996,28 +2145,83 @@ RouteUI::request_redraw () /** The Route's gui_changed signal has been emitted */ void -RouteUI::route_gui_changed (string what_changed) +RouteUI::route_gui_changed (PropertyChange const& what_changed) { - if (what_changed == "color") { + if (what_changed.contains (Properties::color)) { if (set_color_from_route () == 0) { route_color_changed (); } } } +void +RouteUI::track_mode_changed (void) +{ + assert(is_track()); + switch (track()->mode()) { + case ARDOUR::NonLayered: + case ARDOUR::Normal: + rec_enable_button->set_icon (ArdourIcon::RecButton); + break; + case ARDOUR::Destructive: + rec_enable_button->set_icon (ArdourIcon::RecTapeMode); + break; + } + rec_enable_button->queue_draw(); +} + /** @return the color that this route should use; it maybe its own, or it maybe that of its route group. */ + Gdk::Color -RouteUI::color () const +RouteUI::route_color () const { + Gdk::Color c; RouteGroup* g = _route->route_group (); - + string p; + if (g && g->is_color()) { - return GroupTabs::group_color (g); + set_color_from_rgba (c, GroupTabs::group_color (g)); + } else { + + /* deal with older 4.x color, which was stored in the GUI object state */ + + string p = ARDOUR_UI::instance()->gui_object_state->get_string (route_state_id(), X_("color")); + + if (!p.empty()) { + + /* old v4.x or earlier session. Use this information */ + + int red, green, blue; + char colon; + + stringstream ss (p); + + /* old color format version was: + + 16bit value for red:16 bit value for green:16 bit value for blue + + decode to rgb .. + */ + + ss >> red; + ss >> colon; + ss >> green; + ss >> colon; + ss >> blue; + + red >>= 2; + green >>= 2; + blue >>= 2; + + _route->presentation_info().set_color (RGBA_TO_UINT (red, green, blue, 255)); + } + + set_color_from_rgba (c, _route->presentation_info().color()); } - return _color; + return c; } void @@ -2032,7 +2236,7 @@ RouteUI::bus_send_display_changed (boost::shared_ptr send_to) { if (_route == send_to) { show_sends_button->set_active (true); - send_blink_connection = ARDOUR_UI::instance()->Blink.connect (sigc::mem_fun (*this, &RouteUI::send_blink)); + send_blink_connection = Timers::blink_connect (sigc::mem_fun (*this, &RouteUI::send_blink)); } else { show_sends_button->set_active (false); send_blink_connection.disconnect (); @@ -2044,3 +2248,198 @@ RouteUI::route_group() const { return _route->route_group(); } + + +RoutePinWindowProxy::RoutePinWindowProxy(std::string const &name, boost::shared_ptr route) + : WM::ProxyBase (name, string()) + , _route (boost::weak_ptr (route)) +{ + route->DropReferences.connect (going_away_connection, MISSING_INVALIDATOR, boost::bind (&RoutePinWindowProxy::route_going_away, this), gui_context()); +} + +RoutePinWindowProxy::~RoutePinWindowProxy() +{ + _window = 0; +} + +ARDOUR::SessionHandlePtr* +RoutePinWindowProxy::session_handle () +{ + ArdourWindow* aw = dynamic_cast (_window); + if (aw) { return aw; } + return 0; +} + +Gtk::Window* +RoutePinWindowProxy::get (bool create) +{ + boost::shared_ptr r = _route.lock (); + if (!r) { + return 0; + } + + if (!_window) { + if (!create) { + return 0; + } + _window = new PluginPinDialog (r); + ArdourWindow* aw = dynamic_cast (_window); + if (aw) { + aw->set_session (_session); + } + _window->show_all (); + } + return _window; +} + +void +RoutePinWindowProxy::route_going_away () +{ + delete _window; + _window = 0; + WM::Manager::instance().remove (this); + going_away_connection.disconnect(); +} + +void +RouteUI::maybe_add_route_print_mgr () +{ + if (_route->pinmgr_proxy ()) { + return; + } + RoutePinWindowProxy* wp = new RoutePinWindowProxy ( + string_compose ("RPM-%1", _route->id()), _route); + wp->set_session (_session); + + const XMLNode* ui_xml = _session->extra_xml (X_("UI")); + if (ui_xml) { + wp->set_state (*ui_xml, 0); + } + +#if 0 + void* existing_ui = _route->pinmgr_proxy (); + if (existing_ui) { + wp->use_window (*(reinterpret_cast(existing_ui))); + } +#endif + _route->set_pingmgr_proxy (wp); + + WM::Manager::instance().register_window (wp); +} + +void +RouteUI::manage_pins () +{ + RoutePinWindowProxy* proxy = _route->pinmgr_proxy (); + if (proxy) { + proxy->get (true); + proxy->present(); + } +} + +void +RouteUI::fan_out (bool to_busses, bool group) +{ + DisplaySuspender ds; + boost::shared_ptr pi = boost::dynamic_pointer_cast (_route->the_instrument ()); + assert (pi); + + const uint32_t n_outputs = pi->output_streams ().n_audio (); + if (_route->n_outputs ().n_audio () != n_outputs) { + MessageDialog msg (string_compose ( + _("The Plugin's number of audio outputs ports (%1) does not match the Tracks's number of audio outputs (%2). Cannot fan out."), + n_outputs, _route->n_outputs ().n_audio ())); + msg.run (); + return; + } + +#define BUSNAME pd.group_name + "(" + _route->name () + ")" + + /* count busses and channels/bus */ + boost::shared_ptr plugin = pi->plugin (); + std::map busnames; + for (uint32_t p = 0; p < n_outputs; ++p) { + const Plugin::IOPortDescription& pd (plugin->describe_io_port (DataType::AUDIO, false, p)); + std::string bn = BUSNAME; + busnames[bn]++; + } + + if (busnames.size () < 2) { + MessageDialog msg (_("Instrument has only 1 output bus. Nothing to fan out.")); + msg.run (); + return; + } + + uint32_t outputs = 2; + if (_session->master_out ()) { + outputs = std::max (outputs, _session->master_out ()->n_inputs ().n_audio ()); + } + + _route->output ()->disconnect (this); + _route->panner_shell ()->set_bypassed (true); + + RouteList to_group; + for (uint32_t p = 0; p < n_outputs; ++p) { + const Plugin::IOPortDescription& pd (plugin->describe_io_port (DataType::AUDIO, false, p)); + std::string bn = BUSNAME; + boost::shared_ptr r = _session->route_by_name (bn); + if (!r) { + if (to_busses) { + RouteList rl = _session->new_audio_route (busnames[bn], outputs, NULL, 1, bn, PresentationInfo::AudioBus, PresentationInfo::max_order); + r = rl.front (); + assert (r); + } else { + list > tl = + _session->new_audio_track (busnames[bn], outputs, NULL, 1, bn, PresentationInfo::max_order, Normal); + r = tl.front (); + assert (r); + + boost::shared_ptr cl (new ControlList); + cl->push_back (r->monitoring_control ()); + _session->set_controls (cl, (double) MonitorInput, Controllable::NoGroup); + } + r->input ()->disconnect (this); + } + to_group.push_back (r); + _route->output ()->audio (p)->connect (r->input ()->audio (pd.group_channel).get()); + } +#undef BUSNAME + + if (group) { + RouteGroup* rg = NULL; + const std::list& rgs (_session->route_groups ()); + for (std::list::const_iterator i = rgs.begin (); i != rgs.end (); ++i) { + if ((*i)->name () == pi->name ()) { + rg = *i; + break; + } + } + if (!rg) { + rg = new RouteGroup (*_session, pi->name ()); + _session->add_route_group (rg); + rg->set_gain (false); + } + + GroupTabs::set_group_color (rg, _route->presentation_info().color()); + for (RouteList::const_iterator i = to_group.begin(); i != to_group.end(); ++i) { + rg->add (*i); + } + } +} + +bool +RouteUI::mark_hidden (bool yn) +{ + if (yn != _route->presentation_info().hidden()) { + _route->presentation_info().set_hidden (yn); + return true; // things changed + } + return false; +} + +boost::shared_ptr +RouteUI::stripable () const +{ + return _route; +} +