Merge branch 'master' into windows+cc

Conflicts (hopefully resolved):
	gtk2_ardour/ardour_ui.cc

19 files changed, 1626 insertions, 1383 deletions

diff --git a/gtk2_ardour/ardour.menus.in b/gtk2_ardour/ardour.menus.in
index 9694556e56..6068055324 100644
--- a/gtk2_ardour/ardour.menus.in
+++ b/gtk2_ardour/ardour.menus.in
@@ -35,10 +35,9 @@
       <menuitem action='addExistingAudioFiles'/>
       <!--menuitem action='importFromSession'/-->
 
-#ifndef NOVIDEOTIMELINE
       <menuitem action='OpenVideo'/>
       <menuitem action='CloseVideo'/>
-#endif
+
       <menu name='Export' action='Export'>
         <menuitem action='ExportAudio'/>
         <menuitem action='StemExport'/>
@@ -282,9 +281,7 @@
         <menuitem action='snap-regions-to-grid'/>
         <menuitem action='toggle-region-lock'/>
         <menuitem action='toggle-region-lock-style'/>
-#ifndef NOVIDEOTIMELINE
         <menuitem action='toggle-region-video-lock'/>
-#endif
         <menuitem action='set-region-sync-position'/>
         <menuitem action='remove-region-sync'/>
         <menuitem action='nudge-forward'/>
@@ -437,9 +434,7 @@
         <menuitem action="toggle-cd-marker-ruler"/>
         <menuitem action="toggle-marker-ruler"/>
         <separator/>
-#ifndef NOVIDEOTIMELINE
         <menuitem action="toggle-video-ruler"/>
-#endif
       </menu>
       <menu action="VideoMonitorMenu">
         <menuitem action="zoom-vmon-100"/>
@@ -543,10 +538,8 @@
     <menuitem action="toggle-marker-ruler"/>
     <menuitem action="toggle-cd-marker-ruler"/>
     <menuitem action="toggle-loop-punch-ruler"/>
-#ifndef NOVIDEOTIMELINE
     <separator/>
     <menuitem action="toggle-video-ruler"/>
-#endif
   </popup>
 
   <popup name='ProcessorMenu'>
@@ -642,9 +635,7 @@
       <menuitem action='naturalize-region'/>
       <menuitem action='toggle-region-lock'/>
       <menuitem action='toggle-region-lock-style'/>
-#ifndef NOVIDEOTIMELINE
       <menuitem action='toggle-region-video-lock'/>
-#endif
       <menuitem action='snap-regions-to-grid'/>
       <menuitem action='set-region-sync-position'/>
       <menuitem action='remove-region-sync'/>
diff --git a/gtk2_ardour/ardour_button.cc b/gtk2_ardour/ardour_button.cc
index 89e6a20385..3f118921d6 100644
--- a/gtk2_ardour/ardour_button.cc
+++ b/gtk2_ardour/ardour_button.cc
@@ -162,7 +162,7 @@ ArdourButton::set_markup (const std::string& str)
 		_layout = Pango::Layout::create (get_pango_context());
 	} 
 
-	_layout->set_text (str);
+	_layout->set_markup (str);
 	queue_resize ();
 }
 
diff --git a/gtk2_ardour/ardour_button.h b/gtk2_ardour/ardour_button.h
index efa956162a..65ea10b201 100644
--- a/gtk2_ardour/ardour_button.h
+++ b/gtk2_ardour/ardour_button.h
@@ -156,7 +156,7 @@ class ArdourButton : public CairoWidget , public Gtkmm2ext::Activatable
 	bool _fixed_diameter;
 	bool _distinct_led_click;
 	bool _hovering;
-
+    
 	static bool _flat_buttons;
 
 	void setup_led_rect ();
diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index 5f3ef2d31d..b4ea8338dd 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -439,7 +439,7 @@ ARDOUR_UI::engine_halted (const char* reason, bool free_reason)
 		msgstr = string_compose (_("The audio backend was shutdown because:\n\n%1"), reason);
 	} else {
 		msgstr = string_compose (_("\
-`The audio backend has either been shutdown or it\n\
+The audio backend has either been shutdown or it\n\
 disconnected %1 because %1\n\
 was not fast enough. Try to restart\n\
 the audio backend and save the session."), PROGRAM_NAME);
@@ -800,7 +800,11 @@ ARDOUR_UI::starting ()
 		 *  audio backend end up.
 		 */
 
-		audio_midi_setup.get (true);
+		try {
+			audio_midi_setup.get (true);
+		} catch (...) {
+			return -1;
+		}
 
 		/* go get a session */
 
@@ -2851,6 +2855,22 @@ ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name,
 		}
 	}
 
+	if (!new_session->writable()) {
+		MessageDialog msg (_("This session has been opened in read-only mode.\n\nYou will not be able to record or save."),
+				   true,
+				   Gtk::MESSAGE_INFO,
+				   BUTTONS_OK);
+		
+		msg.set_keep_above (true);
+		msg.set_title (_("Read-only Session"));
+		msg.set_position (Gtk::WIN_POS_CENTER);
+		pop_back_splash (msg);
+		msg.present ();
+		(void) msg.run ();
+		msg.hide ();
+	}
+	
+
 	/* Now the session been created, add the transport controls */
 	new_session->add_controllable(roll_controllable);
 	new_session->add_controllable(stop_controllable);
@@ -3815,8 +3835,13 @@ int
 ARDOUR_UI::reconnect_to_engine ()
 {
 	if (AudioEngine::instance()->start ()) {
-		MessageDialog msg (*editor,  _("Could not reconnect to the Audio/MIDI engine"));
-		msg.run (); 
+		if (editor) {
+			MessageDialog msg (*editor,  _("Could not reconnect to the Audio/MIDI engine"));
+			msg.run ();
+		} else {
+			MessageDialog msg (_("Could not reconnect to the Audio/MIDI engine"));
+			msg.run ();
+		}
 		return -1;
 	}
 	
@@ -4133,6 +4158,7 @@ int
 ARDOUR_UI::do_audio_midi_setup (uint32_t desired_sample_rate)
 {
 	audio_midi_setup->set_desired_sample_rate (desired_sample_rate);
+	audio_midi_setup->set_position (WIN_POS_CENTER);
 
 	switch (audio_midi_setup->run()) {
 	case Gtk::RESPONSE_OK:
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index 251fc8f6fc..0ed7a95df3 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -139,7 +139,7 @@ ARDOUR_UI::install_actions ()
 					      sigc::mem_fun (*this, &ARDOUR_UI::remove_video));
 	act->set_sensitive (false);
 	act = ActionManager::register_action (main_actions, X_("ExportVideo"), _("Export To Video File"),
-					      sigc::mem_fun (*editor, &PublicEditor::export_video));
+			hide_return (sigc::bind (sigc::mem_fun(*editor, &PublicEditor::export_video), false)));
 	ActionManager::session_sensitive_actions.push_back (act);
 
 	act = ActionManager::register_action (main_actions, X_("Snapshot"), _("Snapshot..."), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::snapshot_session), false));
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index c7bdfc15da..5da1d09d8f 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -1913,6 +1913,9 @@ Editor::add_selection_context_items (Menu_Helpers::MenuList& edit_items)
 	edit_items.push_back (MenuElem (_("Bounce Range to Region List"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, false)));
 	edit_items.push_back (MenuElem (_("Bounce Range to Region List With Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, true)));
 	edit_items.push_back (MenuElem (_("Export Range..."), sigc::mem_fun(*this, &Editor::export_selection)));
+	if (ARDOUR_UI::instance()->video_timeline->get_duration() > 0) {
+		edit_items.push_back (MenuElem (_("Export Video Range..."), sigc::bind (sigc::mem_fun(*this, &Editor::export_video), true)));
+	}
 }
 
 
diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h
index 566586ebe4..c427429897 100644
--- a/gtk2_ardour/editor.h
+++ b/gtk2_ardour/editor.h
@@ -895,7 +895,7 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
 	void toggle_ruler_video (bool onoff) {ruler_video_action->set_active(onoff);}
 	int videotl_bar_height; /* in units of timebar_height; default: 4 */
 	int get_videotl_bar_height () const { return videotl_bar_height; }
-	void export_video ();
+	void export_video (bool range = false);
 	void toggle_region_video_lock ();
 
 	Gtk::VBox          time_bars_vbox;
diff --git a/gtk2_ardour/editor_videotimeline.cc b/gtk2_ardour/editor_videotimeline.cc
index 1da9fb4f19..2526d7c16a 100644
--- a/gtk2_ardour/editor_videotimeline.cc
+++ b/gtk2_ardour/editor_videotimeline.cc
@@ -111,7 +111,7 @@ Editor::embed_audio_from_video (std::string path, framepos_t n)
 }
 
 void
-Editor::export_video ()
+Editor::export_video (bool range)
 {
 	if (ARDOUR::Config->get_show_video_export_info()) {
 		ExportVideoInfobox infobox (_session);
@@ -127,7 +127,7 @@ Editor::export_video ()
 				break;
 		}
 	}
-	ExportVideoDialog dialog (_session, get_selection().time);
+	ExportVideoDialog dialog (_session, get_selection().time, range);
 	Gtk::ResponseType r = (Gtk::ResponseType) dialog.run();
 	(void) r; // keep gcc quiet
 	dialog.hide();
diff --git a/gtk2_ardour/engine_dialog.cc b/gtk2_ardour/engine_dialog.cc
index dfd24af739..47a2506f92 100644
--- a/gtk2_ardour/engine_dialog.cc
+++ b/gtk2_ardour/engine_dialog.cc
@@ -30,6 +30,7 @@
 #include "pbd/error.h"
 #include "pbd/xml++.h"
 #include "pbd/unwind.h"
+#include "pbd/failed_constructor.h"
 
 #include <gtkmm/alignment.h>
 #include <gtkmm/stock.h>
@@ -57,9 +58,14 @@ using namespace Gtkmm2ext;
 using namespace PBD;
 using namespace Glib;
 
+static const unsigned int midi_tab = -1; /* not currently in use */
+static const unsigned int latency_tab = 1; /* zero-based, page zero is the main setup page */
+
+static const char* results_markup = X_("<span foreground=\"red\" style=\"italic\" size=\"larger\">%1</span>");
+
 EngineControl::EngineControl ()
 	: ArdourDialog (_("Audio/MIDI Setup"))
-	, basic_packer (9, 3)
+	, basic_packer (9, 4)
 	, input_latency_adjustment (0, 0, 99999, 1)
 	, input_latency (input_latency_adjustment)
 	, output_latency_adjustment (0, 0, 99999, 1)
@@ -71,12 +77,14 @@ EngineControl::EngineControl ()
 	, ports_adjustment (128, 8, 1024, 1, 16)
 	, ports_spinner (ports_adjustment)
 	, control_app_button (_("Device Control Panel"))
-	, lm_start_stop_label (_("Measure latency"))
+	, lm_measure_button (_("Measure"))
 	, lm_use_button (_("Use results"))
-	, lm_table (5, 2)
+	, lm_back_button (_("Back to settings ... (ignore results)"))
+	, lm_button (_("Calibrate..."))
+	, lm_table (12, 3)
 	, have_lm_results (false)
+	, lm_running (false)
 	, midi_refresh_button (_("Refresh list"))
-	, aj_button (_("Start MIDI ALSA/JACK bridge"))
 	, ignore_changes (0)
 	, _desired_sample_rate (0)
 	, no_push (true)
@@ -94,6 +102,13 @@ EngineControl::EngineControl ()
 	 */
 
 	vector<const ARDOUR::AudioBackendInfo*> backends = ARDOUR::AudioEngine::instance()->available_backends();
+
+	if (backends.empty()) {
+		MessageDialog msg (string_compose (_("No audio/MIDI backends detected. %1 cannot run\n\n(This is a build/packaging/system error. It should never happen.)"), PROGRAM_NAME));
+		msg.run ();
+		throw failed_constructor ();
+	}
+
 	for (vector<const ARDOUR::AudioBackendInfo*>::const_iterator b = backends.begin(); b != backends.end(); ++b) {
 		strings.push_back ((*b)->name);
 	}
@@ -108,7 +123,7 @@ EngineControl::EngineControl ()
 
 	basic_packer.set_spacings (6);
 	basic_packer.set_border_width (12);
-	basic_packer.set_homogeneous (true);
+	basic_packer.set_homogeneous (false);
 
 	/* pack it in */
 
@@ -122,8 +137,10 @@ EngineControl::EngineControl ()
 	
 	row = 0;
 	lm_table.set_row_spacings (12);
-
-	lm_table.attach (lm_title, 0, 2, row, row+1, xopt, (AttachOptions) 0);
+	lm_table.set_col_spacings (6);
+	lm_table.set_homogeneous (false);
+	
+	lm_table.attach (lm_title, 0, 3, row, row+1, xopt, (AttachOptions) 0);
 	row++;
 
 	Gtk::Label* preamble;
@@ -131,17 +148,17 @@ EngineControl::EngineControl ()
 	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>"));
+	preamble->set_markup (_("<span weight=\"bold\">Turn down the volume on your audio equipment to a very low level.</span>"));
 
-	lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	lm_table.attach (*preamble, 0, 3, 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."));
+	preamble->set_markup (_("Select two channels below and connect them using a cable."));
 
-	lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	lm_table.attach (*preamble, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 	row++;
 
 	label = manage (new Label (_("Output channel")));
@@ -149,7 +166,7 @@ EngineControl::EngineControl ()
 
 	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);
+	lm_table.attach (*misc_align, 1, 3, row, row+1, xopt, (AttachOptions) 0);
 	++row;
 
 	label = manage (new Label (_("Input channel")));
@@ -157,41 +174,61 @@ EngineControl::EngineControl ()
 
 	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);
+	lm_table.attach (*misc_align, 1, 3, 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_measure_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::latency_button_clicked));
 	lm_use_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::use_latency_button_clicked));
