X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Froute_time_axis.cc;h=0c52b96dc3eb0aff504d403e9de5ee9418e0d219;hb=056ceba16a5ab45aabec0cd10ae3228881e640dc;hp=d7e4d3c1b7a905a9f92b6586a35e5ed2091c518d;hpb=0d6515a24349be9add8d3919d4c6c4d509bac687;p=ardour.git

diff --git a/gtk2_ardour/route_time_axis.cc b/gtk2_ardour/route_time_axis.cc
index d7e4d3c1b7..0c52b96dc3 100644
--- a/gtk2_ardour/route_time_axis.cc
+++ b/gtk2_ardour/route_time_axis.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2006 Paul Davis 
+    Copyright (C) 2006 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -23,6 +23,7 @@
 #include <algorithm>
 #include <string>
 #include <vector>
+#include  <map>
 #include <utility>
 
 #include <sigc++/bind.h>
@@ -31,6 +32,8 @@
 #include "pbd/stl_delete.h"
 #include "pbd/whitespace.h"
 #include "pbd/memento_command.h"
+#include "pbd/enumwriter.h"
+#include "pbd/stateful_diff_command.h"
 
 #include <gtkmm/menu.h>
 #include <gtkmm/menuitem.h>
@@ -54,6 +57,7 @@
 #include "ardour/route_group.h"
 #include "ardour/session.h"
 #include "ardour/session_playlist.h"
+#include "ardour/debug.h"
 #include "ardour/utils.h"
 #include "evoral/Parameter.hpp"
 
@@ -86,7 +90,6 @@ using namespace PBD;
 using namespace Gtkmm2ext;
 using namespace Gtk;
 using namespace Editing;
-using namespace sigc;
 using namespace std;
 
 Glib::RefPtr<Gdk::Pixbuf> RouteTimeAxisView::slider;
@@ -99,7 +102,7 @@ RouteTimeAxisView::setup_slider_pix ()
 	}
 }
 
-RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
+RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, boost::shared_ptr<Route> rt, Canvas& canvas)
 	: AxisView(sess)
 	, RouteUI(rt, sess)
 	, TimeAxisView(sess,ed,(TimeAxisView*) 0, canvas)
@@ -110,11 +113,10 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 	, size_button (_("h"))
 	, automation_button (_("a"))
 	, visual_button (_("v"))
-	, gm (sess, slider, true)
+	, gm (sess, slider, true, 115)
+	, _ignore_track_mode_change (false)
 {
-	set_button_names ();
-
-	gm.set_controls (_route, _route->shared_peak_meter(), _route->gain_control(), _route->amp());
+	gm.set_controls (_route, _route->shared_peak_meter(), _route->amp());
 	gm.get_level_meter().set_no_show_all();
 	gm.get_level_meter().setup_meters(50);
 
@@ -122,12 +124,17 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 	playlist_menu = 0;
 	playlist_action_menu = 0;
 	automation_action_menu = 0;
+	plugins_submenu_item = 0;
+	mode_menu = 0;
 	_view = 0;
 
 	if (!_route->is_hidden()) {
 		_marked_for_display = true;
 	}
 
+	mute_changed (0);
+        update_solo_display ();
+
 	timestretch_rect = 0;
 	no_redraw = false;
 	destructive_track_mode_item = 0;
@@ -153,17 +160,12 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 	hide_button.add (*(manage (new Image (::get_icon("hide")))));
 	hide_button.show_all ();
 
- 	route_group_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::edit_click), false);
-	playlist_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::playlist_click));
-	automation_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::automation_click));
-	size_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::size_click), false);
-	visual_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::visual_click));
-	hide_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::hide_click));
-
-	solo_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::solo_press), false);
-	solo_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::solo_release), false);
-	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);
+ 	route_group_button.signal_button_release_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::edit_click), false);
+	playlist_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::playlist_click));
+	automation_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::automation_click));
+	size_button.signal_button_release_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::size_click), false);
+	visual_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::visual_click));
+	hide_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::hide_click));
 
 	if (is_track()) {
 
@@ -182,33 +184,35 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 		}
 		rec_enable_button->show_all ();
 
-		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));
 		controls_table.attach (*rec_enable_button, 5, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
-		ARDOUR_UI::instance()->tooltips().set_tip(*rec_enable_button, _("Record"));
+		ARDOUR_UI::instance()->set_tip(*rec_enable_button, _("Record"));
 
+		rec_enable_button->set_sensitive (_session->writable());
 	}
 
 	controls_hbox.pack_start(gm.get_level_meter(), false, false);
-	_route->meter_change.connect (mem_fun(*this, &RouteTimeAxisView::meter_changed));
-	_route->input()->changed.connect (mem_fun(*this, &RouteTimeAxisView::io_changed));
-	_route->output()->changed.connect (mem_fun(*this, &RouteTimeAxisView::io_changed));
+	_route->meter_change.connect (*this, invalidator (*this), bind (&RouteTimeAxisView::meter_changed, this), gui_context());
+	_route->input()->changed.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context());
+	_route->output()->changed.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context());
 
 	controls_table.attach (*mute_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
-	controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
+
+        if (!_route->is_master()) {
+                controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
+        }
 
 	controls_table.attach (route_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
 	controls_table.attach (gm.get_gain_slider(), 0, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 
-	ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo"));
-	ARDOUR_UI::instance()->tooltips().set_tip(*mute_button,_("Mute"));
-	ARDOUR_UI::instance()->tooltips().set_tip(route_group_button, _("Route Group"));
-	ARDOUR_UI::instance()->tooltips().set_tip(size_button,_("Display Height"));
-	ARDOUR_UI::instance()->tooltips().set_tip(playlist_button,_("Playlist"));
-	ARDOUR_UI::instance()->tooltips().set_tip(automation_button, _("Automation"));
-	ARDOUR_UI::instance()->tooltips().set_tip(visual_button, _("Visual options"));
-	ARDOUR_UI::instance()->tooltips().set_tip(hide_button, _("Hide this track"));
-	
+	ARDOUR_UI::instance()->set_tip(*solo_button,_("Solo"));
+	ARDOUR_UI::instance()->set_tip(*mute_button,_("Mute"));
+	ARDOUR_UI::instance()->set_tip(route_group_button, _("Route Group"));
+	ARDOUR_UI::instance()->set_tip(size_button,_("Display Height"));
+	ARDOUR_UI::instance()->set_tip(playlist_button,_("Playlist"));
+	ARDOUR_UI::instance()->set_tip(automation_button, _("Automation"));
+	ARDOUR_UI::instance()->set_tip(visual_button, _("Visual options"));
+	ARDOUR_UI::instance()->set_tip(hide_button, _("Hide this track"));
+
 	label_view ();
 
 	if (0) {
@@ -231,42 +235,39 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 
 	_y_position = -1;
 
-	_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed));
-	_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
-	_route->processors_changed.connect (mem_fun(*this, &RouteTimeAxisView::processors_changed));
-	_route->NameChanged.connect (mem_fun(*this, &RouteTimeAxisView::route_name_changed));
-	_route->solo_isolated_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
-
+	_route->processors_changed.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context());
+	_route->PropertyChanged.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::route_property_changed, this, _1), gui_context());
 
 	if (is_track()) {
 
-		track()->TrackModeChanged.connect (mem_fun(*this, &RouteTimeAxisView::track_mode_changed));
-		track()->FreezeChange.connect (mem_fun(*this, &RouteTimeAxisView::map_frozen));
-		track()->DiskstreamChanged.connect (mem_fun(*this, &RouteTimeAxisView::diskstream_changed));
-		get_diskstream()->SpeedChanged.connect (mem_fun(*this, &RouteTimeAxisView::speed_changed));
+		track()->TrackModeChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::track_mode_changed, this), gui_context());
+		track()->FreezeChange.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::map_frozen, this), gui_context());
+		track()->SpeedChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::speed_changed, this), gui_context());
 
 		/* pick up the correct freeze state */
 		map_frozen ();
 
 	}
 
-	_editor.ZoomChanged.connect (mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
-	ColorsChanged.connect (mem_fun (*this, &RouteTimeAxisView::color_handler));
+	_editor.ZoomChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
+	ColorsChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::color_handler));
 
-	route_group_menu = new RouteGroupMenu (
-		_session,
-		(RouteGroup::Property) (RouteGroup::Mute | RouteGroup::Solo | RouteGroup::Edit)
-		);
+	PropertyList* plist = new PropertyList();
 	
-	route_group_menu->GroupSelected.connect (mem_fun (*this, &RouteTimeAxisView::set_route_group_from_menu));
+	plist->add (ARDOUR::Properties::edit, true);
+	plist->add (ARDOUR::Properties::mute, true);
+	plist->add (ARDOUR::Properties::solo, true);
+	
+	route_group_menu = new RouteGroupMenu (_session, plist);
+	route_group_menu->GroupSelected.connect (sigc::mem_fun (*this, &RouteTimeAxisView::set_route_group_from_menu));
 
