make RouteUI and its children and relations able to switch the Route/IO object they refer to (significant architectural changes)

git-svn-id: svn://localhost/ardour2/branches/2.0-ongoing@3869 d708f5d6-7413-0410-9779-e7cbd77b26cf

19 files changed, 588 insertions, 325 deletions

diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index ab4591177d..c8d0c8afdc 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -131,13 +131,13 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 	  shuttle_controllable ("shuttle", *this, TransportControllable::ShuttleControl),
 	  shuttle_controller_binding_proxy (shuttle_controllable),
 
-	  roll_button (roll_controllable),
-	  stop_button (stop_controllable),
-	  goto_start_button (goto_start_controllable),
-	  goto_end_button (goto_end_controllable),
-	  auto_loop_button (auto_loop_controllable),
-	  play_selection_button (play_selection_controllable),
-	  rec_button (rec_controllable),
+	  roll_button (&roll_controllable),
+	  stop_button (&stop_controllable),
+	  goto_start_button (&goto_start_controllable),
+	  goto_end_button (&goto_end_controllable),
+	  auto_loop_button (&auto_loop_controllable),
+	  play_selection_button (&play_selection_controllable),
+	  rec_button (&rec_controllable),
 	  
 	  shuttle_units_button (_("% ")),
 
diff --git a/gtk2_ardour/editor_mixer.cc b/gtk2_ardour/editor_mixer.cc
index 87ad8bb6b7..81b79965b9 100644
--- a/gtk2_ardour/editor_mixer.cc
+++ b/gtk2_ardour/editor_mixer.cc
@@ -58,53 +58,49 @@ Editor::show_editor_mixer (bool yn)
 {
 	show_editor_mixer_when_tracks_arrive = false;
 
+	if (!session) {
+		return;
+	}
+
 	if (yn) {
 
 		if (current_mixer_strip == 0) {
 
-			if (selection->tracks.empty()) {
-				
-				if (track_views.empty()) {	
-					show_editor_mixer_when_tracks_arrive = true;
-					return;
-				} 
-				
-				for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
-					AudioTimeAxisView* atv;
-
-					if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
-						
-						current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
-										      *session,
-										      atv->route(), false);
+			current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
+							      *session,
+							      false);
+			current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::cms_deleted));						
+		}
 
-						current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::cms_deleted));						
-						break;
-					}
+		
+		if (selection->tracks.empty()) {
+			
+			if (track_views.empty()) {	
+				show_editor_mixer_when_tracks_arrive = true;
+				return;
+			} 
+			
+			for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+				AudioTimeAxisView* atv;
+				
+				if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
+					current_mixer_strip->set_route (atv->route());
+					break;
 				}
+			}
 
-			} else {
-
-				sort_track_selection ();
-
-				for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
-					AudioTimeAxisView* atv;
-
-					if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
+		} else {
 
-						current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
-										      *session,
-										      atv->route(), false);
-						current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::cms_deleted));						
-						break;
-					}
+			sort_track_selection ();
+			
+			for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+				AudioTimeAxisView* atv;
+				
+				if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
+					current_mixer_strip->set_route (atv->route());
+					break;
 				}
-
 			}
-
-			if (current_mixer_strip == 0) {
-				return;
-			}		
 		}
 		
 		if (current_mixer_strip->get_parent() == 0) {
@@ -128,6 +124,7 @@ Editor::show_editor_mixer (bool yn)
 			}
 		}
 	}
+
 #ifdef GTKOSX
 	/* XXX gtk problem here */
 	ruler_label_event_box.queue_draw ();
@@ -140,7 +137,6 @@ void
 Editor::set_selected_mixer_strip (TimeAxisView& view)
 {
 	AudioTimeAxisView* at;
-	bool show = false;
 
 	if (!session || (at = dynamic_cast<AudioTimeAxisView*>(&view)) == 0) {
 		return;
@@ -154,21 +150,16 @@ Editor::set_selected_mixer_strip (TimeAxisView& view)
 			return;
 		}
 
-		if (current_mixer_strip->get_parent()) {
-			show = true;
-		}
-		delete current_mixer_strip;
-		current_mixer_strip = 0;
+	} else {
+		
+		current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
+						      *session,
+						      false);
+		current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::cms_deleted));
 	}
 
-	current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
-					      *session,
-					      at->route(), false);
-	current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::cms_deleted));
-	
-	if (show) {
-		show_editor_mixer (true);
-	}
+	current_mixer_strip->set_route (at->route());
+	show_editor_mixer (true);
 }
 
 double current = 0.0;
@@ -258,7 +249,7 @@ void
 Editor::current_mixer_strip_removed ()
 {
 	if (current_mixer_strip) {
-		/* it is being deleted */
+		/* it is being deleted elsewhere */
 		current_mixer_strip = 0;
 	}
 }
diff --git a/gtk2_ardour/gain_meter.cc b/gtk2_ardour/gain_meter.cc
index 0daa7e5470..1d05d43876 100644
--- a/gtk2_ardour/gain_meter.cc
+++ b/gtk2_ardour/gain_meter.cc
@@ -68,17 +68,18 @@ GainMeter::setup_slider_pix ()
 	}
 }
 
