X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_routes.cc;h=c4443cbed0c96d24b83c164821b198043e6bd41c;hb=ef213e49a7e4eb7083696fd7e953c8f11e492849;hp=bbda43a295f46cc5d71acbefa3b20b9319acfec7;hpb=bb9cc45cd22af67ac275a5e73accbe14fee664d8;p=ardour.git

diff --git a/gtk2_ardour/editor_routes.cc b/gtk2_ardour/editor_routes.cc
index bbda43a295..c4443cbed0 100644
--- a/gtk2_ardour/editor_routes.cc
+++ b/gtk2_ardour/editor_routes.cc
@@ -24,7 +24,7 @@
 #include <cmath>
 #include <cassert>
 
-#include "ardour/diskstream.h"
+#include "ardour/session.h"
 
 #include "editor.h"
 #include "keyboard.h"
@@ -41,92 +41,416 @@
 #include "pbd/unknown_type.h"
 
 #include "ardour/route.h"
+#include "ardour/midi_track.h"
 
+#include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
 #include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
+#include "gtkmm2ext/treeutils.h"
 
 #include "i18n.h"
 
 using namespace std;
-using namespace sigc;
 using namespace ARDOUR;
 using namespace PBD;
 using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace Glib;
+using Gtkmm2ext::Keyboard;
+
+struct ColumnInfo {
+    int         index;
+    const char* label;
+    const char* tooltip;
+};
 
 EditorRoutes::EditorRoutes (Editor* e)
-	: EditorComponent (e),
-	  _ignore_reorder (false),
-	  _no_redisplay (false),
-	  _redisplay_does_not_sync_order_keys (false),
-	  _redisplay_does_not_reset_order_keys (false),
-	  _menu (0)
+	: EditorComponent (e)
+        , _ignore_reorder (false)
+        , _no_redisplay (false)
+        , _redisplay_does_not_sync_order_keys (false)
+        , _redisplay_does_not_reset_order_keys (false)
+        ,_menu (0)
+        , old_focus (0)
+        , selection_countdown (0)
+        , name_editable (0)
 {
+	static const int column_width = 22;
+
 	_scroller.add (_display);
 	_scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
 
 	_model = ListStore::create (_columns);
 	_display.set_model (_model);
 
-	CellRendererPixbufToggle* rec_col_renderer = manage (new CellRendererPixbufToggle());
+	// Record enable toggle
+	CellRendererPixbufMulti* rec_col_renderer = manage (new CellRendererPixbufMulti());
 
-	rec_col_renderer->set_active_pixbuf (::get_icon("record_normal_red"));
-	rec_col_renderer->set_inactive_pixbuf (::get_icon("record_disabled_grey"));
+	rec_col_renderer->set_pixbuf (0, ::get_icon("record-normal-disabled"));
+	rec_col_renderer->set_pixbuf (1, ::get_icon("record-normal-in-progress"));
+	rec_col_renderer->set_pixbuf (2, ::get_icon("record-normal-enabled"));
+	rec_col_renderer->set_pixbuf (3, ::get_icon("record-step"));
+	rec_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_enable_changed));
 
-	rec_col_renderer->signal_toggled().connect (mem_fun (*this, &EditorRoutes::on_tv_rec_enable_toggled));
+	TreeViewColumn* rec_state_column = manage (new TreeViewColumn("R", *rec_col_renderer));
 
-	Gtk::TreeViewColumn* rec_state_column = manage (new TreeViewColumn("Rec", *rec_col_renderer));
-	rec_state_column->add_attribute(rec_col_renderer->property_active(), _columns.rec_enabled);
+	rec_state_column->add_attribute(rec_col_renderer->property_state(), _columns.rec_state);
 	rec_state_column->add_attribute(rec_col_renderer->property_visible(), _columns.is_track);
 
-	_display.append_column (*rec_state_column);
-	_display.append_column (_("Show"), _columns.visible);
-	_display.append_column (_("Name"), _columns.text);
+	rec_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	rec_state_column->set_alignment(ALIGN_CENTER);
+	rec_state_column->set_expand(false);
+	rec_state_column->set_fixed_width(column_width);
+
+	// MIDI Input Active
+
+	CellRendererPixbufMulti* input_active_col_renderer = manage (new CellRendererPixbufMulti());
+	input_active_col_renderer->set_pixbuf (0, ::get_icon("midi-input-inactive"));
+	input_active_col_renderer->set_pixbuf (1, ::get_icon("midi-input-active"));
+	input_active_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_input_active_changed));
+
+	TreeViewColumn* input_active_column = manage (new TreeViewColumn ("I", *input_active_col_renderer));
+
+	input_active_column->add_attribute(input_active_col_renderer->property_state(), _columns.is_input_active);
+	input_active_column->add_attribute (input_active_col_renderer->property_visible(), _columns.is_midi);
+
+	input_active_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	input_active_column->set_alignment(ALIGN_CENTER);
+	input_active_column->set_expand(false);
+	input_active_column->set_fixed_width(column_width);
+
+	// Mute enable toggle
+	CellRendererPixbufMulti* mute_col_renderer = manage (new CellRendererPixbufMulti());
+
+	mute_col_renderer->set_pixbuf (Gtkmm2ext::Off, ::get_icon("mute-disabled"));
+	mute_col_renderer->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon("muted-by-others"));
+	mute_col_renderer->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon("mute-enabled"));
+	mute_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_mute_enable_toggled));
+
+	TreeViewColumn* mute_state_column = manage (new TreeViewColumn("M", *mute_col_renderer));
+
+	mute_state_column->add_attribute(mute_col_renderer->property_state(), _columns.mute_state);
+	mute_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	mute_state_column->set_alignment(ALIGN_CENTER);
+	mute_state_column->set_expand(false);
+	mute_state_column->set_fixed_width(15);
+
+	// Solo enable toggle
+	CellRendererPixbufMulti* solo_col_renderer = manage (new CellRendererPixbufMulti());
+
+	solo_col_renderer->set_pixbuf (Gtkmm2ext::Off, ::get_icon("solo-disabled"));
+	solo_col_renderer->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon("solo-enabled"));
+	solo_col_renderer->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon("soloed-by-others"));
+	solo_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_enable_toggled));
+
+	TreeViewColumn* solo_state_column = manage (new TreeViewColumn("S", *solo_col_renderer));
+
+	solo_state_column->add_attribute(solo_col_renderer->property_state(), _columns.solo_state);
+	solo_state_column->add_attribute(solo_col_renderer->property_visible(), _columns.solo_visible);
+	solo_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	solo_state_column->set_alignment(ALIGN_CENTER);
+	solo_state_column->set_expand(false);
+	solo_state_column->set_fixed_width(column_width);
+
+	// Solo isolate toggle
+	CellRendererPixbufMulti* solo_iso_renderer = manage (new CellRendererPixbufMulti());
+
+	solo_iso_renderer->set_pixbuf (0, ::get_icon("solo-isolate-disabled"));
+	solo_iso_renderer->set_pixbuf (1, ::get_icon("solo-isolate-enabled"));
+	solo_iso_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_isolate_toggled));
+
+	TreeViewColumn* solo_isolate_state_column = manage (new TreeViewColumn("SI", *solo_iso_renderer));
+
+	solo_isolate_state_column->add_attribute(solo_iso_renderer->property_state(), _columns.solo_isolate_state);
+	solo_isolate_state_column->add_attribute(solo_iso_renderer->property_visible(), _columns.solo_visible);
+	solo_isolate_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	solo_isolate_state_column->set_alignment(ALIGN_CENTER);
+	solo_isolate_state_column->set_expand(false);
+	solo_isolate_state_column->set_fixed_width(column_width);
+
+	// Solo safe toggle
+	CellRendererPixbufMulti* solo_safe_renderer = manage (new CellRendererPixbufMulti ());
 
