drastic, deep and wide changes to make RouteGroup use boost::shared_ptr<Route> and...
[ardour.git] / gtk2_ardour / mixer_strip.cc
index f791314d7519fa0b94288948a39d84e98681479e..22b39c1a298dabe16c13ad386bcb2b203367e8e4 100644 (file)
@@ -21,8 +21,9 @@
 
 #include <sigc++/bind.h>
 
-#include <pbd/convert.h>
-#include <pbd/enumwriter.h>
+#include "pbd/convert.h"
+#include "pbd/enumwriter.h"
+#include "pbd/replace_all.h"
 
 #include <gtkmm2ext/gtk_ui.h>
 #include <gtkmm2ext/utils.h>
 #include <gtkmm2ext/slider_controller.h>
 #include <gtkmm2ext/bindable_button.h>
 
-#include <ardour/ardour.h>
-#include <ardour/session.h>
-#include <ardour/audioengine.h>
-#include <ardour/route.h>
-#include <ardour/audio_track.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/panner.h>
-#include <ardour/send.h>
-#include <ardour/processor.h>
-#include <ardour/ladspa_plugin.h>
-#include <ardour/bundle.h>
+#include "ardour/ardour.h"
+#include "ardour/amp.h"
+#include "ardour/session.h"
+#include "ardour/audioengine.h"
+#include "ardour/internal_send.h"
+#include "ardour/route.h"
+#include "ardour/route_group.h"
+#include "ardour/audio_track.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/panner.h"
+#include "ardour/send.h"
+#include "ardour/processor.h"
+#include "ardour/profile.h"
+#include "ardour/ladspa_plugin.h"
+#include "ardour/user_bundle.h"
 
 #include "ardour_ui.h"
 #include "ardour_dialog.h"
@@ -54,6 +59,7 @@
 #include "io_selector.h"
 #include "utils.h"
 #include "gui_thread.h"
+#include "route_group_menu.h"
 
 #include "i18n.h"
 
@@ -64,43 +70,58 @@ using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace std;
 
+sigc::signal<void,boost::shared_ptr<Route> > MixerStrip::SwitchIO;
+
 int MixerStrip::scrollbar_height = 0;
 
-#ifdef VARISPEED_IN_MIXER_STRIP
-static void 
-speed_printer (char buf[32], Gtk::Adjustment& adj, void* arg)
+MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, bool in_mixer)
+       : AxisView(sess)
+       , RouteUI (sess)
+       ,_mixer(mx)
+       , _mixer_owned (in_mixer)
+       , processor_box (sess, sigc::mem_fun(*this, &MixerStrip::plugin_selector), mx.selection(), this, in_mixer)
+       , gpm (sess, 250)
+       , panners (sess)
+       , _mono_button (_("Mono"))
+       , button_table (3, 2)
+       , middle_button_table (1, 2)
+       , bottom_button_table (1, 2)
+       , meter_point_label (_("pre"))
+       , comment_button (_("Comments"))
 {
-       float val = adj.get_value ();
+       init ();
 
-       if (val == 1.0) {
-               strcpy (buf, "1");
-       } else {
-               snprintf (buf, 32, "%.3f", val);
+       if (!_mixer_owned) {
+               /* the editor mixer strip: don't destroy it every time
+                  the underlying route goes away.
+               */
+
+               self_destruct = false;
        }
 }
-#endif 
 
 MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt, bool in_mixer)
-       : AxisView(sess),
-         RouteUI (rt, sess, _("Mute"), _("Solo"), _("Record")),
-         _mixer(mx),
-         pre_processor_box (PreFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
-         post_processor_box (PostFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
-         gpm (_route, sess),
-         panners (_route, sess),
-         button_table (3, 2),
-         middle_button_table (1, 2),
-         bottom_button_table (1, 2),
-         meter_point_label (_("pre")),
-         comment_button (_("Comments")),
-         speed_adjustment (1.0, 0.001, 4.0, 0.001, 0.1),
-         speed_spinner (&speed_adjustment, "MixerStripSpeedBase", true)
-
+       : AxisView(sess)
+       , RouteUI (sess)
+       ,_mixer(mx)
+       , _mixer_owned (in_mixer)
+       , processor_box (sess, sigc::mem_fun(*this, &MixerStrip::plugin_selector), mx.selection(), this, in_mixer)
+       , gpm (sess, 250)
+       , panners (sess)
+       , button_table (3, 2)
+       , middle_button_table (1, 2)
+       , bottom_button_table (1, 2)
+       , meter_point_label (_("pre"))
+       , comment_button (_("Comments"))
 {
-       if (set_color_from_route()) {
-               set_color (unique_random_color());
-       }
+       init ();
+       set_button_names ();
+       set_route (rt);
+}
 
+void
+MixerStrip::init ()
+{
        input_selector = 0;
        output_selector = 0;
        group_menu = 0;
@@ -108,55 +129,55 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
        route_ops_menu = 0;
        ignore_comment_edit = false;
        ignore_toggle = false;
-       ignore_speed_adjustment = false;
        comment_window = 0;
        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";
+
+       Gtk::Image* img;
 
-       Gtk::Image *width_icon = manage (new Gtk::Image (::get_icon("strip_width")));
-       Gtk::Image *hide_icon = manage (new Gtk::Image (::get_icon("hide")));
-       width_button.add (*width_icon);
-       hide_button.add (*hide_icon);
+       img = manage (new Gtk::Image (::get_icon("strip_width")));
+       img->show ();
+
+       width_button.add (*img);
+
+       img = manage (new Gtk::Image (::get_icon("hide")));
+       img->show ();
+
+       hide_button.add (*img);
 
        input_label.set_text (_("Input"));
+       ARDOUR_UI::instance()->set_tip (&input_button, _("Button 1 to choose inputs from a port matrix, button 3 to select inputs from a menu"), "");
        input_button.add (input_label);
        input_button.set_name ("MixerIOButton");
        input_label.set_name ("MixerIOButtonLabel");
 
+       Gtkmm2ext::set_size_request_to_display_given_text (input_button, longest_label.c_str(), 4, 4);
+
        output_label.set_text (_("Output"));
+       ARDOUR_UI::instance()->set_tip (&output_button, _("Button 1 to choose outputs from a port matrix, button 3 to select inputs from a menu"), "");
        output_button.add (output_label);
        output_button.set_name ("MixerIOButton");
        output_label.set_name ("MixerIOButtonLabel");
+       Gtkmm2ext::set_size_request_to_display_given_text (output_button, longest_label.c_str(), 4, 4);
 
-       _route->meter_change.connect (mem_fun(*this, &MixerStrip::meter_changed));
+       ARDOUR_UI::instance()->set_tip (&meter_point_button, _("Select metering point"), "");
        meter_point_button.add (meter_point_label);
        meter_point_button.set_name ("MixerStripMeterPreButton");
        meter_point_label.set_name ("MixerStripMeterPreButton");
-       
-       switch (_route->meter_point()) {
-       case MeterInput:
-               meter_point_label.set_text (_("input"));
-               break;
-               
-       case MeterPreFader:
-               meter_point_label.set_text (_("pre"));
-               break;
-               
-       case MeterPostFader:
-               meter_point_label.set_text (_("post"));
-               break;
-       }
-       
+
        /* TRANSLATORS: this string should be longest of the strings
           used to describe meter points. In english, it's "input".
        */
        set_size_request_to_display_given_text (meter_point_button, _("tupni"), 5, 5);
-    
+
        bottom_button_table.attach (meter_point_button, 1, 2, 0, 1);
-    
+
        meter_point_button.signal_button_press_event().connect (mem_fun (gpm, &GainMeter::meter_press), false);
-       /* XXX what is this meant to do? */
-       //meter_point_button.signal_button_release_event().connect (mem_fun (gpm, &GainMeter::meter_release), false);
+       meter_point_button.signal_button_release_event().connect (mem_fun (gpm, &GainMeter::meter_release), false);
 
        hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
 
@@ -177,63 +198,24 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
        bottom_button_table.set_col_spacings (0);
        bottom_button_table.set_homogeneous (true);
        bottom_button_table.attach (group_button, 0, 1, 0, 1);
-       
-       if (is_audio_track()) {
-               
-               rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press), false);
-               rec_enable_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::rec_enable_release));
-
-               rec_enable_button->set_name ("MixerRecordEnableButton");
-
-               boost::shared_ptr<AudioTrack> at = audio_track();
-
-               at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen));
-
-#ifdef VARISPEED_IN_MIXER_STRIP
-               speed_adjustment.signal_value_changed().connect (mem_fun(*this, &MixerStrip::speed_adjustment_changed));
-               
-               speed_frame.set_name ("BaseFrame");
-               speed_frame.set_shadow_type (Gtk::SHADOW_IN);
-               speed_frame.add (speed_spinner);
-               
-               speed_spinner.set_print_func (speed_printer, 0);
-
-               ARDOUR_UI::instance()->tooltips().set_tip (speed_spinner, _("Varispeed"));
-
-               button_table.attach (speed_frame, 0, 2, 5, 6);
-#endif /* VARISPEED_IN_MIXER_STRIP */
-
-               button_table.attach (*rec_enable_button, 0, 2, 2, 3);
-       }
 
        name_button.add (name_label);
        name_button.set_name ("MixerNameButton");