-	gm.get_gain_slider().signal_scroll_event().connect(mem_fun(*this, &RouteTimeAxisView::controls_ebox_scroll), false);
+	gm.get_gain_slider().signal_scroll_event().connect(sigc::mem_fun(*this, &RouteTimeAxisView::controls_ebox_scroll), false);
 	gm.get_gain_slider().set_name ("TrackGainFader");
 }
 
 RouteTimeAxisView::~RouteTimeAxisView ()
 {
-	GoingAway (); /* EMIT_SIGNAL */
+	CatchDeletion (this);
 
 	for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
 		delete *i;
@@ -274,7 +275,7 @@ RouteTimeAxisView::~RouteTimeAxisView ()
 
 	delete playlist_menu;
 	playlist_menu = 0;
-  
+
 	delete playlist_action_menu;
 	playlist_action_menu = 0;
 
@@ -284,7 +285,7 @@ RouteTimeAxisView::~RouteTimeAxisView ()
 	for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
 		delete i->second;
 	}
-	
+
 	_automation_tracks.clear ();
 
 	delete route_group_menu;
@@ -298,54 +299,43 @@ RouteTimeAxisView::post_construct ()
 	update_diskstream_display ();
 
 	subplugin_menu.items().clear ();
-	_route->foreach_processor (mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu));
-	_route->foreach_processor (mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
+	_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu));
+	_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
 	reset_processor_automation_curves ();
 }
 
-void
-RouteTimeAxisView::set_playlist (boost::shared_ptr<Playlist> newplaylist)
-{
-	boost::shared_ptr<Playlist> pl = playlist();
-	assert(pl);
-
-	modified_connection.disconnect ();
-	modified_connection = pl->Modified.connect (mem_fun(*this, &RouteTimeAxisView::playlist_modified));
-}
-
-void
-RouteTimeAxisView::playlist_modified ()
-{
-}
-
 gint
 RouteTimeAxisView::edit_click (GdkEventButton *ev)
 {
 	if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
-	        _route->set_route_group (0, this);
-		return FALSE;
+		if (_route->route_group()) {
+			_route->route_group()->remove (_route);
+		}
+		return false;
 	}
 
 	route_group_menu->rebuild (_route->route_group ());
 	route_group_menu->popup (ev->button, ev->time);
 
-	return FALSE;
+	return false;
 }
 
 void
 RouteTimeAxisView::set_route_group_from_menu (RouteGroup *eg)
 {
-	_route->set_route_group (eg, this);
+	if (eg) {
+		eg->add (_route);
+	} else {
+		if (_route->route_group()) {
+			_route->route_group()->remove (_route);
+		}
+	}
 }
 
 void
 RouteTimeAxisView::playlist_changed ()
 {
 	label_view ();
-
-	if (is_track()) {
-		set_playlist (get_diskstream()->playlist());
-	}
 }
 
 void
@@ -357,14 +347,15 @@ RouteTimeAxisView::label_view ()
 		name_entry.set_text (x);
 	}
 
-	ARDOUR_UI::instance()->tooltips().set_tip (name_entry, x);
+	ARDOUR_UI::instance()->set_tip (name_entry, x);
 }
 
 void
-RouteTimeAxisView::route_name_changed ()
+RouteTimeAxisView::route_property_changed (const PropertyChange& what_changed)
 {
-	_editor.route_name_changed (this);
-	label_view ();
+	if (what_changed.contains (ARDOUR::Properties::name)) {
+		label_view ();
+	}
 }
 
 void
@@ -380,12 +371,12 @@ void
 RouteTimeAxisView::playlist_click ()
 {
 	// always build a new action menu
-  
+
 	delete playlist_action_menu;
 
 	playlist_action_menu = new Menu;
 	playlist_action_menu->set_name ("ArdourContextMenu");
-	
+
  	build_playlist_menu (playlist_action_menu);
 
 	conditionally_add_to_selection ();
@@ -401,20 +392,24 @@ RouteTimeAxisView::automation_click ()
 }
 
 int
-RouteTimeAxisView::set_state (const XMLNode& node)
+RouteTimeAxisView::set_state (const XMLNode& node, int version)
 {
-	TimeAxisView::set_state (node);
+	TimeAxisView::set_state (node, version);
 
 	XMLNodeList kids = node.children();
 	XMLNodeConstIterator iter;
 	const XMLProperty* prop;
-	
+
+	if (_view && (prop = node.property ("layer-display"))) {
+		set_layer_display (LayerDisplay (string_2_enum (prop->value(), _view->layer_display ())));
+	}
+
 	for (iter = kids.begin(); iter != kids.end(); ++iter) {
 		if ((*iter)->name() == AutomationTimeAxisView::state_node_name) {
 			if ((prop = (*iter)->property ("automation-id")) != 0) {
 
 				Evoral::Parameter param = ARDOUR::EventTypeMap::instance().new_parameter(prop->value());
-				bool show = ((prop = (*iter)->property ("shown")) != 0) && prop->value() == "yes";
+				bool show = ((prop = (*iter)->property ("shown")) != 0) && string_is_affirmative (prop->value());
 				create_automation_child(param, show);
 			} else {
 				warning << "Automation child has no ID" << endmsg;
@@ -430,40 +425,27 @@ RouteTimeAxisView::build_automation_action_menu ()
 {
 	using namespace Menu_Helpers;
 
-	automation_action_menu = manage (new Menu);
-	MenuList& automation_items = automation_action_menu->items();
-	automation_action_menu->set_name ("ArdourContextMenu");
-	
-	automation_items.push_back (MenuElem (_("Show all automation"),
-					      mem_fun(*this, &RouteTimeAxisView::show_all_automation)));
-
-	automation_items.push_back (MenuElem (_("Show existing automation"),
-					      mem_fun(*this, &RouteTimeAxisView::show_existing_automation)));
-
-	automation_items.push_back (MenuElem (_("Hide all automation"),
-					      mem_fun(*this, &RouteTimeAxisView::hide_all_automation)));
+	delete automation_action_menu;
+	automation_action_menu = new Menu;
 
-	if (subplugin_menu.get_attach_widget())
-		subplugin_menu.detach();
+	MenuList& items = automation_action_menu->items();
 
-	automation_items.push_back (MenuElem (_("Plugins"), subplugin_menu));
-	automation_items.back().set_sensitive (!subplugin_menu.items().empty());
+	automation_action_menu->set_name ("ArdourContextMenu");
 	
-	map<Evoral::Parameter, RouteAutomationNode*>::iterator i;
-	for (i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
-
-		automation_items.push_back (SeparatorElem());
-
-		delete i->second->menu_item;
-
-		automation_items.push_back(CheckMenuElem (_route->describe_parameter(i->second->param), 
-				bind (mem_fun(*this, &RouteTimeAxisView::toggle_automation_track), i->second->param)));
-
-		i->second->menu_item = static_cast<Gtk::CheckMenuItem*>(&automation_items.back());
+	items.push_back (MenuElem (_("Show All Automation"),
+				   sigc::mem_fun(*this, &RouteTimeAxisView::show_all_automation)));
+	
+	items.push_back (MenuElem (_("Show Existing Automation"),
+				   sigc::mem_fun(*this, &RouteTimeAxisView::show_existing_automation)));
+	
+	items.push_back (MenuElem (_("Hide All Automation"),
+				   sigc::mem_fun(*this, &RouteTimeAxisView::hide_all_automation)));
+	
+	/* attach the plugin submenu. It may have previously been used elsewhere, so we detach it first. */
 
-		i->second->menu_item->set_active(show_automation(i->second->param));
-		//i->second->menu_item->set_active(false);
-	}
+	detach_menu (subplugin_menu);
+	items.push_back (MenuElem (_("Plugins"),  subplugin_menu));
+	items.back().set_sensitive (!subplugin_menu.items().empty());
 }
 
 void
@@ -483,17 +465,17 @@ RouteTimeAxisView::build_display_menu ()
 
 	MenuList& items = display_menu->items();
 	display_menu->set_name ("ArdourContextMenu");
-	
+
 	items.push_back (MenuElem (_("Height"), *size_menu));
-	items.push_back (MenuElem (_("Color"), mem_fun(*this, &RouteTimeAxisView::select_track_color)));
+	items.push_back (MenuElem (_("Color"), sigc::mem_fun(*this, &RouteTimeAxisView::select_track_color)));
 
 	items.push_back (SeparatorElem());
 
 	if (!Profile->get_sae()) {
-		build_remote_control_menu ();
-		items.push_back (MenuElem (_("Remote Control ID"), *remote_control_menu));
+		items.push_back (MenuElem (_("Remote Control ID..."), sigc::mem_fun (*this, &RouteUI::open_remote_control_id_dialog)));
 		/* rebuild this every time */
 		build_automation_action_menu ();
+		detach_menu (*automation_action_menu);
 		items.push_back (MenuElem (_("Automation"), *automation_action_menu));
 		items.push_back (SeparatorElem());
 	}
@@ -501,7 +483,7 @@ RouteTimeAxisView::build_display_menu ()
 	// Hook for derived classes to add type specific stuff
 	append_extra_display_menu_items ();
 	items.push_back (SeparatorElem());
-	
+
 	if (is_track()) {
 
 		Menu *layers_menu = manage(new Menu);
@@ -511,9 +493,9 @@ RouteTimeAxisView::build_display_menu ()
 		RadioMenuItem::Group layers_group;
 
 		layers_items.push_back(RadioMenuElem (layers_group, _("Overlaid"),
-				bind (mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid)));
+				sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid)));
 		layers_items.push_back(RadioMenuElem (layers_group, _("Stacked"),
-				bind (mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked)));
+				sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked)));
 
 		items.push_back (MenuElem (_("Layers"), *layers_menu));
 