-	_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
-	_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
-	_display.get_column (2)->set_data (X_("colnum"), GUINT_TO_POINTER(2));
+	solo_safe_renderer->set_pixbuf (0, ::get_icon("solo-safe-disabled"));
+	solo_safe_renderer->set_pixbuf (1, ::get_icon("solo-safe-enabled"));
+	solo_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_safe_toggled));
+
+	TreeViewColumn* solo_safe_state_column = manage (new TreeViewColumn(_("SS"), *solo_safe_renderer));
+	solo_safe_state_column->add_attribute(solo_safe_renderer->property_state(), _columns.solo_safe_state);
+	solo_safe_state_column->add_attribute(solo_safe_renderer->property_visible(), _columns.solo_visible);
+	solo_safe_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	solo_safe_state_column->set_alignment(ALIGN_CENTER);
+	solo_safe_state_column->set_expand(false);
+	solo_safe_state_column->set_fixed_width(column_width);
+
+        _name_column = _display.append_column ("", _columns.text) - 1;
+	_visible_column = _display.append_column ("", _columns.visible) - 1;
+	_active_column = _display.append_column ("", _columns.active) - 1;
+
+	_display.append_column (*input_active_column);
+	_display.append_column (*rec_state_column);
+	_display.append_column (*mute_state_column);
+	_display.append_column (*solo_state_column);
+	_display.append_column (*solo_isolate_state_column);
+	_display.append_column (*solo_safe_state_column);
+
+
+	TreeViewColumn* col;
+	Gtk::Label* l;
+
+	ColumnInfo ci[] = {
+		{ 0, _("Name"), _("Track/Bus Name") },
+		{ 1, _("V"), _("Track/Bus visible ?") },
+		{ 2, _("A"), _("Track/Bus active ?") },
+		{ 3, _("I"), _("MIDI input enabled") },
+		{ 4, _("R"), _("Record enabled") },
+		{ 5, _("M"), _("Muted") },
+		{ 6, _("S"), _("Soloed") },
+		{ 7, _("SI"), _("Solo Isolated") },
+		{ 8, _("SS"), _("Solo Safe (Locked)") },
+		{ -1, 0, 0 }
+	};
+
+	for (int i = 0; ci[i].index >= 0; ++i) {
+		col = _display.get_column (ci[i].index);
+		l = manage (new Label (ci[i].label));
+		ARDOUR_UI::instance()->set_tip (*l, ci[i].tooltip);
+		col->set_widget (*l);
+		l->show ();
+	}
 
 	_display.set_headers_visible (true);
-	_display.set_name ("TrackListDisplay");
-	_display.get_selection()->set_mode (SELECTION_NONE);
+	_display.get_selection()->set_mode (SELECTION_SINGLE);
+	_display.get_selection()->set_select_function (sigc::mem_fun (*this, &EditorRoutes::selection_filter));
 	_display.set_reorderable (true);
 	_display.set_rules_hint (true);
 	_display.set_size_request (100, -1);
 	_display.add_object_drag (_columns.route.index(), "routes");
 
-	CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (1));
+	CellRendererText* name_cell = dynamic_cast<CellRendererText*> (_display.get_column_cell_renderer (_name_column));
+
+	assert (name_cell);
+        name_cell->signal_editing_started().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit_started));
+
+	TreeViewColumn* name_column = _display.get_column (_name_column);
+
+	assert (name_column);
+
+	name_column->add_attribute (name_cell->property_editable(), _columns.name_editable);
+	name_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	name_column->set_expand(true);
+	name_column->set_min_width(50);
+
+	name_cell->property_editable() = true;
+	name_cell->signal_edited().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit));
+
+	// Set the visible column cell renderer to radio toggle
+	CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_visible_column));
 
 	visible_cell->property_activatable() = true;
 	visible_cell->property_radio() = false;
+	visible_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::visible_changed));
 