-       Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
+       Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2);
 
        name_label.set_name ("MixerNameButtonLabel");
-       if (_route->phase_invert()) {
-               name_label.set_text (X_("Ø ") + name_label.get_text());
-       } else {
-               name_label.set_text (_route->name());
-       }
-
+       ARDOUR_UI::instance()->set_tip (&group_button, _("Mix group"), "");
        group_button.add (group_label);
        group_button.set_name ("MixerGroupButton");
        group_label.set_name ("MixerGroupButtonLabel");
 
        comment_button.set_name ("MixerCommentButton");
 
-       ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route->comment()==""        ?
-                                                       _("Click to Add/Edit Comments"):
-                                                       _route->comment());
-
        comment_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::comment_button_clicked));
-       
+
        global_vpacker.set_border_width (0);
        global_vpacker.set_spacing (0);
 
-       VBox *whvbox = manage (new VBox);
-
        width_button.set_name ("MixerWidthButton");
        hide_button.set_name ("MixerHideButton");
        top_event_box.set_name ("MixerTopEventBox");
@@ -244,37 +226,24 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
        width_hide_box.pack_start (width_button, false, true);
        width_hide_box.pack_start (top_event_box, true, true);
        width_hide_box.pack_end (hide_button, false, true);
-       Gtk::Alignment *gain_meter_alignment = Gtk::manage(new Gtk::Alignment());
-       gain_meter_alignment->set_padding(0, 4, 0, 0);
-       gain_meter_alignment->add(gpm);
+       gain_meter_alignment.set_padding(0, 4, 0, 0);
+       gain_meter_alignment.add(gpm);
 
-       whvbox->pack_start (width_hide_box, true, true);
+       whvbox.pack_start (width_hide_box, true, true);
 
-       global_vpacker.pack_start (*whvbox, Gtk::PACK_SHRINK);
+       global_vpacker.pack_start (whvbox, Gtk::PACK_SHRINK);
        global_vpacker.pack_start (button_table,Gtk::PACK_SHRINK);
-       global_vpacker.pack_start (pre_processor_box, true, true);
+       global_vpacker.pack_start (processor_box, true, true);
        global_vpacker.pack_start (middle_button_table,Gtk::PACK_SHRINK);
-       global_vpacker.pack_start (*gain_meter_alignment,Gtk::PACK_SHRINK);
+       global_vpacker.pack_start (gain_meter_alignment,Gtk::PACK_SHRINK);
        global_vpacker.pack_start (bottom_button_table,Gtk::PACK_SHRINK);
-       global_vpacker.pack_start (post_processor_box, true, true);
-       if (!is_midi_track())
+       if (!is_midi_track()) {
                global_vpacker.pack_start (panners, Gtk::PACK_SHRINK);
+       }
+       global_vpacker.pack_start (_mono_button, Gtk::PACK_SHRINK);
        global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
        global_vpacker.pack_start (comment_button, Gtk::PACK_SHRINK);
 
-       if (route()->is_master() || route()->is_control()) {
-               
-               if (scrollbar_height == 0) {
-                       HScrollbar scrollbar;
-                       Gtk::Requisition requisition(scrollbar.size_request ());
-                       scrollbar_height = requisition.height;
-               }
-
-               EventBox* spacer = manage (new EventBox);
-               spacer->set_size_request (-1, scrollbar_height);
-               global_vpacker.pack_start (*spacer, false, false);
-       }
-
        global_frame.add (global_vpacker);
        global_frame.set_shadow_type (Gtk::SHADOW_IN);
        global_frame.set_name ("BaseFrame");
@@ -291,22 +260,6 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 
        _session.engine().Stopped.connect (mem_fun(*this, &MixerStrip::engine_stopped));
        _session.engine().Running.connect (mem_fun(*this, &MixerStrip::engine_running));
-       _route->input_changed.connect (mem_fun(*this, &MixerStrip::input_changed));
-       _route->output_changed.connect (mem_fun(*this, &MixerStrip::output_changed));
-       _route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed));
-       _route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
-       _route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
-       _route->mix_group_changed.connect (mem_fun(*this, &MixerStrip::mix_group_changed));
-       _route->panner().Changed.connect (mem_fun(*this, &MixerStrip::connect_to_pan));
-
-       if (is_audio_track()) {
-               audio_track()->DiskstreamChanged.connect (mem_fun(*this, &MixerStrip::diskstream_changed));
-               get_diskstream()->SpeedChanged.connect (mem_fun(*this, &MixerStrip::speed_changed));
-       }
-
-       _route->NameChanged.connect (mem_fun(*this, &RouteUI::name_changed));
-       _route->comment_changed.connect (mem_fun(*this, &MixerStrip::comment_changed));
-       _route->gui_changed.connect (mem_fun(*this, &MixerStrip::route_gui_changed));
 
        input_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::input_press), false);
        output_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::output_press), false);
@@ -316,11 +269,27 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
        mute_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::mute_press), false);
        mute_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::mute_release), false);
 
+       /* we don't need this if its not an audio track, but we don't know that yet and it doesn't
+          hurt (much).
+       */
+
+       rec_enable_button->set_name ("MixerRecordEnableButton");
+       rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press), false);
+       rec_enable_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::rec_enable_release));
+
+       /* ditto for this button and busses */
+
+       show_sends_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::show_sends_press), false);
+       show_sends_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::show_sends_release));
+
        name_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::name_button_button_press), false);
-       group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_mix_group), false);
+       group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_route_group), false);
 
        _width = (Width) -1;