-GainMeterBase::GainMeterBase (boost::shared_ptr<IO> io, Session& s, 
+GainMeterBase::GainMeterBase (Session& s, 
 			      const Glib::RefPtr<Gdk::Pixbuf>& pix,
 			      bool horizontal)
-	: _io (io),
-	  _session (s),
+	: _session (s),
 	  // 0.781787 is the value needed for gain to be set to 0.
 	  gain_adjustment (0.781787, 0.0, 1.0, 0.01, 0.1),
 	  gain_automation_style_button (""),
 	  gain_automation_state_button ("")
 	
 {
+	using namespace Menu_Helpers;
+
 	ignore_toggle = false;
 	meter_menu = 0;
 	next_release_selects = false;
@@ -88,16 +89,14 @@ GainMeterBase::GainMeterBase (boost::shared_ptr<IO> io, Session& s,
 	if (horizontal) {
 		gain_slider = manage (new HSliderController (pix,
 							     &gain_adjustment,
-							     _io->gain_control(),
 							     false));
 	} else {
 		gain_slider = manage (new VSliderController (pix,
 							     &gain_adjustment,
-							     _io->gain_control(),
 							     false));
 	}
 
-	level_meter = new LevelMeter(_io, _session);
+	level_meter = new LevelMeter(_session);
 
 	gain_slider->signal_button_press_event().connect (mem_fun(*this, &GainMeter::start_gain_touch));
 	gain_slider->signal_button_release_event().connect (mem_fun(*this, &GainMeter::end_gain_touch));
@@ -130,13 +129,55 @@ GainMeterBase::GainMeterBase (boost::shared_ptr<IO> io, Session& s,
 	gain_automation_state_button.set_size_request(15, 15);
 	gain_automation_style_button.set_size_request(15, 15);
 
-	boost::shared_ptr<Route> r;
+	gain_astyle_menu.items().push_back (MenuElem (_("Trim")));
+	gain_astyle_menu.items().push_back (MenuElem (_("Abs")));
+	
+	gain_astate_menu.set_name ("ArdourContextMenu");
+	gain_astyle_menu.set_name ("ArdourContextMenu");
+
+	gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeterBase::gain_adjusted));
+	peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeterBase::peak_button_release), false);
+	gain_display.signal_key_press_event().connect (mem_fun(*this, &GainMeterBase::gain_key_press), false);
+
+	ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_peak_display));
+	ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_group_peak_display));
+
+	UI::instance()->theme_changed.connect (mem_fun(*this, &GainMeterBase::on_theme_changed));
+	ColorsChanged.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), false));
+	DPIReset.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), true));
+
+}
+
+GainMeterBase::~GainMeterBase ()
+{
+	if (meter_menu) {
+		delete meter_menu;
+	}
+
+	if (level_meter) {
+		delete level_meter;
+	}
+}
+
+void
+GainMeterBase::set_io (boost::shared_ptr<IO> io)
+{
+	connections.clear ();
+
+	_io = io;
+
+	level_meter->set_io (_io);
+	gain_slider->set_controllable (&_io->gain_control());
 
+	boost::shared_ptr<Route> r;
+	
 	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
 
 		if (!r->hidden()) {
 
 			using namespace Menu_Helpers;
+
+			gain_astate_menu.items().clear ();
 			
 			gain_astate_menu.items().push_back (MenuElem (_("Manual"), 
 								      bind (mem_fun (*_io, &IO::set_gain_automation_state), (AutoState) Off)));
@@ -147,51 +188,23 @@ GainMeterBase::GainMeterBase (boost::shared_ptr<IO> io, Session& s,
 			gain_astate_menu.items().push_back (MenuElem (_("Touch"),
 								      bind (mem_fun (*_io, &IO::set_gain_automation_state), (AutoState) Touch)));
 			
-			gain_astyle_menu.items().push_back (MenuElem (_("Trim")));
-			gain_astyle_menu.items().push_back (MenuElem (_("Abs")));
+			connections.push_back (gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_style_button_event), false));
+			connections.push_back (gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_state_button_event), false));
 			
-			gain_astate_menu.set_name ("ArdourContextMenu");
-			gain_astyle_menu.set_name ("ArdourContextMenu");
-			
-			gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_style_button_event), false);
-			gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_state_button_event), false);
-			
-			r->gain_automation_curve().automation_state_changed.connect (mem_fun(*this, &GainMeterBase::gain_automation_state_changed));
-			r->gain_automation_curve().automation_style_changed.connect (mem_fun(*this, &GainMeterBase::gain_automation_style_changed));
+			connections.push_back (r->gain_automation_curve().automation_state_changed.connect (mem_fun(*this, &GainMeterBase::gain_automation_state_changed)));
+			connections.push_back (r->gain_automation_curve().automation_style_changed.connect (mem_fun(*this, &GainMeterBase::gain_automation_style_changed)));
 			
 			gain_automation_state_changed ();
 		}
 	}
 
-	_io->gain_changed.connect (mem_fun(*this, &GainMeterBase::gain_changed));
-
-	gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeterBase::gain_adjusted));
-	peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeterBase::peak_button_release), false);
-	gain_display.signal_key_press_event().connect (mem_fun(*this, &GainMeterBase::gain_key_press), false);
+	connections.push_back (_io->gain_changed.connect (mem_fun(*this, &GainMeterBase::gain_changed)));
 
 	gain_changed (0);
 	show_gain ();
 
 	update_gain_sensitive ();
-	
-	ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_peak_display));
-	ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_group_peak_display));
-
-	UI::instance()->theme_changed.connect (mem_fun(*this, &GainMeterBase::on_theme_changed));
-	ColorsChanged.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), false));
-	DPIReset.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), true));
-}
-
-GainMeterBase::~GainMeterBase ()
-{
-	if (meter_menu) {
-		delete meter_menu;
-	}
-
-	if (level_meter) {
-		delete level_meter;
-	}
-}
+}	
 
 void
 GainMeterBase::hide_all_meters ()
@@ -740,10 +753,9 @@ GainMeterBase::on_theme_changed()
 	style_changed = true;
 }
 
-GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
-	: GainMeterBase (io, s, slider, false)
+GainMeter::GainMeter (Session& s)
+	: GainMeterBase (s, slider, false)
 {
-
 	gain_display_box.set_homogeneous (true);
 	gain_display_box.set_spacing (2);
 	gain_display_box.pack_start (gain_display, true, true);
@@ -773,6 +785,31 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
 	hbox.set_spacing (2);
 	hbox.pack_start (*fader_vbox, true, true);
 
+	set_spacing (2);
+
+	pack_start (gain_display_box, Gtk::PACK_SHRINK);
+	pack_start (hbox, Gtk::PACK_SHRINK);
+
+	meter_metric_area.signal_expose_event().connect (mem_fun(*this, &GainMeter::meter_metrics_expose));
+}
+
+void
+GainMeter::set_io (boost::shared_ptr<IO> io)
+{
+	if (level_meter->get_parent()) {
+		hbox.remove (*level_meter);
+	}
+
+	if (peak_display.get_parent()) {
+		gain_display_box.remove (peak_display);
+	}
+
+	if (gain_automation_state_button.get_parent()) {
+		fader_vbox->remove (gain_automation_state_button);
+	}
+
+	GainMeterBase::set_io (io);
+
 	boost::shared_ptr<Route> r;
 
 	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
@@ -789,16 +826,8 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
 			fader_vbox->pack_start (gain_automation_state_button, false, false, 0);
 		}
 	}
-
-	set_spacing (2);
-
-	pack_start (gain_display_box, Gtk::PACK_SHRINK);
-	pack_start (hbox, Gtk::PACK_SHRINK);
-
-	meter_metric_area.signal_expose_event().connect (mem_fun(*this, &GainMeter::meter_metrics_expose));
 }
 
-
 int
 GainMeter::get_gm_width ()
 {
diff --git a/gtk2_ardour/gain_meter.h b/gtk2_ardour/gain_meter.h
index cef6c02024..3e025656c5 100644
--- a/gtk2_ardour/gain_meter.h
+++ b/gtk2_ardour/gain_meter.h
@@ -57,10 +57,12 @@ namespace Gtk {
 class GainMeterBase : virtual public sigc::trackable
 {
   public:
-	GainMeterBase (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&, const Glib::RefPtr<Gdk::Pixbuf>& pix,
+	GainMeterBase ( ARDOUR::Session&, const Glib::RefPtr<Gdk::Pixbuf>& pix,
 		       bool horizontal);
 	virtual ~GainMeterBase ();
 
+	virtual void set_io (boost::shared_ptr<ARDOUR::IO>);
+
 	void update_gain_sensitive ();
 	void update_meters ();
 	void effective_gain_display ();
@@ -79,6 +81,7 @@ class GainMeterBase : virtual public sigc::trackable
 	friend class MixerStrip;
 	boost::shared_ptr<ARDOUR::IO> _io;
 	ARDOUR::Session& _session;
+	std::vector<sigc::connection> connections;
 
 	bool ignore_toggle;
 	bool next_release_selects;
@@ -166,9 +169,11 @@ class GainMeterBase : virtual public sigc::trackable
 class GainMeter : public GainMeterBase, public Gtk::VBox
 {
   public:
-	GainMeter (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+	GainMeter (ARDOUR::Session&);
 	~GainMeter () {}
 
+	void set_io (boost::shared_ptr<ARDOUR::IO>);
+
 	int get_gm_width ();
 	void setup_meters (int len=0);
 
diff --git a/gtk2_ardour/level_meter.cc b/gtk2_ardour/level_meter.cc
index 601f4c45dc..f6680db79c 100644
--- a/gtk2_ardour/level_meter.cc
+++ b/gtk2_ardour/level_meter.cc
@@ -57,9 +57,8 @@ using namespace std;
 //sigc::signal<void,RouteGroup*> LevelMeter::ResetGroupPeakDisplays;
 
 
-LevelMeter::LevelMeter (boost::shared_ptr<IO> io, Session& s)
-	: _io (io),
-	  _session (s)
+LevelMeter::LevelMeter (Session& s)
+	: _session (s)
 	
 {
 	set_spacing (1);
@@ -84,6 +83,12 @@ LevelMeter::~LevelMeter ()
 	}
 }
 
+void
+LevelMeter::set_io (boost::shared_ptr<IO> io)
+{
+	_io = io;
+}
+
 float
 LevelMeter::update_meters ()
 {
@@ -140,6 +145,10 @@ LevelMeter::hide_all_meters ()
 void
 LevelMeter::setup_meters (int len, int initial_width)
 {
+	if (!_io) {
+		return; /* do it later */
+	}
+
 	regular_meter_width = initial_width;
 	uint32_t nmeters = _io->n_outputs();
 	guint16 width;
diff --git a/gtk2_ardour/level_meter.h b/gtk2_ardour/level_meter.h
index ce0aa125cb..521b9d1d8f 100644
--- a/gtk2_ardour/level_meter.h
+++ b/gtk2_ardour/level_meter.h
@@ -56,9 +56,11 @@ namespace Gtk {
 class LevelMeter : public Gtk::HBox
 {
   public:
-	LevelMeter (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+	LevelMeter (ARDOUR::Session&);
 	~LevelMeter ();
 
+	virtual void set_io (boost::shared_ptr<ARDOUR::IO> io);
+
 	void update_gain_sensitive ();
 
 	float update_meters ();
diff --git a/gtk2_ardour/mixer_strip.cc b/gtk2_ardour/mixer_strip.cc
index c0e35ae30a..5d53121d77 100644
--- a/gtk2_ardour/mixer_strip.cc
+++ b/gtk2_ardour/mixer_strip.cc
@@ -83,15 +83,36 @@ speed_printer (char buf[32], Gtk::Adjustment& adj, void* arg)
 }
 #endif 
 
+MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, bool in_mixer)
+	: AxisView(sess),
+	  RouteUI (sess, _("Mute"), _("Solo"), _("Record")),
+	  _mixer(mx),
+	  _mixer_owned (in_mixer),
+	  pre_redirect_box (PreFader, sess, mx.plugin_selector(), mx.selection(), in_mixer),
+	  post_redirect_box (PostFader, sess, mx.plugin_selector(), mx.selection(), in_mixer),
+	  gpm (sess),
+	  panners (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)
+
+{
+	init ();
+}
+
 MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt, bool in_mixer)
 	: AxisView(sess),
-	  RouteUI (rt, sess, _("Mute"), _("Solo"), _("Record")),
+	  RouteUI (sess, _("Mute"), _("Solo"), _("Record")),
 	  _mixer(mx),
 	  _mixer_owned (in_mixer),
-	  pre_redirect_box (PreFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
-	  post_redirect_box (PostFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
-	  gpm (_route, sess),
-	  panners (_route, sess),
+	  pre_redirect_box (PreFader, sess, mx.plugin_selector(), mx.selection(), in_mixer),
+	  post_redirect_box (PostFader, sess, mx.plugin_selector(), mx.selection(), in_mixer),
+	  gpm (sess),
+	  panners (sess),
 	  button_table (3, 2),
 	  middle_button_table (1, 2),
 	  bottom_button_table (1, 2),
@@ -101,10 +122,13 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 	  speed_spinner (&speed_adjustment, "MixerStripSpeedBase", true)
 
 {
-	if (set_color_from_route()) {
-		set_color (unique_random_color());
-	}
+	init ();
+	set_route (rt);
+}
 
+void
+MixerStrip::init ()
+{
 	input_selector = 0;
 	output_selector = 0;
 	group_menu = 0;
@@ -130,25 +154,10 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 	output_button.set_name ("MixerIOButton");
 	output_label.set_name ("MixerIOButtonLabel");
 
-	_route->meter_change.connect (mem_fun(*this, &MixerStrip::meter_changed));
 	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".
 	*/
@@ -180,55 +189,17 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 	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);
 
 	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());
-	}
-
 	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);
@@ -263,19 +234,6 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 	global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
 	global_vpacker.pack_start (comment_button, Gtk::PACK_SHRINK);
 
-	if (route()->master() || route()->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");
@@ -292,22 +250,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->name_changed.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);
@@ -317,11 +259,18 @@ 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));
+
 	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);
 
 	_width = (Width) -1;
-	set_stuff_from_route ();
 
 	/* start off as a passthru strip. we'll correct this, if necessary,
 	   in update_diskstream_display().
@@ -329,6 +278,126 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 
 	set_name ("AudioTrackStripBase");
 
+	add_events (Gdk::BUTTON_RELEASE_MASK);
+}
+
+MixerStrip::~MixerStrip ()
+{
+	GoingAway(); /* EMIT_SIGNAL */
+
+	if (input_selector) {
+		delete input_selector;
+	}
+
+	if (output_selector) {
+		delete output_selector;
+	}
+}
+
+void
+MixerStrip::set_route (boost::shared_ptr<Route> rt)
+{
+	if (rec_enable_button->get_parent()) {
+		button_table.remove (*rec_enable_button);
+	}
+
+#ifdef VARISPEED_IN_MIXER_STRIP
+	if (speed_frame->get_parent()) {
+		button_table.remove (*speed_frame);
+	}
+#endif
+
+	RouteUI::set_route (rt);
+
+	panners.set_io (rt);
+	gpm.set_io (rt);
+	pre_redirect_box.set_route (rt);
+	post_redirect_box.set_route (rt);
+
+	if (set_color_from_route()) {
+		set_color (unique_random_color());
+	}
+
+	if (_mixer_owned && (route()->master() || route()->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);
+	}
+
+	if (is_audio_track()) {
+
+		boost::shared_ptr<AudioTrack> at = audio_track();
+
+		connections.push_back (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);
+	}
+
+	if (_route->phase_invert()) {
+	        name_label.set_text (X_("Ø ") + name_label.get_text());
+	} else {
+	        name_label.set_text (_route->name());
+	}
+
+	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;
+	}
+	
+	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->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed)));
+	connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+	connections.push_back (_route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+	connections.push_back (_route->mix_group_changed.connect (mem_fun(*this, &MixerStrip::mix_group_changed)));
+	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 (get_diskstream()->SpeedChanged.connect (mem_fun(*this, &MixerStrip::speed_changed)));
+	}
+
+	connections.push_back (_route->name_changed.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_redirect_box.update();
@@ -350,21 +419,6 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt
 	update_diskstream_display ();
 	update_input_display ();
 	update_output_display ();
-
-	add_events (Gdk::BUTTON_RELEASE_MASK);
-}
-
-MixerStrip::~MixerStrip ()
-{
-	GoingAway(); /* EMIT_SIGNAL */
-
-	if (input_selector) {
-		delete input_selector;
-	}
-
-	if (output_selector) {
-		delete output_selector;
-	}
 }
 
 void