@@ -523,39 +505,42 @@ RouteTimeAxisView::build_display_menu ()
 
 		RadioMenuItem::Group align_group;
 
-		alignment_items.push_back (RadioMenuElem (align_group, _("Align with existing material"),
-					bind (mem_fun(*this, &RouteTimeAxisView::set_align_style), ExistingMaterial)));
+		alignment_items.push_back (RadioMenuElem (align_group, _("Align With Existing Material"),
+					sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_style), ExistingMaterial)));
 		align_existing_item = dynamic_cast<RadioMenuItem*>(&alignment_items.back());
-		if (get_diskstream()->alignment_style() == ExistingMaterial)
+		if (track()->alignment_style() == ExistingMaterial) {
 			align_existing_item->set_active();
+		}
 
-		alignment_items.push_back (RadioMenuElem (align_group, _("Align with capture time"),
-					bind (mem_fun(*this, &RouteTimeAxisView::set_align_style), CaptureTime)));
+		alignment_items.push_back (RadioMenuElem (align_group, _("Align With Capture Time"),
+					sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_style), CaptureTime)));
 		align_capture_item = dynamic_cast<RadioMenuItem*>(&alignment_items.back());
-		if (get_diskstream()->alignment_style() == CaptureTime)
+		if (track()->alignment_style() == CaptureTime) {
 			align_capture_item->set_active();
+		}
 
 		if (!Profile->get_sae()) {
+
 			items.push_back (MenuElem (_("Alignment"), *alignment_menu));
-			get_diskstream()->AlignmentStyleChanged.connect (
-					mem_fun(*this, &RouteTimeAxisView::align_style_changed));
-			
+			track()->AlignmentStyleChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteTimeAxisView::align_style_changed, this), gui_context());
+
 			RadioMenuItem::Group mode_group;
-			items.push_back (RadioMenuElem (mode_group, _("Normal mode"), bind (
-					mem_fun (*this, &RouteTimeAxisView::set_track_mode),
+			items.push_back (RadioMenuElem (mode_group, _("Normal Mode"), sigc::bind (
+					sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode),
 					ARDOUR::Normal)));
 			normal_track_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
-			items.push_back (RadioMenuElem (mode_group, _("Tape mode"), bind (
-					mem_fun (*this, &RouteTimeAxisView::set_track_mode),
+			items.push_back (RadioMenuElem (mode_group, _("Tape Mode"), sigc::bind (
+					sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode),
 					ARDOUR::Destructive)));
 			destructive_track_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
- 			items.push_back (RadioMenuElem (mode_group, _("No layering mode"),
- 							bind (mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::NonLayered)));
+ 			items.push_back (RadioMenuElem (mode_group, _("Non-Layered Mode"),
+ 							sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::NonLayered)));
  			non_layered_track_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
- 
 
+
+			_ignore_track_mode_change = true;
 			
 			switch (track()->mode()) {
 			case ARDOUR::Destructive:
@@ -568,33 +553,31 @@ RouteTimeAxisView::build_display_menu ()
 				non_layered_track_mode_item->set_active ();
 				break;
 			}
+			
+			_ignore_track_mode_change = false;
 		}
 
-		get_diskstream()->AlignmentStyleChanged.connect (
-				mem_fun(*this, &RouteTimeAxisView::align_style_changed));
+		track()->AlignmentStyleChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteTimeAxisView::align_style_changed, this), gui_context());
 
-		mode_menu = build_mode_menu();
-		if (mode_menu)
-			items.push_back (MenuElem (_("Mode"), *mode_menu));
-			
 		color_mode_menu = build_color_mode_menu();
-		if (color_mode_menu)
+		if (color_mode_menu) {
 			items.push_back (MenuElem (_("Color Mode"), *color_mode_menu));
-			
+		}
+
 		items.push_back (SeparatorElem());
 	}
 
-	items.push_back (CheckMenuElem (_("Active"), mem_fun(*this, &RouteUI::toggle_route_active)));
+	items.push_back (CheckMenuElem (_("Active"), sigc::mem_fun(*this, &RouteUI::toggle_route_active)));
 	route_active_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
 	route_active_menu_item->set_active (_route->active());
 
 	items.push_back (SeparatorElem());
-	items.push_back (MenuElem (_("Hide"), mem_fun(*this, &RouteTimeAxisView::hide_click)));
+	items.push_back (MenuElem (_("Hide"), sigc::mem_fun(*this, &RouteTimeAxisView::hide_click)));
 	if (!Profile->get_sae()) {
-		items.push_back (MenuElem (_("Remove"), mem_fun(*this, &RouteUI::remove_this_route)));
+		items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &RouteUI::remove_this_route)));
 	} else {
 		items.push_front (SeparatorElem());
-		items.push_front (MenuElem (_("Delete"), mem_fun(*this, &RouteUI::remove_this_route)));
+		items.push_front (MenuElem (_("Delete"), sigc::mem_fun(*this, &RouteUI::remove_this_route)));
 	}
 }
 
@@ -608,6 +591,10 @@ static bool __reset_item (RadioMenuItem* item, RadioMenuItem* item_2)
 void
 RouteTimeAxisView::set_track_mode (TrackMode mode)
 {
+	if (_ignore_track_mode_change) {
+		return;
+	}
+	
 	RadioMenuItem* item;
 	RadioMenuItem* other_item;
 	RadioMenuItem* other_item_2;
@@ -633,8 +620,8 @@ RouteTimeAxisView::set_track_mode (TrackMode mode)
 		/*NOTREACHED*/
 		return;
 	}
-	
-	if (item && other_item && other_item_2 && item->get_active() && track()->mode() != mode) {
+
+	if (item && other_item && other_item_2 && track()->mode() != mode) {
 		_set_track_mode (track().get(), mode, other_item, other_item_2);
 	}
 }
@@ -648,10 +635,11 @@ RouteTimeAxisView::_set_track_mode (Track* track, TrackMode mode, RadioMenuItem*
 
 		if (!needs_bounce) {
 			/* cannot be done */
-			Glib::signal_idle().connect (bind (sigc::ptr_fun (__reset_item), reset_item, reset_item_2));
+			Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (__reset_item), reset_item, reset_item_2));
 			return;
 		} else {
 			cerr << "would bounce this one\n";
+			/* XXX: radio menu item becomes inconsistent with track state in this case */
 			return;
 		}
 	}
@@ -677,7 +665,7 @@ void
 RouteTimeAxisView::track_mode_changed ()
 {
 	RadioMenuItem* item;
-	
+
 	switch (track()->mode()) {
 	case ARDOUR::Normal:
 		item = normal_track_mode_item;
@@ -703,12 +691,12 @@ RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end)
 	double x1;
 	double x2;
 	double y2;
-	
+
 	TimeAxisView::show_timestretch (start, end);
 
 	hide_timestretch ();
 
-#if 0	
+#if 0
 	if (ts.empty()) {
 		return;
 	}
@@ -724,7 +712,7 @@ RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end)
 	}
 
 	/* ignore it if our edit group is not active */
-	
+
 	if ((ts.track != this) && _route->route_group() && !_route->route_group()->is_active()) {
 		return;
 	}
@@ -746,7 +734,7 @@ RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end)
 	x1 = start / _editor.get_current_zoom();
 	x2 = (end - 1) / _editor.get_current_zoom();
 	y2 = current_height() - 2;
-	
+
 	timestretch_rect->property_x1() = x1;
 	timestretch_rect->property_y1() = 1.0;
 	timestretch_rect->property_x2() = x2;
@@ -809,7 +797,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 
 		gm.get_gain_slider().show();
 		mute_button->show();
