X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Froute_ui.cc;h=ae36ccba86c30179f7a6b34975a0e33832cd39e9;hb=f0db054a07ecc9d49fede8fcc9175a85c635369f;hp=c32929e35b83905019f23b30546904494f00d491;hpb=5b97b137663d0990d1a3ac172f01b200a45e4692;p=ardour.git

diff --git a/gtk2_ardour/route_ui.cc b/gtk2_ardour/route_ui.cc
index c32929e35b..ae36ccba86 100644
--- a/gtk2_ardour/route_ui.cc
+++ b/gtk2_ardour/route_ui.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2002-2006 Paul Davis 
+    Copyright (C) 2002-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
@@ -26,10 +26,11 @@
 #include <gtkmm2ext/gtk_ui.h>
 
 #include "ardour/route_group.h"
+#include "ardour/dB.h"
 #include "pbd/memento_command.h"
 #include "pbd/stacktrace.h"
-#include "pbd/shiva.h"
 #include "pbd/controllable.h"
+#include "pbd/enumwriter.h"
 
 #include "ardour_ui.h"
 #include "editor.h"
@@ -42,33 +43,32 @@
 #include "latency_gui.h"
 #include "mixer_strip.h"
 #include "automation_time_axis.h"
+#include "route_time_axis.h"
 
 #include "ardour/route.h"
+#include "ardour/event_type_map.h"
 #include "ardour/session.h"
 #include "ardour/audioengine.h"
 #include "ardour/audio_track.h"
-#include "ardour/audio_diskstream.h"
 #include "ardour/midi_track.h"
-#include "ardour/midi_diskstream.h"
 #include "ardour/template_utils.h"
 #include "ardour/filename_extensions.h"
 #include "ardour/directory_names.h"
 #include "ardour/profile.h"
 
 #include "i18n.h"
-using namespace sigc;
 using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace ARDOUR;
 using namespace PBD;
 
-RouteUI::RouteUI (ARDOUR::Session& sess)
+RouteUI::RouteUI (ARDOUR::Session* sess)
 	: AxisView(sess)
 {
 	init ();
 }
 
-RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session& sess)
+RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session* sess)
 	: AxisView(sess)
 {
 	init ();
@@ -77,13 +77,11 @@ RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session& sess)
 
 RouteUI::~RouteUI()
 {
-       /* derived classes should emit GoingAway so that they receive the signal
-          when the object is still a legal derived instance.
-       */
-	
+	_route.reset (); /* drop reference to route, so that it can be cleaned up */
+	route_connections.drop_connections ();
+
 	delete solo_menu;
 	delete mute_menu;
-	delete remote_control_menu;
 	delete sends_menu;
 }
 
@@ -94,25 +92,37 @@ RouteUI::init ()
 	xml_node = 0;
 	mute_menu = 0;
 	solo_menu = 0;
-	remote_control_menu = 0;
 	sends_menu = 0;
+	pre_fader_mute_check = 0;
+	post_fader_mute_check = 0;
+	listen_mute_check = 0;
+	main_mute_check = 0;
+        solo_safe_check = 0;
+        solo_isolated_check = 0;
 	ignore_toggle = false;
-	wait_for_release = false;
+	_solo_release = 0;
+	_mute_release = 0;
 	route_active_menu_item = 0;
-	polarity_menu_item = 0;
 	denormal_menu_item = 0;
 	multiple_mute_change = false;
 	multiple_solo_change = false;
 
+	invert_button = manage (new BindableToggleButton ());
+	// mute_button->set_self_managed (true);
+	invert_button->set_name ("InvertButton");
+	invert_button->add (invert_button_label);
+	invert_button_label.show ();
+	UI::instance()->set_tip (invert_button, _("Invert (Phase reverse) this track"), "");
+
 	mute_button = manage (new BindableToggleButton ());
-	mute_button->set_self_managed (true);
+	// mute_button->set_self_managed (true);
 	mute_button->set_name ("MuteButton");
 	mute_button->add (mute_button_label);
 	mute_button_label.show ();
 	UI::instance()->set_tip (mute_button, _("Mute this track"), "");
 
 	solo_button = manage (new BindableToggleButton ());
-	solo_button->set_self_managed (true);
+	// solo_button->set_self_managed (true);
 	solo_button->set_name ("SoloButton");
 	solo_button->add (solo_button_label);
 	solo_button_label.show ();
@@ -121,48 +131,64 @@ RouteUI::init ()
 
 	rec_enable_button = manage (new BindableToggleButton ());
 	rec_enable_button->set_name ("RecordEnableButton");
-	rec_enable_button->set_self_managed (true);
+	// rec_enable_button->set_self_managed (true);
 	rec_enable_button->add (rec_enable_button_label);
 	rec_enable_button_label.show ();
 	UI::instance()->set_tip (rec_enable_button, _("Enable recording on this track"), "");
 
 	show_sends_button = manage (new BindableToggleButton (""));
 	show_sends_button->set_name ("SendAlert");
-	show_sends_button->set_self_managed (true);
+	// show_sends_button->set_self_managed (true);
 	UI::instance()->set_tip (show_sends_button, _("make mixer strips show sends to this bus"), "");
 
-	_session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute));
-	_session.TransportStateChange.connect (mem_fun (*this, &RouteUI::check_rec_enable_sensitivity));
+	_session->SoloChanged.connect (_session_connections, invalidator (*this), boost::bind (&RouteUI::solo_changed_so_update_mute, this), gui_context());
+	_session->TransportStateChange.connect (_session_connections, invalidator (*this), boost::bind (&RouteUI::check_rec_enable_sensitivity, this), gui_context());
+	_session->RecordStateChanged.connect (_session_connections, invalidator (*this), boost::bind (&RouteUI::session_rec_enable_changed, this), gui_context());
+
+	Config->ParameterChanged.connect (*this, invalidator (*this), ui_bind (&RouteUI::parameter_changed, this, _1), gui_context());
+
+	rec_enable_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press), false);
+	rec_enable_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release), false);
+
+	show_sends_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_press), false);
+	show_sends_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release));
+
+	solo_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press), false);
+	solo_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release), false);
+	mute_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press), false);
+	mute_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release), false);
+	invert_button->signal_toggled().connect (sigc::mem_fun(*this, &RouteUI::invert_toggled), false);
 
-	Config->ParameterChanged.connect (mem_fun (*this, &RouteUI::parameter_changed));
 }
 
 void
 RouteUI::reset ()
 {
-	//Remove route connections associated with us.
-	for (vector<sigc::connection>::iterator it = connections.begin(); it!=connections.end(); ++it) {
-	    (*it).disconnect();
-	}
-
-	connections.clear ();
+	route_connections.drop_connections ();
 
 	delete solo_menu;
 	solo_menu = 0;
 
 	delete mute_menu;
 	mute_menu = 0;
-	
+
 	if (xml_node) {
 		/* do not delete the node - its owned by the route */
 		xml_node = 0;
 	}
 
 	route_active_menu_item = 0;
-	polarity_menu_item = 0;
 	denormal_menu_item = 0;
 }
 
