a metric ton of changes

git-svn-id: svn://localhost/trunk/ardour2@246 d708f5d6-7413-0410-9779-e7cbd77b26cf

36 files changed, 767 insertions, 1213 deletions

diff --git a/gtk2_ardour/ardour-menus.xml b/gtk2_ardour/ardour-menus.xml
index efceee22b2..6521753bea 100644
--- a/gtk2_ardour/ardour-menus.xml
+++ b/gtk2_ardour/ardour-menus.xml
@@ -81,11 +81,13 @@
                <separator/>       
                <menuitem action='edit-cursor-to-range-start'/>
                <menuitem action='edit-cursor-to-range-end'/>
+               <separator/>
+               <menuitem action='crop'/>
+               <menuitem action='duplicate-region'/>
+               <menuitem action='insert-region'/>
+               <menuitem action='normalize-region'/>
         </menu>         
         <menu name='View' action = 'View'>
-               <menuitem action='temporal-zoom-in'/>
-               <menuitem action='temporal-zoom-out'/>
-               <menuitem action='zoom-to-session'/>
                <menu name='ZoomFocus' action='ZoomFocus'>
                    <menuitem action='zoom-focus-left'/>
                    <menuitem action='zoom-focus-right'/>
@@ -97,11 +99,36 @@
                    <menuitem action='snap-to-beat'/>
                    <menuitem action='snap-to-bar'/>
                </menu>
+               <menu name='MeterFalloff' action='MeterFalloff'>
+                    <menuitem action='MeterFalloffOff'/>
+                    <menuitem action='MeterFalloffSlowest'/>
+                    <menuitem action='MeterFalloffSlow'/>
+                    <menuitem action='MeterFalloffMedium'/>
+                    <menuitem action='MeterFalloffFast'/>
+                    <menuitem action='MeterFalloffFaster'/>
+                    <menuitem action='MeterFalloffFastest'/>
+               </menu>
+               <menu name='MeterHold' action='MeterHold'>
+                   <menuitem action='MeterHoldOff'/>
+                   <menuitem action='MeterHoldShort'/>
+                   <menuitem action='MeterHoldMedium'/>
+                   <menuitem action='MeterHoldLong'/>
+               </menu>
+
+               <separator/>
+
+               <menuitem action='temporal-zoom-in'/>
+               <menuitem action='temporal-zoom-out'/>
+               <menuitem action='zoom-to-session'/>
                <menuitem action='scroll-tracks-down'/>
                <menuitem action='scroll-tracks-up'/>
                <menuitem action='scroll-tracks-down'/>
                <menuitem action='step-tracks-up'/>
                <menuitem action='step-tracks-down'/>
+   	       <separator/>
+               <menuitem action='ToggleWaveformVisibility'/>
+               <menuitem action='ToggleWaveformsWhileRecording'/>
+               <menuitem action='ToggleMeasureVisibility'/>
          </menu>
         <menu name='JACK' action='JACK'>
                <menuitem action='JACKDisconnect'/>
@@ -130,21 +157,29 @@
 			   <menuitem action='About'/>
         </menu>
         <menu name='Options' action='Options'>
+               <menu action='Autoconnect'>
+                   <menuitem action='AutoConnectNewTrackInputsToHardware'/>
+                   <menuitem action='AutoConnectNewTrackOutputsToHardware'/>
+                   <menuitem action='AutoConnectNewTrackOutputsToHardware'/>
+                   <menuitem action='ManuallyConnectNewTrackOutputs'/>
+               </menu>
+               <menu action='Monitoring'>
+                   <menuitem action='UseHardwareMonitoring'/>
+                   <menuitem action='UseSoftwareMonitoring'/>
+                   <menuitem action='UseExternalMonitoring'/>
+               </menu>
+               <menu action='Solo'>
+                   <menuitem action='LatchedSolo'/>
+                   <menuitem action='SoloInPlace'/>
+                   <menuitem action='SoloViaBus'/>
+               </menu>
+               <separator/>
                <menuitem action='SendMTC'/>
                <menuitem action='SendMMC'/>
                <menuitem action='UseMMC'/>
                <menuitem action='SendMIDIfeedback'/>
                <menuitem action='UseMIDIcontrol'/>
                <separator/>
-               <menuitem action='AutoConnectNewTrackInputsToHardware'/>
-               <menuitem action='AutoConnectNewTrackOutputsToHardware'/>
-               <menuitem action='AutoConnectNewTrackOutputsToHardware'/>
-               <menuitem action='ManuallyConnectNewTrackOutputs'/>
-               <separator/>
-               <menuitem action='UseHardwareMonitoring'/>
-               <menuitem action='UseSoftwareMonitoring'/>
-               <menuitem action='UseExternalMonitoring'/>
-               <separator/>
                <menuitem action='StopPluginsWithTransport'/>
                <menuitem action='RunPluginsWhileRecording'/>
                <separator/>
@@ -153,10 +188,6 @@
                <menuitem action='StopTransportAtEndOfSession'/>
                <menuitem action='GainReduceFastTransport'/>
                <separator/>
-               <menuitem action='LatchedSolo'/>
-               <menuitem action='SoloInPlace'/>
-               <menuitem action='SoloViaBus'/>
-               <separator/>
                <menuitem action='AutomaticallyCreateCrossfades'/>
                <menuitem action='UnmuteNewFullCrossfades'/>
          </menu>
diff --git a/gtk2_ardour/ardour.bindings b/gtk2_ardour/ardour.bindings
index 089baa9f1d..58b923fd7a 100644
--- a/gtk2_ardour/ardour.bindings
+++ b/gtk2_ardour/ardour.bindings
@@ -8,19 +8,24 @@
 (gtk_accel_path "<Actions>/Transport/GotoEnd" "End")
 
 (gtk_accel_path "<Actions>/Editor/align-regions-sync-relative" "a")
+(gtk_accel_path "<Actions>/Editor/crop" "c")
+(gtk_accel_path "<Actions>/Editor/duplicate-region" "d")
 (gtk_accel_path "<Actions>/Editor/set-edit-cursor" "e")
+(gtk_accel_path "<Actions>/Editor/insert-region" "i")
+(gtk_accel_path "<Actions>/Editor/normalize-region" "n")
 (gtk_accel_path "<Actions>/Transport/loop" "l")
 (gtk_accel_path "<Actions>/Editor/set-playhead" "p")
-(gtk_accel_path "<Actions>/Transport/Record" "R")
+(gtk_accel_path "<Actions>/Transport/Record" "<shift>r")
 
-(gtk_accel_path "<Actions>/Editor/copy" "<Control>c")
+(gtk_accel_path "<Actions>/Editor/editor-copy" "<Control>c")
 (gtk_accel_path "<Actions>/Common/Quit" "<Control>q")
 (gtk_accel_path "<Actions>/Editor/redo" "<Control>r")
 (gtk_accel_path "<Actions>/Common/Save" "<Control>s")
-(gtk_accel_path "<Actions>/Editor/paste" "<Control>v")
-(gtk_accel_path "<Actions>/Editor/cut" "<Control>x")
+(gtk_accel_path "<Actions>/Editor/editor-paste" "<Control>v")
+(gtk_accel_path "<Actions>/Editor/editor-cut" "<Control>x")
 (gtk_accel_path "<Actions>/Editor/undo" "<Control>z")
 
+
 (gtk_accel_path "<Actions>/Editor/scroll-tracks-down" "Page_Down")
 (gtk_accel_path "<Actions>/Editor/scroll-tracks-up" "Page_Up")
 (gtk_accel_path "<Actions>/Editor/step-tracks-down" "Down")
diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index 67323ac07b..30f57a9d13 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -654,18 +654,6 @@ ARDOUR_UI::update_wall_clock ()
 }
 
 void
-ARDOUR_UI::toggle_recording_plugins ()
-{
-	/* XXX use toggle_some_session_state */
-
-	if (session == 0) {
-		return;
-	}
-
-	session->set_recording_plugins (!session->get_recording_plugins());
-}
-	
-void
 ARDOUR_UI::toggle_auto_play ()
 
 {
@@ -735,7 +723,6 @@ ARDOUR_UI::toggle_punch_in ()
 
 void
 ARDOUR_UI::map_button_state ()
-
 {
 	map_some_session_state (auto_return_button,
 				&Session::get_auto_return);
@@ -752,91 +739,6 @@ ARDOUR_UI::map_button_state ()
 }
 
 void
-ARDOUR_UI::queue_map_control_change (Session::ControlType t)
-{
-	ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::map_control_change), t));
-}
-
-void
-ARDOUR_UI::map_control_change (Session::ControlType t)
-{
-	switch (t) {
-	case Session::AutoPlay:
-		map_some_session_state (auto_play_button, &Session::get_auto_play);
-		break;
-
-	case Session::AutoLoop:
-		break;
-
-	case Session::AutoReturn:
-		map_some_session_state (auto_return_button, &Session::get_auto_return);
-		break;
-
-	case Session::AutoInput:
-		map_some_session_state (auto_input_button, &Session::get_auto_input);
-		break;
-
-	case Session::PunchOut:
-		map_some_session_state (punch_in_button, &Session::get_punch_out);
-		break;
-
-	case Session::PunchIn:
-		map_some_session_state (punch_in_button, &Session::get_punch_in);
-		break;
-
-	case Session::Clicking:
-		map_some_session_state (click_button, &Session::get_clicking);
-		break;
-
-	case Session::SlaveType:
-//		map_some_session_state (mtc_slave_button, &Session::get_mtc_slave);
-		break;
-
-	case Session::SendMTC:
-//		map_some_session_state (send_mtc_button, &Session::get_send_mtc);
-		break;
-
-	case Session::SendMMC:
-//		map_some_session_state (send_mmc_button, &Session::get_send_mmc);
-		break;
-
-	case Session::MMCControl:       
-//		map_some_session_state (mmc_control_button, &Session::get_mmc_control);
-		break;
-
-	case Session::MidiFeedback:       
-//		map_some_session_state (mmc_control_button, &Session::get_mmc_control);
-		break;
-	case Session::MidiControl:       
-//		map_some_session_state (mmc_control_button, &Session::get_mmc_control);
-		break;
-		
-	case Session::Live:
-		break;
-
-	case Session::RecordingPlugins:
-		break;
-
-	case Session::CrossFadesActive:
-		break;
-		
-	case Session::EditingMode:
-		break;
-
-	case Session::PlayRange:
-		break;
-
-	case Session::AlignChoice:
-		/* don't care, this is handled by the options editor */
-		break;
-	case Session::SeamlessLoop:
-		/* don't care, this is handled by the options editor */
-		break;
-	       
-	}
-}
-
-void
 ARDOUR_UI::control_methods_adjusted ()
 
 {
diff --git a/gtk2_ardour/ardour_ui.h b/gtk2_ardour/ardour_ui.h
index 907307bd3f..284a89ab21 100644
--- a/gtk2_ardour/ardour_ui.h
+++ b/gtk2_ardour/ardour_ui.h
@@ -566,13 +566,12 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void connect_dependents_to_session (ARDOUR::Session *);
 	void we_have_dependents ();
 	void setup_keybindings ();
-
+	void setup_options ();
+	
 	guint32  last_key_press_time;
 
 	void snapshot_session ();
 
-	void map_control_change (ARDOUR::Session::ControlType);
-	void queue_map_control_change (ARDOUR::Session::ControlType);
 	void map_record_state ();
 	void queue_map_record_state ();
 
@@ -591,10 +590,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	LocationUI *location_ui;
 	int         create_location_ui ();
 
-	/* Various options */
-
-	void toggle_recording_plugins ();
-
 	/* Options window */
 	
 	OptionEditor *option_editor;
@@ -675,7 +670,11 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 
 	void editor_realized ();
 
-	void toggle_session_state (const char* group, const char* action, void (ARDOUR::Session::*set)(bool));
+	std::vector<std::string> positional_sync_strings;
+
+	void toggle_config_state (const char* group, const char* action, void (ARDOUR::Configuration::*set)(bool));
+	void toggle_session_state (const char* group, const char* action, void (ARDOUR::Session::*set)(bool), bool (ARDOUR::Session::*get)(void) const);
+	void toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot);
 	void toggle_send_midi_feedback ();
 	void toggle_use_mmc ();
 	void toggle_send_mmc ();
@@ -699,6 +698,11 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void toggle_SoloViaBus();
 	void toggle_AutomaticallyCreateCrossfades();
 	void toggle_UnmuteNewFullCrossfades();
+
+	void mtc_port_changed ();
+	void map_some_session_state (const char* group, const char* action, bool (ARDOUR::Session::*get)() const);
+	void queue_session_control_changed (ARDOUR::Session::ControlType t);
+	void session_control_changed (ARDOUR::Session::ControlType t);
 };
 
 
diff --git a/gtk2_ardour/ardour_ui2.cc b/gtk2_ardour/ardour_ui2.cc
index 173f6c30a3..ab4a0e9b53 100644
--- a/gtk2_ardour/ardour_ui2.cc
+++ b/gtk2_ardour/ardour_ui2.cc
@@ -53,16 +53,6 @@ using namespace Gtk;
 using namespace Glib;
 using namespace sigc;
 
-
-static const gchar *psync_strings[] = {
-	N_("Internal"),
-	N_("Slave to MTC"),
-	N_("Sync with JACK"),
-	0
-};
-
-static vector<string> positional_sync_strings;
-
 int	
 ARDOUR_UI::setup_windows ()
 {
@@ -391,7 +381,7 @@ ARDOUR_UI::setup_transport ()
 	ARDOUR_UI::instance()->tooltips().set_tip (primary_clock, _("Primary clock"));
 	ARDOUR_UI::instance()->tooltips().set_tip (secondary_clock, _("secondary clock"));
 
-	/* options */
+	/* options: XXX these should all be actions with the buttons as proxies */
 
 	auto_return_button.signal_toggled().connect (mem_fun(*this,&ARDOUR_UI::toggle_auto_return));
 	auto_play_button.signal_toggled().connect (mem_fun(*this,&ARDOUR_UI::toggle_auto_play));
@@ -458,9 +448,7 @@ ARDOUR_UI::setup_transport ()
 	sdframe->set_shadow_type (SHADOW_IN);
 	sdframe->add (speed_display_box);
 
-	positional_sync_strings = internationalize (psync_strings);
-
-	set_popdown_strings (sync_option_combo, positional_sync_strings);
+	mtc_port_changed ();
 	sync_option_combo.set_active_text (positional_sync_strings.front());
 	sync_option_combo.signal_changed().connect (mem_fun (*this, &ARDOUR_UI::sync_option_changed));
 
diff --git a/gtk2_ardour/ardour_ui_dialogs.cc b/gtk2_ardour/ardour_ui_dialogs.cc
index 22fa1d384f..6c8b5b540e 100644
--- a/gtk2_ardour/ardour_ui_dialogs.cc
+++ b/gtk2_ardour/ardour_ui_dialogs.cc
@@ -80,6 +80,8 @@ ARDOUR_UI::connect_to_session (Session *s)
 		sfdb->set_session (s);
 	}
 