-       set_stuff_from_route ();
+
+       /* start off as a passthru strip. we'll correct this, if necessary,
+          in update_diskstream_display().
+       */
 
        /* start off as a passthru strip. we'll correct this, if necessary,
           in update_diskstream_display().
@@ -331,44 +300,184 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
        else
                set_name ("AudioTrackStripBase");
 
+       add_events (Gdk::BUTTON_RELEASE_MASK|
+                   Gdk::ENTER_NOTIFY_MASK|
+                   Gdk::LEAVE_NOTIFY_MASK|
+                   Gdk::KEY_PRESS_MASK|
+                   Gdk::KEY_RELEASE_MASK);
+
+       set_flags (get_flags() | Gtk::CAN_FOCUS);
+
+       SwitchIO.connect (mem_fun (*this, &MixerStrip::switch_io));
+}
+
+MixerStrip::~MixerStrip ()
+{
+       GoingAway(); /* EMIT_SIGNAL */
+
+       delete input_selector;
+       delete output_selector;
+       delete comment_window;
+}
+
+void
+MixerStrip::set_route (boost::shared_ptr<Route> rt)
+{
+       if (rec_enable_button->get_parent()) {
+               button_table.remove (*rec_enable_button);
+       }
+
+       if (show_sends_button->get_parent()) {
+               button_table.remove (*show_sends_button);
+       }
+
+       RouteUI::set_route (rt);
+
+       delete input_selector;
+       input_selector = 0;
+
+       delete output_selector;
+       output_selector = 0;
+
+       revert_to_default_display ();
+
+       processor_box.set_route (rt);
+
+       if (set_color_from_route()) {
+               set_color (unique_random_color());
+       }
+
+       if (_mixer_owned && (route()->is_master() || route()->is_control())) {
+
+               if (scrollbar_height == 0) {
+                       HScrollbar scrollbar;
+                       Gtk::Requisition requisition(scrollbar.size_request ());
+                       scrollbar_height = requisition.height;
+               }
+
+               spacer = manage (new EventBox);
+               spacer->set_size_request (-1, scrollbar_height);
+               global_vpacker.pack_start (*spacer, false, false);
+       }
+
+       if (is_audio_track()) {
+
+               boost::shared_ptr<AudioTrack> at = audio_track();
+
+               connections.push_back (at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen)));
+
+               button_table.attach (*rec_enable_button, 0, 2, 2, 3);
+               rec_enable_button->set_sensitive (_session.writable());
+               rec_enable_button->show();
+
+       } else if (!is_track()) {
+               /* non-master bus */
+
+               if (!_route->is_master()) {
+                       button_table.attach (*show_sends_button, 0, 2, 2, 3);
+                       show_sends_button->show();
+               }
+       }
+
+       if (_route->phase_invert()) {
+               name_label.set_text (X_("Ø ") + name_label.get_text());
+       } else {
+               name_label.set_text (_route->name());
+       }
+
+       _mono_button.set_name ("MixerMonoButton");
+       _mono_button.signal_clicked().connect (mem_fun (*this, &MixerStrip::mono_button_clicked));
+
+       switch (_route->meter_point()) {
+       case MeterInput:
+               meter_point_label.set_text (_("input"));
+               break;
+
+       case MeterPreFader:
+               meter_point_label.set_text (_("pre"));
+               break;
+
+       case MeterPostFader:
+               meter_point_label.set_text (_("post"));
+               break;
+
+       case MeterCustom:
+               meter_point_label.set_text (_("custom"));
+               break;
+       }
+
+       delete route_ops_menu;
+       route_ops_menu = 0;
+
+       ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route->comment().empty() ?
+                                                  _("Click to Add/Edit Comments"):
+                                                  _route->comment());
+
+       connections.push_back (_route->meter_change.connect (
+                       mem_fun(*this, &MixerStrip::meter_changed)));
+       connections.push_back (_route->input()->changed.connect (
+                       mem_fun(*this, &MixerStrip::input_changed)));
+       connections.push_back (_route->output()->changed.connect (
+                       mem_fun(*this, &MixerStrip::output_changed)));
+       connections.push_back (_route->route_group_changed.connect (
+                       mem_fun(*this, &MixerStrip::route_group_changed)));
+
+       if (_route->panner()) {
+               connections.push_back (_route->panner()->Changed.connect (
+                       mem_fun(*this, &MixerStrip::connect_to_pan)));
+       }
+
+       if (is_audio_track()) {
+               connections.push_back (audio_track()->DiskstreamChanged.connect (
+                       mem_fun(*this, &MixerStrip::diskstream_changed)));
+       }
+
+       connections.push_back (_route->NameChanged.connect (
+                       mem_fun(*this, &RouteUI::name_changed)));
+       connections.push_back (_route->comment_changed.connect (
+                       mem_fun(*this, &MixerStrip::comment_changed)));
+       connections.push_back (_route->gui_changed.connect (
+                       mem_fun(*this, &MixerStrip::route_gui_changed)));
+
+       set_stuff_from_route ();
+
        /* now force an update of all the various elements */
 
-       pre_processor_box.update();
-       post_processor_box.update();
        mute_changed (0);
        solo_changed (0);
        name_changed ();
        comment_changed (0);
-       mix_group_changed (0);
+       route_group_changed ();
 
        connect_to_pan ();
 
        panners.setup_pan ();
 
-       if (is_audio_track()) {
-               speed_changed ();
-       }
-
        update_diskstream_display ();
        update_input_display ();
        update_output_display ();
 
        add_events (Gdk::BUTTON_RELEASE_MASK);
 
-       whvbox->show();
-       hide_icon->show();
-       width_icon->show();
-       gain_meter_alignment->show();
+       processor_box.show();
+
+       if (!route()->is_master() && !route()->is_control()) {
+               /* we don't allow master or control routes to be hidden */
+               hide_button.show();
+       }
 
-       pre_processor_box.show();
-       hide_button.show();
        width_button.show();
        width_hide_box.show();
+       whvbox.show ();
        global_frame.show();
        global_vpacker.show();
        button_table.show();
        middle_button_table.show();
        bottom_button_table.show();
+       processor_box.show_all ();
+       gpm.show_all ();
+       panners.show_all ();
+       gain_meter_alignment.show ();
        gain_unit_button.show();
        gain_unit_label.show();
        meter_point_button.show();
@@ -384,24 +493,8 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
        comment_button.show();
        group_button.show();
        group_label.show();
-       speed_spinner.show();
-       speed_label.show();
-       speed_frame.show();
-
-       show();
-}
-
-MixerStrip::~MixerStrip ()
-{
-       GoingAway(); /* EMIT_SIGNAL */
-
-       if (input_selector) {
-               delete input_selector;
-       }
 
-       if (output_selector) {
-               delete output_selector;
-       }
+       show ();
 }
 
 void
@@ -413,11 +506,11 @@ MixerStrip::set_stuff_from_route ()
 
        /* if width is not set, it will be set by the MixerUI or editor */
 
-       if ((prop = xml_node->property ("strip_width")) != 0) {
-               set_width (Width (string_2_enum (prop->value(), _width)), this);
+       if ((prop = xml_node->property ("strip-width")) != 0) {
+               set_width_enum (Width (string_2_enum (prop->value(), _width)), this);
        }
 
-       if ((prop = xml_node->property ("shown_mixer")) != 0) {
+       if ((prop = xml_node->property ("shown-mixer")) != 0) {
                if (prop->value() == "no") {
                        _marked_for_display = false;
                } else {
@@ -430,62 +523,61 @@ MixerStrip::set_stuff_from_route ()
 }
 
 void
-MixerStrip::set_width (Width w, void* owner)
+MixerStrip::set_width_enum (Width w, void* owner)
 {
        /* always set the gpm width again, things may be hidden */
 
        gpm.set_width (w);
        panners.set_width (w);
-       pre_processor_box.set_width (w);
-       post_processor_box.set_width (w);
 
-       boost::shared_ptr<AutomationList> gain_automation = _route->gain_control()->list();
+       boost::shared_ptr<AutomationList> gain_automation = _route->gain_control()->alist();
 
        _width_owner = owner;
 
-       if (_width == w) {
-               return;
-       }
-
        ensure_xml_node ();
-       
+
        _width = w;
 
        if (_width_owner == this) {
-               xml_node->add_property ("strip_width", enum_2_string (_width));
+               xml_node->add_property ("strip-width", enum_2_string (_width));
        }
 
+       set_button_names ();
+
        switch (w) {
        case Wide:
-               set_size_request (-1, -1);
-               
-               if (rec_enable_button)  {
-                       ((Gtk::Label*)rec_enable_button->get_child())->set_text (_("record"));
+               if (show_sends_button)  {
+                       ((Gtk::Label*)show_sends_button->get_child())->set_text (_("Sends"));
                }
-               ((Gtk::Label*)mute_button->get_child())->set_text  (_("Mute"));
-               ((Gtk::Label*)solo_button->get_child())->set_text (_("Solo"));
 
                if (_route->comment() == "") {
-                      comment_button.unset_bg (STATE_NORMAL);
-                      ((Gtk::Label*)comment_button.get_child())->set_text (_("comments"));
+                       comment_button.unset_bg (STATE_NORMAL);
+                       ((Gtk::Label*)comment_button.get_child())->set_text (_("Comments"));
                } else {
-                      comment_button.modify_bg (STATE_NORMAL, color());
-                      ((Gtk::Label*)comment_button.get_child())->set_text (_("*comments*"));
+                       comment_button.modify_bg (STATE_NORMAL, color());
+                       ((Gtk::Label*)comment_button.get_child())->set_text (_("*Comments*"));
+               }
+
+               ((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text (
+                               gpm.astyle_string(gain_automation->automation_style()));
+               ((Gtk::Label*)gpm.gain_automation_state_button.get_child())->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()));
                }
 
-               ((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text (gpm.astyle_string(gain_automation->automation_style()));
-               ((Gtk::Label*)gpm.gain_automation_state_button.get_child())->set_text (gpm.astate_string(gain_automation->automation_state()));
-               ((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()));
                Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2);
+               set_size_request (-1, -1);
                break;
 
        case Narrow:
-               if (rec_enable_button) {
-                       ((Gtk::Label*)rec_enable_button->get_child())->set_text (_("Rec"));
+               if (show_sends_button) {
+                       ((Gtk::Label*)show_sends_button->get_child())->set_text (_("Snd"));
                }
-               ((Gtk::Label*)mute_button->get_child())->set_text (_("M"));
-               ((Gtk::Label*)solo_button->get_child())->set_text (_("S"));
 
                if (_route->comment() == "") {
                       comment_button.unset_bg (STATE_NORMAL);
@@ -495,20 +587,30 @@ MixerStrip::set_width (Width w, void* owner)
                       ((Gtk::Label*)comment_button.get_child())->set_text (_("*Cmt*"));
                }
 
-               ((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text (gpm.short_astyle_string(gain_automation->automation_style()));
-               ((Gtk::Label*)gpm.gain_automation_state_button.get_child())->set_text (gpm.short_astate_string(gain_automation->automation_state()));
-               ((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()));
-               Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
+               ((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text (
+                               gpm.short_astyle_string(gain_automation->automation_style()));
+               ((Gtk::Label*)gpm.gain_automation_state_button.get_child())->set_text (
+                               gpm.short_astate_string(gain_automation->automation_state()));
+
+               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()));
+               }
+
+               Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2);
                set_size_request (max (50, gpm.get_gm_width()), -1);
                break;
        }
 
+       processor_box.set_width (w);
+       
        update_input_display ();
        update_output_display ();
-       mix_group_changed (0);
+       route_group_changed ();
        name_changed ();
-
+       WidthChanged ();
 }
 
 void
@@ -519,9 +621,9 @@ MixerStrip::set_packed (bool yn)
        ensure_xml_node ();
 
        if (_packed) {
-               xml_node->add_property ("shown_mixer", "yes");
+               xml_node->add_property ("shown-mixer", "yes");
        } else {
-               xml_node->add_property ("shown_mixer", "no");
+               xml_node->add_property ("shown-mixer", "no");
        }
 }
 
@@ -540,21 +642,50 @@ MixerStrip::output_press (GdkEventButton *ev)
        switch (ev->button) {
 
        case 1:
+               edit_output_configuration ();
+               break;
+
+       case 3:
+       {
                output_menu.set_name ("ArdourContextMenu");
-               citems.clear();
-               
-               citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_output_configuration)));
-               citems.push_back (SeparatorElem());
+               citems.clear ();
+               output_menu_bundles.clear ();
+
                citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_output)));
                citems.push_back (SeparatorElem());