+	lm_back_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (notebook, &Gtk::Notebook::set_current_page), 0));
+	
 	lm_use_button.set_sensitive (false);
 
+	/* Increase the default spacing around the labels of these three
+	 * buttons
+	 */
+
+	Gtk::Misc* l;
+
+	if ((l = dynamic_cast<Gtk::Misc*>(lm_measure_button.get_child())) != 0) {
+		l->set_padding (10, 10);
+	}
+
+	if ((l = dynamic_cast<Gtk::Misc*>(lm_use_button.get_child())) != 0) {
+		l->set_padding (10, 10);
+	}
+
+	if ((l = dynamic_cast<Gtk::Misc*>(lm_back_button.get_child())) != 0) {
+		l->set_padding (10, 10);
+	}
+
 	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);
+	preamble->set_markup (_("Once the channels are connected, click the \"Measure\" button."));
+	lm_table.attach (*preamble, 0, 3, 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 (*preamble, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 
-	lm_table.attach (lm_use_button, 0, 2, row, row+1, xopt, (AttachOptions) 0);
-	++row;
+	++row; // skip a row in the table 
+	++row; // skip a row in the table 
+
+	lm_table.attach (lm_results, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+
+	++row; // skip a row in the table 
+	++row; // skip a row in the table 
+
+	lm_table.attach (lm_measure_button, 0, 1, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	lm_table.attach (lm_use_button, 1, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
+	lm_table.attach (lm_back_button, 2, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 
-	lm_results.set_markup ("<i>No measurement results yet</i>");
+	lm_results.set_markup (string_compose (results_markup, _("No measurement results yet")));
 
 	lm_vbox.set_border_width (12);
 	lm_vbox.pack_start (lm_table, false, false);
@@ -199,11 +236,11 @@ EngineControl::EngineControl ()
 	/* pack it all up */
 
 	notebook.pages().push_back (TabElem (basic_vbox, _("Audio")));
-	notebook.pages().push_back (TabElem (midi_vbox, _("MIDI")));
+	// notebook.pages().push_back (TabElem (midi_vbox, _("MIDI")));
 	notebook.pages().push_back (TabElem (lm_vbox, _("Latency")));
 	notebook.set_border_width (12);
 
-	notebook.set_tab_pos (POS_RIGHT);
+	notebook.set_show_tabs (false);
 	notebook.show_all ();
 
 	notebook.set_name ("SettingsNotebook");
@@ -230,7 +267,7 @@ EngineControl::EngineControl ()
 	/* Pick up any existing audio setup configuration, if appropriate */
 
 	XMLNode* audio_setup = ARDOUR::Config->extra_xml ("AudioMIDISetup");
-	
+
 	ARDOUR::AudioEngine::instance()->Running.connect (running_connection, MISSING_INVALIDATOR, boost::bind (&EngineControl::engine_running, this), gui_context());
 	ARDOUR::AudioEngine::instance()->Stopped.connect (stopped_connection, MISSING_INVALIDATOR, boost::bind (&EngineControl::engine_stopped, this), gui_context());
 	ARDOUR::AudioEngine::instance()->Halted.connect (stopped_connection, MISSING_INVALIDATOR, boost::bind (&EngineControl::engine_stopped, this), gui_context());
@@ -247,6 +284,7 @@ EngineControl::EngineControl ()
 	sample_rate_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::sample_rate_changed));
 	buffer_size_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::buffer_size_changed));
 	device_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::device_changed));
+	midi_option_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::midi_option_changed));
 
 	input_latency.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 	output_latency.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
@@ -256,1323 +294,1385 @@ EngineControl::EngineControl ()
 	notebook.signal_switch_page().connect (sigc::mem_fun (*this, &EngineControl::on_switch_page));
 
 	no_push = false;
