X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmixer_strip.cc;h=21d6a5007fdc0bcac2aafa356172db4d3371f15d;hb=6d0b0099956a97725cc207ed59c84e6fddc239f6;hp=f0f0235361a80b62695c3ff84ff1bdde7bfb2357;hpb=0d999ea4ec059e62dd72ea595e166dba05109bfc;p=ardour.git

diff --git a/gtk2_ardour/mixer_strip.cc b/gtk2_ardour/mixer_strip.cc
index f0f0235361..21d6a5007f 100644
--- a/gtk2_ardour/mixer_strip.cc
+++ b/gtk2_ardour/mixer_strip.cc
@@ -22,22 +22,18 @@
 
 #include <sigc++/bind.h>
 
+#include <gtkmm/messagedialog.h>
+
 #include "pbd/convert.h"
 #include "pbd/enumwriter.h"
 #include "pbd/replace_all.h"
 #include "pbd/stacktrace.h"
 
-#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/utils.h>
-#include <gtkmm2ext/choice.h>
-#include <gtkmm2ext/doi.h>
-#include <gtkmm2ext/slider_controller.h>
-#include <gtkmm2ext/bindable_button.h>
-
 #include "ardour/amp.h"
 #include "ardour/audio_track.h"
 #include "ardour/audioengine.h"
 #include "ardour/internal_send.h"
+#include "ardour/io.h"
 #include "ardour/meter.h"
 #include "ardour/midi_track.h"
 #include "ardour/pannable.h"
@@ -55,11 +51,18 @@
 #include "ardour/vca.h"
 #include "ardour/vca_manager.h"
 
+#include "gtkmm2ext/gtk_ui.h"
+#include "gtkmm2ext/menu_elems.h"
+#include "gtkmm2ext/utils.h"
+#include "gtkmm2ext/doi.h"
+
+#include "widgets/tooltips.h"
+
 #include "ardour_window.h"
+#include "enums_convert.h"
 #include "mixer_strip.h"
 #include "mixer_ui.h"
 #include "keyboard.h"
-#include "ardour_button.h"
 #include "public_editor.h"
 #include "send_ui.h"
 #include "io_selector.h"
@@ -67,13 +70,12 @@
 #include "gui_thread.h"
 #include "route_group_menu.h"
 #include "meter_patterns.h"
-#include "tooltips.h"
 #include "ui_config.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace ARDOUR;
-using namespace ARDOUR_UI_UTILS;
+using namespace ArdourWidgets;
 using namespace PBD;
 using namespace Gtk;
 using namespace Gtkmm2ext;
@@ -84,7 +86,7 @@ MixerStrip* MixerStrip::_entered_mixer_strip;
 PBD::Signal1<void,MixerStrip*> MixerStrip::CatchDeletion;
 
 MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, bool in_mixer)
-	: AxisView(sess)
+	: SessionHandlePtr (sess)
 	, RouteUI (sess)
 	, _mixer(mx)
 	, _mixer_owned (in_mixer)
@@ -96,13 +98,13 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, bool in_mixer)
 	, solo_iso_table (1, 2)
 	, mute_solo_table (1, 2)
 	, bottom_button_table (1, 3)
-	, meter_point_button (_("pre"))
 	, monitor_section_button (0)
 	, midi_input_enable_button (0)
 	, _plugin_insert_cnt (0)
 	, _comment_button (_("Comments"))
 	, trim_control (ArdourKnob::default_elements, ArdourKnob::Flags (ArdourKnob::Detent | ArdourKnob::ArcToZero))
 	, _visibility (X_("mixer-element-visibility"))
+	, control_slave_ui (sess)
 {
 	init ();
 
@@ -116,7 +118,7 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, bool in_mixer)
 }
 
 MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, boost::shared_ptr<Route> rt, bool in_mixer)
-	: AxisView(sess)
+	: SessionHandlePtr (sess)
 	, RouteUI (sess)
 	, _mixer(mx)
 	, _mixer_owned (in_mixer)
@@ -128,12 +130,13 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, boost::shared_ptr<Route> rt
 	, solo_iso_table (1, 2)
 	, mute_solo_table (1, 2)
 	, bottom_button_table (1, 3)
-	, meter_point_button (_("pre"))
 	, monitor_section_button (0)
 	, midi_input_enable_button (0)
+	, _plugin_insert_cnt (0)
 	, _comment_button (_("Comments"))
 	, trim_control (ArdourKnob::default_elements, ArdourKnob::Flags (ArdourKnob::Detent | ArdourKnob::ArcToZero))
 	, _visibility (X_("mixer-element-visibility"))
+	, control_slave_ui (sess)
 {
 	init ();
 	set_route (rt);
@@ -149,7 +152,6 @@ MixerStrip::init ()
 	ignore_toggle = false;
 	comment_area = 0;
 	_width_owner = 0;
-	spacer = 0;
 
 	/* the length of this string determines the width of the mixer strip when it is set to `wide' */
 	longest_label = "longest label";
@@ -160,9 +162,11 @@ MixerStrip::init ()
 	}
 
 	width_button.set_icon (ArdourIcon::StripWidth);
+	hide_button.set_tweaks (ArdourButton::Square);
 	set_tooltip (width_button, t);
 
 	hide_button.set_icon (ArdourIcon::CloseCross);
+	hide_button.set_tweaks (ArdourButton::Square);
 	set_tooltip (&hide_button, _("Hide this mixer strip"));
 
 	input_button_box.set_spacing(2);
@@ -174,13 +178,7 @@ MixerStrip::init ()
 	output_button.set_text (_("Output"));
 	output_button.set_name ("mixer strip button");
 
-	set_tooltip (&meter_point_button, _("Click to select metering point"));
-	meter_point_button.set_name ("mixer strip button");
-
-	bottom_button_table.attach (meter_point_button, 2, 3, 0, 1);
-
-	meter_point_button.signal_button_press_event().connect (sigc::mem_fun (gpm, &GainMeter::meter_press), false);
-	meter_point_button.signal_button_release_event().connect (sigc::mem_fun (gpm, &GainMeter::meter_release), false);
+	bottom_button_table.attach (gpm.meter_point_button, 2, 3, 0, 1);
 
 	hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
 
@@ -211,15 +209,6 @@ MixerStrip::init ()
 	}
 	solo_iso_table.show ();
 
-	vca_button = manage (new ArdourButton (ArdourButton::default_elements));
-	vca_button->set_no_show_all (true);
-	vca_button->set_name (X_("vca assign"));
-	vca_button->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
-	vca_button->signal_button_release_event().connect (sigc::mem_fun (*this, &MixerStrip::vca_button_release), false);
-	UI::instance()->set_tip (*vca_button, _("VCA assignments"));
-	vca_button->set_text (_("-vca-"));
-	vca_button->show ();
-
 	rec_mon_table.set_homogeneous (true);
 	rec_mon_table.set_row_spacings (2);
 	rec_mon_table.set_col_spacings (2);
@@ -268,7 +257,9 @@ MixerStrip::init ()
 	group_button.set_name ("mixer strip button");
 
 	_comment_button.set_name (X_("mixer strip button"));
+	_comment_button.set_text_ellipsize (Pango::ELLIPSIZE_END);
 	_comment_button.signal_clicked.connect (sigc::mem_fun (*this, &RouteUI::toggle_comment_editor));