+
+               ARDOUR::BundleList current = _route->output()->bundles_connected ();
+
+               boost::shared_ptr<ARDOUR::BundleList> b = _session.bundles ();
+
+               /* give user bundles first chance at being in the menu */
                
-               _session.foreach_bundle (
-                       bind (mem_fun (*this, &MixerStrip::add_bundle_to_output_menu), _route->output_bundle ())
-                       );
+               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);
+                       }
+               }
+
+               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);
+                       }
+               }
+               
+               boost::shared_ptr<ARDOUR::RouteList> routes = _session.get_routes ();
+               for (ARDOUR::RouteList::const_iterator i = routes->begin(); i != routes->end(); ++i) {
+                       maybe_add_bundle_to_output_menu ((*i)->input()->bundle(), current);
+               }
+
+               if (citems.size() == 2) {
+                       /* no routes added; remove the separator */
+                       citems.pop_back ();
+               }
 
                output_menu.popup (1, ev->time);
                break;
-               
+       }
+
        default:
                break;
        }
@@ -565,8 +696,22 @@ void
 MixerStrip::edit_output_configuration ()
 {
        if (output_selector == 0) {
-               output_selector = new IOSelectorWindow (_session, _route, false);
-       } 
+               
+               boost::shared_ptr<Send> send;
+               boost::shared_ptr<IO> output;
+
+               if ((send = boost::dynamic_pointer_cast<Send>(_current_delivery)) != 0) {
+                       if (!boost::dynamic_pointer_cast<InternalSend>(send)) {
+                               output = send->output();
+                       } else {
+                               output = _route->output ();
+                       } 
+               } else {
+                       output = _route->output ();
+               }
+               
+               output_selector = new IOSelectorWindow (&_session, output);
+       }
 
        if (output_selector->is_visible()) {
                output_selector->get_toplevel()->get_window()->raise();
@@ -579,8 +724,8 @@ void
 MixerStrip::edit_input_configuration ()
 {
        if (input_selector == 0) {
-               input_selector = new IOSelectorWindow (_session, _route, true);
-       } 
+               input_selector = new IOSelectorWindow (&_session, _route->input());
+       }
 
        if (input_selector->is_visible()) {
                input_selector->get_toplevel()->get_window()->raise();
@@ -597,7 +742,7 @@ MixerStrip::input_press (GdkEventButton *ev)
        MenuList& citems = input_menu.items();
        input_menu.set_name ("ArdourContextMenu");
        citems.clear();
-       
+
        if (!_session.engine().connected()) {
                MessageDialog msg (_("Not connected to JACK - no I/O changes are possible"));
                msg.run ();
@@ -607,18 +752,46 @@ MixerStrip::input_press (GdkEventButton *ev)
        switch (ev->button) {
 
        case 1:
-               citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_input_configuration)));
-               citems.push_back (SeparatorElem());
+               edit_input_configuration ();
+               break;
+
+       case 3:
+       {
                citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
                citems.push_back (SeparatorElem());
+               input_menu_bundles.clear ();
+
+               ARDOUR::BundleList current = _route->input()->bundles_connected ();
+
+               boost::shared_ptr<ARDOUR::BundleList> b = _session.bundles ();
+
+               /* give user bundles first chance at being in the menu */
+               
+               for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
+                       if (boost::dynamic_pointer_cast<UserBundle> (*i)) {
+                               maybe_add_bundle_to_input_menu (*i, current);
+                       }
+               }
+
+               for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
+                       if (boost::dynamic_pointer_cast<UserBundle> (*i) == 0) {
+                               maybe_add_bundle_to_input_menu (*i, current);
+                       }
+               }
                
-               _session.foreach_bundle (
-                       bind (mem_fun (*this, &MixerStrip::add_bundle_to_input_menu), _route->input_bundle ())
-                       );
+               boost::shared_ptr<ARDOUR::RouteList> routes = _session.get_routes ();
+               for (ARDOUR::RouteList::const_iterator i = routes->begin(); i != routes->end(); ++i) {
+                       maybe_add_bundle_to_input_menu ((*i)->output()->bundle(), current);
+               }
+
+               if (citems.size() == 2) {
+                       /* no routes added; remove the separator */
+                       citems.pop_back ();
+               }
 
                input_menu.popup (1, ev->time);
                break;
-               
+       }
        default:
                break;
        }
@@ -626,84 +799,108 @@ MixerStrip::input_press (GdkEventButton *ev)
 }
 
 void
