the BIG CONFIG patch

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

20 files changed, 299 insertions, 554 deletions

diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index c67697ba4a..d9fc95a649 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -172,9 +172,6 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
 	shuttle_fract = 0.0;
 	shuttle_max_speed = 8.0f;
 
-	set_shuttle_units (Percentage);
-	set_shuttle_behaviour (Sprung);
-
 	shuttle_style_menu = 0;
 	shuttle_unit_menu = 0;
 
@@ -935,10 +932,11 @@ restart JACK with more ports."));
 void
 ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
 {
-	jack_nframes_t _preroll;
+	jack_nframes_t _preroll = 0;
 
 	if (session) {
-		_preroll = session->convert_to_frames_at (new_position, session->preroll);
+		// XXX CONFIG_CHANGE FIX - requires AnyTime handling
+		// _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
 
 		if (new_position > _preroll) {
 			new_position -= _preroll;
@@ -1013,8 +1011,8 @@ ARDOUR_UI::transport_stop ()
 		return;
 	}
 	
-	if (session->get_auto_loop()) {
-		session->request_auto_loop (false);
+	if (Config->get_auto_loop()) {
+		session->request_play_loop (false);
 	}
 	
 	session->request_stop ();
@@ -1068,8 +1066,8 @@ ARDOUR_UI::transport_roll ()
 
 	rolling = session->transport_rolling ();
 
-	if (session->get_auto_loop()) {
-		session->request_auto_loop (false);
+	if (Config->get_auto_loop()) {
+		session->request_play_loop (false);
 		auto_loop_button.set_active (false);
 		roll_button.set_active (true);
 	} else if (session->get_play_range ()) {
@@ -1086,7 +1084,7 @@ void
 ARDOUR_UI::transport_loop()
 {
 	if (session) {
-		if (session->get_auto_loop()) {
+		if (Config->get_auto_loop()) {
 			if (session->transport_rolling()) {
 				Location * looploc = session->locations()->auto_loop_location();
 				if (looploc) {
@@ -1095,7 +1093,7 @@ ARDOUR_UI::transport_loop()
 			}
 		}
 		else {
-			session->request_auto_loop (true);
+			session->request_play_loop (true);
 		}
 	}
 }
@@ -1725,8 +1723,8 @@ ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
 							
 					uint32_t cchns;
 					uint32_t mchns;
-					Session::AutoConnectOption iconnect;
-					Session::AutoConnectOption oconnect;
+					AutoConnectOption iconnect;
+					AutoConnectOption oconnect;
 							
 					if (new_session_dialog->create_control_bus()) {
 						cchns = (uint32_t) new_session_dialog->control_channel_count();
@@ -1741,19 +1739,19 @@ ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
 					}
 							
 					if (new_session_dialog->connect_inputs()) {
-						iconnect = Session::AutoConnectPhysical;
+						iconnect = AutoConnectPhysical;
 					} else {
-						iconnect = Session::AutoConnectOption (0);
+						iconnect = AutoConnectOption (0);
 					}
 							
 					/// @todo some minor tweaks.
 							
 					if (new_session_dialog->connect_outs_to_master()) {
-						oconnect = Session::AutoConnectMaster;
+						oconnect = AutoConnectMaster;
 					} else if (new_session_dialog->connect_outs_to_physical()) {
-						oconnect = Session::AutoConnectPhysical;
+						oconnect = AutoConnectPhysical;
 					} else {
-						oconnect = Session::AutoConnectOption (0);
+						oconnect = AutoConnectOption (0);
 					} 
 							
 					uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
@@ -1822,6 +1820,8 @@ This prevents the session from being loaded."));
 
 	connect_to_session (new_session);
 
+	Config->set_current_owner (ConfigVariableBase::Interface);
+
 	session_loaded = true;
 	return 0;
 }
@@ -1842,8 +1842,8 @@ int
 ARDOUR_UI::build_session (const string & path, const string & snap_name, 
 			  uint32_t control_channels,
 			  uint32_t master_channels, 
-			  Session::AutoConnectOption input_connect,
-			  Session::AutoConnectOption output_connect,
+			  AutoConnectOption input_connect,
+			  AutoConnectOption output_connect,
 			  uint32_t nphysin,
 			  uint32_t nphysout,
 			  jack_nframes_t initial_length)
@@ -2127,9 +2127,9 @@ ARDOUR_UI::add_route ()
 	string name_template = add_route_dialog->name_template ();
 	bool track = add_route_dialog->track ();
 
-	Session::AutoConnectOption oac = session->get_output_auto_connect();
+	AutoConnectOption oac = Config->get_output_auto_connect();
 
-	if (oac & Session::AutoConnectMaster) {
+	if (oac & AutoConnectMaster) {
 		output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
 	} else {
 		output_chan = input_chan;
diff --git a/gtk2_ardour/ardour_ui.h b/gtk2_ardour/ardour_ui.h
index 5d494bc48e..9dcfece760 100644
--- a/gtk2_ardour/ardour_ui.h
+++ b/gtk2_ardour/ardour_ui.h
@@ -112,8 +112,8 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	int build_session (const string & path, const string & snapshot, 
 			   uint32_t ctl_chns, 
 			   uint32_t master_chns,
-			   ARDOUR::Session::AutoConnectOption input_connect,
-			   ARDOUR::Session::AutoConnectOption output_connect,
+			   ARDOUR::AutoConnectOption input_connect,
+			   ARDOUR::AutoConnectOption output_connect,
 			   uint32_t nphysin,
 			   uint32_t nphysout,
 			   jack_nframes_t initial_length);
@@ -373,16 +373,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void toggle_time_master ();
 	void toggle_video_sync ();
 
-	enum ShuttleBehaviour {
-		Sprung,
-		Wheel
-	};
-
-	enum ShuttleUnits {
-		Percentage,
-		Semitones
-	};
-
 	Gtk::DrawingArea  shuttle_box;
 	Gtk::EventBox     speed_display_box;
 	Gtk::Label        speed_display_label;
@@ -390,8 +380,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	Gtk::ComboBoxText shuttle_style_button;
 	Gtk::Menu*        shuttle_unit_menu;
 	Gtk::Menu*        shuttle_style_menu;
-	ShuttleBehaviour  shuttle_behaviour;
-	ShuttleUnits      shuttle_units;
 	float             shuttle_max_speed;
 	Gtk::Menu*        shuttle_context_menu;
 
@@ -399,8 +387,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void show_shuttle_context_menu ();
 	void shuttle_style_changed();
 	void shuttle_unit_clicked ();
-	void set_shuttle_behaviour (ShuttleBehaviour);
-	void set_shuttle_units (ShuttleUnits);
 	void set_shuttle_max_speed (float);
 	void update_speed_display ();
 	float last_speed_displayed;
@@ -416,6 +402,8 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	bool   shuttle_grabbed;
 	double shuttle_fract;
 
+	static const double SHUTTLE_FRACT_SPEED1=0.48412291827; /* derived from A1,A2 */
+
 	Gtk::ToggleButton punch_in_button;
 	Gtk::ToggleButton punch_out_button;
 	Gtk::ToggleButton auto_return_button;
@@ -565,7 +553,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void we_have_dependents ();
 	void setup_keybindings ();
 	void setup_session_options ();
-	void setup_config_options ();
 	
 	guint32  last_key_press_time;
 
@@ -670,9 +657,8 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 
 	std::vector<std::string> positional_sync_strings;
 
-	void toggle_config_state (const char* group, const char* action, void (ARDOUR::Configuration::*set)(bool));
-	void toggle_session_state (const char* group, const char* action, void (ARDOUR::Session::*set)(bool), bool (ARDOUR::Session::*get)(void) const);
-	void toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot);
+	void toggle_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 ();
@@ -699,9 +685,8 @@ class ARDOUR_UI : public Gtkmm2ext::UI
 	void toggle_LatchedRecordEnable ();
 
 	void mtc_port_changed ();
-	void map_some_session_state (const char* group, const char* action, bool (ARDOUR::Session::*get)() const);
-	void queue_session_control_changed (ARDOUR::Session::ControlType t);
-	void session_control_changed (ARDOUR::Session::ControlType t);
+	void map_some_state (const char* group, const char* action, bool (ARDOUR::Configuration::*get)() const);
+	void parameter_changed (const char*);
 
 	void toggle_control_protocol (ARDOUR::ControlProtocolInfo*);
 };
diff --git a/gtk2_ardour/ardour_ui2.cc b/gtk2_ardour/ardour_ui2.cc
index 44287fe61e..337362d9da 100644
--- a/gtk2_ardour/ardour_ui2.cc
+++ b/gtk2_ardour/ardour_ui2.cc
@@ -130,20 +130,16 @@ ARDOUR_UI::transport_stopped ()
 	update_disk_space ();
 }
 
-static const double SHUTTLE_FRACT_SPEED1=0.48412291827; /* derived from A1,A2 */
-
 void
 ARDOUR_UI::transport_rolling ()
 {
 	stop_button.set_active (false);
 	if (session->get_play_range()) {
-
 		play_selection_button.set_active (true);
 		roll_button.set_active (false);
 		auto_loop_button.set_active (false);
 
-	} else if (session->get_auto_loop ()) {
-
+	} else if (Config->get_auto_loop ()) {
 		auto_loop_button.set_active (true);
 		play_selection_button.set_active (false);
 		roll_button.set_active (false);
@@ -396,9 +392,9 @@ ARDOUR_UI::setup_transport ()
 	sdframe->add (speed_display_box);
 
 	mtc_port_changed ();
-	sync_option_combo.set_active_text (positional_sync_strings.front());
 	sync_option_combo.signal_changed().connect (mem_fun (*this, &ARDOUR_UI::sync_option_changed));
-	Gtkmm2ext::set_size_request_to_display_given_text (sync_option_combo, "Internal", 22, 10);
+	const guint32 FUDGE = 25; // Combo's are stupid - they steal space from the entry for the button
+	set_size_request_to_display_given_text (sync_option_combo, X_("Igternal"), 2+FUDGE, 10);
 
 	shbox->pack_start (*sdframe, false, false);
 	shbox->pack_start (shuttle_units_button, true, true);
@@ -514,7 +510,7 @@ ARDOUR_UI::_auditioning_changed (bool onoff)
 void
 ARDOUR_UI::auditioning_changed (bool onoff)
 {
-	Gtkmm2ext::UI::instance()->call_slot(bind (mem_fun(*this, &ARDOUR_UI::_auditioning_changed), onoff));
+	UI::instance()->call_slot(bind (mem_fun(*this, &ARDOUR_UI::_auditioning_changed), onoff));
 }
 
 void
@@ -668,8 +664,8 @@ ARDOUR_UI::shuttle_box_button_release (GdkEventButton* ev)
 		mouse_shuttle (ev->x, true);
 		shuttle_grabbed = false;
 		shuttle_box.remove_modal_grab ();
-		if (shuttle_behaviour == Sprung) {
-			if (session->get_auto_play() || roll_button.get_state()) {
+		if (Config->get_shuttle_behaviour() == Sprung) {
+			if (Config->get_auto_play() || roll_button.get_state()) {
 				shuttle_fract = SHUTTLE_FRACT_SPEED1;				
 				session->request_transport_speed (1.0);
 				stop_button.set_active (false);
@@ -829,49 +825,14 @@ ARDOUR_UI::shuttle_unit_clicked ()
 }
 
 void
-ARDOUR_UI::set_shuttle_units (ShuttleUnits u)
-{
-	switch ((shuttle_units = u)) {
-	case Percentage:
-		shuttle_units_button.set_label("% ");
-		break;
-	case Semitones:
-		shuttle_units_button.set_label(_("ST"));
-		break;
-	}
-}
-
-void
 ARDOUR_UI::shuttle_style_changed ()
 {
 	ustring str = shuttle_style_button.get_active_text ();
 
 	if (str == _("sprung")) {
-		set_shuttle_behaviour (Sprung);
+		Config->set_shuttle_behaviour (Sprung);
 	} else if (str == _("wheel")) {
-		set_shuttle_behaviour (Wheel);
-	}
-}
-
-
-void
-ARDOUR_UI::set_shuttle_behaviour (ShuttleBehaviour b)
-{
-	switch ((shuttle_behaviour = b)) {
-	case Sprung:
-		shuttle_style_button.set_active_text (_("sprung"));
-		shuttle_fract = 0.0;
-		shuttle_box.queue_draw ();
-		if (session) {
-			if (session->transport_rolling()) {
-			        shuttle_fract = SHUTTLE_FRACT_SPEED1;
-				session->request_transport_speed (1.0);
-			}
-		}
-		break;
-	case Wheel:
-		shuttle_style_button.set_active_text (_("wheel"));
-		break;
+		Config->set_shuttle_behaviour (Wheel);
 	}
 }
 
@@ -892,7 +853,7 @@ ARDOUR_UI::update_speed_display ()
 	if (x != last_speed_displayed) {
 
 		if (x != 0) {
-			if (shuttle_units == Percentage) {
+			if (Config->get_shuttle_units() == Percentage) {
 				snprintf (buf, sizeof (buf), "%.2f", x);
 			} else {
 				if (x < 0) {
@@ -920,31 +881,19 @@ ARDOUR_UI::set_transport_sensitivity (bool yn)
 void
 ARDOUR_UI::editor_realized ()
 {
+	Config->map_parameters (mem_fun (*this, &ARDOUR_UI::parameter_changed));
+
 	set_size_request_to_display_given_text (speed_display_box, _("-0.55"), 2, 2);
-	/* XXX: this should really be saved in instant.xml or something similar and restored from there */
-	shuttle_style_button.set_active_text (_("sprung"));
-	const guint32 FUDGE = 20; // Combo's are stupid - they steal space from the entry for the button
+	const guint32 FUDGE = 25; // Combo's are stupid - they steal space from the entry for the button
 	set_size_request_to_display_given_text (shuttle_style_button, _("sprung"), 2+FUDGE, 10);
 }
 
 void
 ARDOUR_UI::sync_option_changed ()
 {
-	string which;
-
-	if (session == 0) {
-		return;
+	if (session) {
+		session->request_slave_source (string_to_slave_source (sync_option_combo.get_active_text()));
 	}
-
-	which = sync_option_combo.get_active_text();
-
-	if (which == positional_sync_strings[Session::None]) {
-		session->request_slave_source (Session::None);
-	} else if (which == positional_sync_strings[Session::MTC]) {
-		session->request_slave_source (Session::MTC);
-	} else if (which == positional_sync_strings[Session::JACK]) {
-		session->request_slave_source (Session::JACK);
-	} 
 }
 
 void
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index ef1906f3f5..944ecdaa33 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -354,8 +354,8 @@ ARDOUR_UI::install_actions ()
 
 	Glib::RefPtr<ActionGroup> shuttle_actions = ActionGroup::create ("ShuttleActions");
 	
-	shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), bind (mem_fun(*this, &ARDOUR_UI::set_shuttle_units), Percentage));
-	shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), bind (mem_fun(*this, &ARDOUR_UI::set_shuttle_units), Semitones));
+	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)));
 
 	Glib::RefPtr<ActionGroup> option_actions = ActionGroup::create ("options");
 
@@ -437,10 +437,6 @@ ARDOUR_UI::install_actions ()
 	ActionManager::add_action_group (transport_actions);
 	ActionManager::add_action_group (main_actions);
 	ActionManager::add_action_group (common_actions);
-
-	/* initialize state of non-session dependent options */
-	
-	setup_config_options ();
 }
 
 void
diff --git a/gtk2_ardour/ardour_ui_options.cc b/gtk2_ardour/ardour_ui_options.cc
index 21afbcde21..c77273f3ea 100644
--- a/gtk2_ardour/ardour_ui_options.cc
+++ b/gtk2_ardour/ardour_ui_options.cc
@@ -36,99 +36,27 @@ using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace ARDOUR;
 using namespace PBD;
+using namespace sigc;
 
 void
-ARDOUR_UI::setup_config_options ()
-{
-	std::vector<Glib::ustring> groups;
-	groups.push_back("options");
-	groups.push_back("Editor");
-	groups.push_back("Transport");	
-
-	struct { 
-	    char* name;
-	    bool (Configuration::*method)(void) const;
-	    char act_type;  //(t)oggle or (r)adio
-	} options[] = {
-		{ "ToggleTimeMaster", &Configuration::get_jack_time_master, 't' },
-		{ "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport, 't' },
-		{ "LatchedRecordEnable", &Configuration::get_latched_record_enable, 't' },
-		{ "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture, 't' },
-		{ "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun, 't' },
-		{ "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end, 't' },
-		{ "UseHardwareMonitoring", &Configuration::get_use_hardware_monitoring, 'r' },
-		{ "UseSoftwareMonitoring", &Configuration::get_use_sw_monitoring, 'r' },
-		{ "UseExternalMonitoring", &Configuration::get_use_external_monitoring, 'r' },
-		{ "MeterFalloffOff", &Configuration::get_meter_falloff_off, 'r' },
-		{ "MeterFalloffSlowest", &Configuration::get_meter_falloff_slowest, 'r' },
-		{ "MeterFalloffSlow", &Configuration::get_meter_falloff_slow, 'r' },
-		{ "MeterFalloffMedium", &Configuration::get_meter_falloff_medium, 'r' },
-		{ "MeterFalloffFast", &Configuration::get_meter_falloff_fast, 'r' },
-		{ "MeterFalloffFaster", &Configuration::get_meter_falloff_faster, 'r' },
-		{ "MeterFalloffFastest", &Configuration::get_meter_falloff_fastest, 'r' },
-		{ "MeterHoldOff", &Configuration::get_meter_hold_off, 'r' },
-		{ "MeterHoldShort", &Configuration::get_meter_hold_short, 'r' },
-		{ "MeterHoldMedium", &Configuration::get_meter_hold_medium, 'r' },
-		{ "MeterHoldLong", &Configuration::get_meter_hold_long, 'r' },
-		{ "ToggleVideoSync", &Configuration::get_use_video_sync, 't' },
-		{ 0, 0, 0 }
-	};
-	
-	for (uint32_t n = 0; options[n].name; ++n) {
-		for (std::vector<Glib::ustring>::iterator i = groups.begin(); i != groups.end(); i++) {
-			Glib::RefPtr<Action> act = ActionManager::get_action (i->c_str(), options[n].name);
-			if (act) {
-				Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-				if (options[n].act_type == 't' || options[n].act_type == 'r') {
-					if ((Config->*(options[n].method))()) {
-						tact->set_active (true);
-					} else {
-						tact->set_active (false);
-					}
-				}
-				continue;
-			}
-		}
-	}
-}
-
-void
-ARDOUR_UI::toggle_time_master ()
-{
-	toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master);
-	if (session) {
-		session->engine().reset_timebase ();
-	}
-}
-
-void
-ARDOUR_UI::toggle_config_state (const char* group, const char* action, void (Configuration::*set)(bool))
+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);
-		(Config->*set) (tact->get_active());
-	}
-}
-
-void
-ARDOUR_UI::toggle_session_state (const char* group, const char* action, void (Session::*set)(bool), bool (Session::*get)(void) const)
-{
-	if (session) {
-		Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
-		if (act) {
-			Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-			bool x = (session->*get)();
 
+		if (tact) {
+			bool x = (Config->*get)();
+			
 			if (x != tact->get_active()) {
-				(session->*set) (!x);
+				(Config->*set) (!x);
 			}
 		}
 	}
 }
 
 void
-ARDOUR_UI::toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot)
+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);
@@ -142,92 +70,101 @@ ARDOUR_UI::toggle_session_state (const char* group, const char* action, sigc::sl
 }
 
 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 ();
+	}
+}
+
+void
 ARDOUR_UI::toggle_send_mtc ()
 {
-	toggle_session_state ("options", "SendMTC", &Session::set_send_mtc, &Session::get_send_mtc);
+	toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
 }
 
 void
 ARDOUR_UI::toggle_send_mmc ()
 {
-	toggle_session_state ("options", "SendMMC", &Session::set_send_mmc, &Session::get_send_mmc);
+	toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
 }
 
 void
 ARDOUR_UI::toggle_use_mmc ()
 {
-	toggle_session_state ("options", "UseMMC", &Session::set_mmc_control, &Session::get_mmc_control);
+	toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
 }
 
 void
 ARDOUR_UI::toggle_use_midi_control ()
 {
-	toggle_session_state ("options", "UseMIDIcontrol", &Session::set_midi_control, &Session::get_midi_control);
+	toggle_config_state ("options", "UseMIDIcontrol", &Configuration::set_midi_control, &Configuration::get_midi_control);
 }
 
 void
 ARDOUR_UI::toggle_send_midi_feedback ()
 {
-	toggle_session_state ("options", "SendMIDIfeedback", &Session::set_midi_feedback, &Session::get_midi_feedback);
+	toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
 }
 
 void
 ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware()
 {
-	toggle_session_state ("options", "AutoConnectNewTrackInputsToHardware", &Session::set_input_auto_connect, &Session::get_input_auto_connect);
+	toggle_config_state ("options", "AutoConnectNewTrackInputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_input_auto_connect), AutoConnectPhysical)));
 }
 void
 ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware()
 {
-	toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectPhysical));
+	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectPhysical)));
 }
 void
 ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster()
 {
-	toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectMaster));
+	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectMaster)));
 }
 void
 ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs()
 {
-	toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectOption (0)));
+	toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectOption (0))));
 }
 
 void
 ARDOUR_UI::toggle_auto_input ()
 {
-	toggle_session_state ("Transport", "ToggleAutoInput", &Session::set_auto_input, &Session::get_auto_input);
+	toggle_config_state ("Transport", "ToggleAutoInput", &Configuration::set_auto_input, &Configuration::get_auto_input);
 }
 
 void
 ARDOUR_UI::toggle_auto_play ()
 {
-	toggle_session_state ("Transport", "ToggleAutoPlay", &Session::set_auto_play, &Session::get_auto_play);
+	toggle_config_state ("Transport", "ToggleAutoPlay", &Configuration::set_auto_play, &Configuration::get_auto_play);
 }
 
 void
 ARDOUR_UI::toggle_auto_return ()
 {
-	toggle_session_state ("Transport", "ToggleAutoReturn", &Session::set_auto_return, &Session::get_auto_return);
+	toggle_config_state ("Transport", "ToggleAutoReturn", &Configuration::set_auto_return, &Configuration::get_auto_return);
 }
 
 void
 ARDOUR_UI::toggle_click ()
 {
-	toggle_session_state ("Transport", "ToggleClick", &Session::set_clicking, &Session::get_clicking);
+	toggle_config_state ("Transport", "ToggleClick", &Configuration::set_clicking, &Configuration::get_clicking);
 }
 
 void
 ARDOUR_UI::toggle_session_auto_loop ()
 {
 	if (session) {
-		if (session->get_auto_loop()) {
+		if (Config->get_auto_loop()) {
 			if (session->transport_rolling()) {
 				transport_roll();
 			} else {
-				session->request_auto_loop (false);
+				session->request_play_loop (false);
 			}
 		} else {
-			session->request_auto_loop (true);
+			session->request_play_loop (true);
 		}
 	}
 }
@@ -235,16 +172,16 @@ ARDOUR_UI::toggle_session_auto_loop ()
 void
 ARDOUR_UI::toggle_punch_in ()
 {
-	toggle_session_state ("Transport", "TogglePunchIn", &Session::set_punch_in, &Session::get_punch_in);
+	toggle_config_state ("Transport", "TogglePunchIn", &Configuration::set_punch_in, &Configuration::get_punch_in);
 }
 
 void
 ARDOUR_UI::toggle_punch_out ()
 {
-	toggle_session_state ("Transport", "TogglePunchOut", &Session::set_punch_out, &Session::get_punch_out);
+	toggle_config_state ("Transport", "TogglePunchOut", &Configuration::set_punch_out, &Configuration::get_punch_out);
 }
 
- void
+void
 ARDOUR_UI::toggle_video_sync()
 {
 	Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", "ToggleVideoSync");
@@ -322,37 +259,37 @@ ARDOUR_UI::toggle_UseExternalMonitoring()
 void
 ARDOUR_UI::toggle_StopPluginsWithTransport()
 {
-	toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport);
+	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);
+	toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
 }
 
 void
 ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
 {
-	toggle_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::set_do_not_record_plugins, &Session::get_do_not_record_plugins);
+	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);
+	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);
+	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);
+	toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end, &Configuration::get_stop_at_session_end);
 }
 
 void