+void
+RouteUI::self_delete ()
+{
+	/* This may be called from a non-GUI thread. Keep it safe */
+
+	delete_when_idle (this);
+}
+
 void
 RouteUI::set_route (boost::shared_ptr<Route> rp)
 {
@@ -174,63 +200,80 @@ RouteUI::set_route (boost::shared_ptr<Route> rp)
 		set_color (unique_random_color());
 	}
 
-	/* no, there is no memory leak here. This object cleans itself (and other stuff)
-	   up when the route is destroyed.
-	*/
-
 	if (self_destruct) {
-		new PairedShiva<Route,RouteUI> (*_route, *this);
+		rp->DropReferences.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::self_delete, this), gui_context());
 	}
-
+	
 	mute_button->set_controllable (_route->mute_control());
 	solo_button->set_controllable (_route->solo_control());
-  
-	connections.push_back (_route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed)));
-	connections.push_back (_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed)));
-	connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
-	connections.push_back (_route->listen_changed.connect (mem_fun(*this, &RouteUI::listen_changed)));
-	connections.push_back (_route->solo_isolated_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
-  
-	if (is_track()) {
+
+	_route->active_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_active_changed, this), gui_context());
+	_route->mute_changed.connect (route_connections, invalidator (*this), ui_bind (&RouteUI::mute_changed, this, _1), gui_context());
+
+	_route->solo_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
+	_route->solo_safe_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
+	_route->listen_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
+	_route->solo_isolated_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
+
+        _route->phase_invert_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::polarity_changed, this), gui_context());
+	_route->PropertyChanged.connect (route_connections, invalidator (*this), ui_bind (&RouteUI::property_changed, this, _1), gui_context());
+
+	if (_session->writable() && is_track()) {
 		boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
 
-		connections.push_back (t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed)));
-		connections.push_back (_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed)));
+		t->RecordEnableChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed, this), gui_context());
 
 		rec_enable_button->show();
  		rec_enable_button->set_controllable (t->rec_enable_control());
 
 		update_rec_display ();
-	} 
+	}
 
 	mute_button->unset_flags (Gtk::CAN_FOCUS);
 	solo_button->unset_flags (Gtk::CAN_FOCUS);
-	
+
 	mute_button->show();
+        invert_button->show ();
 
-	if (_route->is_control()) {
+	if (_route->is_monitor()) {
 		solo_button->hide ();
 	} else {
 		solo_button->show();
 	}
 
-	connections.push_back (_route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu)));
-
-	/* map the current state */
+	map_frozen ();
+}
 
-	mute_changed (0);
-	solo_changed (0);
+void
+RouteUI::invert_toggled ()
+{
+        cerr << this << " button state = " << invert_button->get_active() << " PI = " << _route->phase_invert() << endl;
+        _route->set_phase_invert (invert_button->get_active());
+}
 
-	map_frozen ();
+void
+RouteUI::polarity_changed ()
+{
+        if (!_route) {
+                return;
+        }
+        
+	if (_route->phase_invert()) {
+                invert_button->set_active (true);
+	} else {
+                invert_button->set_active (false);
+	}
 }
 
 bool
-RouteUI::mute_press(GdkEventButton* ev)
+RouteUI::mute_press (GdkEventButton* ev)
 {
 	if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
 		return true;
 	}
+
 	multiple_mute_change = false;
+
 	if (!ignore_toggle) {
 
 		if (Keyboard::is_context_menu_event (ev)) {
@@ -246,46 +289,52 @@ RouteUI::mute_press(GdkEventButton* ev)
 			if (Keyboard::is_button2_event (ev)) {
 				// Primary-button2 click is the midi binding click
 				// button2-click is "momentary"
-				
-				if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) {
-					wait_for_release = true;
-				} else {
-					return false;
-				}
+
+
+				if (mute_button->on_button_press_event (ev)) {
+                                        return true;
+                                }
+
+				_mute_release = new SoloMuteRelease (_route->self_muted ());
 			}
 
 			if (ev->button == 1 || Keyboard::is_button2_event (ev)) {
 
 				if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 
-					/* Primary-Tertiary-click applies change to all routes */
+					if (_mute_release) {
+						_mute_release->routes = _session->get_routes ();
+					}
 
-					_session.begin_reversible_command (_("mute change"));
-                                        Session::GlobalMuteStateCommand *cmd = new Session::GlobalMuteStateCommand(_session, this);
-					_session.set_all_mute (!_route->muted());
-                                        cmd->mark();
-					_session.add_command(cmd);
-					_session.commit_reversible_command ();
-					multiple_mute_change = true;
+					_session->set_mute (_session->get_routes(), !_route->self_muted());
 
 				} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 
-					/* Primary-button1 applies change to the mix group.
+					/* Primary-button1 applies change to the mix group even if it is not active
 					   NOTE: Primary-button2 is MIDI learn.
 					*/
 
-					if (ev->button == 1) {
-						set_route_group_mute (_route, !_route->muted());
+					if (ev->button == 1 && _route->route_group()) {
+						if (_mute_release) {
+							_mute_release->routes = _session->get_routes ();
+						}
+								
+						_session->set_mute (_session->get_routes(), !_route->self_muted(), Session::rt_cleanup, true);
 					}
-					
+
 				} else {
 
 					/* plain click applies change to this route */
-					if (wait_for_release) {
-						_route->set_mute (!_route->muted(), this);
-					} else {
-						reversibly_apply_route_boolean ("mute change", &Route::set_mute, !_route->muted(), this);
+					
+					boost::shared_ptr<RouteList> rl (new RouteList);
+					rl->push_back (_route);
+
+					if (_mute_release) {
+						_mute_release->routes = rl;
 					}
+
+					_session->set_mute (rl, !_route->self_muted());
+
 				}
 			}
 		}
@@ -296,21 +345,16 @@ RouteUI::mute_press(GdkEventButton* ev)
 }
 
 bool
-RouteUI::mute_release(GdkEventButton* ev)
+RouteUI::mute_release (GdkEventButton*)
 {
 	if (!ignore_toggle) {
-		if (wait_for_release){
-			wait_for_release = false;
-			if (multiple_mute_change) {
-				multiple_mute_change = false;
-				// undo the last op
-				// because the press was the last undoable thing we did
-				_session.undo (1U);
-			} else {
-				_route->set_mute (!_route->muted(), this);
-			}
+		if (_mute_release){
+			_session->set_mute (_mute_release->routes, _mute_release->active, Session::rt_cleanup, true);
+			delete _mute_release;
+			_mute_release = 0;
 		}
 	}
+
 	return true;
 }
 
@@ -322,111 +366,116 @@ RouteUI::solo_press(GdkEventButton* ev)
 	if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
 		return true;
 	}
+	
+	multiple_solo_change = false;
 
