many important changes to configuration system and specific parameters

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

12 files changed, 905 insertions, 592 deletions

diff --git a/gtk2_ardour/actions.cc b/gtk2_ardour/actions.cc
index b2408620a5..8aa8ed0cbb 100644
--- a/gtk2_ardour/actions.cc
+++ b/gtk2_ardour/actions.cc
@@ -40,6 +40,7 @@ using namespace Gtk;
 using namespace Glib;
 using namespace sigc;
 using namespace PBD;
+using namespace ARDOUR;
 
 vector<RefPtr<Gtk::Action> > ActionManager::session_sensitive_actions;
 vector<RefPtr<Gtk::Action> > ActionManager::region_list_selection_sensitive_actions;
@@ -283,3 +284,57 @@ ActionManager::uncheck_toggleaction (const char * name)
 	delete [] group_name;
 }
 
+void
+ActionManager::toggle_config_state (const char* group, const char* action, bool (Configuration::*set)(bool), bool (Configuration::*get)(void) const)
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		
+		if (tact) {
+			bool x = (Config->*get)();
+
+			cerr << "\ttoggle config, action = " << tact->get_active() << " config = " << x << endl;
+			
+			if (x != tact->get_active()) {
+				(Config->*set) (!x);
+			}
+		}
+	}
+}
+
+void
+ActionManager::toggle_config_state (const char* group, const char* action, sigc::slot<void> theSlot)
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		if (tact->get_active()) {
+			theSlot ();
+		}
+	}
+}
+
+void
+ActionManager::map_some_state (const char* group, const char* action, bool (Configuration::*get)() const)
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact) {
+			
+			bool x = (Config->*get)();
+
+			cerr << "\tmap state, action = " << tact->get_active() << " config = " << x << endl;
+			
+			if (tact->get_active() != x) {
+				tact->set_active (x);
+			}
+		} else {
+			cerr << "not a toggle\n";
+		}
+	} else {
+		cerr << group << ':' << action << " not an action\n";
+	}
+}
diff --git a/gtk2_ardour/actions.h b/gtk2_ardour/actions.h
index 330caff1c2..e3ec57dbae 100644
--- a/gtk2_ardour/actions.h
+++ b/gtk2_ardour/actions.h
@@ -37,6 +37,10 @@ class ActionManager
 	static std::vector<Glib::RefPtr<Gtk::Action> > jack_opposite_sensitive_actions;
 	static std::vector<Glib::RefPtr<Gtk::Action> > edit_cursor_in_region_sensitive_actions;
 
+	static void map_some_state (const char* group, const char* action, bool (ARDOUR::Configuration::*get)() const);
+	static void toggle_config_state (const char* group, const char* action, bool (ARDOUR::Configuration::*set)(bool), bool (ARDOUR::Configuration::*get)(void) const);
+	static void toggle_config_state (const char* group, const char* action, sigc::slot<void> theSlot);
+
 	static void set_sensitive (std::vector<Glib::RefPtr<Gtk::Action> >& actions, bool);
 
 	static std::string unbound_string;  /* the key string returned if an action is not bound */
diff --git a/gtk2_ardour/ardour.menus b/gtk2_ardour/ardour.menus
index aa6424b8b9..d9019dad06 100644
--- a/gtk2_ardour/ardour.menus
+++ b/gtk2_ardour/ardour.menus
@@ -239,11 +239,12 @@
                </menu>
                <separator/>
                <menu action='Autoconnect'>
-                   <menuitem action='AutoConnectNewTrackInputsToHardware'/>
+                   <menuitem action='InputAutoConnectPhysical'/>
+                   <menuitem action='InputAutoConnectManual'/>
     	           <separator/>
-                   <menuitem action='AutoConnectNewTrackOutputsToHardware'/>
-                   <menuitem action='AutoConnectNewTrackOutputsToMaster'/>
-                   <menuitem action='ManuallyConnectNewTrackOutputs'/>
+                   <menuitem action='OutputAutoConnectPhysical'/>
+                   <menuitem action='OutputAutoConnectMaster'/>
+                   <menuitem action='OutputAutoConnectManual'/>
                </menu>
 	       <menu action='ControlSurfaces'/>
                <menu action='Monitoring'>
@@ -277,7 +278,6 @@
 		   <menuitem action='toggle-xfades-active'/>
 		   <menuitem action='toggle-xfades-visible'/>
 		   <menuitem action='toggle-auto-xfades'/>
-                   <menuitem action='UnmuteNewFullCrossfades'/>
 		   <separator/>
 		   <menuitem action='CrossfadesFull'/>
 		   <menuitem action='CrossfadesShort'/>
diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index a6cd045fb2..701c69c996 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -2344,72 +2344,6 @@ ARDOUR_UI::cmdline_new_session (string path)
 }
 
 void
-ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
-{
-	Glib::RefPtr<Action> act;
-	
-	switch (hf) {
-	case BWF:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
-		break;
-	case WAVE:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
-		break;
-	case WAVE64:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
-		break;
-	case iXML:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
-		break;
-	case RF64:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
-		break;
-	case CAF:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
-		break;
-	case AIFF:
-		act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
-		break;
-	}
-
-	if (act) {
-		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
-		if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
-			Config->set_native_file_header_format (hf);
-			if (session) {
-				session->reset_native_file_format ();
-			}
-		}
-	}
-}
-
-void
-ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
-{
-	Glib::RefPtr<Action> act;
-	
-	switch (sf) {
-	case FormatFloat:
-		act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
-		break;
-	case FormatInt24:
-		act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
-		break;
-	}
-
-	if (act) {
-		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
-
-		if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
-			Config->set_native_file_data_format (sf);
-			if (session) {
-				session->reset_native_file_format ();
-			}
-		}
-	}
-}
-
-void
 ARDOUR_UI::use_config ()
 {
 	Glib::RefPtr<Action> act;
diff --git a/gtk2_ardour/ardour_ui.h b/gtk2_ardour/ardour_ui.h
index 04db74b03f..cf6cda526a 100644
--- a/gtk2_ardour/ardour_ui.h
+++ b/gtk2_ardour/ardour_ui.h
@@ -655,21 +655,17 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 
 	std::vector<std::string> positional_sync_strings;
 
-	void toggle_config_state (const char* group, const char* action, bool (ARDOUR::Configuration::*set)(bool), bool (ARDOUR::Configuration::*get)(void) const);
-	void toggle_config_state (const char* group, const char* action, sigc::slot<void> theSlot);
 	void toggle_send_midi_feedback ();
 	void toggle_use_mmc ();
 	void toggle_send_mmc ();
 	void toggle_use_midi_control();
 	void toggle_send_mtc ();
 
-	void toggle_AutoConnectNewTrackInputsToHardware();
-	void toggle_AutoConnectNewTrackOutputsToHardware();
-	void toggle_AutoConnectNewTrackOutputsToMaster();
-	void toggle_ManuallyConnectNewTrackOutputs();
-	void toggle_UseHardwareMonitoring();
-	void toggle_UseSoftwareMonitoring();
-	void toggle_UseExternalMonitoring();
+	void set_input_auto_connect (ARDOUR::AutoConnectOption);
+	void set_output_auto_connect (ARDOUR::AutoConnectOption);
+	void set_solo_model (ARDOUR::SoloModel);
+	void set_monitor_model (ARDOUR::MonitorModel);
+
 	void toggle_StopPluginsWithTransport();
 	void toggle_DoNotRunPluginsWhileRecording();
 	void toggle_VerifyRemoveLastCapture();
@@ -678,14 +674,22 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void toggle_GainReduceFastTransport();
 	void toggle_LatchedSolo();
 	void toggle_SoloViaBus();
-	void toggle_AutomaticallyCreateCrossfades();
-	void toggle_UnmuteNewFullCrossfades();
 	void toggle_LatchedRecordEnable ();
 
 	void mtc_port_changed ();
-	void map_some_state (const char* group, const char* action, bool (ARDOUR::Configuration::*get)() const);
+	void map_solo_model ();
+	void map_monitor_model ();
+	void map_file_header_format ();
+	void map_file_data_format ();
+	void map_input_auto_connect ();
+	void map_output_auto_connect ();
 	void parameter_changed (const char*);
 
+	void set_meter_hold (ARDOUR::MeterHold);
+	void set_meter_falloff (ARDOUR::MeterFalloff);
+	void map_meter_hold ();
+	void map_meter_falloff ();
+
 	void toggle_control_protocol (ARDOUR::ControlProtocolInfo*);
 };
 
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index 3ae9a76c40..eebe33bf58 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -43,6 +43,7 @@ using namespace ARDOUR;
 using namespace PBD;
 using namespace Gtk;
 using namespace Gtkmm2ext;