@@ -734,6 +788,7 @@ MixerStrip::update_output_display ()
 			break;
 		}
 	}
+
 	gpm.setup_meters ();
 	panners.setup_pan ();
 }
@@ -1213,23 +1268,23 @@ 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 MeterPreFader:
-			meter_point_label.set_text (_("pre"));
-			break;
-			
-		case MeterPostFader:
-			meter_point_label.set_text (_("post"));
-			break;
-		}
-
-		gpm.setup_meters ();
-		// reset peak when meter point changes
-		gpm.reset_peak_display();
-		set_width(_width, this);
+	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;
+	}
+	
+	gpm.setup_meters ();
+	// reset peak when meter point changes
+	gpm.reset_peak_display();
+	set_width (_width, this);
 }
 
diff --git a/gtk2_ardour/mixer_strip.h b/gtk2_ardour/mixer_strip.h
index 464ec51433..f34f39b82b 100644
--- a/gtk2_ardour/mixer_strip.h
+++ b/gtk2_ardour/mixer_strip.h
@@ -83,6 +83,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
 {
   public:
 	MixerStrip (Mixer_UI&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, bool in_mixer = true);
+	MixerStrip (Mixer_UI&, ARDOUR::Session&, bool in_mixer = true);
 	~MixerStrip ();
 
 	void set_width (Width, void* owner);
@@ -93,6 +94,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
 	void set_embedded (bool);
 	
 	ARDOUR::RouteGroup* mix_group() const;
+	void set_route (boost::shared_ptr<ARDOUR::Route>);
 
   protected:
 	friend class Mixer_UI;
@@ -105,6 +107,8 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
   private:
 	Mixer_UI& _mixer;
 
+	void init ();
+
 	bool  _embedded;
 	bool  _packed;
 	bool  _mixer_owned;
diff --git a/gtk2_ardour/option_editor.cc b/gtk2_ardour/option_editor.cc
index bd158d4d70..c440ea62f9 100644
--- a/gtk2_ardour/option_editor.cc
+++ b/gtk2_ardour/option_editor.cc
@@ -1056,7 +1056,8 @@ OptionEditor::setup_click_editor ()
 	click_emphasis_path_entry.set_sensitive (true);
 
 	click_io_selector = new IOSelector (*session, session->click_io(), false);
-	click_gpm = new GainMeter (session->click_io(), *session);
+	click_gpm = new GainMeter (*session);
+	click_gpm->set_io (session->click_io());
 
 	click_hpacker.pack_start (*click_io_selector, false, false);
 	click_hpacker.pack_start (*click_gpm, false, false);
@@ -1098,7 +1099,8 @@ void
 OptionEditor::connect_audition_editor ()
 {
 	auditioner_io_selector = new IOSelector (*session, session->the_auditioner(), false);
-	auditioner_gpm = new GainMeter (session->the_auditioner(), *session);
+	auditioner_gpm = new GainMeter (*session);
+	auditioner_gpm->set_io (session->the_auditioner());
 
 	audition_hpacker.pack_start (*auditioner_io_selector, false, false);
 	audition_hpacker.pack_start (*auditioner_gpm, false, false);
diff --git a/gtk2_ardour/panner_ui.cc b/gtk2_ardour/panner_ui.cc
index fcbaf8d8bb..97a72fa87a 100644
--- a/gtk2_ardour/panner_ui.cc
+++ b/gtk2_ardour/panner_ui.cc
@@ -47,9 +47,8 @@ using namespace sigc;
 
 const int PannerUI::pan_bar_height = 30;
 
-PannerUI::PannerUI (boost::shared_ptr<IO> io, Session& s)
-	: _io (io),
-	  _session (s),
+PannerUI::PannerUI (Session& s)
+	: _session (s),
 	  hAdjustment(0.0, 0.0, 0.0),
 	  vAdjustment(0.0, 0.0, 0.0),
 	  panning_viewport(hAdjustment, vAdjustment),
@@ -61,6 +60,8 @@ PannerUI::PannerUI (boost::shared_ptr<IO> io, Session& s)
 {
 	ignore_toggle = false;
 	pan_menu = 0;
+	pan_astate_menu = 0;
+	pan_astyle_menu = 0;
 	in_pan_update = false;
 
 	pan_automation_style_button.set_name ("MixerAutomationModeButton");
@@ -84,22 +85,6 @@ PannerUI::PannerUI (boost::shared_ptr<IO> io, Session& s)
 	pan_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
 	pan_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
 
-	using namespace Menu_Helpers;
-	pan_astate_menu.items().push_back (MenuElem (_("Manual"), 
-						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Off)));
-	pan_astate_menu.items().push_back (MenuElem (_("Play"),
-						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Play)));
-	pan_astate_menu.items().push_back (MenuElem (_("Write"),
-						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Write)));
-	pan_astate_menu.items().push_back (MenuElem (_("Touch"),
-						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Touch)));
-
-	pan_astyle_menu.items().push_back (MenuElem (_("Trim")));
-	pan_astyle_menu.items().push_back (MenuElem (_("Abs")));
-
-	pan_astate_menu.set_name ("ArdourContextMenu");
-	pan_astyle_menu.set_name ("ArdourContextMenu");
-
 	pan_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &PannerUI::pan_automation_style_button_event), false);
 	pan_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &PannerUI::pan_automation_state_button_event), false);
 
