Merge branch 'windows' of git.ardour.org:ardour/ardour into windows

19 files changed, 806 insertions, 362 deletions

diff --git a/gtk2_ardour/ardour.menus.in b/gtk2_ardour/ardour.menus.in
index 197b484698..9694556e56 100644
--- a/gtk2_ardour/ardour.menus.in
+++ b/gtk2_ardour/ardour.menus.in
@@ -494,21 +494,6 @@
       <menuitem action='ToggleGroupTabs'/>
       <menuitem action='show-marker-lines'/>
     </menu>
-    <menu name='JACK' action='JACK'>
-      <menuitem action='EngineDisconnect'/>
-      <menuitem action='EngineReconnect'/>
-      <menu name='Latency' action='Latency'>
-        <menuitem action='EngineLatency32'/>
-        <menuitem action='EngineLatency64'/>
-        <menuitem action='EngineLatency128'/>
-        <menuitem action='EngineLatency256'/>
-        <menuitem action='EngineLatency512'/>
-        <menuitem action='EngineLatency1024'/>
-        <menuitem action='EngineLatency2048'/>
-        <menuitem action='EngineLatency4096'/>
-        <menuitem action='EngineLatency8192'/>
-      </menu>
-    </menu>
     <menu action = 'WindowMenu'>
       <menuitem action='toggle-audio-midi-setup'/>
       <separator/>
diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index 50a903cf6c..5dde7f977e 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -3798,7 +3798,7 @@ audio may be played at the wrong sample rate.\n"), desired, PROGRAM_NAME, actual
         return 1;
 }
 
-void
+int
 ARDOUR_UI::disconnect_from_engine ()
 {
 	/* drop connection to AudioEngine::Halted so that we don't act
@@ -3807,24 +3807,28 @@ ARDOUR_UI::disconnect_from_engine ()
 	halt_connection.disconnect ();
 	
 	if (AudioEngine::instance()->stop ()) {
-		MessageDialog msg (*editor, _("Could not disconnect from JACK"));
+		MessageDialog msg (*editor, _("Could not disconnect from Audio/MIDI engine"));
 		msg.run ();
+		return -1;
 	} else {
 		AudioEngine::instance()->Halted.connect_same_thread (halt_connection, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
 	}
 	
 	update_sample_rate (0);
+	return 0;
 }
 
-void
+int
 ARDOUR_UI::reconnect_to_engine ()
 {
 	if (AudioEngine::instance()->start ()) {
-		MessageDialog msg (*editor,  _("Could not reconnect to JACK"));
+		MessageDialog msg (*editor,  _("Could not reconnect to the Audio/MIDI engine"));
 		msg.run ();
+		return -1;
 	}
 	
 	update_sample_rate (0);
+	return 0;
 }
 
 void
@@ -4166,9 +4170,7 @@ ARDOUR_UI::do_audio_midi_setup (uint32_t desired_sample_rate)
 
 	_audio_midi_setup->set_desired_sample_rate (desired_sample_rate);
 
-	int r = _audio_midi_setup->run ();
-
-	switch (r) {
+	switch (_audio_midi_setup->run()) {
 	case Gtk::RESPONSE_OK:
 		return 0;
 	case Gtk::RESPONSE_APPLY:
diff --git a/gtk2_ardour/ardour_ui.h b/gtk2_ardour/ardour_ui.h
index 64309c7e38..0ca8cde907 100644
--- a/gtk2_ardour/ardour_ui.h
+++ b/gtk2_ardour/ardour_ui.h
@@ -289,6 +289,9 @@ class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
 
         const std::string& announce_string() const { return _announce_string; }
 
+        int disconnect_from_engine ();
+        int reconnect_to_engine ();
+
   protected:
 	friend class PublicEditor;
 
@@ -667,8 +670,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
 	int pending_state_dialog ();
 	int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 
-	void disconnect_from_engine ();
-	void reconnect_to_engine ();
 	void set_engine_buffer_size (ARDOUR::pframes_t);
 
 	Gtk::MenuItem* jack_disconnect_item;
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index 53ea7c02de..b64498fb33 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -183,39 +183,6 @@ ARDOUR_UI::install_actions ()
 	ActionManager::write_sensitive_actions.push_back (act);
 	ActionManager::session_sensitive_actions.push_back (act);
 
-	/* AudioEngine actions */
-
-	Glib::RefPtr<ActionGroup> engine_actions = ActionGroup::create (X_("Audio"));
-	ActionManager::register_action (engine_actions, X_("JACK"), _("JACK"));
-	ActionManager::register_action (engine_actions, X_("Latency"), _("Latency"));
-
-	act = ActionManager::register_action (engine_actions, X_("EngineReconnect"), _("Reconnect"), sigc::mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_engine));
-	ActionManager::engine_opposite_sensitive_actions.push_back (act);
-
-	act = ActionManager::register_action (engine_actions, X_("EngineDisconnect"), _("Disconnect"), sigc::mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_engine));
-	ActionManager::engine_sensitive_actions.push_back (act);
-
-	RadioAction::Group latency_group;
-
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency32"), X_("32"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 32));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency64"), X_("64"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 64));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency128"), X_("128"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 128));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency256"), X_("256"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 256));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency512"), X_("512"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 512));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency1024"), X_("1024"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 1024));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency2048"), X_("2048"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 2048));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency4096"), X_("4096"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 4096));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency8192"), X_("8192"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 8192));
-	ActionManager::engine_sensitive_actions.push_back (act);
-
 	/* these actions are intended to be shared across all windows */
 
 	common_actions = ActionGroup::create (X_("Common"));
@@ -422,7 +389,6 @@ ARDOUR_UI::install_actions ()
 
 	ActionManager::add_action_group (shuttle_actions);
 	ActionManager::add_action_group (option_actions);
-	ActionManager::add_action_group (engine_actions);
 	ActionManager::add_action_group (transport_actions);
 	ActionManager::add_action_group (main_actions);
 	ActionManager::add_action_group (main_menu_actions);
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index a0418892e7..fc4b6f4d6c 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -365,6 +365,7 @@ Editor::Editor ()
 	location_loop_color = ARDOUR_UI::config()->canvasvar_LocationLoop.get();
 	location_punch_color = ARDOUR_UI::config()->canvasvar_LocationPunch.get();
 
+	zoom_focus = ZoomFocusLeft;
 	_edit_point = EditAtMouse;
 	_internal_editing = false;
 	current_canvas_cursor = 0;
@@ -373,8 +374,6 @@ Editor::Editor ()
 
 	_scroll_callbacks = 0;
 
-	zoom_focus = ZoomFocusLeft;
-	set_zoom_focus (ZoomFocusLeft);
 	zoom_range_clock->ValueChanged.connect (sigc::mem_fun(*this, &Editor::zoom_adjustment_changed));
 
 	bbt_label.set_name ("EditorRulerLabel");
@@ -635,6 +634,7 @@ Editor::Editor ()
 
 	setup_toolbar ();
 
+	set_zoom_focus (zoom_focus);
 	_snap_type = SnapToBeat;
 	set_snap_to (_snap_type);
 	_snap_mode = SnapOff;
diff --git a/gtk2_ardour/engine_dialog.cc b/gtk2_ardour/engine_dialog.cc
index d724f4f4d3..65fa7227a7 100644
--- a/gtk2_ardour/engine_dialog.cc
+++ b/gtk2_ardour/engine_dialog.cc
@@ -31,6 +31,7 @@
 #include "pbd/xml++.h"
 #include "pbd/unwind.h"
 
+#include <gtkmm/alignment.h>
 #include <gtkmm/stock.h>
 #include <gtkmm/notebook.h>
 #include <gtkmm2ext/utils.h>
@@ -44,6 +45,7 @@
 #include "pbd/convert.h"
 #include "pbd/error.h"
 
+#include "ardour_ui.h"
 #include "engine_dialog.h"
 #include "gui_thread.h"
 #include "i18n.h"
@@ -56,6 +58,7 @@ using namespace Glib;
 
 EngineControl::EngineControl ()
 	: ArdourDialog (_("Audio/MIDI Setup"))
+	, basic_packer (9, 3)
 	, input_latency_adjustment (0, 0, 99999, 1)
 	, input_latency (input_latency_adjustment)
 	, output_latency_adjustment (0, 0, 99999, 1)