-	if (Config->get_solo_control_is_listen_control()) {
-
-		_route->set_listen (!_route->listening(), this);
-
-	} else {
-
-		multiple_solo_change = false;
-		if (!ignore_toggle) {
+	if (!ignore_toggle) {
+		
+		if (Keyboard::is_context_menu_event (ev)) {
 			
-			if (Keyboard::is_context_menu_event (ev)) {
-				
-				if (solo_menu == 0) {
-					build_solo_menu ();
-				}
+			if (solo_menu == 0) {
+				build_solo_menu ();
+			}
+			
+			solo_menu->popup (1, ev->time);
+			
+		} else {
+			
+			if (Keyboard::is_button2_event (ev)) {
 				
-				solo_menu->popup (1, ev->time);
+				// Primary-button2 click is the midi binding click
+				// button2-click is "momentary"
 				
-			} else {
+                                if (solo_button->on_button_press_event (ev)) {
+                                        return true;
+                                }
+
+				_solo_release = new SoloMuteRelease (_route->self_soloed());
+			}
+			
+			if (ev->button == 1 || Keyboard::is_button2_event (ev)) {
 				
-				if (Keyboard::is_button2_event (ev)) {
+				if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 					
-					// Primary-button2 click is the midi binding click
-					// button2-click is "momentary"
+					/* Primary-Tertiary-click applies change to all routes */
+
+					if (_solo_release) {
+						_solo_release->routes = _session->get_routes ();
+					}
 					
-					if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) {
-						wait_for_release = true;
+					if (Config->get_solo_control_is_listen_control()) {
+						_session->set_listen (_session->get_routes(), !_route->listening(),  Session::rt_cleanup, true);
 					} else {
-						return false;
+						_session->set_solo (_session->get_routes(), !_route->self_soloed(),  Session::rt_cleanup, true);
 					}
-				}
-				
-				if (ev->button == 1 || Keyboard::is_button2_event (ev)) {
 					
-					if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
-						
-						/* Primary-Tertiary-click applies change to all routes */
-						bool was_not_latched = false;
-						if (!Config->get_solo_latched ()) {
-							was_not_latched = true;
-							/*
-							  XXX it makes no sense to solo all tracks if we're 
-							  not in latched mode, but doing nothing feels like a bug, 
-							  so do it anyway 
-							*/
-							Config->set_solo_latched (true);
-						}
-						_session.begin_reversible_command (_("solo change"));
-						Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this);
-						_session.set_all_solo (!_route->soloed());
-						cmd->mark();
-						_session.add_command (cmd);
-						_session.commit_reversible_command ();
-						multiple_solo_change = true;
-						if (was_not_latched) {
-							Config->set_solo_latched (false);
-						}
-						
-					} else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
-						
-						// Primary-Secondary-click: exclusively solo this track, not a toggle */
-
-						_session.begin_reversible_command (_("solo change"));
-						Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand (_session, this);
-						_session.set_all_solo (false);
-						_route->set_solo (true, this);
-						cmd->mark();
-						_session.add_command(cmd);
-						_session.commit_reversible_command ();
-
-					} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
-
-						// shift-click: set this route to solo safe
-
-						if (Profile->get_sae() && ev->button == 1) {
-							// button 1 and shift-click: disables solo_latched for this click
-							if (!Config->get_solo_latched ()) {
-								Config->set_solo_latched (true);
-								reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this);
-								Config->set_solo_latched (false);
-							}
-						} else {
-							_route->set_solo_isolated (!_route->solo_isolated(), this);
-							wait_for_release = false;
-						}
+				} else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
+					
+					// Primary-Secondary-click: exclusively solo this track
 
-					} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
+					if (_solo_release) {
+						_solo_release->exclusive = true;
 
-						/* Primary-button1: solo mix group.
-						   NOTE: Primary-button2 is MIDI learn.
-						*/
+						boost::shared_ptr<RouteList> routes = _session->get_routes();
 
-						if (ev->button == 1) {
-							set_route_group_solo (_route, !_route->soloed());
+						for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
+							if ((*i)->soloed ()) {
+								_solo_release->routes_on->push_back (*i);
+							} else {
+								_solo_release->routes_off->push_back (*i);
+							}
 						}
-
+					}
+					
+					if (Config->get_solo_control_is_listen_control()) {
+						/* ??? we need a just_one_listen() method */
 					} else {
+						_session->set_just_one_solo (_route, true);
+					}
+
+				} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
+					
+					// shift-click: toggle solo isolated status
+					
+					_route->set_solo_isolated (!_route->solo_isolated(), this);
+					delete _solo_release;
+					_solo_release = 0;
+					
+				} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
+					
+					/* Primary-button1: solo mix group.
+					   NOTE: Primary-button2 is MIDI learn.
+					*/
+					
+					if (ev->button == 1 && _route->route_group()) {
 
-						/* click: solo this route */
-						if (wait_for_release) {
-							_route->set_solo (!_route->soloed(), this);
+						if (_solo_release) {
+							_solo_release->routes = _route->route_group()->route_list();
+						}
+					
+						if (Config->get_solo_control_is_listen_control()) {
+							_session->set_listen (_route->route_group()->route_list(), !_route->listening(),  Session::rt_cleanup, true);
 						} else {
-							reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this);
+							_session->set_solo (_route->route_group()->route_list(), !_route->self_soloed(),  Session::rt_cleanup, true);
 						}
 					}
+					
+				} else {
+					
+					/* click: solo this route */
+					
+					boost::shared_ptr<RouteList> rl (new RouteList);
+					rl->push_back (route());
+
+					if (_solo_release) {
+						_solo_release->routes = rl;
+					}
+
+					if (Config->get_solo_control_is_listen_control()) {
+						_session->set_listen (rl, !_route->listening());
+					} else {
+						_session->set_solo (rl, !_route->self_soloed());
+					}
 				}
 			}
 		}
@@ -436,21 +485,24 @@ RouteUI::solo_press(GdkEventButton* ev)
 }
 
 bool