+	_comment_button.signal_size_allocate().connect (sigc::mem_fun (*this, &MixerStrip::comment_button_resized));
 
 	// TODO implement ArdourKnob::on_size_request properly
 #define PX_SCALE(px) std::max((float)px, rintf((float)px * UIConfiguration::instance().get_ui_scale()))
@@ -277,6 +268,8 @@ MixerStrip::init ()
 	trim_control.set_tooltip_prefix (_("Trim: "));
 	trim_control.set_name ("trim knob");
 	trim_control.set_no_show_all (true);
+	trim_control.StartGesture.connect(sigc::mem_fun(*this, &MixerStrip::trim_start_touch));
+	trim_control.StopGesture.connect(sigc::mem_fun(*this, &MixerStrip::trim_end_touch));
 	input_button_box.pack_start (trim_control, false, false);
 
 	global_vpacker.set_border_width (1);
@@ -288,7 +281,6 @@ MixerStrip::init ()
 	width_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::width_button_pressed), false);
 	hide_button.signal_clicked.connect (sigc::mem_fun(*this, &MixerStrip::hide_clicked));
 
-//	width_hide_box.set_border_width (1);
 	width_hide_box.set_spacing (2);
 	width_hide_box.pack_start (width_button, false, true);
 	width_hide_box.pack_start (number_label, true, true);
@@ -301,6 +293,7 @@ MixerStrip::init ()
 	number_label.set_fixed_colors (0x80808080, 0x80808080);
 	number_label.set_alignment (.5, .5);
 	number_label.set_fallthrough_to_parent (true);
+	number_label.set_tweaks (ArdourButton::OccasionalText);
 
 	global_vpacker.set_spacing (2);
 	if (!ARDOUR::Profile->get_trx()) {
@@ -315,7 +308,7 @@ MixerStrip::init ()
 	global_vpacker.pack_start (solo_iso_table, Gtk::PACK_SHRINK);
 	global_vpacker.pack_start (mute_solo_table, Gtk::PACK_SHRINK);
 	global_vpacker.pack_start (gpm, Gtk::PACK_SHRINK);
-	global_vpacker.pack_start (*vca_button, Gtk::PACK_SHRINK);
+	global_vpacker.pack_start (control_slave_ui, Gtk::PACK_SHRINK);
 	global_vpacker.pack_start (bottom_button_table, Gtk::PACK_SHRINK);
 	if (!ARDOUR::Profile->get_trx()) {
 		global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
@@ -324,6 +317,24 @@ MixerStrip::init ()
 		global_vpacker.pack_start (name_button, Gtk::PACK_SHRINK);
 	}
 
+#ifndef MIXBUS
+	//add a spacer underneath the master bus;
+	//this fills the area that is taken up by the scrollbar on the tracks;
+	//and therefore keeps the faders "even" across the bottom
+	int scrollbar_height = 0;
+	{
+		Gtk::Window window (WINDOW_TOPLEVEL);
+		HScrollbar scrollbar;
+		window.add (scrollbar);
+		scrollbar.set_name ("MixerWindow");
+		scrollbar.ensure_style();
+		Gtk::Requisition requisition(scrollbar.size_request ());
+		scrollbar_height = requisition.height;
+	}
+	spacer.set_size_request (-1, scrollbar_height);
+	global_vpacker.pack_end (spacer, false, false);
+#endif
+
 	global_frame.add (global_vpacker);
 	global_frame.set_shadow_type (Gtk::SHADOW_IN);
 	global_frame.set_name ("BaseFrame");
@@ -355,7 +366,6 @@ MixerStrip::init ()
 	number_label.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::number_button_button_press), false);
 
 	name_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::name_button_button_press), false);
-	name_button.signal_button_release_event().connect (sigc::mem_fun(*this, &MixerStrip::name_button_button_release), false);
 
 	group_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::select_route_group), false);
 
@@ -397,7 +407,7 @@ MixerStrip::init ()
 	_visibility.add (&solo_iso_table, X_("SoloIsoLock"), _("Solo Iso / Lock"), false);
 	_visibility.add (&output_button, X_("Output"), _("Output"), false);
 	_visibility.add (&_comment_button, X_("Comments"), _("Comments"), false);
-	_visibility.add (vca_button, X_("VCA"), _("VCA Assigns"), false);
+	_visibility.add (&control_slave_ui, X_("VCA"), _("VCA Assigns"), false);
 
 	parameter_changed (X_("mixer-element-visibility"));
 	UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &MixerStrip::parameter_changed));
@@ -419,6 +429,22 @@ MixerStrip::~MixerStrip ()
 		_entered_mixer_strip = NULL;
 }
 
+void
+MixerStrip::vca_assign (boost::shared_ptr<ARDOUR::VCA> vca)
+{
+	boost::shared_ptr<Slavable> sl = boost::dynamic_pointer_cast<Slavable> ( route() );
+	if (sl)
+		sl->assign(vca);
+}
+
+void
+MixerStrip::vca_unassign (boost::shared_ptr<ARDOUR::VCA> vca)
+{
+	boost::shared_ptr<Slavable> sl = boost::dynamic_pointer_cast<Slavable> ( route() );
+	if (sl)
+		sl->unassign(vca);
+}
+
 bool
 MixerStrip::mixer_strip_enter_event (GdkEventCrossing* /*ev*/)
 {
@@ -450,6 +476,47 @@ MixerStrip::mixer_strip_leave_event (GdkEventCrossing *ev)
 	return false;
 }
 
+string
+MixerStrip::name() const
+{
+	if (_route) {
+		return _route->name();
+	}
+	return string();
+}
+
+void
+MixerStrip::update_trim_control ()
+{
+	if (route()->trim() && route()->trim()->active() &&
+	    route()->n_inputs().n_audio() > 0) {
+		trim_control.show ();
+		trim_control.set_controllable (route()->trim()->gain_control());
+	} else {
+		trim_control.hide ();
+		boost::shared_ptr<Controllable> none;
+		trim_control.set_controllable (none);
+	}
+}
+
+void
+MixerStrip::trim_start_touch ()
+{
+	assert (_route && _session);
+	if (route()->trim() && route()->trim()->active() && route()->n_inputs().n_audio() > 0) {
+		route()->trim()->gain_control ()->start_touch (_session->transport_frame());
+	}
+}
+
+void
+MixerStrip::trim_end_touch ()
+{
+	assert (_route && _session);
+	if (route()->trim() && route()->trim()->active() && route()->n_inputs().n_audio() > 0) {
+		route()->trim()->gain_control ()->stop_touch (_session->transport_frame());
+	}
+}
+
 void
 MixerStrip::set_route (boost::shared_ptr<Route> rt)
 {
@@ -474,6 +541,8 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 
 	RouteUI::set_route (rt);
 
+	control_slave_ui.set_stripable (boost::dynamic_pointer_cast<Stripable> (rt));
+
 	/* ProcessorBox needs access to _route so that it can read
 	   GUI object state.
 	*/
@@ -509,9 +578,8 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 		solo_button->hide ();
 		mute_button->show ();
 		rec_mon_table.hide ();
-		if (solo_iso_table.get_parent()) {
-			solo_iso_table.get_parent()->remove(solo_iso_table);
-		}
+		solo_iso_table.set_sensitive(false);
+		control_slave_ui.set_sensitive(false);
 		if (monitor_section_button == 0) {
 			Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMonitorSection");
 			_session->MonitorChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::monitor_changed, this), gui_context());