-	_model->signal_row_deleted().connect (mem_fun (*this, &EditorRoutes::route_deleted));
-	_model->signal_row_changed().connect (mem_fun (*this, &EditorRoutes::changed));
-	_model->signal_rows_reordered().connect (mem_fun (*this, &EditorRoutes::reordered));
-	_display.signal_button_press_event().connect (mem_fun (*this, &EditorRoutes::button_press), false);
+	TreeViewColumn* visible_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_visible_column));
+	visible_col->set_expand(false);
+	visible_col->set_sizing(TREE_VIEW_COLUMN_FIXED);
+	visible_col->set_fixed_width(30);
+	visible_col->set_alignment(ALIGN_CENTER);
 
-	Route::SyncOrderKeys.connect (mem_fun (*this, &EditorRoutes::sync_order_keys));
+	CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_active_column));
+
+	active_cell->property_activatable() = true;
+	active_cell->property_radio() = false;
+	active_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::active_changed));
+
+	TreeViewColumn* active_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_active_column));
+	active_col->set_expand (false);
+	active_col->set_sizing (TREE_VIEW_COLUMN_FIXED);
+	active_col->set_fixed_width (30);
+	active_col->set_alignment (ALIGN_CENTER);
+	
+	_model->signal_row_deleted().connect (sigc::mem_fun (*this, &EditorRoutes::route_deleted));
+	_model->signal_rows_reordered().connect (sigc::mem_fun (*this, &EditorRoutes::reordered));
+
+	_display.signal_button_press_event().connect (sigc::mem_fun (*this, &EditorRoutes::button_press), false);
+	_scroller.signal_key_press_event().connect (sigc::mem_fun(*this, &EditorRoutes::key_press), false);
+
+        _scroller.signal_focus_in_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_in), false);
+        _scroller.signal_focus_out_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_out));
+
+        _display.signal_enter_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::enter_notify), false);
+        _display.signal_leave_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::leave_notify), false);
+
+        _display.set_enable_search (false);
+
+	Route::SyncOrderKeys.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_order_keys, this, _1), gui_context());
+}
+
+bool
+EditorRoutes::focus_in (GdkEventFocus*)
+{
+        Window* win = dynamic_cast<Window*> (_scroller.get_toplevel ());
+
+        if (win) {
+                old_focus = win->get_focus ();
+        } else {
+                old_focus = 0;
+        }
+
+        name_editable = 0;
+
+        /* try to do nothing on focus in (doesn't work, hence selection_count nonsense) */
+        return true;
+}
+
+bool
+EditorRoutes::focus_out (GdkEventFocus*)
+{
+        if (old_focus) {
+                old_focus->grab_focus ();
+                old_focus = 0;
+        }
+
+        return false;
+}
+
+bool
+EditorRoutes::enter_notify (GdkEventCrossing*)
+{
+	if (name_editable) {
+		return true;
+	}
+
+        /* arm counter so that ::selection_filter() will deny selecting anything for the
+           next two attempts to change selection status.
+        */
+        selection_countdown = 2;
+        _scroller.grab_focus ();
+        Keyboard::magic_widget_grab_focus ();
+        return false;
+}
+
+bool
+EditorRoutes::leave_notify (GdkEventCrossing*)
+{
+        selection_countdown = 0;
+
+        if (old_focus) {
+                old_focus->grab_focus ();
+                old_focus = 0;
+        }
+
+        Keyboard::magic_widget_drop_focus ();
+        return false;
 }
 
 void
-EditorRoutes::connect_to_session (Session* s)
+EditorRoutes::set_session (Session* s)
 {
-	EditorComponent::connect_to_session (s);
+	SessionHandlePtr::set_session (s);
 
 	initial_display ();
+
+	if (_session) {
+		_session->SoloChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::solo_changed_so_update_mute, this), gui_context());
+		_session->RecordStateChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
+	}
+}
+
+void
+EditorRoutes::on_input_active_changed (std::string const & path_string)
+{
+	// Get the model row that has been toggled.
+	Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
+
+	TimeAxisView* tv = row[_columns.tv];
+	RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+
+	if (rtv) {
+		boost::shared_ptr<MidiTrack> mt;
+		mt = rtv->midi_track();
+		if (mt) {
+			mt->set_input_active (!mt->input_active());
+		}
+	}
+}
+
+void
+EditorRoutes::on_tv_rec_enable_changed (std::string const & path_string)
+{
+	// Get the model row that has been toggled.
+	Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
+
+	TimeAxisView* tv = row[_columns.tv];
+	RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+
+	if (rtv && rtv->track()) {
+		boost::shared_ptr<RouteList> rl (new RouteList);
+		rl->push_back (rtv->route());
+		_session->set_record_enabled (rl, !rtv->track()->record_enabled(), Session::rt_cleanup);
+	}
+}
+
+void
+EditorRoutes::on_tv_mute_enable_toggled (std::string const & path_string)
+{
+	// Get the model row that has been toggled.
+	Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
+
+	TimeAxisView *tv = row[_columns.tv];
+	RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+
+	if (rtv != 0) {
+		boost::shared_ptr<RouteList> rl (new RouteList);
+		rl->push_back (rtv->route());
+		_session->set_mute (rl, !rtv->route()->muted(), Session::rt_cleanup);
+	}
 }
 
 void