-MixerStrip::bundle_input_chosen (boost::shared_ptr<ARDOUR::Bundle> c)
+MixerStrip::bundle_input_toggled (boost::shared_ptr<ARDOUR::Bundle> c)
 {
-       if (!ignore_toggle) {
+       if (ignore_toggle) {
+               return;
+       }
 
-               try { 
-                       _route->connect_input_ports_to_bundle (c, this);
-               }
+       ARDOUR::BundleList current = _route->input()->bundles_connected ();
 
-               catch (AudioEngine::PortRegistrationFailure& err) {
-                       error << _("could not register new ports required for that bundle")
-                             << endmsg;
-               }
+       if (std::find (current.begin(), current.end(), c) == current.end()) {
+               _route->input()->connect_ports_to_bundle (c, this);
+       } else {
+               _route->input()->disconnect_ports_from_bundle (c, this);
        }
 }
 
 void
-MixerStrip::bundle_output_chosen (boost::shared_ptr<ARDOUR::Bundle> c)
+MixerStrip::bundle_output_toggled (boost::shared_ptr<ARDOUR::Bundle> c)
 {
-       if (!ignore_toggle) {
+       if (ignore_toggle) {
+               return;
+       }
 
-               try { 
-                       _route->connect_output_ports_to_bundle (c, this);
-               }
+       ARDOUR::BundleList current = _route->output()->bundles_connected ();
 
-               catch (AudioEngine::PortRegistrationFailure& err) {
-                       error << _("could not register new ports required for that bundle")
-                             << endmsg;
-               }
+       if (std::find (current.begin(), current.end(), c) == current.end()) {
+               _route->output()->connect_ports_to_bundle (c, this);
+       } else {
+               _route->output()->disconnect_ports_from_bundle (c, this);
        }
 }
 
 void
-MixerStrip::add_bundle_to_input_menu (boost::shared_ptr<Bundle> b, boost::shared_ptr<Bundle> current)
+MixerStrip::maybe_add_bundle_to_input_menu (boost::shared_ptr<Bundle> b, ARDOUR::BundleList const & current)
 {
        using namespace Menu_Helpers;
 
-       /* the input menu needs to contain only output bundles (that we
-          can connect inputs to */
-       if (boost::dynamic_pointer_cast<OutputBundle, Bundle> (b) == 0) {
+       if (b->ports_are_outputs() == false ||
+           route()->input()->default_type() != b->type() ||
+           b->nchannels() != _route->n_inputs().get (b->type ())) {
+
+               return;
+       }
+
+       list<boost::shared_ptr<Bundle> >::iterator i = input_menu_bundles.begin ();
+       while (i != input_menu_bundles.end() && b->has_same_ports (*i) == false) {
+               ++i;
+       }
+
+       if (i != input_menu_bundles.end()) {
                return;
        }
 
+       input_menu_bundles.push_back (b);
+
        MenuList& citems = input_menu.items();
-       
-       if (b->nchannels() == _route->n_inputs().n_total()) {
 
-               citems.push_back (CheckMenuElem (b->name(), bind (mem_fun(*this, &MixerStrip::bundle_input_chosen), b)));
-               
-               if (current == b) {
-                       ignore_toggle = true;
-                       dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
-                       ignore_toggle = false;
-               }
+       std::string n = b->name ();
+       replace_all (n, "_", " ");
+
+       citems.push_back (CheckMenuElem (n, bind (mem_fun(*this, &MixerStrip::bundle_input_toggled), b)));
+
+       if (std::find (current.begin(), current.end(), b) != current.end()) {
+               ignore_toggle = true;
+               dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
+               ignore_toggle = false;
        }
 }
 
 void
-MixerStrip::add_bundle_to_output_menu (boost::shared_ptr<Bundle> b, boost::shared_ptr<Bundle> current)
+MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr<Bundle> b, ARDOUR::BundleList const & current)
 {
        using namespace Menu_Helpers;
 
-       /* the output menu needs to contain only input bundles (that we
-          can connect outputs to */
-       if (boost::dynamic_pointer_cast<InputBundle, Bundle> (b) == 0) {
+       if (b->ports_are_inputs() == false ||
+           route()->output()->default_type() != b->type() ||
+           b->nchannels() != _route->n_outputs().get (b->type ())) {
+
+               return;
+       }
+
+       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;
        }
 
+       output_menu_bundles.push_back (b);
+       
+       MenuList& citems = output_menu.items();
 
-       if (b->nchannels() == _route->n_outputs().n_total()) {
+       std::string n = b->name ();
+       replace_all (n, "_", " ");
 
-               MenuList& citems = output_menu.items();
-               citems.push_back (CheckMenuElem (b->name(), bind (mem_fun(*this, &MixerStrip::bundle_output_chosen), b)));
-               
-               if (current == b) {
-                       ignore_toggle = true;
-                       dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
-                       ignore_toggle = false;
-               }
+       citems.push_back (CheckMenuElem (n, bind (mem_fun(*this, &MixerStrip::bundle_output_toggled), b)));
+
+       if (std::find (current.begin(), current.end(), b) != current.end()) {
+               ignore_toggle = true;
+               dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
+               ignore_toggle = false;
        }
 }
 
@@ -712,10 +909,6 @@ MixerStrip::update_diskstream_display ()
 {
        if (is_track()) {
 
-               map_frozen ();
-
-               update_input_display ();
-
                if (input_selector) {
                        input_selector->hide_all ();
                }
@@ -724,9 +917,6 @@ MixerStrip::update_diskstream_display ()
 
        } else {
 
-               map_frozen ();
-
-               update_input_display ();
                show_passthru_color ();
        }
 }
@@ -739,55 +929,248 @@ MixerStrip::connect_to_pan ()
        panstate_connection.disconnect ();
        panstyle_connection.disconnect ();
 
-       if (!_route->panner().empty()) {
-               StreamPanner* sp = _route->panner().front();
+       if (!_route->panner()) {
+               return;
+       }
+
+       boost::shared_ptr<ARDOUR::AutomationControl> pan_control
+               = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
+                               _route->panner()->data().control(Evoral::Parameter(PanAutomation)));
 
-               panstate_connection = sp->pan_control()->list()->automation_state_changed.connect (mem_fun(panners, &PannerUI::pan_automation_state_changed));
-               panstyle_connection = sp->pan_control()->list()->automation_style_changed.connect (mem_fun(panners, &PannerUI::pan_automation_style_changed));
+       if (pan_control) {
+               panstate_connection = pan_control->alist()->automation_state_changed.connect (mem_fun(panners, &PannerUI::pan_automation_state_changed));
+               panstyle_connection = pan_control->alist()->automation_style_changed.connect (mem_fun(panners, &PannerUI::pan_automation_style_changed));
        }
 
        panners.pan_changed (this);
 }
 
+
+/*
+ * Output port labelling
+ * =====================
+ *
+ * Case 1: Each output has one connection, all connections are to system:playback_%i
+ *   out 1 -> system:playback_1
+ *   out 2 -> system:playback_2
+ *   out 3 -> system:playback_3
+ *   Display as: 1/2/3
+ *
+ * Case 2: Each output has one connection, all connections are to ardour:track_x/in 1
+ *   out 1 -> ardour:track_x/in 1
+ *   out 2 -> ardour:track_x/in 2
+ *   Display as: track_x
+ *
+ * Case 3: Each output has one connection, all connections are to Jack client "program x"
+ *   out 1 -> program x:foo
+ *   out 2 -> program x:foo
+ *   Display as: program x
+ *
+ * Case 4: No connections (Disconnected)
+ *   Display as: -
+ *
+ * Default case (unusual routing):
+ *   Display as: *number of connections*
+ *
+ * Tooltips
+ * ========
+ * .-----------------------------------------------.
+ * | Mixdown                                       |
+ * | out 1 -> ardour:master/in 1, jamin:input/in 1 |
+ * | out 2 -> ardour:master/in 2, jamin:input/in 2 |
+ * '-----------------------------------------------'
+ * .-----------------------------------------------.
+ * | Guitar SM58                                   |
+ * | Disconnected                                  |
+ * '-----------------------------------------------'
+ */
+
 void
-MixerStrip::update_input_display ()
+MixerStrip::update_io_button (boost::shared_ptr<ARDOUR::Route> route, Width width, bool for_input)
 {
-       boost::shared_ptr<ARDOUR::Bundle> c;
+       uint32_t io_count;
+       uint32_t io_index;
+       Port *port;
+       vector<string> 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;
 
-       if ((c = _route->input_bundle()) != 0) {
-               input_label.set_text (c->name());
+       ostringstream label;
+       string label_string;
+       char * label_cstr;
+
+       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;
+
+       ostringstream tooltip;
+       char * tooltip_cstr;
+
+       tooltip << route->name();
+
+       if (for_input) {
+               io_count = route->n_inputs().n_total();
        } else {
-               switch (_width) {
-               case Wide:
-                       input_label.set_text (_(" Input"));
-                       break;
-               case Narrow:
-                       input_label.set_text (_("I"));
-                       break;
+               io_count = route->n_outputs().n_total();
+       }
+
+       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);
+               }
+
+               connections.clear ();
+               port->get_connections(connections);
+               io_connection_count = 0;
+
+               if (!connections.empty()) {
+                       for (vector<string>::iterator i = connections.begin(); i != connections.end(); ++i) {
+                               string& connection_name (*i);
+
+                               if (io_connection_count == 0) {
+                                       tooltip << endl << port->name().substr(port->name().find("/") + 1) << " -> " << connection_name;
+                               } else {
+                                       tooltip << ", " << connection_name;
+                               }
+
+                               if (connection_name.find("ardour:") == 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 (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 (io_connection_count != 1) {
+                       each_io_has_one_connection = false;
                }
        }
-       panners.setup_pan ();
+
+       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) {
+               ARDOUR_UI::instance()->set_tip (&input_button, tooltip_cstr, "");
+       } else {
+               ARDOUR_UI::instance()->set_tip (&output_button, tooltip_cstr, "");
+       }
+
+       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) {
+                               label << ardour_track_name.substr(7, slash - 7);
+                               have_label = true;
+                       }
+               }
+               else if (total_connection_count == system_connection_count) {
+                       // all connections are to system ports
+                       label << system_ports;
+                       have_label = true;
+               }
+               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);
+                       have_label = true;
+               }
+       }
+
+       if (!have_label) {
+               if (total_connection_count == 0) {
+                       // Disconnected
+                       label << "-";
+               } else {
+                       // Odd configuration
+                       label << "*" << total_connection_count << "*";
+               }
+       }
+
+       switch (width) {
+       case Wide:
+               label_string = label.str().substr(0, 6);
+               break;
+       case Narrow:
+               label_string = label.str().substr(0, 3);
+               break;
+       }
+
+       label_cstr = new char[label_string.size() + 1];
+       strcpy(label_cstr, label_string.c_str());
+
+       if (for_input) {
+               input_label.set_text (label_cstr);
+       } else {
+               output_label.set_text (label_cstr);
+       }
 }
 
 void