@@ -532,18 +600,14 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 		mute_button->show ();
 		solo_button->show ();
 		rec_mon_table.show ();
+		solo_iso_table.set_sensitive(true);
+		control_slave_ui.set_sensitive(true);
 	}
 
 	if (_mixer_owned && route()->is_master() ) {
-
-		HScrollbar scrollbar;
-		Gtk::Requisition requisition(scrollbar.size_request ());
-		int scrollbar_height = requisition.height;
-
-		spacer = manage (new EventBox);
-		spacer->set_size_request (-1, scrollbar_height+2);
-		global_vpacker.pack_start (*spacer, false, false);
-		spacer->show();
+		spacer.show();
+	} else {
+		spacer.hide();
 	}
 
 	if (is_track()) {
@@ -554,14 +618,7 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 		monitor_disk_button->hide ();
 	}
 
-	if (route()->trim() && route()->trim()->active()) {
-		trim_control.show ();
-		trim_control.set_controllable (route()->trim()->gain_control());
-	} else {
-		trim_control.hide ();
-		boost::shared_ptr<Controllable> none;
-		trim_control.set_controllable (none);
-	}
+	update_trim_control();
 
 	if (is_midi_track()) {
 		if (midi_input_enable_button == 0) {
@@ -618,7 +675,7 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 		}
 	}
 
-	meter_point_button.set_text (meter_point_string (_route->meter_point()));
+	gpm.meter_point_button.set_text (meter_point_string (_route->meter_point()));
 
 	delete route_ops_menu;
 	route_ops_menu = 0;
@@ -640,12 +697,6 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 	}
 
 	_route->comment_changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::setup_comment_button, this), gui_context());
-	_route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::property_changed, this, _1), gui_context());
-
-	_route->gain_control()->MasterStatusChange.connect (route_connections,
-	                                                    invalidator (*this),
-	                                                    boost::bind (&MixerStrip::update_vca_display, this),
-	                                                    gui_context());
 
 	set_stuff_from_route ();
 
@@ -653,7 +704,6 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 
 	update_mute_display ();
 	update_solo_display ();
-	update_vca_display ();
 	name_changed ();
 	comment_changed ();
 	route_group_changed ();
@@ -693,7 +743,7 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 	mute_solo_table.show();
 	bottom_button_table.show();
 	gpm.show_all ();
-	meter_point_button.show();
+	gpm.meter_point_button.show();
 	input_button_box.show_all();
 	output_button.show();
 	name_button.show();
@@ -712,9 +762,9 @@ MixerStrip::set_stuff_from_route ()
 {
 	/* if width is not set, it will be set by the MixerUI or editor */
 
-	string str = gui_property ("strip-width");
-	if (!str.empty()) {
-		set_width_enum (Width (string_2_enum (str, _width)), this);
+	Width width;
+	if (get_gui_property ("strip-width", width)) {
+		set_width_enum (width, this);
 	}
 }
 
@@ -733,7 +783,7 @@ MixerStrip::set_width_enum (Width w, void* owner)
 	_width = w;
 
 	if (_width_owner == this) {
-		set_gui_property ("strip-width", enum_2_string (_width));
+		set_gui_property ("strip-width", _width);
 	}
 
 	set_button_names ();
@@ -747,14 +797,10 @@ MixerStrip::set_width_enum (Width w, void* owner)
 			show_sends_button->set_text (_("Aux"));
 		}
 
-		gpm.gain_automation_style_button.set_text (
-				gpm.astyle_string(gain_automation->automation_style()));
 		gpm.gain_automation_state_button.set_text (
 				gpm.astate_string(gain_automation->automation_state()));
 
 		if (_route->panner()) {
-			((Gtk::Label*)panners.pan_automation_style_button.get_child())->set_text (
-					panners.astyle_string(_route->panner()->automation_style()));
 			((Gtk::Label*)panners.pan_automation_state_button.get_child())->set_text (
 					panners.astate_string(_route->panner()->automation_state()));
 		}
@@ -773,15 +819,11 @@ MixerStrip::set_width_enum (Width w, void* owner)
 			show_sends_button->set_text (_("Snd"));
 		}
 
-		gpm.gain_automation_style_button.set_text (
-				gpm.short_astyle_string(gain_automation->automation_style()));
 		gpm.gain_automation_state_button.set_text (
 				gpm.short_astate_string(gain_automation->automation_state()));
 		gain_meter().setup_meters (); // recalc meter width
 
 		if (_route->panner()) {
-			((Gtk::Label*)panners.pan_automation_style_button.get_child())->set_text (
-			panners.short_astyle_string(_route->panner()->automation_style()));
 			((Gtk::Label*)panners.pan_automation_state_button.get_child())->set_text (
 			panners.short_astate_string(_route->panner()->automation_state()));
 		}
@@ -809,12 +851,7 @@ void
 MixerStrip::set_packed (bool yn)
 {
 	_packed = yn;
-
-	if (_packed) {
-		set_gui_property ("visible", true);
-	} else {
-		set_gui_property ("visible", false);
-	}
+	set_gui_property ("visible", _packed);
 }
 
 
@@ -867,27 +904,37 @@ MixerStrip::output_press (GdkEventButton *ev)
 
 		boost::shared_ptr<ARDOUR::BundleList> b = _session->bundles ();
 
-		/* give user bundles first chance at being in the menu */
+		/* guess the user-intended main type of the route output */
+		DataType intended_type = guess_main_type(false);
+
+		/* try adding the master bus first */
+		boost::shared_ptr<Route> master = _session->master_out();
+		if (master) {
+			maybe_add_bundle_to_output_menu (master->input()->bundle(), current, intended_type);
+		}
 
+		/* then other routes inputs */
+		boost::shared_ptr<ARDOUR::RouteList> routes = _session->get_routes ();
+		RouteList copy = *routes;
+		copy.sort (RouteCompareByName ());
+		for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
+			maybe_add_bundle_to_output_menu ((*i)->input()->bundle(), current, intended_type);
+		}
+
+		/* then try adding user bundles, often labeled/grouped physical inputs */
 		for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
 			if (boost::dynamic_pointer_cast<UserBundle> (*i)) {
-				maybe_add_bundle_to_output_menu (*i, current);
+				maybe_add_bundle_to_output_menu (*i, current, intended_type);
 			}
 		}
 
+		/* then all other bundles, including physical outs or other sofware */
 		for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
 			if (boost::dynamic_pointer_cast<UserBundle> (*i) == 0) {
-				maybe_add_bundle_to_output_menu (*i, current);
+				maybe_add_bundle_to_output_menu (*i, current, intended_type);
 			}
 		}
 
-		boost::shared_ptr<ARDOUR::RouteList> routes = _session->get_routes ();
-		RouteList copy = *routes;
-		copy.sort (RouteCompareByName ());
-		for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
-			maybe_add_bundle_to_output_menu ((*i)->input()->bundle(), current);
-		}
-
 		if (citems.size() == n_with_separator) {
 			/* no routes added; remove the separator */
 			citems.pop_back ();
@@ -909,7 +956,9 @@ MixerStrip::output_press (GdkEventButton *ev)
 		citems.push_back (SeparatorElem());
 		citems.push_back (MenuElem (_("Routing Grid"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::edit_output_configuration)));
 
-		output_menu.popup (1, ev->time);
+		Gtkmm2ext::anchored_menu_popup(&output_menu, &output_button, "",
+		                               1, ev->time);
+
 		break;
 	}
 