+	setup_options ();
+
 	Blink.connect (mem_fun(*this, &ARDOUR_UI::transport_rec_enable_blink));
 	Blink.connect (mem_fun(*this, &ARDOUR_UI::solo_blink));
 	Blink.connect (mem_fun(*this, &ARDOUR_UI::audition_blink));
@@ -89,7 +91,6 @@ ARDOUR_UI::connect_to_session (Session *s)
 	*/
 
 	session->TransportStateChange.connect (mem_fun(*this, &ARDOUR_UI::queue_transport_change));
-	session->ControlChanged.connect (mem_fun(*this, &ARDOUR_UI::queue_map_control_change));
 
 	/* alert the user to these things happening */
 
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index 669eb3a65d..753aa6a667 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -335,7 +335,7 @@ ARDOUR_UI::install_actions ()
 	ActionManager::session_sensitive_actions.push_back (act);
 	act = ActionManager::register_toggle_action (option_actions, X_("SendMMC"), _("Send MMC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mtc));
 	ActionManager::session_sensitive_actions.push_back (act);
-	act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Send MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc));
+	act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Use MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc));
 	ActionManager::session_sensitive_actions.push_back (act);
 	act = ActionManager::register_toggle_action (option_actions, X_("SendMIDIfeedback"), _("Send MIDI feedback"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_feedback));
 	ActionManager::session_sensitive_actions.push_back (act);
diff --git a/gtk2_ardour/ardour_ui_options.cc b/gtk2_ardour/ardour_ui_options.cc
index 7bcd9e2dcb..2fbec5d9a1 100644
--- a/gtk2_ardour/ardour_ui_options.cc
+++ b/gtk2_ardour/ardour_ui_options.cc
@@ -18,36 +18,67 @@
     $Id$
 */
 
+#include <gtkmm2ext/utils.h>
+
 #include <ardour/configuration.h>
 #include <ardour/session.h>
 #include <ardour/audioengine.h>
 
 #include "ardour_ui.h"
 #include "actions.h"
+#include "gui_thread.h"
+
+#include "i18n.h"
 
 using namespace Gtk;
+using namespace Gtkmm2ext;
 using namespace ARDOUR;
 
 void
 ARDOUR_UI::toggle_time_master ()
 {
-	bool yn = time_master_button.get_active();
+	toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master);
+	if (session) {
+		session->engine().reset_timebase ();
+	}
+}
 
-	Config->set_jack_time_master (yn);
+void
+ARDOUR_UI::toggle_config_state (const char* group, const char* action, void (Configuration::*set)(bool))
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		(Config->*set) (tact->get_active());
+	}
+}
 
+void
+ARDOUR_UI::toggle_session_state (const char* group, const char* action, void (Session::*set)(bool), bool (Session::*get)(void) const)
+{
 	if (session) {
-		session->engine().reset_timebase ();
+		Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+		if (act) {
+			Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+			bool x = (session->*get)();
+
+			if (x != tact->get_active()) {
+				(session->*set) (!x);
+			}
+		}
 	}
 }
 
 void
-ARDOUR_UI::toggle_session_state (const char* group, const char* action, void (Session::*set)(bool))
+ARDOUR_UI::toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot)
 {
 	if (session) {
 		Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
 		if (act) {
 			Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-			(session->*set) (tact->get_active());
+			if (tact->get_active()) {
+				theSlot ();
+			}
 		}
 	}
 }
@@ -55,93 +86,170 @@ ARDOUR_UI::toggle_session_state (const char* group, const char* action, void (Se
 void
 ARDOUR_UI::toggle_send_mtc ()
 {
-	toggle_session_state ("options", "SendMTC", &Session::set_send_mtc);
+	toggle_session_state ("options", "SendMTC", &Session::set_send_mtc, &Session::get_send_mtc);
 }
 
 void
 ARDOUR_UI::toggle_send_mmc ()
 {
-	toggle_session_state ("options", "SendMMC", &Session::set_send_mmc);
+	toggle_session_state ("options", "SendMMC", &Session::set_send_mmc, &Session::get_send_mmc);
 }
 
 void
 ARDOUR_UI::toggle_use_mmc ()
 {
-	toggle_session_state ("options", "UseMMC", &Session::set_mmc_control);
+	toggle_session_state ("options", "UseMMC", &Session::set_mmc_control, &Session::get_mmc_control);
 }
 
 void
 ARDOUR_UI::toggle_use_midi_control ()
 {
-	toggle_session_state ("options", "UseMIDIcontrol", &Session::set_midi_control);
+	toggle_session_state ("options", "UseMIDIcontrol", &Session::set_midi_control, &Session::get_midi_control);
 }
 
 void
 ARDOUR_UI::toggle_send_midi_feedback ()
 {
-	toggle_session_state ("options", "SendMIDIfeedback", &Session::set_midi_feedback);
+	toggle_session_state ("options", "SendMIDIfeedback", &Session::set_midi_feedback, &Session::get_midi_feedback);
 }
 
 void
 ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware()
 {
+	toggle_session_state ("options", "AutoConnectNewTrackInputsToHardware", &Session::set_input_auto_connect, &Session::get_input_auto_connect);
 }
 void
 ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware()
 {
+	toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectPhysical));
 }
 void
 ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster()
 {
+	toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectMaster));
 }
 void
 ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs()
 {
+	toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectOption (0)));
 }
+
 void
 ARDOUR_UI::toggle_UseHardwareMonitoring()
 {
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseSoftwareMonitoring");
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		if (tact->get_active()) {
+			Config->set_use_hardware_monitoring (true);
+			Config->set_use_sw_monitoring (false);
+			if (session) {
+				session->reset_input_monitor_state();
+			}
+		}
+	}
 }
+
 void
 ARDOUR_UI::toggle_UseSoftwareMonitoring()
 {
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseSoftwareMonitoring");
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		if (tact->get_active()) {
+			Config->set_use_hardware_monitoring (false);
+			Config->set_use_sw_monitoring (true);
+			if (session) {
+				session->reset_input_monitor_state();
+			}
+		}
+	}
 }
+
 void
 ARDOUR_UI::toggle_UseExternalMonitoring()
 {
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseExternalMonitoring");
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		if (tact->get_active()) {
+			Config->set_use_hardware_monitoring (false);
+			Config->set_use_sw_monitoring (false);
+			if (session) {
+				session->reset_input_monitor_state();
+			}
+		}
+	}
 }
+
 void
 ARDOUR_UI::toggle_StopPluginsWithTransport()
 {
+	toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport);
 }
 void
 ARDOUR_UI::toggle_RunPluginsWhileRecording()
 {
+	toggle_session_state ("options", "RunPluginsWhileRecording", &Session::set_recording_plugins, &Session::get_recording_plugins);
 }
+
 void
 ARDOUR_UI::toggle_VerifyRemoveLastCapture()
 {
+	toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture);
 }
+
 void
 ARDOUR_UI::toggle_StopRecordingOnXrun()
 {
+	toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun);
 }
+
 void
 ARDOUR_UI::toggle_StopTransportAtEndOfSession()
 {
+	toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end);
 }
+
 void
 ARDOUR_UI::toggle_GainReduceFastTransport()
 {
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "GainReduceFastTransport");
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		if (tact->get_active()) {
+			Config->set_quieten_at_speed (0.251189); // -12dB reduction for ffwd or rewind
+		} else {
+			Config->set_quieten_at_speed (1.0); /* no change */
+		}
+	}
 }
+
 void
 ARDOUR_UI::toggle_LatchedSolo()
 {
+	toggle_session_state ("options", "LatchedSolo", &Session::set_solo_latched, &Session::solo_latched);
 }
+
 void
 ARDOUR_UI::toggle_SoloViaBus()
 {
+	if (!session) {
+		return;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "SoloViaBus");
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact->get_active()) {
+			session->set_solo_model (Session::SoloBus);
+		} else {
+			session->set_solo_model (Session::InverseMute);
+		}
+	}
 }
+
 void
 ARDOUR_UI::toggle_AutomaticallyCreateCrossfades()
 {
@@ -150,3 +258,187 @@ void
 ARDOUR_UI::toggle_UnmuteNewFullCrossfades()
 {
 }
+
+void
+ARDOUR_UI::mtc_port_changed ()
+{
+	bool have_mtc;
+
+	if (session) {
+		if (session->mtc_port()) {
+			have_mtc = true;
+		} else {
+			have_mtc = false;
+		}
+	} else {
+		have_mtc = false;
+	}
+
+	if (have_mtc) {
+		const gchar *psync_strings[] = {
+			N_("Internal"),
+			N_("MTC"),
+			N_("JACK"),
+			0
+		};
+		
+		positional_sync_strings = internationalize (psync_strings);
+		
+	} else {
+		const gchar *psync_strings[] = {
+			N_("Internal"),
+			N_("JACK"),
+			0
+		};
+		positional_sync_strings = internationalize (psync_strings);
+	}
+	
+	set_popdown_strings (sync_option_combo, positional_sync_strings);
+}
+
+void
+ARDOUR_UI::setup_options ()
+{
+	mtc_port_changed ();
+
+	session_control_changed (Session::SlaveType);
+	session_control_changed (Session::SendMTC);
+	session_control_changed (Session::SendMMC);
+	session_control_changed (Session::MMCControl);
+	session_control_changed (Session::MidiFeedback);
+	session_control_changed (Session::MidiControl);
+	session_control_changed (Session::RecordingPlugins);
+	session_control_changed (Session::CrossFadesActive);
+	session_control_changed (Session::SoloLatch);
+	session_control_changed (Session::SoloingModel);
+	session_control_changed (Session::LayeringModel);
+	session_control_changed (Session::CrossfadingModel);
+
+	session->ControlChanged.connect (mem_fun (*this, &ARDOUR_UI::queue_session_control_changed));
+}
+
+void
+ARDOUR_UI::map_some_session_state (const char* group, const char* action, bool (Session::*get)() const)
+{
+	if (!session) {
+		return;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		bool x = (session->*get)();
+		if (tact->get_active() != x) {
+			tact->set_active (x);
+		}
+	}
+}
+
+void
+ARDOUR_UI::queue_session_control_changed (Session::ControlType t)
+{
+	ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::session_control_changed), t));
+}
+
+void
+ARDOUR_UI::session_control_changed (Session::ControlType t)
+{
+	switch (t) {
+	case Session::SlaveType:
+		switch (session->slave_source()) {
+		case Session::None:
+			sync_option_combo.set_active_text (_("Internal"));
+			break;
+		case Session::MTC:
+			sync_option_combo.set_active_text (_("MTC"));
+			break;
+		case Session::JACK:
+			sync_option_combo.set_active_text (_("JACK"));
+			break;
+		}
+		
+		break;
+
+	case Session::SendMTC:
+		map_some_session_state ("options", "SendMTC", &Session::get_send_mtc);
+		break;
+
+	case Session::SendMMC:
+		map_some_session_state ("options", "SendMMC", &Session::get_send_mmc);
+		break;
+
+	case Session::MMCControl:       
+		map_some_session_state ("options", "UseMMC", &Session::get_mmc_control);
+		break;
+
+	case Session::MidiFeedback:       
+		map_some_session_state ("options", "SendMIDIfeedback", &Session::get_midi_feedback);
+		break;
+
+	case Session::MidiControl:       
+		map_some_session_state ("options", "UseMIDIcontrol", &Session::get_midi_control);
+		break;
+
+	case Session::RecordingPlugins:
+		map_some_session_state ("options", "RunPluginsWhileRecording", &Session::get_recording_plugins);
+		break;
+
+	case Session::CrossFadesActive:
+		map_some_session_state ("options", "CrossfadesActive", &Session::get_crossfades_active);
+		break;
+
+	case Session::SoloLatch:
+		break;
+
+	case Session::SoloingModel:
+		switch (session->solo_model()) {
+		case Session::InverseMute:
+			break;
+		case Session::SoloBus:
+			break;
+		}
+		break;
+
+	case Session::LayeringModel:
+		break;
+
+	case Session::CrossfadingModel:
+		break;
+
+		
+        // BUTTON STATE: fix me in the future to use actions
+
+
+	case Session::AutoPlay:
+		map_some_session_state (auto_play_button, &Session::get_auto_play);
+		break;
+
+	case Session::AutoLoop:
+		break;
+
+	case Session::AutoReturn:
+		map_some_session_state (auto_return_button, &Session::get_auto_return);
+		break;
+
+	case Session::AutoInput:
+		map_some_session_state (auto_input_button, &Session::get_auto_input);
+		break;
+
+	case Session::PunchOut:
+		map_some_session_state (punch_in_button, &Session::get_punch_out);
+		break;
+
+	case Session::PunchIn:
+		map_some_session_state (punch_in_button, &Session::get_punch_in);
+		break;
+
+	case Session::Clicking:
+		map_some_session_state (click_button, &Session::get_clicking);
+		break;
+
+	default:
+		// somebody else handles this 
+		break;
+
+	}
+}
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index 5bc2590446..a44eba3754 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -669,7 +669,7 @@ Editor::Editor (AudioEngine& eng)
 
 	edit_pane.pack1 (edit_frame, true, true);
 	edit_pane.pack2 (*notebook_tearoff, true, true);