-MixerStrip::update_output_display ()
+MixerStrip::update_input_display ()
 {
-       boost::shared_ptr<ARDOUR::Bundle> c;
+       update_io_button (_route, _width, true);
+       panners.setup_pan ();
+}
 
-       if ((c = _route->output_bundle()) != 0) {
-               output_label.set_text (c->name());
-       } else {
-               switch (_width) {
-               case Wide:
-                       output_label.set_text (_("Output"));
-                       break;
-               case Narrow:
-                       output_label.set_text (_("O"));
-                       break;
-               }
-       }
-       gpm.setup_meters ();
-       panners.setup_pan ();
+void
+MixerStrip::update_output_display ()
+{
+       update_io_button (_route, _width, false);
+       gpm.setup_meters ();
+       panners.setup_pan ();
 }
 
 void
@@ -800,30 +1183,32 @@ void
 MixerStrip::diskstream_changed ()
 {
        Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_diskstream_display));
-}      
+}
 
 void
-MixerStrip::input_changed (IOChange change, void *src)
+MixerStrip::input_changed (IOChange /*change*/, void */*src*/)
 {
        Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_input_display));
+       set_width_enum (_width, this);
 }
 
 void
-MixerStrip::output_changed (IOChange change, void *src)
+MixerStrip::output_changed (IOChange /*change*/, void */*src*/)
 {
        Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_output_display));
+       set_width_enum (_width, this);
 }
 
 
-void 
-MixerStrip::comment_editor_done_editing() 
+void
+MixerStrip::comment_editor_done_editing()
 {
        string str =  comment_area->get_buffer()->get_text();
        if (_route->comment() != str) {
                _route->set_comment (str, this);
 
                switch (_width) {
-                  
+
                case Wide:
                        if (! str.empty()) {
                                comment_button.modify_bg (STATE_NORMAL, color());
@@ -833,7 +1218,7 @@ MixerStrip::comment_editor_done_editing()
                                ((Gtk::Label*)comment_button.get_child())->set_text (_("Comments"));
                        }
                        break;
-                  
+
                case Narrow:
                        if (! str.empty()) {
                                comment_button.modify_bg (STATE_NORMAL, color());
@@ -841,11 +1226,11 @@ MixerStrip::comment_editor_done_editing()
                        } else {
                                comment_button.unset_bg (STATE_NORMAL);
                                ((Gtk::Label*)comment_button.get_child())->set_text (_("Cmt"));
-                       } 
+                       }
                        break;
                }
-                
-               ARDOUR_UI::instance()->tooltips().set_tip (comment_button, 
+
+               ARDOUR_UI::instance()->tooltips().set_tip (comment_button,
                                str.empty() ? _("Click to Add/Edit Comments") : str);
        }
 
@@ -868,8 +1253,8 @@ MixerStrip::comment_button_clicked ()
        comment_window->get_size (cw_width, cw_height);
        comment_window->get_position(x, y);
        comment_window->move(x, y - (cw_height / 2) - 45);
-       /* 
-          half the dialog height minus the comments button height 
+       /*
+          half the dialog height minus the comments button height
           with some window decoration fudge thrown in.
        */
 
@@ -905,7 +1290,7 @@ void
 MixerStrip::comment_changed (void *src)
 {
        ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::comment_changed), src));
-       
+
        if (src != this) {
                ignore_comment_edit = true;
                if (comment_area) {
@@ -916,64 +1301,48 @@ MixerStrip::comment_changed (void *src)
 }
 
 void
-MixerStrip::set_mix_group (RouteGroup *rg)
+MixerStrip::set_route_group (RouteGroup *rg)
 {
-       _route->set_mix_group (rg, this);
-}
-
-void
-MixerStrip::add_mix_group_to_menu (RouteGroup *rg, RadioMenuItem::Group* group)
-{
-       using namespace Menu_Helpers;
-
-       MenuList& items = group_menu->items();
-
-       items.push_back (RadioMenuElem (*group, rg->name(), bind (mem_fun(*this, &MixerStrip::set_mix_group), rg)));
-
-       if (_route->mix_group() == rg) {
-               static_cast<RadioMenuItem*>(&items.back())->set_active ();
-       }
+       rg->add (_route);
 }
 
 bool
-MixerStrip::select_mix_group (GdkEventButton *ev)
+MixerStrip::select_route_group (GdkEventButton *ev)
 {
        using namespace Menu_Helpers;
 
-       if (group_menu == 0) {
-               group_menu = new Menu;
-       } 
-       group_menu->set_name ("ArdourContextMenu");
-       MenuList& items = group_menu->items();
-       RadioMenuItem::Group group;
+       if (ev->button == 1) {
 
-       switch (ev->button) {
-       case 1:
+               if (group_menu == 0) {
 
-               items.clear ();
-               items.push_back (RadioMenuElem (group, _("No group"), bind (mem_fun(*this, &MixerStrip::set_mix_group), (RouteGroup *) 0)));
+                       group_menu = new RouteGroupMenu (
+                               _session,
+                               (RouteGroup::Property) (RouteGroup::Gain | RouteGroup::Mute | RouteGroup::Solo)
+                               );
 
-               _session.foreach_mix_group (bind (mem_fun (*this, &MixerStrip::add_mix_group_to_menu), &group));
+                       group_menu->GroupSelected.connect (mem_fun (*this, &MixerStrip::set_route_group));
+               }
 
                group_menu->popup (1, ev->time);
-               break;
-
-       default:
-               break;
        }
-       
+
        return true;
-}      
+}
 
 void
-MixerStrip::mix_group_changed (void *ignored)
+MixerStrip::route_group_changed ()
 {
-       ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::mix_group_changed), ignored));
-       
-       RouteGroup *rg = _route->mix_group();
-       
+       ENSURE_GUI_THREAD (mem_fun(*this, &MixerStrip::route_group_changed));
+
+       RouteGroup *rg = _route->route_group();
+
        if (rg) {
-               group_label.set_text (rg->name());
+               /* XXX: this needs a better algorithm */
+               string truncated = rg->name ();
+               if (truncated.length () > 5) {
+                       truncated = truncated.substr (0, 5);
+               }
+               group_label.set_text (truncated);
        } else {
                switch (_width) {
                case Wide:
@@ -987,11 +1356,11 @@ MixerStrip::mix_group_changed (void *ignored)
 }
 
 
-void 
+void
 MixerStrip::route_gui_changed (string what_changed, void* ignored)
 {
        ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::route_gui_changed), what_changed, ignored));