-RouteUI::solo_release(GdkEventButton* ev)
+RouteUI::solo_release (GdkEventButton*)
 {
 	if (!ignore_toggle) {
-		if (wait_for_release) {
-			wait_for_release = false;
-			if (multiple_solo_change) {
-				multiple_solo_change = false;
-				// undo the last op
-				// because the press was the last undoable thing we did
-				_session.undo (1U);
+		
+		if (_solo_release) {
+
+			if (_solo_release->exclusive) {
+
 			} else {
-				// we don't use "undo the last op"
-				// here because its expensive for the GUI
-				_route->set_solo (!_route->soloed(), this);
+                                if (Config->get_solo_control_is_listen_control()) {
+                                        _session->set_listen (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true);
+                                } else {
+                                        _session->set_solo (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true);
+                                }
 			}
+
+			delete _solo_release;
+			_solo_release = 0;
 		}
 	}
 
@@ -464,7 +516,7 @@ RouteUI::rec_enable_press(GdkEventButton* ev)
 		return true;
 	}
 
-	if (!_session.engine().connected()) {
+	if (!_session->engine().connected()) {
 	        MessageDialog msg (_("Not connected to JACK - cannot engage record"));
 		msg.run ();
 		return true;
@@ -472,38 +524,33 @@ RouteUI::rec_enable_press(GdkEventButton* ev)
 
 	if (!ignore_toggle && is_track() && rec_enable_button) {
 
-		if (Keyboard::is_button2_event (ev) && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
+		if (Keyboard::is_button2_event (ev)) {
 
-			// do nothing on midi bind event
-			return false;
+			// do nothing on midi sigc::bind event
+			return rec_enable_button->on_button_press_event (ev);
 
 		} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 
-			_session.begin_reversible_command (_("rec-enable change"));
-                        Session::GlobalRecordEnableStateCommand *cmd = new Session::GlobalRecordEnableStateCommand(_session, this);
-
-			if (rec_enable_button->get_active()) {
-				_session.record_disenable_all ();
-			} else {
-				_session.record_enable_all ();
-				check_rec_enable_sensitivity ();
-			}
-
-                        cmd->mark();
-			_session.add_command(cmd);
-			_session.commit_reversible_command ();
+			_session->set_record_enable (_session->get_routes(), !rec_enable_button->get_active());
 
 		} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 
-			/* Primary-button1 applies change to the mix group.
+			/* Primary-button1 applies change to the route group (even if it is not active)
 			   NOTE: Primary-button2 is MIDI learn.
 			*/
+			if (ev->button == 1 && _route->route_group()) {
+				_session->set_record_enable (_route->route_group()->route_list(), !rec_enable_button->get_active(), Session::rt_cleanup, true);
+			}
 
-			set_route_group_rec_enable (_route, !_route->record_enabled());
+		} else if (Keyboard::is_context_menu_event (ev)) {
+
+			/* do this on release */
 
 		} else {
-			reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !track()->record_enabled(), this);
-			check_rec_enable_sensitivity ();
+
+			boost::shared_ptr<RouteList> rl (new RouteList);
+			rl->push_back (route());
+			_session->set_record_enable (rl, !rec_enable_button->get_active());
 		}
 	}
 
@@ -511,7 +558,7 @@ RouteUI::rec_enable_press(GdkEventButton* ev)
 }
 
 bool
-RouteUI::rec_enable_release (GdkEventButton* ev)
+RouteUI::rec_enable_release (GdkEventButton*)
 {
 	return true;
 }
@@ -520,37 +567,64 @@ void
 RouteUI::build_sends_menu ()
 {
 	using namespace Menu_Helpers;
-	
+
 	sends_menu = new Menu;
 	sends_menu->set_name ("ArdourContextMenu");
 	MenuList& items = sends_menu->items();
-	
-	items.push_back (MenuElem(_("Assign all tracks"), mem_fun (*this, &RouteUI::create_sends)));
-	items.push_back (MenuElem(_("Copy track gains to sends"), mem_fun (*this, &RouteUI::set_sends_gain_from_track)));
-	items.push_back (MenuElem(_("Set sends gain to -inf"), mem_fun (*this, &RouteUI::set_sends_gain_to_zero)));
-	items.push_back (MenuElem(_("Set sends gain to 0dB"), mem_fun (*this, &RouteUI::set_sends_gain_to_unity)));
+
+	items.push_back (MenuElem(_("Assign all tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends), PreFader)));
+	items.push_back (MenuElem(_("Assign all tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends), PostFader)));
+	items.push_back (MenuElem(_("Assign selected tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends), PreFader)));
+	items.push_back (MenuElem(_("Assign selected tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends), PostFader)));
+	items.push_back (MenuElem(_("Copy track gains to sends"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_from_track)));
+	items.push_back (MenuElem(_("Set sends gain to -inf"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_zero)));
+	items.push_back (MenuElem(_("Set sends gain to 0dB"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_unity)));
 
 }
 
 void
-RouteUI::create_sends ()
+RouteUI::create_sends (Placement p)
 {
-	_session.globally_add_internal_sends (_route);
+	_session->globally_add_internal_sends (_route, p);
+}
+
+void
+RouteUI::create_selected_sends (Placement p)
+{
+	boost::shared_ptr<RouteList> rlist (new RouteList);
+	TrackSelection& selected_tracks (ARDOUR_UI::instance()->the_editor().get_selection().tracks);
+
+	for (TrackSelection::iterator i = selected_tracks.begin(); i != selected_tracks.end(); ++i) {
+		RouteTimeAxisView* rtv;
+		RouteUI* rui;
+		if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
+			if ((rui = dynamic_cast<RouteUI*>(rtv)) != 0) {
+				if (boost::dynamic_pointer_cast<AudioTrack>(rui->route())) {
+					rlist->push_back (rui->route());
+				}
+			}
+		}
+	}
+	
+	_session->add_internal_sends (_route, p, rlist);
 }
 
 void
 RouteUI::set_sends_gain_from_track ()
 {
+	_session->globally_set_send_gains_from_track (_route);
 }
 
 void
 RouteUI::set_sends_gain_to_zero ()
 {
+	_session->globally_set_send_gains_to_zero (_route);
 }
 
 void
 RouteUI::set_sends_gain_to_unity ()
 {
+	_session->globally_set_send_gains_to_unity (_route);
 }
 
 bool
@@ -564,7 +638,7 @@ RouteUI::show_sends_press(GdkEventButton* ev)
 
 		if (Keyboard::is_button2_event (ev) && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 
-			// do nothing on midi bind event
+			// do nothing on midi sigc::bind event
 			return false;
 
 		} else if (Keyboard::is_context_menu_event (ev)) {
@@ -586,7 +660,7 @@ RouteUI::show_sends_press(GdkEventButton* ev)
 			if (show_sends_button->get_active()) {
 				/* show sends to this bus */
 				MixerStrip::SwitchIO (_route);
-				send_blink_connection = ARDOUR_UI::instance()->Blink.connect (mem_fun(*this, &RouteUI::send_blink));
+				send_blink_connection = ARDOUR_UI::instance()->Blink.connect (sigc::mem_fun(*this, &RouteUI::send_blink));
 			} else {
 				/* everybody back to normal */
 				send_blink_connection.disconnect ();
@@ -600,7 +674,7 @@ RouteUI::show_sends_press(GdkEventButton* ev)
 }
 
 bool
-RouteUI::show_sends_release (GdkEventButton* ev)
+RouteUI::show_sends_release (GdkEventButton*)
 {
 	return true;
 }
@@ -611,7 +685,7 @@ RouteUI::send_blink (bool onoff)
 	if (!show_sends_button) {
 		return;
 	}
-		
+
 	if (onoff) {
 		show_sends_button->set_state (STATE_ACTIVE);
 	} else {
@@ -619,17 +693,86 @@ RouteUI::send_blink (bool onoff)
 	}
 }
 
-void
-RouteUI::solo_changed(void* src)
+int
+RouteUI::solo_visual_state (boost::shared_ptr<Route> r)
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display));
+	if (r->is_master() || r->is_monitor()) {
+		return 0;
+	}
+	
+	if (Config->get_solo_control_is_listen_control()) {
+
+		if (r->listening()) {
+			return 1;
+		} else {
+			return 0;
+		}
+
+	} 
+	
+	if (r->soloed()) {
+		return 1;
+	} else {
+		return 0;
+	}
 }
 
+int
+RouteUI::solo_visual_state_with_isolate (boost::shared_ptr<Route> r)
+{
+	if (r->is_master() || r->is_monitor()) {
+		return 0;
+	}
+	
+	if (Config->get_solo_control_is_listen_control()) {
 
-void
-RouteUI::listen_changed(void* src)
+		if (r->listening()) {
+			return 1;
+		} else {
+                        return 0;
+		}
+
+	} 
+	
+	if (r->solo_isolated()) {
+		return 2;
+	} else if (r->soloed()) {
+                if (!r->self_soloed()) {
+                        return 3;
+                } else {
+                        return 1;
+                }
+	} else {
+		return 0;
+	}
+}
+
+int
+RouteUI::solo_isolate_visual_state (boost::shared_ptr<Route> r)
+{
+	if (r->is_master() || r->is_monitor()) {
+		return 0;
+	}
+	
+	if (r->solo_isolated()) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+int
+RouteUI::solo_safe_visual_state (boost::shared_ptr<Route> r)
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display));
+	if (r->is_master() || r->is_monitor()) {
+		return 0;
+	}
+	
+	if (r->solo_safe()) {
+		return 1;
+	} else {
+		return 0;
+	}
 }
 
 void
@@ -645,46 +788,85 @@ RouteUI::update_solo_display ()
 			ignore_toggle = false;
 		}
 
-		if (x) {
-			solo_button->set_visual_state (1);
-		} else {
-			solo_button->set_visual_state (0);
-		}
-
-
 	} else {
 
-		if (solo_button->get_active() != (x = _route->soloed())){
+		if (solo_button->get_active() != (x = _route->soloed())) {
 			ignore_toggle = true;
 			solo_button->set_active (x);
 			ignore_toggle = false;
-		} 
-		
-		if (_route->solo_isolated()) {
-			solo_button->set_visual_state (2);
-		} else if (x) {
-			solo_button->set_visual_state (1);
-		} else {
-			solo_button->set_visual_state (0);
 		}
+
+	}
+
+	bool yn = _route->solo_safe ();
+
+	if (solo_safe_check && solo_safe_check->get_active() != yn) {
+		solo_safe_check->set_active (yn);
+	}
+
+	yn = _route->solo_isolated ();
+
+	if (solo_isolated_check && solo_isolated_check->get_active() != yn) {
+		solo_isolated_check->set_active (yn);
 	}
+
+        set_button_names ();
+
+	solo_button->set_visual_state (solo_visual_state_with_isolate (_route));
 }
 
 void
 RouteUI::solo_changed_so_update_mute ()
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_mute_display));
+	update_mute_display ();
 }
 
 void
-RouteUI::mute_changed(void* src)
+RouteUI::mute_changed(void* /*src*/)
+{
+	update_mute_display ();
+}
+
+int
+RouteUI::mute_visual_state (Session* s, boost::shared_ptr<Route> r)
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_mute_display));
+	if (r->is_master() || r->is_monitor()) {
+		return 0;
+	}
+	
+	if (Config->get_show_solo_mutes()) {
+		
+		if (r->self_muted ()) {
+			/* full mute */
+			return 2;
+		} else if (r->muted_by_others()) {
+			return 1;
+		} else {
+			/* no mute at all */
+			return 0;
+		}
+
+	} else {
+
+		if (r->self_muted()) {
+			/* full mute */
+			return 2;
+		} else {
+			/* no mute at all */
+			return 0;
+		}
+	}
+
+	return 0;
 }
 
 void
 RouteUI::update_mute_display ()
 {
+        if (!_route) {
+                return;
+        }
+
 	bool model = _route->muted();
 	bool view = mute_button->get_active();
 
@@ -698,41 +880,28 @@ RouteUI::update_mute_display ()
 		ignore_toggle = false;
 	}
 