-}
-
-void
-EngineControl::on_response (int response_id)
-{
-	ArdourDialog::on_response (response_id);
-
-	switch (response_id) {
-	case RESPONSE_APPLY:
-		push_state_to_backend (true);
-		break;
-	case RESPONSE_OK:
-		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 ();
-	}
-}
-
-void
-EngineControl::build_notebook ()
-{
-	Label* label;
-	AttachOptions xopt = AttachOptions (FILL|EXPAND);
-
-	/* clear the table */
-
-	Gtkmm2ext::container_clear (basic_vbox);
-	Gtkmm2ext::container_clear (basic_packer);
-
-	label = manage (left_aligned_label (_("Audio System:")));
-	basic_packer.attach (*label, 0, 1, 0, 1, xopt, (AttachOptions) 0);
-	basic_packer.attach (backend_combo, 1, 2, 0, 1, xopt, (AttachOptions) 0);
-	
-	if (_have_control) {
-		build_full_control_notebook ();
-	} else {
-		build_no_control_notebook ();
-	}
-
-	basic_vbox.pack_start (basic_hbox, false, false);
-
-	if (_have_control) {
-		Gtk::HBox* hpacker = manage (new HBox);
-		hpacker->set_border_width (12);
-		hpacker->pack_start (control_app_button, false, false);
-		hpacker->show ();
-		control_app_button.show();
-		basic_vbox.pack_start (*hpacker);
-	}
-
-	basic_vbox.show_all ();
-}
-
-void
-EngineControl::build_full_control_notebook ()
-{
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	assert (backend);
-
-	using namespace Notebook_Helpers;
-	Label* label;
-	vector<string> strings;
-	AttachOptions xopt = AttachOptions (FILL|EXPAND);
-	int row = 1; // row zero == backend combo
-
-	/* start packing it up */
-
-	if (backend->requires_driver_selection()) {
-		label = manage (left_aligned_label (_("Driver:")));
-		basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
-		basic_packer.attach (driver_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
-		row++;
-	}
-
-	label = manage (left_aligned_label (_("Device:")));
-	basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
-	basic_packer.attach (device_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
-	row++;
-
-	label = manage (left_aligned_label (_("Sample rate:")));
-	basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
-	basic_packer.attach (sample_rate_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
-	row++;
-
-
-	label = manage (left_aligned_label (_("Buffer size:")));
-	basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
-	basic_packer.attach (buffer_size_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
-	buffer_size_duration_label.set_alignment (0.0); /* left-align */
-	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);
-	basic_packer.attach (input_latency, 1, 2, row, row+1, xopt, (AttachOptions) 0);
-	label = manage (left_aligned_label (_("samples")));
-	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);
-	label = manage (left_aligned_label (_("samples")));
-	basic_packer.attach (*label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
-	++row;
-
-}
-
-void
-EngineControl::build_no_control_notebook ()
-{
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	assert (backend);
-
-	using namespace Notebook_Helpers;
-	Label* label;
-	vector<string> strings;
-	AttachOptions xopt = AttachOptions (FILL|EXPAND);
-	int row = 1; // row zero == backend combo
-	const string msg = string_compose (_("The %1 audio backend was configured and started externally.\nThis limits your control over it."), backend->name());
-
-	label = manage (new Label);
-	label->set_markup (string_compose ("<span weight=\"bold\" foreground=\"red\">%1</span>", msg));
-	basic_packer.attach (*label, 0, 2, row, row + 1, xopt, (AttachOptions) 0);
-	row++;
-
-	if (backend->can_change_sample_rate_when_running()) {
-		label = manage (left_aligned_label (_("Sample rate:")));
-		basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
-		basic_packer.attach (sample_rate_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
-		row++;
-	}
-
-	if (backend->can_change_buffer_size_when_running()) {
-		label = manage (left_aligned_label (_("Buffer size:")));
-		basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
-		basic_packer.attach (buffer_size_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
-		buffer_size_duration_label.set_alignment (0.0); /* left-align */
-		basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
-		row++;
-	}
-
-	connect_disconnect_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::connect_disconnect_click));
-
-	basic_packer.attach (connect_disconnect_button, 0, 2, row, row+1, FILL, AttachOptions (0));
-	row++;
-}
-
-EngineControl::~EngineControl ()
-{
-
-}
-
-void
-EngineControl::disable_latency_tab ()
-{
-	vector<string> empty;
-	set_popdown_strings (lm_output_channel_combo, empty);
-	set_popdown_strings (lm_input_channel_combo, empty);
-	lm_measure_button.set_sensitive (false);
-	lm_use_button.set_sensitive (false);
-}
-
-void
-EngineControl::enable_latency_tab ()
-{
-	vector<string> outputs;
-	ARDOUR::AudioEngine::instance()->get_physical_outputs (ARDOUR::DataType::AUDIO, outputs);
-	set_popdown_strings (lm_output_channel_combo, outputs);
-	lm_output_channel_combo.set_active_text (outputs.front());
-
-	vector<string> inputs;
-	ARDOUR::AudioEngine::instance()->get_physical_inputs (ARDOUR::DataType::AUDIO, inputs);
-	set_popdown_strings (lm_input_channel_combo, inputs);
-	lm_input_channel_combo.set_active_text (inputs.front());
-
-	lm_measure_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
-EngineControl::update_sensitivity ()
-{
-}
-
-void
-EngineControl::backend_changed ()
-{
-	if (ignore_changes) {
-		return;
-	}
-
-	string backend_name = backend_combo.get_active_text();
-	boost::shared_ptr<ARDOUR::AudioBackend> backend;
-
-	if (!(backend = ARDOUR::AudioEngine::instance()->set_backend (backend_name, "ardour", ""))) {
-		/* eh? setting the backend failed... how ? */
-		return;
-	}
-
-	_have_control = ARDOUR::AudioEngine::instance()->setup_required ();
-
-	build_notebook ();
-	setup_midi_tab_for_backend ();
-
-	if (backend->requires_driver_selection()) {
-		vector<string> drivers = backend->enumerate_drivers();
-		
-		if (!drivers.empty()) {
-			{
-				PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
-				set_popdown_strings (driver_combo, drivers);
-				driver_combo.set_active_text (drivers.front());
-			}
-
-			driver_changed ();
-		}
-		
-	} else {
-		driver_combo.set_sensitive (false);
-		/* this will change the device text which will cause a call to
-		 * device changed which will set up parameters
+ }
+
+ void
+ EngineControl::on_response (int response_id)
+ {
+	 ArdourDialog::on_response (response_id);
+
+	 switch (response_id) {
+	 case RESPONSE_APPLY:
+		 push_state_to_backend (true);
+		 break;
+	 case RESPONSE_OK:
+		 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 ();
+	 }
+ }
+
+ void
+ EngineControl::build_notebook ()
+ {
+	 Label* label;
+	 AttachOptions xopt = AttachOptions (FILL|EXPAND);
+
+	 /* clear the table */
+
+	 Gtkmm2ext::container_clear (basic_vbox);
+	 Gtkmm2ext::container_clear (basic_packer);
+
+	 label = manage (left_aligned_label (_("Audio System:")));
+	 basic_packer.attach (*label, 0, 1, 0, 1, xopt, (AttachOptions) 0);
+	 basic_packer.attach (backend_combo, 1, 2, 0, 1, xopt, (AttachOptions) 0);
+
+	 lm_button.signal_clicked.connect (sigc::bind (sigc::mem_fun (notebook, &Gtk::Notebook::set_current_page), latency_tab));
+	 lm_button.set_name ("record enable button");
+	 if (_have_control) {
+		 build_full_control_notebook ();
+	 } else {
+		 build_no_control_notebook ();
+	 }
+
+	 basic_vbox.pack_start (basic_hbox, false, false);
+
+	 if (_have_control) {
+		 Gtk::HBox* hpacker = manage (new HBox);
+		 hpacker->set_border_width (12);
+		 hpacker->pack_start (control_app_button, false, false);
+		 hpacker->show ();
+		 control_app_button.show();
+		 basic_vbox.pack_start (*hpacker);
+	 }
+
+	 basic_vbox.show_all ();
+ }
+
+ void
+ EngineControl::build_full_control_notebook ()
+ {
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	 assert (backend);
+
+	 using namespace Notebook_Helpers;
+	 Label* label;
+	 vector<string> strings;
+	 AttachOptions xopt = AttachOptions (FILL|EXPAND);
+	 int row = 1; // row zero == backend combo
+
+	 /* start packing it up */
+
+	 if (backend->requires_driver_selection()) {
+		 label = manage (left_aligned_label (_("Driver:")));
+		 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+		 basic_packer.attach (driver_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
+		 row++;
+	 }
+
+	 label = manage (left_aligned_label (_("Device:")));
+	 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+	 basic_packer.attach (device_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
+	 row++;
+
+	 label = manage (left_aligned_label (_("Sample rate:")));
+	 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+	 basic_packer.attach (sample_rate_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
+	 row++;
+
+
+	 label = manage (left_aligned_label (_("Buffer size:")));
+	 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+	 basic_packer.attach (buffer_size_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
+	 buffer_size_duration_label.set_alignment (0.0); /* left-align */
+	 basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, SHRINK, (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);
+	 basic_packer.attach (input_latency, 1, 2, row, row+1, xopt, (AttachOptions) 0);
+	 label = manage (left_aligned_label (_("samples")));
+	 basic_packer.attach (*label, 2, 3, row, row+1, SHRINK, (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);
+	 label = manage (left_aligned_label (_("samples")));
+	 basic_packer.attach (*label, 2, 3, row, row+1, SHRINK, (AttachOptions) 0);
+
+	 /* button spans 2 rows */
+
+	 basic_packer.attach (lm_button, 3, 4, row-1, row+1, xopt, xopt);
+	 ++row;
+
+	 label = manage (left_aligned_label (_("MIDI System")));
+	 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+	 basic_packer.attach (midi_option_combo, 1, 2, row, row + 1, SHRINK, (AttachOptions) 0);
+	 row++;
+ }
+
+ void
+ EngineControl::build_no_control_notebook ()
+ {
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	 assert (backend);
+
+	 using namespace Notebook_Helpers;
+	 Label* label;
+	 vector<string> strings;
+	 AttachOptions xopt = AttachOptions (FILL|EXPAND);
+	 int row = 1; // row zero == backend combo
+	 const string msg = string_compose (_("The %1 audio backend was configured and started externally.\nThis limits your control over it."), backend->name());
+
+	 label = manage (new Label);
+	 label->set_markup (string_compose ("<span weight=\"bold\" foreground=\"red\">%1</span>", msg));
+	 basic_packer.attach (*label, 0, 2, row, row + 1, xopt, (AttachOptions) 0);
+	 row++;
+
+	 if (backend->can_change_sample_rate_when_running()) {
+		 label = manage (left_aligned_label (_("Sample rate:")));
+		 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+		 basic_packer.attach (sample_rate_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
+		 row++;
+	 }
+
+	 if (backend->can_change_buffer_size_when_running()) {
+		 label = manage (left_aligned_label (_("Buffer size:")));
+		 basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
+		 basic_packer.attach (buffer_size_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
+		 buffer_size_duration_label.set_alignment (0.0); /* left-align */
+		 basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
+		 row++;
+	 }
+
+	 connect_disconnect_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::connect_disconnect_click));
+
+	 basic_packer.attach (connect_disconnect_button, 0, 2, row, row+1, FILL, AttachOptions (0));
+	 row++;
+ }
+
+ EngineControl::~EngineControl ()
+ {
+	 ignore_changes = true;
+ }
+
+ void
+ EngineControl::disable_latency_tab ()
+ {
+	 vector<string> empty;
+	 set_popdown_strings (lm_output_channel_combo, empty);
+	 set_popdown_strings (lm_input_channel_combo, empty);
+	 lm_measure_button.set_sensitive (false);
+	 lm_use_button.set_sensitive (false);
+ }
+
+ void
+ EngineControl::enable_latency_tab ()
+ {
+	 vector<string> outputs;
+	 ARDOUR::AudioEngine::instance()->get_physical_outputs (ARDOUR::DataType::AUDIO, outputs);
+	 set_popdown_strings (lm_output_channel_combo, outputs);
+	 lm_output_channel_combo.set_active_text (outputs.front());
+
+	 vector<string> inputs;
+	 ARDOUR::AudioEngine::instance()->get_physical_inputs (ARDOUR::DataType::AUDIO, inputs);
+	 set_popdown_strings (lm_input_channel_combo, inputs);
+	 lm_input_channel_combo.set_active_text (inputs.front());
+
+	 lm_measure_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 ()
+ {
+ }	
+
+ 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
+ EngineControl::update_sensitivity ()
+ {
+ }
+
+ void
+ EngineControl::backend_changed ()
+ {
+	 if (ignore_changes) {
+		 return;
+	 }
+
+	 string backend_name = backend_combo.get_active_text();
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend;
+
+	 if (!(backend = ARDOUR::AudioEngine::instance()->set_backend (backend_name, "ardour", ""))) {
+		 /* eh? setting the backend failed... how ? */
+		 return;
+	 }
+
+	 _have_control = ARDOUR::AudioEngine::instance()->setup_required ();
+
+	 build_notebook ();
+	 setup_midi_tab_for_backend ();
+
+	 if (backend->requires_driver_selection()) {
+		 vector<string> drivers = backend->enumerate_drivers();
+
+		 if (!drivers.empty()) {
+			 {
+				 PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
+				 set_popdown_strings (driver_combo, drivers);
+				 driver_combo.set_active_text (drivers.front());
+			 }
+
+			 driver_changed ();
+		 }
+
+	 } else {
+		 driver_combo.set_sensitive (false);
+		 /* this will change the device text which will cause a call to
+		  * device changed which will set up parameters
+		  */
+		 list_devices ();
+	 }
+
+	 vector<string> midi_options = backend->enumerate_midi_options();
+
+	 if (midi_options.size() == 1) {
+		 /* only contains the "none" option */
+		 midi_option_combo.set_sensitive (false);
+	 } else {
+		 if (_have_control) {
+			 set_popdown_strings (midi_option_combo, midi_options);
+			 midi_option_combo.set_active_text (midi_options.front());
+			 midi_option_combo.set_sensitive (true);
+		 } else {
+			 midi_option_combo.set_sensitive (false);
+		 }
+	 }
+
+	 maybe_display_saved_state ();
+ }
+
+ bool
+ EngineControl::print_channel_count (Gtk::SpinButton* sb)
+ {
+	 uint32_t cnt = (uint32_t) sb->get_value();
+	 if (cnt == 0) {
+		 sb->set_text (_("all available channels"));
+	 } else {
+		 char buf[32];
+		 snprintf (buf, sizeof (buf), "%d", cnt);
+		 sb->set_text (buf);
+	 }
+	 return true;
+ }
+
+ void
+ EngineControl::list_devices ()
+ {
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	 assert (backend);
+
+	 /* now fill out devices, mark sample rates, buffer sizes insensitive */
+
+	 vector<ARDOUR::AudioBackend::DeviceStatus> all_devices = backend->enumerate_devices ();
+
+	 /* NOTE: Ardour currently does not display the "available" field of the
+	  * returned devices.
+	  *
+	  * Doing so would require a different GUI widget than the combo
+	  * box/popdown that we currently use, since it has no way to list
+	  * items that are not selectable. Something more like a popup menu,
+	  * which could have unselectable items, would be appropriate.
+	  */
+
+	 vector<string> available_devices;
+
+	 for (vector<ARDOUR::AudioBackend::DeviceStatus>::const_iterator i = all_devices.begin(); i != all_devices.end(); ++i) {
+		 available_devices.push_back (i->name);
+	 }
+
+	 if (!available_devices.empty()) {
+
+		 update_sensitivity ();
+
+		 {
+			 PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
+			 set_popdown_strings (device_combo, available_devices);
+			 device_combo.set_active_text (available_devices.front());
+		 }
+
+		 device_changed ();
+
+		 ok_button->set_sensitive (true);
+		 apply_button->set_sensitive (true);
+
+	 } else {
+		 sample_rate_combo.set_sensitive (false);
+		 buffer_size_combo.set_sensitive (false);
+		 input_latency.set_sensitive (false);
+		 output_latency.set_sensitive (false);
+		 input_channels.set_sensitive (false);
+		 output_channels.set_sensitive (false);
+		 ok_button->set_sensitive (false);
+		 apply_button->set_sensitive (false);
+	 }
+ }
+
+ void
+ EngineControl::driver_changed ()
+ {
+	 if (ignore_changes) {
+		 return;
+	 }
+
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	 assert (backend);
+
+	 backend->set_driver (driver_combo.get_active_text());
+	 list_devices ();
+
+	 maybe_display_saved_state ();
+ }
+
+ void
+ EngineControl::device_changed ()
+ {
+	 if (ignore_changes) {
+		 return;
+	 }
+
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	 assert (backend);
+	 string device_name = device_combo.get_active_text ();
+	 vector<string> s;
+
+	 {
+		 PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
+
+		 /* don't allow programmatic change to combos to cause a
+		    recursive call to this method.
 		 */
-		list_devices ();
-	}
-	
-	maybe_display_saved_state ();
-}
 
-bool
-EngineControl::print_channel_count (Gtk::SpinButton* sb)
-{
-	uint32_t cnt = (uint32_t) sb->get_value();
-	if (cnt == 0) {
-		sb->set_text (_("all available channels"));
-	} else {
-		char buf[32];
-		snprintf (buf, sizeof (buf), "%d", cnt);
-		sb->set_text (buf);
-	}
-	return true;
-}
-
-void
-EngineControl::list_devices ()
-{
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	assert (backend);
-
-	/* now fill out devices, mark sample rates, buffer sizes insensitive */
-	    
-	vector<ARDOUR::AudioBackend::DeviceStatus> all_devices = backend->enumerate_devices ();
-	
-	/* NOTE: Ardour currently does not display the "available" field of the
-	 * returned devices.
-	 *
-	 * Doing so would require a different GUI widget than the combo
-	 * box/popdown that we currently use, since it has no way to list
-	 * items that are not selectable. Something more like a popup menu,
-	 * which could have unselectable items, would be appropriate.
+		 /* sample rates */
+
+		 string desired;
+
+		 vector<float> sr;
+
+		 if (_have_control) {
+			 sr = backend->available_sample_rates (device_name);
+		 } else {
+
+			 sr.push_back (8000.0f);
+			 sr.push_back (16000.0f);
+			 sr.push_back (32000.0f);
+			 sr.push_back (44100.0f);
+			 sr.push_back (48000.0f);
+			 sr.push_back (88200.0f);
+			 sr.push_back (96000.0f);
+			 sr.push_back (192000.0f);
+			 sr.push_back (384000.0f);
+		 }
+
+		 for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
+			 s.push_back (rate_as_string (*x));
+			 if (*x == _desired_sample_rate) {
+				 desired = s.back();
+			 }
+		 }
+
+		 if (!s.empty()) {
+			 sample_rate_combo.set_sensitive (true);
+			 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_sensitive (false);
+		 }
+
+		 /* buffer sizes */
+
+		 vector<uint32_t> bs;
+
+		 if (_have_control) {
+			 bs = backend->available_buffer_sizes(device_name);
+		 } else if (backend->can_change_buffer_size_when_running()) {
+			 bs.push_back (8);
+			 bs.push_back (16);
+			 bs.push_back (32);
+			 bs.push_back (64);
+			 bs.push_back (128);
+			 bs.push_back (256);
+			 bs.push_back (512);
+			 bs.push_back (1024);
+			 bs.push_back (2048);
+			 bs.push_back (4096);
+			 bs.push_back (8192);
+		 }
+		 s.clear ();
+		 for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
+			 s.push_back (bufsize_as_string (*x));
+		 }
+
+		 if (!s.empty()) {
+			 buffer_size_combo.set_sensitive (true);
+			 set_popdown_strings (buffer_size_combo, s);
+
+			 buffer_size_combo.set_active_text (s.front());
+			 show_buffer_duration ();
+		 } else {
+			 buffer_size_combo.set_sensitive (false);
+		 }
+
+		 /* XXX theoretically need to set min + max channel counts here
+		  */
+
+		 manage_control_app_sensitivity ();
+	 }
+
+	 /* pick up any saved state for this device */
+
+	 maybe_display_saved_state ();
+
+	 /* and push it to the backend */
+
+	 push_state_to_backend (false);
+ }	
+
+ string
+ EngineControl::bufsize_as_string (uint32_t sz)
+ {
+	 /* Translators: "samples" is always plural here, so no
+	    need for plural+singular forms.
 	 */
-
-	vector<string> available_devices;
-
-	for (vector<ARDOUR::AudioBackend::DeviceStatus>::const_iterator i = all_devices.begin(); i != all_devices.end(); ++i) {
-		available_devices.push_back (i->name);
-	}
-
-	if (!available_devices.empty()) {
-
-		update_sensitivity ();
-						
-		{
-			PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
-			set_popdown_strings (device_combo, available_devices);
-			device_combo.set_active_text (available_devices.front());
-		}
-
-		device_changed ();
-
-		ok_button->set_sensitive (true);
-		apply_button->set_sensitive (true);
-
-	} else {
-		sample_rate_combo.set_sensitive (false);
-		buffer_size_combo.set_sensitive (false);
-		input_latency.set_sensitive (false);
-		output_latency.set_sensitive (false);
-		input_channels.set_sensitive (false);
-		output_channels.set_sensitive (false);
-		ok_button->set_sensitive (false);
-		apply_button->set_sensitive (false);
-	}
-}
-
-void
-EngineControl::driver_changed ()
-{
-	if (ignore_changes) {
-		return;
-	}
-
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	assert (backend);
-
-	backend->set_driver (driver_combo.get_active_text());
-	list_devices ();
-
-	maybe_display_saved_state ();
-}
-
-void
-EngineControl::device_changed ()
-{
-	if (ignore_changes) {
-		return;
-	}
-
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	assert (backend);
-	string device_name = device_combo.get_active_text ();
-	vector<string> s;
-
-	{
-		PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
-
-		/* don't allow programmatic change to combos to cause a
-		   recursive call to this method.
-		*/
-		
-		/* sample rates */
-		
-		string desired;
-		
-		vector<float> sr;
-
-		if (_have_control) {
-			sr = backend->available_sample_rates (device_name);
-		} else {
-
-			sr.push_back (8000.0f);
-			sr.push_back (16000.0f);
-			sr.push_back (32000.0f);
-			sr.push_back (44100.0f);
-			sr.push_back (48000.0f);
-			sr.push_back (88200.0f);
-			sr.push_back (96000.0f);
-			sr.push_back (192000.0f);
-			sr.push_back (384000.0f);
-		}
-
-		for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
-			s.push_back (rate_as_string (*x));
-			if (*x == _desired_sample_rate) {
-				desired = s.back();
-			}
-		}
-		
-		if (!s.empty()) {
-			sample_rate_combo.set_sensitive (true);
-			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_sensitive (false);
-		}
-
-		/* buffer sizes */
-		
-		vector<uint32_t> bs;
-		
-		if (_have_control) {
-			bs = backend->available_buffer_sizes(device_name);
-		} else if (backend->can_change_buffer_size_when_running()) {
-			bs.push_back (8);
-			bs.push_back (16);
-			bs.push_back (32);
-			bs.push_back (64);
-			bs.push_back (128);
-			bs.push_back (256);
-			bs.push_back (512);
-			bs.push_back (1024);
-			bs.push_back (2048);
-			bs.push_back (4096);
-			bs.push_back (8192);
-		}
-		s.clear ();
-		for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
-			s.push_back (bufsize_as_string (*x));
-		}
-		
-		if (!s.empty()) {
-			buffer_size_combo.set_sensitive (true);
-			set_popdown_strings (buffer_size_combo, s);
-			
-			buffer_size_combo.set_active_text (s.front());
-			show_buffer_duration ();
-		} else {
-			buffer_size_combo.set_sensitive (false);
-		}
-
-		/* XXX theoretically need to set min + max channel counts here
-		 */
-		
-		manage_control_app_sensitivity ();
-	}
-
-	/* pick up any saved state for this device */
-
-	maybe_display_saved_state ();
-
-	/* and push it to the backend */
-
-	push_state_to_backend (false);
-}	
-
-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 ()
-{
-	if (ignore_changes) {
-		return;
-	}
-
-	/* reset the strings for buffer size to show the correct msec value
-	   (reflecting the new sample rate).
-	*/
-
-	show_buffer_duration ();
-	save_state ();
-
-}
-
-void 
-EngineControl::buffer_size_changed ()
-{
-	if (ignore_changes) {
-		return;
-	}
-
-	show_buffer_duration ();
-	save_state ();
-}
-
-void
-EngineControl::show_buffer_duration ()
-{
-
-	/* buffer sizes  - convert from just samples to samples + msecs for
-	 * the displayed string
+	 char buf[32];
+	 snprintf (buf, sizeof (buf), _("%u samples"), sz);
+	 return buf;
+ }
+
+ void 
+ EngineControl::sample_rate_changed ()
+ {
+	 if (ignore_changes) {
+		 return;
+	 }
+
+	 /* reset the strings for buffer size to show the correct msec value
+	    (reflecting the new sample rate).
 	 */
 
-	string bs_text = buffer_size_combo.get_active_text ();
-	uint32_t samples = atoi (bs_text); /* will ignore trailing text */
-	uint32_t rate = get_rate();
-
-	/* Translators: "msecs" is ALWAYS plural here, so we do not
-	   need singular form as well.
-	*/
-	/* Developers: note the hard-coding of a double buffered model
-	   in the (2 * samples) computation of latency. we always start
-	   the audiobackend in this configuration.
-	*/
-	char buf[32];
-	snprintf (buf, sizeof (buf), _("(%.1f msecs)"), (2 * samples) / (rate/1000.0));
-	buffer_size_duration_label.set_text (buf);
-}
-
-void
-EngineControl::parameter_changed ()
-{
-	if (!ignore_changes) {
-		save_state ();
-	}
-}
-
-EngineControl::State*
-EngineControl::get_matching_state (const string& backend,
-				   const string& driver,
-				   const string& device)
-{
-	for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
-		if ((*i).backend == backend &&
-		    (*i).driver == driver &&
-		    (*i).device == device) {
-			return &(*i);
-		}
-	}
-	return 0;
-}
-
-EngineControl::State*
-EngineControl::get_saved_state_for_currently_displayed_backend_and_device ()
-{
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-
-	if (backend) {
-		return get_matching_state (backend_combo.get_active_text(),
-					   (backend->requires_driver_selection() ? (std::string) driver_combo.get_active_text() : string()),
-					   device_combo.get_active_text());
-	}
-
-
-	return get_matching_state (backend_combo.get_active_text(),
-				   string(),
-				   device_combo.get_active_text());
-}
-
-EngineControl::State*
-EngineControl::save_state ()
-{
-	if (!_have_control) {
-		return 0;
-	}
-
-	bool existing = true;
-	State* state = get_saved_state_for_currently_displayed_backend_and_device ();
-
-	if (!state) {
-		existing = false;
-		state = new State;
-	}
-	
-	store_state (*state);
-
-	if (!existing) {
-		states.push_back (*state);
-	}
-
-	return 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 ()
-{
-	if (!_have_control) {
-		return;
-	}
-
-	State* state = get_saved_state_for_currently_displayed_backend_and_device ();
-
-	if (state) {
-		PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
-
-		if (!_desired_sample_rate) {
-			sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
-		}
-		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);
-	}
-}
-	
-XMLNode&
-EngineControl::get_state ()
-{
-	XMLNode* root = new XMLNode ("AudioMIDISetup");
-	std::string path;
-
-	if (!states.empty()) {
-		XMLNode* state_nodes = new XMLNode ("EngineStates");
-		
-		for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
-			
-			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 ("sample-rate", (*i).sample_rate);
-			node->add_property ("buffer-size", (*i).buffer_size);
-			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");
-			
-			state_nodes->add_child_nocopy (*node);
-		}
-		
-		root->add_child_nocopy (*state_nodes);
-	}
-
-	return *root;
-}
-
-void
-EngineControl::set_state (const XMLNode& root)
-{
-	XMLNodeList          clist, cclist;
-	XMLNodeConstIterator citer, cciter;
-	XMLNode* child;
-	XMLNode* grandchild;
-	XMLProperty* prop = NULL;
-
-	if (root.name() != "AudioMIDISetup") {
-		return;
-	}
-
-	clist = root.children();
-
-	states.clear ();
-
-	for (citer = clist.begin(); citer != clist.end(); ++citer) {
-
-		child = *citer;
-		
-		if (child->name() != "EngineStates") {
-			continue;
-		}
-
-		cclist = child->children();
-
-		for (cciter = cclist.begin(); cciter != cclist.end(); ++cciter) {
-			State state;
-			
-			grandchild = *cciter;
-
-			if (grandchild->name() != "State") {
-				continue;
-			}
-			
-			if ((prop = grandchild->property ("backend")) == 0) {
-				continue;
-			}
-			state.backend = prop->value ();
-			
-			if ((prop = grandchild->property ("driver")) == 0) {
-				continue;
-			}
-			state.driver = prop->value ();
-			
-			if ((prop = grandchild->property ("device")) == 0) {
-				continue;
-			}
-			state.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 ("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 ());
-			
-			states.push_back (state);
-		}
-	}
-
-	/* now see if there was an active state and switch the setup to it */
-	
-	for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
-
-		if ((*i).active) {
-			ignore_changes++;
-			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 (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--;
-			break;
-		}
-	}
-}
-
-
-int
-EngineControl::push_state_to_backend (bool start)
-{
-	if (no_push) {
-		return 0;
-	}
-
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-
-	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 ();
-
-	if (_have_control) {
-
-		if (started_at_least_once) {
-			
-			/* we can control the backend */
-			
-			if (backend->requires_driver_selection()) {
-				if (get_driver() != backend->driver_name()) {
-					change_driver = true;
-				}
-			}
-			
-			if (get_device_name() != backend->device_name()) {
-				change_device = true;
-			}
-			
-			if (get_rate() != backend->sample_rate()) {
-				change_rate = true;
-			}
-			
-			if (get_buffer_size() != backend->buffer_size()) {
-				change_bufsize = true;
-			}
-			
-			/* zero-requested channels means "all available" */
-
-			if (ichan == 0) {
-				ichan = backend->input_channels();
-			}
-			
-			if (ochan == 0) {
-				ochan = backend->output_channels();
-			}
-			
-			if (ichan != backend->input_channels()) {
-				change_channels = true;
-			}
-			
-			if (ochan != backend->output_channels()) {
-				change_channels = true;
-			}
-
-			if (get_input_latency() != backend->systemic_input_latency() ||
-			    get_output_latency() != backend->systemic_output_latency()) {
-				change_latency = true;
-			}
-		} else {
-			/* backend never started, so we have to force a group
-			   of settings.
-			*/
-			change_driver = true;
-			change_device = true;
-			change_rate = true;
-			change_bufsize = true;
-			change_channels = true;
-			change_latency = true;
-		}
-
-	} else {
-
-		/* we have no control over the backend, meaning that we can
-		 * only possibly change sample rate and buffer size.
-		 */
-
-
-		if (get_rate() != backend->sample_rate()) {
-			change_bufsize = true;
-		}
-
-		if (get_buffer_size() != backend->buffer_size()) {
-			change_bufsize = true;
-		}
-	}
-
-	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.
-		 */
-
-		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 (change_rate) {
-			backend->set_sample_rate (get_rate());
-		}
-		
-		if (change_bufsize) {
-			backend->set_buffer_size (get_buffer_size());
-		}
-
-		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;
-	}
+	 show_buffer_duration ();
+	 save_state ();
 
-	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;
-			}
-		}
-	}
+ void 
+ EngineControl::buffer_size_changed ()
+ {
+	 if (ignore_changes) {
+		 return;
+	 }
 
-	if (was_running) {
-		if (restart_required) {
-			if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
-				return -1;
-			}
-		}
-	}
-		
+	 show_buffer_duration ();
+	 save_state ();
+ }
 
-	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;
-	}
+ void
+ EngineControl::show_buffer_duration ()
+ {
 
-	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 ();
+	 /* buffer sizes  - convert from just samples to samples + msecs for
+	  * the displayed string
+	  */
 
-	return 0;
-}
+	 string bs_text = buffer_size_combo.get_active_text ();
+	 uint32_t samples = atoi (bs_text); /* will ignore trailing text */
+	 uint32_t rate = get_rate();
 