@@ -141,10 +126,33 @@ PannerUI::PannerUI (boost::shared_ptr<IO> io, Session& s)
 	panner = 0;
 
 	set_width(Narrow);
+}
+
+void
+PannerUI::set_io (boost::shared_ptr<IO> io)
+{
+	connections.clear ();
+
+	if (pan_astyle_menu) {
+		delete pan_astyle_menu;
+		pan_astyle_menu = 0;
+	}
+
+	if (pan_astate_menu) {
+		delete pan_astate_menu;
+		pan_astate_menu = 0;
+	}
+			
+	_io = io;
 
-	_io->panner().Changed.connect (mem_fun(*this, &PannerUI::panner_changed));
-	_io->panner().LinkStateChanged.connect (mem_fun(*this, &PannerUI::update_pan_linkage));
-	_io->panner().StateChanged.connect (mem_fun(*this, &PannerUI::update_pan_state));
+	connections.push_back (_io->panner().Changed.connect (mem_fun(*this, &PannerUI::panner_changed)));
+	connections.push_back (_io->panner().LinkStateChanged.connect (mem_fun(*this, &PannerUI::update_pan_linkage)));
+	connections.push_back (_io->panner().StateChanged.connect (mem_fun(*this, &PannerUI::update_pan_state)));
+
+	if (panner) {
+		delete panner;
+		panner = 0;
+	}
 
 	pan_changed (0);
 	update_pan_sensitive ();
@@ -152,6 +160,45 @@ PannerUI::PannerUI (boost::shared_ptr<IO> io, Session& s)
 	pan_automation_state_changed ();
 }
 