-EditorRoutes::on_tv_rec_enable_toggled (Glib::ustring const & path_string)
+EditorRoutes::on_tv_solo_enable_toggled (std::string const & path_string)
 {
 	// Get the model row that has been toggled.
 	Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 
 	TimeAxisView *tv = row[_columns.tv];
-	AudioTimeAxisView *atv = dynamic_cast<AudioTimeAxisView*> (tv);
+	RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 
-	if (atv != 0 && atv->is_audio_track()){
-		atv->reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !atv->track()->record_enabled(), this);
+	if (rtv != 0) {
+		boost::shared_ptr<RouteList> rl (new RouteList);
+		rl->push_back (rtv->route());
+		if (Config->get_solo_control_is_listen_control()) {
+			_session->set_listen (rl, !rtv->route()->listening_via_monitor(), Session::rt_cleanup);
+		} else {
+			_session->set_solo (rl, !rtv->route()->self_soloed(), Session::rt_cleanup);
+		}
+	}
+}
+
+void
+EditorRoutes::on_tv_solo_isolate_toggled (std::string const & path_string)
+{
+	// Get the model row that has been toggled.
+	Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
+
+	TimeAxisView *tv = row[_columns.tv];
+	RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+
+	if (rtv) {
+		rtv->route()->set_solo_isolated (!rtv->route()->solo_isolated(), this);
+	}
+}
+
+void
+EditorRoutes::on_tv_solo_safe_toggled (std::string const & path_string)
+{
+	// Get the model row that has been toggled.
+	Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
+
+	TimeAxisView *tv = row[_columns.tv];
+	RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+
+	if (rtv) {
+		rtv->route()->set_solo_safe (!rtv->route()->solo_safe(), this);
 	}
 }
 
@@ -141,13 +465,15 @@ EditorRoutes::build_menu ()
 	MenuList& items = _menu->items();
 	_menu->set_name ("ArdourContextMenu");
 
-	items.push_back (MenuElem (_("Show All"), mem_fun (*this, &EditorRoutes::show_all_routes)));
-	items.push_back (MenuElem (_("Hide All"), mem_fun (*this, &EditorRoutes::hide_all_routes)));
-	items.push_back (MenuElem (_("Show All Audio Tracks"), mem_fun (*this, &EditorRoutes::show_all_audiotracks)));
-	items.push_back (MenuElem (_("Hide All Audio Tracks"), mem_fun (*this, &EditorRoutes::hide_all_audiotracks)));
-	items.push_back (MenuElem (_("Show All Audio Busses"), mem_fun (*this, &EditorRoutes::show_all_audiobus)));
-	items.push_back (MenuElem (_("Hide All Audio Busses"), mem_fun (*this, &EditorRoutes::hide_all_audiobus)));
-
+	items.push_back (MenuElem (_("Show All"), sigc::mem_fun (*this, &EditorRoutes::show_all_routes)));
+	items.push_back (MenuElem (_("Hide All"), sigc::mem_fun (*this, &EditorRoutes::hide_all_routes)));
+	items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiotracks)));
+	items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiotracks)));
+	items.push_back (MenuElem (_("Show All Audio Busses"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiobus)));
+	items.push_back (MenuElem (_("Hide All Audio Busses"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiobus)));
+	items.push_back (MenuElem (_("Show All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_miditracks)));
+	items.push_back (MenuElem (_("Hide All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_miditracks)));
+	items.push_back (MenuElem (_("Show Tracks With Regions Under Playhead"), sigc::mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead)));
 }
 
 void
@@ -163,16 +489,25 @@ EditorRoutes::show_menu ()
 void
 EditorRoutes::redisplay ()
 {
+	if (_no_redisplay || !_session || _session->deletion_in_progress()) {
+		return;
+	}
+
 	TreeModel::Children rows = _model->children();
 	TreeModel::Children::iterator i;
 	uint32_t position;
+
+	/* n will be the count of tracks plus children (updated by TimeAxisView::show_at),
+	   so we will use that to know where to put things.
+	*/
 	int n;
 
-	if (_no_redisplay) {
-		return;
-	}
+	/* Order keys must not take children into account, so use a separate counter
+	   for that.
+	*/
+	int order_key;
 
-	for (n = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
+	for (n = 0, order_key = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
 		TimeAxisView *tv = (*i)[_columns.tv];
 		boost::shared_ptr<Route> route = (*i)[_columns.route];
 
@@ -182,36 +517,34 @@ EditorRoutes::redisplay ()
 		}
 
 		if (!_redisplay_does_not_reset_order_keys) {
-
 			/* this reorder is caused by user action, so reassign sort order keys
 			   to tracks.
 			*/
-
-			route->set_order_key (N_ ("editor"), n);
+			route->set_order_key (N_ ("editor"), order_key);
 		}
 
-		bool visible = (*i)[_columns.visible];
+		bool visible = tv->marked_for_display ();
 
 		/* show or hide the TimeAxisView */
 		if (visible) {
-			tv->set_marked_for_display (true);
 			position += tv->show_at (position, n, &_editor->edit_controls_vbox);
 			tv->clip_to_viewport ();
 		} else {
-			tv->set_marked_for_display (false);
 			tv->hide ();
 		}
 
 		n++;
+		order_key++;
 	}
 
 	/* whenever we go idle, update the track view list to reflect the new order.
 	   we can't do this here, because we could mess up something that is traversing
 	   the track order and has caused a redisplay of the list.
 	*/
+	Glib::signal_idle().connect (sigc::mem_fun (*_editor, &Editor::sync_track_view_list_and_routes));
 
-	Glib::signal_idle().connect (mem_fun (*_editor, &Editor::sync_track_view_list_and_routes));
-
+        _editor->reset_controls_layout_height (position);
+        _editor->reset_controls_layout_width ();
 	_editor->full_canvas_height = position + _editor->canvas_timebars_vsize;
 	_editor->vertical_adjustment.set_upper (_editor->full_canvas_height);
 
@@ -231,22 +564,53 @@ EditorRoutes::redisplay ()
 void
 EditorRoutes::route_deleted (Gtk::TreeModel::Path const &)
 {
-	/* this could require an order reset & sync */
+	if (!_session || _session->deletion_in_progress()) {
+		return;
+	}
+
+        /* this could require an order reset & sync */
 	_session->set_remote_control_ids();
 	_ignore_reorder = true;
 	redisplay ();
 	_ignore_reorder = false;
 }
 
+void
+EditorRoutes::visible_changed (std::string const & path)
+{
+	if (_session && _session->deletion_in_progress()) {
+		return;
+	}
+
+	TreeIter iter;
+
+	if ((iter = _model->get_iter (path))) {
+		TimeAxisView* tv = (*iter)[_columns.tv];
+		if (tv) {
+			bool visible = (*iter)[_columns.visible];
+
+			if (tv->set_marked_for_display (!visible)) {
+				_redisplay_does_not_reset_order_keys = true;
+				_session->set_remote_control_ids();
+				update_visibility ();
+				redisplay ();
+				_redisplay_does_not_reset_order_keys = false;
+			}
+		}
+	}
+}
 
 void
-EditorRoutes::changed (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &)
+EditorRoutes::active_changed (std::string const & path)
 {
-	/* never reset order keys because of a property change */
-	_redisplay_does_not_reset_order_keys = true;
-	_session->set_remote_control_ids();
-	redisplay ();
-	_redisplay_does_not_reset_order_keys = false;
+	if (_session && _session->deletion_in_progress ()) {
+		return;
+	}
+
+	Gtk::TreeModel::Row row = *_model->get_iter (path);
+	boost::shared_ptr<Route> route = row[_columns.route];
+	bool const active = row[_columns.active];
+	route->set_active (!active, this);
 }
 
 void
@@ -259,14 +623,32 @@ EditorRoutes::routes_added (list<RouteTimeAxisView*> routes)
 
 	for (list<RouteTimeAxisView*>::iterator x = routes.begin(); x != routes.end(); ++x) {
 
+		boost::shared_ptr<MidiTrack> midi_trk = boost::dynamic_pointer_cast<MidiTrack> ((*x)->route());
+
 		row = *(_model->append ());
 
 		row[_columns.text] = (*x)->route()->name();
 		row[_columns.visible] = (*x)->marked_for_display();
+		row[_columns.active] = (*x)->route()->active ();
 		row[_columns.tv] = *x;
 		row[_columns.route] = (*x)->route ();
 		row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> ((*x)->route()) != 0);
 
+		if (midi_trk) {
+			row[_columns.is_input_active] = midi_trk->input_active ();
+			row[_columns.is_midi] = true;
+		} else {
+			row[_columns.is_input_active] = false;
+			row[_columns.is_midi] = false;
+		}
+
+		row[_columns.mute_state] = (*x)->route()->muted() ? Gtkmm2ext::ExplicitActive : Gtkmm2ext::Off;
+		row[_columns.solo_state] = RouteUI::solo_active_state ((*x)->route());
+		row[_columns.solo_visible] = !(*x)->route()->is_master ();
+		row[_columns.solo_isolate_state] = (*x)->route()->solo_isolated();
+		row[_columns.solo_safe_state] = (*x)->route()->solo_safe();
+		row[_columns.name_editable] = true;
+
 		_ignore_reorder = true;
 
 		/* added a new fresh one at the end */
@@ -277,24 +659,44 @@ EditorRoutes::routes_added (list<RouteTimeAxisView*> routes)
 		_ignore_reorder = false;
 
 		boost::weak_ptr<Route> wr ((*x)->route());
-		(*x)->route()->gui_changed.connect (mem_fun (*this, &EditorRoutes::handle_gui_changes));
-		(*x)->route()->NameChanged.connect (bind (mem_fun (*this, &EditorRoutes::route_name_changed), wr));
-		(*x)->GoingAway.connect (bind (mem_fun (*this, &EditorRoutes::route_removed), *x));
+
+		(*x)->route()->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
+		(*x)->route()->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context());
 
 		if ((*x)->is_track()) {
 			boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
-			t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &EditorRoutes::update_rec_display));
+			t->RecordEnableChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
 		}
+
+		if ((*x)->is_midi_track()) {
+			boost::shared_ptr<MidiTrack> t = boost::dynamic_pointer_cast<MidiTrack> ((*x)->route());
+			t->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
+			t->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context());
+		}
+
+		(*x)->route()->mute_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
+		(*x)->route()->solo_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this, _1), gui_context());
+		(*x)->route()->listen_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this, _1), gui_context());
+		(*x)->route()->solo_isolated_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
+		(*x)->route()->solo_safe_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context());
+		(*x)->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ());
 	}
 
