X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fengine_dialog.cc;h=1389e815effe1579b3c06e196ce6a0465334a543;hb=6b1b72a247bf04c81292fc41af4f69c9b7f90379;hp=8e36e2a619f38e2669ebcf54d140bc3242bf9f44;hpb=34fe25c603588c6f97d7f2ef521fcdcaeadca33f;p=ardour.git

diff --git a/gtk2_ardour/engine_dialog.cc b/gtk2_ardour/engine_dialog.cc
index 8e36e2a619..1389e815ef 100644
--- a/gtk2_ardour/engine_dialog.cc
+++ b/gtk2_ardour/engine_dialog.cc
@@ -27,6 +27,7 @@
 #include <gtkmm/messagedialog.h>
 
 #include "pbd/error.h"
+#include "pbd/locale_guard.h"
 #include "pbd/xml++.h"
 #include "pbd/unwind.h"
 #include "pbd/failed_constructor.h"
@@ -52,14 +53,18 @@
 #include "ardour_ui.h"
 #include "engine_dialog.h"
 #include "gui_thread.h"
+#include "ui_config.h"
+#include "public_editor.h"
 #include "utils.h"
 #include "pbd/i18n.h"
+#include "splash.h"
 
 using namespace std;
 using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace PBD;
 using namespace Glib;
+using namespace ArdourWidgets;
 using namespace ARDOUR_UI_UTILS;
 
 #define DEBUG_ECONTROL(msg) DEBUG_TRACE (PBD::DEBUG::EngineControl, string_compose ("%1: %2\n", __LINE__, msg));
@@ -276,6 +281,8 @@ EngineControl::EngineControl ()
 	start_stop_button.set_sensitive (false);
 	start_stop_button.set_name ("generic button");
 	start_stop_button.set_can_focus(true);
+	start_stop_button.set_can_default(true);
+	start_stop_button.set_act_on_release (false);
 
 	update_devices_button.signal_clicked.connect (mem_fun (*this, &EngineControl::update_devices_button_clicked));
 	update_devices_button.set_sensitive (false);
@@ -287,9 +294,6 @@ EngineControl::EngineControl ()
 	use_buffered_io_button.set_name ("generic button");
 	use_buffered_io_button.set_can_focus(true);
 
-	cancel_button = add_button (Gtk::Stock::CLOSE, Gtk::RESPONSE_CANCEL);
-	ok_button = add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
-
 	/* Pick up any existing audio setup configuration, if appropriate */
 
 	XMLNode* audio_setup = ARDOUR::Config->extra_xml ("AudioMIDISetup");
@@ -398,8 +402,8 @@ EngineControl::unblock_changed_signals ()
 
 EngineControl::SignalBlocker::SignalBlocker (EngineControl& engine_control,
                                              const std::string& reason)
-    : ec (engine_control)
-    , m_reason (reason)
+	: ec (engine_control)
+	, m_reason (reason)
 {
 	DEBUG_ECONTROL (string_compose ("SignalBlocker: %1", m_reason));
 	ec.block_changed_signals ();
@@ -420,7 +424,20 @@ EngineControl::on_show ()
 		backend_changed ();
 	}
 	device_changed ();
-	ok_button->grab_focus();
+	start_stop_button.grab_focus();
+}
+
+void
+EngineControl::on_map ()
+{
+	if (!ARDOUR_UI::instance()->the_session () && !PublicEditor::_instance) {
+		set_type_hint (Gdk::WINDOW_TYPE_HINT_NORMAL);
+	} else if (UIConfiguration::instance().get_all_floating_windows_are_dialogs()) {
+		set_type_hint (Gdk::WINDOW_TYPE_HINT_DIALOG);
+	} else {
+		set_type_hint (Gdk::WINDOW_TYPE_HINT_UTILITY);
+	}
+	ArdourDialog::on_map ();
 }
 
 bool
@@ -459,49 +476,6 @@ EngineControl::stop_engine (bool for_latency)
 	return true;
 }
 