+void
+PannerUI::build_astate_menu ()
+{
+	using namespace Menu_Helpers;
+
+	if (pan_astate_menu == 0) {
+		pan_astate_menu = new Menu;
+		pan_astate_menu->set_name ("ArdourContextMenu");
+	} else {
+		pan_astate_menu->items().clear ();
+	}
+
+	pan_astate_menu->items().push_back (MenuElem (_("Manual"), 
+						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Off)));
+	pan_astate_menu->items().push_back (MenuElem (_("Play"),
+						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Play)));
+	pan_astate_menu->items().push_back (MenuElem (_("Write"),
+						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Write)));
+	pan_astate_menu->items().push_back (MenuElem (_("Touch"),
+						     bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Touch)));
+
+}
+
+void
+PannerUI::build_astyle_menu ()
+{
+	using namespace Menu_Helpers;
+
+	if (pan_astyle_menu == 0) {
+		pan_astyle_menu = new Menu;
+		pan_astyle_menu->set_name ("ArdourContextMenu");
+	} else {
+		pan_astyle_menu->items().clear();
+	}
+
+	pan_astyle_menu->items().push_back (MenuElem (_("Trim")));
+	pan_astyle_menu->items().push_back (MenuElem (_("Abs")));
+}
+
 PBD::Controllable* 
 PannerUI::get_controllable() 
 { 
@@ -248,7 +295,14 @@ PannerUI::~PannerUI ()
 	if (pan_menu) {
 		delete pan_menu;
 	}
-
+	
+	if (pan_astyle_menu) {
+		delete pan_astyle_menu;
+	}
+	
+	if (pan_astate_menu) {
+		delete pan_astate_menu;
+	}
 }
 
 