-void
-EngineControl::post_push ()
-{
-	/* get a pointer to the current state object, creating one if
-	 * necessary
+	 /* Translators: "msecs" is ALWAYS plural here, so we do not
+	    need singular form as well.
 	 */
-	
-	if (_have_control) {
-		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
-{
-	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.
+	 /* Developers: note the hard-coding of a double buffered model
+	    in the (2 * samples) computation of latency. we always start
+	    the audiobackend in this configuration.
 	 */
-	if (r < 1000.0) {
-		r *= 1000.0;
-	}
-	return r;
-}
-	
-
-uint32_t
-EngineControl::get_buffer_size () const
-{
-	string txt = buffer_size_combo.get_active_text ();
-	uint32_t samples;
-
-	if (sscanf (txt.c_str(), "%d", &samples) != 1) {
-		throw exception ();
-	}
-
-	return samples;
-}
-
-uint32_t
-EngineControl::get_input_channels() const
-{
-	return (uint32_t) input_channels_adjustment.get_value();
-}
-
-uint32_t
-EngineControl::get_output_channels() const
-{
-	return (uint32_t) output_channels_adjustment.get_value();
-}
-
-uint32_t
-EngineControl::get_input_latency() const
-{
-	return (uint32_t) input_latency_adjustment.get_value();
-}
-
-uint32_t
-EngineControl::get_output_latency() const
-{
-	return (uint32_t) output_latency_adjustment.get_value();
-}
-
-string
-EngineControl::get_backend () const
-{
-	return backend_combo.get_active_text ();
-}
-
-string
-EngineControl::get_driver () const
-{
-	return driver_combo.get_active_text ();
-}
-
-string
-EngineControl::get_device_name () const
-{
-	return device_combo.get_active_text ();
-}
-
-void
-EngineControl::control_app_button_clicked ()
-{
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	
-	if (!backend) {
-		return;
-	}
-	
-	backend->launch_control_app ();
-}
-
-void
-EngineControl::manage_control_app_sensitivity ()
-{
-	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
-	
-	if (!backend) {
-		return;
-	}
-	
-	string appname = backend->control_app_name();
-
-	if (appname.empty()) {
-		control_app_button.set_sensitive (false);
-	} else {
-		control_app_button.set_sensitive (true);
-	}
-}
-
-void
-EngineControl::set_desired_sample_rate (uint32_t sr)
-{
-	_desired_sample_rate = sr;
-	device_changed ();
-}
-
-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);
-	}
+	 char buf[32];
+	 snprintf (buf, sizeof (buf), _("(%.1f msecs)"), (2 * samples) / (rate/1000.0));
+	 buffer_size_duration_label.set_text (buf);
+ }
+
+ void
+ EngineControl::midi_option_changed ()
+ {
+	 if (!ignore_changes) {
+		 save_state ();
+	 }
+ }
+
+ void
+ EngineControl::parameter_changed ()
+ {
+	 if (!ignore_changes) {
+		 save_state ();
+	 }
+ }
+
+ EngineControl::State*
+ EngineControl::get_matching_state (const string& backend,
+				    const string& driver,
+				    const string& device)
+ {
+	 for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
+		 if ((*i).backend == backend &&
+		     (*i).driver == driver &&
+		     (*i).device == device) {
+			 return &(*i);
+		 }
+	 }
+	 return 0;
+ }
+
+ EngineControl::State*
+ EngineControl::get_saved_state_for_currently_displayed_backend_and_device ()
+ {
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+
+	 if (backend) {
+		 return get_matching_state (backend_combo.get_active_text(),
+					    (backend->requires_driver_selection() ? (std::string) driver_combo.get_active_text() : string()),
+					    device_combo.get_active_text());
+	 }
+
+
+	 return get_matching_state (backend_combo.get_active_text(),
+				    string(),
+				    device_combo.get_active_text());
+ }
+
+ EngineControl::State*
+ EngineControl::save_state ()
+ {
+	 if (!_have_control) {
+		 return 0;
+	 }
+
+	 bool existing = true;
+	 State* state = get_saved_state_for_currently_displayed_backend_and_device ();
+
+	 if (!state) {
+		 existing = false;
+		 state = new State;
+	 }
+
+	 store_state (*state);
+
+	 if (!existing) {
+		 states.push_back (*state);
+	 }
+
+	 return 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 ();
+	 state.midi_option = get_midi_option ();
+ }
+
+ void
+ EngineControl::maybe_display_saved_state ()
+ {
+	 if (!_have_control) {
+		 return;
+	 }
+
+	 State* state = get_saved_state_for_currently_displayed_backend_and_device ();
+
+	 if (state) {
+		 PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
+
+		 if (!_desired_sample_rate) {
+			 sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
+		 }
+		 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);
+
+		 if (!state->midi_option.empty()) {
+			 midi_option_combo.set_active_text (state->midi_option);
+		 }
+	 }
+ }
 