-	/* now attend to visual state */
-	
-	if (Config->get_show_solo_mutes()) {
-		if (_route->muted()) {
-			mute_button->set_visual_state (2);
-		} else if (!_route->soloed() && _session.soloing()) {
-			mute_button->set_visual_state (1);
-		} else {
-			mute_button->set_visual_state (0);
-		}
-	} else {
-		if (_route->muted()) {
-			mute_button->set_visual_state (2);
-		} else {
-			mute_button->set_visual_state (0);
-		}
-	}
-
+	mute_button->set_visual_state (mute_visual_state (_session, _route));
 }
 
 void
 RouteUI::route_rec_enable_changed ()
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_rec_display));
+	Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&RouteUI::update_rec_display, this));
 }
 
 void
 RouteUI::session_rec_enable_changed ()
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_rec_display));
+        update_rec_display ();
 }
 
 void
 RouteUI::update_rec_display ()
 {
+	if (!rec_enable_button || !_route) {
+		return;
+	}
+			
 	bool model = _route->record_enabled();
 	bool view = rec_enable_button->get_active();
 
@@ -745,15 +914,12 @@ RouteUI::update_rec_display ()
 		rec_enable_button->set_active (model);
 		ignore_toggle = false;
 	}
-	else {
-		return;
-	}
-	
+
 	/* now make sure its color state is correct */
 
 	if (model) {
 
-		switch (_session.record_status ()) {
+		switch (_session->record_status ()) {
 		case Session::Recording:
 			rec_enable_button->set_visual_state (1);
 			break;
@@ -768,79 +934,15 @@ RouteUI::update_rec_display ()
 	} else {
 		rec_enable_button->set_visual_state (0);
 	}
-}
 
-void
-RouteUI::build_remote_control_menu ()
-{
-	remote_control_menu = new Menu;
-	refresh_remote_control_menu ();
-}
-
-void
-RouteUI::refresh_remote_control_menu ()
-{
-	ENSURE_GUI_THREAD (mem_fun (*this, &RouteUI::refresh_remote_control_menu));
-
-	// only refresh the menu if it has been instantiated
-
-	if (remote_control_menu == 0) {
-		return;
-	}
-
-	using namespace Menu_Helpers;
-
-	RadioMenuItem::Group rc_group;
-	CheckMenuItem* rc_active;
-	uint32_t limit = _session.ntracks() + _session.nbusses();
-	char buf[32];
-
-	MenuList& rc_items = remote_control_menu->items();
-	rc_items.clear ();
-
-	/* note that this menu list starts at zero, not 1, because zero
-	   is a valid, if useless, ID.
-	*/
-
-	limit += 4; /* leave some breathing room */
-	
-	rc_items.push_back (RadioMenuElem (rc_group, _("None")));
-	if (_route->remote_control_id() == 0) {
-		rc_active = dynamic_cast<CheckMenuItem*> (&rc_items.back());
-		rc_active->set_active ();
-	}
-		
-	for (uint32_t i = 1; i < limit; ++i) {
-		snprintf (buf, sizeof (buf), "%u", i);
-		rc_items.push_back (RadioMenuElem (rc_group, buf));
-		rc_active = dynamic_cast<RadioMenuItem*>(&rc_items.back());
-		if (_route->remote_control_id() == i) {
-			rc_active = dynamic_cast<CheckMenuItem*> (&rc_items.back());
-			rc_active->set_active ();
-		}
-		rc_active->signal_activate().connect (bind (mem_fun (*this, &RouteUI::set_remote_control_id), i, rc_active));
-	}
-}
-
-void
-RouteUI::set_remote_control_id (uint32_t id, CheckMenuItem* item)
-{
-	/* this is called when the radio menu item is toggled, and so 
-	   is actually invoked twice per menu selection. we only
-	   care about the invocation for the item that was being
-	   marked active.
-	*/
-
-	if (item->get_active()) {
-		_route->set_remote_control_id (id);
-	}
+	check_rec_enable_sensitivity ();
 }
 
 void
 RouteUI::build_solo_menu (void)
 {
 	using namespace Menu_Helpers;
-	
+
 	solo_menu = new Menu;
 	solo_menu->set_name ("ArdourContextMenu");
 	MenuList& items = solo_menu->items();
@@ -848,151 +950,123 @@ RouteUI::build_solo_menu (void)
 
 	check = new CheckMenuItem(_("Solo Isolate"));
 	check->set_active (_route->solo_isolated());
-	check->signal_toggled().connect (bind (mem_fun (*this, &RouteUI::toggle_solo_isolated), check));
-	_route->solo_isolated_changed.connect(bind (mem_fun (*this, &RouteUI::solo_isolated_toggle), check));
+	check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated), check));
 	items.push_back (CheckMenuElem(*check));