+	update_rec_display ();
+	update_mute_display ();
+	update_solo_display (true);
+	update_solo_isolate_display ();
+	update_solo_safe_display ();
+	update_input_active_display ();
+	update_active_display ();
 	resume_redisplay ();
 	_redisplay_does_not_sync_order_keys = false;
 }
 
 void
-EditorRoutes::handle_gui_changes (string const & what, void *src)
+EditorRoutes::handle_gui_changes (string const & what, void*)
 {
-	ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRoutes::handle_gui_changes), what, src));
+	ENSURE_GUI_THREAD (*this, &EditorRoutes::handle_gui_changes, what, src)
 
 	if (what == "track_height") {
 		/* Optional :make tracks change height while it happens, instead
@@ -312,7 +714,7 @@ EditorRoutes::handle_gui_changes (string const & what, void *src)
 void
 EditorRoutes::route_removed (TimeAxisView *tv)
 {
-	ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRoutes::route_removed), tv));
+	ENSURE_GUI_THREAD (*this, &EditorRoutes::route_removed, tv)
 
 	TreeModel::Children rows = _model->children();
 	TreeModel::Children::iterator ri;
@@ -334,11 +736,16 @@ EditorRoutes::route_removed (TimeAxisView *tv)
 }
 
 void
-EditorRoutes::route_name_changed (boost::weak_ptr<Route> r)
+EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Route> r)
 {
-	ENSURE_GUI_THREAD (bind (mem_fun (*this, &EditorRoutes::route_name_changed), r));
+	if (!what_changed.contains (ARDOUR::Properties::name)) {
+		return;
+	}
+
+	ENSURE_GUI_THREAD (*this, &EditorRoutes::route_name_changed, r)
 
 	boost::shared_ptr<Route> route = r.lock ();
+
 	if (!route) {
 		return;
 	}
@@ -355,6 +762,18 @@ EditorRoutes::route_name_changed (boost::weak_ptr<Route> r)
 	}
 }
 
+void
+EditorRoutes::update_active_display ()
+{
+	TreeModel::Children rows = _model->children();
+	TreeModel::Children::iterator i;
+
+	for (i = rows.begin(); i != rows.end(); ++i) {
+		boost::shared_ptr<Route> route = (*i)[_columns.route];
+		(*i)[_columns.active] = route->active ();
+	}
+}
+
 void
 EditorRoutes::update_visibility ()
 {
@@ -366,7 +785,6 @@ EditorRoutes::update_visibility ()
 	for (i = rows.begin(); i != rows.end(); ++i) {
 		TimeAxisView *tv = (*i)[_columns.tv];
 		(*i)[_columns.visible] = tv->marked_for_display ();
-		cerr << "marked " << tv->name() << " for display = " << tv->marked_for_display() << endl;
 	}
 
 	resume_redisplay ();
@@ -380,7 +798,9 @@ EditorRoutes::hide_track_in_display (TimeAxisView& tv)
 
 	for (i = rows.begin(); i != rows.end(); ++i) {
 		if ((*i)[_columns.tv] == &tv) {
+			tv.set_marked_for_display (false);
 			(*i)[_columns.visible] = false;
+			redisplay ();
 			break;
 		}
 	}
@@ -392,9 +812,12 @@ EditorRoutes::show_track_in_display (TimeAxisView& tv)
 	TreeModel::Children rows = _model->children();
 	TreeModel::Children::iterator i;
 
+
 	for (i = rows.begin(); i != rows.end(); ++i) {
 		if ((*i)[_columns.tv] == &tv) {
+			tv.set_marked_for_display (true);
 			(*i)[_columns.visible] = true;
+			redisplay ();
 			break;
 		}
 	}
@@ -412,28 +835,24 @@ EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, i
 void
 EditorRoutes::sync_order_keys (string const & src)
 {
-	vector<int> neworder;
+	map<int, int> new_order;
 	TreeModel::Children rows = _model->children();
 	TreeModel::Children::iterator ri;
 
-	if (src == N_ ("editor") || !_session || (_session->state_of_the_state() & Session::Loading) || rows.empty()) {
+	if (src == N_ ("editor") || !_session || (_session->state_of_the_state() & (Session::Loading|Session::Deletion)) || rows.empty()) {
 		return;
 	}
 
-	for (ri = rows.begin(); ri != rows.end(); ++ri) {
-		neworder.push_back (0);
-	}
-
 	bool changed = false;
 	int order;
 
 	for (order = 0, ri = rows.begin(); ri != rows.end(); ++ri, ++order) {
 		boost::shared_ptr<Route> route = (*ri)[_columns.route];
 
-		int old_key = order;
-		int new_key = route->order_key (N_ ("editor"));
+		int const old_key = order;
+		int const new_key = route->order_key (N_ ("editor"));
 
-		neworder[new_key] = old_key;
+		new_order[new_key] = old_key;
 
 		if (new_key != old_key) {
 			changed = true;
@@ -442,7 +861,16 @@ EditorRoutes::sync_order_keys (string const & src)
 
 	if (changed) {
 		_redisplay_does_not_reset_order_keys = true;
-		_model->reorder (neworder);
+
+		/* `compact' new_order into a vector */
+		vector<int> co;
+		for (map<int, int>::const_iterator i = new_order.begin(); i != new_order.end(); ++i) {
+			co.push_back (i->second);
+		}
+
+		assert (co.size() == _model->children().size ());
+
+		_model->reorder (co);
 		_redisplay_does_not_reset_order_keys = false;
 	}
 }