@@ -66,14 +69,24 @@ EngineControl::EngineControl ()
 	, output_channels (output_channels_adjustment)
 	, ports_adjustment (128, 8, 1024, 1, 16)
 	, ports_spinner (ports_adjustment)
-	, control_app_button (_("Launch Control App"))
-	, lm_measure_button (_("Measure latency"))
+	, control_app_button (_("Device Control Panel"))
+	, lm_start_stop_label (_("Measure latency"))
 	, lm_use_button (_("Use results"))
 	, lm_table (5, 2)
-	, basic_packer (9, 3)
+	, have_lm_results (false)
+	, midi_refresh_button (_("Refresh list"))
+	, aj_button (_("Start MIDI ALSA/JACK bridge"))
 	, ignore_changes (0)
 	, _desired_sample_rate (0)
 {
+	if (!ARDOUR::AudioEngine::instance()->setup_required()) {
+		_have_control = false;
+	} else {
+		_have_control = true;
+	}
+
+	set_name (X_("AudioMIDISetup"));
+
 	build_notebook ();
 
 	get_vbox()->set_border_width (12);
@@ -82,9 +95,9 @@ EngineControl::EngineControl ()
 	control_app_button.signal_clicked().connect (mem_fun (*this, &EngineControl::control_app_button_clicked));
 	manage_control_app_sensitivity ();
 
-	add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-	add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
-	add_button (Gtk::Stock::APPLY, Gtk::RESPONSE_APPLY);
+	cancel_button = add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
+	ok_button = add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
+	apply_button = add_button (Gtk::Stock::APPLY, Gtk::RESPONSE_APPLY);
 
 	/* Pick up any existing audio setup configuration, if appropriate */
 
@@ -111,6 +124,13 @@ EngineControl::on_response (int response_id)
 		push_state_to_backend (true);
 		hide ();
 		break;
+	case RESPONSE_DELETE_EVENT: {
+		GdkEventButton ev;
+		ev.type = GDK_BUTTON_PRESS;
+		ev.button = 1;
+		on_delete_event ((GdkEventAny*) &ev);
+		break;
+	}
 	default:
 		hide ();
 	}
@@ -168,18 +188,33 @@ EngineControl::build_notebook ()
 	basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
 	row++;
 
+	input_channels.set_name ("InputChannels");
+	input_channels.set_flags(Gtk::CAN_FOCUS);
+	input_channels.set_digits(0);
+	input_channels.set_wrap(false);
+	output_channels.set_editable (true);
 
 	label = manage (left_aligned_label (_("Input Channels:")));
 	basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 	basic_packer.attach (input_channels, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 
+	output_channels.set_name ("OutputChannels");
+	output_channels.set_flags(Gtk::CAN_FOCUS);
+	output_channels.set_digits(0);
+	output_channels.set_wrap(false);
+	output_channels.set_editable (true);
 
 	label = manage (left_aligned_label (_("Output Channels:")));
 	basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 	basic_packer.attach (output_channels, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 
+	input_latency.set_name ("InputLatency");
+	input_latency.set_flags(Gtk::CAN_FOCUS);
+	input_latency.set_digits(0);
+	input_latency.set_wrap(false);
+	input_latency.set_editable (true);
 
 	label = manage (left_aligned_label (_("Hardware input latency:")));
 	basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
@@ -188,6 +223,12 @@ EngineControl::build_notebook ()
 	basic_packer.attach (*label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 
+	output_latency.set_name ("OutputLatency");
+	output_latency.set_flags(Gtk::CAN_FOCUS);
+	output_latency.set_digits(0);
+	output_latency.set_wrap(false);
+	output_latency.set_editable (true);
+
 	label = manage (left_aligned_label (_("Hardware output latency:")));
 	basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 	basic_packer.attach (output_latency, 1, 2, row, row+1, xopt, (AttachOptions) 0);
@@ -205,8 +246,6 @@ EngineControl::build_notebook ()
 	control_app_button.show();
 	basic_vbox.pack_start (*hpacker);
 
-	midi_packer.set_border_width (12);
-
 	/* latency measurement tab */
 	
 	lm_title.set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("Latency Measurement Tool")));
@@ -217,48 +256,81 @@ EngineControl::build_notebook ()
 	lm_table.attach (lm_title, 0, 2, row, row+1, xopt, (AttachOptions) 0);
 	row++;
 
-	lm_preamble.set_width_chars (60);
-	lm_preamble.set_line_wrap (true);
-	lm_preamble.set_markup (_("1. <span weight=\"bold\">Turn down the volume on your hardware to a very low level.</span>\n\n\
-2. Connect the two channels that you select below using either a cable or (less ideally) a speaker \
-and microphone.\n\n\
-3. Once the channels are connected, click the \"Measure latency\" button.\n\n\
-4. When satisfied with the results, click the \"Use results\" button."));
+	Gtk::Label* preamble;
+
+	preamble = manage (new Label);
+	preamble->set_width_chars (60);
+	preamble->set_line_wrap (true);
+	preamble->set_markup (_("<span weight=\"bold\">Turn down the volume on your hardware to a very low level.</span>"));
+
+	lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	row++;
+
+	preamble = manage (new Label);
+	preamble->set_width_chars (60);
+	preamble->set_line_wrap (true);
+	preamble->set_markup (_("Select two channels below and connect them using a cable or (less ideally) a speaker and microphone."));
 
-	lm_table.attach (lm_preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 	row++;
 
 	label = manage (new Label (_("Output channel")));
 	lm_table.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
-	lm_table.attach (lm_output_channel_combo, 1, 2, row, row+1, xopt, (AttachOptions) 0);
+
+	Gtk::Alignment* misc_align = manage (new Alignment (0.0, 0.5));
+	misc_align->add (lm_output_channel_combo);
+	lm_table.attach (*misc_align, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 
 	label = manage (new Label (_("Input channel")));
 	lm_table.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
-	lm_table.attach (lm_input_channel_combo, 1, 2, row, row+1, xopt, (AttachOptions) 0);
+
+	misc_align = manage (new Alignment (0.0, 0.5));
+	misc_align->add (lm_input_channel_combo);
+	lm_table.attach (*misc_align, 1, 2, row, row+1, FILL, (AttachOptions) 0);
 	++row;
 
 	xopt = AttachOptions(0);
 
+	lm_measure_button.add (lm_start_stop_label);
+	
 	lm_measure_button.signal_toggled().connect (sigc::mem_fun (*this, &EngineControl::latency_button_toggled));
 	lm_use_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::use_latency_button_clicked));
 	lm_use_button.set_sensitive (false);
 		
+
+	preamble = manage (new Label);
+	preamble->set_width_chars (60);
+	preamble->set_line_wrap (true);
+	preamble->set_markup (_("Once the channels are connected, click the \"Measure latency\" button."));
+	lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	row++;
+
 	lm_table.attach (lm_measure_button, 0, 2, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 	lm_table.attach (lm_results, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 	++row;
+
+
+	preamble = manage (new Label);
+	preamble->set_width_chars (60);
+	preamble->set_line_wrap (true);
+	preamble->set_markup (_("When satisfied with the results, click the \"Use results\" button."));
+	lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	row++;
+
 	lm_table.attach (lm_use_button, 0, 2, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 
 	lm_results.set_markup ("<i>No measurement results yet</i>");
 
+	lm_vbox.set_border_width (12);
 	lm_vbox.pack_start (lm_table, false, false);
 
 	/* pack it all up */
 
 	notebook.pages().push_back (TabElem (basic_vbox, _("Audio")));
-	notebook.pages().push_back (TabElem (midi_hbox, _("MIDI")));
+	notebook.pages().push_back (TabElem (midi_vbox, _("MIDI")));
 	notebook.pages().push_back (TabElem (lm_vbox, _("Latency")));
 	notebook.set_border_width (12);
 
@@ -280,7 +352,6 @@ and microphone.\n\n\
 	input_channels.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 	output_channels.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 
-
 	input_channels.signal_output().connect (sigc::bind (sigc::ptr_fun (&EngineControl::print_channel_count), &input_channels));
 	output_channels.signal_output().connect (sigc::bind (sigc::ptr_fun (&EngineControl::print_channel_count), &output_channels));
 
@@ -316,7 +387,87 @@ EngineControl::enable_latency_tab ()
 	lm_input_channel_combo.set_active_text (inputs.front());
 
 	lm_measure_button.set_sensitive (true);
-	lm_use_button.set_sensitive (true);
+}
+
+void
+EngineControl::setup_midi_tab_for_backend ()
+{
+	string backend = backend_combo.get_active_text ();
+
+	Gtkmm2ext::container_clear (midi_vbox);
+
+	midi_vbox.set_border_width (12);
+	midi_device_table.set_border_width (12);
+
+	if (backend == "JACK") {
+		setup_midi_tab_for_jack ();
+	}
+
+	midi_vbox.pack_start (midi_device_table, true, true);
+	midi_vbox.pack_start (midi_refresh_button, false, false);
+	midi_vbox.show_all ();
+
+	midi_refresh_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::refresh_midi_display));
+}
+
+void
+EngineControl::setup_midi_tab_for_jack ()
+{
+	midi_vbox.pack_start (aj_button, false, false);
+}	
+
+void
+EngineControl::refresh_midi_display ()
+{
+	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	assert (backend);
+
+	vector<string> midi_inputs;
+	vector<string> midi_outputs;
+	int row  = 0;
+	AttachOptions xopt = AttachOptions (FILL|EXPAND);
+	Gtk::Label* l;
+
+	Gtkmm2ext::container_clear (midi_device_table);
+
+	backend->get_physical_inputs (ARDOUR::DataType::MIDI, midi_inputs);
+	backend->get_physical_outputs (ARDOUR::DataType::MIDI, midi_outputs);
+
+	midi_device_table.set_spacings (6);
+	midi_device_table.set_homogeneous (true);
+	midi_device_table.resize (midi_inputs.size() + midi_outputs.size() + 3, 1);
+
+	l = manage (new Label);
+	l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Inputs")));
+	midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+	l->set_alignment (0, 0.5);
+	row++;
+	l->show ();
+	
+	for (vector<string>::iterator p = midi_inputs.begin(); p != midi_inputs.end(); ++p) {
+		l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
+		l->set_alignment (0, 0.5);
+		midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+		l->show ();
+		row++;
+	}
+
+	row++; // extra row of spacing
+
+	l = manage (new Label);
+	l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Outputs")));
+	midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+	l->set_alignment (0, 0.5);
+	row++;
+	l->show ();
+
+	for (vector<string>::iterator p = midi_outputs.begin(); p != midi_outputs.end(); ++p) {
+		l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
+		l->set_alignment (0, 0.5);
+		midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+		l->show ();
+		row++;
+	}
 }
 
 void
@@ -334,6 +485,8 @@ EngineControl::backend_changed ()
 		return;
 	}
 