@@ -372,7 +309,7 @@ ARDOUR_UI::toggle_GainReduceFastTransport()
 void
 ARDOUR_UI::toggle_LatchedSolo()
 {
-	toggle_session_state ("options", "LatchedSolo", &Session::set_solo_latched, &Session::solo_latched);
+	toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched);
 }
 
 void
@@ -387,9 +324,9 @@ ARDOUR_UI::toggle_SoloViaBus()
 		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 
 		if (tact->get_active()) {
-			session->set_solo_model (Session::SoloBus);
+			Config->set_solo_model (SoloBus);
 		} else {
-			session->set_solo_model (Session::InverseMute);
+			Config->set_solo_model (InverseMute);
 		}
 	}
 }
@@ -398,6 +335,7 @@ void
 ARDOUR_UI::toggle_AutomaticallyCreateCrossfades()
 {
 }
+
 void
 ARDOUR_UI::toggle_UnmuteNewFullCrossfades()
 {
@@ -418,24 +356,12 @@ ARDOUR_UI::mtc_port_changed ()
 		have_mtc = false;
 	}
 
+	positional_sync_strings.clear ();
+	positional_sync_strings.push_back (slave_source_to_string (None));
 	if (have_mtc) {
-		const gchar *psync_strings[] = {
-			N_("Internal"),
-			N_("MTC"),
-			N_("JACK"),
-			0
-		};
-		
-		positional_sync_strings = PBD::internationalize (psync_strings);
-		
-	} else {
-		const gchar *psync_strings[] = {
-			N_("Internal"),
-			N_("JACK"),
-			0
-		};
-		positional_sync_strings = PBD::internationalize (psync_strings);
+		positional_sync_strings.push_back (slave_source_to_string (MTC));
 	}