@@ -647,7 +701,10 @@ PannerUI::pan_automation_state_button_event (GdkEventButton *ev)
 
 	switch (ev->button) {
 	case 1:
-		pan_astate_menu.popup (1, ev->time);
+		if (pan_astate_menu == 0) {
+			build_astate_menu ();
+		}
+		pan_astate_menu->popup (1, ev->time);
 		break;
 	default:
 		break;
@@ -665,7 +722,10 @@ PannerUI::pan_automation_style_button_event (GdkEventButton *ev)
 
 	switch (ev->button) {
 	case 1:
-		pan_astyle_menu.popup (1, ev->time);
+		if (pan_astyle_menu == 0) {
+			build_astyle_menu ();
+		}
+		pan_astyle_menu->popup (1, ev->time);
 		break;
 	default:
 		break;
diff --git a/gtk2_ardour/panner_ui.h b/gtk2_ardour/panner_ui.h
index 093800387d..11bffc1661 100644
--- a/gtk2_ardour/panner_ui.h
+++ b/gtk2_ardour/panner_ui.h
@@ -54,9 +54,11 @@ namespace Gtk {
 class PannerUI : public Gtk::HBox
 {
   public:
-	PannerUI (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+	PannerUI (ARDOUR::Session&);
 	~PannerUI ();
 
+	virtual void set_io (boost::shared_ptr<ARDOUR::IO>);
+
 	void pan_changed (void *);
 
 	void update_pan_sensitive ();
@@ -75,6 +77,7 @@ class PannerUI : public Gtk::HBox
 
 	boost::shared_ptr<ARDOUR::IO> _io;
 	ARDOUR::Session& _session;
+	std::vector<sigc::connection> connections;
 
 	bool ignore_toggle;
 	bool in_pan_update;
@@ -101,8 +104,8 @@ class PannerUI : public Gtk::HBox
 	bool panning_link_button_press (GdkEventButton*);
 	bool panning_link_button_release (GdkEventButton*);
 
-	Gtk::Menu pan_astate_menu;
-	Gtk::Menu pan_astyle_menu;
+	Gtk::Menu* pan_astate_menu;
+	Gtk::Menu* pan_astyle_menu;
 
 	Gtk::Button pan_automation_style_button;
 	Gtk::ToggleButton pan_automation_state_button;
@@ -118,6 +121,8 @@ class PannerUI : public Gtk::HBox
 	void update_pan_bars (bool only_if_aplay);
 	void update_pan_linkage ();
 	void update_pan_state ();
+	void build_astate_menu ();
+	void build_astyle_menu ();
 
 	void panner_changed ();
 	
diff --git a/gtk2_ardour/redirect_box.cc b/gtk2_ardour/redirect_box.cc
index 037123d169..de84a07db8 100644
--- a/gtk2_ardour/redirect_box.cc
+++ b/gtk2_ardour/redirect_box.cc
@@ -83,10 +83,9 @@ bool RedirectBox::get_colors = true;
 Gdk::Color* RedirectBox::active_redirect_color;
 Gdk::Color* RedirectBox::inactive_redirect_color;
 
-RedirectBox::RedirectBox (Placement pcmnt, Session& sess, boost::shared_ptr<Route> rt, PluginSelector &plugsel, 
-			  RouteRedirectSelection & rsel, bool owner_is_mixer)
-	: _route(rt), 
-	  _session(sess), 
+RedirectBox::RedirectBox (Placement pcmnt, Session& sess, PluginSelector &plugsel, 
+			  RouteRedirectSelection& rsel, bool owner_is_mixer)
+	: _session(sess), 
 	  _owner_is_mixer (owner_is_mixer), 
 	  _placement(pcmnt), 
 	  _plugin_selector(plugsel),
@@ -139,21 +138,10 @@ RedirectBox::RedirectBox (Placement pcmnt, Session& sess, boost::shared_ptr<Rout
 
 	pack_start (redirect_eventbox, true, true);
 
-	_route->redirects_changed.connect (mem_fun(*this, &RedirectBox::redisplay_redirects));
-	_route->GoingAway.connect (mem_fun (*this, &RedirectBox::route_going_away));
-
 	redirect_eventbox.signal_enter_notify_event().connect (bind (sigc::ptr_fun (RedirectBox::enter_box), this));
 
 	redirect_display.signal_button_press_event().connect (mem_fun(*this, &RedirectBox::redirect_button_press_event), false);
 	redirect_display.signal_button_release_event().connect (mem_fun(*this, &RedirectBox::redirect_button_release_event));
-
-	/* start off as a passthru strip. we'll correct this, if necessary,
-	   in update_diskstream_display().
-	*/
-
-	/* now force an update of all the various elements */
-
-	redisplay_redirects (0);
 }
 
 RedirectBox::~RedirectBox ()
@@ -161,6 +149,19 @@ RedirectBox::~RedirectBox ()
 }
 
 void
+RedirectBox::set_route (boost::shared_ptr<Route> r)
+{
+	connections.clear ();
+
+	_route = r;
+
+	connections.push_back (_route->redirects_changed.connect (mem_fun(*this, &RedirectBox::redisplay_redirects)));
+	connections.push_back (_route->GoingAway.connect (mem_fun (*this, &RedirectBox::route_going_away)));
+
+	redisplay_redirects (0);
+}
+
+void
 RedirectBox::route_going_away ()
 {
 	/* don't keep updating display as redirects are deleted */
diff --git a/gtk2_ardour/redirect_box.h b/gtk2_ardour/redirect_box.h
index 74a0832152..0d0ce84bd2 100644
--- a/gtk2_ardour/redirect_box.h
+++ b/gtk2_ardour/redirect_box.h
@@ -67,9 +67,11 @@ class RedirectBox : public Gtk::HBox, public PluginInterestedObject
 {
   public:
 	RedirectBox (ARDOUR::Placement, ARDOUR::Session&, 
-		     boost::shared_ptr<ARDOUR::Route>, PluginSelector &, RouteRedirectSelection &, bool owner_is_mixer = false);
+		     PluginSelector &, RouteRedirectSelection &, bool owner_is_mixer = false);
 	~RedirectBox ();
 
+	void set_route (boost::shared_ptr<ARDOUR::Route>);
+
 	void set_width (Width);
 
 	void update();
@@ -85,13 +87,11 @@ class RedirectBox : public Gtk::HBox, public PluginInterestedObject
 	
 	static void register_actions();
 
-  protected:
-	void set_stuff_from_route ();
-
   private:
 	boost::shared_ptr<ARDOUR::Route>  _route;
 	ARDOUR::Session &   _session;
 	bool                _owner_is_mixer;
+	std::vector<sigc::connection> connections;
 
 	ARDOUR::Placement   _placement;
 
diff --git a/gtk2_ardour/route_params_ui.cc b/gtk2_ardour/route_params_ui.cc
index 9904359fc2..d1a79de8af 100644
--- a/gtk2_ardour/route_params_ui.cc
+++ b/gtk2_ardour/route_params_ui.cc
@@ -220,8 +220,11 @@ RouteParams_UI::setup_redirect_boxes()
 		cleanup_redirect_boxes();
 		
 		// construct new redirect boxes
-		pre_redirect_box = new RedirectBox(PreFader, *session, _route, *_plugin_selector, _rr_selection);
-		post_redirect_box = new RedirectBox(PostFader, *session, _route, *_plugin_selector, _rr_selection);
+		pre_redirect_box = new RedirectBox(PreFader, *session, *_plugin_selector, _rr_selection);
+		post_redirect_box = new RedirectBox(PostFader, *session, *_plugin_selector, _rr_selection);
+
+		pre_redirect_box->set_route (_route);
+		post_redirect_box->set_route (_route);
 
 	        pre_redir_hpane.pack1 (*pre_redirect_box);
 		post_redir_hpane.pack1 (*post_redirect_box);
diff --git a/gtk2_ardour/route_time_axis.cc b/gtk2_ardour/route_time_axis.cc
index 7cf3d24d27..f2c8575e7a 100644
--- a/gtk2_ardour/route_time_axis.cc
+++ b/gtk2_ardour/route_time_axis.cc
@@ -105,8 +105,9 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 	  size_button (_("h")), // height
 	  automation_button (_("a")),
 	  visual_button (_("v")),
-	  gm (rt, sess, slider, true)
+	  gm (sess, slider, true)
 {
+	gm.set_io (rt);
 	gm.get_level_meter().set_no_show_all();
 	gm.get_level_meter().setup_meters(50);
 
diff --git a/gtk2_ardour/route_ui.cc b/gtk2_ardour/route_ui.cc
index 6e4a8645c4..1b2264e270 100644
--- a/gtk2_ardour/route_ui.cc
+++ b/gtk2_ardour/route_ui.cc
@@ -47,13 +47,24 @@ using namespace Gtkmm2ext;
 using namespace ARDOUR;
 using namespace PBD;
 
-RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session& sess, const char* m_name,
-		  const char* s_name, const char* r_name)
-	: AxisView(sess),
-	  _route(rt),
-	  mute_button(0),
-	  solo_button(0),
-	  rec_enable_button(0)
+RouteUI::RouteUI (ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name)
+	: AxisView(sess)
+{
+	init ();
+	set_button_names (mute_name, solo_name, rec_name);
+}
+
+RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, 
+		  ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name)
+	: AxisView(sess)
+{
+	init ();
+	set_button_names (mute_name, solo_name, rec_name);
+	set_route (rt);
+}
+
+void
+RouteUI::init ()
 {
 	xml_node = 0;
 	mute_menu = 0;
@@ -66,49 +77,106 @@ RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session& sess, co
 	polarity_menu_item = 0;
 	denormal_menu_item = 0;
 
-	if (set_color_from_route()) {
-		set_color (unique_random_color());
+	mute_button = manage (new BindableToggleButton (0, ""));
+	mute_button->set_self_managed (true);
+	mute_button->set_name ("MuteButton");
+
+	solo_button = manage (new BindableToggleButton (0, ""));
+	solo_button->set_self_managed (true);
+	solo_button->set_name ("SoloButton");
+
+	rec_enable_button = manage (new BindableToggleButton (0, ""));
+	rec_enable_button->set_name ("RecordEnableButton");
+	rec_enable_button->set_self_managed (true);
+	
+	_session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute));
+}
+
+void
+RouteUI::reset ()
+{
+	connections.clear ();
+
+	if (solo_menu) {
+		delete solo_menu;
+		solo_menu = 0;
 	}
 
-	new PairedShiva<Route,RouteUI> (*_route, *this);
+	if (mute_menu) {
+		delete mute_menu;
+		mute_menu = 0;
+	}
+	
+	if (remote_control_menu) {
+		delete remote_control_menu;
+		remote_control_menu = 0;
+	}
 
-	_route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed));
+	if (xml_node) {
+		/* do not delete the node - its owned by the route */
+		xml_node = 0;
+	}
 
-        mute_button = manage (new BindableToggleButton (_route->mute_control(), m_name ));
-	mute_button->set_self_managed (true);
+	route_active_menu_item = 0;
+	polarity_menu_item = 0;
+	denormal_menu_item = 0;
+}
 
-        solo_button = manage (new BindableToggleButton (_route->solo_control(), s_name ));
-	solo_button->set_self_managed (true);
+void
+RouteUI::set_button_names (const char* mute, const char* solo, const char* rec)
+{
+	m_name = mute;
+	s_name = solo;
+	r_name = rec;
+}
 
-	mute_button->set_name ("MuteButton");
-	solo_button->set_name ("SoloButton");
+void
+RouteUI::set_route (boost::shared_ptr<Route> rp)
+{
+	reset ();
 
-	_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 = rp;
 
-	/* when solo changes, update mute state too, in case the user wants us to display it */
+	if (set_color_from_route()) {
+		set_color (unique_random_color());
+	}
 
-	_session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute));
+	/* no, there is no memory leak here. This object cleans itself (and other stuff)
+	   up when the route is destroyed.
+	*/
+
+	new PairedShiva<Route,RouteUI> (*_route, *this);
+
+	mute_button->set_controllable (&_route->mute_control());
+	mute_button->set_label (m_name);
 	