+	setup_midi_tab_for_backend ();
+
 	if (backend->requires_driver_selection()) {
 		vector<string> drivers = backend->enumerate_drivers();
 		driver_combo.set_sensitive (true);
@@ -387,8 +540,10 @@ EngineControl::list_devices ()
 		available_devices.push_back (i->name);
 	}
 
+	ignore_changes++;
 	set_popdown_strings (device_combo, available_devices);
-	
+	ignore_changes--;
+
 	if (!available_devices.empty()) {
 		sample_rate_combo.set_sensitive (true);
 		buffer_size_combo.set_sensitive (true);
@@ -452,39 +607,42 @@ EngineControl::device_changed ()
 
 	vector<float> sr = backend->available_sample_rates (device_name);
 	for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
-		char buf[32];
-		if (fmod (*x, 1000.0f)) {
-			snprintf (buf, sizeof (buf), "%.1f kHz", (*x)/1000.0);
-		} else {
-			snprintf (buf, sizeof (buf), "%.0f kHz", (*x)/1000.0);
-		}
-		s.push_back (buf);
+		s.push_back (rate_as_string (*x));
 		if (*x == _desired_sample_rate) {
-			desired = buf;
+			desired = s.back();
 		}
 	}
 
-	set_popdown_strings (sample_rate_combo, s);
-	if (desired.empty()) {
-		sample_rate_combo.set_active_text (s.front());
+	if (!s.empty()) {
+		set_popdown_strings (sample_rate_combo, s);
+	
+		if (desired.empty()) {
+			sample_rate_combo.set_active_text (s.front());
+		} else {
+			sample_rate_combo.set_active_text (desired);
+		}
 	} else {
-		sample_rate_combo.set_active_text (desired);
+		/* hmm ... how to tell the user about the fact that we have no
+		 * available sample rates.
+		 */
 	}
+		 
 
 	vector<uint32_t> bs = backend->available_buffer_sizes(device_name);
 	s.clear ();
 	for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
-		char buf[32];
-		/* Translators: "samples" is always plural here, so no
-		   need for plural+singular forms.
-		*/
-		snprintf (buf, sizeof (buf), _("%u samples"), *x);
-		s.push_back (buf);
+		s.push_back (bufsize_as_string (*x));
 	}
 
-	set_popdown_strings (buffer_size_combo, s);
-	buffer_size_combo.set_active_text (s.front());
-	show_buffer_duration ();
+	if (!s.empty()) {
+		set_popdown_strings (buffer_size_combo, s);
+		buffer_size_combo.set_active_text (s.front());
+		show_buffer_duration ();
+	} else {
+		/* hmm ... how to tell the user about the fact that we have no
+		 * available buffer sizes.
+		 */
+	}
 
 	manage_control_app_sensitivity ();
 
@@ -499,6 +657,29 @@ EngineControl::device_changed ()
 	push_state_to_backend (false);
 }	
 
+string
+EngineControl::rate_as_string (float r)
+{
+	char buf[32];
+	if (fmod (r, 1000.0f)) {
+		snprintf (buf, sizeof (buf), "%.1f kHz", r/1000.0);
+	} else {
+		snprintf (buf, sizeof (buf), "%.0f kHz", r/1000.0);
+	}
+	return buf;
+}
+
+string
+EngineControl::bufsize_as_string (uint32_t sz)
+{
+	/* Translators: "samples" is always plural here, so no
+	   need for plural+singular forms.
+	*/
+	char buf[32];
+	snprintf (buf, sizeof (buf), _("%u samples"), sz);
+	return buf;
+}
+
 void 
 EngineControl::sample_rate_changed ()
 {
@@ -511,7 +692,6 @@ EngineControl::sample_rate_changed ()
 	*/
 
 	show_buffer_duration ();
-	push_state_to_backend (false);
 	save_state ();
 
 }
@@ -524,7 +704,6 @@ EngineControl::buffer_size_changed ()
 	}
 
 	show_buffer_duration ();
-	push_state_to_backend (false);
 	save_state ();
 }
 
@@ -603,15 +782,7 @@ EngineControl::save_state ()
 		state = new State;
 	}
 	
-	state->backend = backend_combo.get_active_text ();
-	state->driver = driver_combo.get_active_text ();
-	state->device = device_combo.get_active_text ();
-	state->buffer_size = buffer_size_combo.get_active_text ();
-	state->sample_rate = sample_rate_combo.get_active_text ();
-	state->input_latency = (uint32_t) input_latency.get_value();
-	state->output_latency = (uint32_t) output_latency.get_value();
-	state->input_channels = (uint32_t) input_channels.get_value();
-	state->output_channels = (uint32_t) output_channels.get_value();
+	store_state (*state);
 
 	if (!existing) {
 		states.push_back (*state);
@@ -621,6 +792,20 @@ EngineControl::save_state ()
 }
 
 void