-	if (page_num == 1) {
-		/* MIDI tab */
-		refresh_midi_display ();
-	}
+ XMLNode&
+ EngineControl::get_state ()
+ {
+	 XMLNode* root = new XMLNode ("AudioMIDISetup");
+	 std::string path;
+
+	 if (!states.empty()) {
+		 XMLNode* state_nodes = new XMLNode ("EngineStates");
+
+		 for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
+
+			 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 ("sample-rate", (*i).sample_rate);
+			 node->add_property ("buffer-size", (*i).buffer_size);
+			 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 ("midi-option", (*i).midi_option);
+
+			 state_nodes->add_child_nocopy (*node);
+		 }
+
+		 root->add_child_nocopy (*state_nodes);
+	 }
+
+	 return *root;
+ }
+
+ void
+ EngineControl::set_state (const XMLNode& root)
+ {
+	 XMLNodeList          clist, cclist;
+	 XMLNodeConstIterator citer, cciter;
+	 XMLNode* child;
+	 XMLNode* grandchild;
+	 XMLProperty* prop = NULL;
+
+	 if (root.name() != "AudioMIDISetup") {
+		 return;
+	 }
+
+	 clist = root.children();
+
+	 states.clear ();
+
+	 for (citer = clist.begin(); citer != clist.end(); ++citer) {
+
+		 child = *citer;
+
+		 if (child->name() != "EngineStates") {
+			 continue;
+		 }
+
+		 cclist = child->children();
+
+		 for (cciter = cclist.begin(); cciter != cclist.end(); ++cciter) {
+			 State state;
+
+			 grandchild = *cciter;
+
+			 if (grandchild->name() != "State") {
+				 continue;
+			 }
+
+			 if ((prop = grandchild->property ("backend")) == 0) {
+				 continue;
+			 }
+			 state.backend = prop->value ();
+
+			 if ((prop = grandchild->property ("driver")) == 0) {
+				 continue;
+			 }
+			 state.driver = prop->value ();
+
+			 if ((prop = grandchild->property ("device")) == 0) {
+				 continue;
+			 }
+			 state.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 ("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 ("midi-option")) == 0) {
+				 continue;
+			 }
+			 state.midi_option = prop->value ();
 
-	if (page_num == 2) {
-		/* latency tab */
+			 states.push_back (state);
+		 }
+	 }
+
+	 /* now see if there was an active state and switch the setup to it */
+
+	 for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
+
+		 if ((*i).active) {
+			 ignore_changes++;
+			 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 (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);
+			 midi_option_combo.set_active_text ((*i).midi_option);
+			 ignore_changes--;
+			 break;
+		 }
+	 }
+ }
+
+
+ int
+ EngineControl::push_state_to_backend (bool start)
+ {
+	 if (no_push) {
+		 return 0;
+	 }
+
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+
+	 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;
+	 bool change_midi = false;
+
+	 uint32_t ochan = get_output_channels ();
+	 uint32_t ichan = get_input_channels ();
+
+	 if (_have_control) {
+
+		 if (started_at_least_once) {
+
+			 /* we can control the backend */
+
+			 if (backend->requires_driver_selection()) {
+				 if (get_driver() != backend->driver_name()) {
+					 change_driver = true;
+				 }
+			 }
+
+			 if (get_device_name() != backend->device_name()) {
+				 change_device = true;
+			 }
+
+			 if (get_rate() != backend->sample_rate()) {
+				 change_rate = true;
+			 }
+
+			 if (get_buffer_size() != backend->buffer_size()) {
+				 change_bufsize = true;
+			 }
+
+			 if (get_midi_option() != backend->midi_option()) {
+				 change_midi = true;
+			 }
+
+			 /* zero-requested channels means "all available" */
+
+			 if (ichan == 0) {
+				 ichan = backend->input_channels();
+			 }
+
+			 if (ochan == 0) {
+				 ochan = backend->output_channels();
+			 }
+
+			 if (ichan != backend->input_channels()) {
+				 change_channels = true;
+			 }
+
+			 if (ochan != backend->output_channels()) {
+				 change_channels = true;
+			 }
+
+			 if (get_input_latency() != backend->systemic_input_latency() ||
+			     get_output_latency() != backend->systemic_output_latency()) {
+				 change_latency = true;
+			 }
+		 } else {
+			 /* backend never started, so we have to force a group
+			    of settings.
+			 */
+			 change_driver = true;
+			 change_device = true;
+			 change_rate = true;
+			 change_bufsize = true;
+			 change_channels = true;
+			 change_latency = true;
+			 change_midi = true;
+		 }
+
+	 } else {
+
+		 /* we have no control over the backend, meaning that we can
+		  * only possibly change sample rate and buffer size.
+		  */
+
+
+		 if (get_rate() != backend->sample_rate()) {
+			 change_bufsize = true;
+		 }
+
+		 if (get_buffer_size() != backend->buffer_size()) {
+			 change_bufsize = true;
+		 }
+	 }
+
+	 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.
+		  */
+
+		 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 (change_rate) {
+			 backend->set_sample_rate (get_rate());
+		 }
+
+		 if (change_bufsize) {
+			 backend->set_buffer_size (get_buffer_size());
+		 }
+
+		 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_midi ||
+	     (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 && !change_midi) {
+			 /* 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;
+			 }
+		 }
+	 }
+
+
+	 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 (change_midi) {
+		 backend->set_midi_option (get_midi_option());
+	 }
+
+	 if (start || (was_running && restart_required)) {
+		 if (ARDOUR_UI::instance()->reconnect_to_engine()) {
+			 return -1;
+		 }
+	 }
+
+	 post_push ();
+
+	 return 0;
+ }
+
+ void
+ EngineControl::post_push ()
+ {
+	 /* get a pointer to the current state object, creating one if
+	  * necessary
+	  */
+
+	 if (_have_control) {
+		 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
+ {
+	 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 r;
+ }
+
+
+ uint32_t
+ EngineControl::get_buffer_size () const
+ {
+	 string txt = buffer_size_combo.get_active_text ();
+	 uint32_t samples;
+
+	 if (sscanf (txt.c_str(), "%d", &samples) != 1) {
+		 throw exception ();
+	 }
+
+	 return samples;
+ }
+
+ string
+ EngineControl::get_midi_option () const
+ {
+	 return midi_option_combo.get_active_text();
+ }
+
+ uint32_t
+ EngineControl::get_input_channels() const
+ {
+	 return (uint32_t) input_channels_adjustment.get_value();
+ }
+
+ uint32_t
+ EngineControl::get_output_channels() const
+ {
+	 return (uint32_t) output_channels_adjustment.get_value();
+ }
+
+ uint32_t
+ EngineControl::get_input_latency() const
+ {
+	 return (uint32_t) input_latency_adjustment.get_value();
+ }
+
+ uint32_t
+ EngineControl::get_output_latency() const
+ {
+	 return (uint32_t) output_latency_adjustment.get_value();
+ }
+
+ string
+ EngineControl::get_backend () const
+ {
+	 return backend_combo.get_active_text ();
+ }
+
+ string
+ EngineControl::get_driver () const
+ {
+	 return driver_combo.get_active_text ();
+ }
+
+ string
+ EngineControl::get_device_name () const
+ {
+	 return device_combo.get_active_text ();
+ }
+
+ void
+ EngineControl::control_app_button_clicked ()
+ {
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+
+	 if (!backend) {
+		 return;
+	 }
+
+	 backend->launch_control_app ();
+ }
+
+ void
+ EngineControl::manage_control_app_sensitivity ()
+ {
+	 boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+
+	 if (!backend) {
+		 return;
+	 }
+
+	 string appname = backend->control_app_name();
+
+	 if (appname.empty()) {
+		 control_app_button.set_sensitive (false);
+	 } else {
+		 control_app_button.set_sensitive (true);
+	 }
+ }
+
+ void
+ EngineControl::set_desired_sample_rate (uint32_t sr)
+ {
+	 _desired_sample_rate = sr;
+	 device_changed ();
+ }
+
+ 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 == midi_tab) {
+		 /* MIDI tab */
+		 refresh_midi_display ();
+	 }
+
+	 if (page_num == latency_tab) {
+		 /* latency tab */
+
+		 if (!ARDOUR::AudioEngine::instance()->running()) {
+
+			 PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
+
+			 /* save any existing latency values */
+
+			 uint32_t il = (uint32_t) input_latency.get_value ();
+			 uint32_t ol = (uint32_t) input_latency.get_value ();
+
+			 /* reset to zero so that our new test instance of JACK
+			    will be clean of any existing latency measures.
+			 */
 
-		if (!ARDOUR::AudioEngine::instance()->running()) {
-			
-			PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
-			
-			/* save any existing latency values */
-			
-			uint32_t il = (uint32_t) input_latency.get_value ();
-			uint32_t ol = (uint32_t) input_latency.get_value ();
+			 input_latency.set_value (0);
+			 output_latency.set_value (0);
 
-			/* reset to zero so that our new test instance of JACK
-			   will be clean of any existing latency measures.
-			*/
-			
-			input_latency.set_value (0);
-			output_latency.set_value (0);
-			
-			/* reset control */
+			 /* reset control */
 
-			input_latency.set_value (il);
-			output_latency.set_value (ol);
+			 input_latency.set_value (il);
+			 output_latency.set_value (ol);
 
-		} 
+		 } 
 
-		if (ARDOUR::AudioEngine::instance()->prepare_for_latency_measurement()) {
-			disable_latency_tab ();
-		}
+		 if (ARDOUR::AudioEngine::instance()->prepare_for_latency_measurement()) {
+			 disable_latency_tab ();
+		 }
 
-		enable_latency_tab ();
+		 enable_latency_tab ();
 
-	} else {
-		ARDOUR::AudioEngine::instance()->stop_latency_detection();
-	}
-}
+	 } else {
+		 ARDOUR::AudioEngine::instance()->stop_latency_detection();
+	 }
+ }
 