-       
+
        if (what_changed == "color") {
                if (set_color_from_route () == 0) {
                        show_route_color ();
@@ -1017,12 +1386,14 @@ void
 MixerStrip::build_route_ops_menu ()
 {
        using namespace Menu_Helpers;
-       route_ops_menu = manage (new Menu);
+       route_ops_menu = new Menu;
        route_ops_menu->set_name ("ArdourContextMenu");
 
        MenuList& items = route_ops_menu->items();
 
+       items.push_back (MenuElem (_("Save As Template"), mem_fun(*this, &RouteUI::save_as_template)));
        items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteUI::route_rename)));
+       rename_menu_item = &items.back();
        items.push_back (SeparatorElem());
        items.push_back (CheckMenuElem (_("Active"), mem_fun (*this, &RouteUI::toggle_route_active)));
        route_active_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
@@ -1040,10 +1411,10 @@ MixerStrip::build_route_ops_menu ()
        denormal_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
        denormal_menu_item->set_active (_route->denormal_protection());
 
-       build_remote_control_menu ();
-       
-       items.push_back (SeparatorElem());
-       items.push_back (MenuElem (_("Remote Control ID"), *remote_control_menu));
+       if (!Profile->get_sae()) {
+               items.push_back (SeparatorElem());
+               items.push_back (MenuElem (_("Remote Control ID..."), mem_fun (*this, &RouteUI::open_remote_control_id_dialog)));
+        }
 
        items.push_back (SeparatorElem());
        items.push_back (MenuElem (_("Remove"), mem_fun(*this, &RouteUI::remove_this_route)));
@@ -1052,13 +1423,11 @@ MixerStrip::build_route_ops_menu ()
 gint
 MixerStrip::name_button_button_press (GdkEventButton* ev)
 {
-       if (ev->button == 1) {
+       if (ev->button == 1 || ev->button == 3) {
                list_route_operations ();
 
-               Menu_Helpers::MenuList& items = route_ops_menu->items();
                /* do not allow rename if the track is record-enabled */
-               static_cast<MenuItem*> (&items.front())->set_sensitive (!_route->record_enabled());
-
+               rename_menu_item->set_sensitive (!_route->record_enabled());
                route_ops_menu->popup (1, ev->time);
        }
        return FALSE;
@@ -1070,47 +1439,8 @@ MixerStrip::list_route_operations ()
        if (route_ops_menu == 0) {
                build_route_ops_menu ();
        }
-       
-       refresh_remote_control_menu();
 }
 
-
-void
-MixerStrip::speed_adjustment_changed ()
-{
-       /* since there is a usable speed adjustment, there has to be a diskstream */
-       if (!ignore_speed_adjustment) {
-               get_diskstream()->set_speed (speed_adjustment.get_value());
-       }
-}
-
-void
-MixerStrip::speed_changed ()
-{
-       Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_speed_display));
-}
-
-void
-MixerStrip::update_speed_display ()
-{
-       float val;
-       
-       val = get_diskstream()->speed();
-
-       if (val != 1.0) {
-               speed_spinner.set_name ("MixerStripSpeedBaseNotOne");
-       } else {
-               speed_spinner.set_name ("MixerStripSpeedBase");
-       }
-
-       if (speed_adjustment.get_value() != val) {
-               ignore_speed_adjustment = true;
-               speed_adjustment.set_value (val);
-               ignore_speed_adjustment = false;
-       }
-}                      
-
-
 void
 MixerStrip::set_selected (bool yn)
 {
@@ -1146,10 +1476,10 @@ MixerStrip::width_clicked ()
 {
        switch (_width) {
        case Wide:
-               set_width (Narrow, this);
+               set_width_enum (Narrow, this);
                break;
        case Narrow:
-               set_width (Wide, this);
+               set_width_enum (Wide, this);
                break;
        }
 }
@@ -1157,16 +1487,16 @@ MixerStrip::width_clicked ()
 void
 MixerStrip::hide_clicked ()
 {
-    // LAME fix to reset the button status for when it is redisplayed (part 1)
-    hide_button.set_sensitive(false);
-    
+       // LAME fix to reset the button status for when it is redisplayed (part 1)
+       hide_button.set_sensitive(false);
+
        if (_embedded) {
-                Hiding(); /* EMIT_SIGNAL */
+               Hiding(); /* EMIT_SIGNAL */
        } else {
                _mixer.hide_strip (this);
        }
-       
-    // (part 2)
+
+       // (part 2)
        hide_button.set_sensitive(true);
 }
 
@@ -1186,25 +1516,34 @@ MixerStrip::map_frozen ()
        if (at) {
                switch (at->freeze_state()) {
                case AudioTrack::Frozen:
-                       pre_processor_box.set_sensitive (false);
-                       post_processor_box.set_sensitive (false);
-                       speed_spinner.set_sensitive (false);
+                       processor_box.set_sensitive (false);
                        break;
                default:
-                       pre_processor_box.set_sensitive (true);
-                       post_processor_box.set_sensitive (true);
-                       speed_spinner.set_sensitive (true);
+                       processor_box.set_sensitive (true);
+                       // XXX need some way, maybe, to retoggle redirect editors
                        break;
                }
        }
-       _route->foreach_processor (this, &MixerStrip::hide_processor_editor);
+
+       hide_redirect_editors ();
 }
 
 void