+using namespace sigc;
 
 int
 ARDOUR_UI::create_editor ()
@@ -81,6 +82,9 @@ ARDOUR_UI::install_actions ()
 	ActionManager::register_action (main_actions, X_("AudioFileFormatHeader"), _("Header"));
 	ActionManager::register_action (main_actions, X_("AudioFileFormatData"), _("Data"));
 	ActionManager::register_action (main_actions, X_("ControlSurfaces"), _("Control Surfaces"));
+	ActionManager::register_action (main_actions, X_("Metering"), _("Metering"));
+	ActionManager::register_action (main_actions, X_("MeteringFallOffRate"), _("Fall off rate"));
+	ActionManager::register_action (main_actions, X_("MeteringHoldTime"), _("Hold Time"));
 
 	/* the real actions */
 
@@ -354,8 +358,8 @@ ARDOUR_UI::install_actions ()
 
 	Glib::RefPtr<ActionGroup> shuttle_actions = ActionGroup::create ("ShuttleActions");
 	
-	shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), sigc::hide_return (sigc::bind (sigc::mem_fun (*Config, &Configuration::set_shuttle_units), Percentage)));
-	shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), sigc::hide_return (sigc::bind (sigc::mem_fun (*Config, &Configuration::set_shuttle_units), Semitones)));
+	shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Percentage)));
+	shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Semitones)));
 
 	Glib::RefPtr<ActionGroup> option_actions = ActionGroup::create ("options");
 
@@ -370,9 +374,37 @@ ARDOUR_UI::install_actions ()
 	act = ActionManager::register_toggle_action (option_actions, X_("UseMIDIcontrol"), _("Use MIDI control"), mem_fun (*this, &ARDOUR_UI::toggle_use_midi_control));
 	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = ActionManager::register_toggle_action (option_actions, X_("AutoConnectNewTrackInputsToHardware"), _("Connect new track inputs to hardware"), mem_fun (*this, &ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware));
+	ActionManager::register_toggle_action (option_actions, X_("StopPluginsWithTransport"), _("Stop plugins with transport"), mem_fun (*this, &ARDOUR_UI::toggle_StopPluginsWithTransport));
+	ActionManager::register_toggle_action (option_actions, X_("VerifyRemoveLastCapture"), _("Verify remove last capture"), mem_fun (*this, &ARDOUR_UI::toggle_VerifyRemoveLastCapture));
+	ActionManager::register_toggle_action (option_actions, X_("StopRecordingOnXrun"), _("Stop recording on xrun"), mem_fun (*this, &ARDOUR_UI::toggle_StopRecordingOnXrun));
+	ActionManager::register_toggle_action (option_actions, X_("StopTransportAtEndOfSession"), _("Stop transport at session end"), mem_fun (*this, &ARDOUR_UI::toggle_StopTransportAtEndOfSession));
+	ActionManager::register_toggle_action (option_actions, X_("GainReduceFastTransport"), _("-12dB gain reduce ffwd/rewind"), mem_fun (*this, &ARDOUR_UI::toggle_GainReduceFastTransport));
+	ActionManager::register_toggle_action (option_actions, X_("LatchedRecordEnable"), _("Rec-enable stays engaged at stop"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedRecordEnable));
+
+	act = ActionManager::register_toggle_action (option_actions, X_("DoNotRunPluginsWhileRecording"), _("Do not run plugins while recording"), mem_fun (*this, &ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording));
+	ActionManager::session_sensitive_actions.push_back (act);
+
+	act = ActionManager::register_toggle_action (option_actions, X_("LatchedSolo"), _("Latched solo"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedSolo));
 	ActionManager::session_sensitive_actions.push_back (act);
 
+	/* !!! REMEMBER THAT RADIO ACTIONS HAVE TO BE HANDLED WITH MORE FINESSE THAN SIMPLE TOGGLES !!! */
+
+	RadioAction::Group meter_falloff_group;
+	RadioAction::Group meter_hold_group;
+
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffOff));
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlowest));
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlow));
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffMedium));
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFast));
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFaster));
+	ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFastest));
+
+	ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldOff));
+	ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldShort));
+	ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldMedium));
+	ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldLong));
+
 	RadioAction::Group file_header_group;
 
 	act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatBWF"), X_("Broadcast WAVE"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::BWF));
@@ -387,48 +419,33 @@ ARDOUR_UI::install_actions ()
 	act = ActionManager::register_radio_action (option_actions, file_data_group, X_("FileDataFormatFloat"), X_("32-bit floating point"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_data_format), ARDOUR::FormatFloat));
 	act = ActionManager::register_radio_action (option_actions, file_data_group, X_("FileDataFormat24bit"), X_("24-bit signed integer"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_data_format), ARDOUR::FormatInt24));
 
-	RadioAction::Group connect_outputs_group;
-
-	act = ActionManager::register_radio_action (option_actions, connect_outputs_group, X_("AutoConnectNewTrackOutputsToHardware"), _("Connect new track outputs to hardware"), mem_fun (*this, &ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware));
-	ActionManager::session_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (option_actions, connect_outputs_group, X_("AutoConnectNewTrackOutputsToMaster"), _("Connect new track outputs to master"), mem_fun (*this, &ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster));
-	ActionManager::session_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (option_actions, connect_outputs_group, X_("ManuallyConnectNewTrackOutputs"), _("Manually connect new track outputs"), mem_fun (*this, &ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs));
-	ActionManager::session_sensitive_actions.push_back (act);
-
 	RadioAction::Group monitoring_group;
 
-	act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseHardwareMonitoring"), _("Hardware monitoring"), mem_fun (*this, &ARDOUR_UI::toggle_UseHardwareMonitoring));
-	act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseSoftwareMonitoring"), _("Software monitoring"), mem_fun (*this, &ARDOUR_UI::toggle_UseSoftwareMonitoring));
-	act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseExternalMonitoring"), _("External monitoring"), mem_fun (*this, &ARDOUR_UI::toggle_UseExternalMonitoring));
-
-	/* Configuration object options (i.e. not session specific) */
+	act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseHardwareMonitoring"), _("Hardware monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), HardwareMonitoring));
+	act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseSoftwareMonitoring"), _("Software monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), SoftwareMonitoring));
+	act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseExternalMonitoring"), _("External monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), ExternalMonitoring));
 
-	ActionManager::register_toggle_action (option_actions, X_("StopPluginsWithTransport"), _("Stop plugins with transport"), mem_fun (*this, &ARDOUR_UI::toggle_StopPluginsWithTransport));
-	ActionManager::register_toggle_action (option_actions, X_("VerifyRemoveLastCapture"), _("Verify remove last capture"), mem_fun (*this, &ARDOUR_UI::toggle_VerifyRemoveLastCapture));
-	ActionManager::register_toggle_action (option_actions, X_("StopRecordingOnXrun"), _("Stop recording on xrun"), mem_fun (*this, &ARDOUR_UI::toggle_StopRecordingOnXrun));
-	ActionManager::register_toggle_action (option_actions, X_("StopTransportAtEndOfSession"), _("Stop transport at session end"), mem_fun (*this, &ARDOUR_UI::toggle_StopTransportAtEndOfSession));
-	ActionManager::register_toggle_action (option_actions, X_("GainReduceFastTransport"), _("-12dB gain reduce ffwd/rewind"), mem_fun (*this, &ARDOUR_UI::toggle_GainReduceFastTransport));
-	ActionManager::register_toggle_action (option_actions, X_("LatchedRecordEnable"), _("Rec-enable stays engaged at stop"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedRecordEnable));
+	RadioAction::Group solo_group;
 
-	/* session options */
-	
-	act = ActionManager::register_toggle_action (option_actions, X_("DoNotRunPluginsWhileRecording"), _("Do not run plugins while recording"), mem_fun (*this, &ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording));
+	act = ActionManager::register_radio_action (option_actions, solo_group, X_("SoloInPlace"), _("Solo in-place"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_solo_model), InverseMute)));
 	ActionManager::session_sensitive_actions.push_back (act);
-
-	act = ActionManager::register_toggle_action (option_actions, X_("LatchedSolo"), _("Latched solo"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedSolo));
+	act = ActionManager::register_radio_action (option_actions, solo_group, X_("SoloViaBus"), _("Solo via bus"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_solo_model), SoloBus)));
 	ActionManager::session_sensitive_actions.push_back (act);
 
-	RadioAction::Group solo_group;
+	RadioAction::Group input_auto_connect_group;
 
-	act = ActionManager::register_radio_action (option_actions, solo_group, X_("SoloInPlace"), _("Solo in-place"), mem_fun (*this, &ARDOUR_UI::toggle_SoloViaBus));
+	act = ActionManager::register_radio_action (option_actions, input_auto_connect_group, X_("InputAutoConnectPhysical"), _("Auto-connect inputs to physical inputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_input_auto_connect), AutoConnectPhysical)));
 	ActionManager::session_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (option_actions, solo_group, X_("SoloViaBus"), _("Solo via bus"), mem_fun (*this, &ARDOUR_UI::toggle_SoloViaBus));
+	act = ActionManager::register_radio_action (option_actions, input_auto_connect_group, X_("InputAutoConnectManual"), _("Manually connect inputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_input_auto_connect), (AutoConnectOption) 0)));
 	ActionManager::session_sensitive_actions.push_back (act);
 
-	act = ActionManager::register_action (option_actions, X_("AutomaticallyCreateCrossfades"), _("Automatically create crossfades"), mem_fun (*this, &ARDOUR_UI::toggle_AutomaticallyCreateCrossfades));
+	RadioAction::Group output_auto_connect_group;
+
+	act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectPhysical"), _("Auto-connect outputs to physical outs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), AutoConnectPhysical)));
+	ActionManager::session_sensitive_actions.push_back (act);
+	act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectMaster"), _("Auto-connect outputs to master bus"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), AutoConnectMaster)));
 	ActionManager::session_sensitive_actions.push_back (act);
-	act = ActionManager::register_action (option_actions, X_("UnmuteNewFullCrossfades"), _("Unmute new full crossfades"), mem_fun (*this, &ARDOUR_UI::toggle_UnmuteNewFullCrossfades));
+	act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectManual"), _("Manually connect outputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), (AutoConnectOption) 0)));
 	ActionManager::session_sensitive_actions.push_back (act);
 
 	ActionManager::add_action_group (shuttle_actions);
diff --git a/gtk2_ardour/ardour_ui_options.cc b/gtk2_ardour/ardour_ui_options.cc
index f7e1faa806..9ab4f07676 100644
--- a/gtk2_ardour/ardour_ui_options.cc
+++ b/gtk2_ardour/ardour_ui_options.cc
@@ -39,120 +39,241 @@ using namespace PBD;
 using namespace sigc;
 
 void
-ARDOUR_UI::toggle_config_state (const char* group, const char* action, bool (Configuration::*set)(bool), bool (Configuration::*get)(void) const)
-{
-	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
-	if (act) {
-		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-
-		if (tact) {
-			bool x = (Config->*get)();
-
-			cerr << "\ttoggle config, action = " << tact->get_active() << " config = " << x << endl;
-			
-			if (x != tact->get_active()) {
-				(Config->*set) (!x);
-			}
-		}
-	}
-}
-
-void
-ARDOUR_UI::toggle_config_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);
-			if (tact->get_active()) {
-				theSlot ();
-			}
-		}
-	}
-}
-
-void
 ARDOUR_UI::toggle_time_master ()
 {
-	toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master, &Configuration::get_jack_time_master);
-	if (session) {
-		session->engine().reset_timebase ();
-	}
+	ActionManager::toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master, &Configuration::get_jack_time_master);
 }
 
 void
 ARDOUR_UI::toggle_send_mtc ()
 {
-	toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
+	ActionManager::toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
 }
 
 void
 ARDOUR_UI::toggle_send_mmc ()
 {
-	toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
+	ActionManager::toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
 }
 
 void
 ARDOUR_UI::toggle_use_mmc ()
 {
-	toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
+	ActionManager::toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
 }
 
 void
 ARDOUR_UI::toggle_use_midi_control ()
 {
-	toggle_config_state ("options", "UseMIDIcontrol", &Configuration::set_midi_control, &Configuration::get_midi_control);
+	ActionManager::toggle_config_state ("options", "UseMIDIcontrol", &Configuration::set_midi_control, &Configuration::get_midi_control);
 }
 
 void
 ARDOUR_UI::toggle_send_midi_feedback ()
 {
-	toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
+	ActionManager::toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
+}
+
+void
+ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
+{
+	const char *action;
+
+	switch (hf) {
+	case BWF:
+		action = X_("FileHeaderFormatBWF");
+		break;
+	case WAVE:
+		action = X_("FileHeaderFormatWAVE");
+		break;
+	case WAVE64:
+		action = X_("FileHeaderFormatWAVE64");
+		break;
+	case iXML:
+		action = X_("FileHeaderFormatiXML");
+		break;
+	case RF64:
+		action = X_("FileHeaderFormatRF64");
+		break;
+	case CAF:
+		action = X_("FileHeaderFormatCAF");
+		break;
+	case AIFF:
+		action = X_("FileHeaderFormatAIFF");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
+			Config->set_native_file_header_format (hf);
+		}
+	}
 }
 
 void
-ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware()
+ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
 {
-	toggle_config_state ("options", "AutoConnectNewTrackInputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_input_auto_connect), AutoConnectPhysical)));
+	const char* action;
+
+	switch (sf) {
+	case FormatFloat:
+		action = X_("FileDataFormatFloat");
+		break;
+	case FormatInt24:
+		action = X_("FileDataFormat24bit");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
+			Config->set_native_file_data_format (sf);
+		}
+	}
 }
+
 void
-ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware()
+ARDOUR_UI::set_input_auto_connect (AutoConnectOption option)
 {
-	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectPhysical)));
+	const char* action;
+	
+	switch (option) {
+	case AutoConnectPhysical:
+		action = X_("InputAutoConnectPhysical");
+		break;
+	default:
+		action = X_("InputAutoConnectManual");
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+
+		if (ract && ract->get_active() && Config->get_input_auto_connect() != option) {
+			Config->set_input_auto_connect (option);
+		}
+	}
 }
+
 void
-ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster()
+ARDOUR_UI::set_output_auto_connect (AutoConnectOption option)
 {
-	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectMaster)));
+	const char* action;
+	
+	switch (option) {
+	case AutoConnectPhysical:
+		action = X_("OutputAutoConnectPhysical");
+		break;
+	case AutoConnectMaster:
+		action = X_("OutputAutoConnectMaster");
+		break;
+	default:
+		action = X_("OutputAutoConnectManual");
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+
+		if (ract && ract->get_active() && Config->get_output_auto_connect() != option) {
+			Config->set_output_auto_connect (option);
+		}
+	}
 }
+
 void
-ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs()
+ARDOUR_UI::set_solo_model (SoloModel model)
 {
-	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectOption (0))));
+	const char* action = 0;
+
+	switch (model) {
+	case SoloBus:
+		action = X_("SoloViaBus");
+		break;
+		
+	case InverseMute:
+		action = X_("SoloInPlace");
+		break;
+	default:
+		fatal << string_compose (_("programming error: unknown solo model in ARDOUR_UI::set_solo_model: %1"), model) << endmsg;
+		/*NOTREACHED*/
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+
+		if (ract && ract->get_active() && Config->get_solo_model() != model) {
+			Config->set_solo_model (model);
+		}
+	}
+
+}
+
+void
+ARDOUR_UI::set_monitor_model (MonitorModel model)
+{
+	const char* action = 0;
+
+	switch (model) {
+	case HardwareMonitoring:
+		action = X_("UseHardwareMonitoring");
+		break;
+		
+	case SoftwareMonitoring:
+		action = X_("UseSoftwareMonitoring");
+		break;
+	case ExternalMonitoring:
+		action = X_("UseExternalMonitoring");
+		break;
+
+	default:
+		fatal << string_compose (_("programming error: unknown solo model in ARDOUR_UI::set_solo_model: %1"), model) << endmsg;
+		/*NOTREACHED*/
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+
+		if (ract && ract->get_active() && Config->get_monitoring_model() != model) {
+			Config->set_monitoring_model (model);
+		}
+	}
+
 }
 
 void
 ARDOUR_UI::toggle_auto_input ()
 {
-	toggle_config_state ("Transport", "ToggleAutoInput", &Configuration::set_auto_input, &Configuration::get_auto_input);
+	ActionManager::toggle_config_state ("Transport", "ToggleAutoInput", &Configuration::set_auto_input, &Configuration::get_auto_input);
 }
 
 void
 ARDOUR_UI::toggle_auto_play ()
 {
-	toggle_config_state ("Transport", "ToggleAutoPlay", &Configuration::set_auto_play, &Configuration::get_auto_play);
+	ActionManager::toggle_config_state ("Transport", "ToggleAutoPlay", &Configuration::set_auto_play, &Configuration::get_auto_play);
 }
 
 void
 ARDOUR_UI::toggle_auto_return ()
 {
-	toggle_config_state ("Transport", "ToggleAutoReturn", &Configuration::set_auto_return, &Configuration::get_auto_return);
+	ActionManager::toggle_config_state ("Transport", "ToggleAutoReturn", &Configuration::set_auto_return, &Configuration::get_auto_return);
 }
 
 void
 ARDOUR_UI::toggle_click ()
 {
-	toggle_config_state ("Transport", "ToggleClick", &Configuration::set_clicking, &Configuration::get_clicking);
+	ActionManager::toggle_config_state ("Transport", "ToggleClick", &Configuration::set_clicking, &Configuration::get_clicking);
 }
 
 void
@@ -174,13 +295,13 @@ ARDOUR_UI::toggle_session_auto_loop ()
 void
 ARDOUR_UI::toggle_punch_in ()
 {
-	toggle_config_state ("Transport", "TogglePunchIn", &Configuration::set_punch_in, &Configuration::get_punch_in);
+	ActionManager::toggle_config_state ("Transport", "TogglePunchIn", &Configuration::set_punch_in, &Configuration::get_punch_in);
 }
 
 void
 ARDOUR_UI::toggle_punch_out ()
 {
-	toggle_config_state ("Transport", "TogglePunchOut", &Configuration::set_punch_out, &Configuration::get_punch_out);
+	ActionManager::toggle_config_state ("Transport", "TogglePunchOut", &Configuration::set_punch_out, &Configuration::get_punch_out);
 }
 
 void
@@ -208,90 +329,39 @@ ARDOUR_UI::toggle_editing_space()
 }
 
 void
-ARDOUR_UI::toggle_UseHardwareMonitoring()
-{
-	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseHardwareMonitoring");
-	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);
-			Config->set_use_external_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);
-			Config->set_use_external_monitoring (false);
-			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);
-			Config->set_use_external_monitoring (true);
-			if (session) {
-				session->reset_input_monitor_state();
-			}
-		}
-	}
-}
-
-void
 ARDOUR_UI::toggle_StopPluginsWithTransport()
 {
-	toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport, &Configuration::get_plugins_stop_with_transport);
+	ActionManager::toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport, &Configuration::get_plugins_stop_with_transport);
 }
 
 void
 ARDOUR_UI::toggle_LatchedRecordEnable()
 {
-	toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
+	ActionManager::toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
 }
 
 void
 ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
 {
-	toggle_config_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::set_do_not_record_plugins, &Configuration::get_do_not_record_plugins);
+	ActionManager::toggle_config_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::set_do_not_record_plugins, &Configuration::get_do_not_record_plugins);
 }
 
 void
 ARDOUR_UI::toggle_VerifyRemoveLastCapture()
 {
-	toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture);
+	ActionManager::toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture);
 }
 
 void
 ARDOUR_UI::toggle_StopRecordingOnXrun()
 {
-	toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun, &Configuration::get_stop_recording_on_xrun);
+	ActionManager::toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun, &Configuration::get_stop_recording_on_xrun);
 }
 
 void
 ARDOUR_UI::toggle_StopTransportAtEndOfSession()
 {
-	toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end, &Configuration::get_stop_at_session_end);
+	ActionManager::toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end, &Configuration::get_stop_at_session_end);
 }
 
 void
@@ -311,36 +381,7 @@ ARDOUR_UI::toggle_GainReduceFastTransport()
 void
 ARDOUR_UI::toggle_LatchedSolo()
 {
-	toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_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()) {
-			Config->set_solo_model (SoloBus);
-		} else {
-			Config->set_solo_model (InverseMute);
-		}
-	}
-}
-
-void
-ARDOUR_UI::toggle_AutomaticallyCreateCrossfades()
-{
-}
-
-void
-ARDOUR_UI::toggle_UnmuteNewFullCrossfades()
-{
+	ActionManager::toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched);
 }
 
 void
@@ -376,27 +417,330 @@ ARDOUR_UI::setup_session_options ()
 	Config->ParameterChanged.connect (mem_fun (*this, &ARDOUR_UI::parameter_changed));
 }
 
+
 void
-ARDOUR_UI::map_some_state (const char* group, const char* action, bool (Configuration::*get)() const)
+ARDOUR_UI::map_solo_model ()
 {
-	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
+	const char* on;
+
+	if (Config->get_solo_model() == InverseMute) {
+		on = "SoloInPlace";
+	} else {
+		on = "SoloViaBus";
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 	if (act) {
 		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 
-		if (tact) {
-			
-			bool x = (Config->*get)();
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
+		}
+	}
+}
 
-			cerr << "\tmap state, action = " << tact->get_active() << " config = " << x << endl;
-			
-			if (tact->get_active() != x) {
-				tact->set_active (x);
-			}
-		} else {
-			cerr << "not a toggle\n";
+void
+ARDOUR_UI::map_monitor_model ()
+{
+	const char* on = 0;
+
+	switch (Config->get_monitoring_model()) {
+	case HardwareMonitoring:
+		on = X_("UseHardwareMonitoring");
+		break;
+	case SoftwareMonitoring:
+		on = X_("UseSoftwareMonitoring");
+		break;
+	case ExternalMonitoring:
+		on = X_("UseExternalMonitoring");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
+		}
+	}
+}
+
+void
+ARDOUR_UI::map_file_header_format ()
+{
+	const char* action = 0;
+
+	switch (Config->get_native_file_header_format()) {
+	case BWF:
+		action = X_("FileHeaderFormatBWF");
+		break;
+
+	case WAVE:
+		action = X_("FileHeaderFormatWAVE");
+		break;
+
+	case WAVE64:
+		action = X_("FileHeaderFormatWAVE64");
+		break;
+
+	case iXML:
+		action = X_("FileHeaderFormatiXML");
+		break;
+
+	case RF64:
+		action = X_("FileHeaderFormatRF64");
+		break;
+
+	case CAF:
+		action = X_("FileHeaderFormatCAF");
+		break;
+
+	default:
+		fatal << string_compose (_("programming error: unknown file header format passed to ARDOUR_UI::map_file_data_format: %1"), 
+					 Config->get_native_file_header_format()) << endmsg;
+		/*NOTREACHED*/
+	}
+
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
+		}
+	}
+}
+
+void
+ARDOUR_UI::map_file_data_format ()
+{
+	const char* action = 0;
+
+	switch (Config->get_native_file_data_format()) {
+	case FormatFloat:
+		action = X_("FileDataFormatFloat");
+		break;
+
+	case FormatInt24:
+		action = X_("FileDataFormat24bit");
+		break;
+
+	default:
+		fatal << string_compose (_("programming error: unknown file data format passed to ARDOUR_UI::map_file_data_format: %1"), 
+					 Config->get_native_file_data_format()) << endmsg;
+		/*NOTREACHED*/
+	}
+
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
+
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
 		}
+	}
+}
+
+void
+ARDOUR_UI::map_input_auto_connect ()
+{
+	const char* on;
+
+	if (Config->get_input_auto_connect() == (AutoConnectOption) 0) {
+		on = "InputAutoConnectManual";
 	} else {
-		cerr << group << ':' << action << " not an action\n";
+		on = "InputAutoConnectPhysical";
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
+		}
+	}
+}
+
+void
+ARDOUR_UI::map_output_auto_connect ()
+{
+	const char* on;
+
+	if (Config->get_output_auto_connect() == (AutoConnectOption) 0) {
+		on = "OutputAutoConnectManual";
+	} else if (Config->get_output_auto_connect() == AutoConnectPhysical) {
+		on = "OutputAutoConnectPhysical";
+	} else {
+		on = "OutputAutoConnectMaster";
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
+		}
+	}
+}
+
+void
+ARDOUR_UI::map_meter_falloff ()
+{
+	const char* action = 0;
+
+	/* XXX hack alert. Fix this. Please */
+
+	float val = Config->get_meter_falloff ();
+	MeterFalloff code = (MeterFalloff) (floor (val));
+
+	switch (code) {
+	case MeterFalloffOff:
+		action = X_("MeterFalloffOff");
+		break;
+	case MeterFalloffSlowest:
+		action = X_("MeterFalloffSlowest");
+		break;
+	case MeterFalloffSlow:
+		action = X_("MeterFalloffSlow");
+		break;
+	case MeterFalloffMedium:
+		action = X_("MeterFalloffMedium");
+		break;
+	case MeterFalloffFast:
+		action = X_("MeterFalloffFast");
+		break;
+	case MeterFalloffFaster:
+		action = X_("MeterFalloffFaster");
+		break;
+	case MeterFalloffFastest:
+		action = X_("MeterFalloffFastest");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && !ract->get_active()) {
+			ract->set_active (true);
+		}
+	}
+}
+
+void
+ARDOUR_UI::map_meter_hold ()
+{
+	const char* action = 0;
+
+	/* XXX hack alert. Fix this. Please */
+
+	float val = Config->get_meter_hold ();
+	MeterHold code = (MeterHold) (floor (val));
+
+	switch (code) {
+	case MeterHoldOff:
+		action = X_("MeterHoldOff");
+		break;
+	case MeterHoldShort:
+		action = X_("MeterHoldShort");
+		break;
+	case MeterHoldMedium:
+		action = X_("MeterHoldMedium");
+		break;
+	case MeterHoldLong:
+		action = X_("MeterHoldLong");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && !ract->get_active()) {
+			ract->set_active (true);
+		}
+	}
+}
+
+void 
+ARDOUR_UI::set_meter_hold (MeterHold val)
+{
+	const char* action = 0;
+	float fval;
+
+	fval = meter_hold_to_float (val);
+
+	switch (val) {
+	case MeterHoldOff:
+		action = X_("MeterHoldOff");
+		break;
+	case MeterHoldShort:
+		action = X_("MeterHoldShort");
+		break;
+	case MeterHoldMedium:
+		action = X_("MeterHoldMedium");
+		break;
+	case MeterHoldLong:
+		action = X_("MeterHoldLong");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
+	
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && ract->get_active() && Config->get_meter_hold() != fval) {
+			Config->set_meter_hold (fval);
+		}
+	}
+}
+
+void
+ARDOUR_UI::set_meter_falloff (MeterFalloff val)
+{
+	const char* action = 0;
+	float fval;
+
+	fval = meter_falloff_to_float (val);
+
+	switch (val) {
+	case MeterFalloffOff:
+		action = X_("MeterFalloffOff");
+		break;
+	case MeterFalloffSlowest:
+		action = X_("MeterFalloffSlowest");
+		break;
+	case MeterFalloffSlow:
+		action = X_("MeterFalloffSlow");
+		break;
+	case MeterFalloffMedium:
+		action = X_("MeterFalloffMedium");
+		break;
+	case MeterFalloffFast:
+		action = X_("MeterFalloffFast");
+		break;
+	case MeterFalloffFaster:
+		action = X_("MeterFalloffFaster");
+		break;
+	case MeterFalloffFastest:
+		action = X_("MeterFalloffFastest");
+		break;
+	}
+
+	Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
+
+	if (act) {
+		Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && ract->get_active() && Config->get_meter_falloff () != fval) {
+			Config->set_meter_falloff (fval);
+		}
 	}
 }
 