+	solo_button->set_controllable (&_route->solo_control());
+	solo_button->set_label (s_name);
+
+	connections.push_back (_route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed)));
+	connections.push_back (_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed)));
+	connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+	connections.push_back (_route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+
+	/* when solo changes, update mute state too, in case the user wants us to display it */
+
 	update_solo_display ();
 	update_mute_display ();
 
 	if (is_track()) {
 		boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
 
-		t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed));
+		connections.push_back (t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed)));
 
-		_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed));
+		connections.push_back (_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed)));
 
-		rec_enable_button = manage (new BindableToggleButton (t->rec_enable_control(), r_name ));
-		rec_enable_button->set_name ("RecordEnableButton");
-		rec_enable_button->set_self_managed (true);
+		rec_enable_button->set_controllable (&t->rec_enable_control());
+		rec_enable_button->set_label (r_name);
 
 		update_rec_display ();
 	} 
 	
-	_route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu));
+	connections.push_back (_route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu)));
 
 	/* map the current state */
 
@@ -118,7 +186,17 @@ RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session& sess, co
 RouteUI::~RouteUI()
 {
 	GoingAway (); /* EMIT SIGNAL */
-	delete mute_menu;
+	if (solo_menu) {
+		delete solo_menu;
+	}
+
+	if (mute_menu) {
+		delete mute_menu;
+	}
+
+	if (remote_control_menu) {
+		delete remote_control_menu;
+	}
 }
 
 bool
diff --git a/gtk2_ardour/route_ui.h b/gtk2_ardour/route_ui.h
index f22b0f2967..e3b423f52d 100644
--- a/gtk2_ardour/route_ui.h
+++ b/gtk2_ardour/route_ui.h
@@ -44,9 +44,14 @@ class BindableToggleButton;
 class RouteUI : public virtual AxisView
 {
   public:
+	RouteUI(ARDOUR::Session&, const char*, const char*, const char*);
 	RouteUI(boost::shared_ptr<ARDOUR::Route>, ARDOUR::Session&, const char*, const char*, const char*);
+
 	virtual ~RouteUI();
 
+	virtual void set_route (boost::shared_ptr<ARDOUR::Route>);
+	void set_button_names (const char*, const char*, const char*);
+
 	bool is_track() const;
 	bool is_audio_track() const;
 
@@ -154,6 +159,15 @@ class RouteUI : public virtual AxisView
 
 	void reversibly_apply_route_boolean (string name, void (ARDOUR::Route::*func)(bool, void*), bool, void *);
 	void reversibly_apply_audio_track_boolean (string name, void (ARDOUR::AudioTrack::*func)(bool, void*), bool, void *);
+
+  protected:
+	std::vector<sigc::connection> connections;
+	std::string s_name;
+	std::string m_name;
+	std::string r_name;
+
+	void init ();
+	void reset ();
 };
 
 #endif /* __ardour_route_ui__ */
diff --git a/gtk2_ardour/send_ui.cc b/gtk2_ardour/send_ui.cc
index bb0923db12..ee97ae959c 100644
--- a/gtk2_ardour/send_ui.cc
+++ b/gtk2_ardour/send_ui.cc
@@ -32,9 +32,12 @@ using namespace PBD;
 SendUI::SendUI (boost::shared_ptr<Send> s, Session& se)
 	: _send (s),
 	  _session (se),
-	  gpm (s, se),
-	  panners (s, se)
+	  gpm (se),
+	  panners (se)
 {
+	panners.set_io (s);
+	gpm.set_io (s);
+
 	hbox.pack_start (gpm, true, true);
 	set_name ("SendUIFrame");
 	
diff --git a/gtk2_ardour/sfdb_ui.cc b/gtk2_ardour/sfdb_ui.cc
index 56c693a87d..8492ae1e05 100644
--- a/gtk2_ardour/sfdb_ui.cc
+++ b/gtk2_ardour/sfdb_ui.cc
@@ -584,7 +584,8 @@ SoundFileBrowser::add_gain_meter ()
 		delete gm;
 	}
 
-	gm = new GainMeter (session->the_auditioner(), *session);
+	gm = new GainMeter (*session);
+	gm->set_io (session->the_auditioner());
 
 	meter_packer.set_border_width (12);
 	meter_packer.pack_start (*gm, false, true);