@@ -501,7 +929,7 @@ EditorRoutes::set_all_tracks_visibility (bool yn)
 }
 
 void
-EditorRoutes::set_all_audio_visibility (int tracks, bool yn)
+EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn)
 {
 	TreeModel::Children rows = _model->children();
 	TreeModel::Children::iterator i;
@@ -509,9 +937,12 @@ EditorRoutes::set_all_audio_visibility (int tracks, bool yn)
 	suspend_redisplay ();
 
 	for (i = rows.begin(); i != rows.end(); ++i) {
+
 		TreeModel::Row row = (*i);
 		TimeAxisView* tv = row[_columns.tv];
+
 		AudioTimeAxisView* atv;
+		MidiTimeAxisView* mtv;
 
 		if (tv == 0) {
 			continue;
@@ -536,6 +967,19 @@ EditorRoutes::set_all_audio_visibility (int tracks, bool yn)
 				break;
 			}
 		}
+		else if ((mtv = dynamic_cast<MidiTimeAxisView*>(tv)) != 0) {
+			switch (tracks) {
+			case 0:
+				(*i)[_columns.visible] = yn;
+				break;
+
+			case 3:
+				if (mtv->is_midi_track()) {
+					(*i)[_columns.visible] = yn;
+				}
+				break;
+			}
+		}
 	}
 
 	resume_redisplay ();
@@ -553,26 +997,138 @@ EditorRoutes::show_all_routes ()
 	set_all_tracks_visibility (true);
 }
 
+void
+EditorRoutes::show_all_audiotracks()
+{
+	set_all_audio_midi_visibility (1, true);
+}
+void
+EditorRoutes::hide_all_audiotracks ()
+{
+	set_all_audio_midi_visibility (1, false);
+}
+
 void
 EditorRoutes::show_all_audiobus ()
 {
-	set_all_audio_visibility (2, true);
+	set_all_audio_midi_visibility (2, true);
 }
 void
 EditorRoutes::hide_all_audiobus ()
 {
-	set_all_audio_visibility (2, false);
+	set_all_audio_midi_visibility (2, false);
 }
 
 void
-EditorRoutes::show_all_audiotracks()
+EditorRoutes::show_all_miditracks()
 {
-	set_all_audio_visibility (1, true);
+	set_all_audio_midi_visibility (3, true);
 }
 void
-EditorRoutes::hide_all_audiotracks ()
+EditorRoutes::hide_all_miditracks ()
 {
-	set_all_audio_visibility (1, false);
+	set_all_audio_midi_visibility (3, false);
+}
+
+bool
+EditorRoutes::key_press (GdkEventKey* ev)
+{
+        TreeViewColumn *col;
+        boost::shared_ptr<RouteList> rl (new RouteList);
+        TreePath path;
+
+        switch (ev->keyval) {
+        case GDK_Tab:
+        case GDK_ISO_Left_Tab:
+
+                /* If we appear to be editing something, leave that cleanly and appropriately.
+                */
+                if (name_editable) {
+                        name_editable->editing_done ();
+                        name_editable = 0;
+                }
+
+                col = _display.get_column (_name_column); // select&focus on name column
+
+                if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
+                        treeview_select_previous (_display, _model, col);
+                } else {
+                        treeview_select_next (_display, _model, col);
+                }
+
+                return true;
+                break;
+
+        case 'm':
+                if (get_relevant_routes (rl)) {
+                        _session->set_mute (rl, !rl->front()->muted(), Session::rt_cleanup);
+                }
+                return true;
+                break;
+
+        case 's':
+		if (Config->get_solo_control_is_listen_control()) {
+			_session->set_listen (rl, !rl->front()->listening_via_monitor(), Session::rt_cleanup);
+		} else {
+			_session->set_solo (rl, !rl->front()->self_soloed(), Session::rt_cleanup);
+		}
+                return true;
+                break;
+
+        case 'r':
+                if (get_relevant_routes (rl)) {
+                        _session->set_record_enabled (rl, !rl->front()->record_enabled(), Session::rt_cleanup);
+                }
+                break;
+
+        default:
+                break;
+        }
+
+	return false;
+}
+
+bool
+EditorRoutes::get_relevant_routes (boost::shared_ptr<RouteList> rl)
+{
+        TimeAxisView* tv;
+        RouteTimeAxisView* rtv;
+	RefPtr<TreeSelection> selection = _display.get_selection();
+        TreePath path;
+        TreeIter iter;
+
+        if (selection->count_selected_rows() != 0) {
+
+                /* use selection */
+
+                RefPtr<TreeModel> tm = RefPtr<TreeModel>::cast_dynamic (_model);
+                iter = selection->get_selected (tm);
+
+        } else {
+                /* use mouse pointer */
+
+                int x, y;
+                int bx, by;
+
+                _display.get_pointer (x, y);
+                _display.convert_widget_to_bin_window_coords (x, y, bx, by);
+
+                if (_display.get_path_at_pos (bx, by, path)) {
+                        iter = _model->get_iter (path);
+                }
+        }
+
+        if (iter) {
+                tv = (*iter)[_columns.tv];
+                if (tv) {
+                        rtv = dynamic_cast<RouteTimeAxisView*>(tv);
+                        if (rtv) {
+                                rl->push_back (rtv->route());
+                        }
+                }
+        }
+
+        return !rl->empty();
 }
 
 bool
@@ -583,45 +1139,54 @@ EditorRoutes::button_press (GdkEventButton* ev)
 		return true;
 	}
 
-	TreeIter iter;
 	TreeModel::Path path;
-	TreeViewColumn* column;
-	int cellx;
-	int celly;
-
-	if (!_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
-		return false;
+	TreeViewColumn *tvc;
+	int cell_x;
+	int cell_y;
+
+	if (!_display.get_path_at_pos ((int) ev->x, (int) ev->y, path, tvc, cell_x, cell_y)) {
+		/* cancel selection */
+		_display.get_selection()->unselect_all ();
+		/* end any editing by grabbing focus */
+		_display.grab_focus ();
+		return true;
 	}
 
-	switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
+	//Scroll editor canvas to selected track
+	if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 
-	case 0:
-		/* allow normal processing to occur */
-		return false;
-	case 1:
-		if ((iter = _model->get_iter (path))) {
-			TimeAxisView* tv = (*iter)[_columns.tv];
-			if (tv) {
-				bool visible = (*iter)[_columns.visible];
-				(*iter)[_columns.visible] = !visible;
-			}
-		}
-		return true;
+		// Get the model row.
+		Gtk::TreeModel::Row row = *_model->get_iter (path);
+
+		TimeAxisView *tv = row[_columns.tv];
 
-	case 2:
-		/* allow normal processing to occur */
-		return false;
+		int y_pos = tv->y_position();
 
-	default:
-		break;
+		//Clamp the y pos so that we do not extend beyond the canvas full height.
+		if (_editor->full_canvas_height - y_pos < _editor->_canvas_height){
+		    y_pos = _editor->full_canvas_height - _editor->_canvas_height;
+		}
+
+		//Only scroll to if the track is visible
+		if(y_pos != -1){
+		    _editor->reset_y_origin (y_pos);
+		}
 	}
 
 	return false;
 }
 
 bool
-EditorRoutes::selection_filter (Glib::RefPtr<TreeModel> const &, TreeModel::Path const &, bool)
+EditorRoutes::selection_filter (Glib::RefPtr<TreeModel> const &, TreeModel::Path const&, bool /*selected*/)
 {
+        if (selection_countdown) {
+                if (--selection_countdown == 0) {
+                        return true;
+                } else {
+                        /* no selection yet ... */
+                        return false;
+                }
+        }
 	return true;
 }
 
@@ -635,15 +1200,19 @@ struct EditorOrderRouteSorter {
 void
 EditorRoutes::initial_display ()
 {
+	suspend_redisplay ();
+	_model->clear ();
+
+	if (!_session) {
+		resume_redisplay ();
+		return;
+	}
+
 	boost::shared_ptr<RouteList> routes = _session->get_routes();
 	RouteList r (*routes);
 	EditorOrderRouteSorter sorter;
 
 	r.sort (sorter);
-
-	suspend_redisplay ();
-
-	_model->clear ();
 	_editor->handle_new_route (r);
 
 	/* don't show master bus in a new session */
@@ -656,6 +1225,7 @@ EditorRoutes::initial_display ()
 		_no_redisplay = true;
 
 		for (i = rows.begin(); i != rows.end(); ++i) {
+
 			TimeAxisView *tv =  (*i)[_columns.tv];
 			RouteTimeAxisView *rtv;
 
@@ -803,11 +1373,36 @@ EditorRoutes::move_selected_tracks (bool up)
 		neworder.push_back (leading->second->order_key (N_ ("editor")));
 	}
 
+#ifndef NDEBUG
+	for (vector<int>::iterator i = neworder.begin(); i != neworder.end(); ++i) {
+		assert (*i < (int) neworder.size ());
+	}
+#endif	
+
 	_model->reorder (neworder);
 
 	_session->sync_order_keys (N_ ("editor"));
 }
 
+void
+EditorRoutes::update_input_active_display ()
+{
+	TreeModel::Children rows = _model->children();
+	TreeModel::Children::iterator i;
+
+	for (i = rows.begin(); i != rows.end(); ++i) {
+		boost::shared_ptr<Route> route = (*i)[_columns.route];
+
+		if (boost::dynamic_pointer_cast<Track> (route)) {
+			boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
+			
+			if (mt) {
+				(*i)[_columns.is_input_active] = mt->input_active();
+			}
+		}
+	}
+}
+
 void
 EditorRoutes::update_rec_display ()
 {
@@ -817,17 +1412,74 @@ EditorRoutes::update_rec_display ()
 	for (i = rows.begin(); i != rows.end(); ++i) {
 		boost::shared_ptr<Route> route = (*i)[_columns.route];
 
-		if (boost::dynamic_pointer_cast<Track>(route)) {
+		if (boost::dynamic_pointer_cast<Track> (route)) {
+			boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
 
-			if (route->record_enabled()){
-				(*i)[_columns.rec_enabled] = true;
+			if (route->record_enabled()) {
+				if (_session->record_status() == Session::Recording) {
+					(*i)[_columns.rec_state] = 1;
+				} else {
+					(*i)[_columns.rec_state] = 2;
+				}
+			} else if (mt && mt->step_editing()) {
+				(*i)[_columns.rec_state] = 3;
 			} else {
-				(*i)[_columns.rec_enabled] = false;
+				(*i)[_columns.rec_state] = 0;
 			}
+
+			(*i)[_columns.name_editable] = !route->record_enabled ();
 		}
 	}
 }
 
+void
+EditorRoutes::update_mute_display ()
+{
+	TreeModel::Children rows = _model->children();
+	TreeModel::Children::iterator i;
+
+	for (i = rows.begin(); i != rows.end(); ++i) {
+		boost::shared_ptr<Route> route = (*i)[_columns.route];
+		(*i)[_columns.mute_state] = RouteUI::mute_active_state (_session, route);
+	}
+}
+
+void
+EditorRoutes::update_solo_display (bool /* selfsoloed */)
+{
+	TreeModel::Children rows = _model->children();
+	TreeModel::Children::iterator i;
+
+	for (i = rows.begin(); i != rows.end(); ++i) {
+		boost::shared_ptr<Route> route = (*i)[_columns.route];
+		(*i)[_columns.solo_state] = RouteUI::solo_active_state (route);
+	}
+}
+
+void
+EditorRoutes::update_solo_isolate_display ()
+{
+	TreeModel::Children rows = _model->children();
+	TreeModel::Children::iterator i;
+
+	for (i = rows.begin(); i != rows.end(); ++i) {
+		boost::shared_ptr<Route> route = (*i)[_columns.route];
+		(*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (route) ? 1 : 0;
+	}
+}
+
+void
+EditorRoutes::update_solo_safe_display ()
+{
+	TreeModel::Children rows = _model->children();
+	TreeModel::Children::iterator i;
+
+	for (i = rows.begin(); i != rows.end(); ++i) {
+		boost::shared_ptr<Route> route = (*i)[_columns.route];
+		(*i)[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (route) ? 1 : 0;
+	}
+}
+
 list<TimeAxisView*>
 EditorRoutes::views () const
 {
@@ -846,3 +1498,65 @@ EditorRoutes::clear ()
 	_model->clear ();
 	_display.set_model (_model);
 }
+
+void
+EditorRoutes::name_edit_started (CellEditable* ce, const Glib::ustring&)
+{
+        name_editable = ce;
+
+        /* give it a special name */
+
+        Gtk::Entry *e = dynamic_cast<Gtk::Entry*> (ce);
+
+        if (e) {
+                e->set_name (X_("RouteNameEditorEntry"));
+        }
+}
+
+void
+EditorRoutes::name_edit (std::string const & path, std::string const & new_text)
+{
+        name_editable = 0;
+
+	TreeIter iter = _model->get_iter (path);
+
+	if (!iter) {
+		return;
+	}
+
+	boost::shared_ptr<Route> route = (*iter)[_columns.route];
+
+	if (route && route->name() != new_text) {
+		route->set_name (new_text);
+	}
+}
+
+void
+EditorRoutes::solo_changed_so_update_mute ()
+{
+	update_mute_display ();
+}
+
+void
+EditorRoutes::show_tracks_with_regions_at_playhead ()
+{
+	boost::shared_ptr<RouteList> const r = _session->get_routes_with_regions_at (_session->transport_frame ());
+
+	set<TimeAxisView*> show;
+	for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
+		TimeAxisView* tav = _editor->axis_view_from_route (*i);
+		if (tav) {
+			show.insert (tav);
+		}
+	}
+
+	suspend_redisplay ();
+
+	TreeModel::Children rows = _model->children ();
+	for (TreeModel::Children::iterator i = rows.begin(); i != rows.end(); ++i) {
+		TimeAxisView* tv = (*i)[_columns.tv];
+		(*i)[_columns.visible] = (show.find (tv) != show.end());
+	}
+
+	resume_redisplay ();
+}