+EngineControl::store_state (State& state)
+{
+	state.backend = get_backend ();
+	state.driver = get_driver ();
+	state.device = get_device_name ();
+	state.sample_rate = get_rate ();
+	state.buffer_size = get_buffer_size ();
+	state.input_latency = get_input_latency ();
+	state.output_latency = get_output_latency ();
+	state.input_channels = get_input_channels ();
+	state.output_channels = get_output_channels ();
+}
+
+void
 EngineControl::maybe_display_saved_state ()
 {
 	State* state = get_saved_state_for_currently_displayed_backend_and_device ();
@@ -628,9 +813,13 @@ EngineControl::maybe_display_saved_state ()
 	if (state) {
 		ignore_changes++;
 		if (!_desired_sample_rate) {
-			sample_rate_combo.set_active_text (state->sample_rate);
+			sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
 		}
-		buffer_size_combo.set_active_text (state->buffer_size);
+		buffer_size_combo.set_active_text (bufsize_as_string (state->buffer_size));
+		/* call this explicitly because we're ignoring changes to
+		   the controls at this point.
+		*/
+		show_buffer_duration ();
 		input_latency.set_value (state->input_latency);
 		output_latency.set_value (state->output_latency);
 		ignore_changes--;
@@ -724,12 +913,12 @@ EngineControl::set_state (const XMLNode& root)
 			if ((prop = grandchild->property ("sample-rate")) == 0) {
 				continue;
 			}
-			state.sample_rate = prop->value ();
+			state.sample_rate = atof (prop->value ());
 			
 			if ((prop = grandchild->property ("buffer-size")) == 0) {
 				continue;
 			}
-			state.buffer_size = prop->value ();
+			state.buffer_size = atoi (prop->value ());
 			
 			if ((prop = grandchild->property ("input-latency")) == 0) {
 				continue;
@@ -768,13 +957,11 @@ EngineControl::set_state (const XMLNode& root)
 			backend_combo.set_active_text ((*i).backend);
 			driver_combo.set_active_text ((*i).driver);
 			device_combo.set_active_text ((*i).device);
-			sample_rate_combo.set_active_text ((*i).sample_rate);
-			buffer_size_combo.set_active_text ((*i).buffer_size);
+			sample_rate_combo.set_active_text (rate_as_string ((*i).sample_rate));
+			buffer_size_combo.set_active_text (bufsize_as_string ((*i).buffer_size));
 			input_latency.set_value ((*i).input_latency);
 			output_latency.set_value ((*i).output_latency);
 			ignore_changes--;
-
-			push_state_to_backend (false);
 			break;
 		}
 	}
@@ -788,96 +975,246 @@ EngineControl::push_state_to_backend (bool start)
 
 	if (!backend) {
 		return 0;
-	 }
+	}
+	
+	/* figure out what is going to change */
+
+	bool restart_required = false;
+	bool was_running = ARDOUR::AudioEngine::instance()->running();
+	bool change_driver = false;
+	bool change_device = false;
+	bool change_rate = false;
+	bool change_bufsize = false;
+	bool change_latency = false;
+	bool change_channels = false;
+
+	uint32_t ochan = get_output_channels ();
+	uint32_t ichan = get_input_channels ();
 