-MixerStrip::hide_processor_editor (boost::shared_ptr<Processor> processor)
+MixerStrip::hide_redirect_editors ()
 {
+       _route->foreach_processor (mem_fun (*this, &MixerStrip::hide_processor_editor));
+}
+
+void
+MixerStrip::hide_processor_editor (boost::weak_ptr<Processor> p)
+{
+       boost::shared_ptr<Processor> processor (p.lock ());
+       if (!processor) {
+               return;
+       }
+
        void* gui = processor->get_gui ();
-       
+
        if (gui) {
                static_cast<Gtk::Widget*>(gui)->hide ();
        }
@@ -1214,43 +1553,55 @@ void
 MixerStrip::route_active_changed ()
 {
        RouteUI::route_active_changed ();
+       reset_strip_style ();
+}
+
+void
+MixerStrip::reset_strip_style ()
+{
+       if (_current_delivery && boost::dynamic_pointer_cast<Send>(_current_delivery)) {
+
+               gpm.set_fader_name ("SendStripBase");
 
-       if (is_midi_track()) {
-               if (_route->active()) {
-                       set_name ("MidiTrackStripBase");
-                       gpm.set_meter_strip_name ("MidiTrackStripBase");
-               } else {
-                       set_name ("MidiTrackStripBaseInactive");
-                       gpm.set_meter_strip_name ("MidiTrackStripBaseInactive");
-               }
-               gpm.set_fader_name ("MidiTrackFader");
-       } else if (is_audio_track()) {
-               if (_route->active()) {
-                       set_name ("AudioTrackStripBase");
-                       gpm.set_meter_strip_name ("AudioTrackMetrics");
-               } else {
-                       set_name ("AudioTrackStripBaseInactive");
-                       gpm.set_meter_strip_name ("AudioTrackMetricsInactive");
-               }
-               gpm.set_fader_name ("AudioTrackFader");
        } else {
-               if (_route->active()) {
-                       set_name ("AudioBusStripBase");
-                       gpm.set_meter_strip_name ("AudioBusMetrics");
+               
+               if (is_midi_track()) {
+                       if (_route->active()) {
+                               set_name ("MidiTrackStripBase");
+                               gpm.set_meter_strip_name ("MidiTrackStripBase");
+                       } else {
+                               set_name ("MidiTrackStripBaseInactive");
+                               gpm.set_meter_strip_name ("MidiTrackStripBaseInactive");
+                       }
+                       gpm.set_fader_name ("MidiTrackFader");
+               } else if (is_audio_track()) {
+                       if (_route->active()) {
+                               set_name ("AudioTrackStripBase");
+                               gpm.set_meter_strip_name ("AudioTrackMetrics");
+                       } else {
+                               set_name ("AudioTrackStripBaseInactive");
+                               gpm.set_meter_strip_name ("AudioTrackMetricsInactive");
+                       }
+                       gpm.set_fader_name ("AudioTrackFader");
                } else {
-                       set_name ("AudioBusStripBaseInactive");
-                       gpm.set_meter_strip_name ("AudioBusMetricsInactive");
+                       if (_route->active()) {
+                               set_name ("AudioBusStripBase");
+                               gpm.set_meter_strip_name ("AudioBusMetrics");
+                       } else {
+                               set_name ("AudioBusStripBaseInactive");
+                               gpm.set_meter_strip_name ("AudioBusMetricsInactive");
+                       }
+                       gpm.set_fader_name ("AudioBusFader");
+                       
+                       /* (no MIDI busses yet) */
                }
-               gpm.set_fader_name ("AudioBusFader");
-               
-               /* (no MIDI busses yet) */
        }
 }
 
 RouteGroup*
-MixerStrip::mix_group() const
+MixerStrip::route_group() const
 {
-       return _route->mix_group();
+       return _route->route_group();
 }
 
 void
@@ -1263,26 +1614,294 @@ MixerStrip::engine_running ()
 {
 }
 
+/** Called when the metering point has changed */
 void
 MixerStrip::meter_changed (void *src)
 {
-
        ENSURE_GUI_THREAD (bind (mem_fun(*this, &MixerStrip::meter_changed), src));
 
        switch (_route->meter_point()) {
-               case MeterInput:
-                       meter_point_label.set_text (_("input"));
-                       break;
+       case MeterInput:
+               meter_point_label.set_text (_("input"));
+               break;
 
-               case MeterPreFader:
-                       meter_point_label.set_text (_("pre"));
-                       break;
+       case MeterPreFader:
+               meter_point_label.set_text (_("pre"));
+               break;
 
-               case MeterPostFader:
-                       meter_point_label.set_text (_("post"));
-                       break;
+       case MeterPostFader:
+               meter_point_label.set_text (_("post"));
+               break;
+
+       case MeterCustom:
+               meter_point_label.set_text (_("custom"));
+               break;
        }
 
        gpm.setup_meters ();
+       // reset peak when meter point changes
+       gpm.reset_peak_display();
+}
+
+void
+MixerStrip::switch_io (boost::shared_ptr<Route> target)
+{
+       /* don't respond to switch IO signal outside of the mixer window */
+
+       if (!_mixer_owned) {
+               return;
+       }
+
+       if (_route == target || _route->is_master()) {
+               /* don't change the display for the target or the master bus */
+               return;
+       } else if (!is_track() && show_sends_button) {
+               /* make sure our show sends button is inactive, and we no longer blink,
+                  since we're not the target.
+               */
+               send_blink_connection.disconnect ();
+               show_sends_button->set_active (false);
+               show_sends_button->set_state (STATE_NORMAL);
+       }
+
+       if (!target) {
+               /* switch back to default */
+               revert_to_default_display ();
+               return;
+       }
+
+       boost::shared_ptr<Send> send = _route->internal_send_for (target);
+
+       if (send) {
+               show_send (send);
+       } else {
+               revert_to_default_display ();
+       }
+}
+
+void
+MixerStrip::drop_send ()
+{
+       boost::shared_ptr<Send> current_send;
+
+       if (_current_delivery && (current_send = boost::dynamic_pointer_cast<Send>(_current_delivery))) {
+               current_send->set_metering (false);
+       }
+
+       send_gone_connection.disconnect ();
+       input_button.set_sensitive (true);
+       output_button.set_sensitive (true);
+}
+
+void
+MixerStrip::show_send (boost::shared_ptr<Send> send)
+{
+       assert (send != 0);
+
+       drop_send ();
+
+       _current_delivery = send;
+
+       send->set_metering (true);
+       send_gone_connection = _current_delivery->GoingAway.connect (mem_fun (*this, &MixerStrip::revert_to_default_display));
+
+       gain_meter().set_controls (_route, send->meter(), send->amp());
+       gain_meter().setup_meters ();
+
+       panner_ui().set_panner (_current_delivery->panner());
+       panner_ui().setup_pan ();
+
+       input_button.set_sensitive (false);
+
+       if (boost::dynamic_pointer_cast<InternalSend>(send)) {
+               output_button.set_sensitive (false);
+       }
+
+       reset_strip_style ();
+}
+
+void
+MixerStrip::revert_to_default_display ()
+{
+       if (show_sends_button) {
+               show_sends_button->set_active (false);
+       }
+
+       drop_send ();
+
+       _current_delivery = _route->main_outs();
+
+       gain_meter().set_controls (_route, _route->shared_peak_meter(), _route->amp());
+       gain_meter().setup_meters ();
+
+       panner_ui().set_panner (_route->main_outs()->panner());
+       panner_ui().setup_pan ();
+
+       reset_strip_style ();
+}
+
+void
+MixerStrip::set_button_names ()
+{
+       switch (_width) {
+       case Wide:
+               rec_enable_button_label.set_text (_("Rec"));
+               mute_button_label.set_text (_("Mute"));
+               if (!Config->get_solo_control_is_listen_control()) {
+                       solo_button_label.set_text (_("Solo"));
+               } else {
+                       switch (Config->get_listen_position()) {
+                       case AfterFaderListen:
+                               solo_button_label.set_text (_("AFL"));
+                               break;
+                       case PreFaderListen:
+                               solo_button_label.set_text (_("PFL"));
+                               break;
+                       }
+               }
+               break;
+
+       default:
+               rec_enable_button_label.set_text (_("R"));
+               mute_button_label.set_text (_("M"));
+               if (!Config->get_solo_control_is_listen_control()) {
+                       solo_button_label.set_text (_("S"));
+               } else {
+                       switch (Config->get_listen_position()) {
+                       case AfterFaderListen:
+                               solo_button_label.set_text (_("A"));
+                               break;
+                       case PreFaderListen:
+                               solo_button_label.set_text (_("P"));
+                               break;
+                       }
+               }
+               break;
+
+       }
+}
+
+bool
+MixerStrip::on_key_press_event (GdkEventKey* ev)
+{
+       GdkEventButton fake;
+       fake.type = GDK_BUTTON_PRESS;
+       fake.button = 1;
+       fake.state = ev->state;
+
+       switch (ev->keyval) {
+       case GDK_m:
+               mute_press (&fake);
+               return true;
+               break;
+
+       case GDK_s:
+               solo_press (&fake);
+               return true;
+               break;
+
+       case GDK_r:
+               rec_enable_press (&fake);
+               return true;
+               break;
+
+       case GDK_e:
+               show_sends_press (&fake);
+               return true;
+               break;
+
+       case GDK_g:
+               if (ev->state & Keyboard::PrimaryModifier) {
+                       step_gain_down ();
+               } else {
+                       step_gain_up ();
+               }
+               return true;
+               break;
+
+       case GDK_0:
+               if (_route) {
+                       _route->set_gain (1.0, this);
+               }
+               return true;
+
+       default:
+               break;
+       }
+
+       return false;
 }
 
+
+bool
+MixerStrip::on_key_release_event (GdkEventKey* ev)
+{
+       GdkEventButton fake;
+       fake.type = GDK_BUTTON_RELEASE;
+       fake.button = 1;
+       fake.state = ev->state;
+
+       switch (ev->keyval) {
+       case GDK_m:
+               mute_release (&fake);
+               return true;
+               break;
+
+       case GDK_s:
+               solo_release (&fake);
+               return true;
+               break;
+
+       case GDK_r:
+               rec_enable_release (&fake);
+               return true;
+               break;
+
+       case GDK_e:
+               show_sends_release (&fake);
+               return true;
+               break;
+
+       case GDK_g:
+               return true;
+               break;
+
+       default:
+               break;
+       }
+
+       return false;
+}
+
+bool
+MixerStrip::on_enter_notify_event (GdkEventCrossing*)
+{
+       Keyboard::magic_widget_grab_focus ();
+       grab_focus ();
+       return false;
+}
+
+bool
+MixerStrip::on_leave_notify_event (GdkEventCrossing* ev)
+{
+       switch (ev->detail) {
+       case GDK_NOTIFY_INFERIOR:
+               break;
+       default:
+               Keyboard::magic_widget_drop_focus ();
+       }
+
+       return false;
+}
+
+void
+MixerStrip::mono_button_clicked ()
+{
+       panners.set_mono (_mono_button.get_active ());
+}
+
+PluginSelector*
+MixerStrip::plugin_selector()
+{
+       return _mixer.plugin_selector();
+}