-
+	
 	edit_pane.signal_size_allocate().connect_notify (bind (mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
 
 	top_hbox.pack_start (toolbar_frame, true, true);
@@ -2605,23 +2605,35 @@ Editor::setup_toolbar ()
 
 	selection_start_clock_label.set_text (_("Start:"));
 	selection_end_clock_label.set_text (_("End:"));
-	edit_cursor_clock_label.set_text (_("Edit:"));
+	edit_cursor_clock_label.set_text (_("Edit"));
 
-	toolbar_selection_clock_table.set_border_width (5);
-	toolbar_selection_clock_table.set_col_spacings (2);
-	toolbar_selection_clock_table.set_homogeneous (false);
+	/* the zoom in/out buttons are generally taller than the clocks, so
+	   put all the toolbar clocks into a size group with one of the 
+	   buttons to make them all equal height.
+
+	   this also applies to the various toolbar combos
+	*/
 
-//	toolbar_selection_clock_table.attach (selection_start_clock_label, 0, 1, 0, 1, 0, 0, 0, 0);
-//	toolbar_selection_clock_table.attach (selection_end_clock_label, 1, 2, 0, 1, 0, 0, 0, 0);
-	toolbar_selection_clock_table.attach (edit_cursor_clock_label, 2, 3, 0, 1, FILL, FILL, 0, 0);
+	RefPtr<SizeGroup> toolbar_clock_size_group = SizeGroup::create (SIZE_GROUP_VERTICAL);
+	toolbar_clock_size_group->add_widget (zoom_out_button);
+	toolbar_clock_size_group->add_widget (edit_cursor_clock);
+	toolbar_clock_size_group->add_widget (zoom_range_clock);
+	toolbar_clock_size_group->add_widget (nudge_clock);
+	toolbar_clock_size_group->add_widget (edit_mode_selector);
+	toolbar_clock_size_group->add_widget (snap_type_selector);
+	toolbar_clock_size_group->add_widget (snap_mode_selector);
+	toolbar_clock_size_group->add_widget (zoom_focus_selector);
 
-//	toolbar_selection_clock_table.attach (selection_start_clock, 0, 1, 1, 2, 0, 0);
-//	toolbar_selection_clock_table.attach (selection_end_clock, 1, 2, 1, 2, 0, 0);
-	toolbar_selection_clock_table.attach (edit_cursor_clock, 2, 3, 1, 2, FILL, FILL);
+	HBox* edit_clock_hbox = manage (new HBox());
+	VBox* edit_clock_vbox = manage (new VBox());
 
+	edit_clock_hbox->pack_start (edit_cursor_clock, false, false);
+
+	edit_clock_vbox->set_spacing (3);
+	edit_clock_vbox->set_border_width (3);
+	edit_clock_vbox->pack_start (edit_cursor_clock_label, false, false);
+	edit_clock_vbox->pack_start (*edit_clock_hbox, false, false);
 
-//	toolbar_clock_vbox.set_spacing (2);
-//	toolbar_clock_vbox.set_border_width (10);
 	/* the editor/mixer button will be enabled at session connect */
 
 	editor_mixer_button.set_active(false);
@@ -2630,7 +2642,7 @@ Editor::setup_toolbar ()
 	HBox* hbox = new HBox;
 
 	hbox->pack_start (editor_mixer_button, false, false);
-	hbox->pack_start (toolbar_selection_clock_table, false, false);
+	hbox->pack_start (*edit_clock_vbox, false, false);
 	hbox->pack_start (zoom_indicator_vbox, false, false); 
 	hbox->pack_start (zoom_focus_box, false, false);
 	hbox->pack_start (snap_type_box, false, false);
@@ -3643,7 +3655,7 @@ Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
 	char buf[32];
 	XMLNode* node = ARDOUR_UI::instance()->editor_settings();
 	int width, height;
-	static int32_t done[4] = { 0, 0, 0, 0 };
+	static int32_t done;
 	XMLNode* geometry;
 
 	if ((geometry = find_named_node (*node, "geometry")) == 0) {
@@ -3656,18 +3668,19 @@ Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
 
 	if (which == static_cast<Paned*> (&edit_pane)) {
 
-		if (done[0]) {
+		if (done) {
 			return;
 		}
 
 		if (!geometry || (prop = geometry->property ("edit_pane_pos")) == 0) {
-			pos = 75;
+			/* initial allocation is 90% to canvas, 10% to notebook */
+			pos = (int) floor (alloc.get_width() * 0.90f);
 			snprintf (buf, sizeof(buf), "%d", pos);
 		} else {
 			pos = atoi (prop->value());
 		}
-
-		if ((done[0] = GTK_WIDGET(edit_pane.gobj())->allocation.width > pos)) {
+		
+		if ((done = GTK_WIDGET(edit_pane.gobj())->allocation.width > pos)) {
 			edit_pane.set_position (pos);
 		}
 	}
diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h
index 74a565cd91..349781c406 100644
--- a/gtk2_ardour/editor.h
+++ b/gtk2_ardour/editor.h
@@ -278,6 +278,13 @@ class Editor : public PublicEditor
 	void toggle_follow_playhead ();
 	bool follow_playhead() const { return _follow_playhead; }
 
+	void toggle_waveform_visibility ();
+	void toggle_waveforms_while_recording ();
+	void toggle_measure_visibility ();
+
+	void set_meter_falloff (float);
+	void set_meter_hold (int32_t);
+
 	/* xfades */
 
 	void toggle_xfades_active();
diff --git a/gtk2_ardour/editor_actions.cc b/gtk2_ardour/editor_actions.cc
index 35a9ac6d54..dbf7bc1c89 100644
--- a/gtk2_ardour/editor_actions.cc
+++ b/gtk2_ardour/editor_actions.cc
@@ -21,10 +21,15 @@ Editor::register_actions ()
 	RefPtr<ActionGroup> editor_actions = ActionGroup::create (X_("Editor"));
 	
 	/* non-operative menu items for menu bar */
--
+
 	ActionManager::register_action (editor_actions, X_("Edit"), _("Edit"));
 	ActionManager::register_action (editor_actions, X_("View"), _("View"));
 	ActionManager::register_action (editor_actions, X_("ZoomFocus"), _("ZoomFocus"));
+	ActionManager::register_action (editor_actions, X_("MeterHold"), _("Meter hold"));
+	ActionManager::register_action (editor_actions, X_("MeterFalloff"), _("Meter falloff"));
+	ActionManager::register_action (editor_actions, X_("Solo"), _("Solo"));
+	ActionManager::register_action (editor_actions, X_("Monitoring"), _("Monitoring"));
+	ActionManager::register_action (editor_actions, X_("Autoconnect"), _("Autoconnect"));
 
 	/* add named actions for the editor */
 
@@ -165,7 +170,7 @@ Editor::register_actions ()
 	ActionManager::session_sensitive_actions.push_back (act);
 	act = ActionManager::register_action (editor_actions, "normalize-region", _("normalize region"), mem_fun(*this, &Editor::normalize_region));
 	ActionManager::session_sensitive_actions.push_back (act);
-	act = ActionManager::register_action (editor_actions, "editor-crop", _("editor crop"), mem_fun(*this, &Editor::crop_region_to_selection));
+	act = ActionManager::register_action (editor_actions, "crop", _("crop"), mem_fun(*this, &Editor::crop_region_to_selection));
 	ActionManager::session_sensitive_actions.push_back (act);
 	act = ActionManager::register_action (editor_actions, "insert-chunk", _("insert chunk"), bind (mem_fun(*this, &Editor::paste_named_selection), 1.0f));
 	ActionManager::session_sensitive_actions.push_back (act);
@@ -200,8 +205,6 @@ Editor::register_actions ()
 	Glib::RefPtr<ActionGroup> zoom_actions = ActionGroup::create (X_("Zoom"));
 	RadioAction::Group zoom_group;
 
-	ActionManager::register_action (editor_actions, X_("ZoomFocus"), _("Zoom focus"));
-
 	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-left", _("zoom focus left"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusLeft));
 	ActionManager::session_sensitive_actions.push_back (act);
 	ActionManager::register_radio_action (zoom_actions, zoom_group, "zoom-focus-right", _("zoom focus right"), bind (mem_fun(*this, &Editor::set_zoom_focus), Editing::ZoomFocusRight));
@@ -297,13 +300,30 @@ Editor::register_actions ()
 	act = ActionManager::register_action (rl_actions, X_("rlImportAudio"), _("Embed audio (link)"), bind (mem_fun(*this, &Editor::import_audio), false));
 	ActionManager::session_sensitive_actions.push_back (act);
 
-#ifdef NEW_ACTIONS
+	ActionManager::register_toggle_action (editor_actions, X_("ToggleWaveformVisibility"), _("show waveforms"), mem_fun (*this, &Editor::toggle_waveform_visibility));
+	ActionManager::register_toggle_action (editor_actions, X_("ToggleWaveformsWhileRecording"), _("show waveforms while recording"), mem_fun (*this, &Editor::toggle_waveforms_while_recording));
+	ActionManager::register_toggle_action (editor_actions, X_("ToggleMeasureVisibility"), _("show measures"), mem_fun (*this, &Editor::toggle_measure_visibility));
+
+	RadioAction::Group meter_falloff_group;
+	RadioAction::Group meter_hold_group;
 
-	ToggleWaveformVisibility;
-	ToggleWaveformsWhileRecording;
-	ToggleMeasureVisibility;
+	/*
+	    Slowest = 6.6dB/sec falloff at update rate of 40ms
+	    Slow    = 6.8dB/sec falloff at update rate of 40ms
+	*/
 
-#endif
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffOff"), _("off"), bind (mem_fun (*this, &Editor::set_meter_falloff), 0.0f));
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("slowest"), bind (mem_fun (*this, &Editor::set_meter_falloff), 0.266f)); 
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("slow"), bind (mem_fun (*this, &Editor::set_meter_falloff), 0.342f));
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("medium"), bind (mem_fun (*this, &Editor::set_meter_falloff), 0.7f));
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFast"), _("fast"), bind (mem_fun (*this, &Editor::set_meter_falloff), 1.1f));
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("faster"), bind (mem_fun (*this, &Editor::set_meter_falloff), 1.5f));
+	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("fastest"), bind (mem_fun (*this, &Editor::set_meter_falloff), 2.5f));
+
+	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldOff"), _("off"), bind (mem_fun (*this, &Editor::set_meter_hold), 0));
+	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldShort"), _("short"), bind (mem_fun (*this, &Editor::set_meter_hold), 40));
+	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldMedium"), _("medium"), bind (mem_fun (*this, &Editor::set_meter_hold), 100));
+	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldLong"), _("long"), bind (mem_fun (*this, &Editor::set_meter_hold), 200));
 
 	ActionManager::add_action_group (rl_actions);
 	ActionManager::add_action_group (zoom_actions);
@@ -311,3 +331,34 @@ Editor::register_actions ()
 	ActionManager::add_action_group (snap_actions);
 	ActionManager::add_action_group (editor_actions);
 }
+
+void
+Editor::toggle_waveform_visibility ()
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("ToggleWaveformVisibility"));
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		set_show_waveforms (tact->get_active());
+	}
+}
+
+void
+Editor::toggle_waveforms_while_recording ()
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("ToggleWaveformVisibility"));
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		set_show_waveforms_recording (tact->get_active());
+	}
+}
+
+void
+Editor::toggle_measure_visibility ()
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("ToggleWaveformVisibility"));
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		set_show_measures (tact->get_active());
+	}
+}
+
diff --git a/gtk2_ardour/editor_mouse.cc b/gtk2_ardour/editor_mouse.cc
index fa0649faf1..64d00f56ab 100644
--- a/gtk2_ardour/editor_mouse.cc
+++ b/gtk2_ardour/editor_mouse.cc
@@ -3244,8 +3244,9 @@ Editor::region_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event
 			}
 
 			rv->get_time_axis_view().reveal_dependent_views (*rv);
+
+			/* no need to add an undo here, we did that when we added this playlist to motion_frozen playlists */
 			
-			session->add_undo (rv->region.playlist()->get_memento());
 			rv->region.set_position (where, (void *) this);
 		}
 	}
diff --git a/gtk2_ardour/editor_ops.cc b/gtk2_ardour/editor_ops.cc
index aa8eec8df3..7bc088e2df 100644
--- a/gtk2_ardour/editor_ops.cc
+++ b/gtk2_ardour/editor_ops.cc
@@ -79,6 +79,7 @@ void
 Editor::undo (uint32_t n)
 {
 	if (session) {
+		cerr << "Undo " << n << " operations\n";
 		session->undo (n);
 	}
 }
@@ -91,6 +92,23 @@ Editor::redo (uint32_t n)
 	}
 }
 
+void
+Editor::set_meter_hold (int32_t cnt)
+{
+	if (session) {
+		session->set_meter_hold (cnt);
+	}
+}
+
+void
+Editor::set_meter_falloff (float val)
+{
+	if (session) {
+		session->set_meter_falloff (val);
+	}
+}
+
+
 int
 Editor::ensure_cursor (jack_nframes_t *pos)
 {
diff --git a/gtk2_ardour/mixer_strip.cc b/gtk2_ardour/mixer_strip.cc
index 771a3eda9f..346f9ec2dd 100644
--- a/gtk2_ardour/mixer_strip.cc
+++ b/gtk2_ardour/mixer_strip.cc
@@ -1244,7 +1244,7 @@ MixerStrip::build_route_ops_menu ()
 {
 	using namespace Menu_Helpers;
 
-	route_ops_menu = new Menu;
+	route_ops_menu = manage (new Menu);
 	route_ops_menu->set_name ("ArdourContextMenu");
 
 	MenuList& items = route_ops_menu->items();
@@ -1255,6 +1255,11 @@ MixerStrip::build_route_ops_menu ()
 	route_active_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
 	route_active_menu_item->set_active (_route.active());
 
+	build_remote_control_menu ();
+	
+	items.push_back (SeparatorElem());
+	items.push_back (MenuElem (_("Remote Control ID"), *remote_control_menu));
+
 	items.push_back (SeparatorElem());
 	items.push_back (MenuElem (_("Remove"), mem_fun(*this, &RouteUI::remove_this_route)));
 }
@@ -1274,6 +1279,8 @@ MixerStrip::list_route_operations ()
 	if (route_ops_menu == 0) {
 		build_route_ops_menu ();
 	}
+	
+	refresh_remote_control_menu();
 
 	route_ops_menu->popup (1, 0);
 }
diff --git a/gtk2_ardour/mixer_strip.h b/gtk2_ardour/mixer_strip.h
index 8b69e26379..f348b96803 100644
--- a/gtk2_ardour/mixer_strip.h
+++ b/gtk2_ardour/mixer_strip.h
@@ -220,7 +220,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
 
 	void set_automated_controls_sensitivity (bool yn);
 
-	Gtk::Menu *route_ops_menu;
+	Gtk::Menu* route_ops_menu;
 	void build_route_ops_menu ();
 	gint name_button_button_release (GdkEventButton*);
 	void list_route_operations ();
@@ -268,6 +268,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
 
 	string solo_button_name () const { return "MixerSoloButton"; }
 	string safe_solo_button_name () const { return "MixerSafeSoloButton"; }
+
 };
 
 #endif /* __ardour_mixer_strip__ */
diff --git a/gtk2_ardour/option_editor.cc b/gtk2_ardour/option_editor.cc
index 049bf5331b..c31fdb98f5 100644
--- a/gtk2_ardour/option_editor.cc
+++ b/gtk2_ardour/option_editor.cc
@@ -45,14 +45,6 @@ using namespace Editing;
 using namespace Gtkmm2ext;
 using namespace std;
 