-	/* grab the parameters from the GUI and apply them */
+	if (_have_control) {
+		
+		/* we can control the backend */
 
-	try {
 		if (backend->requires_driver_selection()) {
-			if (backend->set_driver (get_driver())) {
-				return -1;
+			if (get_driver() != backend->driver_name()) {
+				change_driver = true;
 			}
 		}
 
-		if (backend->set_device_name (get_device_name())) {
-			return -1;
+		if (get_device_name() != backend->device_name()) {
+			change_device = true;
 		}
 
-		if (backend->set_sample_rate (get_rate())) {
-			error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
-			return -1;
+		if (get_rate() != backend->sample_rate()) {
+			change_rate = true;
 		}
-		if (backend->set_buffer_size (get_buffer_size())) {
-			error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
-			return -1;
+
+		if (get_buffer_size() != backend->buffer_size()) {
+			change_bufsize = true;
 		}
-		if (backend->set_input_channels (get_input_channels())) {
-			error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
-			return -1;
+
+		/* zero-requested channels means "all available" */
+
+		if (ichan == 0) {
+			ichan = backend->input_channels();
 		}
-		if (backend->set_output_channels (get_output_channels())) {
-			error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
-			return -1;
+
+		if (ochan == 0) {
+			ochan = backend->output_channels();
 		}
-		if (backend->set_systemic_input_latency (get_input_latency())) {
-			error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
-			return -1;
+
+		if (ichan != backend->input_channels()) {
+			change_channels = true;
 		}
-		if (backend->set_systemic_output_latency (get_output_latency())) {
-			error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
-			return -1;
+
+		if (ochan != backend->output_channels()) {
+			change_channels = true;
 		}
 
-		/* get a pointer to the current state object, creating one if
-		 * necessary
+		if (get_input_latency() != backend->systemic_input_latency() ||
+		    get_output_latency() != backend->systemic_output_latency()) {
+			change_latency = true;
+		}
+
+	} else {
+
+		/* we have no control over the backend, meaning that we can
+		 * only possibly change sample rate and buffer size.
 		 */
 
-		State* state = get_saved_state_for_currently_displayed_backend_and_device ();
 
-		if (!state) {
-			state = save_state ();
-			assert (state);
+		if (get_rate() != backend->sample_rate()) {
+			change_bufsize = true;
 		}
 
-		/* all off */
-
-		for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
-			(*i).active = false;
+		if (get_buffer_size() != backend->buffer_size()) {
+			change_bufsize = true;
 		}
+	}
 
-		/* mark this one active (to be used next time the dialog is
-		 * shown)
+	if (!_have_control) {
+
+		/* We do not have control over the backend, so the best we can
+		 * do is try to change the sample rate and/or bufsize and get
+		 * out of here.
 		 */
 
-		state->active = true;
+		if (change_rate && !backend->can_change_sample_rate_when_running()) {
+			return 1;
+		}
+
+		if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
+			return 1;
+		}
 		
-		if (start) {
-			if (ARDOUR::AudioEngine::instance()->start()) {
-				return -1;
-			}
+		if (change_rate) {
+			backend->set_sample_rate (get_rate());
+		}
+		
+		if (change_bufsize) {
+			backend->set_buffer_size (get_buffer_size());
 		}
 
-		manage_control_app_sensitivity ();
+		post_push ();
+
 		return 0;
+	} 
+
+	/* determine if we need to stop the backend before changing parameters */
+
+	if (change_driver || change_device || change_channels || change_latency ||
+	    (change_rate && !backend->can_change_sample_rate_when_running()) ||
+	    (change_bufsize && !backend->can_change_buffer_size_when_running())) {
+		restart_required = true;
+	} else {
+		restart_required = false;
+	}
+
+	if (was_running) {
+
+		if (!change_driver && !change_device && !change_channels && !change_latency) {
+			/* no changes in any parameters that absolutely require a
+			 * restart, so check those that might be changeable without a
+			 * restart
+			 */
+			
+			if (change_rate && !backend->can_change_sample_rate_when_running()) {
+				/* can't do this while running ... */
+				restart_required = true;
+			}
+
+			if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
+				/* can't do this while running ... */
+				restart_required = true;
+			}
+		}
+	}
+
+	if (was_running) {
+		if (restart_required) {
+			if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
+				return -1;
+			}
+		}
+	}
+		
 
-	} catch (...) {
-		cerr << "exception thrown...\n";
+	if (change_driver && backend->set_driver (get_driver())) {
+		error << string_compose (_("Cannot set driver to %1"), get_driver()) << endmsg;
+		return -1;
+	}
+	if (change_device && backend->set_device_name (get_device_name())) {
+		error << string_compose (_("Cannot set device name to %1"), get_device_name()) << endmsg;
+		return -1;
+	}
+	if (change_rate && backend->set_sample_rate (get_rate())) {
+		error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
+		return -1;
+	}
+	if (change_bufsize && backend->set_buffer_size (get_buffer_size())) {
+		error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
 		return -1;
 	}
+
+	if (change_channels || get_input_channels() == 0 || get_output_channels() == 0) {
+		if (backend->set_input_channels (get_input_channels())) {
+			error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
+			return -1;
+		}
+		if (backend->set_output_channels (get_output_channels())) {
+			error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
+			return -1;
+		}
+	}
+	if (change_latency) {
+		if (backend->set_systemic_input_latency (get_input_latency())) {
+			error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
+			return -1;
+		}
+		if (backend->set_systemic_output_latency (get_output_latency())) {
+			error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
+			return -1;
+		}
+	}
+			
+	if (start || (was_running && restart_required)) {
+		if (ARDOUR_UI::instance()->reconnect_to_engine()) {
+			return -1;
+		}
+	}
+	
+	post_push ();
+
+	return 0;
 }
 
-uint32_t
+void
+EngineControl::post_push ()
+{
+	/* get a pointer to the current state object, creating one if
+	 * necessary
+	 */
+	
+	State* state = get_saved_state_for_currently_displayed_backend_and_device ();
+	
+	if (!state) {
+		state = save_state ();
+		assert (state);
+	}
+	
+	/* all off */
+	
+	for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
+		(*i).active = false;
+	}
+	
+	/* mark this one active (to be used next time the dialog is
+	 * shown)
+	 */
+	
+	state->active = true;
+
+	manage_control_app_sensitivity ();
+
+	/* schedule a redisplay of MIDI ports */
+	
+	Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
+}
+
+
+float
 EngineControl::get_rate () const
 {
-	double r = atof (sample_rate_combo.get_active_text ());
+	float r = atof (sample_rate_combo.get_active_text ());
 	/* the string may have been translated with an abbreviation for
 	 * thousands, so use a crude heuristic to fix this.
 	 */
 	if (r < 1000.0) {
 		r *= 1000.0;
 	}
-	return lrint (r);
+	return r;
 }
+	
 
 uint32_t
 EngineControl::get_buffer_size () const
@@ -917,6 +1254,12 @@ EngineControl::get_output_latency() const
 }
 
 string
+EngineControl::get_backend () const
+{
+	return backend_combo.get_active_text ();
+}
+
+string
 EngineControl::get_driver () const
 {
 	return driver_combo.get_active_text ();
@@ -968,6 +1311,21 @@ EngineControl::set_desired_sample_rate (uint32_t sr)
 void
 EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
 {
+	if (page_num == 0) {
+		cancel_button->set_sensitive (true);
+		ok_button->set_sensitive (true);
+		apply_button->set_sensitive (true);
+	} else {
+		cancel_button->set_sensitive (false);
+		ok_button->set_sensitive (false);
+		apply_button->set_sensitive (false);
+	}
+
+	if (page_num == 1) {
+		/* MIDI tab */
+		refresh_midi_display ();
+	}
+
 	if (page_num == 2) {
 		/* latency tab */
 
@@ -987,18 +1345,19 @@ EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
 			input_latency.set_value (0);
 			output_latency.set_value (0);
 			
-			push_state_to_backend (false);
-
 			/* reset control */
 
 			input_latency.set_value (il);
 			output_latency.set_value (ol);
-		}
+
+		} 
 
 		if (ARDOUR::AudioEngine::instance()->prepare_for_latency_measurement()) {
 			disable_latency_tab ();
 		}
+
 		enable_latency_tab ();
+
 	} else {
 		ARDOUR::AudioEngine::instance()->stop_latency_detection();
 	}
@@ -1010,15 +1369,9 @@ bool
 EngineControl::check_latency_measurement ()
 {
         MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
-	static uint32_t cnt = 0;
 
         if (mtdm->resolve () < 0) {
-		string txt = _("No signal detected ");
-		uint32_t dots = cnt++%10;
-		for (uint32_t i = 0; i < dots; ++i) {
-			txt += '.';
-		}
-		lm_results.set_text (txt);
+		lm_results.set_markup (string_compose ("<span foreground=\"red\">%1</span>", _("No signal detected ")));
                 return true;
         }
 
@@ -1037,7 +1390,6 @@ EngineControl::check_latency_measurement ()
         }
 
 	uint32_t frames_total = mtdm->del();
-	cerr << "total = " << frames_total << " delay = " << ARDOUR::AudioEngine::instance()->latency_signal_delay() << endl;
 	uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
 
         snprintf (buf, sizeof (buf), "%u samples %10.3lf ms", extra, extra * 1000.0f/sample_rate);
@@ -1058,6 +1410,7 @@ EngineControl::check_latency_measurement ()
                 lm_measure_button.set_active (false);
 		lm_use_button.set_sensitive (true);
                 strcat (buf, " (set)");
+		have_lm_results = true;
         }
 	
         lm_results.set_text (buf);
@@ -1066,19 +1419,39 @@ EngineControl::check_latency_measurement ()
 }
 
 void
-EngineControl::latency_button_toggled ()
+EngineControl::start_latency_detection ()
 {
-        if (lm_measure_button.get_active ()) {
+	ARDOUR::AudioEngine::instance()->set_latency_input_port (lm_input_channel_combo.get_active_text());
+	ARDOUR::AudioEngine::instance()->set_latency_output_port (lm_output_channel_combo.get_active_text());
+	ARDOUR::AudioEngine::instance()->start_latency_detection ();
+	lm_results.set_text (_("Detecting ..."));
+	latency_timeout = Glib::signal_timeout().connect (mem_fun (*this, &EngineControl::check_latency_measurement), 250);
+	lm_start_stop_label.set_text (_("Cancel measurement"));
+	have_lm_results = false;
+	lm_input_channel_combo.set_sensitive (false);
+	lm_output_channel_combo.set_sensitive (false);
+}
 
-		ARDOUR::AudioEngine::instance()->set_latency_input_port (lm_input_channel_combo.get_active_text());
-		ARDOUR::AudioEngine::instance()->set_latency_output_port (lm_output_channel_combo.get_active_text());
-		ARDOUR::AudioEngine::instance()->start_latency_detection ();
-                lm_results.set_text (_("Detecting ..."));
-                latency_timeout = Glib::signal_timeout().connect (mem_fun (*this, &EngineControl::check_latency_measurement), 250);
+void
+EngineControl::end_latency_detection ()
+{
+	ARDOUR::AudioEngine::instance()->stop_latency_detection ();
+	latency_timeout.disconnect ();
+	lm_start_stop_label.set_text (_("Measure latency"));
+	if (!have_lm_results) {
+		lm_results.set_markup ("<i>No measurement results yet</i>");
+	}
+	lm_input_channel_combo.set_sensitive (true);
+	lm_output_channel_combo.set_sensitive (true);
+}
 
-        } else {
-		ARDOUR::AudioEngine::instance()->stop_latency_detection ();
-                latency_timeout.disconnect ();
+void
+EngineControl::latency_button_toggled ()
+{
+        if (lm_measure_button.get_active ()) {
+		start_latency_detection ();
+	} else {
+		end_latency_detection ();
         }
 }
 
@@ -1098,3 +1471,14 @@ EngineControl::use_latency_button_clicked ()
 	input_latency_adjustment.set_value (one_way);
 	output_latency_adjustment.set_value (one_way);
 }
+
+bool
+EngineControl::on_delete_event (GdkEventAny* ev)
+{
+	if (notebook.get_current_page() == 2) {
+		/* currently on latency tab - be sure to clean up */
+		end_latency_detection ();
+	}
+	return ArdourDialog::on_delete_event (ev);
+}
+
diff --git a/gtk2_ardour/engine_dialog.h b/gtk2_ardour/engine_dialog.h
index 98ddf2c1b3..fcbdfe4cb8 100644
--- a/gtk2_ardour/engine_dialog.h
+++ b/gtk2_ardour/engine_dialog.h
@@ -54,7 +54,13 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
 
     /* core fields used by all backends */
 
+    Gtk::Table basic_packer;
+    Gtk::HBox basic_hbox;
+    Gtk::VBox basic_vbox;
+
     Gtk::ComboBoxText backend_combo;
+    Gtk::ComboBoxText driver_combo;
+    Gtk::ComboBoxText device_combo;
     Gtk::ComboBoxText sample_rate_combo;
     Gtk::ComboBoxText buffer_size_combo;
     Gtk::Label        buffer_size_duration_label;
@@ -75,42 +81,31 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
 
     Gtk::ComboBoxText lm_output_channel_combo;
     Gtk::ComboBoxText lm_input_channel_combo;
+    Gtk::Label        lm_start_stop_label;
     Gtk::ToggleButton lm_measure_button;
     Gtk::Button       lm_use_button;
     Gtk::Label        lm_title;
-    Gtk::Label        lm_preamble;
     Gtk::Label        lm_results;
     Gtk::Table        lm_table;
     Gtk::VBox         lm_vbox;
+    bool              have_lm_results;
 
-    /* JACK specific */
-    
-    Gtk::CheckButton realtime_button;
-    Gtk::CheckButton no_memory_lock_button;
-    Gtk::CheckButton unlock_memory_button;
-    Gtk::CheckButton soft_mode_button;
-    Gtk::CheckButton monitor_button;
-    Gtk::CheckButton force16bit_button;
-    Gtk::CheckButton hw_monitor_button;
-    Gtk::CheckButton hw_meter_button;
-    Gtk::CheckButton verbose_output_button;
+    Gtk::Button* cancel_button;
+    Gtk::Button* ok_button;
+    Gtk::Button* apply_button;
+
+    /* MIDI Tab */
+
+    Gtk::VBox midi_vbox;
+    Gtk::Button midi_refresh_button;
+    Gtk::Table midi_device_table;
+
+    /* MIDI ... JACK */
     
-    Gtk::ComboBoxText preset_combo;
-    Gtk::ComboBoxText serverpath_combo;
-    Gtk::ComboBoxText driver_combo;
-    Gtk::ComboBoxText device_combo;
-    Gtk::ComboBoxText timeout_combo;
-    Gtk::ComboBoxText dither_mode_combo;
-    Gtk::ComboBoxText audio_mode_combo;
-    Gtk::ComboBoxText midi_driver_combo;
+    Gtk::CheckButton aj_button;
     
-    Gtk::Table basic_packer;
-    Gtk::Table midi_packer;
-    Gtk::HBox basic_hbox;
-    Gtk::VBox basic_vbox;
-    Gtk::HBox midi_hbox;
-
     uint32_t ignore_changes;
+    uint32_t _desired_sample_rate;
     
     static bool engine_running ();
     
@@ -120,7 +115,14 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     void buffer_size_changed ();
     void parameter_changed ();
 
-    uint32_t get_rate() const;
+    void setup_midi_tab_for_backend ();
+    void setup_midi_tab_for_jack ();
+    void refresh_midi_display ();
+    
+    std::string rate_as_string (float);
+    std::string bufsize_as_string (uint32_t);
+
+    float get_rate() const;
     uint32_t get_buffer_size() const;
     uint32_t get_input_channels() const;
     uint32_t get_output_channels() const;
@@ -128,6 +130,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     uint32_t get_output_latency() const;
     std::string get_device_name() const;
     std::string get_driver() const;
+    std::string get_backend() const;
 
     void device_changed ();
     void list_devices ();
@@ -137,15 +140,21 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
 	std::string backend;
 	std::string driver;
 	std::string device;
-	std::string sample_rate;
-	std::string buffer_size;
+	float sample_rate;
+	uint32_t buffer_size;
 	uint32_t input_latency;
 	uint32_t output_latency;
 	uint32_t input_channels;
 	uint32_t output_channels;
 	bool active;
 
-	State() : active (false) {};
+	State() 
+		: input_latency (0)
+		, output_latency (0)
+		, input_channels (0)
+		, output_channels (0)
+		, active (false) {}
+
     };
     
     typedef std::list<State> StateList;
@@ -158,6 +167,9 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     State* get_saved_state_for_currently_displayed_backend_and_device ();
     void maybe_display_saved_state ();
     State* save_state ();
+    void store_state (State&);
+
+    bool  _have_control;
 
     static bool print_channel_count (Gtk::SpinButton*);
 
@@ -168,7 +180,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     void use_latency_button_clicked ();
     void manage_control_app_sensitivity ();
     int push_state_to_backend (bool start);
-    uint32_t _desired_sample_rate;
+    void post_push ();
 
     /* latency measurement */
     void latency_button_toggled ();
@@ -176,8 +188,11 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     sigc::connection latency_timeout;
     void enable_latency_tab ();
     void disable_latency_tab ();
+    void start_latency_detection ();
+    void end_latency_detection ();
 
     void on_switch_page (GtkNotebookPage*, guint page_num);
+    bool on_delete_event (GdkEventAny*);
 };
 
 #endif /* __gtk2_ardour_engine_dialog_h__ */