-		if (!_route || _route->is_master()) {
+		if (!_route || _route->is_monitor()) {
 			solo_button->hide();
 		} else {
 			solo_button->show();
@@ -822,7 +810,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 		visual_button.show();
 		size_button.show();
 		automation_button.show();
-		
+
 		if (is_track() && track()->mode() == ARDOUR::Normal) {
 			playlist_button.show();
 		}
@@ -835,7 +823,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 
 		gm.get_gain_slider().hide();
 		mute_button->show();
-		if (!_route || _route->is_master()) {
+		if (!_route || _route->is_monitor()) {
 			solo_button->hide();
 		} else {
 			solo_button->show();
@@ -848,7 +836,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 		visual_button.hide ();
 		size_button.hide ();
 		automation_button.hide ();
-		
+
 		if (is_track() && track()->mode() == ARDOUR::Normal) {
 			playlist_button.hide ();
 		}
@@ -869,7 +857,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 
 		hide_name_entry ();
 		show_name_label ();
-		
+
 		gm.get_gain_slider().hide();
 		mute_button->hide();
 		solo_button->hide();
@@ -885,7 +873,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 		name_label.set_text (_route->name());
 	}
 
-	if (height_changed) {
+	if (height_changed && !no_redraw) {
 		/* only emit the signal if the height really changed */
 		 _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 	}
@@ -913,10 +901,10 @@ RouteTimeAxisView::set_samples_per_unit (double spu)
 {
 	double speed = 1.0;
 
-	if (get_diskstream() != 0) {
-		speed = get_diskstream()->speed();
+	if (track()) {
+		speed = track()->speed();
 	}
-	
+
 	if (_view) {
 		_view->set_samples_per_unit (spu * speed);
 	}
@@ -927,7 +915,7 @@ RouteTimeAxisView::set_samples_per_unit (double spu)
 void
 RouteTimeAxisView::align_style_changed ()
 {
-	switch (get_diskstream()->alignment_style()) {
+	switch (track()->alignment_style()) {
 	case ExistingMaterial:
 		if (!align_existing_item->get_active()) {
 			align_existing_item->set_active();
@@ -960,7 +948,7 @@ RouteTimeAxisView::set_align_style (AlignStyle style)
 	}
 
 	if (item->get_active()) {
-		get_diskstream()->set_align_style (style);
+		track()->set_align_style (style);
 	}
 }
 
@@ -970,15 +958,18 @@ RouteTimeAxisView::rename_current_playlist ()
 	ArdourPrompter prompter (true);
 	string name;
 
-	boost::shared_ptr<Diskstream> ds = get_diskstream();
-	if (!ds || ds->destructive())
+	boost::shared_ptr<Track> tr = track();
+	if (!tr || tr->destructive()) {
 		return;
+	}
 
-	boost::shared_ptr<Playlist> pl = ds->playlist();
-	if (!pl)
+	boost::shared_ptr<Playlist> pl = tr->playlist();
+	if (!pl) {
 		return;
+	}
 
-	prompter.set_prompt (_("Name for playlist"));
+	prompter.set_title (_("Rename Playlist"));
+	prompter.set_prompt (_("New name for playlist:"));
 	prompter.set_initial_text (pl->name());
 	prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
 	prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
@@ -996,7 +987,7 @@ RouteTimeAxisView::rename_current_playlist ()
 	}
 }
 
-std::string 
+std::string
 RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector<boost::shared_ptr<Playlist> > const & playlists)
 {
 	std::string ret (basename);
@@ -1008,7 +999,7 @@ RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector
 	for (vector<boost::shared_ptr<Playlist> >::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
 		std::string tmp = (*i)->name();
 
-		std::string::size_type idx = tmp.find(group_string);			
+		std::string::size_type idx = tmp.find(group_string);
 		// find those which belong to this group
 		if (idx != string::npos) {
 			tmp = tmp.substr(idx + group_string.length());
@@ -1025,7 +1016,7 @@ RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector
 
 	char buf[32];
 	snprintf (buf, sizeof(buf), "%d", maxnumber);
-               
+
 	ret = this->name() + "." + route_group()->name () + "." + buf;
 
 	return ret;
@@ -1035,23 +1026,25 @@ void
 RouteTimeAxisView::use_copy_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op)
 {
 	string name;
-	
-	boost::shared_ptr<Diskstream> ds = get_diskstream();
-	if (!ds || ds->destructive())
+
+	boost::shared_ptr<Track> tr = track ();
+	if (!tr || tr->destructive()) {
 		return;
+	}
 
-	boost::shared_ptr<const Playlist> pl = ds->playlist();
-	if (!pl)
+	boost::shared_ptr<const Playlist> pl = tr->playlist();
+	if (!pl) {
 		return;
+	}
 
 	name = pl->name();
-	
+
 	if (route_group() && route_group()->is_active()) {
 		name = resolve_new_group_playlist_name(name, playlists_before_op);
 	}
 
-	while (_session.playlist_by_name(name)) {
-		name = Playlist::bump_name (name, _session);
+	while (_session->playlists->by_name(name)) {
+		name = Playlist::bump_name (name, *_session);
 	}
 
 	// TODO: The prompter "new" button should be de-activated if the user
@@ -1060,26 +1053,27 @@ RouteTimeAxisView::use_copy_playlist (bool prompt, vector<boost::shared_ptr<Play
 	if (prompt) {
 
 		ArdourPrompter prompter (true);
-		
-		prompter.set_prompt (_("Name for Playlist"));
+
+		prompter.set_title (_("New Copy Playlist"));
+		prompter.set_prompt (_("Name for new playlist:"));
 		prompter.set_initial_text (name);
 		prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
 		prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
 		prompter.show_all ();
-		
+
 		switch (prompter.run ()) {
 		case Gtk::RESPONSE_ACCEPT:
 			prompter.get_result (name);
 			break;
-			
+
 		default:
 			return;
 		}
 	}
 
 	if (name.length()) {
-		ds->use_copy_playlist ();
-		ds->playlist()->set_name (name);
+		tr->use_copy_playlist ();
+		tr->playlist()->set_name (name);
 	}
 }
 
@@ -1087,31 +1081,34 @@ void
 RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op)
 {
 	string name;
-	
-	boost::shared_ptr<Diskstream> ds = get_diskstream();
-	if (!ds || ds->destructive())
+
+	boost::shared_ptr<Track> tr = track ();
+	if (!tr || tr->destructive()) {
 		return;
+	}
 
-	boost::shared_ptr<const Playlist> pl = ds->playlist();
-	if (!pl)
+	boost::shared_ptr<const Playlist> pl = tr->playlist();
+	if (!pl) {
 		return;
+	}
 
 	name = pl->name();
-	
+
 	if (route_group() && route_group()->is_active()) {
 		name = resolve_new_group_playlist_name(name,playlists_before_op);
 	}
 
-	while (_session.playlist_by_name(name)) {
-		name = Playlist::bump_name (name, _session);
+	while (_session->playlists->by_name(name)) {
+		name = Playlist::bump_name (name, *_session);
 	}
 
 
 	if (prompt) {
-		
+
 		ArdourPrompter prompter (true);
-		
-		prompter.set_prompt (_("Name for Playlist"));
+
+		prompter.set_title (_("New Playlist"));
+		prompter.set_prompt (_("Name for new playlist:"));
 		prompter.set_initial_text (name);
 		prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
 		prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
@@ -1120,28 +1117,30 @@ RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playl
 		case Gtk::RESPONSE_ACCEPT:
 			prompter.get_result (name);
 			break;
-			
+
 		default:
 			return;
 		}
 	}
 
 	if (name.length()) {
-		ds->use_new_playlist ();
-		ds->playlist()->set_name (name);
+		tr->use_new_playlist ();
+		tr->playlist()->set_name (name);
 	}
 }
 
 void
 RouteTimeAxisView::clear_playlist ()
 {
-	boost::shared_ptr<Diskstream> ds = get_diskstream();
-	if (!ds || ds->destructive())
+	boost::shared_ptr<Track> tr = track ();
+	if (!tr || tr->destructive()) {
 		return;
+	}
 
-	boost::shared_ptr<Playlist> pl = ds->playlist();
-	if (!pl)
+	boost::shared_ptr<Playlist> pl = tr->playlist();
+	if (!pl) {
 		return;
+	}
 
 	_editor.clear_playlist (pl);
 }
@@ -1149,24 +1148,18 @@ RouteTimeAxisView::clear_playlist ()
 void
 RouteTimeAxisView::speed_changed ()
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
+	Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&RouteTimeAxisView::reset_samples_per_unit, this));
 }
 
-void
-RouteTimeAxisView::diskstream_changed ()
-{
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &RouteTimeAxisView::update_diskstream_display));
-}	
-
 void
 RouteTimeAxisView::update_diskstream_display ()
 {
-	if (!get_diskstream()) // bus
+	if (!track()) {
 		return;
+	}
 
-	set_playlist (get_diskstream()->playlist());
 	map_frozen ();
-}	
+}
 
 void
 RouteTimeAxisView::selection_click (GdkEventButton* ev)
@@ -1181,35 +1174,25 @@ RouteTimeAxisView::selection_click (GdkEventButton* ev)
 		}
 
 		return;
-	} 
-
-	PublicEditor::TrackViewList* tracks = _editor.get_valid_views (this, _route->route_group());
+	}
 