-/* latency measurement */
+ /* latency measurement */
 
-bool
-EngineControl::check_latency_measurement ()
-{
-        MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
+ bool
+ EngineControl::check_latency_measurement ()
+ {
+	 MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
 
-        if (mtdm->resolve () < 0) {
-		lm_results.set_markup (string_compose ("<span foreground=\"red\">%1</span>", _("No signal detected ")));
-                return true;
-        }
+	 if (mtdm->resolve () < 0) {
+		 lm_results.set_markup (string_compose (results_markup, _("No signal detected ")));
+		 return true;
+	 }
 
-        if (mtdm->err () > 0.3) {
-                mtdm->invert ();
-                mtdm->resolve ();
-        }
+	 if (mtdm->err () > 0.3) {
+		 mtdm->invert ();
+		 mtdm->resolve ();
+	 }
 
-        char buf[128];
-	ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
+	 char buf[128];
+	 ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
 
-        if (sample_rate == 0) {
-                lm_results.set_text (_("Disconnected from audio engine"));
-		ARDOUR::AudioEngine::instance()->stop_latency_detection ();
-                return false;
-        }
+	 if (sample_rate == 0) {
+		 lm_results.set_markup (string_compose (results_markup, _("Disconnected from audio engine")));
+		 ARDOUR::AudioEngine::instance()->stop_latency_detection ();
+		 return false;
+	 }
 
-	uint32_t frames_total = mtdm->del();
-	uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
+	 uint32_t frames_total = mtdm->del();
+	 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);
+	 snprintf (buf, sizeof (buf), "%u samples / %.3lf ms", extra, extra * 1000.0f/sample_rate);
 
-        bool solid = true;
+	 bool solid = true;
 
-        if (mtdm->err () > 0.2) {
-                strcat (buf, " ??");
-                solid = false;
-        }
+	 if (mtdm->err () > 0.2) {
+		 strcat (buf, " ");
+		 strcat (buf, _("(signal detection error)"));
+		 solid = false;
+	 }
 
-        if (mtdm->inv ()) {
-                strcat (buf, " (Inv)");
-                solid = false;
-        }
+	 if (mtdm->inv ()) {
+		 strcat (buf, " ");
+		 strcat (buf, _("(inverted - bad wiring)"));
+		 solid = false;
+	 }
 
-        if (solid) {
-                lm_measure_button.set_active (false);
-		lm_use_button.set_sensitive (true);
-                strcat (buf, " (set)");
-		have_lm_results = true;
+	 if (solid) {
+		 end_latency_detection ();
+		 lm_use_button.set_sensitive (true);
+		 have_lm_results = true;
         }
 	
-        lm_results.set_text (buf);
+        lm_results.set_markup (string_compose (results_markup, string_compose (_("Detected roundtrip latency: %1"), buf)));
 
         return true;
 }
@@ -1582,32 +1682,39 @@ EngineControl::start_latency_detection ()
 {
 	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);
+
+	if (ARDOUR::AudioEngine::instance()->start_latency_detection () == 0) {
+		lm_results.set_markup (string_compose (results_markup, _("Detecting ...")));
+		latency_timeout = Glib::signal_timeout().connect (mem_fun (*this, &EngineControl::check_latency_measurement), 100);
+		lm_measure_button.set_label (_("Cancel"));
+		have_lm_results = false;
+		lm_use_button.set_sensitive (false);
+		lm_input_channel_combo.set_sensitive (false);
+		lm_output_channel_combo.set_sensitive (false);
+		lm_running = true;
+	}
 }
 
 void
 EngineControl::end_latency_detection ()
 {
-	ARDOUR::AudioEngine::instance()->stop_latency_detection ();
 	latency_timeout.disconnect ();
-	lm_start_stop_label.set_text (_("Measure latency"));
+	ARDOUR::AudioEngine::instance()->stop_latency_detection ();
+	lm_measure_button.set_label (_("Measure"));
 	if (!have_lm_results) {
-		lm_results.set_markup ("<i>No measurement results yet</i>");
+		lm_results.set_markup (string_compose (results_markup, _("No measurement results yet")));
+	} else {
+		lm_use_button.set_sensitive (false);
 	}
 	lm_input_channel_combo.set_sensitive (true);
 	lm_output_channel_combo.set_sensitive (true);
+	lm_running = false;
 }
 
 void