-static const gchar *psync_strings[] = {
-	N_("Internal"),
-	N_("Slave to MTC"),
-	N_("Sync with JACK"),
-	N_("never used but stops crashes"),
-	0
-};
-
 static const gchar *lmode_strings[] = {
 	N_("Later regions are higher"),
 	N_("Most recently added/moved/trimmed regions are higher"),
@@ -91,32 +83,13 @@ OptionEditor::OptionEditor (ARDOUR_UI& uip, PublicEditor& ed, Mixer_UI& mixui)
 	  short_xfade_adjustment (0, 1.0, 500.0, 5.0, 100.0),
 	  short_xfade_slider (short_xfade_adjustment),
 
-	  /* solo */
-	  solo_latched_button (_("Latched solo")),
-	  solo_via_bus_button (_("Solo via bus")),
-
-	  /* display */
-
-	  show_waveforms_button (_("Show waveforms")),
-	  show_waveforms_recording_button (_("Show waveforms while recording")),
-	  mixer_strip_width_button (_("Narrow mixer strips")),
-	  show_measures_button (_("Show measure lines")),
-	  follow_playhead_button (_("Follow playhead")),
-	  
 	  /* Sync */
 
-	  send_mtc_button (_("Send MTC")),
-	  send_mmc_button (_("Send MMC")),
-	  jack_time_master_button (_("JACK time master")),
 	  smpte_offset_clock (X_("SMPTEOffsetClock"), true, true),
 	  smpte_offset_negative_button (_("SMPTE offset is negative")),
 
 	  /* MIDI */
 
-	  midi_feedback_button (_("Send MIDI parameter feedback")),
-	  midi_control_button (_("MIDI parameter control")),
-	  mmc_control_button (_("MMC control")),
-	  
 	  /* Click */
 
 	  click_table (2, 3),
@@ -129,23 +102,7 @@ OptionEditor::OptionEditor (ARDOUR_UI& uip, PublicEditor& ed, Mixer_UI& mixui)
 	  delete_button_adjustment (3, 1, 5),
 	  delete_button_spin (delete_button_adjustment),
 	  edit_button_adjustment (3, 1, 5),
-	  edit_button_spin (edit_button_adjustment),
-
-	  /* Misc */
-
-	  auto_connect_inputs_button (_("Auto-connect new track inputs to hardware")),
-	  auto_connect_output_physical_button (_("Auto-connect new track outputs to hardware")),
-	  auto_connect_output_master_button (_("Auto-connect new track outputs to master bus")),
-	  auto_connect_output_manual_button (_("Manually connect new track outputs")),
-	  hw_monitor_button(_("Use Hardware Monitoring")),
-	  sw_monitor_button(_("Use Software Monitoring")),
-	  plugins_stop_button (_("Stop plugins with transport")),
-	  plugins_on_rec_button (_("Run plugins while recording")),
-	  verify_remove_last_capture_button (_("Verify remove last capture")),
-	  stop_rec_on_xrun_button (_("Stop recording on xrun")),
-	  stop_at_end_button (_("Stop transport at end of session")),
-	  debug_keyboard_button (_("Debug keyboard events")),
-	  speed_quieten_button (_("-12dB gain reduction for ffwd/rew"))
+	  edit_button_spin (edit_button_adjustment)
 	  
 {
 	using namespace Notebook_Helpers;
@@ -178,21 +135,15 @@ OptionEditor::OptionEditor (ARDOUR_UI& uip, PublicEditor& ed, Mixer_UI& mixui)
 	setup_sync_options();
 	setup_path_options();
 	setup_fade_options ();
-	setup_solo_options ();
-	setup_display_options ();
-	setup_misc_options ();
 	setup_keyboard_options ();
 	setup_auditioner_editor ();
 
-	notebook.pages().push_back (TabElem (misc_packer, _("Misc")));
 	notebook.pages().push_back (TabElem (sync_packer, _("Sync")));
 	notebook.pages().push_back (TabElem (path_table, _("Paths/Files")));
-	notebook.pages().push_back (TabElem (display_packer, _("Display")));
 	notebook.pages().push_back (TabElem (keyboard_mouse_table, _("Kbd/Mouse")));
 	notebook.pages().push_back (TabElem (click_packer, _("Click")));
 	notebook.pages().push_back (TabElem (audition_packer, _("Audition")));
 	notebook.pages().push_back (TabElem (fade_packer, _("Layers & Fades")));
-	notebook.pages().push_back (TabElem (solo_packer, _("Solo")));
 
 	if (!MIDI::Manager::instance()->get_midi_ports().empty()) {
 		setup_midi_options ();
@@ -213,26 +164,11 @@ OptionEditor::set_session (Session *s)
 	click_emphasis_path_entry.set_text ("");
 	session_raid_entry.set_text ("");
 
-	send_mtc_button.set_sensitive (false);
-	send_mmc_button.set_sensitive (false);
-	midi_feedback_button.set_sensitive (false);
-	midi_control_button.set_sensitive (false);
-	mmc_control_button.set_sensitive (false);
 	click_path_entry.set_sensitive (false);
 	click_emphasis_path_entry.set_sensitive (false);
 	session_raid_entry.set_sensitive (false);
-	plugins_on_rec_button.set_sensitive (false);
-	verify_remove_last_capture_button.set_sensitive (false);
-	slave_type_combo.set_sensitive (false);
-	solo_latched_button.set_sensitive (false);
-	solo_via_bus_button.set_sensitive (false);
+
 	smpte_fps_combo.set_sensitive (false);
-	meter_hold_combo.set_sensitive (false);
-	meter_falloff_combo.set_sensitive (false);
-	auto_connect_inputs_button.set_sensitive (false);
-	auto_connect_output_physical_button.set_sensitive (false);
-	auto_connect_output_master_button.set_sensitive (false);
-	auto_connect_output_manual_button.set_sensitive (false);
 	layer_mode_combo.set_sensitive (false);
 	short_xfade_slider.set_sensitive (false);
 	smpte_offset_negative_button.set_sensitive (false);
@@ -243,26 +179,11 @@ OptionEditor::set_session (Session *s)
 		return;
 	}
 
-	send_mtc_button.set_sensitive (true);
-	send_mmc_button.set_sensitive (true);
-	midi_feedback_button.set_sensitive (true);
-	midi_control_button.set_sensitive (true);
-	mmc_control_button.set_sensitive (true);
+
 	click_path_entry.set_sensitive (true);
 	click_emphasis_path_entry.set_sensitive (true);
 	session_raid_entry.set_sensitive (true);
-	plugins_on_rec_button.set_sensitive (true);
-	verify_remove_last_capture_button.set_sensitive (true);
-	slave_type_combo.set_sensitive (true);
-	solo_latched_button.set_sensitive (true);
-	solo_via_bus_button.set_sensitive (true);
 	smpte_fps_combo.set_sensitive (true);
-	meter_hold_combo.set_sensitive (true);
-	meter_falloff_combo.set_sensitive (true);
-	auto_connect_inputs_button.set_sensitive (true);
-	auto_connect_output_physical_button.set_sensitive (true);
-	auto_connect_output_master_button.set_sensitive (true);
-	auto_connect_output_manual_button.set_sensitive (true);
 	layer_mode_combo.set_sensitive (true);
 	short_xfade_slider.set_sensitive (true);
 	smpte_offset_negative_button.set_sensitive (true);
@@ -289,14 +210,6 @@ OptionEditor::set_session (Session *s)
 	smpte_offset_clock.set (s->smpte_offset (), true);
 
 	smpte_offset_negative_button.set_active (session->smpte_offset_negative());
-	send_mtc_button.set_active (session->get_send_mtc());
-
-	/* MIDI I/O */
-
-	send_mmc_button.set_active (session->get_send_mmc());
-	midi_control_button.set_active (session->get_midi_control());
-	midi_feedback_button.set_active (session->get_midi_feedback());
-	mmc_control_button.set_active (session->get_mmc_control());
 
 	/* set up port assignments */
 
@@ -320,77 +233,15 @@ OptionEditor::set_session (Session *s)
 		}
 	}
 
-	auto_connect_inputs_button.set_active (session->get_input_auto_connect());
-
-	Session::AutoConnectOption oac = session->get_output_auto_connect();
-	if (oac & Session::AutoConnectPhysical) {
-		auto_connect_output_physical_button.set_active (true);
-	} else if (oac & Session::AutoConnectMaster) {
-		auto_connect_output_master_button.set_active (true);
-	} else {
-		auto_connect_output_manual_button.set_active (true);
-	}
-
 	setup_click_editor ();
 	connect_audition_editor ();
 
-	plugins_on_rec_button.set_active (session->get_recording_plugins ());
-	verify_remove_last_capture_button.set_active (Config->get_verify_remove_last_capture());
-
 	layer_mode_combo.set_active_text (layer_mode_strings[session->get_layer_model()]);
 	xfade_model_combo.set_active_text (xfade_model_strings[session->get_xfade_model()]);
 
 	short_xfade_adjustment.set_value ((Crossfade::short_xfade_length() / (float) session->frame_rate()) * 1000.0);
 
-	xfade_active_button.set_active (session->get_crossfades_active());
-	solo_latched_button.set_active (session->solo_latched());
-	solo_via_bus_button.set_active (session->solo_model() == Session::SoloBus);
-	
 	add_session_paths ();
-
-	vector<string> dumb;
-	dumb.push_back (positional_sync_strings[Session::None]);
-	dumb.push_back (positional_sync_strings[Session::JACK]);
-	if (session->mtc_port()) {
-		dumb.push_back (positional_sync_strings[Session::MTC]);
-	} 
-	set_popdown_strings (slave_type_combo, dumb);
-
-	// meter stuff
-	if (session->meter_falloff() == 0.0f) {
-		meter_falloff_combo.set_active_text (_("Off"));
-	} else if (session->meter_falloff() <= 0.3f) {
-		meter_falloff_combo.set_active_text (_("Slowest"));
-	} else if (session->meter_falloff() <= 0.4f) {
-		meter_falloff_combo.set_active_text (_("Slow"));
-	} else if (session->meter_falloff() <= 0.8f) {
-		meter_falloff_combo.set_active_text (_("Medium"));
-	} else if (session->meter_falloff() <= 1.4f) {
-		meter_falloff_combo.set_active_text (_("Fast"));
-	} else if (session->meter_falloff() <= 2.0f) {
-		meter_falloff_combo.set_active_text (_("Faster"));
-	} else {
-		meter_falloff_combo.set_active_text (_("Fastest"));
-	}
-
-	switch ((int) floor (session->meter_hold())) {
-	case 0:
-		meter_hold_combo.set_active_text (_("Off"));
-		break;
-	case 40:
-		meter_hold_combo.set_active_text (_("Short"));
-		break;
-	case 100:
-		meter_hold_combo.set_active_text (_("Medium"));
-		break;
-	case 200:
-		meter_hold_combo.set_active_text (_("Long"));
-		break;
-	}
-	
-	session_control_changed (Session::SlaveType);
-	session_control_changed (Session::AlignChoice);
-	session->ControlChanged.connect (mem_fun(*this, &OptionEditor::queue_session_control_changed));
 }
 
 OptionEditor::~OptionEditor ()
@@ -609,236 +460,11 @@ OptionEditor::xfade_active_clicked ()
 }
 
 void
-OptionEditor::setup_solo_options ()
-{
-	Gtk::HBox* hbox;
-
-	solo_via_bus_button.set_name ("OptionEditorToggleButton");
-	solo_latched_button.set_name ("OptionEditorToggleButton");
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (12);
-	hbox->pack_start (solo_via_bus_button, false, false);
-	solo_packer.pack_start (*hbox, false, false);
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (12);
-	hbox->pack_start (solo_latched_button, false, false);
-	solo_packer.pack_start (*hbox, false, false);
-
-	solo_via_bus_button.signal_clicked().connect 
-		(mem_fun(*this, &OptionEditor::solo_via_bus_clicked));
-	solo_latched_button.signal_clicked().connect 
-		(mem_fun(*this, &OptionEditor::solo_latched_clicked));
-
-	solo_packer.show_all ();
-}
-
-void
-OptionEditor::solo_via_bus_clicked ()
-{
-	if (!session) {
-		return;
-	}
-
-	if (solo_via_bus_button.get_active()) {
-		session->set_solo_model (Session::SoloBus);
-	} else {
-		session->set_solo_model (Session::InverseMute);
-	}
-}
-
-void
-OptionEditor::solo_latched_clicked ()
-{
-	if (!session) {
-		return;
-	}
-
-	bool x = solo_latched_button.get_active();
-
-	if (x != session->solo_latched()) {
-		session->set_solo_latched (x);
-	}
-}
-
-void
-OptionEditor::setup_display_options ()
-{
-	HBox* hbox;
-	vector<string> dumb;
-
-	display_packer.set_border_width (12);
-	display_packer.set_spacing (5);
-
-	show_waveforms_button.set_name ("OptionEditorToggleButton");
-	show_waveforms_recording_button.set_name ("OptionEditorToggleButton");
-	show_measures_button.set_name ("OptionEditorToggleButton");
-	follow_playhead_button.set_name ("OptionEditorToggleButton");
-	mixer_strip_width_button.set_name ("OptionEditorToggleButton");
-
-	mixer_strip_width_button.set_active (mixer.get_strip_width() == Narrow);
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->pack_start (show_waveforms_button, false, false);
-	display_packer.pack_start (*hbox, false, false);
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->pack_start (show_waveforms_recording_button, false, false);
-	display_packer.pack_start (*hbox, false, false);
-	
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->pack_start (show_measures_button, false, false);
-	display_packer.pack_start (*hbox, false, false);
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->pack_start (mixer_strip_width_button, false, false);
-	display_packer.pack_start (*hbox, false, false);
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->pack_start (follow_playhead_button, false, false);
-	display_packer.pack_start (*hbox, false, false);
-
-	Label *meter_hold_label = manage (new Label (_("Meter Peak Hold")));
-	meter_hold_label->set_name ("OptionsLabel");
-	dumb.clear ();
-	dumb.push_back (_("Off"));
-	dumb.push_back (_("Short"));
-	dumb.push_back (_("Medium"));
-	dumb.push_back (_("Long"));
-	set_popdown_strings (meter_hold_combo, dumb);
-	meter_hold_combo.signal_changed().connect (mem_fun(*this, &OptionEditor::meter_hold_chosen));
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->set_spacing (8);
-	hbox->pack_start (*meter_hold_label, false, false);
-	hbox->pack_start (meter_hold_combo, false, false);
-	display_packer.pack_start (*hbox, false, false);
-
-	Label *meter_falloff_label = manage (new Label (_("Meter Falloff")));
-	meter_falloff_label->set_name ("OptionsLabel");
-	dumb.clear ();
-	dumb.push_back (_("Off"));
-	dumb.push_back (_("Slowest"));
-	dumb.push_back (_("Slow"));
-	dumb.push_back (_("Medium"));
-	dumb.push_back (_("Fast"));
-	dumb.push_back (_("Faster"));
-	dumb.push_back (_("Fastest"));
-	set_popdown_strings (meter_falloff_combo, dumb);
-	meter_falloff_combo.signal_changed().connect (mem_fun(*this, &OptionEditor::meter_falloff_chosen));
-	hbox = manage (new HBox);
-	hbox->set_border_width (8);
-	hbox->set_spacing (8);
-	hbox->pack_start (*meter_falloff_label, false, false);
-	hbox->pack_start (meter_falloff_combo, false, false);
-	display_packer.pack_start (*hbox, false, false);
-	
-	
-	show_waveforms_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::show_waveforms_clicked));
-	show_waveforms_recording_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::show_waveforms_recording_clicked));
-	show_measures_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::show_measures_clicked));
-	mixer_strip_width_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::strip_width_clicked));
-	follow_playhead_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::follow_playhead_clicked));
-
-	editor.DisplayControlChanged.connect (mem_fun(*this, &OptionEditor::display_control_changed));
-
-	show_measures_button.set_active (editor.show_measures());
-	show_waveforms_button.set_active (editor.show_waveforms());
-	show_waveforms_recording_button.set_active (editor.show_waveforms_recording());
-	follow_playhead_button.set_active (editor.follow_playhead());
-}
-
-void
-OptionEditor::meter_hold_chosen ()
-{
-	if (session) {
-		string str = meter_hold_combo.get_active_text();
-		
-		if (str == _("Off")) {
-			session->set_meter_hold (0);
-		} else if (str == _("Short")) {
-			session->set_meter_hold (40);
-		} else if (str == _("Medium")) {
-			session->set_meter_hold (100);
-		} else if (str == _("Long")) {
-			session->set_meter_hold (200);
-		}
-	}
-}
-
-void
-OptionEditor::meter_falloff_chosen ()
-{
-	if (session) {
-		string str = meter_falloff_combo.get_active_text();
-		
-		if (str == _("Off")) {
-			session->set_meter_falloff (0.0f);
-		} else if (str == _("Slowest")) {
-			session->set_meter_falloff (0.266f); // 6.6 dB/sec falloff at update rate of 40 ms
-		} else if (str == _("Slow")) {
-			session->set_meter_falloff (0.342f); // 8.6 dB/sec falloff at update rate of 40 ms
-		} else if (str == _("Medium")) {
-			session->set_meter_falloff  (0.7f);
-		} else if (str == _("Fast")) {
-			session->set_meter_falloff (1.1f);
-		} else if (str == _("Faster")) {
-			session->set_meter_falloff (1.5f);
-		} else if (str == _("Fastest")) {
-			session->set_meter_falloff (2.5f);
-		}
-	}
-}
-
-void
-OptionEditor::display_control_changed (Editing::DisplayControl dc)
-{
-	ToggleButton* button = 0;
-	bool val = true;
-
-	switch (dc) {
-	case ShowMeasures:
-		val = editor.show_measures ();
-		button = &show_measures_button;
-		break;
-	case ShowWaveforms:
-		val = editor.show_waveforms ();
-		button = &show_waveforms_button;
-		break;
-	case ShowWaveformsRecording:
-		val = editor.show_waveforms_recording ();
-		button = &show_waveforms_recording_button;
-		break;
-	case FollowPlayhead:
-		val = editor.follow_playhead ();
-		button = &follow_playhead_button;
-		break;
-	}
-
-	if (button->get_active() != val) {
-		button->set_active (val);
-	}
-}
-
-void
 OptionEditor::setup_sync_options ()
 {
-	Label *slave_type_label = manage (new Label (_("Positional Sync")));
 	HBox* hbox;
 	vector<string> dumb;
 
-	slave_type_label->set_name("OptionsLabel");
-	positional_sync_strings = internationalize (psync_strings);
-
-	slave_type_combo.set_name ("OptionsEntry");
-	slave_type_combo.signal_changed().connect (mem_fun(*this, &OptionEditor::slave_type_chosen));
-
 	dumb.clear ();
 	dumb.push_back (X_("24 FPS"));
 	dumb.push_back (X_("25 FPS"));
@@ -851,32 +477,10 @@ OptionEditor::setup_sync_options ()
 	smpte_offset_clock.set_mode (AudioClock::SMPTE);
 	smpte_offset_clock.ValueChanged.connect (mem_fun(*this, &OptionEditor::smpte_offset_chosen));
 	
-	send_mtc_button.set_name ("OptionEditorToggleButton");
-	jack_time_master_button.set_name ("OptionEditorToggleButton");
 	smpte_offset_negative_button.set_name ("OptionEditorToggleButton");
 
-	send_mtc_button.unset_flags (Gtk::CAN_FOCUS);
-	jack_time_master_button.unset_flags (Gtk::CAN_FOCUS);
 	smpte_offset_negative_button.unset_flags (Gtk::CAN_FOCUS);
 
-	hbox = manage (new HBox);
-	hbox->set_border_width (5);
-	hbox->set_spacing (10);
-	hbox->pack_start (*slave_type_label, false, false);
-	hbox->pack_start (slave_type_combo, false, false);
-
-	sync_packer.pack_start (*hbox, false, false);
-	
-	hbox = manage (new HBox);
-	hbox->set_border_width (5);
-	hbox->pack_start (send_mtc_button, false, false);
-	sync_packer.pack_start (*hbox, false, false);
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (5);
-	hbox->pack_start (jack_time_master_button, false, false);
-	sync_packer.pack_start (*hbox, false, false);
-
 	Label *smpte_fps_label = manage (new Label (_("SMPTE Frames/second")));
 	Label *smpte_offset_label = manage (new Label (_("SMPTE Offset")));
 	smpte_fps_label->set_name("OptionsLabel");
@@ -899,10 +503,6 @@ OptionEditor::setup_sync_options ()
 
 	sync_packer.pack_start (*hbox, false, false);
 
-	jack_time_master_button.set_active (Config->get_jack_time_master());
-
-	send_mtc_button.signal_button_press_event().connect (bind (mem_fun(*this, &OptionEditor::send_mtc_toggled), &send_mtc_button));
-	jack_time_master_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::jack_time_master_clicked));
 	smpte_offset_negative_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::smpte_offset_negative_clicked));
 }
 