-void
-EngineControl::on_response (int response_id)
-{
-	ArdourDialog::on_response (response_id);
-
-	switch (response_id) {
-	case RESPONSE_OK:
-		if (!start_engine()) {
-			return;
-		} else {
-			hide();
-		}
-#ifdef PLATFORM_WINDOWS
-
-		// But if there's no session open, this can produce
-		// a long gap when nothing appears to be happening.
-		// Let's show the splash image while we're waiting.
-		if (!ARDOUR_COMMAND_LINE::no_splash) {
-			if (ARDOUR_UI::instance()) {
-				if (!ARDOUR_UI::instance()->session_loaded) {
-					ARDOUR_UI::instance()->show_splash();
-				}
-			}
-		}
-#endif
-		break;
-	case RESPONSE_DELETE_EVENT: {
-		GdkEventButton ev;
-		ev.type = GDK_BUTTON_PRESS;
-		ev.button = 1;
-		on_delete_event((GdkEventAny*)&ev);
-		break;
-	}
-	case RESPONSE_CANCEL:
-		if (ARDOUR_UI::instance() && ARDOUR_UI::instance()->session_loaded) {
-			ARDOUR_UI::instance()->check_audioengine(*this);
-		}
-	// fall through
-	default:
-		hide();
-	}
-}
-
 void
 EngineControl::build_notebook ()
 {
@@ -798,13 +772,13 @@ EngineControl::update_sensitivity ()
 {
 	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 	if (!backend) {
-		ok_button->set_sensitive (false);
 		start_stop_button.set_sensitive (false);
 		return;
 	}
 
 	bool valid = true;
 	size_t devices_available = 0;
+	bool engine_running = ARDOUR::AudioEngine::instance()->running();
 
 	if (backend->use_separate_input_and_output_devices ()) {
 		devices_available += get_popdown_string_count (input_device_combo);
@@ -822,29 +796,17 @@ EngineControl::update_sensitivity ()
 	} else {
 		input_latency.set_sensitive (true);
 		output_latency.set_sensitive (true);
-		input_channels.set_sensitive (true);
-		output_channels.set_sensitive (true);
+		input_channels.set_sensitive (!engine_running);
+		output_channels.set_sensitive (!engine_running);
 	}
 
 	if (get_popdown_string_count (buffer_size_combo) > 0) {
-		if (!ARDOUR::AudioEngine::instance()->running()) {
+		if (!engine_running) {
 			buffer_size_combo.set_sensitive (valid);
-		} else if (backend->can_change_sample_rate_when_running()) {
+		} else if (backend->can_change_buffer_size_when_running ()) {
 			buffer_size_combo.set_sensitive (valid || !_have_control);
 		} else {
-#if 1
-			/* TODO
-			 * Currently there is no way to manually stop the
-			 * engine in order to re-configure it.
-			 * This needs to remain sensitive for now.
-			 *
-			 * (it's also handy to implicily
-			 * re-start the engine)
-			 */
-			buffer_size_combo.set_sensitive (true);
-#else
 			buffer_size_combo.set_sensitive (false);
-#endif
 		}
 	} else {
 		buffer_size_combo.set_sensitive (false);
@@ -852,18 +814,24 @@ EngineControl::update_sensitivity ()
 	}
 
 	if (get_popdown_string_count (sample_rate_combo) > 0) {
-		if (!ARDOUR::AudioEngine::instance()->running()) {
-			sample_rate_combo.set_sensitive (true);
-		} else {
-			sample_rate_combo.set_sensitive (false);
+		bool allow_to_set_rate = false;
+		if (!engine_running) {
+			if (!ARDOUR_UI::instance()->the_session ()) {
+				// engine is not running, no session loaded -> anything goes.
+				allow_to_set_rate = true;
+			} else if (_desired_sample_rate > 0 && get_rate () != _desired_sample_rate) {
+				// only allow to change if the current setting is not the native session rate.
+				allow_to_set_rate = true;
+			}
 		}
+		sample_rate_combo.set_sensitive (allow_to_set_rate);
 	} else {
 		sample_rate_combo.set_sensitive (false);
 		valid = false;
 	}
 
 	if (get_popdown_string_count (nperiods_combo) > 0) {
-		if (!ARDOUR::AudioEngine::instance()->running()) {
+		if (!engine_running) {
 			nperiods_combo.set_sensitive (true);
 		} else {
 			nperiods_combo.set_sensitive (false);
@@ -875,7 +843,7 @@ EngineControl::update_sensitivity ()
 	if (_have_control) {
 		start_stop_button.set_sensitive(true);
 		start_stop_button.show();
-		if (ARDOUR::AudioEngine::instance()->running()) {
+		if (engine_running) {
 			start_stop_button.set_text("Stop");
 			update_devices_button.set_sensitive(false);
 			use_buffered_io_button.set_sensitive(false);
@@ -903,7 +871,7 @@ EngineControl::update_sensitivity ()
 		start_stop_button.hide();
 	}
 
-	if (ARDOUR::AudioEngine::instance()->running() && _have_control) {
+	if (engine_running && _have_control) {
 		input_device_combo.set_sensitive (false);
 		output_device_combo.set_sensitive (false);
 		device_combo.set_sensitive (false);
@@ -919,11 +887,7 @@ EngineControl::update_sensitivity ()
 		}
 	}
 
-	if (valid || !_have_control) {
-		ok_button->set_sensitive (true);
-	} else {
-		ok_button->set_sensitive (false);
-	}
+	midi_option_combo.set_sensitive (!engine_running);
 }
 
 void
@@ -1068,6 +1032,7 @@ EngineControl::backend_changed ()
 
 	if (!_have_control) {
 		// set settings from backend that we do have control over
+		set_buffersize_popdown_strings ();
 		set_active_text_if_present (buffer_size_combo, bufsize_as_string (backend->buffer_size()));
 	}
 
@@ -1075,9 +1040,14 @@ EngineControl::backend_changed ()
 		// set driver & devices
 		State state = get_matching_state (backend_combo.get_active_text());
 		if (state) {
+			DEBUG_ECONTROL ("backend-changed(): found prior state for backend");
 			PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
 			set_current_state (state);
+		} else {
+			DEBUG_ECONTROL ("backend-changed(): no prior state for backend");
 		}
+	} else {
+		DEBUG_ECONTROL (string_compose ("backend-changed(): _have_control=%1 ignore_changes=%2", _have_control, ignore_changes));
 	}
 
 	if (!ignore_changes) {
@@ -1392,7 +1362,17 @@ EngineControl::set_samplerate_popdown_strings ()
 	set_popdown_strings (sample_rate_combo, s);
 
 	if (!s.empty()) {
-		if (desired.empty ()) {
+		if (ARDOUR::AudioEngine::instance()->running()) {
+			sample_rate_combo.set_active_text (rate_as_string (backend->sample_rate()));
+		} else if (ARDOUR_UI::instance()->the_session ()) {
+			float active_sr = ARDOUR_UI::instance()->the_session()->nominal_sample_rate ();
+
+			if (std::find (sr.begin (), sr.end (), active_sr) == sr.end ()) {
+				active_sr = sr.front ();
+			}
+
+			sample_rate_combo.set_active_text (rate_as_string (active_sr));
+		} else if (desired.empty ()) {
 			float new_active_sr = backend->default_sample_rate ();
 
 			if (std::find (sr.begin (), sr.end (), new_active_sr) == sr.end ()) {
@@ -1403,7 +1383,6 @@ EngineControl::set_samplerate_popdown_strings ()
 		} else {
 			sample_rate_combo.set_active_text (desired);
 		}
-
 	}
 	update_sensitivity ();
 }
@@ -1459,7 +1438,7 @@ EngineControl::set_buffersize_popdown_strings ()
 		s.push_back (bufsize_as_string (*x));
 	}
 
-	uint32_t previous_size = 0;
+	uint32_t previous_size = backend->buffer_size ();
 	if (!buffer_size_combo.get_active_text().empty()) {
 		previous_size = get_buffer_size ();
 	}
@@ -1505,13 +1484,13 @@ EngineControl::set_nperiods_popdown_strings ()
 	}
 
 	for (vector<uint32_t>::const_iterator x = np.begin(); x != np.end(); ++x) {
-		s.push_back (nperiods_as_string (*x));
+		s.push_back (to_string (*x));
 	}
 
 	set_popdown_strings (nperiods_combo, s);
 
 	if (!s.empty()) {
-		set_active_text_if_present (nperiods_combo, nperiods_as_string (backend->period_size())); // XXX 
+		set_active_text_if_present (nperiods_combo, to_string (backend->period_size())); // XXX
 	}
 
 	update_sensitivity ();
@@ -1583,6 +1562,24 @@ void
 EngineControl::input_device_changed ()
 {
 	DEBUG_ECONTROL ("input_device_changed");
+
+	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	if (backend && backend->match_input_output_devices_or_none ()) {
+		const std::string& dev_none = ARDOUR::AudioBackend::get_standard_device_name (ARDOUR::AudioBackend::DeviceNone);
+
+		if (get_output_device_name () != dev_none
+				&& get_input_device_name () != dev_none
+				&& get_input_device_name () != get_output_device_name ()) {
+			block_changed_signals ();
+			if (contains_value (output_device_combo, get_input_device_name ())) {
+				output_device_combo.set_active_text (get_input_device_name ());
+			} else {
+				assert (contains_value (output_device_combo, dev_none));
+				output_device_combo.set_active_text (dev_none);
+			}
+			unblock_changed_signals ();
+		}
+	}
 	device_changed ();
 }
 
@@ -1590,24 +1587,32 @@ void
 EngineControl::output_device_changed ()
 {
 	DEBUG_ECONTROL ("output_device_changed");
+	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	if (backend && backend->match_input_output_devices_or_none ()) {
+		const std::string& dev_none = ARDOUR::AudioBackend::get_standard_device_name (ARDOUR::AudioBackend::DeviceNone);
+
+		if (get_input_device_name () != dev_none
+				&& get_input_device_name () != dev_none
+				&& get_input_device_name () != get_output_device_name ()) {
+			block_changed_signals ();
+			if (contains_value (input_device_combo, get_output_device_name ())) {
+				input_device_combo.set_active_text (get_output_device_name ());
+			} else {
+				assert (contains_value (input_device_combo, dev_none));
+				input_device_combo.set_active_text (dev_none);
+			}
+			unblock_changed_signals ();
+		}
+	}
 	device_changed ();
 }
 
 string
 EngineControl::bufsize_as_string (uint32_t sz)
 {
-	return string_compose (P_("%1 sample", "%1 samples", sz), sz);
+	return string_compose (P_("%1 sample", "%1 samples", sz), to_string(sz));
 }
 
-string
-EngineControl::nperiods_as_string (uint32_t np)
-{
-	char buf[8];
-	snprintf (buf, sizeof (buf), "%u", np);
-	return buf;
-}
-
-
 void
 EngineControl::sample_rate_changed ()
 {
@@ -1624,6 +1629,12 @@ void
 EngineControl::buffer_size_changed ()
 {
 	DEBUG_ECONTROL ("buffer_size_changed");
+	if (ARDOUR::AudioEngine::instance()->running()) {
+		boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+		if (backend && backend->can_change_buffer_size_when_running ()) {
+			backend->set_buffer_size (get_buffer_size());
+		}
+	}
 	show_buffer_duration ();
 }
 
@@ -1788,6 +1799,7 @@ bool EngineControl::equivalent_states (const EngineControl::State& state1,
 	return false;
 }
 
+// sort active first, then most recently used to the beginning of the list
 bool
 EngineControl::state_sort_cmp (const State &a, const State &b) {
 	if (a->active) {
@@ -1797,7 +1809,7 @@ EngineControl::state_sort_cmp (const State &a, const State &b) {
 		return false;
 	}
 	else {
-		return a->lru < b->lru;
+		return a->lru > b->lru;
 	}
 }
 
@@ -1858,7 +1870,7 @@ EngineControl::store_state (State state)
 void
 EngineControl::maybe_display_saved_state ()
 {
-	if (!_have_control) {
+	if (!_have_control || ARDOUR::AudioEngine::instance()->running ()) {
 		return;
 	}
 
@@ -1868,12 +1880,12 @@ EngineControl::maybe_display_saved_state ()
 		DEBUG_ECONTROL ("Restoring saved state");
 		PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
 
-		if (!_desired_sample_rate) {
+		if (0 == _desired_sample_rate && sample_rate_combo.get_sensitive ()) {
 			sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
 		}
 		set_active_text_if_present (buffer_size_combo, bufsize_as_string (state->buffer_size));
 
-		set_active_text_if_present (nperiods_combo, nperiods_as_string (state->n_periods));
+		set_active_text_if_present (nperiods_combo, to_string(state->n_periods));
 		/* call this explicitly because we're ignoring changes to
 		   the controls at this point.
 		 */
@@ -1907,30 +1919,31 @@ EngineControl::get_state ()
 
 			XMLNode* node = new XMLNode ("State");
 
-			node->add_property ("backend", (*i)->backend);
-			node->add_property ("driver", (*i)->driver);
-			node->add_property ("device", (*i)->device);
-			node->add_property ("input-device", (*i)->input_device);
-			node->add_property ("output-device", (*i)->output_device);
-			node->add_property ("sample-rate", (*i)->sample_rate);
-			node->add_property ("buffer-size", (*i)->buffer_size);
-			node->add_property ("n-periods", (*i)->n_periods);
-			node->add_property ("input-latency", (*i)->input_latency);
-			node->add_property ("output-latency", (*i)->output_latency);
-			node->add_property ("input-channels", (*i)->input_channels);
-			node->add_property ("output-channels", (*i)->output_channels);
-			node->add_property ("active", (*i)->active ? "yes" : "no");
-			node->add_property ("use-buffered-io", (*i)->use_buffered_io ? "yes" : "no");
-			node->add_property ("midi-option", (*i)->midi_option);
-			node->add_property ("lru", (*i)->active ? time (NULL) : (*i)->lru);
+			node->set_property ("backend", (*i)->backend);
+			node->set_property ("driver", (*i)->driver);
+			node->set_property ("device", (*i)->device);
+			node->set_property ("input-device", (*i)->input_device);
+			node->set_property ("output-device", (*i)->output_device);
+			node->set_property ("sample-rate", (*i)->sample_rate);
+			node->set_property ("buffer-size", (*i)->buffer_size);
+			node->set_property ("n-periods", (*i)->n_periods);
+			node->set_property ("input-latency", (*i)->input_latency);
+			node->set_property ("output-latency", (*i)->output_latency);
+			node->set_property ("input-channels", (*i)->input_channels);
+			node->set_property ("output-channels", (*i)->output_channels);
+			node->set_property ("active", (*i)->active);
+			node->set_property ("use-buffered-io", (*i)->use_buffered_io);
+			node->set_property ("midi-option", (*i)->midi_option);
+			int32_t lru_val = (*i)->active ? time (NULL) : (*i)->lru;
+			node->set_property ("lru", lru_val );
 
 			XMLNode* midi_devices = new XMLNode ("MIDIDevices");
 			for (std::vector<MidiDeviceSettings>::const_iterator p = (*i)->midi_devices.begin(); p != (*i)->midi_devices.end(); ++p) {
 				XMLNode* midi_device_stuff = new XMLNode ("MIDIDevice");
-				midi_device_stuff->add_property (X_("name"), (*p)->name);
-				midi_device_stuff->add_property (X_("enabled"), (*p)->enabled);
-				midi_device_stuff->add_property (X_("input-latency"), (*p)->input_latency);
-				midi_device_stuff->add_property (X_("output-latency"), (*p)->output_latency);
+				midi_device_stuff->set_property (X_("name"), (*p)->name);
+				midi_device_stuff->set_property (X_("enabled"), (*p)->enabled);
+				midi_device_stuff->set_property (X_("input-latency"), (*p)->input_latency);
+				midi_device_stuff->set_property (X_("output-latency"), (*p)->output_latency);
 				midi_devices->add_child_nocopy (*midi_device_stuff);
 			}
 			node->add_child_nocopy (*midi_devices);
@@ -1967,7 +1980,6 @@ EngineControl::set_state (const XMLNode& root)
 	XMLNodeConstIterator citer, cciter;
 	XMLNode const * child;
 	XMLNode const * grandchild;
-	XMLProperty const * prop = NULL;
 
 	if (root.name() != "AudioMIDISetup") {
 		return false;
@@ -1996,132 +2008,68 @@ EngineControl::set_state (const XMLNode& root)
 				continue;
 			}
 
-			if ((prop = grandchild->property ("backend")) == 0) {
+			if (!grandchild->get_property ("backend", state->backend)) {
 				continue;
 			}
-			state->backend = prop->value ();
 
-			if ((prop = grandchild->property ("driver")) == 0) {
+			// If any of the required properties are not found in the state node
+			// then continue/skip to the next engine state
+			if (!grandchild->get_property ("driver", state->driver) ||
+			    !grandchild->get_property ("device", state->device) ||
+			    !grandchild->get_property ("input-device", state->input_device) ||
+			    !grandchild->get_property ("output-device", state->output_device) ||
+			    !grandchild->get_property ("sample-rate", state->sample_rate) ||
+			    !grandchild->get_property ("buffer-size", state->buffer_size) ||
+			    !grandchild->get_property ("input-latency", state->input_latency) ||
+			    !grandchild->get_property ("output-latency", state->output_latency) ||
+			    !grandchild->get_property ("input-channels", state->input_channels) ||
+			    !grandchild->get_property ("output-channels", state->output_channels) ||
+			    !grandchild->get_property ("active", state->active) ||
+			    !grandchild->get_property ("use-buffered-io", state->use_buffered_io) ||
+			    !grandchild->get_property ("midi-option", state->midi_option)) {
 				continue;
 			}
-			state->driver = prop->value ();
 
-			if ((prop = grandchild->property ("device")) == 0) {
-				continue;
-			}
-			state->device = prop->value ();
-
-			if ((prop = grandchild->property ("input-device")) == 0) {
-				continue;
-			}
-			state->input_device = prop->value ();
-
-			if ((prop = grandchild->property ("output-device")) == 0) {
-				continue;
-			}
-			state->output_device = prop->value ();
-
-			if ((prop = grandchild->property ("sample-rate")) == 0) {
-				continue;
-			}
-			state->sample_rate = atof (prop->value ());
-
-			if ((prop = grandchild->property ("buffer-size")) == 0) {
-				continue;
-			}
-			state->buffer_size = atoi (prop->value ());
-
-			if ((prop = grandchild->property ("n-periods")) == 0) {
+			if (!grandchild->get_property ("n-periods", state->n_periods)) {
 				// optional (new value in 4.5)
 				state->n_periods = 0;
-			} else {
-				state->n_periods = atoi (prop->value ());
-			}
-
-			if ((prop = grandchild->property ("input-latency")) == 0) {
-				continue;
-			}
-			state->input_latency = atoi (prop->value ());
-
-			if ((prop = grandchild->property ("output-latency")) == 0) {
-				continue;
-			}
-			state->output_latency = atoi (prop->value ());
-
-			if ((prop = grandchild->property ("input-channels")) == 0) {
-				continue;
-			}
-			state->input_channels = atoi (prop->value ());
-
-			if ((prop = grandchild->property ("output-channels")) == 0) {
-				continue;
-			}
-			state->output_channels = atoi (prop->value ());
-
-			if ((prop = grandchild->property ("active")) == 0) {
-				continue;
-			}
-			state->active = string_is_affirmative (prop->value ());
-
-			if ((prop = grandchild->property ("use-buffered-io")) == 0) {
-				continue;
 			}
-			state->use_buffered_io = string_is_affirmative (prop->value ());
-
-			if ((prop = grandchild->property ("midi-option")) == 0) {
-				continue;
-			}
-			state->midi_option = prop->value ();
 
 			state->midi_devices.clear();
 			XMLNode* midinode;
 			if ((midinode = ARDOUR::find_named_node (*grandchild, "MIDIDevices")) != 0) {
 				const XMLNodeList mnc = midinode->children();
 				for (XMLNodeList::const_iterator n = mnc.begin(); n != mnc.end(); ++n) {
-					if ((*n)->property (X_("name")) == 0
-							|| (*n)->property (X_("enabled")) == 0
-							|| (*n)->property (X_("input-latency")) == 0
-							|| (*n)->property (X_("output-latency")) == 0
-						 ) {
+					std::string name;
+					bool enabled;
+					uint32_t input_latency;
+					uint32_t output_latency;
+
+					if (!(*n)->get_property (X_("name"), name) ||
+					    !(*n)->get_property (X_("enabled"), enabled) ||
+					    !(*n)->get_property (X_("input-latency"), input_latency) ||
+					    !(*n)->get_property (X_("output-latency"), output_latency)) {
 						continue;
 					}
 
-					MidiDeviceSettings ptr (new MidiDeviceSetting(
-								(*n)->property (X_("name"))->value (),
-								string_is_affirmative ((*n)->property (X_("enabled"))->value ()),
-								atoi ((*n)->property (X_("input-latency"))->value ()),
-								atoi ((*n)->property (X_("output-latency"))->value ())
-								));
+					MidiDeviceSettings ptr (
+					    new MidiDeviceSetting (name, enabled, input_latency, output_latency));
 					state->midi_devices.push_back (ptr);
 				}
 			}
 
-			if ((prop = grandchild->property ("lru"))) {
-				state->lru = atoi (prop->value ());
+			int32_t lru_val;
+			if (grandchild->get_property ("lru", lru_val)) {
+				state->lru = lru_val;
 			}
 
-#if 1
-			/* remove accumulated duplicates (due to bug in ealier version)
-			 * this can be removed again before release
-			 */
-			for (StateList::iterator i = states.begin(); i != states.end();) {
-				if ((*i)->backend == state->backend &&
-						(*i)->driver == state->driver &&
-						(*i)->device == state->device) {
-					i =  states.erase(i);
-				} else {
-					++i;
-				}
-			}
-#endif
-
 			states.push_back (state);
 		}
 	}
 
 	/* now see if there was an active state and switch the setup to it */
 
-	// purge states of backend that are not available in this built
+	/* purge states of backend that are not available in this built */
 	vector<const ARDOUR::AudioBackendInfo*> backends = ARDOUR::AudioEngine::instance()->available_backends();
 	vector<std::string> backend_names;
 
@@ -2138,6 +2086,28 @@ EngineControl::set_state (const XMLNode& root)
 
 	states.sort (state_sort_cmp);
 
+	/* purge old states referring to the same backend */
+	const time_t now = time (NULL);
+	for (vector<std::string>::const_iterator bi = backend_names.begin(); bi != backend_names.end(); ++bi) {
+		bool first = true;
+		for (StateList::iterator i = states.begin(); i != states.end();) {
+			if ((*i)->backend != *bi) {
+				++i; continue;
+			}
+			// keep at latest one for every audio-system
+			if (first) {
+				first = false;
+				++i; continue;
+			}
+			// also keep states used in the last 90 days.
+			if ((now - (*i)->lru) < 86400 * 90) {
+				++i; continue;
+			}
+			assert (!(*i)->active);
+			i = states.erase(i);
+		}
+	}
+
 	for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
 
 		if ((*i)->active) {
@@ -2235,9 +2205,11 @@ EngineControl::set_current_state (const State& state)
 	device_combo.set_active_text (state->device);
 	input_device_combo.set_active_text (state->input_device);
 	output_device_combo.set_active_text (state->output_device);
-	sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
+	if (0 == _desired_sample_rate && sample_rate_combo.get_sensitive ()) {
+		sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
+	}
 	set_active_text_if_present (buffer_size_combo, bufsize_as_string (state->buffer_size));
-	set_active_text_if_present (nperiods_combo, nperiods_as_string (state->n_periods));
+	set_active_text_if_present (nperiods_combo, to_string (state->n_periods));
 	input_latency.set_value (state->input_latency);
 	output_latency.set_value (state->output_latency);
 	midi_option_combo.set_active_text (state->midi_option);
@@ -2712,7 +2684,15 @@ EngineControl::start_stop_button_clicked ()
 	if (ARDOUR::AudioEngine::instance()->running()) {
 		ARDOUR::AudioEngine::instance()->stop ();
 	} else {
+		if (!ARDOUR_UI::instance()->the_session ()) {
+			pop_splash ();
+			hide ();
+			ARDOUR::GUIIdle ();
+		}
 		start_engine ();
+		if (!ARDOUR_UI::instance()->the_session ()) {
+			ArdourDialog::on_response (RESPONSE_OK);
+		}
 	}
 }
 
@@ -2777,12 +2757,8 @@ void
 EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
 {
 	if (page_num == 0) {
-		cancel_button->set_sensitive (true);
 		_measure_midi.reset();
 		update_sensitivity ();
-	} else {
-		cancel_button->set_sensitive (false);
-		ok_button->set_sensitive (false);
 	}
 
 	if (page_num == midi_tab) {
@@ -2863,7 +2839,7 @@ EngineControl::check_audio_latency_measurement ()
 	}
 
 	char buf[256];
-	ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
+	ARDOUR::samplecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
 
 	if (sample_rate == 0) {
 		lm_results.set_markup (string_compose (results_markup, _("Disconnected from audio engine")));
@@ -2871,12 +2847,12 @@ EngineControl::check_audio_latency_measurement ()
 		return false;
 	}
 
-	int frames_total = mtdm->del();
-	int extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
+	int samples_total = mtdm->del();
+	int extra = samples_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
 
 	snprintf (buf, sizeof (buf), "%s%d samples (%.3lf ms)\n%s%d samples (%.3lf ms)",
 			_("Detected roundtrip latency: "),
-			frames_total, frames_total * 1000.0f/sample_rate,
+			samples_total, samples_total * 1000.0f/sample_rate,
 			_("Systemic latency: "),
 			extra, extra * 1000.0f/sample_rate);
 
@@ -2917,7 +2893,7 @@ EngineControl::check_midi_latency_measurement ()
 	}
 
 	char buf[256];
-	ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
+	ARDOUR::samplecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
 
 	if (sample_rate == 0) {
 		lm_results.set_markup (string_compose (results_markup, _("Disconnected from audio engine")));
@@ -2925,11 +2901,11 @@ EngineControl::check_midi_latency_measurement ()
 		return false;
 	}
 
-	ARDOUR::framecnt_t frames_total = mididm->latency();
-	ARDOUR::framecnt_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
+	ARDOUR::samplecnt_t samples_total = mididm->latency();
+	ARDOUR::samplecnt_t extra = samples_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
 	snprintf (buf, sizeof (buf), "%s%" PRId64" samples (%.1lf ms) dev: %.2f[spl]\n%s%" PRId64" samples (%.1lf ms)",
 			_("Detected roundtrip latency: "),
-			frames_total, frames_total * 1000.0f / sample_rate, mididm->deviation (),
+			samples_total, samples_total * 1000.0f / sample_rate, mididm->deviation (),
 			_("Systemic latency: "),
 			extra, extra * 1000.0f / sample_rate);
 
@@ -3017,23 +2993,28 @@ EngineControl::latency_button_clicked ()
 void
 EngineControl::latency_back_button_clicked ()
 {
-	ARDOUR::AudioEngine::instance()->stop(true);
+	ARDOUR::AudioEngine::instance()->stop_latency_detection ();
 	notebook.set_current_page(0);
 }
 
 void
 EngineControl::use_latency_button_clicked ()
 {
+	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 	if (_measure_midi) {
 		ARDOUR::MIDIDM* mididm = ARDOUR::AudioEngine::instance()->mididm ();
 		if (!mididm) {
 			return;
 		}
-		ARDOUR::framecnt_t frames_total = mididm->latency();
-		ARDOUR::framecnt_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
-		uint32_t one_way = max ((ARDOUR::framecnt_t) 0, extra / 2);
+		ARDOUR::samplecnt_t samples_total = mididm->latency();
+		ARDOUR::samplecnt_t extra = samples_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
+		uint32_t one_way = max ((ARDOUR::samplecnt_t) 0, extra / 2);
 		_measure_midi->input_latency = one_way;
 		_measure_midi->output_latency = one_way;
+		if (backend->can_change_systemic_latency_when_running ()) {
+			backend->set_systemic_midi_input_latency (_measure_midi->name, one_way);
+			backend->set_systemic_midi_output_latency (_measure_midi->name, one_way);
+		}
 		notebook.set_current_page (midi_tab);
 	} else {
 		MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
@@ -3047,6 +3028,10 @@ EngineControl::use_latency_button_clicked ()
 
 		input_latency_adjustment.set_value (one_way);
 		output_latency_adjustment.set_value (one_way);
+		if (backend->can_change_systemic_latency_when_running ()) {
+			backend->set_systemic_input_latency (one_way);
+			backend->set_systemic_output_latency (one_way);
+		}
 
 		/* back to settings page */
 		notebook.set_current_page (0);
@@ -3073,7 +3058,7 @@ EngineControl::engine_running ()
 	sample_rate_combo.set_active_text (rate_as_string (backend->sample_rate()));
 
 	if (backend->can_set_period_size ()) {
-		set_active_text_if_present (nperiods_combo, nperiods_as_string (backend->period_size()));
+		set_active_text_if_present (nperiods_combo, to_string (backend->period_size()));
 	}
 
 	connect_disconnect_button.set_label (string_compose (_("Disconnect from %1"), backend->name()));
@@ -3123,7 +3108,15 @@ EngineControl::connect_disconnect_click()
 	if (ARDOUR::AudioEngine::instance()->running()) {
 		stop_engine ();
 	} else {
+		if (!ARDOUR_UI::instance()->the_session ()) {
+			pop_splash ();
+			hide ();
+			ARDOUR::GUIIdle ();
+		}
 		start_engine ();
+		if (!ARDOUR_UI::instance()->the_session ()) {
+			ArdourDialog::on_response (RESPONSE_OK);
+		}
 	}
 }