diff --git a/gtk2_ardour/utils.cc b/gtk2_ardour/utils.cc
index a35d171690..bbce202ad1 100644
--- a/gtk2_ardour/utils.cc
+++ b/gtk2_ardour/utils.cc
@@ -365,12 +365,11 @@ relay_key_press (GdkEventKey* ev, Gtk::Window* win)
 {
 	PublicEditor& ed (PublicEditor::instance());
 
-	if (&ed == 0) {
-		/* early key press in pre-main-window-dialogs, no editor yet */
-		return false;
-	}
-
 	if (!key_press_focus_accelerator_handler (*win, ev)) {
+		if (&ed == 0) {
+			/* early key press in pre-main-window-dialogs, no editor yet */
+			return false;
+		}
 		return ed.on_key_press_event(ev);
 	} else {
 		return true;
diff --git a/libs/ardour/ardour/audio_backend.h b/libs/ardour/ardour/audio_backend.h
index 4d57f0b43d..9052acd530 100644
--- a/libs/ardour/ardour/audio_backend.h
+++ b/libs/ardour/ardour/audio_backend.h
@@ -223,6 +223,11 @@ class AudioBackend : public PortEngine {
     virtual uint32_t     systemic_input_latency () const = 0;
     virtual uint32_t     systemic_output_latency () const = 0;
 
+    /** override this if this implementation returns true from
+     * requires_driver_selection()
+     */
+    virtual std::string  driver_name() const { return std::string(); }
+
     /** Return the name of a control application for the 
      * selected/in-use device. If no such application exists,
      * or if no device has been selected or is in-use,
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index d0cd3fa06e..3fa9fbcb28 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -1071,7 +1071,6 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
 	boost::scoped_ptr<SessionDirectory> _session_dir;
 
 	void hookup_io ();
-        int when_engine_running ();
 	void graph_reordered ();
 
 	/** current snapshot name, without the .ardour suffix */
@@ -1137,8 +1136,10 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
 	void             auto_loop_changed (Location *);
 	void             auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
 
+        int  ensure_engine (uint32_t desired_sample_rate);
 	void pre_engine_init (std::string path);
 	int  post_engine_init ();
+        int  immediately_post_engine ();
 	void remove_empty_sounds ();
 
 	void setup_midi_control ();
@@ -1521,13 +1522,6 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
 		float opt
 		);
 
-	/* number of hardware ports we're using,
-	   based on max (requested,available)
-	*/
-
-	ChanCount n_physical_outputs;
-	ChanCount n_physical_inputs;
-
 	int find_all_sources (std::string path, std::set<std::string>& result);
 	int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
 
@@ -1624,7 +1618,6 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
     void setup_ltc ();
     void setup_click ();
     void setup_bundles ();
-    int  ensure_engine (uint32_t desired_sample_rate);
 };
 
 } // namespace ARDOUR
diff --git a/libs/ardour/audioengine.cc b/libs/ardour/audioengine.cc
index ebebac5774..05fc469c77 100644
--- a/libs/ardour/audioengine.cc
+++ b/libs/ardour/audioengine.cc
@@ -1037,12 +1037,22 @@ AudioEngine::start_latency_detection ()
 	delete _mtdm;
 	_mtdm = 0;
 
+	/* find the ports we will connect to */
+
+	PortEngine::PortHandle* out = pe.get_port_by_name (_latency_output_name);
+	PortEngine::PortHandle* in = pe.get_port_by_name (_latency_input_name);
+
+	if (!out || !in) {
+		return;
+	}
+
 	/* create the ports we will use to read/write data */
 	
 	if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
 		return;
 	}
 	if (pe.connect (_latency_output_port, _latency_output_name)) {
+		pe.unregister_port (_latency_output_port);
 		return;
 	}
 
@@ -1058,9 +1068,9 @@ AudioEngine::start_latency_detection ()
 
 	LatencyRange lr;
 	_latency_signal_latency = 0;
-	lr = pe.get_latency_range (_latency_input_port, false);
+	lr = pe.get_latency_range (in, false);
 	_latency_signal_latency = lr.max;
-	lr = pe.get_latency_range (_latency_output_port, true);
+	lr = pe.get_latency_range (out, true);
 	_latency_signal_latency += lr.max;
 
 	/* all created and connected, lets go */