-EngineControl::latency_button_toggled ()
+EngineControl::latency_button_clicked ()
 {
-        if (lm_measure_button.get_active ()) {
+	if (!lm_running) {
 		start_latency_detection ();
 	} else {
 		end_latency_detection ();
@@ -1629,6 +1736,10 @@ EngineControl::use_latency_button_clicked ()
 
 	input_latency_adjustment.set_value (one_way);
 	output_latency_adjustment.set_value (one_way);
+
+	/* back to settings page */
+
+	notebook.set_current_page (0);
 }
 
 bool
diff --git a/gtk2_ardour/engine_dialog.h b/gtk2_ardour/engine_dialog.h
index ac17814a5f..0bf1c3a507 100644
--- a/gtk2_ardour/engine_dialog.h
+++ b/gtk2_ardour/engine_dialog.h
@@ -36,6 +36,7 @@
 #include "pbd/signals.h"
 
 #include "ardour_dialog.h"
+#include "ardour_button.h"
 
 class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
   public:
@@ -62,6 +63,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     Gtk::ComboBoxText driver_combo;
     Gtk::ComboBoxText device_combo;
     Gtk::ComboBoxText sample_rate_combo;
+    Gtk::ComboBoxText midi_option_combo;
     Gtk::ComboBoxText buffer_size_combo;
     Gtk::Label        buffer_size_duration_label;
     Gtk::Adjustment input_latency_adjustment;
@@ -84,14 +86,16 @@ 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_measure_button;
     Gtk::Button       lm_use_button;
+    Gtk::Button       lm_back_button;
+    ArdourButton      lm_button;
     Gtk::Label        lm_title;
     Gtk::Label        lm_results;
     Gtk::Table        lm_table;
     Gtk::VBox         lm_vbox;
     bool              have_lm_results;
+    bool              lm_running;
 
     Gtk::Button* cancel_button;
     Gtk::Button* ok_button;
@@ -117,6 +121,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     void sample_rate_changed ();
     void buffer_size_changed ();
     void parameter_changed ();
+    void midi_option_changed ();
 
     void setup_midi_tab_for_backend ();
     void setup_midi_tab_for_jack ();
@@ -133,6 +138,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     std::string get_device_name() const;
     std::string get_driver() const;
     std::string get_backend() const;
+    std::string get_midi_option () const;
 
     void device_changed ();
     void list_devices ();
@@ -149,6 +155,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
 	uint32_t input_channels;
 	uint32_t output_channels;
 	bool active;
+	std::string midi_option;
 
 	State() 
 		: input_latency (0)
@@ -188,7 +195,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     void update_sensitivity ();
 
     /* latency measurement */
-    void latency_button_toggled ();
+    void latency_button_clicked ();
     bool check_latency_measurement ();
     sigc::connection latency_timeout;
     void enable_latency_tab ();
diff --git a/gtk2_ardour/export_video_dialog.cc b/gtk2_ardour/export_video_dialog.cc
index 7e84cab122..a9d0f99ad1 100644
--- a/gtk2_ardour/export_video_dialog.cc
+++ b/gtk2_ardour/export_video_dialog.cc
@@ -63,7 +63,7 @@ using namespace PBD;
 using namespace ARDOUR;
 using namespace VideoUtils;
 
-ExportVideoDialog::ExportVideoDialog (Session* s, TimeSelection &tme)
+ExportVideoDialog::ExportVideoDialog (Session* s, TimeSelection &tme, bool range)
 	: ArdourDialog (_("Export Video File "))
 	, export_range (tme)
 	, outfn_path_label (_("File:"), Gtk::ALIGN_LEFT)
@@ -154,7 +154,11 @@ ExportVideoDialog::ExportVideoDialog (Session* s, TimeSelection &tme)
 	if (!export_range.empty()) {
 		insnd_combo.append_text (_("Selected range"));  // TODO show export_range.start() -> export_range.end_frame()
 	}
-	insnd_combo.set_active(0);
+	if (range) {
+		insnd_combo.set_active(2);
+	} else {
+		insnd_combo.set_active(0);
+	}
 
 	outfn_path_entry.set_width_chars(38);
 	outfn_path_entry.set_text (_session->session_directory().export_path() + G_DIR_SEPARATOR +"export.avi");
@@ -512,9 +516,8 @@ ExportVideoDialog::launch_export ()
 		end += av_offset;
 	}
 	else if (insnd_combo.get_active_row_number() == 2) {
-		// TODO quantize to video-frame ?!
-		start = export_range.start();
-		end   = export_range.end_frame();
+		start = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv(export_range.start());
+		end   = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv(export_range.end_frame());
 	}
 	if (end <= 0) {
 		start = _session->current_start_frame();
@@ -524,6 +527,15 @@ ExportVideoDialog::launch_export ()
 	printf("audio export-range %lld -> %lld\n", start, end);
 #endif
 
+	const frameoffset_t vstart = ARDOUR_UI::instance()->video_timeline->get_offset();
+	const frameoffset_t vend   = vstart + ARDOUR_UI::instance()->video_timeline->get_duration();
+
+	if ( (start >= end) || (end < vstart) || (start > vend)) {
+		warning << _("Export Video: export-range does not include video.") << endmsg;
+		Gtk::Dialog::response(RESPONSE_CANCEL);
+		return;
+	}
+
 	tsp->set_range (start, end);
 	tsp->set_name ("mysession");
 	tsp->set_range_id ("session");
diff --git a/gtk2_ardour/export_video_dialog.h b/gtk2_ardour/export_video_dialog.h
index 7e3cf442a7..5ebcf3258d 100644
--- a/gtk2_ardour/export_video_dialog.h
+++ b/gtk2_ardour/export_video_dialog.h
@@ -41,7 +41,7 @@
 class ExportVideoDialog : public ArdourDialog , public PBD::ScopedConnectionList
 {
   public:
-	ExportVideoDialog (ARDOUR::Session*, TimeSelection &tme);
+	ExportVideoDialog (ARDOUR::Session*, TimeSelection &tme, bool range = false);
 	~ExportVideoDialog ();
 
 	std::string get_exported_filename () { return outfn_path_entry.get_text(); }
diff --git a/gtk2_ardour/plugin_ui.cc b/gtk2_ardour/plugin_ui.cc
index 28ef9b1297..4423e3905d 100644
--- a/gtk2_ardour/plugin_ui.cc
+++ b/gtk2_ardour/plugin_ui.cc
@@ -159,6 +159,7 @@ PluginUIWindow::PluginUIWindow (
 
 PluginUIWindow::~PluginUIWindow ()
 {
+	cerr << "PluginWindow deleted for " << this << endl;
 	delete _pluginui;
 }
 
@@ -403,8 +404,6 @@ PluginUIWindow::plugin_going_away ()
 	}
 
 	death_connection.disconnect ();
-
-	delete_when_idle (this);
 }
 
 PlugUIBase::PlugUIBase (boost::shared_ptr<PluginInsert> pi)
diff --git a/gtk2_ardour/processor_box.cc b/gtk2_ardour/processor_box.cc
index 1ed7c39312..1749e4dd66 100644
--- a/gtk2_ardour/processor_box.cc
+++ b/gtk2_ardour/processor_box.cc
@@ -1392,7 +1392,7 @@ ProcessorBox::redisplay_processors ()
 
 	_route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::add_processor_to_display));
 
-	for (list<ProcessorWindowProxy*>::iterator i = _processor_window_info.begin(); i != _processor_window_info.end(); ++i) {
+	for (ProcessorWindowProxies::iterator i = _processor_window_info.begin(); i != _processor_window_info.end(); ++i) {
 		(*i)->marked = false;
 	}
 
@@ -1400,16 +1400,43 @@ ProcessorBox::redisplay_processors ()
 
 	/* trim dead wood from the processor window proxy list */
 
-	list<ProcessorWindowProxy*>::iterator i = _processor_window_info.begin();
+	ProcessorWindowProxies::iterator i = _processor_window_info.begin();
 	while (i != _processor_window_info.end()) {
-		list<ProcessorWindowProxy*>::iterator j = i;
+		ProcessorWindowProxies::iterator j = i;
 		++j;
 
-		if (!(*i)->marked) {
+		if (!(*i)->valid()) {
+
 			WM::Manager::instance().remove (*i);
 			delete *i;
 			_processor_window_info.erase (i);
-		}
+			
+		} else if (!(*i)->marked) {
+
+			/* this processor is no longer part of this processor
+			 * box.
+			 *
+			 * that could be because it was deleted or it could be
+			 * because the route being displayed in the parent
+			 * strip changed.
+			 *
+			 * The latter only happens with the editor mixer strip.
+			 */
+
+			if (is_editor_mixer_strip()) {
+				
+				/* editor mixer strip .. DO NOTHING
+				 *
+				 * note: the processor window stays visible if
+				 * it is already visible
+				 */
+			} else {
+				(*i)->hide ();
+				WM::Manager::instance().remove (*i);
+				delete *i;
+				_processor_window_info.erase (i);
+			} 
+		} 
 
 		i = j;
 	}
@@ -1428,7 +1455,7 @@ ProcessorBox::maybe_add_processor_to_ui_list (boost::weak_ptr<Processor> w)
 		return;
 	}
 