+        solo_isolated_check = dynamic_cast<CheckMenuItem*>(&items.back());
+	check->show_all();
+
+	check = new CheckMenuItem(_("Solo Safe"));
+	check->set_active (_route->solo_safe());
+	check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe), check));
+	items.push_back (CheckMenuElem(*check));
+        solo_safe_check = dynamic_cast<CheckMenuItem*>(&items.back());
 	check->show_all();
 
 	//items.push_back (SeparatorElem());
-	// items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
-	
+	// items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
+
 }
 
 void
 RouteUI::build_mute_menu(void)
 {
 	using namespace Menu_Helpers;
-	
+
 	mute_menu = new Menu;
 	mute_menu->set_name ("ArdourContextMenu");
 
-#if FIX_ME_IN_3_0	
 	MenuList& items = mute_menu->items();
-	CheckMenuItem* check;
 
-	check = new CheckMenuItem(_("Pre Fader"));
-	init_mute_menu(PRE_FADER, check);
-	check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), PRE_FADER, check));
-	_route->pre_fader_changed.connect(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), check));
-	items.push_back (CheckMenuElem(*check));
-	check->show_all();
+	pre_fader_mute_check = manage (new CheckMenuItem(_("Pre Fader")));
+	init_mute_menu(MuteMaster::PreFader, pre_fader_mute_check);
+	pre_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PreFader, pre_fader_mute_check));
+	items.push_back (CheckMenuElem(*pre_fader_mute_check));
+	pre_fader_mute_check->show_all();
+
+	post_fader_mute_check = manage (new CheckMenuItem(_("Post Fader")));
+	init_mute_menu(MuteMaster::PostFader, post_fader_mute_check);
+	post_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PostFader, post_fader_mute_check));
+	items.push_back (CheckMenuElem(*post_fader_mute_check));
+	post_fader_mute_check->show_all();
+
+	listen_mute_check = manage (new CheckMenuItem(_("Control Outs")));
+	init_mute_menu(MuteMaster::Listen, listen_mute_check);
+	listen_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::Listen, listen_mute_check));
+	items.push_back (CheckMenuElem(*listen_mute_check));
+	listen_mute_check->show_all();
+
+	main_mute_check = manage (new CheckMenuItem(_("Main Outs")));
+	init_mute_menu(MuteMaster::Main, main_mute_check);
+	main_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::Main, main_mute_check));
+	items.push_back (CheckMenuElem(*main_mute_check));
+	main_mute_check->show_all();
 
-	check = new CheckMenuItem(_("Post Fader"));
-	init_mute_menu(POST_FADER, check);
-	check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), POST_FADER, check));
-	_route->post_fader_changed.connect(bind (mem_fun (*this, &RouteUI::post_fader_toggle), check));
-	items.push_back (CheckMenuElem(*check));
-	check->show_all();
-	
-	check = new CheckMenuItem(_("Control Outs"));
-	init_mute_menu(CONTROL_OUTS, check);
-	check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), CONTROL_OUTS, check));
-	_route->control_outs_changed.connect(bind (mem_fun (*this, &RouteUI::control_outs_toggle), check));
-	items.push_back (CheckMenuElem(*check));
-	check->show_all();
-
-	check = new CheckMenuItem(_("Main Outs"));
-	init_mute_menu(MAIN_OUTS, check);
-	check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MAIN_OUTS, check));
-	_route->main_outs_changed.connect(bind (mem_fun (*this, &RouteUI::main_outs_toggle), check));
-	items.push_back (CheckMenuElem(*check));
-	check->show_all();
-#endif
 	//items.push_back (SeparatorElem());
-	// items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
+	// items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
+
+	_route->mute_points_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::muting_change, this), gui_context());
 }
 
 void
 RouteUI::init_mute_menu(MuteMaster::MutePoint mp, CheckMenuItem* check)
 {
-	check->set_active (_route->mute_master()->muted_at (mp));
+	check->set_active (_route->mute_points() & mp);
 }
 
 void
 RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp, Gtk::CheckMenuItem* check)
 {
-	// _route->set_mute_config(type, check->get_active(), this);
+	if (check->get_active()) {
+		_route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() | mp));
+	} else {
+		_route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() & ~mp));
+	}
 }
 
 void
-RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem* check)
+RouteUI::muting_change ()
 {
-	_route->set_solo_isolated (check->get_active(), this);
-}
+	ENSURE_GUI_THREAD (*this, &RouteUI::muting_change)
 
-void
-RouteUI::set_route_group_solo(boost::shared_ptr<Route> route, bool yn)
-{
-	RouteGroup* route_group;
+	bool yn;
+	MuteMaster::MutePoint current = _route->mute_points ();
 
-	if((route_group = route->route_group()) != 0){
-		_session.begin_reversible_command (_("mix group solo  change"));
-                Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this);
-		route_group->apply(&Route::set_solo, yn, this);
-                cmd->mark();
-		_session.add_command (cmd);
-		_session.commit_reversible_command ();
-	} else {
-		reversibly_apply_route_boolean ("solo change", &Route::set_solo, !route->soloed(), this);
+	yn = (current & MuteMaster::PreFader);
+
+	if (pre_fader_mute_check->get_active() != yn) {
+		pre_fader_mute_check->set_active (yn);
 	}
-}
 