@@ -1061,46 +661,9 @@ OptionEditor::setup_midi_options ()
 	hbox->set_border_width (6);
 	hbox->pack_start (*table, true, false);
 	midi_packer.pack_start (*hbox, false, false);
-	
-	VBox* mmcbuttonbox = manage (new VBox);
-
-	mmc_control_button.set_name ("OptionEditorToggleButton");
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (6);
-	hbox->pack_start (mmc_control_button, false, false, 36);
-	mmcbuttonbox->pack_start (*hbox, false, false);
-
-	midi_control_button.set_name ("OptionEditorToggleButton");
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (6);
-	hbox->pack_start (midi_control_button, false, false, 36);
-	mmcbuttonbox->pack_start (*hbox, false, false);
-
-	send_mmc_button.set_name ("OptionEditorToggleButton");
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (6);
-	hbox->pack_start (send_mmc_button, false, false, 36);
-	mmcbuttonbox->pack_start (*hbox, false, false);
-	
-	midi_feedback_button.set_name ("OptionEditorToggleButton");
-
-	hbox = manage (new HBox);
-	hbox->set_border_width (6);
-	hbox->pack_start (midi_feedback_button, false, false, 36);
-	mmcbuttonbox->pack_start (*hbox, false, false);
-
-	midi_packer.pack_start (*mmcbuttonbox, false, false);
-
-	mmc_control_button.signal_toggled().connect (bind (mem_fun(*this, &OptionEditor::mmc_control_toggled), &mmc_control_button));
-	midi_control_button.signal_toggled().connect (bind (mem_fun(*this, &OptionEditor::midi_control_toggled), &midi_control_button));
-	send_mmc_button.signal_toggled().connect (bind (mem_fun(*this, &OptionEditor::send_mmc_toggled), &send_mmc_button));
-	midi_feedback_button.signal_toggled().connect (bind (mem_fun(*this, &OptionEditor::midi_feedback_toggled), &midi_feedback_button));
 }
 
-gint
+bool
 OptionEditor::mtc_port_chosen (GdkEventButton* ev, MIDI::Port *port, Gtk::RadioButton* rb) 
 {
 	if (session) {
@@ -1111,26 +674,14 @@ OptionEditor::mtc_port_chosen (GdkEventButton* ev, MIDI::Port *port, Gtk::RadioB
 			} else {
 				session->set_mtc_port ("");
 			}
-
-			/* update sync options to reflect MTC port availability */
-
-			vector<string> dumb;
-			dumb.push_back (positional_sync_strings[Session::None]);
-			dumb.push_back (positional_sync_strings[Session::JACK]);
-
-			if (session->mtc_port()) {
-				dumb.push_back (positional_sync_strings[Session::MTC]);
-			}
-			set_popdown_strings (slave_type_combo, dumb);
-
 			rb->set_active (true);
 		}
 	}
-
-	return stop_signal (*rb, "button_press_event");
+	
+	return false;
 }
 
-gint
+bool
 OptionEditor::mmc_port_chosen (GdkEventButton* ev, MIDI::Port* port, Gtk::RadioButton* rb)
 {
 	if (session) {
@@ -1144,10 +695,10 @@ OptionEditor::mmc_port_chosen (GdkEventButton* ev, MIDI::Port* port, Gtk::RadioB
 			rb->set_active (true);
 		}
 	}
-	return stop_signal (*rb, "button_press_event");
+	return false;
 }
 
-gint
+bool
 OptionEditor::midi_port_chosen (GdkEventButton* ev, MIDI::Port* port, Gtk::RadioButton* rb)
 {
 	if (session) {
@@ -1161,7 +712,7 @@ OptionEditor::midi_port_chosen (GdkEventButton* ev, MIDI::Port* port, Gtk::Radio
 			rb->set_active (true);
 		}
 	}
-	return stop_signal (*rb, "button_press_event");
+	return false;
 }
 
 gint
@@ -1207,47 +758,6 @@ OptionEditor::port_trace_out_toggled (GdkEventButton* ev,MIDI::Port* port, Toggl
 	return stop_signal (*tb, "button_press_event");
 }
 