@@ -1011,7 +1060,8 @@ MixerStrip::input_press (GdkEventButton *ev)
 		citems.push_back (SeparatorElem());
 		citems.push_back (MenuElem (_("Routing Grid"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::edit_input_configuration)));
 
-		input_menu.popup (1, ev->time);
+		Gtkmm2ext::anchored_menu_popup(&input_menu, &input_button, "",
+		                               1, ev->time);
 
 		break;
 	}
@@ -1028,13 +1078,7 @@ MixerStrip::bundle_input_chosen (boost::shared_ptr<ARDOUR::Bundle> c)
 		return;
 	}
 
-	ARDOUR::BundleList current = _route->input()->bundles_connected ();
-
-	if (std::find (current.begin(), current.end(), c) == current.end()) {
-		_route->input()->connect_ports_to_bundle (c, true, this);
-	} else {
-		_route->input()->disconnect_ports_from_bundle (c, this);
-	}
+	_route->input()->connect_ports_to_bundle (c, true, this);
 }
 
 void
@@ -1044,13 +1088,7 @@ MixerStrip::bundle_output_chosen (boost::shared_ptr<ARDOUR::Bundle> c)
 		return;
 	}
 
-	ARDOUR::BundleList current = _route->output()->bundles_connected ();
-
-	if (std::find (current.begin(), current.end(), c) == current.end()) {
-		_route->output()->connect_ports_to_bundle (c, true, this);
-	} else {
-		_route->output()->disconnect_ports_from_bundle (c, this);
-	}
+	_route->output()->connect_ports_to_bundle (c, true, true, this);
 }
 
 void
@@ -1074,49 +1112,59 @@ MixerStrip::maybe_add_bundle_to_input_menu (boost::shared_ptr<Bundle> b, ARDOUR:
 	input_menu_bundles.push_back (b);
 
 	MenuList& citems = input_menu.items();
-
-	std::string n = b->name ();
-	replace_all (n, "_", " ");
-
-	citems.push_back (MenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_input_chosen), b)));
+	citems.push_back (MenuElemNoMnemonic (b->name (), sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_input_chosen), b)));
 }
 
 void
-MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr<Bundle> b, ARDOUR::BundleList const& /*current*/)
+MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr<Bundle> b, ARDOUR::BundleList const& /*current*/,
+                                             DataType type)
 {
 	using namespace Menu_Helpers;
 
-	if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs() || *b == *_route->input()->bundle()) {
+	/* The bundle should be an input one, but not ours */
+	if (b->ports_are_inputs() == false || *b == *_route->input()->bundle()) {
+		return;
+	}
+
+	/* Don't add the monitor input unless we are Master */
+	boost::shared_ptr<Route> monitor = _session->monitor_out();
+	if ((!_route->is_master()) && monitor && b->has_same_ports (monitor->input()->bundle()))
 		return;
+
+	/* It should either match exactly our outputs (if |type| is DataType::NIL)
+	 * or have the same number of |type| channels than our outputs. */
+	if (type == DataType::NIL) {
+		if(b->nchannels() != _route->n_outputs())
+			return;
+	} else {
+		if (b->nchannels().n(type) != _route->n_outputs().n(type))
+			return;
 	}
 
+	/* Avoid adding duplicates */
 	list<boost::shared_ptr<Bundle> >::iterator i = output_menu_bundles.begin ();
 	while (i != output_menu_bundles.end() && b->has_same_ports (*i) == false) {
 		++i;
 	}
-
 	if (i != output_menu_bundles.end()) {
 		return;
 	}
 
+	/* Now add the bundle to the menu */
 	output_menu_bundles.push_back (b);
 
 	MenuList& citems = output_menu.items();
-
-	std::string n = b->name ();
-	replace_all (n, "_", " ");
-
-	citems.push_back (MenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_output_chosen), b)));
+	citems.push_back (MenuElemNoMnemonic (b->name (), sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_output_chosen), b)));
 }
 
 void
 MixerStrip::update_diskstream_display ()
 {
-        if (is_track() && input_selector) {
-                        input_selector->hide_all ();
-        }
+	if (is_track() && input_selector) {
+		input_selector->hide_all ();
+	}
 
-        route_color_changed ();
+	route_color_changed ();
 }
 
 void
@@ -1134,7 +1182,6 @@ MixerStrip::connect_to_pan ()
 	boost::shared_ptr<Pannable> p = _route->pannable ();
 
 	p->automation_state_changed.connect (panstate_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_state_changed, &panners), gui_context());
-	p->automation_style_changed.connect (panstyle_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_style_changed, &panners), gui_context());
 
 	/* This call reduncant, PannerUI::set_panner() connects to _panshell->Changed itself
 	 * However, that only works a panner was previously set.
@@ -1164,6 +1211,53 @@ MixerStrip::update_panner_choices ()
 	panners.set_available_panners(PannerManager::instance().PannerManager::get_available_panners(in, out));
 }
 
+DataType
+MixerStrip::guess_main_type(bool for_input, bool favor_connected) const
+{
+	/* The heuristic follows these principles:
+	 *  A) If all ports that the user connected are of the same type, then he
+	 *     very probably intends to use the IO with that type. A common subcase
+	 *     is when the IO has only ports of the same type (connected or not).
+	 *  B) If several types of ports are connected, then we should guess based
+	 *     on the likeliness of the user wanting to use a given type.
+	 *     We assume that the DataTypes are ordered from the most likely to the
+	 *     least likely when iterating or comparing them with "<".
+	 *  C) If no port is connected, the same logic can be applied with all ports
+	 *     instead of connected ones. TODO: Try other ideas, for instance look at
+	 *     the last plugin output when |for_input| is false (note: when StrictIO
+	 *     the outs of the last plugin should be the same as the outs of the route
+	 *     modulo the panner which forwards non-audio anyway).
+	 * All of these constraints are respected by the following algorithm that
+	 * just returns the most likely datatype found in connected ports if any, or
+	 * available ports if any (since if all ports are of the same type, the most
+	 * likely found will be that one obviously). */
+
+	boost::shared_ptr<IO> io = for_input ? _route->input() : _route->output();
+
+	/* Find most likely type among connected ports */
+	if (favor_connected) {
+		DataType type = DataType::NIL; /* NIL is always last so least likely */
+		for (PortSet::iterator p = io->ports().begin(); p != io->ports().end(); ++p) {
+			if (p->connected() && p->type() < type)
+				type = p->type();
+		}
+		if (type != DataType::NIL) {
+			/* There has been a connected port (necessarily non-NIL) */
+			return type;
+		}
+	}
+
+	/* Find most likely type among available ports.
+	 * The iterator stops before NIL. */
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+		if (io->n_ports().n(*t) > 0)
+			return *t;
+	}
+
+	/* No port at all, return the most likely datatype by default */
+	return DataType::front();
+}
+
 /*
  * Output port labelling
  * =====================
@@ -1204,228 +1298,214 @@ MixerStrip::update_panner_choices ()
  */
 
 void