@@ -413,69 +757,58 @@ ARDOUR_UI::parameter_changed (const char* parameter_name)
 
 	} else if (PARAM_IS ("send-mtc")) {
 
-		map_some_state ("options", "SendMTC", &Configuration::get_send_mtc);
+		ActionManager::map_some_state ("options", "SendMTC", &Configuration::get_send_mtc);
 
 	} else if (PARAM_IS ("send-mmc")) {
 
-		map_some_state ("options", "SendMMC", &Configuration::get_send_mmc);
+		ActionManager::map_some_state ("options", "SendMMC", &Configuration::get_send_mmc);
 
 	} else if (PARAM_IS ("mmc-control")) {
-		map_some_state ("options", "UseMMC", &Configuration::get_mmc_control);
+		ActionManager::map_some_state ("options", "UseMMC", &Configuration::get_mmc_control);
 	} else if (PARAM_IS ("midi-feedback")) {
-		map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback);
+		ActionManager::map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback);
 	} else if (PARAM_IS ("midi-control")) {
-		map_some_state ("options", "UseMIDIcontrol", &Configuration::get_midi_control);
+		ActionManager::map_some_state ("options", "UseMIDIcontrol", &Configuration::get_midi_control);
 	} else if (PARAM_IS ("do-not-record-plugins")) {
-		map_some_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::get_do_not_record_plugins);
-	} else if (PARAM_IS ("automatic-crossfades")) {
-		map_some_state ("Editor", "toggle-auto-xfades", &Configuration::get_automatic_crossfades);
-	} else if (PARAM_IS ("crossfades-active")) {
-		map_some_state ("Editor", "toggle-xfades-active", &Configuration::get_crossfades_active);
-	} else if (PARAM_IS ("crossfades-visible")) {
-		map_some_state ("Editor", "toggle-xfades-visible", &Configuration::get_crossfades_visible);
+		ActionManager::map_some_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::get_do_not_record_plugins);
 	} else if (PARAM_IS ("latched-record-enable")) {
-		map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
+		ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
 	} else if (PARAM_IS ("solo-latched")) {
-		map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched);
+		ActionManager::map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched);
 	} else if (PARAM_IS ("solo-model")) {
-	} else if (PARAM_IS ("layer-model")) {
-	} else if (PARAM_IS ("crossfade-model")) {
+		map_solo_model ();
 	} else if (PARAM_IS ("auto-play")) {
-		map_some_state ("Transport", "ToggleAutoPlay", &Configuration::get_auto_play);
+		ActionManager::map_some_state ("Transport", "ToggleAutoPlay", &Configuration::get_auto_play);
 	} else if (PARAM_IS ("auto-loop")) {
-		map_some_state ("Transport", "Loop", &Configuration::get_auto_loop);
+		ActionManager::map_some_state ("Transport", "Loop", &Configuration::get_auto_loop);
 	} else if (PARAM_IS ("auto-return")) {
-		map_some_state ("Transport", "ToggleAutoReturn", &Configuration::get_auto_return);
+		ActionManager::map_some_state ("Transport", "ToggleAutoReturn", &Configuration::get_auto_return);
 	} else if (PARAM_IS ("auto-input")) {
-		map_some_state ("Transport", "ToggleAutoInput", &Configuration::get_auto_input);
+		ActionManager::map_some_state ("Transport", "ToggleAutoInput", &Configuration::get_auto_input);
 	} else if (PARAM_IS ("punch-out")) {
-		map_some_state ("Transport", "TogglePunchOut", &Configuration::get_punch_out);
+		ActionManager::map_some_state ("Transport", "TogglePunchOut", &Configuration::get_punch_out);
 	} else if (PARAM_IS ("punch-in")) {
-		map_some_state ("Transport", "TogglePunchIn", &Configuration::get_punch_in);
+		ActionManager::map_some_state ("Transport", "TogglePunchIn", &Configuration::get_punch_in);
 	} else if (PARAM_IS ("clicking")) {
-		map_some_state ("Transport", "ToggleClick", &Configuration::get_clicking);
+		ActionManager::map_some_state ("Transport", "ToggleClick", &Configuration::get_clicking);
 	} else if (PARAM_IS ("jack-time-master")) {
-		map_some_state ("Transport",  "ToggleTimeMaster", &Configuration::get_jack_time_master);
+		ActionManager::map_some_state ("Transport",  "ToggleTimeMaster", &Configuration::get_jack_time_master);
 	} else if (PARAM_IS ("plugins-stop-with-transport")) {
-		map_some_state ("options",  "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport);
+		ActionManager::map_some_state ("options",  "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport);
 	} else if (PARAM_IS ("latched-record-enable")) {
-		map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
+		ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
 	} else if (PARAM_IS ("verify-remove-last-capture")) {
-		map_some_state ("options",  "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture);
+		ActionManager::map_some_state ("options",  "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture);
 	} else if (PARAM_IS ("stop-recording-on-xrun")) {
-		map_some_state ("options",  "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun);
+		ActionManager::map_some_state ("options",  "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun);
 	} else if (PARAM_IS ("stop-at-session-end")) {
-		map_some_state ("options",  "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end);
-	} else if (PARAM_IS ("use-hardware-monitoring")) {
-		map_some_state ("options",  "UseHardwareMonitoring", &Configuration::get_use_hardware_monitoring);
-	} else if (PARAM_IS ("use-sw-monitoring")) {
-		map_some_state ("options",  "UseSoftwareMonitoring", &Configuration::get_use_sw_monitoring);
-	} else if (PARAM_IS ("use-external-monitoring")) {
-		map_some_state ("options",  "UseExternalMonitoring", &Configuration::get_use_external_monitoring);
+		ActionManager::map_some_state ("options",  "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end);
+	} else if (PARAM_IS ("monitoring-model")) {
+		map_monitor_model ();
 	} else if (PARAM_IS ("use-video-sync")) {
-		map_some_state ("Transport",  "ToggleVideoSync", &Configuration::get_use_video_sync);
+		ActionManager::map_some_state ("Transport",  "ToggleVideoSync", &Configuration::get_use_video_sync);
 	} else if (PARAM_IS ("quieten-at-speed")) {
-		map_some_state ("options",  "GainReduceFastTransport", &Configuration::get_quieten_at_speed);
+		ActionManager::map_some_state ("options",  "GainReduceFastTransport", &Configuration::get_quieten_at_speed);
 	} else if (PARAM_IS ("shuttle-behaviour")) {
 
 		switch (Config->get_shuttle_behaviour ()) {
@@ -505,7 +838,19 @@ ARDOUR_UI::parameter_changed (const char* parameter_name)
 			shuttle_units_button.set_label(_("ST"));
 			break;
 		}
+	} else if (PARAM_IS ("input-auto-connect")) {
+		map_input_auto_connect ();
+	} else if (PARAM_IS ("output-auto-connect")) {
+		map_output_auto_connect ();
+	} else if (PARAM_IS ("native-file-header-format")) {
+		map_file_header_format ();
+	} else if (PARAM_IS ("native-file-data-format")) {
+		map_file_data_format ();
+	} else if (PARAM_IS ("meter-hold")) {
+		map_meter_hold ();
+	} else if (PARAM_IS ("meter-falloff")) {
+		map_meter_falloff ();
 	}
-	
+
 #undef PARAM_IS
 }
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index 22d9290b78..071f18d3ec 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -98,15 +98,6 @@ const double Editor::timebar_height = 15.0;
 
 #include "editor_xpms"
 
-static const int32_t slide_index = 0;
-static const int32_t splice_index = 1;
-
-static const gchar *edit_mode_strings[] = {
-	N_("Slide Edit"),
-	N_("Splice Edit"),
-	0
-};
-
 static const gchar *snap_type_strings[] = {
 	N_("None"),
 	N_("CD Frames"),
@@ -1003,31 +994,6 @@ Editor::on_realize ()
 }
 
 void
-Editor::parameter_changed (const char* parameter_name)
-{
-#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
-
-	ENSURE_GUI_THREAD (bind (mem_fun (*this, &Editor::parameter_changed), parameter_name));
-
-	if (PARAM_IS ("auto-loop")) {
-		update_loop_range_view (true);
-	} else if (PARAM_IS ("punch-in")) {
-		update_punch_range_view (true);
-	} else if (PARAM_IS ("punch-out")) {
-		update_punch_range_view (true);
-	} else if (PARAM_IS ("layer-model")) {
-		update_layering_model ();
-	} else if (PARAM_IS ("smpte-frames-per-second") || PARAM_IS ("smpte-drop-frames")) {
-		update_smpte_mode ();
-		update_just_smpte ();
-	} else if (PARAM_IS ("video-pullup")) {
-		update_video_pullup ();
-	} 
-
-#undef PARAM_IS
-}
-
-void
 Editor::start_scrolling ()
 {
 	scroll_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect 
@@ -1181,16 +1147,6 @@ Editor::connect_to_session (Session *t)
 		analysis_window->set_session (session);
 #endif
 
-	switch (Config->get_edit_mode()) {
-	case Splice:
-		edit_mode_selector.set_active_text (edit_mode_strings[splice_index]);
-		break;
-
-	case Slide:
-		edit_mode_selector.set_active_text (edit_mode_strings[slide_index]);
-		break;
-	}
-
 	Location* loc = session->locations()->auto_loop_location();
 	if (loc == 0) {
 		loc = new Location (0, session->current_end_frame(), _("Loop"),(Location::Flags) (Location::IsAutoLoop | Location::IsHidden));
@@ -1231,35 +1187,6 @@ Editor::connect_to_session (Session *t)
 	session->locations()->StateChanged.connect (mem_fun(*this, &Editor::refresh_location_display_s));
 	session->locations()->end_location()->changed.connect (mem_fun(*this, &Editor::end_location_changed));
 
-	bool yn;
-	RefPtr<Action> act;
-
-	act = ActionManager::get_action (X_("Editor"), X_("toggle-xfades-active"));
-	if (act) {
-		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
-		/* do it twice to force the change */
-		yn = Config->get_crossfades_active();
-		tact->set_active (!yn);
-		tact->set_active (yn);
-	}
-
-	act = ActionManager::get_action (X_("Editor"), X_("toggle-auto-xfades"));
-	if (act) {
-		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
-		/* do it twice to force the change */
-		yn = Config->get_auto_xfade ();
-		tact->set_active (!yn);
-		tact->set_active (yn);
-	}
-
-	/* xfade visibility state set from editor::set_state() */
-
-	update_crossfade_model();
-	update_layering_model();
-
-	update_smpte_mode();
-	update_video_pullup();
-
 	handle_new_duration ();
 
 	redisplay_regions ();
@@ -2569,9 +2496,13 @@ Editor::setup_toolbar ()
 	mouse_mode_button_box.pack_start(mouse_audition_button, true, true);
 	mouse_mode_button_box.set_homogeneous(true);
 
+	vector<string> edit_mode_strings;
+	edit_mode_strings.push_back (edit_mode_to_string (Splice));
+	edit_mode_strings.push_back (edit_mode_to_string (Slide));
+
 	edit_mode_selector.set_name ("EditModeSelector");
-	Gtkmm2ext::set_size_request_to_display_given_text (edit_mode_selector, "Splice Edit", 2+FUDGE, 10);
-	set_popdown_strings (edit_mode_selector, internationalize (edit_mode_strings));
+	Gtkmm2ext::set_size_request_to_display_given_text (edit_mode_selector, longest (edit_mode_strings).c_str(), 2+FUDGE, 10);
+	set_popdown_strings (edit_mode_selector, edit_mode_strings);
 	edit_mode_selector.signal_changed().connect (mem_fun(*this, &Editor::edit_mode_selection_done));
 
 	mode_box->pack_start(edit_mode_selector);
@@ -4136,131 +4067,3 @@ Editor::on_key_press_event (GdkEventKey* ev)
 	return key_press_focus_accelerator_handler (*this, ev);
 }
 
-void
-Editor::update_smpte_mode ()
-{
-	ENSURE_GUI_THREAD(mem_fun(*this, &Editor::update_smpte_mode));
-
-	RefPtr<Action> act;
-
-	float frames = Config->get_smpte_frames_per_second();
-	bool drop = Config->get_smpte_drop_frames();
-
-	if ((frames < 23.976 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte23976"));
-	else if ((frames < 24 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte24"));
-	else if ((frames < 24.976 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte24976"));
-	else if ((frames < 25 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte25"));
-	else if ((frames < 29.97 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte2997"));
-	else if ((frames < 29.97 * 1.0005) && drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte2997drop"));
-	else if ((frames < 30 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte30"));
-	else if ((frames < 30 * 1.0005) && drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte30drop"));
-	else if ((frames < 59.94 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte5994"));
-	else if ((frames < 60 * 1.0005) && !drop)
-		act = ActionManager::get_action (X_("Editor"), X_("Smpte60"));
-	else
-		cerr << "Unexpected SMPTE value (" << frames << (drop ? "drop" : "") << ") in update_smpte_mode.  Menu is probably wrong\n" << endl;
-		
-
-	if (act) {
-		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-		if (ract && !ract->get_active()) {
-			ract->set_active (true);
-		}
-	}
-}
-
-void
-Editor::update_video_pullup ()
-{
-	ENSURE_GUI_THREAD (mem_fun(*this, &Editor::update_video_pullup));
-
-	RefPtr<Action> act;
-
-	float pullup = Config->get_video_pullup();
-
-	if ( pullup < (-4.1667 - 0.1) * 0.99) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4Minus1"));
-	} else if ( pullup < (-4.1667) * 0.99 ) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4"));
-	} else if ( pullup < (-4.1667 + 0.1) * 0.99 ) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4Plus1"));
-	} else if ( pullup < (-0.1) * 0.99 ) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus1"));
-	} else if (pullup > (4.1667 + 0.1) * 0.99 ) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus4Plus1"));
-	} else if ( pullup > (4.1667) * 0.99 ) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus4"));
-	} else if ( pullup > (4.1667 - 0.1) * 0.99) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus4Minus1"));
-	} else if ( pullup > (0.1) * 0.99 ) {
-		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus1"));
-	} else
-		act = ActionManager::get_action (X_("Editor"), X_("PullupNone"));
-
-
-	if (act) {
-		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-		if (ract && !ract->get_active()) {
-			ract->set_active (true);
-		}
-	}
-
-}
-
-
-void
-Editor::update_layering_model ()
-{
-	RefPtr<Action> act;
-
-	switch (Config->get_layer_model()) {
-	case LaterHigher:
-		act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
-		break;
-	case MoveAddHigher:
-		act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
-		break;
-	case AddHigher:
-		act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
-		break;
-	}
-
-	if (act) {
-		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-		if (ract && !ract->get_active()) {
-			ract->set_active (true);
-		}
-	}
-}
-
-void
-Editor::update_crossfade_model ()
-{
-	RefPtr<Action> act;
-
-	switch (Config->get_xfade_model()) {
-	case FullCrossfade:
-		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
-		break;
-	case ShortCrossfade:
-		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesShort"));
-		break;
-	}
-
-	if (act) {
-		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-		if (ract && !ract->get_active()) {
-			ract->set_active (true);
-		}
-	}
-}
-
diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h
index 4feee52d0a..a8c12b4d81 100644
--- a/gtk2_ardour/editor.h
+++ b/gtk2_ardour/editor.h
@@ -315,7 +315,6 @@ class Editor : public PublicEditor
 	void update_crossfade_model ();
 	void set_crossfade_model (ARDOUR::CrossfadeModel);
 
-
 	/* layers */
 	void set_layer_model (ARDOUR::LayerModel);
 	void update_layering_model ();
diff --git a/gtk2_ardour/editor_actions.cc b/gtk2_ardour/editor_actions.cc
index 229177d5c3..b61c2c049b 100644
--- a/gtk2_ardour/editor_actions.cc
+++ b/gtk2_ardour/editor_actions.cc
@@ -5,6 +5,7 @@
 #include "editing.h"
 #include "actions.h"
 #include "ardour_ui.h"
+#include "gui_thread.h"
 #include "i18n.h"
 
 using namespace Gtk;
@@ -41,9 +42,6 @@ Editor::register_actions ()
 	ActionManager::register_action (editor_actions, X_("Layering"), _("Layering"));
 	ActionManager::register_action (editor_actions, X_("SMPTE"), _("SMPTE fps"));
 	ActionManager::register_action (editor_actions, X_("Pullup"), _("Pullup / Pulldown"));
-	ActionManager::register_action (editor_actions, X_("Metering"), _("Metering"));
-	ActionManager::register_action (editor_actions, X_("MeteringFallOffRate"), _("Fall off rate"));
-	ActionManager::register_action (editor_actions, X_("MeteringHoldTime"), _("Hold Time"));
 	ActionManager::register_action (editor_actions, X_("addExistingAudioFiles"), _("Add Existing Audio"));
 
 	/* add named actions for the editor */
@@ -368,27 +366,6 @@ Editor::register_actions ()
 	ActionManager::register_toggle_action (editor_actions, X_("ToggleWaveformsWhileRecording"), _("Show Waveforms While Recording"), mem_fun (*this, &Editor::toggle_waveforms_while_recording));
 	act = 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;
-
-	/*
-	    Slowest = 6.6dB/sec falloff at update rate of 40ms
-	    Slow    = 6.8dB/sec falloff at update rate of 40ms
-	*/
-
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 0.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 1.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 2.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 3.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 4.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 5.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 6.0f)));
-
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 0.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 40.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 100.0f)));
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 200.0f)));
-
 	RadioAction::Group layer_model_group;
 
 	ActionManager::register_radio_action (editor_actions, layer_model_group,  X_("LayerLaterHigher"), _("Later is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), LaterHigher));
@@ -458,32 +435,156 @@ Editor::toggle_measure_visibility ()
 }
 
 void
-Editor::toggle_auto_xfade ()
+Editor::set_crossfade_model (CrossfadeModel model)
 {
-	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-auto-xfades"));
+	RefPtr<Action> act;
+
+	/* this is driven by a toggle on a radio group, and so is invoked twice,
+	   once for the item that became inactive and once for the one that became
+	   active.
+	*/
+
+	switch (model) {
+	case FullCrossfade:
+		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
+		break;
+	case ShortCrossfade:
+		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesShort"));
+		break;
+	}
+	
 	if (act) {
-		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-		Config->set_auto_xfade (tact->get_active());
+		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && ract->get_active()) {
+			Config->set_xfade_model (model);
+		}
 	}
 }
 
 void
-Editor::toggle_xfades_active ()
+Editor::update_crossfade_model ()
 {
-	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-xfades-active"));
-	if (session && act) {
-		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-		Config->set_crossfades_active (tact->get_active());
+	RefPtr<Action> act;
+
+	switch (Config->get_xfade_model()) {
+	case FullCrossfade:
+		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
+		break;
+	case ShortCrossfade:
+		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesShort"));
+		break;
+	}
+
+	if (act) {
+		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && !ract->get_active()) {
+			ract->set_active (true);
+		}
 	}
 }
 
 void
-Editor::toggle_xfade_visibility ()
+Editor::update_smpte_mode ()
 {
-	Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-xfades-visible"));
-	if (session && act) {
-		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-		// set_xfade_visibility (tact->get_active());
+	ENSURE_GUI_THREAD(mem_fun(*this, &Editor::update_smpte_mode));
+
+	RefPtr<Action> act;
+
+	float frames = Config->get_smpte_frames_per_second();
+	bool drop = Config->get_smpte_drop_frames();
+
+	if ((frames < 23.976 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte23976"));
+	else if ((frames < 24 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte24"));
+	else if ((frames < 24.976 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte24976"));
+	else if ((frames < 25 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte25"));
+	else if ((frames < 29.97 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte2997"));
+	else if ((frames < 29.97 * 1.0005) && drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte2997drop"));
+	else if ((frames < 30 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte30"));
+	else if ((frames < 30 * 1.0005) && drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte30drop"));
+	else if ((frames < 59.94 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte5994"));
+	else if ((frames < 60 * 1.0005) && !drop)
+		act = ActionManager::get_action (X_("Editor"), X_("Smpte60"));
+	else
+		cerr << "Unexpected SMPTE value (" << frames << (drop ? "drop" : "") << ") in update_smpte_mode.  Menu is probably wrong\n" << endl;
+		
+
+	if (act) {
+		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && !ract->get_active()) {
+			ract->set_active (true);
+		}
+	}
+}
+
+void
+Editor::update_video_pullup ()
+{
+	ENSURE_GUI_THREAD (mem_fun(*this, &Editor::update_video_pullup));
+
+	RefPtr<Action> act;
+
+	float pullup = Config->get_video_pullup();
+
+	if ( pullup < (-4.1667 - 0.1) * 0.99) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4Minus1"));
+	} else if ( pullup < (-4.1667) * 0.99 ) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4"));
+	} else if ( pullup < (-4.1667 + 0.1) * 0.99 ) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4Plus1"));
+	} else if ( pullup < (-0.1) * 0.99 ) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus1"));
+	} else if (pullup > (4.1667 + 0.1) * 0.99 ) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus4Plus1"));
+	} else if ( pullup > (4.1667) * 0.99 ) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus4"));
+	} else if ( pullup > (4.1667 - 0.1) * 0.99) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus4Minus1"));
+	} else if ( pullup > (0.1) * 0.99 ) {
+		act = ActionManager::get_action (X_("Editor"), X_("PullupPlus1"));
+	} else
+		act = ActionManager::get_action (X_("Editor"), X_("PullupNone"));
+
+
+	if (act) {
+		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && !ract->get_active()) {
+			ract->set_active (true);
+		}
+	}
+
+}
+
+void
+Editor::update_layering_model ()
+{
+	RefPtr<Action> act;
+
+	switch (Config->get_layer_model()) {
+	case LaterHigher:
+		act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
+		break;
+	case MoveAddHigher:
+		act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
+		break;
+	case AddHigher:
+		act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
+		break;
+	}
+
+	if (act) {
+		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && !ract->get_active()) {
+			ract->set_active (true);
+		}
 	}
 }
 
@@ -497,24 +598,22 @@ Editor::set_layer_model (LayerModel model)
 
 	RefPtr<Action> act;
 
-	if (session) {
-		switch (model) {
-		case LaterHigher:
-			act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
-			break;
-		case MoveAddHigher:
-			act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
-			break;
-		case AddHigher:
-			act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
-			break;
-		}
-		
-		if (act) {
-			RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-			if (ract && ract->get_active()) {
-				Config->set_layer_model (model);
-			}
+	switch (model) {
+	case LaterHigher:
+		act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
+		break;
+	case MoveAddHigher:
+		act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
+		break;
+	case AddHigher:
+		act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
+		break;
+	}
+	
+	if (act) {
+		RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
+		if (ract && ract->get_active() && Config->get_layer_model() != model) {
+			Config->set_layer_model (model);
 		}
 	}
 }
@@ -662,32 +761,56 @@ Editor::video_pullup_chosen (Session::PullupFormat pullup)
 	}
 }
 
+void
+Editor::toggle_auto_xfade ()
+{
+	ActionManager::toggle_config_state ("Editor", "toggle-auto-xfades", &Configuration::set_auto_xfade, &Configuration::get_auto_xfade);
+}
 
 void
-Editor::set_crossfade_model (CrossfadeModel model)
+Editor::toggle_xfades_active ()
 {
-	RefPtr<Action> act;
+	ActionManager::toggle_config_state ("Editor", "toggle-xfades-active", &Configuration::set_crossfades_active, &Configuration::get_crossfades_active);
+}
 
-	/* this is driven by a toggle on a radio group, and so is invoked twice,
-	   once for the item that became inactive and once for the one that became
-	   active.
-	*/
+void
+Editor::toggle_xfade_visibility ()
+{
+	ActionManager::toggle_config_state ("Editor", "toggle-xfades-visibility", &Configuration::set_crossfades_visible, &Configuration::get_crossfades_visible);
+}
 
-	if (session) {
-		switch (model) {
-		case FullCrossfade:
-			act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
-			break;
-		case ShortCrossfade:
-			act = ActionManager::get_action (X_("Editor"), X_("CrossfadesShort"));
-			break;
-		}
-		
-		if (act) {
-			RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-			if (ract && ract->get_active()) {
-				Config->set_xfade_model (model);
-			}
-		}
+void
+Editor::parameter_changed (const char* parameter_name)
+{
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+
+	ENSURE_GUI_THREAD (bind (mem_fun (*this, &Editor::parameter_changed), parameter_name));
+
+	if (PARAM_IS ("auto-loop")) {
+		update_loop_range_view (true);
+	} else if (PARAM_IS ("punch-in")) {
+		update_punch_range_view (true);
+	} else if (PARAM_IS ("punch-out")) {
+		update_punch_range_view (true);
+	} else if (PARAM_IS ("layer-model")) {
+		update_layering_model ();
+	} else if (PARAM_IS ("smpte-frames-per-second") || PARAM_IS ("smpte-drop-frames")) {
+		update_smpte_mode ();
+		update_just_smpte ();
+	} else if (PARAM_IS ("video-pullup")) {
+		update_video_pullup ();
+	} else if (PARAM_IS ("crossfades-active")) {
+		ActionManager::map_some_state ("Editor", "toggle-xfades-active", &Configuration::get_crossfades_active);
+	} else if (PARAM_IS ("crossfades-visible")) {
+		ActionManager::map_some_state ("Editor", "toggle-xfades-visible", &Configuration::get_crossfades_visible);
+	} else if (PARAM_IS ("auto-xfade")) {
+		ActionManager::map_some_state ("Editor", "toggle-auto-xfade", &Configuration::get_auto_xfade);
+	} else if (PARAM_IS ("edit-mode")) {
+		edit_mode_selector.set_active_text (edit_mode_to_string (Config->get_edit_mode()));
+	} else if (PARAM_IS ("native-file-data-format")) {
 	}
+
+
+
+#undef PARAM_IS
 }
diff --git a/gtk2_ardour/utils.cc b/gtk2_ardour/utils.cc
index ef90c34755..7e58d0e2f7 100644
--- a/gtk2_ardour/utils.cc
+++ b/gtk2_ardour/utils.cc
@@ -469,3 +469,30 @@ get_xpm (std::string name)
 	return (xpm_map[name]);
 }
 
+string
+longest (vector<string>& strings)
+{
+	if (strings.empty()) {
+		return string ("");
+	}
+
+	vector<string>::iterator longest = strings.begin();
+	string::size_type longest_length = (*longest).length();
+	
+	vector<string>::iterator i = longest;
+	++i;
+
+	while (i != strings.end()) {
+		
+		string::size_type len = (*i).length();
+		
+		if (len > longest_length) {
+			longest = i;
+			longest_length = len;
+		} 
+		
+		++i;
+	}
+	
+	return *longest;
+}
diff --git a/gtk2_ardour/utils.h b/gtk2_ardour/utils.h
index c0b7aac524..a48a32c10e 100644
--- a/gtk2_ardour/utils.h
+++ b/gtk2_ardour/utils.h
@@ -23,6 +23,7 @@
 
 #include <string>
 #include <cmath>
+#include <vector>
 #include <ardour/types.h>
 #include <libgnomecanvasmm/line.h>
 #include <gdkmm/types.h>
@@ -78,5 +79,6 @@ bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev);
 Glib::RefPtr<Gdk::Pixbuf> get_xpm(std::string);
 static std::map<std::string, Glib::RefPtr<Gdk::Pixbuf> > xpm_map;
 const char* const *get_xpm_data (std::string path);
+std::string longest (std::vector<std::string>&);
 
 #endif /* __ardour_gtk_utils_h__ */