@@ -1076,9 +1086,14 @@ AudioEngine::stop_latency_detection ()
 {
 	_measuring_latency = false;
 
-	port_engine().unregister_port (_latency_output_port);
-	port_engine().unregister_port (_latency_input_port);
-	
+	if (_latency_output_port) {
+		port_engine().unregister_port (_latency_output_port);
+		_latency_output_port = 0;
+	}
+	if (_latency_input_port) {
+		port_engine().unregister_port (_latency_input_port);
+		_latency_input_port = 0;
+	}
 	if (_started_for_latency) {
 		stop ();
 	}
diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index 4be42c769a..2a081086d4 100644
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -258,17 +258,26 @@ Session::Session (AudioEngine &eng,
 	, _suspend_timecode_transmission (0)
 	,  _speakers (new Speakers)
 	, ignore_route_processor_changes (false)
+	, _midi_ports (0)
+	, _mmc (0)
 {
 	uint32_t sr = 0;
 
 	pre_engine_init (fullpath);
 	
 	if (_is_new) {
+		if (ensure_engine (sr)) {
+			destroy ();
+			throw failed_constructor ();
+		}
+
 		if (create (mix_template, bus_profile)) {
 			destroy ();
 			throw failed_constructor ();
 		}
+
 	} else {
+
 		if (load_state (_current_snapshot_name)) {
 			throw failed_constructor ();
 		}
@@ -284,11 +293,11 @@ Session::Session (AudioEngine &eng,
 				sr = atoi (prop->value());
 			}
 		}
-	}
 
-	if (ensure_engine (sr)) {
-		destroy ();
-		throw failed_constructor ();
+		if (ensure_engine (sr)) {
+			destroy ();
+			throw failed_constructor ();
+		}
 	}
 
 	if (post_engine_init ()) {
@@ -361,6 +370,50 @@ Session::ensure_engine (uint32_t desired_sample_rate)
 		return -1;
 	}
 
+	return immediately_post_engine ();
+
+}
+
+int
+Session::immediately_post_engine ()
+{
+	/* Do various initializations that should take place directly after we
+	 * know that the engine is running, but before we either create a
+	 * session or set state for an existing one.
+	 */
+	 
+	if (how_many_dsp_threads () > 1) {
+		/* For now, only create the graph if we are using >1 DSP threads, as
+		   it is a bit slower than the old code with 1 thread.
+		*/
+		_process_graph.reset (new Graph (*this));
+	}
+
+	/* every time we reconnect, recompute worst case output latencies */
+
+	_engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
+
+	if (synced_to_jack()) {
+		_engine.transport_stop ();
+	}
+
+	if (config.get_jack_time_master()) {
+		_engine.transport_locate (_transport_frame);
+	}
+
+	try {
+		BootMessage (_("Set up LTC"));
+		setup_ltc ();
+		BootMessage (_("Set up Click"));
+		setup_click ();
+		BootMessage (_("Set up standard connections"));
+		setup_bundles ();
+	}
+
+	catch (failed_constructor& err) {
+		return -1;
+	}
+
 	return 0;
 }
 
@@ -474,9 +527,9 @@ Session::destroy ()
 	/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
 	playlists.reset ();
 
-	delete _mmc;
-	delete _midi_ports;
-	delete _locations;
+	delete _mmc; _mmc = 0;
+	delete _midi_ports; _midi_ports = 0;
+	delete _locations; _locations = 0;
 
 	DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
 
@@ -683,81 +736,6 @@ Session::setup_bundles ()
 
 }
 
-int
-Session::when_engine_running ()
-{
-	/* every time we reconnect, recompute worst case output latencies */
-
-	_engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
-
-	if (synced_to_jack()) {
-		_engine.transport_stop ();
-	}
-
-	if (config.get_jack_time_master()) {
-		_engine.transport_locate (_transport_frame);
-	}
-
-
-	try {
-		BootMessage (_("Set up LTC"));
-		setup_ltc ();
-		BootMessage (_("Set up Click"));
-		setup_click ();
-		BootMessage (_("Set up standard connections"));
-		setup_bundles ();
-	}
-
-	catch (failed_constructor& err) {
-		return -1;
-	}
-
-	BootMessage (_("Setup signal flow and plugins"));
-
-	/* Reset all panners */
-
-	Delivery::reset_panners ();
-
-	/* this will cause the CPM to instantiate any protocols that are in use
-	 * (or mandatory), which will pass it this Session, and then call
-	 * set_state() on each instantiated protocol to match stored state.
-	 */
-
-	ControlProtocolManager::instance().set_session (this);
-
-	/* This must be done after the ControlProtocolManager set_session above,
-	   as it will set states for ports which the ControlProtocolManager creates.
-	*/
-
-	// XXX set state of MIDI::Port's
-	// MidiPortManager::instance()->set_port_states (Config->midi_port_states ());
-
-	/* And this must be done after the MIDI::Manager::set_port_states as
-	 * it will try to make connections whose details are loaded by set_port_states.
-	 */
-
-	hookup_io ();
-
-	/* Let control protocols know that we are now all connected, so they
-	 * could start talking to surfaces if they want to.
-	 */
-
-	ControlProtocolManager::instance().midi_connectivity_established ();
-
-	if (_is_new && !no_auto_connect()) {
-		Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
-		auto_connect_master_bus ();
-	}
-
-	_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
-
-        /* update latencies */
-
-        initialize_latencies ();
-
-	return 0;
-}
-
 void
 Session::auto_connect_master_bus ()
 {
@@ -917,14 +895,14 @@ Session::add_monitor_section ()
 			
 			/* Monitor bus is audio only */
 
-			uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
-			uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
 			vector<string> outputs[DataType::num_types];
 
 			for (uint32_t i = 0; i < DataType::num_types; ++i) {
 				_engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
 			}
-			
+
+			uint32_t mod = outputs[DataType::AUDIO].size();
+			uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
 			
 			if (mod != 0) {
 				
diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc
index 2d91bdd4c2..1a605d2fd5 100644
--- a/libs/ardour/session_state.cc
+++ b/libs/ardour/session_state.cc
@@ -211,16 +211,6 @@ Session::post_engine_init ()
 	set_block_size (_engine.samples_per_cycle());
 	set_frame_rate (_engine.sample_rate());
 
-	if (how_many_dsp_threads () > 1) {
-		/* For now, only create the graph if we are using >1 DSP threads, as
-		   it is a bit slower than the old code with 1 thread.
-		*/
-		_process_graph.reset (new Graph (*this));
-	}
-
-	n_physical_outputs = _engine.n_physical_outputs ();
-	n_physical_inputs =  _engine.n_physical_inputs ();
-
 	BootMessage (_("Using configuration"));
 
 	_midi_ports = new MidiPortManager;
@@ -281,8 +271,47 @@ Session::post_engine_init ()
 		Config->map_parameters (ff);
 		config.map_parameters (ft);
 
-		when_engine_running ();
-
+		/* Reset all panners */
+		
+		Delivery::reset_panners ();
+		
+		/* this will cause the CPM to instantiate any protocols that are in use
+		 * (or mandatory), which will pass it this Session, and then call
+		 * set_state() on each instantiated protocol to match stored state.
+		 */
+		
+		ControlProtocolManager::instance().set_session (this);
+		
+		/* This must be done after the ControlProtocolManager set_session above,
+		   as it will set states for ports which the ControlProtocolManager creates.
+		*/
+		
+		// XXX set state of MIDI::Port's
+		// MidiPortManager::instance()->set_port_states (Config->midi_port_states ());
+		
+		/* And this must be done after the MIDI::Manager::set_port_states as
+		 * it will try to make connections whose details are loaded by set_port_states.
+		 */
+		
+		hookup_io ();
+		
+		/* Let control protocols know that we are now all connected, so they
+		 * could start talking to surfaces if they want to.
+		 */
+		
+		ControlProtocolManager::instance().midi_connectivity_established ();
+		
+		if (_is_new && !no_auto_connect()) {
+			Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
+			auto_connect_master_bus ();
+		}
+		
+		_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
+		
+		/* update latencies */
+		
+		initialize_latencies ();
+		
 		_locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
 		_locations->added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1));
 		
diff --git a/libs/backends/jack/jack_audiobackend.cc b/libs/backends/jack/jack_audiobackend.cc
index b3dbdcae71..1e7cb9d8d5 100644
--- a/libs/backends/jack/jack_audiobackend.cc
+++ b/libs/backends/jack/jack_audiobackend.cc
@@ -57,8 +57,8 @@ JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnec
 	, _target_buffer_size (1024)
 	, _target_sample_format (FormatFloat)
 	, _target_interleaved (false)
-	, _target_input_channels (-1)
-	, _target_output_channels (-1)
+	, _target_input_channels (0)
+	, _target_output_channels (0)
 	, _target_systemic_input_latency (0)
 	, _target_systemic_output_latency (0)
 	, _current_sample_rate (0)