-	list<ProcessorWindowProxy*>::iterator i = _processor_window_info.begin ();
+	ProcessorWindowProxies::iterator i = _processor_window_info.begin ();
 	while (i != _processor_window_info.end()) {
 
 		boost::shared_ptr<Processor> t = (*i)->processor().lock ();
@@ -2077,6 +2104,18 @@ ProcessorBox::get_editor_window (boost::shared_ptr<Processor> processor, bool us
 	boost::shared_ptr<PortInsert> port_insert;
 	Window* gidget = 0;
 
+	/* This method may or may not return a Window, but if it does not it
+	 * will modify the parent mixer strip appearance layout to allow
+	 * "editing" the @param processor that was passed in.
+	 *
+	 * So for example, if the processor is an Amp (gain), the parent strip
+	 * will be forced back into a model where the fader controls the main gain.
+	 * If the processor is a send, then we map the send controls onto the
+	 * strip.
+	 * 
+	 * Plugins and others will return a window for control.
+	 */
+
 	if (boost::dynamic_pointer_cast<AudioTrack>(_route) != 0) {
 
 		if (boost::dynamic_pointer_cast<AudioTrack> (_route)->freeze_state() == AudioTrack::Frozen) {
@@ -2554,7 +2593,13 @@ ProcessorBox::generate_processor_title (boost::shared_ptr<PluginInsert> pi)
 		maker += " ...";
 	}
 
-	return string_compose(_("%1: %2 (by %3)"), _route->name(), pi->name(), maker);
+	SessionObject* owner = pi->owner();
+
+	if (owner) {
+		return string_compose(_("%1: %2 (by %3)"), owner->name(), pi->name(), maker);
+	} else {
+		return string_compose(_("%2 (by %3)"), pi->name(), maker);
+	}
 }
 
 /** @param p Processor.
@@ -2667,6 +2712,12 @@ ProcessorBox::update_gui_object_state (ProcessorEntry* entry)
 	entry->add_control_state (proc);
 }
 
+bool
+ProcessorBox::is_editor_mixer_strip() const
+{
+	return _parent_strip && !_parent_strip->mixer_owned();
+}
+
 ProcessorWindowProxy::ProcessorWindowProxy (string const & name, ProcessorBox* box, boost::weak_ptr<Processor> processor)
 	: WM::ProxyBase (name, string())
 	, marked (false)
@@ -2674,8 +2725,34 @@ ProcessorWindowProxy::ProcessorWindowProxy (string const & name, ProcessorBox* b
 	, _processor (processor)
 	, is_custom (false)
 	, want_custom (false)
+	, _valid (true)
 {
+	boost::shared_ptr<Processor> p = _processor.lock ();
+	if (!p) {
+		return;
+	}
+	p->DropReferences.connect (going_away_connection, MISSING_INVALIDATOR, boost::bind (&ProcessorWindowProxy::processor_going_away, this), gui_context());
+}
+
+ProcessorWindowProxy::~ProcessorWindowProxy()
+{
+	/* processor window proxies do not own the windows they create with
+	 * ::get(), so set _window to null before the normal WindowProxy method
+	 * deletes it.
+	 */
+	_window = 0;
+}
 
+void
+ProcessorWindowProxy::processor_going_away ()
+{
+	delete _window;
+	_window = 0;
+	_valid = false;
+	/* should be no real reason to do this, since the object that would
+	   send DropReferences is about to be deleted, but lets do it anyway.
+	*/
+	going_away_connection.disconnect();
 }
 
 ARDOUR::SessionHandlePtr*
@@ -2685,6 +2762,12 @@ ProcessorWindowProxy::session_handle()
 	return 0;
 }
 
+bool
+ProcessorWindowProxy::valid() const
+{
+	return _valid;
+}
+
 XMLNode&
 ProcessorWindowProxy::get_state () const
 {
diff --git a/gtk2_ardour/processor_box.h b/gtk2_ardour/processor_box.h
index a72eb3223d..41bc68281f 100644
--- a/gtk2_ardour/processor_box.h
+++ b/gtk2_ardour/processor_box.h
@@ -79,6 +79,7 @@ class ProcessorWindowProxy : public WM::ProxyBase
 {
   public:
     ProcessorWindowProxy (std::string const &, ProcessorBox *, boost::weak_ptr<ARDOUR::Processor>);
+    ~ProcessorWindowProxy();
 
     Gtk::Window* get (bool create = false);
     
@@ -91,6 +92,7 @@ class ProcessorWindowProxy : public WM::ProxyBase
     void set_custom_ui_mode(bool use_custom) { want_custom = use_custom; }
 
     bool marked;
+    bool valid () const;
 
     void set_state (const XMLNode&);
     XMLNode& get_state () const;
@@ -100,6 +102,10 @@ class ProcessorWindowProxy : public WM::ProxyBase
     boost::weak_ptr<ARDOUR::Processor> _processor;
     bool is_custom;
     bool want_custom;
+    bool _valid;
+
+    void processor_going_away ();
+    PBD::ScopedConnection going_away_connection;
 };
 
 class ProcessorEntry : public Gtkmm2ext::DnDVBoxChild, public sigc::trackable
@@ -303,6 +309,8 @@ class ProcessorBox : public Gtk::HBox, public PluginInterestedObject, public ARD
 
 	void route_going_away ();
 
+        bool is_editor_mixer_strip() const;
+
 	Gtkmm2ext::DnDVBox<ProcessorEntry> processor_display;
 	Gtk::ScrolledWindow    processor_scroller;
 
@@ -404,7 +412,9 @@ class ProcessorBox : public Gtk::HBox, public PluginInterestedObject, public ARD
 	void route_property_changed (const PBD::PropertyChange&);
 	std::string generate_processor_title (boost::shared_ptr<ARDOUR::PluginInsert> pi);
 
-	std::list<ProcessorWindowProxy*> _processor_window_info;
+        typedef std::list<ProcessorWindowProxy*> ProcessorWindowProxies;
+        ProcessorWindowProxies _processor_window_info;
+
         ProcessorWindowProxy* find_window_proxy (boost::shared_ptr<ARDOUR::Processor>) const;
 
 	void set_processor_ui (boost::shared_ptr<ARDOUR::Processor>, Gtk::Window *);
diff --git a/gtk2_ardour/public_editor.h b/gtk2_ardour/public_editor.h
index 3fc2b878b0..a99dcdd253 100644
--- a/gtk2_ardour/public_editor.h
+++ b/gtk2_ardour/public_editor.h
@@ -296,7 +296,7 @@ class PublicEditor : public Gtk::Window, public PBD::StatefulDestructible, publi
 	virtual int  get_videotl_bar_height () const = 0;
 	virtual void set_video_timeline_height (const int h) = 0;
 	virtual void embed_audio_from_video (std::string, framepos_t n = 0) = 0;
-	virtual void export_video () = 0;
+	virtual void export_video (bool range = false) = 0;
 
 	virtual RouteTimeAxisView* get_route_view_by_route_id (const PBD::ID& id) const = 0;
 
diff --git a/gtk2_ardour/window_manager.cc b/gtk2_ardour/window_manager.cc
index 4a44dc4691..01baf3e1fd 100644
--- a/gtk2_ardour/window_manager.cc
+++ b/gtk2_ardour/window_manager.cc
@@ -349,7 +349,7 @@ ProxyBase::setup ()
 	assert (_window);
 
 	vistracker = new Gtkmm2ext::VisibilityTracker (*_window);
-	_window->signal_delete_event().connect (sigc::mem_fun (*this, &ProxyBase::handle_win_event));
+	_window->signal_delete_event().connect (sigc::mem_fun (*this, &ProxyBase::delete_event_handler));
 
 	if (_width != -1 || _height != -1 || _x_off != -1 || _y_off != -1) {
 		/* cancel any mouse-based positioning */
@@ -369,8 +369,9 @@ ProxyBase::setup ()
 void
 ProxyBase::show ()
 {
-	Gtk::Window* win = get (true);
-	win->show ();
+	get (true);
+	assert (_window);
+	_window->show ();
 }
 
 void
@@ -384,17 +385,19 @@ ProxyBase::maybe_show ()
 void
 ProxyBase::show_all ()
 {
-	Gtk::Window* win = get (true);
-	win->show_all ();
+	get (true);
+	assert (_window);
+	_window->show_all ();
 }
 
-
 void
 ProxyBase::present ()
 {
-	Gtk::Window* win = get (true);
-	win->show_all ();
-	win->present ();
+	get (true);
+	assert (_window);
+
+	_window->show_all ();
+	_window->present ();
 
 	/* turn off any mouse-based positioning */
 	_window->set_position (Gtk::WIN_POS_NONE);
@@ -403,15 +406,14 @@ ProxyBase::present ()
 void
 ProxyBase::hide ()
 {
-	Gtk::Window* win = get (false);
-	if (win) {
+	if (_window) {
 		save_pos_and_size();
-		win->hide ();
+		_window->hide ();
 	}
 }
 
 bool
-ProxyBase::handle_win_event (GdkEventAny* /*ev*/)
+ProxyBase::delete_event_handler (GdkEventAny* /*ev*/)
 {
 	hide();
 	return true;
@@ -420,10 +422,9 @@ ProxyBase::handle_win_event (GdkEventAny* /*ev*/)
 void
 ProxyBase::save_pos_and_size ()
 {
-	Gtk::Window* win = get (false);
-	if (win) {
-		win->get_position (_x_off, _y_off);
-		win->get_size (_width, _height);
+	if (_window) {
+		_window->get_position (_x_off, _y_off);
+		_window->get_size (_width, _height);
 	}
 }
 /*-----------------------*/
diff --git a/gtk2_ardour/window_manager.h b/gtk2_ardour/window_manager.h
index 135f72c3ee..2dd6a2262e 100644
--- a/gtk2_ardour/window_manager.h
+++ b/gtk2_ardour/window_manager.h
@@ -122,7 +122,7 @@ class ProxyBase : public ARDOUR::SessionHandlePtr, public sigc::trackable {
     Gtkmm2ext::VisibilityTracker* vistracker;
 
     void save_pos_and_size ();
-    bool handle_win_event (GdkEventAny *ev);
+    bool delete_event_handler (GdkEventAny *ev);
     
     void setup ();
 };
diff --git a/gtk2_ardour/wscript b/gtk2_ardour/wscript
index 8e1a136931..011126da64 100644
--- a/gtk2_ardour/wscript
+++ b/gtk2_ardour/wscript
@@ -640,7 +640,7 @@ def build(bld):
     # Menus
     menus_argv = []
     if bld.is_defined('GTKOSX'):
-        menus_argv = [ '-E', '-P', '-DGTKOSX', '-DNOVIDEOTIMELINE' ]
+        menus_argv = [ '-E', '-P', '-DGTKOSX' ]
     else:
         menus_argv = [ '-E', '-P' ]