-gint
-OptionEditor::send_mtc_toggled (GdkEventButton *ev, CheckButton *button)
-{
-	if (session) {
-		session->set_send_mtc (!button->get_active());
-	}
-	return stop_signal (*button, "button_press_event");
-}
-
-void
-OptionEditor::send_mmc_toggled (CheckButton *button)
-{
-	if (session) {
-		session->set_send_mmc (button->get_active());
-	}
-}
-
-void
-OptionEditor::mmc_control_toggled (CheckButton *button)
-{
-	if (session) {
-		session->set_mmc_control (button->get_active());
-	}
-}
-
-void
-OptionEditor::midi_control_toggled (CheckButton *button)
-{
-	if (session) {
-		session->set_midi_control (button->get_active());
-	}
-}
-
-void
-OptionEditor::midi_feedback_toggled (CheckButton *button)
-{
-	if (session) {
-		session->set_midi_feedback (button->get_active());
-	}
-}
-
 void
 OptionEditor::save ()
 {
@@ -1260,23 +770,11 @@ gint
 OptionEditor::wm_close (GdkEventAny *ev)
 {
 	save ();
-	just_close_win();
+	hide ();
 	return TRUE;
 }
 
 void
-OptionEditor::jack_time_master_clicked ()
-{
-	bool yn = jack_time_master_button.get_active();
-
-	Config->set_jack_time_master (yn);
-
-	if (session) {
-		session->engine().reset_timebase ();
-	}
-}
-
-void
 OptionEditor::raid_path_changed ()
 {
 	if (session) {
@@ -1377,96 +875,6 @@ OptionEditor::click_emphasis_sound_changed ()
 }
 
 void
-OptionEditor::show_waveforms_clicked ()
-{
-	editor.set_show_waveforms (show_waveforms_button.get_active());
-}
-
-void
-OptionEditor::show_waveforms_recording_clicked ()
-{
-	editor.set_show_waveforms_recording (show_waveforms_recording_button.get_active());
-}
-
-void
-OptionEditor::show_measures_clicked ()
-{
-	editor.set_show_measures (show_measures_button.get_active());
-}
-
-void
-OptionEditor::follow_playhead_clicked ()
-{
-	editor.set_follow_playhead (follow_playhead_button.get_active());
-}
-
-void
-OptionEditor::strip_width_clicked ()
-{
-	mixer.set_strip_width (mixer_strip_width_button.get_active() ? Narrow : Wide);
-}
-
-
-void
-OptionEditor::just_close_win()
-{
-	hide();
-}
-
-void
-OptionEditor::queue_session_control_changed (Session::ControlType t)
-{
-	ui.call_slot (bind (mem_fun(*this, &OptionEditor::session_control_changed), t));
-}
-
-void
-OptionEditor::session_control_changed (Session::ControlType t)
-{
-	switch (t) {
-	case Session::SlaveType:
-		switch (session->slave_source()) {
-		case Session::None:
-			slave_type_combo.set_active_text (positional_sync_strings[Session::None]);
-			break;
-		case Session::MTC:
-			slave_type_combo.set_active_text (positional_sync_strings[Session::MTC]);
-			break;
-		case Session::JACK:
-			slave_type_combo.set_active_text (positional_sync_strings[Session::JACK]);
-			break;
-		default:
-			slave_type_combo.set_active_text (_("--unknown--"));
-			break;
-		}
-		
-		break;
-
-	case Session::SendMTC:
-		map_some_session_state (send_mtc_button, &Session::get_send_mtc);
-		break;
-
-	case Session::SendMMC:
-		map_some_session_state (send_mmc_button, &Session::get_send_mmc);
-		break;
-
-	case Session::MMCControl:       
-		map_some_session_state (mmc_control_button, &Session::get_mmc_control);
-		break;
-
-	case Session::MidiFeedback:       
-		map_some_session_state (midi_feedback_button, &Session::get_midi_feedback);
-		break;
-
-	case Session::MidiControl:       
-		 map_some_session_state (midi_control_button, &Session::get_midi_control);
-		break;
-	
-	default:
-		break;
-	}
-}
-
-void
 OptionEditor::native_format_chosen ()
 {
 	string which;
@@ -1484,26 +892,6 @@ OptionEditor::native_format_chosen ()
 }
 
 void
-OptionEditor::slave_type_chosen ()
-{
-	string which;
-
-	if (session == 0) {
-		return;
-	}
-
-	which = slave_type_combo.get_active_text();
-
-	if (which == positional_sync_strings[Session::None]) {
-		session->request_slave_source (Session::None);
-	} else if (which == positional_sync_strings[Session::MTC]) {
-		session->request_slave_source (Session::MTC);
-	} else if (which == positional_sync_strings[Session::JACK]) {
-		session->request_slave_source (Session::JACK);
-	} 
-}
-
-void
 OptionEditor::clear_click_editor ()
 {
 	if (click_io_selector) {
@@ -1619,183 +1007,6 @@ OptionEditor::focus_out_event_handler (GdkEventFocus* ev, void (OptionEditor::*p
 	return false;
 }
 
-void
-OptionEditor::setup_misc_options()
-{
-	Gtk::Table* table = manage (new Table (4, 2));	
-	table->set_homogeneous (true);
-
-	misc_packer.set_border_width (8);
-	misc_packer.set_spacing (3);
-	misc_packer.pack_start (*table, true, true);
-
-	table->attach (hw_monitor_button, 0, 1, 0, 1, Gtk::FILL, FILL, 8, 0);
-	table->attach (sw_monitor_button, 0, 1, 1, 2, Gtk::FILL, FILL, 8, 0);
-	table->attach (plugins_stop_button, 0, 1, 2, 3, Gtk::FILL, FILL, 8, 0);
-	table->attach (plugins_on_rec_button, 0, 1, 3, 4, Gtk::FILL, FILL, 8, 0);
-	table->attach (verify_remove_last_capture_button, 0, 1, 4, 5, Gtk::FILL, FILL, 8, 0);
-
-	table->attach (stop_rec_on_xrun_button, 1, 2, 0, 1, Gtk::FILL, FILL, 8, 0);
-	table->attach (stop_at_end_button, 1, 2, 1, 2, Gtk::FILL, FILL, 8, 0);
-	table->attach (debug_keyboard_button, 1, 2, 2, 3, Gtk::FILL, FILL, 8, 0);
-	table->attach (speed_quieten_button, 1, 2, 3, 4, Gtk::FILL, FILL, 8, 0);
-
-	Gtk::VBox* connect_box = manage (new VBox);
-	connect_box->set_spacing (3);
-	connect_box->set_border_width (8);
-
-	auto_connect_output_button_group = auto_connect_output_master_button.get_group();
-	auto_connect_output_manual_button.set_group (auto_connect_output_button_group);
-	auto_connect_output_physical_button.set_group (auto_connect_output_button_group);
-
-	Gtk::HBox* useless_box = manage (new HBox);
-	useless_box->pack_start (auto_connect_inputs_button, false, false);
-	connect_box->pack_start (*useless_box, false, false);
-	connect_box->pack_start (auto_connect_output_master_button, false, false);
-	connect_box->pack_start (auto_connect_output_physical_button, false, false);
-	connect_box->pack_start (auto_connect_output_manual_button, false, false);
-
-	misc_packer.pack_start (*connect_box, false, false);
-	
-	hw_monitor_button.set_name ("OptionEditorToggleButton");
-	sw_monitor_button.set_name ("OptionEditorToggleButton");
-	plugins_stop_button.set_name ("OptionEditorToggleButton");
-	plugins_on_rec_button.set_name ("OptionEditorToggleButton");
-	verify_remove_last_capture_button.set_name ("OptionEditorToggleButton");
-	auto_connect_inputs_button.set_name ("OptionEditorToggleButton");
-	auto_connect_output_physical_button.set_name ("OptionEditorToggleButton");
-	auto_connect_output_master_button.set_name ("OptionEditorToggleButton");
-	auto_connect_output_manual_button.set_name ("OptionEditorToggleButton");
-	stop_rec_on_xrun_button.set_name ("OptionEditorToggleButton");
-	stop_at_end_button.set_name ("OptionEditorToggleButton");
-	debug_keyboard_button.set_name ("OptionEditorToggleButton");
-	speed_quieten_button.set_name ("OptionEditorToggleButton");
-
-	hw_monitor_button.set_active (Config->get_use_hardware_monitoring());
-	sw_monitor_button.set_active (!Config->get_no_sw_monitoring());
-	plugins_stop_button.set_active (Config->get_plugins_stop_with_transport());
-	stop_rec_on_xrun_button.set_active (Config->get_stop_recording_on_xrun());
-	stop_at_end_button.set_active (Config->get_stop_at_session_end());
-	debug_keyboard_button.set_active (false);
-	speed_quieten_button.set_active (Config->get_quieten_at_speed() != 1.0f);
-
-	hw_monitor_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::hw_monitor_clicked));
-	sw_monitor_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::sw_monitor_clicked));
-	plugins_stop_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::plugins_stop_with_transport_clicked));
-	plugins_on_rec_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::plugins_on_while_recording_clicked));
-	verify_remove_last_capture_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::verify_remove_last_capture_clicked));
-	auto_connect_inputs_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::auto_connect_inputs_clicked));
-	auto_connect_output_physical_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::auto_connect_output_physical_clicked));
-	auto_connect_output_master_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::auto_connect_output_master_clicked));
-	auto_connect_output_manual_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::auto_connect_output_manual_clicked));
-	stop_rec_on_xrun_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::stop_rec_on_xrun_clicked));
-	stop_at_end_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::stop_at_end_clicked));
-	debug_keyboard_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::debug_keyboard_clicked));
-	speed_quieten_button.signal_clicked().connect (mem_fun(*this, &OptionEditor::speed_quieten_clicked));
-}
-
-void
-OptionEditor::speed_quieten_clicked ()
-{
-	if (speed_quieten_button.get_active()) {
-		Config->set_quieten_at_speed (0.251189); // -12dB reduction for ffwd or rewind
-	} else {
-		Config->set_quieten_at_speed (1.0); /* no change */
-	}
-}
-
-void
-OptionEditor::debug_keyboard_clicked ()
-{
-	extern bool debug_keyboard;
-	debug_keyboard = debug_keyboard_button.get_active ();
-}
-
-void
-OptionEditor::auto_connect_inputs_clicked ()
-{
-	if (session) {
-		session->set_input_auto_connect (auto_connect_inputs_button.get_active());
-	}
-}
-
-void
-OptionEditor::auto_connect_output_master_clicked ()
-{
-	if (session) {
-		if (auto_connect_output_master_button.get_active()) {
-			session->set_output_auto_connect (Session::AutoConnectMaster);
-		} 
-	}
-}
-
-void
-OptionEditor::auto_connect_output_physical_clicked ()
-{
-	if (session) {
-		if (auto_connect_output_physical_button.get_active()) {
-			session->set_output_auto_connect (Session::AutoConnectPhysical);
-		} 
-	}
-}
-
-void
-OptionEditor::auto_connect_output_manual_clicked ()
-{
-	if (session) {
-		if (auto_connect_output_manual_button.get_active()) {
-			session->set_output_auto_connect (Session::AutoConnectOption (0));
-		} 
-	}
-}
-
-void
-OptionEditor::hw_monitor_clicked ()
-{
-	Config->set_use_hardware_monitoring (hw_monitor_button.get_active());
-	if (session) {
-		session->reset_input_monitor_state ();
-	}
-}
-
-void
-OptionEditor::sw_monitor_clicked ()
-{
-	Config->set_no_sw_monitoring (!sw_monitor_button.get_active());
-}
-
-void
-OptionEditor::plugins_stop_with_transport_clicked ()
-{
-	Config->set_plugins_stop_with_transport (plugins_stop_button.get_active());
-}
-
-void
-OptionEditor::plugins_on_while_recording_clicked ()
-{
-	if (session) {
-		session->set_recording_plugins (plugins_on_rec_button.get_active());
-	}
-}
-
-void
-OptionEditor::verify_remove_last_capture_clicked ()
-{
-	Config->set_verify_remove_last_capture(verify_remove_last_capture_button.get_active());
-}
-
-void
-OptionEditor::stop_rec_on_xrun_clicked ()
-{
-	Config->set_stop_recording_on_xrun (stop_rec_on_xrun_button.get_active());
-}
-
-void
-OptionEditor::stop_at_end_clicked ()
-{
-	Config->set_stop_at_session_end (stop_at_end_button.get_active());
-}
-						  
 static const struct {
     const char *name;
     guint   modifier;
@@ -1988,11 +1199,3 @@ OptionEditor::fixup_combo_size (Gtk::ComboBoxText& combo, vector<string>& string
 	set_size_request_to_display_given_text (combo, maxstring.c_str(), 10 + FUDGE, 10);
 }
 
-void
-OptionEditor::map_some_session_state (CheckButton& button, bool (Session::*get)() const)
-{
-	if (session) {
-		button.set_active ((session->*get)());
-	}
-}
-
diff --git a/gtk2_ardour/option_editor.h b/gtk2_ardour/option_editor.h
index d1513f4661..cf70e65a36 100644
--- a/gtk2_ardour/option_editor.h
+++ b/gtk2_ardour/option_editor.h
@@ -65,28 +65,22 @@ class OptionEditor : public Gtk::Dialog
 
 	/* Generic */
 
-	void session_control_changed (ARDOUR::Session::ControlType);
-	void queue_session_control_changed (ARDOUR::Session::ControlType);
-	void map_some_session_state (Gtk::CheckButton& button, bool (ARDOUR::Session::*get)() const);
 	gint wm_close (GdkEventAny *);
-	void just_close_win();
 	bool focus_out_event_handler (GdkEventFocus*, void (OptionEditor::*pmf)());
 
 	/* paths */
 
 	Gtk::Table		path_table;
-
 	Gtk::Entry              session_raid_entry;
-
 	Gtk::ComboBoxText       native_format_combo;
 
-	struct SoundFilePathColumns : public Gtk::TreeModel::ColumnRecord
-	{
-	  public:
-	    Gtk::TreeModelColumn<std::string> paths;
-
-		SoundFilePathColumns() { add (paths); }
+	struct SoundFilePathColumns : public Gtk::TreeModel::ColumnRecord {
+	    public:
+                 SoundFilePathColumns() { add (paths); }
+                 Gtk::TreeModelColumn<std::string> paths;
+	         	    
 	};
+
 	SoundFilePathColumns sfdb_path_columns;
 	Glib::RefPtr<Gtk::ListStore> sfdb_paths;
 	Gtk::TreeView sfdb_path_view;
@@ -99,8 +93,6 @@ class OptionEditor : public Gtk::Dialog
 
 	/* fades */
 
-	// Gtk::Table		fade_table;
-
 	Gtk::VBox        fade_packer;
 	Gtk::CheckButton auto_xfade_button;
 	Gtk::CheckButton xfade_active_button;
@@ -118,57 +110,17 @@ class OptionEditor : public Gtk::Dialog
 	void setup_fade_options();
 	void short_xfade_adjustment_changed ();
 
-	/* solo */
-
-	Gtk::VBox        solo_packer;
-	Gtk::CheckButton solo_latched_button;
-	Gtk::CheckButton solo_via_bus_button;
-
-	void solo_latched_clicked();
-	void solo_via_bus_clicked ();
-	
-	void setup_solo_options();
-
-	/* display */
-
-	Gtk::VBox        display_packer;
-	Gtk::CheckButton show_waveforms_button;
-	Gtk::CheckButton show_waveforms_recording_button;
-	Gtk::CheckButton mixer_strip_width_button;
-	Gtk::CheckButton show_measures_button;
-	Gtk::CheckButton follow_playhead_button;
-	Gtk::ComboBoxText meter_hold_combo;
-	Gtk::ComboBoxText meter_falloff_combo;
-
-	void setup_display_options();
-	void show_waveforms_clicked ();
-	void show_waveforms_recording_clicked ();
-	void show_measures_clicked ();
-	void strip_width_clicked ();
-	void follow_playhead_clicked ();
-	void meter_hold_chosen ();
-	void meter_falloff_chosen ();
-	
-	void display_control_changed (Editing::DisplayControl);
-
 	/* Sync */
 
 	Gtk::VBox sync_packer;
 
-	Gtk::CheckButton send_mtc_button;
-	Gtk::CheckButton send_mmc_button;
-	Gtk::CheckButton jack_time_master_button;
 	Gtk::ComboBoxText slave_type_combo;
 	Gtk::ComboBoxText smpte_fps_combo;
 	AudioClock smpte_offset_clock;
 	Gtk::CheckButton smpte_offset_negative_button;
 
 	void setup_sync_options ();
-	gint send_mtc_toggled (GdkEventButton*, Gtk::CheckButton*);
 
-	void slave_type_chosen ();
-	void jack_time_master_clicked ();
-	void jack_transport_master_clicked ();
 	void smpte_fps_chosen ();
 	void smpte_offset_chosen ();
 	void smpte_offset_negative_clicked ();
@@ -176,26 +128,18 @@ class OptionEditor : public Gtk::Dialog
 	/* MIDI */
 
 	Gtk::VBox  midi_packer;
-	Gtk::CheckButton midi_feedback_button;
-	Gtk::CheckButton midi_control_button;
-	Gtk::CheckButton mmc_control_button;
 
 	Gtk::RadioButton::Group mtc_button_group;
 	Gtk::RadioButton::Group mmc_button_group;
 	Gtk::RadioButton::Group midi_button_group;
 
-	void send_mmc_toggled (Gtk::CheckButton*);
-	void mmc_control_toggled (Gtk::CheckButton*);
-	void midi_control_toggled (Gtk::CheckButton*);
-	void midi_feedback_toggled (Gtk::CheckButton*);
-
 	gint port_online_toggled (GdkEventButton*,MIDI::Port*,Gtk::ToggleButton*);
 	gint port_trace_in_toggled (GdkEventButton*,MIDI::Port*,Gtk::ToggleButton*);
 	gint port_trace_out_toggled (GdkEventButton*,MIDI::Port*,Gtk::ToggleButton*);
 	
-	gint mmc_port_chosen (GdkEventButton*,MIDI::Port*,Gtk::RadioButton*);
-	gint mtc_port_chosen (GdkEventButton*,MIDI::Port*,Gtk::RadioButton*);
-	gint midi_port_chosen (GdkEventButton*,MIDI::Port*,Gtk::RadioButton*);
+	bool mmc_port_chosen (GdkEventButton*,MIDI::Port*,Gtk::RadioButton*);
+	bool mtc_port_chosen (GdkEventButton*,MIDI::Port*,Gtk::RadioButton*);
+	bool midi_port_chosen (GdkEventButton*,MIDI::Port*,Gtk::RadioButton*);
 
 	void map_port_online (MIDI::Port*, Gtk::ToggleButton*);
 
@@ -264,42 +208,6 @@ class OptionEditor : public Gtk::Dialog
 	void edit_button_changed ();
 	void delete_button_changed ();
 
-	/* Miscellany */
-
-	Gtk::VBox misc_packer;
-
-	Gtk::CheckButton auto_connect_inputs_button;
-
-	Gtk::RadioButton auto_connect_output_physical_button;
-	Gtk::RadioButton auto_connect_output_master_button;
-	Gtk::RadioButton auto_connect_output_manual_button;
-	Gtk::RadioButton::Group auto_connect_output_button_group;
-
-	Gtk::CheckButton hw_monitor_button;
-	Gtk::CheckButton sw_monitor_button;
-	Gtk::CheckButton plugins_stop_button;
-	Gtk::CheckButton plugins_on_rec_button;
-	Gtk::CheckButton verify_remove_last_capture_button;
-	Gtk::CheckButton stop_rec_on_xrun_button;
-	Gtk::CheckButton stop_at_end_button;
-	Gtk::CheckButton debug_keyboard_button;
-	Gtk::CheckButton speed_quieten_button;
-
-	void setup_misc_options ();
-	void plugins_stop_with_transport_clicked ();
-	void verify_remove_last_capture_clicked ();
-	void plugins_on_while_recording_clicked ();
-	void auto_connect_inputs_clicked ();
-	void auto_connect_output_physical_clicked ();
-	void auto_connect_output_master_clicked ();
-	void auto_connect_output_manual_clicked ();
-	void hw_monitor_clicked ();
-	void sw_monitor_clicked ();
-	void stop_rec_on_xrun_clicked ();
-	void stop_at_end_clicked ();
-	void debug_keyboard_clicked ();
-	void speed_quieten_clicked ();
-
 	void fixup_combo_size (Gtk::ComboBoxText&, std::vector<std::string>& strings);
 };
 
diff --git a/gtk2_ardour/route_ui.cc b/gtk2_ardour/route_ui.cc
index 1780204321..82b6cac3bd 100644
--- a/gtk2_ardour/route_ui.cc
+++ b/gtk2_ardour/route_ui.cc
@@ -54,6 +54,7 @@ RouteUI::RouteUI (ARDOUR::Route& rt, ARDOUR::Session& sess, const char* m_name,
 	xml_node = 0;
 	mute_menu = 0;
 	solo_menu = 0;
+	remote_control_menu = 0;
 	ignore_toggle = false;
 	wait_for_release = false;
 	route_active_menu_item = 0;
@@ -409,6 +410,58 @@ RouteUI::update_rec_display ()
 }
 
 void
+RouteUI::build_remote_control_menu ()
+{
+	remote_control_menu = manage (new Menu);
+	refresh_remote_control_menu ();
+}
+
+void
+RouteUI::refresh_remote_control_menu ()
+{
+	using namespace Menu_Helpers;
+
+	RadioMenuItem::Group rc_group;
+	CheckMenuItem* rc_active;
+	uint32_t limit = _session.ntracks();
+	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 */
+	
+	for (uint32_t i = 0; 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);
+	}
+}
+
+void
 RouteUI::build_solo_menu (void)
 {
 	using namespace Menu_Helpers;
@@ -840,3 +893,4 @@ RouteUI::map_frozen ()
 		}
 	}
 }