+	positional_sync_strings.push_back (slave_source_to_string (JACK));
 	
 	set_popdown_strings (sync_option_combo, positional_sync_strings);
 }
@@ -445,147 +371,126 @@ ARDOUR_UI::setup_session_options ()
 {
 	mtc_port_changed ();
 
-	session_control_changed (Session::SlaveType);
-	session_control_changed (Session::SendMTC);
-	session_control_changed (Session::SendMMC);
-	session_control_changed (Session::MMCControl);
-	session_control_changed (Session::MidiFeedback);
-	session_control_changed (Session::MidiControl);
-	session_control_changed (Session::RecordingPlugins);
-	session_control_changed (Session::CrossFadesActive);
-	session_control_changed (Session::SoloLatch);
-	session_control_changed (Session::SoloingModel);
-	session_control_changed (Session::LayeringModel);
-	session_control_changed (Session::CrossfadingModel);
-	session_control_changed (Session::PunchOut);
-	session_control_changed (Session::PunchIn);
-	session_control_changed (Session::AutoPlay);
-	session_control_changed (Session::AutoReturn);
-	session_control_changed (Session::AutoInput);
-	session_control_changed (Session::Clicking);
-	session_control_changed (Session::SmpteMode);
-	
-	session->ControlChanged.connect (mem_fun (*this, &ARDOUR_UI::queue_session_control_changed));
+	Config->ParameterChanged.connect (mem_fun (*this, &ARDOUR_UI::parameter_changed));
 }
 
 void