-	switch (Keyboard::selection_type (ev->state)) {
+	switch (ArdourKeyboard::selection_type (ev->state)) {
 	case Selection::Toggle:
-		_editor.get_selection().toggle (*tracks);
+		_editor.get_selection().toggle (this);
 		break;
-		
+
 	case Selection::Set:
-		_editor.get_selection().set (*tracks);
+		_editor.get_selection().set (this);
 		break;
 
 	case Selection::Extend:
-		if (tracks->size() > 1) {
-			/* add each one, do not "extend" */
-			_editor.get_selection().add (*tracks);
-		} else {
-			/* extend to the single track */
-			_editor.extend_selection_to_track (*tracks->front());
-		}
+		_editor.extend_selection_to_track (*this);
 		break;
 
 	case Selection::Add:
-		_editor.get_selection().add (*tracks);
+		_editor.get_selection().add (this);
 		break;
 	}
-
-	delete tracks;
 }
 
 void
@@ -1235,20 +1218,20 @@ void
 RouteTimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results)
 {
 	double speed = 1.0;
-	
-	if (get_diskstream() != 0) {
-		speed = get_diskstream()->speed();
+
+	if (track() != 0) {
+		speed = track()->speed();
 	}
-	
+
 	nframes_t start_adjusted = session_frame_to_track_frame(start, speed);
 	nframes_t end_adjusted   = session_frame_to_track_frame(end, speed);
 
 	if ((_view && ((top < 0.0 && bot < 0.0))) || touched (top, bot)) {
-		_view->get_selectables (start_adjusted, end_adjusted, results);
+		_view->get_selectables (start_adjusted, end_adjusted, top, bot, results);
 	}
 
 	/* pick up visible automation tracks */
-	
+
 	for (Children::iterator i = children.begin(); i != children.end(); ++i) {
 		if (!(*i)->hidden()) {
 			(*i)->get_selectables (start_adjusted, end_adjusted, top, bot, results);
@@ -1293,7 +1276,7 @@ RouteTimeAxisView::automation_track (Evoral::Parameter param)
 }
 
 /** Shorthand for GainAutomation, etc.
- */	
+ */
 RouteTimeAxisView::RouteAutomationNode*
 RouteTimeAxisView::automation_track (AutomationType type)
 {
@@ -1313,12 +1296,12 @@ RouteTimeAxisView::name() const
 }
 
 boost::shared_ptr<Playlist>
-RouteTimeAxisView::playlist () const 
+RouteTimeAxisView::playlist () const
 {
-	boost::shared_ptr<Diskstream> ds;
+	boost::shared_ptr<Track> tr;
 
-	if ((ds = get_diskstream()) != 0) {
-		return ds->playlist(); 
+	if ((tr = track()) != 0) {
+		return tr->playlist();
 	} else {
 		return boost::shared_ptr<Playlist> ();
 	}
@@ -1330,7 +1313,7 @@ RouteTimeAxisView::name_entry_changed ()
 	string x;
 
 	x = name_entry.get_text ();
-	
+
 	if (x == _route->name()) {
 		return;
 	}
@@ -1342,10 +1325,10 @@ RouteTimeAxisView::name_entry_changed ()
 		return;
 	}
 
-	if (!_session.route_name_unique (x)) {
+	if (!_session->route_name_unique (x)) {
 		ARDOUR_UI::instance()->popup_error (_("A track already exists with that name"));
 		name_entry.set_text (_route->name());
-	} else if (_session.route_name_internal (x)) {
+	} else if (_session->route_name_internal (x)) {
 		ARDOUR_UI::instance()->popup_error (_("You cannot create a track with that name as it is reserved for Ardour"));
 		name_entry.set_text (_route->name());
 	} else {
@@ -1364,33 +1347,31 @@ RouteTimeAxisView::hide_click ()
 {
 	// LAME fix for hide_button refresh fix
 	hide_button.set_sensitive(false);
-	
+
 	_editor.hide_track_in_display (*this);
-	
+
 	hide_button.set_sensitive(true);
 }
 
 boost::shared_ptr<Region>
 RouteTimeAxisView::find_next_region (nframes_t pos, RegionPoint point, int32_t dir)
 {
-	boost::shared_ptr<Diskstream> stream;
-	boost::shared_ptr<Playlist> playlist;
+	boost::shared_ptr<Playlist> pl = playlist ();
 
-	if ((stream = get_diskstream()) != 0 && (playlist = stream->playlist()) != 0) {
-		return playlist->find_next_region (pos, point, dir);
+	if (pl) {
+		return pl->find_next_region (pos, point, dir);
 	}
 
 	return boost::shared_ptr<Region> ();
 }
 
-nframes64_t 
+nframes64_t
 RouteTimeAxisView::find_next_region_boundary (nframes64_t pos, int32_t dir)
 {
-	boost::shared_ptr<Diskstream> stream;
-	boost::shared_ptr<Playlist> playlist;
+	boost::shared_ptr<Playlist> pl = playlist ();
 
-	if ((stream = get_diskstream()) != 0 && (playlist = stream->playlist()) != 0) {
-		return playlist->find_next_region_boundary (pos, dir);
+	if (pl) {
+		return pl->find_next_region_boundary (pos, dir);
 	}
 
 	return -1;
@@ -1400,32 +1381,42 @@ bool
 RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
 {
 	boost::shared_ptr<Playlist> what_we_got;
-	boost::shared_ptr<Diskstream> ds = get_diskstream();
+	boost::shared_ptr<Track> tr = track ();
 	boost::shared_ptr<Playlist> playlist;
 	bool ret = false;
 
-	if (ds == 0) {
+	if (tr == 0) {
 		/* route is a bus, not a track */
 		return false;
 	}
 
-	playlist = ds->playlist();
+	playlist = tr->playlist();
 
 	TimeSelection time (selection.time);
-	float speed = ds->speed();
+	float const speed = tr->speed();
 	if (speed != 1.0f) {
 		for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) {
 			(*i).start = session_frame_to_track_frame((*i).start, speed);
 			(*i).end   = session_frame_to_track_frame((*i).end,   speed);
 		}
 	}
-	
-	XMLNode &before = playlist->get_state();
+
+        playlist->clear_history ();
+        playlist->clear_owned_history ();
+
 	switch (op) {
 	case Cut:
 		if ((what_we_got = playlist->cut (time)) != 0) {
 			_editor.get_cut_buffer().add (what_we_got);
-			_session.add_command( new MementoCommand<Playlist>(*playlist.get(), &before, &playlist->get_state()));
+
+                        vector<StatefulDiffCommand*> cmds;
+                        
+                        playlist->rdiff (cmds);
+                        
+                        for (vector<StatefulDiffCommand*>::iterator c = cmds.begin(); c != cmds.end(); ++c) {
+                                _session->add_command (*c);
+                        }
+                        _session->add_command (new StatefulDiffCommand (playlist));
 			ret = true;
 		}
 		break;
@@ -1437,7 +1428,14 @@ RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
 
 	case Clear:
 		if ((what_we_got = playlist->cut (time)) != 0) {
-			_session.add_command( new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+                        vector<StatefulDiffCommand*> cmds;
+                        
+                        playlist->rdiff (cmds);
+                        
+                        for (vector<StatefulDiffCommand*>::iterator c = cmds.begin(); c != cmds.end(); ++c) {
+                                _session->add_command (*c);
+                        }
+                        _session->add_command (new StatefulDiffCommand (playlist));
 			what_we_got->release ();
 			ret = true;
 		}
@@ -1454,21 +1452,22 @@ RouteTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size
 		return false;
 	}
 
-	boost::shared_ptr<Playlist> playlist = get_diskstream()->playlist();
+	boost::shared_ptr<Playlist> pl = playlist ();
 	PlaylistSelection::iterator p;
-	
+
 	for (p = selection.playlists.begin(); p != selection.playlists.end() && nth; ++p, --nth) {}
 
 	if (p == selection.playlists.end()) {
 		return false;
 	}
 
-	if (get_diskstream()->speed() != 1.0f)
-		pos = session_frame_to_track_frame(pos, get_diskstream()->speed() );
-	
-	XMLNode &before = playlist->get_state();
-	playlist->paste (*p, pos, times);
-	_session.add_command( new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+	if (track()->speed() != 1.0f) {
+		pos = session_frame_to_track_frame (pos, track()->speed());
+	}
+
+        pl->clear_history ();
+	pl->paste (*p, pos, times);
+	_session->add_command (new StatefulDiffCommand (pl));
 
 	return true;
 }
@@ -1478,7 +1477,7 @@ TimeAxisView::Children
 RouteTimeAxisView::get_child_list()
 {
 	TimeAxisView::Children redirect_children;
-	
+
 	for (Children::iterator i = children.begin(); i != children.end(); ++i) {
 		if (!(*i)->hidden()) {
 			redirect_children.push_back(*i);
@@ -1488,6 +1487,12 @@ RouteTimeAxisView::get_child_list()
 }
 
 
+struct PlaylistSorter {
+    bool operator() (boost::shared_ptr<Playlist> a, boost::shared_ptr<Playlist> b) const {
+            return a->sort_id() < b->sort_id();
+    }
+};
+
 void
 RouteTimeAxisView::build_playlist_menu (Gtk::Menu * menu)
 {
@@ -1503,59 +1508,68 @@ RouteTimeAxisView::build_playlist_menu (Gtk::Menu * menu)
 
 	delete playlist_menu;
 
-	playlist_menu = new Menu;
-	playlist_menu->set_name ("ArdourContextMenu");
 
-	vector<boost::shared_ptr<Playlist> > playlists;
-	boost::shared_ptr<Diskstream> ds = get_diskstream();
+        vector<boost::shared_ptr<Playlist> > playlists, playlists_tr;
+	boost::shared_ptr<Track> tr = track();
 	RadioMenuItem::Group playlist_group;
 
-	_session.get_playlists (playlists);
-	
-	for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
-
-		if ((*i)->get_orig_diskstream_id() == ds->id()) {
-			playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name(), bind (mem_fun (*this, &RouteTimeAxisView::use_playlist),
-												     boost::weak_ptr<Playlist> (*i))));
-
-			if (ds->playlist()->id() == (*i)->id()) {
-				static_cast<RadioMenuItem*>(&playlist_items.back())->set_active();
-			}
-		} else if (ds->playlist()->id() == (*i)->id()) {
-			playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name(), bind (mem_fun (*this, &RouteTimeAxisView::use_playlist), 
-												     boost::weak_ptr<Playlist>(*i))));
-			static_cast<RadioMenuItem*>(&playlist_items.back())->set_active();
-			
+	_session->playlists->get (playlists);
+
+        /* find the playlists for this diskstream */
+        for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+                if (((*i)->get_orig_diskstream_id() == tr->diskstream_id()) || (tr->playlist()->id() == (*i)->id())) {
+                        playlists_tr.push_back(*i);
+                }
+        }
+
+        /* sort the playlists */
+        PlaylistSorter cmp;
+        sort (playlists_tr.begin(), playlists_tr.end(), cmp);
+        
+        /* add the playlists to the menu */
+        for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists_tr.begin(); i != playlists_tr.end(); ++i) {
+                playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name()));
+                RadioMenuItem *item = static_cast<RadioMenuItem*>(&playlist_items.back());
+                item->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), item, boost::weak_ptr<Playlist> (*i)));
+                
+                if (tr->playlist()->id() == (*i)->id()) {
+                        item->set_active();
+                        
 		}
 	}
-
+        
 	playlist_items.push_back (SeparatorElem());
-	playlist_items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
+	playlist_items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
 	playlist_items.push_back (SeparatorElem());
 
 	if (!route_group() || !route_group()->is_active()) {
-		playlist_items.push_back (MenuElem (_("New"), bind(mem_fun(_editor, &PublicEditor::new_playlists), this)));
-		playlist_items.push_back (MenuElem (_("New Copy"), bind(mem_fun(_editor, &PublicEditor::copy_playlists), this)));
+		playlist_items.push_back (MenuElem (_("New..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
+		playlist_items.push_back (MenuElem (_("New Copy..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
 
 	} else {
 		// Use a label which tells the user what is happening
-		playlist_items.push_back (MenuElem (_("New Take"), bind(mem_fun(_editor, &PublicEditor::new_playlists), this)));
-		playlist_items.push_back (MenuElem (_("Copy Take"), bind(mem_fun(_editor, &PublicEditor::copy_playlists), this)));
-		
+		playlist_items.push_back (MenuElem (_("New Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
+		playlist_items.push_back (MenuElem (_("Copy Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
+
 	}
 
 	playlist_items.push_back (SeparatorElem());
-	playlist_items.push_back (MenuElem (_("Clear Current"), bind(mem_fun(_editor, &PublicEditor::clear_playlists), this)));
+	playlist_items.push_back (MenuElem (_("Clear Current"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::clear_playlists), this)));
 	playlist_items.push_back (SeparatorElem());
 
-	playlist_items.push_back (MenuElem(_("Select from all ..."), mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
+	playlist_items.push_back (MenuElem(_("Select from all..."), sigc::mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
 }
 
 void
-RouteTimeAxisView::use_playlist (boost::weak_ptr<Playlist> wpl)
+RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr<Playlist> wpl)
 {
 	assert (is_track());
 
+        // exit if we were triggered by deactivating the old playlist
+        if (!item->get_active()) {
+                return;
+        }
+
 	boost::shared_ptr<Playlist> pl (wpl.lock());
 
 	if (!pl) {
@@ -1563,18 +1577,16 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr<Playlist> wpl)
 	}
 
 	boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl);
-	
+
 	if (apl) {
-		if (get_diskstream()->playlist() == apl) {
-			// radio button cotnrols mean this function is called for both the 
-			// old and new playlist
+		if (track()->playlist() == apl) {
+                        // exit when use_playlist is called by the creation of the playlist menu
+                        // or the playlist choice is unchanged
 			return;
 		}
-		get_diskstream()->use_playlist (apl);
-
+		track()->use_playlist (apl);
 
 		if (route_group() && route_group()->is_active()) {
-			//PBD::stacktrace(cerr, 20);
 			std::string group_string = "."+route_group()->name()+".";
 
 			std::string take_name = apl->name();
@@ -1584,30 +1596,30 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr<Playlist> wpl)
 				return;
 
 			take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name
-			
-			for (list<Route*>::const_iterator i = route_group()->route_list().begin(); i != route_group()->route_list().end(); ++i) {
-				if ( (*i) == this->route().get()) {
+
+			boost::shared_ptr<RouteList> rl (route_group()->route_list());
+
+			for (RouteList::const_iterator i = rl->begin(); i != rl->end(); ++i) {
+				if ( (*i) == this->route()) {
 					continue;
 				}
-				
+
 				std::string playlist_name = (*i)->name()+group_string+take_name;
 
-				Track *track = dynamic_cast<Track *>(*i);
+				boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track>(*i);
 				if (!track) {
 					std::cerr << "route " << (*i)->name() << " is not a Track" << std::endl;
 					continue;
 				}
 
-				boost::shared_ptr<Playlist> ipl = session().playlist_by_name(playlist_name);
+				boost::shared_ptr<Playlist> ipl = session()->playlists->by_name(playlist_name);
 				if (!ipl) {
 					// No playlist for this track for this take yet, make it
-					track->diskstream()->use_new_playlist();
-					track->diskstream()->playlist()->set_name(playlist_name);
+					track->use_new_playlist();
+					track->playlist()->set_name(playlist_name);
 				} else {
-					track->diskstream()->use_playlist(ipl);
+					track->use_playlist(ipl);
 				}
-				
-				//(*i)->get_dis
 			}
 		}
 	}
@@ -1626,7 +1638,7 @@ RouteTimeAxisView::map_frozen ()
 		return;
 	}
 
-	ENSURE_GUI_THREAD (mem_fun(*this, &RouteTimeAxisView::map_frozen));
+	ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::map_frozen)
 
 	switch (track()->freeze_state()) {
 	case Track::Frozen:
@@ -1655,31 +1667,28 @@ RouteTimeAxisView::color_handler ()
 	reset_meter();
 }
 
+/** Toggle an automation track for a fully-specified Parameter (type,channel,id)
+ *  Will add track if necessary.
+ */
 void
-RouteTimeAxisView::toggle_automation_track (Evoral::Parameter param)
+RouteTimeAxisView::toggle_automation_track (const Evoral::Parameter& param)
 {
 	RouteAutomationNode* node = automation_track(param);
-
-	if (!node)
-		return;
-
-	bool showit = node->menu_item->get_active();
-
-	if (showit != node->track->marked_for_display()) {
-		if (showit) {
-			node->track->set_marked_for_display (true);
-			node->track->canvas_display()->show();
-			node->track->get_state_node()->add_property ("shown", X_("yes"));
-		} else {
-			node->track->set_marked_for_display (false);
-			node->track->hide ();
-			node->track->get_state_node()->add_property ("shown", X_("no"));
-		}
-
-		/* now trigger a redisplay */
-		
-		if (!no_redraw) {
-			 _route->gui_changed (X_("track_height"), (void *) 0); /* EMIT_SIGNAL */
+	
+	if (!node) {
+		/* it doesn't exist yet, so we don't care about the button state: just add it */
+		create_automation_child (param, true);
+	} else {
+		bool yn = node->menu_item->get_active();
+		if (node->track->set_visibility (node->menu_item->get_active()) && yn) {
+			
+			/* we made it visible, now trigger a redisplay. if it was hidden, then automation_track_hidden()
+			   will have done that for us.
+			*/
+			
+			if (!no_redraw) {
+				_route->gui_changed (X_("track_height"), (void *) 0); /* EMIT_SIGNAL */
+			} 
 		}
 	}
 }
@@ -1688,19 +1697,24 @@ void
 RouteTimeAxisView::automation_track_hidden (Evoral::Parameter param)
 {
 	RouteAutomationNode* ran = automation_track(param);
+
 	if (!ran) {
 		return;
 	}
-	
+
 	// if Evoral::Parameter::operator< doesn't obey strict weak ordering, we may crash here....
-	_show_automation.erase(param);
+	_show_automation.erase (param);
 	ran->track->get_state_node()->add_property (X_("shown"), X_("no"));
 
 	if (ran->menu_item && !_hidden) {
+		ignore_toggle = true;
 		ran->menu_item->set_active (false);
+		ignore_toggle = false;
 	}
 
-	 _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
+	if (_route && !no_redraw) {
+		_route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
+	}
 }
 
 
@@ -1708,7 +1722,7 @@ void
 RouteTimeAxisView::show_all_automation ()
 {
 	no_redraw = true;
-	
+
 	/* Show our automation */
 
 	map<Evoral::Parameter, RouteAutomationNode*>::iterator i;
@@ -1716,7 +1730,9 @@ RouteTimeAxisView::show_all_automation ()
 		i->second->track->set_marked_for_display (true);
 		i->second->track->canvas_display()->show();
 		i->second->track->get_state_node()->add_property ("shown", X_("yes"));
-		i->second->menu_item->set_active(true);
+		if (i->second->menu_item) {
+			i->second->menu_item->set_active(true);
+		}
 	}
 
 
@@ -1726,7 +1742,7 @@ RouteTimeAxisView::show_all_automation ()
 		for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
 			if ((*ii)->view == 0) {
 				add_processor_automation_curve ((*i)->processor, (*ii)->what);
-			} 
+			}
 
 			(*ii)->menu_item->set_active (true);
 		}
@@ -1736,14 +1752,14 @@ RouteTimeAxisView::show_all_automation ()
 
 	/* Redraw */
 
-	 _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
+	 _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 }
 
 void
 RouteTimeAxisView::show_existing_automation ()
 {
 	no_redraw = true;
-	
+
 	/* Show our automation */
 
 	map<Evoral::Parameter, RouteAutomationNode*>::iterator i;
@@ -1761,15 +1777,15 @@ RouteTimeAxisView::show_existing_automation ()
 
 	for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
 		for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
-			if ((*ii)->view != 0 && (*i)->processor->data().control((*ii)->what)->list()->size() > 0) {
+			if ((*ii)->view != 0 && (*i)->processor->control((*ii)->what)->list()->size() > 0) {
 				(*ii)->menu_item->set_active (true);
 			}
 		}
 	}
 
 	no_redraw = false;
-	
-	_route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
+
+	_route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 }
 
 void
@@ -1783,7 +1799,9 @@ RouteTimeAxisView::hide_all_automation ()
 		i->second->track->set_marked_for_display (false);
 		i->second->track->hide ();
 		i->second->track->get_state_node()->add_property ("shown", X_("no"));
-		i->second->menu_item->set_active (false);
+		if (i->second->menu_item) {
+			i->second->menu_item->set_active (false);
+		}
 	}
 
 	/* Hide processor automation */
@@ -1797,7 +1815,7 @@ RouteTimeAxisView::hide_all_automation ()
 	_show_automation.clear();
 
 	no_redraw = false;
-	 _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
+	 _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 }
 
 
@@ -1805,10 +1823,10 @@ void
 RouteTimeAxisView::region_view_added (RegionView* rv)
 {
 	/* XXX need to find out if automation children have automationstreamviews. If yes, no ghosts */
-	if(is_audio_track()) {
+	if (is_audio_track()) {
 		for (Children::iterator i = children.begin(); i != children.end(); ++i) {
 			boost::shared_ptr<AutomationTimeAxisView> atv;
-			
+
 			if ((atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (*i)) != 0) {
 				atv->add_ghost(rv);
 			}
@@ -1859,7 +1877,7 @@ RouteTimeAxisView::find_processor_automation_node (boost::shared_ptr<Processor>
 	return 0;
 }
 
-static string 
+static string
 legalize_for_xml_node (string str)
 {
 	string::size_type pos;
@@ -1885,7 +1903,7 @@ RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor>
 	ProcessorAutomationNode* pan;
 
 	if ((pan = find_processor_automation_node (processor, what)) == 0) {
-		fatal << _("programming error: ")
+		error << _("programming error: ")
 		      << string_compose (X_("processor automation curve for %1:%2 not registered with track!"),
 				  processor->name(), what)
 		      << endmsg;
@@ -1907,13 +1925,13 @@ RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor>
 	snprintf (state_name, sizeof (state_name), "Redirect-%s-%" PRIu32, legalize_for_xml_node (processor->name()).c_str(), what.id());
 
 	boost::shared_ptr<AutomationControl> control
-			= boost::dynamic_pointer_cast<AutomationControl>(processor->data().control(what, true));
+			= boost::dynamic_pointer_cast<AutomationControl>(processor->control(what, true));
 
 	pan->view = boost::shared_ptr<AutomationTimeAxisView>(
 			new AutomationTimeAxisView (_session, _route, processor, control,
 				_editor, *this, false, parent_canvas, name, state_name));
 
-	pan->view->Hiding.connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
+	pan->view->Hiding.connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
 
 	if (!pan->view->marked_for_display()) {
 		pan->view->hide ();
@@ -1924,7 +1942,7 @@ RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor>
 	add_child (pan->view);
 
 	if (_view) {
-		_view->foreach_regionview (mem_fun(*pan->view.get(), &TimeAxisView::add_ghost));
+		_view->foreach_regionview (sigc::mem_fun(*pan->view.get(), &TimeAxisView::add_ghost));
 	}
 
 	processor->mark_automation_visible (what, true);
@@ -1939,7 +1957,9 @@ RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::Process
 
 	i->mark_automation_visible (pan->what, false);
 
-	 _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
+	if (!no_redraw) {
+		_route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
+	}
 }
 
 void
@@ -1949,14 +1969,14 @@ RouteTimeAxisView::add_existing_processor_automation_curves (boost::weak_ptr<Pro
 	if (!processor) {
 		return;
 	}
-	
+
 	set<Evoral::Parameter> s;
 	boost::shared_ptr<AutomationLine> al;
 
 	processor->what_has_visible_data (s);
 
 	for (set<Evoral::Parameter>::iterator i = s.begin(); i != s.end(); ++i) {
-		
+
 		if ((al = find_processor_automation_curve (processor, *i)) != 0) {
 			al->queue_reset ();
 		} else {
@@ -1966,7 +1986,7 @@ RouteTimeAxisView::add_existing_processor_automation_curves (boost::weak_ptr<Pro
 }
 
 void
-RouteTimeAxisView::add_automation_child(Evoral::Parameter param, boost::shared_ptr<AutomationTimeAxisView> track, bool show)
+RouteTimeAxisView::add_automation_child (Evoral::Parameter param, boost::shared_ptr<AutomationTimeAxisView> track, bool show)
 {
 	using namespace Menu_Helpers;
 
@@ -1975,51 +1995,54 @@ RouteTimeAxisView::add_automation_child(Evoral::Parameter param, boost::shared_p
 
 	add_child (track);
 
-	track->Hiding.connect (bind (mem_fun (*this, &RouteTimeAxisView::automation_track_hidden), param));
+	track->Hiding.connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::automation_track_hidden), param));
 
 	bool hideit = (!show);
 
 	if ((node = track->get_state_node()) != 0) {
 		if  ((prop = node->property ("shown")) != 0) {
-			if (prop->value() == "yes") {
+			if (string_is_affirmative (prop->value())) {
 				hideit = false;
 			}
-		} 
+		}
 	}
 
-	_automation_tracks.insert(std::make_pair(param, new RouteAutomationNode(param, NULL, track)));
+	_automation_tracks.insert (std::make_pair (param, new RouteAutomationNode(param, NULL, track)));
 
-	if (hideit) {
-		track->hide ();
-	} else {
-		_show_automation.insert (param);
+	track->set_visibility (!hideit);
 
-
-		if (!no_redraw) {
-			_route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
-		}
+	if (!hideit) {
+		_show_automation.insert (param);
+	}
+	
+	if (!no_redraw) {
+		_route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 	}
 
-	build_display_menu();
+	if (!EventTypeMap::instance().is_midi_parameter(param)) {
+		/* MIDI-related parameters are always in the menu, there's no
+		   reason to rebuild the menu just because we added a automation
+		   lane for one of them. But if we add a non-MIDI automation
+		   lane, then we need to invalidate the display menu.
+		*/
+		delete display_menu;
+		display_menu = 0;
+	}
 }
 
-
 void
 RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p)
 {
 	boost::shared_ptr<Processor> processor (p.lock ());
-	if (!processor) {
-		return;
-	}
 
-	if (!processor->visible ()) {
+	if (!processor || !processor->display_to_user ()) {
 		return;
 	}
-	
+
 	using namespace Menu_Helpers;
 	ProcessorAutomationInfo *rai;
 	list<ProcessorAutomationInfo*>::iterator x;
-	
+
 	const std::set<Evoral::Parameter>& automatable = processor->what_can_be_automated ();
 	std::set<Evoral::Parameter> has_visible_automation;
 
@@ -2060,9 +2083,9 @@ RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p
 
 		ProcessorAutomationNode* pan;
 		CheckMenuItem* mitem;
-		
+
 		string name = processor->describe_parameter (*i);
-		
+
 		items.push_back (CheckMenuElem (name));
 		mitem = dynamic_cast<CheckMenuItem*> (&items.back());
 
@@ -2073,9 +2096,9 @@ RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p
 		if ((pan = find_processor_automation_node (processor, *i)) == 0) {
 
 			/* new item */
-			
+
 			pan = new ProcessorAutomationNode (*i, mitem, *this);
-			
+
 			rai->lines.push_back (pan);
 
 		} else {
@@ -2084,7 +2107,7 @@ RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p
 
 		}
 
-		mitem->signal_toggled().connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, pan));
+		mitem->signal_toggled().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, pan));
 	}
 
 	/* add the menu for this processor, because the subplugin
@@ -2126,27 +2149,31 @@ RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::ProcessorAuto
 	}
 
 	if (redraw && !no_redraw) {
-
-		/* now trigger a redisplay */
-		
-		 _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
+		 _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 
 	}
 }
 
 void
-RouteTimeAxisView::processors_changed ()
+RouteTimeAxisView::processors_changed (RouteProcessorChange c)
 {
+	if (c.type == RouteProcessorChange::MeterPointChange) {
+		/* nothing to do if only the meter point has changed */
+		return;
+	}
+
 	using namespace Menu_Helpers;
-	
+
 	for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
 		(*i)->valid = false;
 	}
 
 	subplugin_menu.items().clear ();
 
-	_route->foreach_processor (mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu));
-	_route->foreach_processor (mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
+	_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu));
+	_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
+
+	bool deleted_processor_automation = false;
 
 	for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ) {
 
@@ -2159,15 +2186,16 @@ RouteTimeAxisView::processors_changed ()
 
 			delete *i;
 			processor_automation.erase (i);
+			deleted_processor_automation = true;
 
-		} 
+		}
 
 		i = tmp;
 	}
 
-	/* change in visibility was possible */
-
-	_route->gui_changed ("visible_tracks", this);
+	if (deleted_processor_automation && !no_redraw) {
+		_route->gui_changed ("track_height", this);
+	}
 }
 
 boost::shared_ptr<AutomationLine>
@@ -2178,7 +2206,7 @@ RouteTimeAxisView::find_processor_automation_curve (boost::shared_ptr<Processor>
 	if ((pan = find_processor_automation_node (processor, what)) != 0) {
 		if (pan->view) {
 			pan->view->line();
-		} 
+		}
 	}
 
 	return boost::shared_ptr<AutomationLine>();
@@ -2198,13 +2226,16 @@ RouteTimeAxisView::update_rec_display ()
 	RouteUI::update_rec_display ();
 	name_entry.set_sensitive (!_route->record_enabled());
 }
-		
+
 void
 RouteTimeAxisView::set_layer_display (LayerDisplay d)
 {
 	if (_view) {
 		_view->set_layer_display (d);
 	}
+
+	ensure_xml_node ();
+	xml_node->add_property (N_("layer-display"), enum_2_string (d));
 }
 
 LayerDisplay
@@ -2218,16 +2249,17 @@ RouteTimeAxisView::layer_display () const
 	return Overlaid;
 }
 
-	
+
 
 boost::shared_ptr<AutomationTimeAxisView>
 RouteTimeAxisView::automation_child(Evoral::Parameter param)
 {
 	AutomationTracks::iterator i = _automation_tracks.find(param);
-	if (i != _automation_tracks.end())
+	if (i != _automation_tracks.end()) {
 		return i->second->track;
-	else
+	} else {
 		return boost::shared_ptr<AutomationTimeAxisView>();
+	}
 }
 
 void
@@ -2266,52 +2298,53 @@ RouteTimeAxisView::clear_meter ()
 }
 
 void
-RouteTimeAxisView::meter_changed (void *src)
+RouteTimeAxisView::meter_changed ()
 {
-	ENSURE_GUI_THREAD (bind (mem_fun(*this, &RouteTimeAxisView::meter_changed), src));
+	ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::meter_changed)
 	reset_meter();
 }
 
 void
-RouteTimeAxisView::io_changed (IOChange change, void *src)
+RouteTimeAxisView::io_changed (IOChange /*change*/, void */*src*/)
 {
 	reset_meter ();
 }
 
 void
-RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu) {
+RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu)
+{
 	using namespace Menu_Helpers;
 
-	if(!_underlay_streams.empty()) {
+	if (!_underlay_streams.empty()) {
 		MenuList& parent_items = parent_menu->items();
 		Menu* gs_menu = manage (new Menu);
 		gs_menu->set_name ("ArdourContextMenu");
 		MenuList& gs_items = gs_menu->items();
-		
+
 		parent_items.push_back (MenuElem (_("Underlays"), *gs_menu));
-		
+
 		for(UnderlayList::iterator it = _underlay_streams.begin(); it != _underlay_streams.end(); ++it) {
 			gs_items.push_back(MenuElem(string_compose(_("Remove \"%1\""), (*it)->trackview().name()),
-						    bind(mem_fun(*this, &RouteTimeAxisView::remove_underlay), *it)));
+						    sigc::bind(sigc::mem_fun(*this, &RouteTimeAxisView::remove_underlay), *it)));
 		}
 	}
 }
 
 bool
-RouteTimeAxisView::set_underlay_state() 
+RouteTimeAxisView::set_underlay_state()
 {
-	if(!underlay_xml_node) {
+	if (!underlay_xml_node) {
 		return false;
 	}
 
 	XMLNodeList nlist = underlay_xml_node->children();
 	XMLNodeConstIterator niter;
 	XMLNode *child_node;
-	
+
 	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 		child_node = *niter;
 
-		if(child_node->name() != "Underlay") {
+		if (child_node->name() != "Underlay") {
 			continue;
 		}
 
@@ -2331,16 +2364,16 @@ RouteTimeAxisView::set_underlay_state()
 }
 
 void
-RouteTimeAxisView::add_underlay(StreamView* v, bool update_xml) 
+RouteTimeAxisView::add_underlay (StreamView* v, bool update_xml)
 {
-	if(!v) {
+	if (!v) {
 		return;
 	}
 
 	RouteTimeAxisView& other = v->trackview();
 
-	if(find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
-		if(find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) {
+	if (find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
+		if (find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) {
 			fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
 			/*NOTREACHED*/
 		}
@@ -2348,10 +2381,10 @@ RouteTimeAxisView::add_underlay(StreamView* v, bool update_xml)
 		_underlay_streams.push_back(v);
 		other._underlay_mirrors.push_back(this);
 
-		v->foreach_regionview(mem_fun(*this, &RouteTimeAxisView::add_ghost));
+		v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::add_ghost));
 
-		if(update_xml) {
-			if(!underlay_xml_node) {
+		if (update_xml) {
+			if (!underlay_xml_node) {
 				ensure_xml_node();
 				underlay_xml_node = xml_node->add_child("Underlays");
 			}
@@ -2364,29 +2397,29 @@ RouteTimeAxisView::add_underlay(StreamView* v, bool update_xml)
 }
 
 void
-RouteTimeAxisView::remove_underlay(StreamView* v) 
+RouteTimeAxisView::remove_underlay (StreamView* v)
 {
-	if(!v) {
+	if (!v) {
 		return;
 	}
 
 	UnderlayList::iterator it = find(_underlay_streams.begin(), _underlay_streams.end(), v);
 	RouteTimeAxisView& other = v->trackview();
 
-	if(it != _underlay_streams.end()) {
+	if (it != _underlay_streams.end()) {
 		UnderlayMirrorList::iterator gm = find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this);
 
-		if(gm == other._underlay_mirrors.end()) {
+		if (gm == other._underlay_mirrors.end()) {
 			fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
 			/*NOTREACHED*/
 		}
 
-		v->foreach_regionview(mem_fun(*this, &RouteTimeAxisView::remove_ghost));
+		v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::remove_ghost));
 
 		_underlay_streams.erase(it);
 		other._underlay_mirrors.erase(gm);
 
-		if(underlay_xml_node) {
+		if (underlay_xml_node) {
 			underlay_xml_node->remove_nodes_and_delete("id", v->trackview().route()->id().to_s());
 		}
 	}
@@ -2397,12 +2430,21 @@ RouteTimeAxisView::set_button_names ()
 {
 	rec_enable_button_label.set_text (_("r"));
 
-	if (Config->get_solo_control_is_listen_control()) {
-		solo_button_label.set_text (_("l"));
-	} else {
-		solo_button_label.set_text (_("s"));
-	}
-
+        if (_route && _route->solo_safe()) {
+                solo_button_label.set_text (X_("!"));
+        } else {
+                if (Config->get_solo_control_is_listen_control()) {
+                        switch (Config->get_listen_position()) {
+                        case AfterFaderListen:
+                                solo_button_label.set_text (_("A"));
+                                break;
+                        case PreFaderListen:
+                                solo_button_label.set_text (_("P"));
+                                break;
+                        }
+                } else {
+                        solo_button_label.set_text (_("s"));
+                }
+        }
 	mute_button_label.set_text (_("m"));
 }
-