-MixerStrip::update_io_button (boost::shared_ptr<ARDOUR::Route> route, Width width, bool for_input)
+MixerStrip::update_io_button (bool for_input)
 {
-	uint32_t io_count;
-	uint32_t io_index;
-	boost::shared_ptr<Port> port;
-	vector<string> port_connections;
-
-	uint32_t total_connection_count = 0;
-	uint32_t io_connection_count = 0;
-	uint32_t ardour_connection_count = 0;
-	uint32_t system_connection_count = 0;
-	uint32_t other_connection_count = 0;
-	uint32_t typed_connection_count = 0;
-
+	ostringstream tooltip;
 	ostringstream label;
-
 	bool have_label = false;
-	bool each_io_has_one_connection = true;
 
-	string connection_name;
-	string ardour_track_name;
-	string other_connection_type;
-	string system_ports;
-	string system_port;
+	uint32_t total_connection_count = 0;
+	uint32_t typed_connection_count = 0;
+	bool each_typed_port_has_one_connection = true;
 
-	ostringstream tooltip;
-	char * tooltip_cstr;
-
-	//to avoid confusion, the button caption should only show connections that match the datatype of the track
-	DataType dt = DataType::AUDIO;
-	if ( boost::dynamic_pointer_cast<MidiTrack>(route) != 0 ) {
-		dt = DataType::MIDI;
-		// avoid further confusion with Midi-tracks that have a synth.
-		// Audio-ports may be connected, but button says "Disconnected"
-		tooltip << _("MIDI ");
-	}
+	DataType dt = guess_main_type(for_input);
+	boost::shared_ptr<IO> io = for_input ? _route->input() : _route->output();
 
+	/* Fill in the tooltip. Also count:
+	 *  - The total number of connections.
+	 *  - The number of main-typed connections.
+	 *  - Whether each main-typed port has exactly one connection. */
 	if (for_input) {
-		io_count = route->n_inputs().n_total();
-		tooltip << string_compose (_("<b>INPUT</b> to %1"), Gtkmm2ext::markup_escape_text (route->name()));
+		tooltip << string_compose (_("<b>INPUT</b> to %1"),
+				Gtkmm2ext::markup_escape_text (_route->name()));
 	} else {
-		io_count = route->n_outputs().n_total();
-		tooltip << string_compose (_("<b>OUTPUT</b> from %1"), Gtkmm2ext::markup_escape_text (route->name()));
+		tooltip << string_compose (_("<b>OUTPUT</b> from %1"),
+				Gtkmm2ext::markup_escape_text (_route->name()));
 	}
 
-
-	for (io_index = 0; io_index < io_count; ++io_index) {
-		if (for_input) {
-			port = route->input()->nth (io_index);
-		} else {
-			port = route->output()->nth (io_index);
-		}
-
-		port_connections.clear ();
+	string arrow = Gtkmm2ext::markup_escape_text(for_input ? " <- " : " -> ");
+	vector<string> port_connections;
+	for (PortSet::iterator port = io->ports().begin();
+	                       port != io->ports().end();
+	                       ++port) {
+		port_connections.clear();
 		port->get_connections(port_connections);
 
-		//ignore any port connections that don't match our DataType
-		if (port->type() != dt) {
-			if (!port_connections.empty()) {
-				++typed_connection_count;
-			}
-			continue;
-		}
-
-		io_connection_count = 0;
+		uint32_t port_connection_count = 0;
 
-		if (!port_connections.empty()) {
-			for (vector<string>::iterator i = port_connections.begin(); i != port_connections.end(); ++i) {
-				string pn = "";
-				string& connection_name (*i);
+		for (vector<string>::iterator i = port_connections.begin();
+		                              i != port_connections.end();
+		                              ++i) {
+			++port_connection_count;
 
-				if (connection_name.find("system:") == 0) {
-					pn = AudioEngine::instance()->get_pretty_name_by_name (connection_name);
-				}
-
-				if (io_connection_count == 0) {
-					tooltip << endl << Gtkmm2ext::markup_escape_text (port->name().substr(port->name().find("/") + 1))
-						<< " -> "
-						<< Gtkmm2ext::markup_escape_text ( pn.empty() ? connection_name : pn );
-				} else {
-					tooltip << ", "
-						<< Gtkmm2ext::markup_escape_text ( pn.empty() ? connection_name : pn );
-				}
-
-				if (connection_name.find(RouteUI::program_port_prefix) == 0) {
-					if (ardour_track_name.empty()) {
-						// "ardour:Master/in 1" -> "ardour:Master/"
-						string::size_type slash = connection_name.find("/");
-						if (slash != string::npos) {
-							ardour_track_name = connection_name.substr(0, slash + 1);
-						}
-					}
-
-					if (connection_name.find(ardour_track_name) == 0) {
-						++ardour_connection_count;
-					}
-				} else if (!pn.empty()) {
-					if (system_ports.empty()) {
-						system_ports += pn;
-					} else {
-						system_ports += "/" + pn;
-					}
-					if (connection_name.find("system:") == 0) {
-						++system_connection_count;
-					}
-				} else if (connection_name.find("system:midi_") == 0) {
-					if (for_input) {
-						// "system:midi_capture_123" -> "123"
-						system_port = "M " + connection_name.substr(20);
-					} else {
-						// "system:midi_playback_123" -> "123"
-						system_port = "M " + connection_name.substr(21);
-					}
-
-					if (system_ports.empty()) {
-						system_ports += system_port;
-					} else {
-						system_ports += "/" + system_port;
-					}
-
-					++system_connection_count;
-
-				} else if (connection_name.find("system:") == 0) {
-					if (for_input) {
-						// "system:capture_123" -> "123"
-						system_port = connection_name.substr(15);
-					} else {
-						// "system:playback_123" -> "123"
-						system_port = connection_name.substr(16);
-					}
-
-					if (system_ports.empty()) {
-						system_ports += system_port;
-					} else {
-						system_ports += "/" + system_port;
-					}
-
-					++system_connection_count;
-				} else {
-					if (other_connection_type.empty()) {
-						// "jamin:in 1" -> "jamin:"
-						other_connection_type = connection_name.substr(0, connection_name.find(":") + 1);
-					}
-
-					if (connection_name.find(other_connection_type) == 0) {
-						++other_connection_count;
-					}
-				}
-
-				++total_connection_count;
-				++io_connection_count;
+			if (port_connection_count == 1) {
+				tooltip << endl << Gtkmm2ext::markup_escape_text (
+						port->name().substr(port->name().find("/") + 1));
+				tooltip << arrow;
+			} else {
+				tooltip << ", ";
 			}
+
+			tooltip << Gtkmm2ext::markup_escape_text(*i);
 		}
 
-		if (io_connection_count != 1) {
-			each_io_has_one_connection = false;
+		total_connection_count += port_connection_count;
+		if (port->type() == dt) {
+			typed_connection_count += port_connection_count;
+			each_typed_port_has_one_connection &= (port_connection_count == 1);
 		}
+
 	}
 
 	if (total_connection_count == 0) {
 		tooltip << endl << _("Disconnected");
 	}
 
-	tooltip_cstr = new char[tooltip.str().size() + 1];
-	strcpy(tooltip_cstr, tooltip.str().c_str());
-
-	if (for_input) {
-		set_tooltip (&input_button, tooltip_cstr);
-	} else {
-		set_tooltip (&output_button, tooltip_cstr);
+	if (typed_connection_count == 0) {
+		label << "-";
+		have_label = true;
 	}
 
-	delete [] tooltip_cstr;
+	/* Are all main-typed channels connected to the same route ? */
+	if (!have_label) {
+		boost::shared_ptr<ARDOUR::RouteList> routes = _session->get_routes ();
+		for (ARDOUR::RouteList::const_iterator route = routes->begin();
+		                                       route != routes->end();
+		                                       ++route) {
+			boost::shared_ptr<IO> dest_io =
+				for_input ? (*route)->output() : (*route)->input();
+			if (io->bundle()->connected_to(dest_io->bundle(),
+			                               _session->engine(),
+			                               dt, true)) {
+				label << Gtkmm2ext::markup_escape_text ((*route)->name());
+				have_label = true;
+				break;
+			}
+		}
+	}
 
-	if (each_io_has_one_connection) {
-		if (total_connection_count == ardour_connection_count) {
-			// all connections are to the same track in ardour
-			// "ardour:Master/" -> "Master"
-			string::size_type slash = ardour_track_name.find("/");
-			if (slash != string::npos) {
-				const size_t ppps = RouteUI::program_port_prefix.size (); // "ardour:"
-				label << ardour_track_name.substr (ppps, slash - ppps);
+	/* Are all main-typed channels connected to the same (user) bundle ? */
+	if (!have_label) {
+		boost::shared_ptr<ARDOUR::BundleList> bundles = _session->bundles ();
+		for (ARDOUR::BundleList::iterator bundle = bundles->begin();
+		                                  bundle != bundles->end();
+		                                  ++bundle) {
+			if (boost::dynamic_pointer_cast<UserBundle> (*bundle) == 0)
+				continue;
+			if (io->bundle()->connected_to(*bundle, _session->engine(),
+			                               dt, true)) {
+				label << Gtkmm2ext::markup_escape_text ((*bundle)->name());
 				have_label = true;
+				break;
 			}
 		}
-		else if (total_connection_count == system_connection_count) {
-			// all connections are to system ports
-			label << system_ports;
-			have_label = true;
+	}
+
+	/* Is each main-typed channel only connected to a physical output ? */
+	if (!have_label && each_typed_port_has_one_connection) {
+		ostringstream temp_label;
+		vector<string> phys;
+		string playorcapture;
+		if (for_input) {
+			_session->engine().get_physical_inputs(dt, phys);
+			playorcapture = "capture_";
+		} else {
+			_session->engine().get_physical_outputs(dt, phys);
+			playorcapture = "playback_";
+		}
+		for (PortSet::iterator port = io->ports().begin(dt);
+		                       port != io->ports().end(dt);
+		                       ++port) {
+			string pn = "";
+			for (vector<string>::iterator s = phys.begin();
+			                              s != phys.end();
+			                              ++s) {
+				if (!port->connected_to(*s))
+					continue;
+				pn = AudioEngine::instance()->get_pretty_name_by_name(*s);
+				if (pn.empty()) {
+					string::size_type start = (*s).find(playorcapture);
+					if (start != string::npos) {
+						pn = (*s).substr(start + playorcapture.size());
+					}
+				}
+				break;
+			}
+			if (pn.empty()) {
+				temp_label.str(""); /* erase the failed attempt */
+				break;
+			}
+			if (port != io->ports().begin(dt))
+				temp_label << "/";
+			temp_label << pn;
 		}
-		else if (total_connection_count == other_connection_count) {
-			// all connections are to the same external program eg jamin
-			// "jamin:" -> "jamin"
-			label << other_connection_type.substr(0, other_connection_type.size() - 1);
+
+		if (!temp_label.str().empty()) {
+			label << temp_label.str();
 			have_label = true;
 		}
 	}
 
-	if (!have_label) {
-		if (total_connection_count == 0) {
-			// Disconnected
-			label << "-";
-		} else {
-			// Odd configuration
-			label << "*" << total_connection_count << "*";
+	/* Is each main-typed channel connected to a single and different port with
+	 * the same client name (e.g. another JACK client) ? */
+	if (!have_label && each_typed_port_has_one_connection) {
+		string maybe_client = "";
+		vector<string> connections;
+		for (PortSet::iterator port = io->ports().begin(dt);
+		                       port != io->ports().end(dt);
+		                       ++port) {
+			port_connections.clear();
+			port->get_connections(port_connections);
+			string connection = port_connections.front();
+
+			vector<string>::iterator i = connections.begin();
+			while (i != connections.end() && *i != connection) {
+				++i;
+			}
+			if (i != connections.end())
+				break; /* duplicate connection */
+			connections.push_back(connection);
+
+			connection = connection.substr(0, connection.find(":"));
+			if (maybe_client.empty())
+				maybe_client = connection;
+			if (maybe_client != connection)
+				break;
 		}
-		if (typed_connection_count > 0) {
-			label << "\u2295"; // circled plus
+		if (connections.size() == io->n_ports().n(dt)) {
+			label << maybe_client;
+			have_label = true;
 		}
 	}
 
+	/* Odd configuration */
+	if (!have_label) {
+		label << "*" << total_connection_count << "*";
+	}
+
+	if (total_connection_count > typed_connection_count) {
+		label << "\u2295"; /* circled plus */
+	}
+
+	/* Actually set the properties of the button */
+	char * cstr = new char[tooltip.str().size() + 1];
+	strcpy(cstr, tooltip.str().c_str());
+
 	if (for_input) {
 		input_button.set_text (label.str());
+		set_tooltip (&input_button, cstr);
 	} else {
 		output_button.set_text (label.str());
+		set_tooltip (&output_button, cstr);
 	}
+
+	delete [] cstr;
 }
 
 void
 MixerStrip::update_input_display ()
 {
-	update_io_button (_route, _width, true);
+	update_io_button (true);
 	panners.setup_pan ();
 
 	if (has_audio_outputs ()) {
@@ -1439,7 +1519,7 @@ MixerStrip::update_input_display ()
 void
 MixerStrip::update_output_display ()
 {
-	update_io_button (_route, _width, false);
+	update_io_button (false);
 	gpm.setup_meters ();
 	panners.setup_pan ();
 
@@ -1466,6 +1546,7 @@ void
 MixerStrip::io_changed_proxy ()
 {
 	Glib::signal_idle().connect_once (sigc::mem_fun (*this, &MixerStrip::update_panner_choices));
+	Glib::signal_idle().connect_once (sigc::mem_fun (*this, &MixerStrip::update_trim_control));
 }
 
 void
@@ -1488,33 +1569,27 @@ MixerStrip::port_connected_or_disconnected (boost::weak_ptr<Port> wa, boost::wea
 void
 MixerStrip::setup_comment_button ()
 {
-	switch (_width) {
+	std::string comment = _route->comment();
 
-	case Wide:
-		if (_route->comment().empty ()) {
-			_comment_button.unset_bg (STATE_NORMAL);
-			_comment_button.set_text (_("Comments"));
-		} else {
-			_comment_button.modify_bg (STATE_NORMAL, color ());
-			_comment_button.set_text (_("*Comments*"));
-		}
-		break;
+	set_tooltip (_comment_button, comment.empty() ? _("Click to add/edit comments") : _route->comment());
 
-	case Narrow:
-		if (_route->comment().empty ()) {
-			_comment_button.unset_bg (STATE_NORMAL);
-			_comment_button.set_text (_("Cmt"));
-		} else {
-			_comment_button.modify_bg (STATE_NORMAL, color ());
-			_comment_button.set_text (_("*Cmt*"));
-		}
-		break;
+	if (comment.empty ()) {
+		_comment_button.set_name ("generic button");
+		_comment_button.set_text (_width  == Wide ? _("Comments") : _("Cmt"));
+		return;
 	}
 
-	set_tooltip (
-		_comment_button, _route->comment().empty() ? _("Click to add/edit comments") : _route->comment()
-		);
+	_comment_button.set_name ("comment button");
 
+	string::size_type pos = comment.find_first_of (" \t\n");
+	if (pos != string::npos) {
+		comment = comment.substr (0, pos);
+	}
+	if (comment.empty()) {
+		_comment_button.set_text (_width  == Wide ? _("Comments") : _("Cmt"));
+	} else {
+		_comment_button.set_text (comment);
+	}
 }
 
 bool
@@ -1528,9 +1603,9 @@ MixerStrip::select_route_group (GdkEventButton *ev)
 
 			PropertyList* plist = new PropertyList();
 
-			plist->add (Properties::gain, true);
-			plist->add (Properties::mute, true);
-			plist->add (Properties::solo, true);
+			plist->add (Properties::group_gain, true);
+			plist->add (Properties::group_mute, true);
+			plist->add (Properties::group_solo, true);
 
 			group_menu = new RouteGroupMenu (_session, plist);
 		}
@@ -1538,7 +1613,12 @@ MixerStrip::select_route_group (GdkEventButton *ev)
 		WeakRouteList r;
 		r.push_back (route ());
 		group_menu->build (r);
-		group_menu->menu()->popup (1, ev->time);
+
+		RouteGroup *rg = _route->route_group();
+
+		Gtkmm2ext::anchored_menu_popup(group_menu->menu(), &group_button,
+		                               rg ? rg->name() : _("No Group"),
+		                               1, ev->time);
 	}
 
 	return true;
@@ -1568,6 +1648,7 @@ MixerStrip::route_group_changed ()
 void
 MixerStrip::route_color_changed ()
 {
+	using namespace ARDOUR_UI_UTILS;
 	name_button.modify_bg (STATE_NORMAL, color());
 	number_label.set_fixed_colors (gdk_color_to_rgba (color()), gdk_color_to_rgba (color()));
 	reset_strip_style ();
@@ -1587,7 +1668,13 @@ MixerStrip::help_count_plugins (boost::weak_ptr<Processor> p)
 	if (!processor || !processor->display_to_user()) {
 		return;
 	}
-	if (boost::dynamic_pointer_cast<PluginInsert> (processor)) {
+	boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
+#ifdef MIXBUS
+	if (pi && pi->is_channelstrip ()) {
+		return;
+	}
+#endif
+	if (pi) {
 		++_plugin_insert_cnt;
 	}
 }
@@ -1608,13 +1695,26 @@ MixerStrip::build_route_ops_menu ()
 
 	items.push_back (MenuElem (_("Outputs..."), sigc::mem_fun (*this, &RouteUI::edit_output_configuration)));
 
-	items.push_back (SeparatorElem());
+	if (!Profile->get_mixbus()) {
+		items.push_back (SeparatorElem());
+	}
 
-	if (!_route->is_master()) {
+	if (!_route->is_master()
+#ifdef MIXBUS
+			&& !_route->mixbus()
+#endif
+			) {
+		if (Profile->get_mixbus()) {
+			items.push_back (SeparatorElem());
+		}
 		items.push_back (MenuElem (_("Save As Template..."), sigc::mem_fun(*this, &RouteUI::save_as_template)));
 	}
-	items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteUI::route_rename)));
-	rename_menu_item = &items.back();
+
+	if (!Profile->get_mixbus()) {
+		items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteUI::route_rename)));
+		/* do not allow rename if the track is record-enabled */
+		items.back().set_sensitive (!is_track() || !track()->rec_enable_control()->get_value());
+	}
 
 	items.push_back (SeparatorElem());
 	items.push_back (CheckMenuElem (_("Active")));
@@ -1638,6 +1738,12 @@ MixerStrip::build_route_ops_menu ()
 		items.push_back (MenuElem (_("Pin Connections..."), sigc::mem_fun (*this, &RouteUI::manage_pins)));
 	}
 
+	if (_route->the_instrument () && _route->the_instrument ()->output_streams().n_audio() > 2) {
+		// TODO ..->n_audio() > 1 && separate_output_groups) hard to check here every time.
+		items.push_back (MenuElem (_("Fan out to Busses"), sigc::bind (sigc::mem_fun (*this, &RouteUI::fan_out), true, true)));
+		items.push_back (MenuElem (_("Fan out to Tracks"), sigc::bind (sigc::mem_fun (*this, &RouteUI::fan_out), false, true)));
+	}
+
 	items.push_back (SeparatorElem());
 	items.push_back (MenuElem (_("Adjust Latency..."), sigc::mem_fun (*this, &RouteUI::adjust_latency)));
 
@@ -1646,20 +1752,17 @@ MixerStrip::build_route_ops_menu ()
 	denormal_menu_item = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
 	denormal_menu_item->set_active (_route->denormal_protection());
 
-	items.push_back (SeparatorElem());
-	items.push_back (MenuElem (_("Remote Control ID..."), sigc::mem_fun (*this, &RouteUI::open_remote_control_id_dialog)));
-
 	if (_route) {
 		/* note that this relies on selection being shared across editor and
 		   mixer (or global to the backend, in the future), which is the only
 		   sane thing for users anyway.
 		*/
 
-		RouteTimeAxisView* rtav = PublicEditor::instance().get_route_view_by_route_id (_route->id());
-		if (rtav) {
+		StripableTimeAxisView* stav = PublicEditor::instance().get_stripable_time_axis_by_id (_route->id());
+		if (stav) {
 			Selection& selection (PublicEditor::instance().get_selection());
-			if (!selection.selected (rtav)) {
-				selection.set (rtav);
+			if (!selection.selected (stav)) {
+				selection.set (stav);
 			}
 
 			if (!_route->is_master()) {
@@ -1676,12 +1779,15 @@ MixerStrip::build_route_ops_menu ()
 gboolean
 MixerStrip::name_button_button_press (GdkEventButton* ev)
 {
-	if (ev->button == 3) {
+	if (ev->button == 1 || ev->button == 3) {
 		list_route_operations ();
 
-		/* do not allow rename if the track is record-enabled */
-		rename_menu_item->set_sensitive (!is_track() || !track()->rec_enable_control()->get_value());
-		route_ops_menu->popup (1, ev->time);
+		if (ev->button == 1) {
+			Gtkmm2ext::anchored_menu_popup(route_ops_menu, &name_button, "",
+			                               1, ev->time);
+		} else {
+			route_ops_menu->popup (3, ev->time);
+		}
 
 		return true;
 	}
@@ -1689,28 +1795,12 @@ MixerStrip::name_button_button_press (GdkEventButton* ev)
 	return false;
 }
 
-gboolean
-MixerStrip::name_button_button_release (GdkEventButton* ev)
-{
-	if (ev->button == 1) {
-		list_route_operations ();
-
-		/* do not allow rename if the track is record-enabled */
-		rename_menu_item->set_sensitive (!is_track() || !track()->rec_enable_control()->get_value());
-		route_ops_menu->popup (1, ev->time);
-	}
-
-	return false;
-}
-
 gboolean
 MixerStrip::number_button_button_press (GdkEventButton* ev)
 {
 	if (  ev->button == 3 ) {
 		list_route_operations ();
 
-		/* do not allow rename if the track is record-enabled */
-		rename_menu_item->set_sensitive (!is_track() || !track()->rec_enable_control()->get_value());
 		route_ops_menu->popup (1, ev->time);
 
 		return true;
@@ -1730,13 +1820,15 @@ void
 MixerStrip::set_selected (bool yn)
 {
 	AxisView::set_selected (yn);
-	if (_selected) {
+
+	if (selected()) {
 		global_frame.set_shadow_type (Gtk::SHADOW_ETCHED_OUT);
 		global_frame.set_name ("MixerStripSelectedFrame");
 	} else {
 		global_frame.set_shadow_type (Gtk::SHADOW_IN);
 		global_frame.set_name ("MixerStripFrame");
 	}
+
 	global_frame.queue_draw ();
 
 //	if (!yn)
@@ -1744,10 +1836,8 @@ MixerStrip::set_selected (bool yn)
 }
 
 void
-MixerStrip::property_changed (const PropertyChange& what_changed)
+MixerStrip::route_property_changed (const PropertyChange& what_changed)
 {
-	RouteUI::property_changed (what_changed);
-
 	if (what_changed.contains (ARDOUR::Properties::name)) {
 		name_changed ();
 	}
@@ -1772,7 +1862,7 @@ MixerStrip::name_changed ()
 		if (track_number == 0) {
 			number_label.set_text ("-");
 		} else {
-			number_label.set_text (PBD::to_string (abs(_route->track_number ()), std::dec));
+			number_label.set_text (PBD::to_string (abs(_route->track_number ())));
 		}
 	} else {
 		number_label.set_text ("");
@@ -1797,6 +1887,12 @@ MixerStrip::name_button_resized (Gtk::Allocation& alloc)
 	name_button.set_layout_ellipsize_width (alloc.get_width() * PANGO_SCALE);
 }
 
+void
+MixerStrip::comment_button_resized (Gtk::Allocation& alloc)
+{
+	_comment_button.set_layout_ellipsize_width (alloc.get_width() * PANGO_SCALE);
+}
+
 bool
 MixerStrip::width_button_pressed (GdkEventButton* ev)
 {
@@ -2015,7 +2111,7 @@ MixerStrip::monitor_changed ()
 void
 MixerStrip::meter_changed ()
 {
-	meter_point_button.set_text (meter_point_string (_route->meter_point()));
+	gpm.meter_point_button.set_text (meter_point_string (_route->meter_point()));
 	gpm.setup_meters ();
 	// reset peak when meter point changes
 	gpm.reset_peak_display();
@@ -2056,7 +2152,7 @@ MixerStrip::drop_send ()
 	output_button.set_sensitive (true);
 	group_button.set_sensitive (true);
 	set_invert_sensitive (true);
-	meter_point_button.set_sensitive (true);
+	gpm.meter_point_button.set_sensitive (true);
 	mute_button->set_sensitive (true);
 	solo_button->set_sensitive (true);
 	solo_isolated_led->set_sensitive (true);
@@ -2103,7 +2199,7 @@ MixerStrip::show_send (boost::shared_ptr<Send> send)
 	input_button.set_sensitive (false);
 	group_button.set_sensitive (false);
 	set_invert_sensitive (false);
-	meter_point_button.set_sensitive (false);
+	gpm.meter_point_button.set_sensitive (false);
 	mute_button->set_sensitive (false);
 	solo_button->set_sensitive (false);
 	rec_enable_button->set_sensitive (false);
@@ -2209,9 +2305,9 @@ MixerStrip::set_button_names ()
 	}
 
 	if (_route) {
-		meter_point_button.set_text (meter_point_string (_route->meter_point()));
+		gpm.meter_point_button.set_text (meter_point_string (_route->meter_point()));
 	} else {
-		meter_point_button.set_text ("");
+		gpm.meter_point_button.set_text ("");
 	}
 }
 
@@ -2502,100 +2598,6 @@ MixerStrip::set_meter_type (MeterType t)
 	gpm.set_type (t);
 }
 
-void
-MixerStrip::vca_menu_toggle (Gtk::CheckMenuItem* menuitem, uint32_t n)
-{
-	if (!_route) {
-		return;
-	}
-
-	boost::shared_ptr<VCA> vca = _session->vca_manager().vca_by_number (n);
-
-	if (!vca) {
-		return;
-	}
-
-	if (!_selected) {
-		/* if this strip is not selected, add it before carrying out
-		   changes to assignment. the user probably didn't notice
-		   that they were clicking on an unselected track.
-		*/
-		_mixer.select_strip (*this);
-	}
-
-	if (!menuitem->get_active()) {
-		_mixer.do_vca_unassign (vca);
-	} else {
-		_mixer.do_vca_assign (vca);
-	}
-}
-
-void
-MixerStrip::vca_assign (boost::shared_ptr<VCA> vca)
-{
-	if (!vca || !_route) {
-		return;
-	}
-
-	_route->assign (vca);
-}
-
-void
-MixerStrip::vca_unassign (boost::shared_ptr<VCA> vca)
-{
-	if (!_route) {
-		return;
-	}
-
-	_route->unassign (vca);
-}
-
-bool
-MixerStrip::vca_button_release (GdkEventButton* ev)
-{
-	using namespace Gtk::Menu_Helpers;
-
-	if (!_session) {
-		return false;
-	}
-
-	/* primary click only */
-
-	if (ev->button != 1) {
-		return false;
-	}
-
-	if (!_route) {
-		/* no route - nothing to do */
-		return false;
-	}
-
-	VCAList vcas (_session->vca_manager().vcas());
-
-	if (vcas.empty()) {
-		/* the button should not have been visible under these conditions */
-		return true;
-	}
-
-	Menu* menu = new Menu;
-	MenuList& items = menu->items();
-
-	items.push_back (MenuElem (_("Unassign"), sigc::bind (sigc::mem_fun (_mixer, &Mixer_UI::do_vca_unassign), boost::shared_ptr<VCA>())));
-
-	for (VCAList::iterator v = vcas.begin(); v != vcas.end(); ++v) {
-		items.push_back (CheckMenuElem ((*v)->name()));
-		Gtk::CheckMenuItem* item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back());
-		if (_route->slaved_to (*v)) {
-			item->set_active (true);
-		}
-		item->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &MixerStrip::vca_menu_toggle), item, (*v)->number()));
-	}
-
-	menu->popup (1, ev->time);
-
-	return true;
-}
-
 void
 MixerStrip::update_track_number_visibility ()
 {
@@ -2619,3 +2621,21 @@ MixerStrip::update_track_number_visibility ()
 		number_label.hide ();
 	}
 }
+
+Gdk::Color
+MixerStrip::color () const
+{
+	return route_color ();
+}
+
+bool
+MixerStrip::marked_for_display () const
+{
+	return !_route->presentation_info().hidden();
+}
+
+bool
+MixerStrip::set_marked_for_display (bool yn)
+{
+	return RouteUI::mark_hidden (!yn);
+}