-ARDOUR_UI::map_some_session_state (const char* group, const char* action, bool (Session::*get)() const)
+ARDOUR_UI::map_some_state (const char* group, const char* action, bool (Configuration::*get)() const)
 {
-	if (!session) {
-		return;
-	}
-
 	Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
 	if (act) {
 		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
-		bool x = (session->*get)();
-		if (tact->get_active() != x) {
-			tact->set_active (x);
+
+		if (tact) {
+			bool x = (Config->*get)();
+			
+			if (tact->get_active() != x) {
+				tact->set_active (x);
+			}
 		}
 	}
 }
 
 void
-ARDOUR_UI::queue_session_control_changed (Session::ControlType t)
-{
-	ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::session_control_changed), t));
-}
-
-void
-ARDOUR_UI::session_control_changed (Session::ControlType t)
-{
-	switch (t) {
-	case Session::SlaveType:
-		switch (session->slave_source()) {
-		case Session::None:
-			sync_option_combo.set_active_text (_("Internal"));
-			break;
-		case Session::MTC:
-			sync_option_combo.set_active_text (_("MTC"));
+ARDOUR_UI::parameter_changed (const char* 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()));
+
+	} else if (PARAM_IS ("send-mtc")) {
+
+		map_some_state ("options", "SendMTC", &Configuration::get_send_mtc);
+
+	} else if (PARAM_IS ("send-mmc")) {
+
+		map_some_state ("options", "SendMMC", &Configuration::get_send_mmc);
+
+	} else if (PARAM_IS ("mmc-control")) {
+		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);
+	} 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);
+	} 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);
+	} else if (PARAM_IS ("solo-model")) {
+	} else if (PARAM_IS ("layer-model")) {
+	} else if (PARAM_IS ("crossfade-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);
+	} else if (PARAM_IS ("auto-return")) {
+		map_some_state ("Transport", "ToggleAutoReturn", &Configuration::get_auto_return);
+	} else if (PARAM_IS ("auto-input")) {
+		map_some_state ("Transport", "ToggleAutoInput", &Configuration::get_auto_input);
+	} else if (PARAM_IS ("punch-out")) {
+		map_some_state ("Transport", "TogglePunchOut", &Configuration::get_punch_out);
+	} else if (PARAM_IS ("punch-in")) {
+		map_some_state ("Transport", "TogglePunchIn", &Configuration::get_punch_in);
+	} else if (PARAM_IS ("clicking")) {
+		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);
+	} else if (PARAM_IS ("plugins-stop-with-transport")) {
+		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);
+	} else if (PARAM_IS ("verify-remove-last-capture")) {
+		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);
+	} 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);
+	} else if (PARAM_IS ("use-video-sync")) {
+		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);
+	} else if (PARAM_IS ("shuttle-behaviour")) {
+
+		switch (Config->get_shuttle_behaviour ()) {
+		case Sprung:
+			shuttle_style_button.set_active_text (_("sprung"));
+			shuttle_fract = 0.0;
+			shuttle_box.queue_draw ();
+			if (session) {
+				if (session->transport_rolling()) {
+					shuttle_fract = SHUTTLE_FRACT_SPEED1;
+					session->request_transport_speed (1.0);
+				}
+			}
 			break;
-		case Session::JACK:
-			sync_option_combo.set_active_text (_("JACK"));
+		case Wheel:
+			shuttle_style_button.set_active_text (_("wheel"));
 			break;
 		}
-		
-		break;
-
-	case Session::SendMTC:
-		map_some_session_state ("options", "SendMTC", &Session::get_send_mtc);
-		break;
-
-	case Session::SendMMC:
-		map_some_session_state ("options", "SendMMC", &Session::get_send_mmc);
-		break;
 
-	case Session::MMCControl:       
-		map_some_session_state ("options", "UseMMC", &Session::get_mmc_control);
-		break;
-
-	case Session::MidiFeedback:       
-		map_some_session_state ("options", "SendMIDIfeedback", &Session::get_midi_feedback);
-		break;
-
-	case Session::MidiControl:       
-		map_some_session_state ("options", "UseMIDIcontrol", &Session::get_midi_control);
-		break;
-
-	case Session::RecordingPlugins:
-		map_some_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::get_do_not_record_plugins);
-		break;
-
-	case Session::CrossFadesActive:
-		map_some_session_state ("options", "CrossfadesActive", &Session::get_crossfades_active);
-		break;
-
-	case Session::SoloLatch:
-		break;
-
-	case Session::SoloingModel:
-		switch (session->solo_model()) {
-		case Session::InverseMute:
+	} else if (PARAM_IS ("shuttle-units")) {
+		
+		switch (Config->get_shuttle_units()) {
+		case Percentage:
+			shuttle_units_button.set_label("% ");
 			break;
-		case Session::SoloBus:
+		case Semitones:
+			shuttle_units_button.set_label(_("ST"));
 			break;
 		}
-		break;
-
-	case Session::LayeringModel:
-		break;
-
-	case Session::CrossfadingModel:
-		break;
-
-	case Session::AutoPlay:
-		map_some_session_state ("Transport", "ToggleAutoPlay", &Session::get_auto_play);
-		break;
-
-	case Session::AutoLoop:
-		break;
-
-	case Session::AutoReturn:
-		map_some_session_state ("Transport", "ToggleAutoReturn", &Session::get_auto_return);
-		break;
-
-	case Session::AutoInput:
-		map_some_session_state ("Transport", "ToggleAutoInput", &Session::get_auto_input);
-		break;
-
-	case Session::PunchOut:
-		map_some_session_state ("Transport", "TogglePunchOut", &Session::get_punch_out);
-		break;
-
-	case Session::PunchIn:
-		map_some_session_state ("Transport", "TogglePunchIn", &Session::get_punch_in);
-		break;
-
-	case Session::Clicking:
-		map_some_session_state ("Transport", "ToggleClick", &Session::get_clicking);
-		break;
-
-	default:
-		// somebody else handles this 
-		break;
-
 	}