@@ -292,7 +292,10 @@ int
 JACKAudioBackend::set_input_channels (uint32_t cnt)
 {
 	if (available()) {
-		return -1;
+		if (cnt != 0) {
+			/* can't set a real value for this while JACK runs */
+			return -1;
+		}
 	}
 
 	_target_input_channels = cnt;
@@ -304,7 +307,10 @@ int
 JACKAudioBackend::set_output_channels (uint32_t cnt)
 {
 	if (available()) {
-		return -1;
+		if (cnt != 0) {
+			/* can't set a real value for this while JACK runs */
+			return -1;
+		}
 	}
 
 	_target_output_channels = cnt;
@@ -316,6 +322,7 @@ int
 JACKAudioBackend::set_systemic_input_latency (uint32_t l)
 {
 	if (available()) {
+		/* can't do this while JACK runs */
 		return -1;
 	}
 
@@ -328,6 +335,7 @@ int
 JACKAudioBackend::set_systemic_output_latency (uint32_t l)
 {
 	if (available()) {
+		/* can't do this while JACK runs */
 		return -1;
 	}
 
@@ -341,18 +349,34 @@ JACKAudioBackend::set_systemic_output_latency (uint32_t l)
 std::string
 JACKAudioBackend::device_name () const
 {
-	if (available()) {
-		return "???";
+	if (!_jack_connection->in_control()) {
+		return "???"; // JACK has no way (as of fall 2013) to return
+			      // the device name
 	} 
 
 	return _target_device;
 }
 
+std::string
+JACKAudioBackend::driver_name() const
+{
+	if (!_jack_connection->in_control()) {
+		return "???"; // JACK has no way (as of fall 2013) to return
+			      // the driver name
+	}
+
+	return _target_driver;
+}
+
 float
 JACKAudioBackend::sample_rate () const
 {
-	if (available()) {
-		return _current_sample_rate;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return _current_sample_rate;
+		} else {
+			return 0;
+		}
 	}
 	return _target_sample_rate;
 }
@@ -360,8 +384,12 @@ JACKAudioBackend::sample_rate () const
 uint32_t
 JACKAudioBackend::buffer_size () const
 {
-	if (available()) {
-		return _current_buffer_size;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return _current_buffer_size;
+		} else {
+			return 0;
+		}
 	}
 	return _target_buffer_size;
 }
@@ -381,19 +409,37 @@ JACKAudioBackend::interleaved () const
 uint32_t
 JACKAudioBackend::input_channels () const
 {
-	if (available()) {
-		return n_physical (JackPortIsInput).n_audio();
-	} 
-	return _target_input_channels;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return n_physical (JackPortIsInput).n_audio();
+		} else {
+			return 0;
+		}
+	} else {
+		if (available()) {
+			return n_physical (JackPortIsInput).n_audio();
+		} else {
+			return _target_input_channels;
+		}
+	}
 }
 
 uint32_t
 JACKAudioBackend::output_channels () const
 {
-	if (available()) {
-		return n_physical (JackPortIsOutput).n_audio();
-	} 
-	return _target_output_channels;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return n_physical (JackPortIsOutput).n_audio();
+		} else {
+			return 0;
+		}
+	} else {
+		if (available()) {
+			return n_physical (JackPortIsOutput).n_audio();
+		} else {
+			return _target_output_channels;
+		}
+	}
 }
 
 uint32_t
diff --git a/libs/backends/jack/jack_audiobackend.h b/libs/backends/jack/jack_audiobackend.h
index 655c939c51..9ab545f3ee 100644
--- a/libs/backends/jack/jack_audiobackend.h
+++ b/libs/backends/jack/jack_audiobackend.h
@@ -85,6 +85,7 @@ class JACKAudioBackend : public AudioBackend {
     uint32_t     output_channels () const;
     uint32_t     systemic_input_latency () const;
     uint32_t     systemic_output_latency () const;
+    std::string  driver_name() const;
 
     std::string control_app_name () const;
     void launch_control_app ();
diff --git a/libs/backends/jack/jack_connection.cc b/libs/backends/jack/jack_connection.cc
index 00b6feb5e1..d5d25c747f 100644
--- a/libs/backends/jack/jack_connection.cc
+++ b/libs/backends/jack/jack_connection.cc
@@ -16,6 +16,7 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
 */
+#include <iostream>
 
 #include <boost/scoped_ptr.hpp>
 #include <jack/session.h>
@@ -53,6 +54,7 @@ JackConnection::JackConnection (const std::string& arg1, const std::string& arg2
 	, _client_name (arg1)
 	, session_uuid (arg2)
 {
+	_in_control = !server_running();
 }
 
 JackConnection::~JackConnection ()
@@ -104,6 +106,19 @@ JackConnection::open ()
                 global_epa->restore ();
         }
 
+	/* check to see if the server is already running so that we know if we
+	 * are starting it.
+	 */
+
+	jack_client_t* c = jack_client_open ("ardourprobe", JackNoStartServer, &status);
+
+	if (status == 0) {
+		_in_control = false;
+		jack_client_close (c);
+	} else {
+		_in_control = true;
+	}
+
 	/* ensure that PATH or equivalent includes likely locations of the JACK
 	 * server, in case the user's default does not.
 	 */
diff --git a/libs/backends/jack/jack_connection.h b/libs/backends/jack/jack_connection.h
index cd45f3b9ba..229d9697d9 100644
--- a/libs/backends/jack/jack_connection.h
+++ b/libs/backends/jack/jack_connection.h
@@ -27,12 +27,15 @@ class JackConnection {
     void halted_callback ();
     void halted_info_callback (jack_status_t, const char*);
 
-    static bool server_running();
+    bool in_control() const { return _in_control; }
 
+    static bool server_running();
+    
   private:
     jack_client_t* volatile _jack;
     std::string _client_name;
     std::string session_uuid;
+    bool _in_control;
 };
 
 } // namespace 
diff --git a/libs/gtkmm2ext/keyboard.cc b/libs/gtkmm2ext/keyboard.cc
index 5087f61a23..2bfb5fa58b 100644
--- a/libs/gtkmm2ext/keyboard.cc
+++ b/libs/gtkmm2ext/keyboard.cc
@@ -233,8 +233,9 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 	DEBUG_TRACE (
 		DEBUG::Keyboard,
 		string_compose (
-			"Snoop widget %1 key %2 type %3 state %4 magic %5\n",
-			widget, event->keyval, event->type, event->state, _some_magic_widget_has_focus
+			"Snoop widget %1 name: [%6] key %2 type %3 state %4 magic %5\n",
+			widget, event->keyval, event->type, event->state, _some_magic_widget_has_focus,
+			gtk_widget_get_name (widget)
 			)
 		);
 
@@ -324,6 +325,8 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 		}
 	}
 
+	DEBUG_TRACE (DEBUG::Keyboard, string_compose ("snooper returns %1\n", ret));
+
 	return ret;
 }
 
@@ -346,6 +349,7 @@ bool
 Keyboard::enter_window (GdkEventCrossing *, Gtk::Window* win)
 {
 	current_window = win;
+	DEBUG_TRACE (DEBUG::Keyboard, string_compose ("Entering window, title = %1\n", win->get_title()));
 	return false;
 }
 
diff --git a/libs/surfaces/wscript b/libs/surfaces/wscript
index 335d14ee87..29edc427b2 100644
--- a/libs/surfaces/wscript
+++ b/libs/surfaces/wscript
@@ -55,9 +55,12 @@ def configure(conf):
     if conf.is_defined('HAVE_CWIID_H'):
         conf.check_cc (header_name='bluetooth/bluetooth.h', define_name='HAVE_BLUETOOTH_H',mandatory=False)
         if conf.is_defined('HAVE_BLUETOOTH_H'):
-            autowaf.check_pkg(conf, 'cwiid', uselib_store='CWIID', atleast_version='0.6.00')
-            conf.define ('BUILD_WIIMOTE', 1)
-            sub_config_and_use(conf, 'wiimote')
+            autowaf.check_pkg(conf, 'cwiid', uselib_store='CWIID', atleast_version='0.6.00',mandatory=False)
+            if conf.is_defined ('HAVE_CWIID'):
+                conf.define ('BUILD_WIIMOTE', 1)
+                sub_config_and_use(conf, 'wiimote')
+            else:
+                print('You have the cwiid headers needed to compile wiimote support BUT you are missing the pkg-config file for cwiid')
         else:
             print('You are missing the libbluetooth headers needed to compile wiimote support')
     else: