X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui_options.cc;h=1d03fd158e71b63c8a4bb4b49466cfa3db4401a0;hb=b6b366b631cc0ee60df8e6e9bb7a9acdac7d0402;hp=c77273f3ea95df4ac9fef39d4f04dbbcd5a5ce65;hpb=ac1272c0d4d4632106f7ed636ff1a9182b671a05;p=ardour.git

diff --git a/gtk2_ardour/ardour_ui_options.cc b/gtk2_ardour/ardour_ui_options.cc
index c77273f3ea..1d03fd158e 100644
--- a/gtk2_ardour/ardour_ui_options.cc
+++ b/gtk2_ardour/ardour_ui_options.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2005 Paul Davis 
+    Copyright (C) 2005 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -15,10 +15,10 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
 #include <pbd/convert.h>
+#include <pbd/stacktrace.h>
 
 #include <gtkmm2ext/utils.h>
 
@@ -26,9 +26,14 @@
 #include <ardour/session.h>
 #include <ardour/audioengine.h>
 
+#ifdef HAVE_LIBLO
+#include <ardour/osc.h>
+#endif
+
 #include "ardour_ui.h"
 #include "actions.h"
 #include "gui_thread.h"
+#include "public_editor.h"
 
 #include "i18n.h"
 
@@ -39,125 +44,348 @@ 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)
+ARDOUR_UI::toggle_time_master ()
 {
-	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
-	if (act) {
-		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+	ActionManager::toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master, &Configuration::get_jack_time_master);
+}
 
-		if (tact) {
-			bool x = (Config->*get)();
-			
-			if (x != tact->get_active()) {
-				(Config->*set) (!x);
-			}
-		}
-	}
+void
+ARDOUR_UI::toggle_send_mtc ()
+{
+	ActionManager::toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
 }
 
 void
-ARDOUR_UI::toggle_config_state (const char* group, const char* action, sigc::slot<void> theSlot)
+ARDOUR_UI::toggle_send_mmc ()
 {
-	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 ();
-			}
-		}
-	}
+	ActionManager::toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
 }
 
 void
-ARDOUR_UI::toggle_time_master ()
+ARDOUR_UI::toggle_send_midi_clock ()
 {
-	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 ("options", "SendMidiClock", &Configuration::set_send_midi_clock, &Configuration::get_send_midi_clock);
 }
 
 void
-ARDOUR_UI::toggle_send_mtc ()
+ARDOUR_UI::toggle_use_mmc ()
 {
-	toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
+	ActionManager::toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
 }
 
 void
-ARDOUR_UI::toggle_send_mmc ()
+ARDOUR_UI::toggle_use_osc ()
 {
-	toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
+	ActionManager::toggle_config_state ("options", "UseOSC", &Configuration::set_use_osc, &Configuration::get_use_osc);
 }
 
 void
-ARDOUR_UI::toggle_use_mmc ()
+ARDOUR_UI::toggle_send_midi_feedback ()
 {
-	toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
+	ActionManager::toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
 }
 
 void
-ARDOUR_UI::toggle_use_midi_control ()
+ARDOUR_UI::toggle_denormal_protection ()
 {
-	toggle_config_state ("options", "UseMIDIcontrol", &Configuration::set_midi_control, &Configuration::get_midi_control);
+	ActionManager::toggle_config_state ("options", "DenormalProtection", &Configuration::set_denormal_protection, &Configuration::get_denormal_protection);
 }
 
 void
-ARDOUR_UI::toggle_send_midi_feedback ()
+ARDOUR_UI::toggle_only_copy_imported_files ()
 {
-	toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
+	ActionManager::toggle_config_state ("options", "OnlyCopyImportedFiles", &Configuration::set_only_copy_imported_files, &Configuration::get_only_copy_imported_files);
 }
 
+
 void
-ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware()
+ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
 {
-	toggle_config_state ("options", "AutoConnectNewTrackInputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_input_auto_connect), AutoConnectPhysical)));
+	const char *action = 0;
+
+	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;
+	default:
+		fatal << string_compose (_("programming error: %1"), "illegal file header format in ::set_native_file_header_format") << 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_native_file_header_format() != hf) {
+			Config->set_native_file_header_format (hf);
+		}
+	}
 }
+
 void
-ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware()
+ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
 {
-	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectPhysical)));
+	const char* action = 0;
+
+	switch (sf) {
+	case FormatFloat:
+		action = X_("FileDataFormatFloat");
+		break;
+	case FormatInt24:
+		action = X_("FileDataFormat24bit");
+		break;
+	case FormatInt16:
+		action = X_("FileDataFormat16bit");
+		break;
+	default:
+		fatal << string_compose (_("programming error: %1"), "illegal file data format in ::set_native_file_data_format") << 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_native_file_data_format() != sf) {
+			Config->set_native_file_data_format (sf);
+		}
+	}
 }
+
 void
-ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster()
+ARDOUR_UI::set_input_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_("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::set_output_auto_connect (AutoConnectOption option)
+{
+	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::set_solo_model (SoloModel model)
+{
+	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_remote_model (RemoteModel model)
+{
+	const char* action = 0;
+
+	switch (model) {
+	case UserOrdered:
+		action = X_("RemoteUserDefined");
+		break;
+	case MixerOrdered:
+		action = X_("RemoteMixerDefined");
+		break;
+	case EditorOrdered:
+		action = X_("RemoteEditorDefined");
+		break;
+
+	default:
+		fatal << string_compose (_("programming error: unknown remote model in ARDOUR_UI::set_remote_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_remote_model() != model) {
+			Config->set_remote_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 monitor model in ARDOUR_UI::set_monitor_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_ManuallyConnectNewTrackOutputs()
+ARDOUR_UI::set_denormal_model (DenormalModel 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 DenormalNone:
+		action = X_("DenormalNone");
+		break;
+
+	case DenormalFTZ:
+		action = X_("DenormalFTZ");
+		break;
+
+	case DenormalDAZ:
+		action = X_("DenormalDAZ");
+		break;
+
+	case DenormalFTZDAZ:
+		action = X_("DenormalFTZDAZ");
+		break;
+
+	default:
+		fatal << string_compose (_("programming error: unknown denormal model in ARDOUR_UI::set_denormal_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_denormal_model() != model) {
+			Config->set_denormal_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
 ARDOUR_UI::toggle_session_auto_loop ()
 {
 	if (session) {
-		if (Config->get_auto_loop()) {
+		if (session->get_play_loop()) {
 			if (session->transport_rolling()) {
 				transport_roll();
 			} else {
@@ -169,16 +397,62 @@ ARDOUR_UI::toggle_session_auto_loop ()
 	}
 }
 
+void
+ARDOUR_UI::unset_dual_punch ()
+{
+	Glib::RefPtr<Action> action = ActionManager::get_action ("Transport", "TogglePunch");
+
+	if (action) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(action);
+		if (tact) {
+			ignore_dual_punch = true;
+			tact->set_active (false);
+			ignore_dual_punch = false;
+		}
+	}
+}
+
+void
+ARDOUR_UI::toggle_punch ()
+{
+	if (ignore_dual_punch) {
+		return;
+	}
+
+	Glib::RefPtr<Action> action = ActionManager::get_action ("Transport", "TogglePunch");
+
+	if (action) {
+
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(action);
+
+		if (!tact) {
+			return;
+		}
+
+		/* drive the other two actions from this one */
+
+		Glib::RefPtr<Action> in_action = ActionManager::get_action ("Transport", "TogglePunchIn");
+		Glib::RefPtr<Action> out_action = ActionManager::get_action ("Transport", "TogglePunchOut");
+
+		if (in_action && out_action) {
+			Glib::RefPtr<ToggleAction> tiact = Glib::RefPtr<ToggleAction>::cast_dynamic(in_action);
+			Glib::RefPtr<ToggleAction> toact = Glib::RefPtr<ToggleAction>::cast_dynamic(out_action);
+			tiact->set_active (tact->get_active());
+			toact->set_active (tact->get_active());
+		}
+	}
+}
+
 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
@@ -206,145 +480,148 @@ ARDOUR_UI::toggle_editing_space()
 }
 
 void
-ARDOUR_UI::toggle_UseHardwareMonitoring()
+ARDOUR_UI::toggle_new_plugins_active ()
 {
-	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();
-			}
-		}
-	}
+	ActionManager::toggle_config_state ("options", "NewPluginsActive", &Configuration::set_new_plugins_active, &Configuration::get_new_plugins_active);
 }
 
 void
-ARDOUR_UI::toggle_UseSoftwareMonitoring()
+ARDOUR_UI::toggle_StopPluginsWithTransport()
 {
-	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();
-			}
-		}
-	}
+	ActionManager::toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport, &Configuration::get_plugins_stop_with_transport);
 }
 
 void
-ARDOUR_UI::toggle_UseExternalMonitoring()
+ARDOUR_UI::toggle_LatchedRecordEnable()
 {
-	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();
-			}
-		}
-	}
+	ActionManager::toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
 }
 
 void
-ARDOUR_UI::toggle_StopPluginsWithTransport()
+ARDOUR_UI::toggle_RegionEquivalentsOverlap()
 {
-	toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport, &Configuration::get_plugins_stop_with_transport);
+	ActionManager::toggle_config_state ("options", "RegionEquivalentsOverlap", &Configuration::set_use_overlap_equivalency, &Configuration::get_use_overlap_equivalency);
 }
 
 void
-ARDOUR_UI::toggle_LatchedRecordEnable()
+ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
 {
-	toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
+	ActionManager::toggle_config_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::set_do_not_record_plugins, &Configuration::get_do_not_record_plugins);
 }
 
 void
-ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
+ARDOUR_UI::toggle_VerifyRemoveLastCapture()
 {
-	toggle_config_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::set_do_not_record_plugins, &Configuration::get_do_not_record_plugins);
+	ActionManager::toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture);
 }
 
 void
-ARDOUR_UI::toggle_VerifyRemoveLastCapture()
+ARDOUR_UI::toggle_PeriodicSafetyBackups()
 {
-	toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture);
+	ActionManager::toggle_config_state ("options", "PeriodicSafetyBackups", &Configuration::set_periodic_safety_backups, &Configuration::get_periodic_safety_backups);
 }
 
 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_CreateXrunMarker()
+{
+	ActionManager::toggle_config_state ("options", "CreateXrunMarker", &Configuration::set_create_xrun_marker, &Configuration::get_create_xrun_marker);
+}
+
+void
+ARDOUR_UI::toggle_sync_order_keys ()
+{
+	ActionManager::toggle_config_state ("options", "SyncEditorAndMixerTrackOrder", &Configuration::set_sync_all_route_ordering, &Configuration::get_sync_all_route_ordering);
 }
 
 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
 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 */
-		}
-	}
+	ActionManager::toggle_config_state ("options", "GainReduceFastTransport", &Configuration::set_quieten_at_speed, &Configuration::get_quieten_at_speed);
 }
 
 void
 ARDOUR_UI::toggle_LatchedSolo()
 {
-	toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched);
+	ActionManager::toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched);
 }
 
 void
-ARDOUR_UI::toggle_SoloViaBus()
+ARDOUR_UI::toggle_ShowSoloMutes()
 {
-	if (!session) {
-		return;
-	}
+	ActionManager::toggle_config_state ("options", "ShowSoloMutes", &Configuration::set_show_solo_mutes, &Configuration::get_show_solo_mutes);
+}
 
-	Glib::RefPtr<Action> act = ActionManager::get_action ("options", "SoloViaBus");
-	if (act) {
-		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+void
+ARDOUR_UI::toggle_SoloMuteOverride()
+{
+	ActionManager::toggle_config_state ("options", "SoloMuteOverride", &Configuration::set_solo_mute_override, &Configuration::get_solo_mute_override);
+}
 
-		if (tact->get_active()) {
-			Config->set_solo_model (SoloBus);
-		} else {
-			Config->set_solo_model (InverseMute);
-		}
-	}
+void
+ARDOUR_UI::toggle_PrimaryClockDeltaEditCursor()
+{
+	ActionManager::toggle_config_state ("options", "PrimaryClockDeltaEditCursor", &Configuration::set_primary_clock_delta_edit_cursor, &Configuration::get_primary_clock_delta_edit_cursor);
 }
 
 void
-ARDOUR_UI::toggle_AutomaticallyCreateCrossfades()
+ARDOUR_UI::toggle_SecondaryClockDeltaEditCursor()
 {
+	ActionManager::toggle_config_state ("options", "SecondaryClockDeltaEditCursor", &Configuration::set_secondary_clock_delta_edit_cursor, &Configuration::get_secondary_clock_delta_edit_cursor);
 }
 
 void
-ARDOUR_UI::toggle_UnmuteNewFullCrossfades()
+ARDOUR_UI::toggle_ShowTrackMeters()
 {
+	ActionManager::toggle_config_state ("options", "ShowTrackMeters", &Configuration::set_show_track_meters, &Configuration::get_show_track_meters);
+}
+
+void
+ARDOUR_UI::toggle_TapeMachineMode ()
+{
+	ActionManager::toggle_config_state ("options", "ToggleTapeMachineMode", &Configuration::set_tape_machine_mode, &Configuration::get_tape_machine_mode);
+}
+
+void
+ARDOUR_UI::toggle_use_narrow_ms()
+{
+	ActionManager::toggle_config_state ("options", "DefaultNarrowMS", &Configuration::set_default_narrow_ms, &Configuration::get_default_narrow_ms);
+}
+
+void
+ARDOUR_UI::toggle_NameNewMarkers()
+{
+	ActionManager::toggle_config_state ("options", "NameNewMarkers", &Configuration::set_name_new_markers, &Configuration::get_name_new_markers);
+}
+
+void
+ARDOUR_UI::toggle_rubberbanding_snaps_to_grid ()
+{
+	ActionManager::toggle_config_state ("options", "RubberbandingSnapsToGrid", &Configuration::set_rubberbanding_snaps_to_grid, &Configuration::get_rubberbanding_snaps_to_grid);
+}
+
+void
+ARDOUR_UI::toggle_auto_analyse_audio ()
+{
+	ActionManager::toggle_config_state ("options", "AutoAnalyseAudio", &Configuration::set_auto_analyse_audio, &Configuration::get_auto_analyse_audio);
 }
 
 void
 ARDOUR_UI::mtc_port_changed ()
 {
 	bool have_mtc;
+	bool have_midi_clock;
 
 	if (session) {
 		if (session->mtc_port()) {
@@ -352,8 +629,14 @@ ARDOUR_UI::mtc_port_changed ()
 		} else {
 			have_mtc = false;
 		}
+		if (session->midi_clock_port()) {
+			have_midi_clock = true;
+		} else {
+			have_midi_clock = false;
+		}
 	} else {
 		have_mtc = false;
+		have_midi_clock = false;
 	}
 
 	positional_sync_strings.clear ();
@@ -361,8 +644,11 @@ ARDOUR_UI::mtc_port_changed ()
 	if (have_mtc) {
 		positional_sync_strings.push_back (slave_source_to_string (MTC));
 	}
+	if (have_midi_clock) {
+		positional_sync_strings.push_back (slave_source_to_string (MIDIClock));
+	}
 	positional_sync_strings.push_back (slave_source_to_string (JACK));
-	
+
 	set_popdown_strings (sync_option_combo, positional_sync_strings);
 }
 
@@ -374,19 +660,416 @@ 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 = X_("SoloInPlace");
+	} else {
+		on = X_("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->get_active() != x) {
-				tact->set_active (x);
-			}
+		if (tact && !tact->get_active()) {
+			tact->set_active (true);
+		}
+	}
+}
+
+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_denormal_protection ()
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", X_("DenormalProtection"));
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact && !tact->get_active()) {
+			tact->set_active (Config->get_denormal_protection());
+		}
+	}
+}
+
+void
+ARDOUR_UI::map_denormal_model ()
+{
+	const char* on = 0;
+
+	switch (Config->get_denormal_model()) {
+	case DenormalNone:
+		on = X_("DenormalNone");
+		break;
+	case DenormalFTZ:
+		on = X_("DenormalFTZ");
+		break;
+	case DenormalDAZ:
+		on = X_("DenormalDAZ");
+		break;
+	case DenormalFTZDAZ:
+		on = X_("DenormalFTZDAZ");
+		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_remote_model ()
+{
+	const char* on = 0;
+
+	switch (Config->get_remote_model()) {
+	case UserOrdered:
+		on = X_("RemoteUserDefined");
+		break;
+	case MixerOrdered:
+		on = X_("RemoteMixerDefined");
+		break;
+	case EditorOrdered:
+		on = X_("RemoteEditorDefined");
+		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;
+
+	case FormatInt16:
+		action = X_("FileDataFormat16bit");
+		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 {
+		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_only_copy_imported_files ()
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action ("options", X_("OnlyCopyImportedFiles"));
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+
+		if (tact && !tact->get_active()) {
+			tact->set_active (Config->get_only_copy_imported_files());
+		}
+	}
+
+}
+
+
+void
+ARDOUR_UI::map_meter_falloff ()
+{
+	const char* action = X_("MeterFalloffMedium");
+
+	float val = Config->get_meter_falloff ();
+	MeterFalloff code = meter_falloff_from_float(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 = X_("MeterHoldMedium");
+
+	/* XXX hack alert. Fix this. Please */
+
+	float val = Config->get_meter_hold ();
+	MeterHold code = (MeterHold) (int) (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);
 		}
 	}
 }
@@ -394,73 +1077,115 @@ ARDOUR_UI::map_some_state (const char* group, const char* action, bool (Configur
 void
 ARDOUR_UI::parameter_changed (const char* parameter_name)
 {
+	ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::parameter_changed), parameter_name));
+
 #define PARAM_IS(x) (!strcmp (parameter_name, (x)))
 
 	if (PARAM_IS ("slave-source")) {
 
 		sync_option_combo.set_active_text (slave_source_to_string (Config->get_slave_source()));
 
+		switch (Config->get_slave_source()) {
+		case None:
+			ActionManager::get_action ("Transport", "ToggleAutoPlay")->set_sensitive (true);
+			ActionManager::get_action ("Transport", "ToggleAutoReturn")->set_sensitive (true);
+			break;
+
+		default:
+			/* XXX need to make auto-play is off as well as insensitive */
+			ActionManager::get_action ("Transport", "ToggleAutoPlay")->set_sensitive (false);
+			ActionManager::get_action ("Transport", "ToggleAutoReturn")->set_sensitive (false);
+			break;
+		}
+
 	} 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 ("use-osc")) {
+
+#ifdef HAVE_LIBLO
+		if (Config->get_use_osc()) {
+			osc->start ();
+		} else {
+			osc->stop ();
+		}
+#endif
+
+		ActionManager::map_some_state ("options", "UseOSC", &Configuration::get_use_osc);
 
 	} 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);
-	} else if (PARAM_IS ("midi-control")) {
-		map_some_state ("options", "UseMIDIcontrol", &Configuration::get_midi_control);
+		ActionManager::map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback);
 	} else if (PARAM_IS ("do-not-record-plugins")) {
-		map_some_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::get_do_not_record_plugins);
-	} else if (PARAM_IS ("crossfades-active")) {
-		map_some_state ("options", "CrossfadesActive", &Configuration::get_crossfades_active);
+		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);
-	} else if (PARAM_IS ("solo-latch")) {
-		map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched);
+		ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
+	} else if (PARAM_IS ("solo-latched")) {
+		ActionManager::map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched);
+	} else if (PARAM_IS ("show-solo-mutes")) {
+		ActionManager::map_some_state ("options", "ShowSoloMutes", &Configuration::get_show_solo_mutes);
+	} else if (PARAM_IS ("solo-mute-override")) {
+		ActionManager::map_some_state ("options", "SoloMuteOverride", &Configuration::get_solo_mute_override);
 	} 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);
-	} else if (PARAM_IS ("auto-loop")) {
-		map_some_state ("Transport", "Loop", &Configuration::get_auto_loop);
+		ActionManager::map_some_state ("Transport", "ToggleAutoPlay", &Configuration::get_auto_play);
 	} 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 ("tape-machine-mode")) {
+		ActionManager::map_some_state ("options", "ToggleTapeMachineMode", &Configuration::get_tape_machine_mode);
 	} 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);
+		if (!Config->get_punch_out()) {
+			unset_dual_punch ();
+		}
 	} 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);
+		if (!Config->get_punch_in()) {
+			unset_dual_punch ();
+		}
 	} 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 ("new-plugins-active")) {
+		ActionManager::map_some_state ("options",  "NewPluginsActive", &Configuration::get_new_plugins_active);
 	} 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 ("periodic-safety-backups")) {
+		ActionManager::map_some_state ("options",  "PeriodicSafetyBackups", &Configuration::get_periodic_safety_backups);
 	} 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 ("create-xrun-marker")) {
+		ActionManager::map_some_state ("options",  "CreateXrunMarker", &Configuration::get_create_xrun_marker);
+	} else if (PARAM_IS ("sync-all-route-ordering")) {
+		ActionManager::map_some_state ("options",  "SyncEditorAndMixerTrackOrder", &Configuration::get_sync_all_route_ordering);
 	} 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 ("denormal-model")) {
+		map_denormal_model ();
+	} else if (PARAM_IS ("denormal-protection")) {
+		map_denormal_protection ();
+	} else if (PARAM_IS ("remote-model")) {
+		map_remote_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 ()) {
@@ -481,7 +1206,7 @@ ARDOUR_UI::parameter_changed (const char* parameter_name)
 		}
 
 	} else if (PARAM_IS ("shuttle-units")) {
-		
+
 		switch (Config->get_shuttle_units()) {
 		case Percentage:
 			shuttle_units_button.set_label("% ");
@@ -490,7 +1215,44 @@ 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 ();
+	} else if (PARAM_IS ("video-pullup") || PARAM_IS ("smpte-format")) {
+		if (session) {
+			primary_clock.set (session->audible_frame(), true);
+			secondary_clock.set (session->audible_frame(), true);
+		} else {
+			primary_clock.set (0, true);
+			secondary_clock.set (0, true);
+		}
+	} else if (PARAM_IS ("use-overlap-equivalency")) {
+		ActionManager::map_some_state ("options", "RegionEquivalentsOverlap", &Configuration::get_use_overlap_equivalency);
+	} else if (PARAM_IS ("primary-clock-delta-edit-cursor")) {
+		ActionManager::map_some_state ("options",  "PrimaryClockDeltaEditCursor", &Configuration::get_primary_clock_delta_edit_cursor);
+	} else if (PARAM_IS ("secondary-clock-delta-edit-cursor")) {
+		ActionManager::map_some_state ("options",  "SecondaryClockDeltaEditCursor", &Configuration::get_secondary_clock_delta_edit_cursor);
+	} else if (PARAM_IS ("only-copy-imported-files")) {
+		map_only_copy_imported_files ();
+	} else if (PARAM_IS ("show-track-meters")) {
+		ActionManager::map_some_state ("options",  "ShowTrackMeters", &Configuration::get_show_track_meters);
+		editor->toggle_meter_updating();
+	} else if (PARAM_IS ("default-narrow_ms")) {
+		ActionManager::map_some_state ("options",  "DefaultNarrowMS", &Configuration::get_default_narrow_ms);
+	} else if (PARAM_IS ("rubberbanding-snaps-to-grid")) {
+		ActionManager::map_some_state ("options", "RubberbandingSnapsToGrid", &Configuration::get_rubberbanding_snaps_to_grid);
 	}
-	
+
+
+
 #undef PARAM_IS
 }