+	
+#undef PARAM_IS
 }
diff --git a/gtk2_ardour/audio_clock.cc b/gtk2_ardour/audio_clock.cc
index 8c6f3a7d82..d629a1a972 100644
--- a/gtk2_ardour/audio_clock.cc
+++ b/gtk2_ardour/audio_clock.cc
@@ -1140,7 +1140,7 @@ AudioClock::get_frames (Field field,jack_nframes_t pos,int dir)
 		frames = session->frame_rate();
 		break;
 	case SMPTE_Frames:
-		frames = (jack_nframes_t) floor (session->frame_rate() / session->smpte_frames_per_second);
+		frames = (jack_nframes_t) floor (session->frame_rate() / Config->get_smpte_frames_per_second());
 		break;
 
 	case AudioFrames:
@@ -1248,7 +1248,7 @@ AudioClock::smpte_sanitize_display()
 		seconds_label.set_text("59");
 	}
 	
-	switch ((long)rint(session->smpte_frames_per_second)) {
+	switch ((long)rint(Config->get_smpte_frames_per_second())) {
 	case 24:
 		if (atoi(frames_label.get_text()) > 23) {
 			frames_label.set_text("23");
@@ -1268,7 +1268,7 @@ AudioClock::smpte_sanitize_display()
 		break;
 	}
 	
-	if (session->smpte_drop_frames) {
+	if (Config->get_smpte_drop_frames()) {
 		if ((atoi(minutes_label.get_text()) % 10) && (atoi(seconds_label.get_text()) == 0) && (atoi(frames_label.get_text()) < 2)) {
 			frames_label.set_text("02");
 		}
diff --git a/gtk2_ardour/canvas-waveview.c b/gtk2_ardour/canvas-waveview.c
index 3e4a14d86a..f491da43b2 100644
--- a/gtk2_ardour/canvas-waveview.c
+++ b/gtk2_ardour/canvas-waveview.c
@@ -861,6 +861,7 @@ gnome_canvas_waveview_get_property (GObject      *object,
 
 	case PROP_RECTIFIED:
 		g_value_set_boolean (value, waveview->rectified);
+		break;
 
 	case PROP_REGION_START:
 		g_value_set_uint (value, waveview->region_start);
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index 0729533f76..9011e3efa2 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -1003,36 +1003,28 @@ Editor::on_realize ()
 }
 
 void
-Editor::queue_session_control_changed (Session::ControlType t)
+Editor::parameter_changed (const char* parameter_name)
 {
-	Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &Editor::session_control_changed), t));
-}
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
 
-void
-Editor::session_control_changed (Session::ControlType t)
-{
-	// right now we're only tracking some state here 
+	ENSURE_GUI_THREAD (bind (mem_fun (*this, &Editor::parameter_changed), parameter_name));
 
-	switch (t) {
-	case Session::AutoLoop:
+	if (PARAM_IS ("auto-loop")) {
 		update_loop_range_view (true);
-		break;
-	case Session::PunchIn:
-	case Session::PunchOut:
+	} else if (PARAM_IS ("punch-in")) {
 		update_punch_range_view (true);
-		break;
-
-	case Session::LayeringModel:
+	} else if (PARAM_IS ("punch-out")) {
+		update_punch_range_view (true);
+	} else if (PARAM_IS ("layer-model")) {
 		update_layering_model ();
-		break;
-
-	case Session::SmpteMode:
+	} else if (PARAM_IS ("smpte-frames-per-second") || PARAM_IS ("smpte-drop-frames")) {
 		update_smpte_mode ();
-		break;
+		update_just_smpte ();
+	} else if (PARAM_IS ("video-pullup")) {
+		update_video_pullup ();
+	} 
 
-	default:
-		break;
-	}
+#undef PARAM_IS
 }
 
 void
@@ -1174,10 +1166,6 @@ Editor::connect_to_session (Session *t)
 	session_connections.push_back (session->RegionHiddenChange.connect (mem_fun(*this, &Editor::region_hidden)));
 
 	session_connections.push_back (session->SMPTEOffsetChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
-	session_connections.push_back (session->SMPTETypeChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
-
-	session_connections.push_back (session->SMPTETypeChanged.connect (mem_fun(*this, &Editor::update_smpte_mode)));
-	session_connections.push_back (session->PullupChanged.connect (mem_fun(*this, &Editor::update_video_pullup)));
 
 	session_connections.push_back (session->tempo_map().StateChanged.connect (mem_fun(*this, &Editor::tempo_map_changed)));
 
@@ -1193,7 +1181,7 @@ Editor::connect_to_session (Session *t)
 		analysis_window->set_session (session);
 #endif
 
-	switch (session->get_edit_mode()) {
+	switch (Config->get_edit_mode()) {
 	case Splice:
 		edit_mode_selector.set_active_text (edit_mode_strings[splice_index]);
 		break;
@@ -1234,7 +1222,6 @@ Editor::connect_to_session (Session *t)
 	update_loop_range_view (true);
 	update_punch_range_view (true);
 	
-	session->ControlChanged.connect (mem_fun(*this, &Editor::queue_session_control_changed));
 	session->StateSaved.connect (mem_fun(*this, &Editor::session_state_saved));
 	
 	refresh_location_display ();
@@ -1251,7 +1238,7 @@ Editor::connect_to_session (Session *t)
 	if (act) {
 		RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
 		/* do it twice to force the change */
-		yn = session->get_crossfades_active();
+		yn = Config->get_crossfades_active();
 		tact->set_active (!yn);
 		tact->set_active (yn);
 	}
@@ -3522,7 +3509,7 @@ Editor::edit_mode_selection_done ()
 		mode = Slide;
 	}
 
-	session->set_edit_mode (mode);
+	Config->set_edit_mode (mode);
 }	
 
 void
@@ -4156,8 +4143,8 @@ Editor::update_smpte_mode ()
 
 	RefPtr<Action> act;
 
-	float frames = session->smpte_frames_per_second;
-	bool drop = session->smpte_drop_frames;
+	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"));
@@ -4198,7 +4185,7 @@ Editor::update_video_pullup ()
 
 	RefPtr<Action> act;
 
-	float pullup = session->video_pullup;
+	float pullup = Config->get_video_pullup();
 
 	if ( pullup < (-4.1667 - 0.1) * 0.99) {
 		act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4Minus1"));
@@ -4235,14 +4222,14 @@ Editor::update_layering_model ()
 {
 	RefPtr<Action> act;
 
-	switch (session->get_layer_model()) {
-	case Session::LaterHigher:
+	switch (Config->get_layer_model()) {
+	case LaterHigher:
 		act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
 		break;
-	case Session::MoveAddHigher:
+	case MoveAddHigher:
 		act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
 		break;
-	case Session::AddHigher:
+	case AddHigher:
 		act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
 		break;
 	}
@@ -4260,7 +4247,7 @@ Editor::update_crossfade_model ()
 {
 	RefPtr<Action> act;
 
-	switch (session->get_xfade_model()) {
+	switch (Config->get_xfade_model()) {
 	case FullCrossfade:
 		act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
 		break;
diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h
index f5fb65e7e9..b69febb8b1 100644
--- a/gtk2_ardour/editor.h
+++ b/gtk2_ardour/editor.h
@@ -298,9 +298,6 @@ class Editor : public PublicEditor
 	void toggle_waveforms_while_recording ();
 	void toggle_measure_visibility ();
 
-	void set_meter_falloff (int);
-	void set_meter_hold (int32_t);
-
 	/* SMPTE timecode & video sync */
 
 	void smpte_fps_chosen (ARDOUR::Session::SmpteFormat format);
@@ -320,7 +317,7 @@ class Editor : public PublicEditor
 
 
 	/* layers */
-	void set_layer_model (ARDOUR::Session::LayerModel);
+	void set_layer_model (ARDOUR::LayerModel);
 	void update_layering_model ();
 
 	/* redirect shared ops menu. caller must free returned menu */
@@ -488,9 +485,7 @@ class Editor : public PublicEditor
 	ArdourCanvas::Text* verbose_canvas_cursor;
 	bool                 verbose_cursor_visible;
 
-	void session_control_changed (ARDOUR::Session::ControlType);
-	void queue_session_control_changed (ARDOUR::Session::ControlType);
-
+	void parameter_changed (const char *);
 	
 	bool track_canvas_motion (GdkEvent*);
 
diff --git a/gtk2_ardour/editor_actions.cc b/gtk2_ardour/editor_actions.cc
index f1b9ef4b83..229177d5c3 100644
--- a/gtk2_ardour/editor_actions.cc
+++ b/gtk2_ardour/editor_actions.cc
@@ -376,24 +376,24 @@ Editor::register_actions ()
 	    Slow    = 6.8dB/sec falloff at update rate of 40ms
 	*/
 
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &Editor::set_meter_falloff), 0));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &Editor::set_meter_falloff), 1)); 
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &Editor::set_meter_falloff), 2));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &Editor::set_meter_falloff), 3));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &Editor::set_meter_falloff), 4));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &Editor::set_meter_falloff), 5));
-	ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &Editor::set_meter_falloff), 6));
-
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &Editor::set_meter_hold), 0));
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &Editor::set_meter_hold), 40));
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &Editor::set_meter_hold), 100));
-	ActionManager::register_radio_action (editor_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &Editor::set_meter_hold), 200));
+	ActionManager::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), Session::LaterHigher));
-	ActionManager::register_radio_action (editor_actions, layer_model_group,  X_("LayerMoveAddHigher"), _("Most Recently Moved/Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), Session::MoveAddHigher));
-	ActionManager::register_radio_action (editor_actions, layer_model_group,  X_("LayerAddHigher"), _("Most Recently Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), Session::AddHigher));
+	ActionManager::register_radio_action (editor_actions, layer_model_group,  X_("LayerLaterHigher"), _("Later is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), LaterHigher));
+	ActionManager::register_radio_action (editor_actions, layer_model_group,  X_("LayerMoveAddHigher"), _("Most Recently Moved/Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), MoveAddHigher));
+	ActionManager::register_radio_action (editor_actions, layer_model_group,  X_("LayerAddHigher"), _("Most Recently Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), AddHigher));
 
 	RadioAction::Group smpte_group;
 
@@ -473,7 +473,7 @@ Editor::toggle_xfades_active ()
 	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);
-		session->set_crossfades_active (tact->get_active());
+		Config->set_crossfades_active (tact->get_active());
 	}
 }
 
@@ -488,7 +488,7 @@ Editor::toggle_xfade_visibility ()
 }
 
 void
-Editor::set_layer_model (Session::LayerModel model)
+Editor::set_layer_model (LayerModel model)
 {
 	/* 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
@@ -499,13 +499,13 @@ Editor::set_layer_model (Session::LayerModel model)
 
 	if (session) {
 		switch (model) {
-		case Session::LaterHigher:
+		case LaterHigher:
 			act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
 			break;
-		case Session::MoveAddHigher:
+		case MoveAddHigher:
 			act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
 			break;
-		case Session::AddHigher:
+		case AddHigher:
 			act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
 			break;
 		}
@@ -513,7 +513,7 @@ Editor::set_layer_model (Session::LayerModel model)
 		if (act) {
 			RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
 			if (ract && ract->get_active()) {
-				session->set_layer_model (model);
+				Config->set_layer_model (model);
 			}
 		}
 	}
@@ -656,7 +656,7 @@ Editor::video_pullup_chosen (Session::PullupFormat pullup)
 		if (act) {
 			RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
 			if (ract && ract->get_active()) {
-				session->set_video_pullup ( pull );
+				Config->set_video_pullup ( pull );
 			}
 		} else  cerr << "Editor::video_pullup_chosen could not find action to match pullup." << endl;
 	}
@@ -686,7 +686,7 @@ Editor::set_crossfade_model (CrossfadeModel model)
 		if (act) {
 			RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
 			if (ract && ract->get_active()) {
-				session->set_xfade_model (model);
+				Config->set_xfade_model (model);
 			}
 		}
 	}
diff --git a/gtk2_ardour/editor_audio_import.cc b/gtk2_ardour/editor_audio_import.cc
index 2b3d983ab4..8f964cc1c4 100644
--- a/gtk2_ardour/editor_audio_import.cc
+++ b/gtk2_ardour/editor_audio_import.cc
@@ -294,7 +294,7 @@ Editor::embed_sndfile (Glib::ustring path, bool split, bool multiple_files, bool
 	
 	input_chan = finfo.channels;
 	
-	if (session->get_output_auto_connect() & Session::AutoConnectMaster) {
+	if (Config->get_output_auto_connect() & AutoConnectMaster) {
 		output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
 	} else {
 		output_chan = input_chan;
diff --git a/gtk2_ardour/editor_audiotrack.cc b/gtk2_ardour/editor_audiotrack.cc
index 5b575b4814..aaf271f9b7 100644
--- a/gtk2_ardour/editor_audiotrack.cc
+++ b/gtk2_ardour/editor_audiotrack.cc
@@ -27,7 +27,7 @@ Editor::set_route_loop_selection ()
 		loc->set (start, end);
 
 		// enable looping, reposition and start rolling
-		session->request_auto_loop (true);
+		session->request_play_loop (true);
 		session->request_locate (loc->start(), true);
 	}
 
diff --git a/gtk2_ardour/editor_markers.cc b/gtk2_ardour/editor_markers.cc
index 40f00c2e10..66c54c14b7 100644
--- a/gtk2_ardour/editor_markers.cc
+++ b/gtk2_ardour/editor_markers.cc
@@ -745,7 +745,7 @@ Editor::marker_menu_loop_range ()
 			l2->set (l->start(), l->end());
 			
 			// enable looping, reposition and start rolling
-			session->request_auto_loop(true);
+			session->request_play_loop(true);
 			session->request_locate (l2->start(), true);
 		}
 	}
@@ -925,7 +925,7 @@ Editor::update_loop_range_view (bool visibility)
 
 	Location* tll;
 
-	if (session->get_auto_loop() && ((tll = transport_loop_location()) != 0)) {
+	if (Config->get_auto_loop() && ((tll = transport_loop_location()) != 0)) {
 
 		double x1 = frame_to_pixel (tll->start());
 		double x2 = frame_to_pixel (tll->end());
@@ -951,7 +951,7 @@ Editor::update_punch_range_view (bool visibility)
 
 	Location* tpl;
 
-	if ((session->get_punch_in() || session->get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
+	if ((Config->get_punch_in() || Config->get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
 
 		double x1 = frame_to_pixel (tpl->start());
 		double x2 = frame_to_pixel (tpl->end());
diff --git a/gtk2_ardour/editor_mouse.cc b/gtk2_ardour/editor_mouse.cc
index 62f7d7be0d..70c6694152 100644
--- a/gtk2_ardour/editor_mouse.cc
+++ b/gtk2_ardour/editor_mouse.cc
@@ -3513,7 +3513,7 @@ Editor::show_verbose_time_cursor (jack_nframes_t frame, double offset, double xp
 	case AudioClock::MinSec:
 		/* XXX fix this to compute min/sec properly */
 		session->smpte_time (frame, smpte);
-		secs = smpte.seconds + ((float) smpte.frames / session->smpte_frames_per_second);
+		secs = smpte.seconds + ((float) smpte.frames / Config->get_smpte_frames_per_second());
 		snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
 		break;
 
@@ -3580,7 +3580,7 @@ Editor::show_verbose_duration_cursor (jack_nframes_t start, jack_nframes_t end,
 	case AudioClock::MinSec:
 		/* XXX fix this to compute min/sec properly */
 		session->smpte_duration (end - start, smpte);
-		secs = smpte.seconds + ((float) smpte.frames / session->smpte_frames_per_second);
+		secs = smpte.seconds + ((float) smpte.frames / Config->get_smpte_frames_per_second());
 		snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
 		break;
 
diff --git a/gtk2_ardour/editor_ops.cc b/gtk2_ardour/editor_ops.cc
index 637ba1c676..9c100521a7 100644
--- a/gtk2_ardour/editor_ops.cc
+++ b/gtk2_ardour/editor_ops.cc
@@ -90,87 +90,6 @@ Editor::redo (uint32_t n)
 	}
 }
 
-void
-Editor::set_meter_hold (int32_t cnt)
-{
-	Config->set_meter_hold_off(false);
-	Config->set_meter_hold_short(false);
-	Config->set_meter_hold_medium(false);
-	Config->set_meter_hold_long(false);
-
-	switch (cnt)
-	{
-		case 0:
-		 Config->set_meter_hold_off(true);
-		 break;
-		case 40:
-		 Config->set_meter_hold_short(true);
-		 break;
-		case 100:
-		 Config->set_meter_hold_medium(true);
-		 break;
-		case 200:
-		 Config->set_meter_hold_long(true);
-		 break;
-	}
-		 
-	if (session) {
-		session->set_meter_hold (cnt);
-	}
-}
-
-void
-Editor::set_meter_falloff (int intval)
-{
-	float val = 0.0f; /* off */
-	std::string str;
-
-	Config->set_meter_falloff_off(false);
-	Config->set_meter_falloff_slowest(false);
-	Config->set_meter_falloff_slow(false);
-	Config->set_meter_falloff_medium(false);
-	Config->set_meter_falloff_fast(false);
-	Config->set_meter_falloff_faster(false);
-	Config->set_meter_falloff_fastest(false);
-	
-	switch (intval)
-	{
-		case 0:
-		 val = 0.0f;
-		 Config->set_meter_falloff_off(true);
-		 break;
-		case 1:
-		 val = 0.125f;
-		 Config->set_meter_falloff_slowest(true);
-		 break;
-		case 2:
-		 val = 0.250f;
-		 Config->set_meter_falloff_slow(true);
-		 break;
-		case 3:
-		 val = 0.375f;
-		 Config->set_meter_falloff_medium(true);
-		 break;
-		case 4:
-		 val = 0.500f;
-		 Config->set_meter_falloff_fast(true);
-		 break;
-		case 5:
-		 val = 0.750f;
-		 Config->set_meter_falloff_faster(true);
-		 break;
-		case 6:
-		 val = 0.875f;
-		 Config->set_meter_falloff_fastest(true);
-		 break;
-	}
-	
-	if (session) {
-		session->set_meter_falloff (val);
-	}
-}
-
-
 int
 Editor::ensure_cursor (jack_nframes_t *pos)
 {
@@ -1898,9 +1817,9 @@ Editor::toggle_playback (bool with_abort)
 		return;
 	}
 
-	switch (session->slave_source()) {
-	case Session::None:
-	case Session::JACK:
+	switch (Config->get_slave_source()) {
+	case None:
+	case JACK:
 		break;
 	default:
 		/* transport controlled by the master */
@@ -1914,8 +1833,8 @@ Editor::toggle_playback (bool with_abort)
 	
 	if (session->transport_rolling()) {
 		session->request_stop (with_abort);
-		if (session->get_auto_loop()) {
-			session->request_auto_loop (false);
+		if (Config->get_auto_loop()) {
+			session->request_play_loop (false);
 		}
 	} else {
 		session->request_transport_speed (1.0f);
@@ -1961,7 +1880,7 @@ Editor::loop_selected_region ()
 			
 			// enable looping, reposition and start rolling
 
-			session->request_auto_loop (true);
+			session->request_play_loop (true);
 			session->request_locate (tll->start(), false);
 			session->request_transport_speed (1.0f);
 		}
@@ -1991,7 +1910,7 @@ Editor::loop_location (Location& location)
 		tll->set (location.start(), location.end());
 
 		// enable looping, reposition and start rolling
-		session->request_auto_loop (true);
+		session->request_play_loop (true);
 		session->request_locate (tll->start(), true);
 	}
 }
diff --git a/gtk2_ardour/gain_meter.cc b/gtk2_ardour/gain_meter.cc
index d2e829581a..d553011898 100644
--- a/gtk2_ardour/gain_meter.cc
+++ b/gtk2_ardour/gain_meter.cc
@@ -201,7 +201,7 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
 	gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeter::gain_adjusted));
 	peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeter::peak_button_release));
 
-	_session.MeterHoldChanged.connect (mem_fun(*this, &GainMeter::meter_hold_changed));
+	Config->ParameterChanged.connect (mem_fun (*this, &GainMeter::parameter_changed));
 
 	gain_changed (0);
 	update_gain_sensitive ();
@@ -346,17 +346,24 @@ GainMeter::update_meters ()
 }
 
 void
-GainMeter::meter_hold_changed()
+GainMeter::parameter_changed(const char* parameter_name)
 {
-	ENSURE_GUI_THREAD(mem_fun(*this, &GainMeter::meter_hold_changed));
-	
-	vector<MeterInfo>::iterator i;
-	uint32_t n;
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+
+	ENSURE_GUI_THREAD (bind (mem_fun(*this, &GainMeter::parameter_changed), parameter_name));
+
+	if (PARAM_IS ("meter-hold")) {
 	
-	for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
+		vector<MeterInfo>::iterator i;
+		uint32_t n;
 		
-		(*i).meter->set_hold_count ((uint32_t) floor(_session.meter_hold()));
+		for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
+			
+			(*i).meter->set_hold_count ((uint32_t) floor(Config->get_meter_hold()));
+		}
 	}
+
+#undef PARAM_IS
 }
 
 void
@@ -424,7 +431,7 @@ GainMeter::setup_meters ()
 	for (uint32_t n = 0; n < nmeters; ++n) {
 		if (meters[n].width != width) {
 			delete meters[n].meter;
-			meters[n].meter = new FastMeter ((uint32_t) floor (_session.meter_hold()), width, FastMeter::Vertical);
+			meters[n].meter = new FastMeter ((uint32_t) floor (Config->get_meter_hold()), width, FastMeter::Vertical);
 			meters[n].width = width;
 
 			meters[n].meter->add_events (Gdk::BUTTON_RELEASE_MASK);
diff --git a/gtk2_ardour/gain_meter.h b/gtk2_ardour/gain_meter.h
index 1dfc088248..bbc12ccb6c 100644
--- a/gtk2_ardour/gain_meter.h
+++ b/gtk2_ardour/gain_meter.h
@@ -172,7 +172,7 @@ class GainMeter : public Gtk::VBox
 	bool wait_for_release;
 	ARDOUR::MeterPoint old_meter_point;
 
-	void meter_hold_changed();
+	void parameter_changed (const char*);
 
 	void reset_peak_display ();
 	void reset_group_peak_display (ARDOUR::RouteGroup*);
diff --git a/gtk2_ardour/main.cc b/gtk2_ardour/main.cc
index 7d716e1bb8..ce7a129d08 100644
--- a/gtk2_ardour/main.cc
+++ b/gtk2_ardour/main.cc
@@ -441,6 +441,7 @@ int main (int argc, char *argv[])
 
     	try {
 		ARDOUR::init (use_vst, try_hw_optimization);
+		Config->set_current_owner (ConfigVariableBase::Interface);
 		ui->set_engine (*engine);
 	} catch (failed_constructor& err) {
 		error << _("could not initialize Ardour.") << endmsg;
diff --git a/gtk2_ardour/option_editor.cc b/gtk2_ardour/option_editor.cc
index 013761a86a..ac2296ea55 100644
--- a/gtk2_ardour/option_editor.cc
+++ b/gtk2_ardour/option_editor.cc
@@ -248,16 +248,16 @@ OptionEditor::add_session_paths ()
 	click_emphasis_path_entry.set_sensitive (true);
 	session_raid_entry.set_sensitive (true);
 
-	if (session->click_sound.length() == 0) {
+	if (Config->get_click_sound().empty()) {
 		click_path_entry.set_text (_("internal"));
 	} else {
-		click_path_entry.set_text (session->click_sound);
+		click_path_entry.set_text (Config->get_click_sound());
 	}
 
-	if (session->click_emphasis_sound.length() == 0) {
+	if (Config->get_click_emphasis_sound().empty()) {
 		click_emphasis_path_entry.set_text (_("internal"));
 	} else {
-		click_emphasis_path_entry.set_text (session->click_emphasis_sound);
+		click_emphasis_path_entry.set_text (Config->get_click_emphasis_sound());
 	}
 
 	session_raid_entry.set_text(session->raid_path());
@@ -607,7 +607,7 @@ void
 OptionEditor::raid_path_changed ()
 {
 	if (session) {
-		session->set_raid_path (session_raid_entry.get_text());
+		Config->set_raid_path (session_raid_entry.get_text());
 	}
 }
 
@@ -655,22 +655,22 @@ OptionEditor::click_sound_changed ()
 	if (session) {
 		string path = click_path_entry.get_text();
 
-		if (path == session->click_sound) {
+		if (path == Config->get_click_sound()) {
 			return;
 		}
 
-		if (path.length() == 0) {
+		if (path.empty()) {
 
-			session->set_click_sound ("");
+			Config->set_click_sound ("");
 
 		} else {
 
 			strip_whitespace_edges (path);
 			
 			if (path == _("internal")) {
-				session->set_click_sound ("");
+				Config->set_click_sound ("");
 			} else {
-				session->set_click_sound (path);
+				Config->set_click_sound (path);
 			}
 		}
 	}
@@ -682,22 +682,22 @@ OptionEditor::click_emphasis_sound_changed ()
 	if (session) {
 		string path = click_emphasis_path_entry.get_text();
 
-		if (path == session->click_emphasis_sound) {
+		if (path == Config->get_click_emphasis_sound()) {
 			return;
 		}
 
-		if (path.length() == 0) {
+		if (path.empty()) {
 
-			session->set_click_emphasis_sound ("");
+			Config->set_click_emphasis_sound ("");
 
 		} else {
 
 			strip_whitespace_edges (path);
 
 			if (path == _("internal")) {
-				session->set_click_emphasis_sound ("");
+				Config->set_click_emphasis_sound ("");
 			} else {
-				session->set_click_emphasis_sound (path);
+				Config->set_click_emphasis_sound (path);
 			}
 		}
 	}
diff --git a/gtk2_ardour/send_ui.cc b/gtk2_ardour/send_ui.cc
index 897f5f3847..88b8b304e4 100644
--- a/gtk2_ardour/send_ui.cc
+++ b/gtk2_ardour/send_ui.cc
@@ -113,7 +113,7 @@ SendUI::update ()
 void
 SendUI::fast_update ()
 {
-	if (_session.meter_falloff() > 0.0f) {
+	if (Config->get_meter_falloff() > 0.0f) {
 		gpm.update_meters ();
 	}
 }