-void
-RouteUI::reversibly_apply_route_boolean (string name, void (Route::*func)(bool, void *), bool yn, void *arg)
-{
-	_session.begin_reversible_command (name);
-	XMLNode &before = _route->get_state();
-	bind(mem_fun(*_route, func), yn, arg)();
-	XMLNode &after = _route->get_state();
-	_session.add_command (new MementoCommand<Route>(*_route, &before, &after));
-	_session.commit_reversible_command ();
-}
+	yn = (current & MuteMaster::PostFader);
 
-void
-RouteUI::reversibly_apply_track_boolean (string name, void (Track::*func)(bool, void *), bool yn, void *arg)
-{
-	_session.begin_reversible_command (name);
-	XMLNode &before = track()->get_state();
-	bind (mem_fun (*track(), func), yn, arg)();
-	XMLNode &after = track()->get_state();
-	_session.add_command (new MementoCommand<Track>(*track(), &before, &after));
-	_session.commit_reversible_command ();
-}
+	if (post_fader_mute_check->get_active() != yn) {
+		post_fader_mute_check->set_active (yn);
+	}
 
-void
-RouteUI::set_route_group_mute(boost::shared_ptr<Route> route, bool yn)
-{
-	RouteGroup* route_group;
+	yn = (current & MuteMaster::Listen);
 
-	if((route_group = route->route_group()) != 0){
-		_session.begin_reversible_command (_("mix group mute change"));
-                Session::GlobalMuteStateCommand *cmd = new Session::GlobalMuteStateCommand (_session, this);
-		route_group->apply(&Route::set_mute, yn, this);
-                cmd->mark();
-		_session.add_command(cmd);
-		_session.commit_reversible_command ();
-	} else {
-		reversibly_apply_route_boolean ("mute change", &Route::set_mute, !route->muted(), this);
+	if (listen_mute_check->get_active() != yn) {
+		listen_mute_check->set_active (yn);
+	}
+
+	yn = (current & MuteMaster::Main);
+
+	if (main_mute_check->get_active() != yn) {
+		main_mute_check->set_active (yn);
 	}
 }
 
 void
-RouteUI::set_route_group_rec_enable(boost::shared_ptr<Route> route, bool yn)
+RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem* check)
 {
-	RouteGroup* route_group;
-
-	if((route_group = route->route_group()) != 0){
-		_session.begin_reversible_command (_("mix group rec-enable change"));
-                Session::GlobalRecordEnableStateCommand *cmd = new Session::GlobalRecordEnableStateCommand(_session, this);
-		route_group->apply (&Route::set_record_enable, yn, this);
-                cmd->mark();
-		_session.add_command(cmd);
-		_session.commit_reversible_command ();
-	} else {
-		reversibly_apply_route_boolean ("rec-enable change", &Route::set_record_enable, !_route->record_enabled(), this);
-	}
+	_route->set_solo_isolated (check->get_active(), this);
 }
 
+void
+RouteUI::toggle_solo_safe (Gtk::CheckMenuItem* check)
+{
+	_route->set_solo_safe (check->get_active(), this);
+}
 
 bool
 RouteUI::choose_color()
@@ -1013,9 +1087,9 @@ void
 RouteUI::set_color (const Gdk::Color & c)
 {
 	char buf[64];
-	
+
 	_color = c;
-	
+
 	ensure_xml_node ();
 	snprintf (buf, sizeof (buf), "%d:%d:%d", c.get_red(), c.get_green(), c.get_blue());
 	xml_node->add_property ("color", buf);
@@ -1039,7 +1113,7 @@ XMLNode*
 RouteUI::get_automation_child_xml_node (Evoral::Parameter param)
 {
 	ensure_xml_node ();
-	
+
 	XMLNodeList kids = xml_node->children();
 	XMLNodeConstIterator iter;
 
@@ -1065,7 +1139,7 @@ int
 RouteUI::set_color_from_route ()
 {
 	XMLProperty *prop;
-	
+
 	RouteUI::ensure_xml_node ();
 
 	if ((prop = xml_node->property ("color")) != 0) {
@@ -1075,7 +1149,7 @@ RouteUI::set_color_from_route ()
 		_color.set_green(g);
 		_color.set_blue(b);
 		return 0;
-	} 
+	}
 	return 1;
 }
 
@@ -1086,25 +1160,32 @@ RouteUI::remove_this_route ()
 	string prompt;
 
 	if (is_track()) {
-		prompt  = string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n(cannot be undone)"), _route->name());
+		prompt  = string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n(this cannot be undone)"), _route->name());
 	} else {
-		prompt  = string_compose (_("Do you really want to remove bus \"%1\" ?\n(cannot be undone)"), _route->name());
+		prompt  = string_compose (_("Do you really want to remove bus \"%1\" ?\n(this cannot be undone)"), _route->name());
 	}
 
 	choices.push_back (_("No, do nothing."));
 	choices.push_back (_("Yes, remove it."));
 
-	Choice prompter (prompt, choices);
+	string title;
+	if (is_track()) {
+		title = _("Remove track");
+	} else {
+		title = _("Remove bus");
+	}
+
+	Choice prompter (title, prompt, choices);
 
 	if (prompter.run () == 1) {
-		Glib::signal_idle().connect (bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this));
+		Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this));
 	}
 }
 
 gint
 RouteUI::idle_remove_this_route (RouteUI *rui)
 {
-	rui->_session.remove_route (rui->_route);
+	rui->_session->remove_route (rui->_route);
 	return false;
 }
 
@@ -1125,20 +1206,20 @@ RouteUI::route_rename ()
         name_prompter.get_result (result);
         if (result.length()) {
 			_route->set_name (result);
-		}	
+		}
 		break;
 	}
 
 	return;
-  
+
 }
 
 void
-RouteUI::name_changed ()
+RouteUI::property_changed (const PropertyChange& what_changed)
 {
-	ENSURE_GUI_THREAD(sigc::mem_fun(*this, &RouteUI::name_changed));
-
-	name_label.set_text (_route->name());
+	if (what_changed.contains (ARDOUR::Properties::name)) {
+		name_label.set_text (_route->name());
+	}
 }
 
 void
@@ -1157,39 +1238,10 @@ void
 RouteUI::route_active_changed ()
 {
 	if (route_active_menu_item) {
-		Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun (*route_active_menu_item, &CheckMenuItem::set_active), _route->active()));
+		Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&CheckMenuItem::set_active, route_active_menu_item, _route->active()));
 	}
 }
 
-void
-RouteUI::toggle_polarity ()
-{
-	if (polarity_menu_item) {
-
-		bool x;
-
-		ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::toggle_polarity));
-		
-		if ((x = polarity_menu_item->get_active()) != _route->phase_invert()) {
-			_route->set_phase_invert (x);
-			if (x) {
-			        name_label.set_text (X_("Ø ") + name_label.get_text());
-			} else {
-			        name_label.set_text (_route->name());
-			}
-		}
-	}
-}
-
-void
-RouteUI::polarity_changed ()
-{
-	if (_route->phase_invert()) {
-		name_label.set_text (X_("Ø ") + name_label.get_text());
-	} else {
-		name_label.set_text (_route->name());
-	}
-}
 
 void
 RouteUI::toggle_denormal_protection ()