+
diff --git a/gtk2_ardour/route_ui.h b/gtk2_ardour/route_ui.h
index c49583ab45..990bcd99ed 100644
--- a/gtk2_ardour/route_ui.h
+++ b/gtk2_ardour/route_ui.h
@@ -74,6 +74,7 @@ class RouteUI : public virtual AxisView
 	
 	Gtk::Menu* mute_menu;
 	Gtk::Menu* solo_menu;
+	Gtk::Menu* remote_control_menu;
 
 	XMLNode *xml_node;
 	void ensure_xml_node ();
@@ -92,6 +93,8 @@ class RouteUI : public virtual AxisView
 	void session_rec_enable_changed();
 
 	void build_solo_menu (void);
+	void build_remote_control_menu (void);
+	void refresh_remote_control_menu ();
 
 	void solo_safe_toggle (void*, Gtk::CheckMenuItem*);
 	void toggle_solo_safe (Gtk::CheckMenuItem*);
@@ -123,8 +126,6 @@ class RouteUI : public virtual AxisView
 	virtual void name_changed (void *src);
 	void route_removed ();
 
-	static gint okay_gplusplus_cannot_do_complex_templates (RouteUI *rui);
-
 	Gtk::CheckMenuItem *route_active_menu_item;
 	void toggle_route_active ();
 	virtual void route_active_changed ();
@@ -137,6 +138,8 @@ class RouteUI : public virtual AxisView
 	void update_solo_display ();
 	virtual void map_frozen ();
 
+	void set_remote_control_id (uint32_t id, Gtk::CheckMenuItem* item);
+
 	void reversibly_apply_route_boolean (string name, void (ARDOUR::Route::*func)(bool, void*), bool, void *);
 	void reversibly_apply_audio_track_boolean (string name, void (ARDOUR::AudioTrack::*func)(bool, void*), bool, void *);
 };
diff --git a/gtk2_ardour/streamview.cc b/gtk2_ardour/streamview.cc
index 4213bc8431..a8b7499644 100644
--- a/gtk2_ardour/streamview.cc
+++ b/gtk2_ardour/streamview.cc
@@ -470,7 +470,7 @@ StreamView::redisplay_diskstream ()
 		if (!(*i)->is_valid()) {
 			delete *i;
 			region_views.erase (i);
-		}
+		} 
 
 		i = tmp;
 	}
diff --git a/libs/ardour/ardour/configuration.h b/libs/ardour/ardour/configuration.h
index 140490d46d..fd44d27329 100644
--- a/libs/ardour/ardour/configuration.h
+++ b/libs/ardour/ardour/configuration.h
@@ -124,6 +124,9 @@ class Configuration : public Stateful
 	bool get_use_hardware_monitoring();
 	void set_use_hardware_monitoring(bool);
 
+	bool get_use_sw_monitoring();
+	void set_use_sw_monitoring(bool);
+
 	bool get_jack_time_master();
 	void set_jack_time_master(bool);
 
@@ -133,9 +136,6 @@ class Configuration : public Stateful
 	bool get_plugins_stop_with_transport();
 	void set_plugins_stop_with_transport(bool);
 
-	bool get_no_sw_monitoring();
-	void set_no_sw_monitoring(bool);
-
 	bool get_stop_recording_on_xrun();
 	void set_stop_recording_on_xrun(bool);
 
@@ -220,12 +220,12 @@ class Configuration : public Stateful
 	bool          trace_midi_output_is_user;
 	bool          plugins_stop_with_transport;
 	bool          plugins_stop_with_transport_is_user;
-	bool          no_sw_monitoring;
-	bool          no_sw_monitoring_is_user;
+	bool          use_sw_monitoring;
+	bool          use_sw_monitoring_is_user;
 	bool          stop_recording_on_xrun;
 	bool          stop_recording_on_xrun_is_user;
-	bool		  verify_remove_last_capture;
-	bool		  verify_remove_last_capture_is_user;
+	bool	      verify_remove_last_capture;
+	bool	      verify_remove_last_capture_is_user;
 	bool          stop_at_session_end;
 	bool          stop_at_session_end_is_user;
 	bool          seamless_looping;
diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 9c0edcdad4..ed4b695bff 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -245,6 +245,10 @@ class Route : public IO
 
 	void protect_automation ();
 	
+	void set_remote_control_id (uint32_t id);
+	uint32_t remote_control_id () const;
+	sigc::signal<void> RemoteControlIDChanged;
+
   protected:
 	friend class Session;
 
@@ -317,6 +321,7 @@ class Route : public IO
 
 	state_id_t _current_state_id;
 	uint32_t redirect_max_outs;
+	uint32_t _remote_control_id;
 
 	uint32_t pans_required() const;
 	uint32_t n_process_buffers ();
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 88f629e516..0b13cf5f30 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -391,7 +391,8 @@ class Session : public sigc::trackable, public Stateful
 		PunchOut,
 		SendMTC,
 		MMCControl,
-		Live,
+		SoloLatch,
+		SoloingModel,
 		RecordingPlugins,
 		CrossFadesActive,
 		SendMMC,
@@ -399,7 +400,8 @@ class Session : public sigc::trackable, public Stateful
 		Clicking,
 		EditingMode,
 		PlayRange,
-		AlignChoice,
+		LayeringModel,
+		CrossfadingModel,
 		SeamlessLoop,
 		MidiFeedback,
 		MidiControl
@@ -440,7 +442,7 @@ class Session : public sigc::trackable, public Stateful
 	bool get_recording_plugins () const { return recording_plugins; }
 	bool get_crossfades_active () const { return crossfades_active; }
 
-	AutoConnectOption get_input_auto_connect () const { return input_auto_connect; }
+	bool get_input_auto_connect () const;
 	AutoConnectOption get_output_auto_connect () const { return output_auto_connect; }
 
 	enum LayerModel {
@@ -452,14 +454,9 @@ class Session : public sigc::trackable, public Stateful
 	void set_layer_model (LayerModel);
 	LayerModel get_layer_model () const { return layer_model; }
 
-	sigc::signal<void> LayerModelChanged;
-
 	void set_xfade_model (CrossfadeModel);
 	CrossfadeModel get_xfade_model () const { return xfade_model; }
 
-	void set_align_style (AlignStyle);
-	AlignStyle get_align_style () const { return align_style; }
-
 	void add_event (jack_nframes_t action_frame, Event::Type type, jack_nframes_t target_frame = 0);
 	void remove_event (jack_nframes_t frame, Event::Type type);
 	void clear_events (Event::Type type);
@@ -1719,8 +1716,6 @@ class Session : public sigc::trackable, public Stateful
 	AutoConnectOption input_auto_connect;
 	AutoConnectOption output_auto_connect;
 
-	AlignStyle align_style;
-
 	gain_t* _gain_automation_buffer;
 	pan_t** _pan_automation_buffer;
 	void allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force);
diff --git a/libs/ardour/ardour/state_manager.h b/libs/ardour/ardour/state_manager.h
index faedc120ee..105ca38dcc 100644
--- a/libs/ardour/ardour/state_manager.h
+++ b/libs/ardour/ardour/state_manager.h
@@ -3,6 +3,7 @@
 
 #include <list>
 #include <string>
+#include <vector>
 
 #include <sigc++/signal.h>
 
@@ -35,7 +36,14 @@ class StateManager : public sigc::trackable
 
 	state_id_t _current_state_id;
 
+	static void set_allow_save (bool);
+	static bool allow_save ();
+
   protected:
+	static bool _allow_save;
+	typedef std::pair<StateManager*,std::string> DeferredSave;
+	static std::vector<DeferredSave> deferred;
+
 	StateMap   states;
 
 	virtual Change   restore_state (State&) = 0;
diff --git a/libs/ardour/audio_playlist.cc b/libs/ardour/audio_playlist.cc
index 73e0a91164..9c68c61114 100644
--- a/libs/ardour/audio_playlist.cc
+++ b/libs/ardour/audio_playlist.cc
@@ -576,7 +576,6 @@ AudioPlaylist::state_factory (std::string why) const
 	for (Crossfades::const_iterator i = _crossfades.begin(); i != _crossfades.end(); ++i) {
 		state->crossfade_states.push_back ((*i)->get_memento());
 	}
-
 	return state;
 }
 
@@ -592,13 +591,13 @@ AudioPlaylist::restore_state (StateManager::State& state)
 		regions = apstate->regions;
 
 		for (list<UndoAction>::iterator s = apstate->region_states.begin(); s != apstate->region_states.end(); ++s) {
-		  *s;
+			(*s) ();
 		}
 
 		_crossfades = apstate->crossfades;
 		
 		for (list<UndoAction>::iterator s = apstate->crossfade_states.begin(); s != apstate->crossfade_states.end(); ++s) {
-		  *s;
+			(*s) ();
 		}
 
 		in_set_state = false;
@@ -611,7 +610,7 @@ AudioPlaylist::restore_state (StateManager::State& state)
 UndoAction
 AudioPlaylist::get_memento () const
 {
-  return sigc::bind (mem_fun (*(const_cast<AudioPlaylist*> (this)), &StateManager::use_state), _current_state_id);
+	return sigc::bind (mem_fun (*(const_cast<AudioPlaylist*> (this)), &StateManager::use_state), _current_state_id);
 }
 
 void
diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc
index 1d3f32ae6b..4a922d631d 100644
--- a/libs/ardour/audio_track.cc
+++ b/libs/ardour/audio_track.cc
@@ -322,6 +322,24 @@ AudioTrack::set_state (const XMLNode& node)
 		}
 	}
 
+
+	XMLNodeList nlist;
+	XMLNodeConstIterator niter;
+	XMLNode *child;
+
+	nlist = node.children();
+	for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+		child = *niter;
+
+		if (child->name() == X_("remote_control")) {
+			if ((prop = child->property (X_("id"))) != 0) {
+				int32_t x;
+				sscanf (prop->value().c_str(), "%d", &x);
+				set_remote_control_id (x);
+			}
+		}
+	}
+
 	pending_state = const_cast<XMLNode*> (&node);
 
 	_session.StateReady.connect (mem_fun (*this, &AudioTrack::set_state_part_two));
@@ -393,7 +411,11 @@ AudioTrack::get_state()
 		set_midi_node_info (child, ev, chn, additional);
 	}
 
-	
+	XMLNode* remote_control_node = new XMLNode (X_("remote_control"));
+	snprintf (buf, sizeof (buf), "%d", _remote_control_id);
+	remote_control_node->add_property (X_("id"), buf);
+	root.add_child_nocopy (*remote_control_node);
+
 	return root;
 }
 
@@ -519,17 +541,17 @@ AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nf
 	} else {
 
 		if (_session.get_auto_input()) {
-			if (Config->get_no_sw_monitoring()) {
-				send_silence = true;
-			} else {
+			if (Config->get_use_sw_monitoring()) {
 				send_silence = false;
+			} else {
+				send_silence = true;
 			}
 		} else {
 			if (diskstream->record_enabled()) {
-				if (Config->get_no_sw_monitoring()) {
-					send_silence = true;
-				} else {
+				if (Config->get_use_sw_monitoring()) {
 					send_silence = false;
+				} else {
+					send_silence = true;
 				}
 			} else {
 				send_silence = true;
diff --git a/libs/ardour/audioregion.cc b/libs/ardour/audioregion.cc
index 8d4a5f0177..bc14968fa7 100644
--- a/libs/ardour/audioregion.cc
+++ b/libs/ardour/audioregion.cc
@@ -376,7 +376,7 @@ AudioRegion::restore_state (StateManager::State& sstate)
 UndoAction
 AudioRegion::get_memento() const
 {
-  return sigc::bind (mem_fun (*(const_cast<AudioRegion *> (this)), &StateManager::use_state), _current_state_id);
+	return sigc::bind (mem_fun (*(const_cast<AudioRegion *> (this)), &StateManager::use_state), _current_state_id);
 }
 
 bool
diff --git a/libs/ardour/configuration.cc b/libs/ardour/configuration.cc
index 0de30a3538..28f13aabb8 100644
--- a/libs/ardour/configuration.cc
+++ b/libs/ardour/configuration.cc
@@ -257,8 +257,8 @@ Configuration::state (bool user_only)
 	if (!user_only || plugins_stop_with_transport_is_user) {
 		node->add_child_nocopy(option_node("plugins-stop-with-transport", plugins_stop_with_transport?"yes":"no"));
 	}
-	if (!user_only || no_sw_monitoring_is_user) {
-		node->add_child_nocopy(option_node("no-sw-monitoring", no_sw_monitoring?"yes":"no"));
+	if (!user_only || use_sw_monitoring_is_user) {
+		node->add_child_nocopy(option_node("use-sw-monitoring", use_sw_monitoring?"yes":"no"));
 	}
 	if (!user_only || stop_recording_on_xrun_is_user) {
 		node->add_child_nocopy(option_node("stop-recording-on-xrun", stop_recording_on_xrun?"yes":"no"));
@@ -400,8 +400,10 @@ Configuration::set_state (const XMLNode& root)
 					set_trace_midi_output (option_value == "yes");
 				} else if (option_name == "plugins-stop-with-transport") {
 					set_plugins_stop_with_transport (option_value == "yes");
-				} else if (option_name == "no-sw-monitoring") {
-					set_no_sw_monitoring (option_value == "yes");
+				} else if (option_name == "use-sw-monitoring") {
+					set_use_sw_monitoring (option_value == "yes");
+				} else if (option_name == "no-sw-monitoring") {     /* DEPRECATED */
+					set_use_sw_monitoring (option_value != "yes");
 				} else if (option_name == "stop-recording-on-xrun") {
 					set_stop_recording_on_xrun (option_value == "yes");
 				} else if (option_name == "verify-remove-last-capture") {
@@ -475,7 +477,7 @@ Configuration::set_defaults ()
 	trace_midi_input = false;
 	trace_midi_output = false;
 	plugins_stop_with_transport = false;
-	no_sw_monitoring = false;
+	use_sw_monitoring = true;
 	stop_recording_on_xrun = false;
 	verify_remove_last_capture = true;
 	stop_at_session_end = true;
@@ -514,7 +516,7 @@ Configuration::set_defaults ()
 	trace_midi_input_is_user = false;
 	trace_midi_output_is_user = false;
 	plugins_stop_with_transport_is_user = false;
-	no_sw_monitoring_is_user = false;
+	use_sw_monitoring_is_user = false;
 	stop_recording_on_xrun_is_user = false;
 	verify_remove_last_capture_is_user = false;
 	stop_at_session_end_is_user = false;
@@ -948,17 +950,17 @@ Configuration::set_plugins_stop_with_transport (bool yn)
 }
 
 bool
-Configuration::get_no_sw_monitoring ()
+Configuration::get_use_sw_monitoring ()
 {
-	return no_sw_monitoring;
+	return use_sw_monitoring;
 }
 
 void
-Configuration::set_no_sw_monitoring (bool yn)
+Configuration::set_use_sw_monitoring (bool yn)
 {
-	no_sw_monitoring = yn;
+	use_sw_monitoring = yn;
 	if (user_configuration) {
-		no_sw_monitoring_is_user = true;
+		use_sw_monitoring_is_user = true;
 	}
 }
 
diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index 8977135ba7..7772fcbf82 100644
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -223,8 +223,6 @@ Playlist::init (bool hide)
 	layer_op_counter = 0;
 	freeze_length = 0;
 
-	// _session.LayerModelChanged.connect (slot (*this, &Playlist::relayer));
-
 	Modified.connect (mem_fun (*this, &Playlist::mark_session_dirty));
 }
 
diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index 6e07ef90f2..5fcbd53bb6 100644
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -86,6 +86,7 @@ Route::init ()
 	_have_internal_generator = false;
 	_declickable = false;
 	_pending_declick = true;
+	_remote_control_id = 0;
 
 	_edit_group = 0;
 	_mix_group = 0;
@@ -118,6 +119,21 @@ Route::~Route ()
 	}
 }
 
+void
+Route::set_remote_control_id (uint32_t id)
+{
+	if (id != _remote_control_id) {
+		_remote_control_id = id;
+		RemoteControlIDChanged ();
+	}
+}
+
+uint32_t
+Route::remote_control_id() const
+{
+	return _remote_control_id;
+}
+
 long
 Route::order_key (string name) const
 {
@@ -213,7 +229,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	IO *co;
 	bool mute_audible;
 	bool solo_audible;
-	bool no_monitor = (Config->get_use_hardware_monitoring() || Config->get_no_sw_monitoring ());
+	bool no_monitor = (Config->get_use_hardware_monitoring() || !Config->get_use_sw_monitoring ());
 	gain_t* gab = _session.gain_automation_buffer();
 
 	declick = _pending_declick;
@@ -406,7 +422,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 
 		 // AND software monitoring required
 
-		 !Config->get_no_sw_monitoring())) { 
+		 Config->get_use_sw_monitoring())) { 
 		
 		if (apply_gain_automation) {
 			
diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index f811fbd0af..726d3070bb 100644
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -989,6 +989,12 @@ Session::set_input_auto_connect (bool yn)
 	set_dirty ();
 }
 
+bool
+Session::get_input_auto_connect () const
+{
+	return (input_auto_connect & AutoConnectPhysical);
+}
+
 void
 Session::set_output_auto_connect (AutoConnectOption aco)
 {
@@ -1715,6 +1721,8 @@ Session::new_audio_track (int input_channels, int output_channels)
 		track->diskstream_changed.connect (mem_fun (this, &Session::resort_routes));
 
 		add_route (track);
+
+		track->set_remote_control_id (ntracks());
 	}
 
 	catch (failed_constructor &err) {
@@ -2031,8 +2039,11 @@ Session::route_solo_changed (void* src, Route* route)
 void
 Session::set_solo_latched (bool yn)
 {
-	_solo_latched = yn;
-	set_dirty ();
+	if (yn != _solo_latched) {
+		_solo_latched = yn;
+		set_dirty ();
+		ControlChanged (SoloLatch);
+	}
 }
 
 void
@@ -3305,21 +3316,13 @@ Session::n_playlists () const
 }
 
 void
-Session::set_align_style (AlignStyle style)
-{
-	align_style = style;
-
-	foreach_diskstream (&DiskStream::set_capture_offset);
-
-	set_dirty ();
-	ControlChanged (AlignChoice);
-}
-
-void
 Session::set_solo_model (SoloModel sm)
 {
-	_solo_model = sm;
-	set_dirty ();
+	if (sm != _solo_model) {
+		_solo_model = sm;
+		ControlChanged (SoloingModel);
+		set_dirty ();
+	}
 }
 
 void
@@ -3555,15 +3558,20 @@ Session::nbusses () const
 void
 Session::set_layer_model (LayerModel lm)
 {
-	layer_model = lm;
-	LayerModelChanged (); /* EMIT SIGNAL */
-	set_dirty ();
+	if (lm != layer_model) {
+		layer_model = lm;
+		set_dirty ();
+		ControlChanged (LayeringModel);
+	}
 }
 
 void
 Session::set_xfade_model (CrossfadeModel xm)
 {
-	xfade_model = xm;
-	set_dirty ();
+	if (xm != xfade_model) {
+		xfade_model = xm;
+		set_dirty ();
+		ControlChanged (CrossfadingModel);
+	}
 }
 
diff --git a/libs/ardour/session_feedback.cc b/libs/ardour/session_feedback.cc
index 2e6d0cd80b..840cb6a97d 100644
--- a/libs/ardour/session_feedback.cc
+++ b/libs/ardour/session_feedback.cc
@@ -204,7 +204,7 @@ Session::feedback_thread_work ()
 			tmp = i;
 			++tmp;
 			
-			if ((*i)) {
+			if ((*i) ()) {
 				feedback_functions.erase (i);
 			}
 			
diff --git a/libs/ardour/session_midi.cc b/libs/ardour/session_midi.cc
index 18d8b3672b..56e593086a 100644
--- a/libs/ardour/session_midi.cc
+++ b/libs/ardour/session_midi.cc
@@ -803,19 +803,14 @@ Session::mmc_record_enable (MIDI::MachineControl &mmc, size_t trk, bool enabled)
 {
 	if (mmc_control) {
 
-		/* don't take route or diskstream lock: if using dynamic punch,
-		   this could cause a dropout. XXX is that really OK?
-		   or should we queue a rec-enable request?
-		*/
-
-		size_t n;
 		RouteList::iterator i;
-
-		for (n = 0, i = routes.begin(); i != routes.end(); ++i) {
+		RWLockMonitor (route_lock, false, __LINE__, __FILE__);
+		
+		for (i = routes.begin(); i != routes.end(); ++i) {
 			AudioTrack *at;
 
 			if ((at = dynamic_cast<AudioTrack*>(*i)) != 0) {
-				if (n++ == trk) {
+				if (trk == at->remote_control_id()) {
 					at->set_record_enable (enabled, &mmc);
 					break;
 				}
@@ -1468,7 +1463,7 @@ Session::midi_thread_work ()
 				tmp = i;
 				++tmp;
 				
-				if (!(*i)) {
+				if (!(*i)()) {
 					midi_timeouts.erase (i);
 				}
 				
diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc
index 53ca23a366..7a88443dbd 100644
--- a/libs/ardour/session_state.cc
+++ b/libs/ardour/session_state.cc
@@ -177,7 +177,6 @@ Session::first_stage_init (string fullpath, string snapshot_name)
 	_edit_mode = Slide;
 	pending_edit_mode = _edit_mode;
 	_play_range = false;
-	align_style = ExistingMaterial;
 	_control_out = 0;
 	_master_out = 0;
 	input_auto_connect = AutoConnectOption (0);
@@ -988,16 +987,6 @@ Session::load_options (const XMLNode& node)
 		}
 	}
 
-	if ((child = find_named_node (node, "align-style")) != 0) {
-		if ((prop = child->property ("val")) != 0) {
-			if (prop->value() == "capture") {
-				set_align_style (CaptureTime);
-			} else {
-				set_align_style (ExistingMaterial);
-			}
-		}
-	}
-
 	if ((child = find_named_node (node, "layer-model")) != 0) {
 		if ((prop = child->property ("val")) != 0) {
 			if (prop->value() == X_("LaterHigher")) {
@@ -1197,9 +1186,6 @@ Session::get_options () const
 	child = opthead->add_child ("solo-model");
 	child->add_property ("val", _solo_model == SoloBus ? "SoloBus" : "InverseMute");
 
-	child = opthead->add_child ("align-style");
-	child->add_property ("val", (align_style == ExistingMaterial ? "existing" : "capture"));
-
 	child = opthead->add_child ("layer-model");
 	switch (layer_model) {
 	case LaterHigher:
@@ -1450,6 +1436,7 @@ Session::set_state (const XMLNode& node)
 	XMLNodeList nlist;
 	XMLNode* child;
 	const XMLProperty* prop;
+	int ret = -1;
 
 	_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
 	
@@ -1458,6 +1445,8 @@ Session::set_state (const XMLNode& node)
 		return -1;
 	}
 
+	StateManager::set_allow_save (false);
+
 	if ((prop = node.property ("name")) != 0) {
 		_name = prop->value ();
 	}
@@ -1483,7 +1472,6 @@ Session::set_state (const XMLNode& node)
 	*/
 
 	if (use_config_midi_ports ()) {
-		return -1;
 	}
 
 	if ((child = find_named_node (node, "Path")) != 0) {
@@ -1500,63 +1488,61 @@ Session::set_state (const XMLNode& node)
 
 	if ((child = find_named_node (node, "Options")) == 0) {
 		error << _("Session: XML state has no options section") << endmsg;
-		return -1;
 	} else if (load_options (*child)) {
-		return -1;
 	}
 
 	if ((child = find_named_node (node, "Sources")) == 0) {
 		error << _("Session: XML state has no sources section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_sources (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "Regions")) == 0) {
 		error << _("Session: XML state has no Regions section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_regions (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "Playlists")) == 0) {
 		error << _("Session: XML state has no playlists section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_playlists (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "UnusedPlaylists")) == 0) {
 		// this is OK
 	} else if (load_unused_playlists (*child)) {
-		return -1;
+		goto out;
 	}
 	
 	if ((child = find_named_node (node, "NamedSelections")) != 0) {
 		if (load_named_selections (*child)) {
-			return -1;
+			goto out;
 		}
 	}
 
 	if ((child = find_named_node (node, "DiskStreams")) == 0) {
 		error << _("Session: XML state has no diskstreams section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_diskstreams (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "Connections")) == 0) {
 		error << _("Session: XML state has no connections section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_connections (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "Locations")) == 0) {
 		error << _("Session: XML state has no locations section") << endmsg;
-		return -1;
+		goto out;
 	} else if (_locations.set_state (*child)) {
-		return -1;
+		goto out;
 	}
 
 	Location* location;
@@ -1579,30 +1565,30 @@ Session::set_state (const XMLNode& node)
 
 	if ((child = find_named_node (node, "EditGroups")) == 0) {
 		error << _("Session: XML state has no edit groups section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_edit_groups (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "MixGroups")) == 0) {
 		error << _("Session: XML state has no mix groups section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_mix_groups (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "TempoMap")) == 0) {
 		error << _("Session: XML state has no Tempo Map section") << endmsg;
-		return -1;
+		goto out;
 	} else if (_tempo_map->set_state (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "Routes")) == 0) {
 		error << _("Session: XML state has no routes section") << endmsg;
-		return -1;
+		goto out;
 	} else if (load_routes (*child)) {
-		return -1;
+		goto out;
 	}
 
 	if ((child = find_named_node (node, "Click")) == 0) {
@@ -1621,13 +1607,20 @@ Session::set_state (const XMLNode& node)
 
 	_state_of_the_state = Clean;
 
+	StateManager::set_allow_save (true);
+
 	if (state_was_pending) {
 		save_state (_current_snapshot_name);
 		remove_pending_capture_state ();
 		state_was_pending = false;
 	}
 
-	return 0;
+	ret = 0;
+
+  out:
+	/* yes, doing it twice doesn't hurt and makes the code easier */
+	StateManager::set_allow_save (true);
+	return ret;
 }
 
 int
diff --git a/libs/ardour/state_manager.cc b/libs/ardour/state_manager.cc
index de9a72b40a..4bb44dbc95 100644
--- a/libs/ardour/state_manager.cc
+++ b/libs/ardour/state_manager.cc
@@ -4,6 +4,10 @@
 #include "i18n.h"
 
 using namespace ARDOUR;
+using namespace std;
+
+bool StateManager::_allow_save = true;
+vector<StateManager::DeferredSave> StateManager::deferred;
 
 StateManager::StateManager ()
 {
@@ -15,6 +19,19 @@ StateManager::~StateManager()
 }
 
 void
+StateManager::set_allow_save (bool yn)
+{
+	_allow_save = yn;
+
+	if (yn) {
+		for (vector<DeferredSave>::iterator x = deferred.begin(); x != deferred.end(); ++x) {
+			(*x).first->save_state ((*x).second);
+		}
+		deferred.clear ();
+	}
+}
+
+void
 StateManager::drop_all_states ()
 {
 	for (StateMap::iterator i = states.begin(); i != states.end(); ++i) {
@@ -32,13 +49,12 @@ StateManager::use_state (state_id_t id)
 	Change what_changed;
 	state_id_t n;
 	StateMap::iterator i;
-	
+
 	for (n = 0, i = states.begin(); n < id && i != states.end(); ++n, ++i);
 
 	if (n != id || i == states.end()) {
 		fatal << string_compose (_("programming error: illegal state ID (%1) passed to "
-				    "StateManager::set_state() (range = 0-%3)"), id,
-				  states.size()-1)
+				    "StateManager::set_state() (range = 0-%2)"), id, states.size()-1)
 		      << endmsg;
 		/*NOTREACHED*/
 		return;
@@ -52,6 +68,11 @@ StateManager::use_state (state_id_t id)
 void
 StateManager::save_state (std::string why)
 {
+	if (!_allow_save) {
+		deferred.push_back (DeferredSave (this, why));
+		return;
+	}
+
 	states.push_back (state_factory (why));
 	_current_state_id = states.size() - 1;
 }
diff --git a/libs/pbd3/undo.cc b/libs/pbd3/undo.cc
index 0af1cc2e7a..482cb5cf37 100644
--- a/libs/pbd3/undo.cc
+++ b/libs/pbd3/undo.cc
@@ -77,6 +77,7 @@ UndoCommand::clear ()
 void
 UndoCommand::undo ()
 {
+	cerr << "There are " << undo_actions.size() << " actions to undo\n";
 	for (list<UndoAction>::reverse_iterator i = undo_actions.rbegin(); i != undo_actions.rend(); ++i) {
 		(*i)();
 	}
@@ -99,12 +100,14 @@ UndoHistory::add (UndoCommand uc)
 void
 UndoHistory::undo (unsigned int n)
 {
+	cerr << "Undo history undoing " << n << " with a list of " << UndoList.size() << endl;
 	while (n--) {
 		if (UndoList.size() == 0) {
 			return;
 		}
 		UndoCommand uc = UndoList.back ();
 		UndoList.pop_back ();
+		cerr << "undoing command called " << uc.name() << endl;
 		uc.undo ();
 		RedoList.push_back (uc);
 	}