@@ -1198,8 +1250,8 @@ RouteUI::toggle_denormal_protection ()
 
 		bool x;
 
-		ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::toggle_denormal_protection));
-		
+		ENSURE_GUI_THREAD (*this, &RouteUI::toggle_denormal_protection)
+
 		if ((x = denormal_menu_item->get_active()) != _route->denormal_protection()) {
 			_route->set_denormal_protection (x);
 		}
@@ -1214,62 +1266,6 @@ RouteUI::denormal_protection_changed ()
 	}
 }
 
-void
-RouteUI::solo_isolated_toggle(void* src, Gtk::CheckMenuItem* check)
-{
-	bool yn = _route->solo_isolated ();
-
-	if (check->get_active() != yn) {
-		check->set_active (yn);
-	}
-}
-
-#ifdef FIX_THIS_FOR_3_0
-void
-RouteUI::pre_fader_toggle(void* src, Gtk::CheckMenuItem* check)
-{
-	ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), src, check));
-	
-	bool yn = _route->get_mute_config(PRE_FADER);
-	if (check->get_active() != yn) {
-		check->set_active (yn);
-	}
-}
-
-void
-RouteUI::post_fader_toggle(void* src, Gtk::CheckMenuItem* check)
-{
-	ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::post_fader_toggle), src, check));
-	
-	bool yn = _route->get_mute_config(POST_FADER);
-	if (check->get_active() != yn) {
-		check->set_active (yn);
-	}
-}
-
-void
-RouteUI::control_outs_toggle(void* src, Gtk::CheckMenuItem* check)
-{
-	ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::control_outs_toggle), src, check));
-	
-	bool yn = _route->get_mute_config(CONTROL_OUTS);
-	if (check->get_active() != yn) {
-		check->set_active (yn);
-	}
-}
-
-void
-RouteUI::main_outs_toggle(void* src, Gtk::CheckMenuItem* check)
-{
-	ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::main_outs_toggle), src, check));
-	
-	bool yn = _route->get_mute_config(MAIN_OUTS);
-	if (check->get_active() != yn) {
-		check->set_active (yn);
-	}
-}
-#endif
-
 void
 RouteUI::disconnect_input ()
 {
@@ -1318,18 +1314,6 @@ RouteUI::midi_track() const
 	return boost::dynamic_pointer_cast<MidiTrack>(_route);
 }
 
-boost::shared_ptr<Diskstream>
-RouteUI::get_diskstream () const
-{
-	boost::shared_ptr<Track> t;
-
-	if ((t = boost::dynamic_pointer_cast<Track>(_route)) != 0) {
-		return t->diskstream();
-	} else {
-		return boost::shared_ptr<Diskstream> ((Diskstream*) 0);
-	}
-}
-
 string
 RouteUI::name() const
 {
@@ -1339,7 +1323,7 @@ RouteUI::name() const
 void
 RouteUI::map_frozen ()
 {
-	ENSURE_GUI_THREAD (mem_fun (*this, &RouteUI::map_frozen));
+	ENSURE_GUI_THREAD (*this, &RouteUI::map_frozen)
 
  	AudioTrack* at = dynamic_cast<AudioTrack*>(_route.get());
 
@@ -1358,7 +1342,7 @@ RouteUI::map_frozen ()
 void
 RouteUI::adjust_latency ()
 {
-	LatencyDialog dialog (_route->name() + _(" latency"), *(_route->output()), _session.frame_rate(), _session.engine().frames_per_cycle());
+	LatencyDialog dialog (_route->name() + _(" latency"), *(_route->output()), _session->frame_rate(), _session->engine().frames_per_cycle());
 }
 
 void
@@ -1367,16 +1351,16 @@ RouteUI::save_as_template ()
 	sys::path path;
 	Glib::ustring safe_name;
 	string name;
-	
+
 	path = ARDOUR::user_route_template_directory ();
-	
+
 	if (g_mkdir_with_parents (path.to_string().c_str(), 0755)) {
 		error << string_compose (_("Cannot create route template directory %1"), path.to_string()) << endmsg;
 		return;
 	}
-	
+
 	Prompter p (true); // modal
-	
+
 	p.set_prompt (_("Template name:"));
 	switch (p.run()) {
 	case RESPONSE_ACCEPT:
@@ -1384,22 +1368,22 @@ RouteUI::save_as_template ()
 	default:
 		return;
 	}
-	
+
 	p.hide ();
 	p.get_result (name, true);
-	
+
 	safe_name = legalize_for_path (name);
 	safe_name += template_suffix;
-	
+
 	path /= safe_name;
-	
+
 	_route->save_as_template (path.to_string(), name);
 }
 
 void
 RouteUI::check_rec_enable_sensitivity ()
 {
-	if (_session.transport_rolling() && rec_enable_button->get_active() && Config->get_disable_disarm_during_roll()) {
+	if (_session->transport_rolling() && rec_enable_button->get_active() && Config->get_disable_disarm_during_roll()) {
 		rec_enable_button->set_sensitive (false);
 	} else {
 		rec_enable_button->set_sensitive (true);
@@ -1409,8 +1393,6 @@ RouteUI::check_rec_enable_sensitivity ()
 void
 RouteUI::parameter_changed (string const & p)
 {
-	ENSURE_GUI_THREAD (bind (mem_fun (*this, &RouteUI::parameter_changed), p));
-	
 	if (p == "disable-disarm-during-roll") {
 		check_rec_enable_sensitivity ();
 	} else if (p == "solo-control-is-listen-control") {
@@ -1420,3 +1402,55 @@ RouteUI::parameter_changed (string const & p)
 	}
 }
 
+void
+RouteUI::step_gain_up ()
+{
+	_route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), this);
+}
+
+void
+RouteUI::page_gain_up ()
+{
+	_route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), this);
+}
+
+void
+RouteUI::step_gain_down ()
+{
+	_route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), this);
+}
+
+void
+RouteUI::page_gain_down ()
+{
+	_route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.5), this);
+}
+
+void
+RouteUI::open_remote_control_id_dialog ()
+{
+	ArdourDialog dialog (_("Remote Control ID"));
+
+	uint32_t const limit = _session->ntracks() + _session->nbusses () + 4;
+
+	HBox* hbox = manage (new HBox);
+	hbox->set_spacing (6);
+	hbox->pack_start (*manage (new Label (_("Remote control ID:"))));
+	SpinButton* spin = manage (new SpinButton);
+	spin->set_digits (0);
+	spin->set_increments (1, 10);
+	spin->set_range (0, limit);
+	spin->set_value (_route->remote_control_id());
+	hbox->pack_start (*spin);
+	dialog.get_vbox()->pack_start (*hbox);
+
+	dialog.add_button (Stock::CANCEL, RESPONSE_CANCEL);
+	dialog.add_button (Stock::APPLY, RESPONSE_ACCEPT);
+
+	dialog.show_all ();
+	int const r = dialog.run ();
+
+	if (r == RESPONSE_ACCEPT) {
+		_route->set_remote_control_id (spin->get_value_as_int ());
+	}
+}