X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui.cc;h=23df74e6fd07f9342a978efb8b64d19fa225947c;hb=8e59a26ccf13de93ac681d761bad09cd6bcf0c90;hp=83a19ff37929feb8962517d2910067ad7bed4e8f;hpb=09ec34292683c8a4edcc0060b938192ae18225c4;p=ardour.git

diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index 83a19ff379..23df74e6fd 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -44,13 +44,13 @@
 #include "pbd/memento_command.h"
 #include "pbd/file_utils.h"
 
-#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/utils.h>
-#include <gtkmm2ext/click_box.h>
-#include <gtkmm2ext/fastmeter.h>
-#include <gtkmm2ext/stop_signal.h>
-#include <gtkmm2ext/popup.h>
-#include <gtkmm2ext/window_title.h>
+#include "gtkmm2ext/gtk_ui.h"
+#include "gtkmm2ext/utils.h"
+#include "gtkmm2ext/click_box.h"
+#include "gtkmm2ext/fastmeter.h"
+#include "gtkmm2ext/stop_signal.h"
+#include "gtkmm2ext/popup.h"
+#include "gtkmm2ext/window_title.h"
 
 #include "midi++/manager.h"
 
@@ -95,6 +95,7 @@ typedef uint64_t microseconds_t;
 #include "route_time_axis.h"
 #include "startup.h"
 #include "engine_dialog.h"
+#include "processor_box.h"
 
 #include "i18n.h"
 
@@ -102,7 +103,6 @@ using namespace ARDOUR;
 using namespace PBD;
 using namespace Gtkmm2ext;
 using namespace Gtk;
-using namespace sigc;
 
 ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
 UIConfiguration *ARDOUR_UI::ui_config = 0;
@@ -114,12 +114,12 @@ sigc::signal<void,nframes_t, bool, nframes_t> ARDOUR_UI::Clock;
 
 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 
-	: Gtkmm2ext::UI (X_("Ardour"), argcp, argvp),
+	: Gtkmm2ext::UI (X_("gui"), argcp, argvp),
 
-	  primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, false, true),
-	  secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, false, true),
-	  preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true),
-	  postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true),
+	  primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, true, false, true),
+	  secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, true, false, true),
+	  preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, false, true),
+	  postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, false, true),
 
 	  /* preroll stuff */
 
@@ -128,7 +128,7 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 
 	  /* big clock */
 
-	  big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
+	  big_clock (X_("bigclock"), false, "BigClockNonRecording", true, true, false, true),
 
 	  /* transport */
 
@@ -193,7 +193,6 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 
 	editor = 0;
 	mixer = 0;
-	session = 0;
 	editor = 0;
 	engine = 0;
 	_session_is_new = false;
@@ -235,24 +234,24 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 
 	last_shuttle_request = last_peak_grab = 0; //  get_microseconds();
 
-	ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
-	ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+	ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context());
+	ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context());
 
 	/* handle dialog requests */
 
-	ARDOUR::Session::Dialog.connect (mem_fun(*this, &ARDOUR_UI::session_dialog));
+	ARDOUR::Session::Dialog.connect (forever_connections, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
 
-	/* handle pending state with a dialog */
+	/* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
 
-	ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
+	ARDOUR::Session::AskAboutPendingState.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::pending_state_dialog, this));
 
-	/* handle sr mismatch with a dialog */
+	/* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
 
-	ARDOUR::Session::AskAboutSampleRateMismatch.connect (mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
+	ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
 
 	/* lets get this party started */
 
-    	try {
+	try {
 		if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) {
 			throw failed_constructor ();
 		}
@@ -262,6 +261,8 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 
 		GainMeter::setup_slider_pix ();
 		RouteTimeAxisView::setup_slider_pix ();
+		SendProcessorEntry::setup_slider_pix ();
+		SessionEvent::create_per_thread_pool ("GUI", 512);
 
 	} catch (failed_constructor& err) {
 		error << _("could not initialize Ardour.") << endmsg;
@@ -271,17 +272,23 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 
 	/* we like keyboards */
 
-	keyboard = new Keyboard;
+	keyboard = new ArdourKeyboard;
+
+	XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
+	if (node) {
+		keyboard->set_state (*node, Stateful::loading_state_version);
+	}
 
 	reset_dpi();
 
-	starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
-	stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+	starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
+	stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
 
 	platform_setup ();
 }
 
-void
+/** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
+bool
 ARDOUR_UI::run_startup (bool should_be_new)
 {
 	if (_startup == 0) {
@@ -293,9 +300,14 @@ ARDOUR_UI::run_startup (bool should_be_new)
 
 	main().run();
 
-	/* we don't return here until the startup assistant is finished */
-
 	_startup->hide ();
+
+	switch (_startup->response()) {
+	case RESPONSE_OK:
+		return true;
+	default:
+		return false;
+	}
 }
 
 int
@@ -317,10 +329,10 @@ ARDOUR_UI::create_engine ()
 		return -1;
 	}
 
-	engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped));
-	engine->Running.connect (mem_fun(*this, &ARDOUR_UI::engine_running));
-	engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
-	engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
+	engine->Stopped.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context());
+	engine->Running.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_running, this), gui_context());
+	engine->Halted.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this), gui_context());
+	engine->SampleRateChanged.connect (forever_connections, ui_bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
 
 	post_engine ();
 
@@ -335,7 +347,7 @@ ARDOUR_UI::post_engine ()
 
 	MIDI::Manager::instance()->set_api_data (engine->jack());
 	setup_midi ();
-
+	
 	ARDOUR::init_post_engine ();
 
 	ActionManager::init ();
@@ -344,7 +356,7 @@ ARDOUR_UI::post_engine ()
 	if (setup_windows ()) {
 		throw failed_constructor ();
 	}
-
+	
 	check_memory_locking();
 
 	/* this is the first point at which all the keybindings are available */
@@ -379,7 +391,7 @@ ARDOUR_UI::post_engine ()
 		primary_clock.set_mode (AudioClock::BBT);
 		secondary_clock.set_mode (AudioClock::MinSec);
 	}  else {
-		primary_clock.set_mode (AudioClock::SMPTE);
+		primary_clock.set_mode (AudioClock::Timecode);
 		secondary_clock.set_mode (AudioClock::BBT);
 	}
 
@@ -388,21 +400,25 @@ ARDOUR_UI::post_engine ()
 #ifndef GTKOSX
 	/* OS X provides an always visible wallclock, so don't be stupid */
 	update_wall_clock ();
-	Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
+	Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
 #endif
 
 	update_disk_space ();
 	update_cpu_load ();
 	update_sample_rate (engine->frame_rate());
 
+	Config->ParameterChanged.connect (forever_connections, ui_bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
+	boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
+	Config->map_parameters (pc);
+
 	/* now start and maybe save state */
 
 	if (do_engine_start () == 0) {
-		if (session && _session_is_new) {
+		if (_session && _session_is_new) {
 			/* we need to retain initial visual
 			   settings for a new session
 			*/
-			session->save_state ("");
+			_session->save_state ("");
 		}
 	}
 }
@@ -452,7 +468,7 @@ ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
 	if (have_configure_timeout) {
 		last_configure_time = get_microseconds();
 	} else {
-		Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
+		Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
 		have_configure_timeout = true;
 	}
 
@@ -539,9 +555,9 @@ ARDOUR_UI::save_ardour_state ()
 	XMLNode enode(static_cast<Stateful*>(editor)->get_state());
 	XMLNode mnode(mixer->get_state());
 
-	if (session) {
-		session->add_instant_xml (enode);
-		session->add_instant_xml (mnode);
+	if (_session) {
+		_session->add_instant_xml (enode);
+		_session->add_instant_xml (mnode);
 	} else {
 		Config->add_instant_xml (enode);
 		Config->add_instant_xml (mnode);
@@ -565,8 +581,8 @@ ARDOUR_UI::autosave_session ()
                 return 1;
 	}
 
-        if (session) {
-                session->maybe_write_autosave();
+        if (_session) {
+                _session->maybe_write_autosave();
         }
 
 	return 1;
@@ -575,14 +591,14 @@ ARDOUR_UI::autosave_session ()
 void
 ARDOUR_UI::update_autosave ()
 {
-	ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_autosave)
 
-	if (session && session->dirty()) {
+	if (_session && _session->dirty()) {
 		if (_autosave_connection.connected()) {
 			_autosave_connection.disconnect();
 		}
 
-		_autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session),
+		_autosave_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &ARDOUR_UI::autosave_session),
 				Config->get_periodic_safety_backup_interval() * 1000);
 
 	} else {
@@ -632,7 +648,7 @@ Please consider the possibilities, and perhaps (re)start JACK."));
 		win.add_button (Stock::OK, RESPONSE_CLOSE);
 	} else {
 		win.add_button (Stock::QUIT, RESPONSE_CLOSE);
- 	}
+	}
 
 	win.set_default_response (RESPONSE_CLOSE);
 
@@ -654,7 +670,7 @@ ARDOUR_UI::startup ()
 		_startup->engine_control()->set_state (*audio_setup);
 	}
 
-	if (get_session_parameters (ARDOUR_COMMAND_LINE::new_session)) {
+	if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session)) {
 		exit (1);
 	}
 
@@ -714,7 +730,7 @@ ARDOUR_UI::check_memory_locking ()
 				HBox hbox;
 				CheckButton cb (_("Do not show this window again"));
 
-				cb.signal_toggled().connect (mem_fun (*this, &ARDOUR_UI::no_memory_warning));
+				cb.signal_toggled().connect (sigc::mem_fun (*this, &ARDOUR_UI::no_memory_warning));
 
 				hbox.pack_start (cb, true, false);
 				vbox->pack_start (hbox);
@@ -736,14 +752,14 @@ ARDOUR_UI::check_memory_locking ()
 void
 ARDOUR_UI::finish()
 {
-	if (session) {
+	if (_session) {
 
-		if (session->transport_rolling()) {
-			session->request_stop ();
+		if (_session->transport_rolling()) {
+			_session->request_stop ();
 			usleep (250000);
 		}
 
-		if (session->dirty()) {
+		if (_session->dirty()) {
 			switch (ask_about_saving_session(_("quit"))) {
 			case -1:
 				return;
@@ -767,7 +783,15 @@ If you still wish to quit, please use the\n\n\
 			}
 		}
 
-		session->set_deletion_in_progress ();
+		second_connection.disconnect ();
+		point_one_second_connection.disconnect ();
+		point_oh_five_second_connection.disconnect ();
+		point_zero_one_second_connection.disconnect();
+		
+		// _session->set_deletion_in_progress ();
+		_session->remove_pending_capture_state ();
+		delete _session;
+		_session = 0;
 	}
 
 	ArdourDialog::close_all_dialogs ();
@@ -801,13 +825,13 @@ ARDOUR_UI::ask_about_saving_session (const string & what)
 	string prompt;
 	string type;
 
-	if (session->snap_name() == session->name()) {
+	if (_session->snap_name() == _session->name()) {
 		type = _("session");
 	} else {
 		type = _("snapshot");
 	}
 	prompt = string_compose(_("The %1 \"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
-			 type, session->snap_name());
+			 type, _session->snap_name());
 
 	prompt_label.set_text (prompt);
 	prompt_label.set_name (X_("PrompterLabel"));
@@ -878,7 +902,7 @@ ARDOUR_UI::update_sample_rate (nframes_t ignored)
 {
 	char buf[32];
 
-	ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::update_sample_rate), ignored));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_sample_rate, ignored)
 
 	if (!engine->connected()) {
 
@@ -916,14 +940,14 @@ ARDOUR_UI::update_buffer_load ()
 	char buf[64];
 	uint32_t c, p;
 
-	if (session) {
-		c = session->capture_load ();
-		p = session->playback_load ();
+	if (_session) {
+		c = _session->capture_load ();
+		p = _session->playback_load ();
 
 		push_buffer_stats (c, p);
 
 		snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
-			  session->playback_load(), session->capture_load());
+			  _session->playback_load(), _session->capture_load());
 		buffer_load_label.set_text (buf);
 	} else {
 		buffer_load_label.set_text ("");
@@ -942,19 +966,19 @@ ARDOUR_UI::count_recenabled_streams (Route& route)
 void
 ARDOUR_UI::update_disk_space()
 {
-	if (session == 0) {
+	if (_session == 0) {
 		return;
 	}
 
-	nframes_t frames = session->available_capture_duration();
+	nframes_t frames = _session->available_capture_duration();
 	char buf[64];
-	nframes_t fr = session->frame_rate();
+	nframes_t fr = _session->frame_rate();
 
 	if (frames == max_frames) {
 		strcpy (buf, _("Disk: 24hrs+"));
 	} else {
 		rec_enabled_streams = 0;
-		session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
+		_session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
 
 		if (rec_enabled_streams) {
 			frames /= rec_enabled_streams;
@@ -1106,7 +1130,7 @@ ARDOUR_UI::build_session_selector ()
 	recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
 	recent_session_display.set_headers_visible (false);
 	recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
-	recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
+	recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
 
 	scroller->add (recent_session_display);
 	scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
@@ -1129,7 +1153,7 @@ ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColum
 void
 ARDOUR_UI::open_recent_session ()
 {
-	bool can_return = (session != 0);
+	bool can_return = (_session != 0);
 
 	if (session_selector_window == 0) {
 		build_session_selector ();
@@ -1253,7 +1277,7 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t
 {
 	list<boost::shared_ptr<MidiTrack> > tracks;
 
-	if (session == 0) {
+	if (_session == 0) {
 		warning << _("You cannot add a track without a session already loaded.") << endmsg;
 		return;
 	}
@@ -1261,7 +1285,7 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t
 	try {
 		if (disk) {
 
-			tracks = session->new_midi_track (ARDOUR::Normal, route_group, how_many);
+			tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many);
 
 			if (tracks.size() != how_many) {
 				if (how_many == 1) {
@@ -1271,7 +1295,7 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t
 				}
 			}
 		} /*else {
-			if ((route = session->new_midi_route ()) == 0) {
+			if ((route = _session->new_midi_route ()) == 0) {
 				error << _("could not create new midi bus") << endmsg;
 			}
 		}*/
@@ -1289,19 +1313,19 @@ restart JACK with more ports."));
 
 
 void
-ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+ARDOUR_UI::session_add_audio_route (bool track, bool aux, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
 {
 	list<boost::shared_ptr<AudioTrack> > tracks;
 	RouteList routes;
 
-	if (session == 0) {
+	if (_session == 0) {
 		warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
 		return;
 	}
 
 	try {
 		if (track) {
-			tracks = session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
+			tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
 
 			if (tracks.size() != how_many) {
 				if (how_many == 1) {
@@ -1314,7 +1338,7 @@ ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t
 
 		} else {
 
-			routes = session->new_audio_route (input_channels, output_channels, route_group, how_many);
+			routes = _session->new_audio_route (aux, input_channels, output_channels, route_group, how_many);
 
 			if (routes.size() != how_many) {
 				if (how_many == 1) {
@@ -1354,9 +1378,9 @@ ARDOUR_UI::do_transport_locate (nframes_t new_position)
 {
 	nframes_t _preroll = 0;
 
-	if (session) {
+	if (_session) {
 		// XXX CONFIG_CHANGE FIX - requires AnyTime handling
-		// _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
+		// _preroll = _session->convert_to_frames_at (new_position, Config->get_preroll());
 
 		if (new_position > _preroll) {
 			new_position -= _preroll;
@@ -1364,23 +1388,22 @@ ARDOUR_UI::do_transport_locate (nframes_t new_position)
 			new_position = 0;
 		}
 
-		session->request_locate (new_position);
+		_session->request_locate (new_position);
 	}
 }
 
 void
 ARDOUR_UI::transport_goto_start ()
 {
-	if (session) {
-		session->goto_start();
-
+	if (_session) {
+		_session->goto_start();
 
 		/* force displayed area in editor to start no matter
 		   what "follow playhead" setting is.
 		*/
 
 		if (editor) {
-			editor->reset_x_origin (session->current_start_frame());
+			editor->center_screen (_session->current_start_frame ());
 		}
 	}
 }
@@ -1388,8 +1411,8 @@ ARDOUR_UI::transport_goto_start ()
 void
 ARDOUR_UI::transport_goto_zero ()
 {
-	if (session) {
-		session->request_locate (0);
+	if (_session) {
+		_session->request_locate (0);
 
 
 		/* force displayed area in editor to start no matter
@@ -1405,7 +1428,7 @@ ARDOUR_UI::transport_goto_zero ()
 void
 ARDOUR_UI::transport_goto_wallclock ()
 {
-	if (session && editor) {
+	if (_session && editor) {
 
 		time_t now;
 		struct tm tmnow;
@@ -1414,18 +1437,18 @@ ARDOUR_UI::transport_goto_wallclock ()
 		time (&now);
 		localtime_r (&now, &tmnow);
 
-		frames = tmnow.tm_hour * (60 * 60 * session->frame_rate());
-		frames += tmnow.tm_min * (60 * session->frame_rate());
-		frames += tmnow.tm_sec * session->frame_rate();
+		frames = tmnow.tm_hour * (60 * 60 * _session->frame_rate());
+		frames += tmnow.tm_min * (60 * _session->frame_rate());
+		frames += tmnow.tm_sec * _session->frame_rate();
 
-		session->request_locate (frames);
+		_session->request_locate (frames);
 
 		/* force displayed area in editor to start no matter
 		   what "follow playhead" setting is.
 		*/
 
 		if (editor) {
-			editor->reset_x_origin (frames - (editor->current_page_frames()/2));
+			editor->center_screen (frames);
 		}
 	}
 }
@@ -1433,16 +1456,16 @@ ARDOUR_UI::transport_goto_wallclock ()
 void
 ARDOUR_UI::transport_goto_end ()
 {
-	if (session) {
-		nframes_t frame = session->current_end_frame();
-		session->request_locate (frame);
+	if (_session) {
+		nframes_t const frame = _session->current_end_frame();
+		_session->request_locate (frame);
 
 		/* force displayed area in editor to start no matter
 		   what "follow playhead" setting is.
 		*/
 
 		if (editor) {
-			editor->reset_x_origin (frame);
+			editor->center_screen (frame);
 		}
 	}
 }
@@ -1450,27 +1473,23 @@ ARDOUR_UI::transport_goto_end ()
 void
 ARDOUR_UI::transport_stop ()
 {
-	if (!session) {
+	if (!_session) {
 		return;
 	}
 
-	if (session->is_auditioning()) {
-		session->cancel_audition ();
+	if (_session->is_auditioning()) {
+		_session->cancel_audition ();
 		return;
 	}
 
-	if (session->get_play_loop ()) {
-		session->request_play_loop (false);
-	}
-
-	session->request_stop ();
+	_session->request_stop ();
 }
 
 void
 ARDOUR_UI::transport_stop_and_forget_capture ()
 {
-	if (session) {
-		session->request_stop (true);
+	if (_session) {
+		_session->request_stop (true);
 	}
 }
 
@@ -1486,75 +1505,145 @@ void
 ARDOUR_UI::transport_record (bool roll)
 {
 
-	if (session) {
-		switch (session->record_status()) {
+	if (_session) {
+		switch (_session->record_status()) {
 		case Session::Disabled:
-			if (session->ntracks() == 0) {
+			if (_session->ntracks() == 0) {
 				MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
 				msg.run ();
 				return;
 			}
-			session->maybe_enable_record ();
+			_session->maybe_enable_record ();
 			if (roll) {
 				transport_roll ();
 			}
 			break;
 		case Session::Recording:
 			if (roll) {
-				session->request_stop();
+				_session->request_stop();
 			} else {
-				session->disable_record (false, true);
+				_session->disable_record (false, true);
 			}
 			break;
 
 		case Session::Enabled:
-			session->disable_record (false, true);
+			_session->disable_record (false, true);
 		}
 	}
-	//cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " session->record_status() = " << session->record_status() << endl;
+	//cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " _session->record_status() = " << _session->record_status() << endl;
 }
 
-void
+void 
 ARDOUR_UI::transport_roll ()
 {
-	bool rolling;
+	if (!_session) {
+		return;
+	}
 
-	if (!session) {
+	if (_session->is_auditioning()) {
 		return;
 	}
+	
+	if (_session->config.get_external_sync()) {
+		switch (_session->config.get_sync_source()) {
+		case JACK:
+			break;
+		default:
+			/* transport controlled by the master */
+			return;
+		}
+	}
 
-	rolling = session->transport_rolling ();
+	bool rolling = _session->transport_rolling();
 
-	//cerr << "ARDOUR_UI::transport_roll () called session->record_status() = " << session->record_status() << endl;
+	if (_session->get_play_loop()) {
+		_session->request_play_loop (false, true);
+	} else if (_session->get_play_range ()) {
+		_session->request_play_range (false, true);
+	} 
 
-	if (session->get_play_loop()) {
-		session->request_play_loop (false);
-		auto_loop_button.set_visual_state (1);
-		roll_button.set_visual_state (1);
-	} else if (session->get_play_range ()) {
-		session->request_play_range (false);
-		play_selection_button.set_visual_state (0);
-	} else if (rolling) {
-		session->request_locate (session->last_transport_start(), true);
+	if (!rolling) {
+		_session->request_transport_speed (1.0f);
 	}
 
-	session->request_transport_speed (1.0f);
+	map_transport_state ();
 }
 
 void
-ARDOUR_UI::transport_loop()
+ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode)
 {
-	if (session) {
-		if (session->get_play_loop()) {
-			if (session->transport_rolling()) {
-				Location * looploc = session->locations()->auto_loop_location();
+	
+	if (!_session) {
+		return;
+	}
+
+	if (_session->is_auditioning()) {
+		_session->cancel_audition ();
+		return;
+	}
+	
+	if (_session->config.get_external_sync()) {
+		switch (_session->config.get_sync_source()) {
+		case JACK:
+			break;
+		default:
+			/* transport controlled by the master */
+			return;
+		}
+	}
+
+	bool rolling = _session->transport_rolling();
+	bool affect_transport = true;
+
+	if (rolling && roll_out_of_bounded_mode) {
+		/* drop out of loop/range playback but leave transport rolling */
+		if (_session->get_play_loop()) {
+			if (Config->get_seamless_loop()) {
+				/* the disk buffers contain copies of the loop - we can't 
+				   just keep playing, so stop the transport. the user
+				   can restart as they wish.
+				*/
+				affect_transport = true;
+			} else {
+				/* disk buffers are normal, so we can keep playing */
+				affect_transport = false;
+			}
+			_session->request_play_loop (false, true);
+		} else if (_session->get_play_range ()) {
+			affect_transport = false;
+			_session->request_play_range (0, true);
+		} 
+	} 
+
+	if (affect_transport) {
+		if (rolling) {
+			_session->request_stop (with_abort, true);
+		} else {
+			_session->request_transport_speed (1.0f);
+		}
+	}
+
+	map_transport_state ();	
+}
+
+void
+ARDOUR_UI::toggle_session_auto_loop ()
+{
+	if (_session) {
+		if (_session->get_play_loop()) {
+			if (_session->transport_rolling()) {
+				Location * looploc = _session->locations()->auto_loop_location();
 				if (looploc) {
-					session->request_locate (looploc->start(), true);
+					_session->request_locate (looploc->start(), true);
 				}
+			} else {
+				_session->request_play_loop (false);
+			}
+		} else {
+			Location * looploc = _session->locations()->auto_loop_location();
+			if (looploc) {
+				_session->request_play_loop (true);
 			}
-		}
-		else {
-			session->request_play_loop (true);
 		}
 	}
 }
@@ -1562,14 +1651,10 @@ ARDOUR_UI::transport_loop()
 void
 ARDOUR_UI::transport_play_selection ()
 {
-	if (!session) {
+	if (!_session) {
 		return;
 	}
 
-	if (!session->get_play_range()) {
-		session->request_stop ();
-	}
-
 	editor->play_selection ();
 }
 
@@ -1578,24 +1663,24 @@ ARDOUR_UI::transport_rewind (int option)
 {
 	float current_transport_speed;
 
-       	if (session) {
-		current_transport_speed = session->transport_speed();
+       	if (_session) {
+		current_transport_speed = _session->transport_speed();
 
 		if (current_transport_speed >= 0.0f) {
 			switch (option) {
 			case 0:
-				session->request_transport_speed (-1.0f);
+				_session->request_transport_speed (-1.0f);
 				break;
 			case 1:
-				session->request_transport_speed (-4.0f);
+				_session->request_transport_speed (-4.0f);
 				break;
 			case -1:
-				session->request_transport_speed (-0.5f);
+				_session->request_transport_speed (-0.5f);
 				break;
 			}
 		} else {
 			/* speed up */
-			session->request_transport_speed (current_transport_speed * 1.5f);
+			_session->request_transport_speed (current_transport_speed * 1.5f);
 		}
 	}
 }
@@ -1605,38 +1690,39 @@ ARDOUR_UI::transport_forward (int option)
 {
 	float current_transport_speed;
 
-	if (session) {
-		current_transport_speed = session->transport_speed();
+	if (_session) {
+		current_transport_speed = _session->transport_speed();
 
 		if (current_transport_speed <= 0.0f) {
 			switch (option) {
 			case 0:
-				session->request_transport_speed (1.0f);
+				_session->request_transport_speed (1.0f);
 				break;
 			case 1:
-				session->request_transport_speed (4.0f);
+				_session->request_transport_speed (4.0f);
 				break;
 			case -1:
-				session->request_transport_speed (0.5f);
+				_session->request_transport_speed (0.5f);
 				break;
 			}
 		} else {
 			/* speed up */
-			session->request_transport_speed (current_transport_speed * 1.5f);
+			_session->request_transport_speed (current_transport_speed * 1.5f);
 		}
+
 	}
 }
 
 void
 ARDOUR_UI::toggle_record_enable (uint32_t dstream)
 {
-	if (session == 0) {
+	if (_session == 0) {
 		return;
 	}
 
 	boost::shared_ptr<Route> r;
 
-	if ((r = session->route_by_remote_id (dstream)) != 0) {
+	if ((r = _session->route_by_remote_id (dstream)) != 0) {
 
 		Track* t;
 
@@ -1644,37 +1730,72 @@ ARDOUR_UI::toggle_record_enable (uint32_t dstream)
 			t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
 		}
 	}
-	if (session == 0) {
+	if (_session == 0) {
 		return;
 	}
 }
 
-void
-ARDOUR_UI::queue_transport_change ()
-{
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
-}
-
 void
 ARDOUR_UI::map_transport_state ()
 {
-	float sp = session->transport_speed();
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::map_transport_state)
+
+	if (!_session) {
+		auto_loop_button.set_visual_state (0);
+		play_selection_button.set_visual_state (0);
+		roll_button.set_visual_state (0);
+		stop_button.set_visual_state (1);
+		return;
+	}
+
+	float sp = _session->transport_speed();
 
 	if (sp == 1.0f) {
-		transport_rolling ();
-	} else if (sp < 0.0f) {
-		transport_rewinding ();
-	} else if (sp > 0.0f) {
-		transport_forwarding ();
+		shuttle_fract = SHUTTLE_FRACT_SPEED1;  /* speed = 1.0, believe it or not */
+		shuttle_box.queue_draw ();
+	} else if (sp == 0.0f) {
+		shuttle_fract = 0;
+		shuttle_box.queue_draw ();
+		update_disk_space ();
+	}
+
+	if (sp != 0.0) {
+
+		if (_session->get_play_range()) {
+
+			play_selection_button.set_visual_state (1);
+			roll_button.set_visual_state (0);
+			auto_loop_button.set_visual_state (0);
+			
+		} else if (_session->get_play_loop ()) {
+			
+			auto_loop_button.set_visual_state (1);
+			play_selection_button.set_visual_state (0);
+			roll_button.set_visual_state (0);
+
+		} else {
+			
+			roll_button.set_visual_state (1);
+			play_selection_button.set_visual_state (0);
+			auto_loop_button.set_visual_state (0);
+		}
+
+		stop_button.set_visual_state (0);
+
 	} else {
-		transport_stopped ();
+
+		stop_button.set_visual_state (1);
+		roll_button.set_visual_state (0);
+		play_selection_button.set_visual_state (0);
+		auto_loop_button.set_visual_state (0);
 	}
+
 }
 
 void
 ARDOUR_UI::engine_stopped ()
 {
-	ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_stopped));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_stopped)
 	ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
 	ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
 }
@@ -1682,7 +1803,7 @@ ARDOUR_UI::engine_stopped ()
 void
 ARDOUR_UI::engine_running ()
 {
-	ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_running)
 	ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
 	ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
 
@@ -1733,7 +1854,7 @@ ARDOUR_UI::engine_running ()
 void
 ARDOUR_UI::engine_halted ()
 {
-	ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_halted)
 
 	ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
 	ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
@@ -1778,14 +1899,14 @@ void
 ARDOUR_UI::update_clocks ()
 {
 	if (!editor || !editor->dragging_playhead()) {
-		Clock (session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
+		Clock (_session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
 	}
 }
 
 void
 ARDOUR_UI::start_clocking ()
 {
-	clock_signal_connection = RapidScreenUpdate.connect (mem_fun(*this, &ARDOUR_UI::update_clocks));
+	clock_signal_connection = RapidScreenUpdate.connect (sigc::mem_fun(*this, &ARDOUR_UI::update_clocks));
 }
 
 void
@@ -1872,7 +1993,7 @@ ARDOUR_UI::snapshot_session ()
 		bool do_save = (snapname.length() != 0);
 
 		vector<sys::path> p;
-		get_state_files_in_directory (session->session_directory().root_path(), p);
+		get_state_files_in_directory (_session->session_directory().root_path(), p);
 		vector<string> n = get_file_names_no_extension (p);
 		if (find (n.begin(), n.end(), snapname) != n.end()) {
 
@@ -1908,14 +2029,14 @@ ARDOUR_UI::save_state (const string & name)
 int
 ARDOUR_UI::save_state_canfail (string name)
 {
-	if (session) {
+	if (_session) {
 		int ret;
 
 		if (name.length() == 0) {
-			name = session->snap_name();
+			name = _session->snap_name();
 		}
 
-		if ((ret = session->save_state (name)) != 0) {
+		if ((ret = _session->save_state (name)) != 0) {
 			return ret;
 		}
 	}
@@ -1926,36 +2047,36 @@ ARDOUR_UI::save_state_canfail (string name)
 void
 ARDOUR_UI::primary_clock_value_changed ()
 {
-	if (session) {
-		session->request_locate (primary_clock.current_time ());
+	if (_session) {
+		_session->request_locate (primary_clock.current_time ());
 	}
 }
 
 void
 ARDOUR_UI::big_clock_value_changed ()
 {
-	if (session) {
-		session->request_locate (big_clock.current_time ());
+	if (_session) {
+		_session->request_locate (big_clock.current_time ());
 	}
 }
 
 void
 ARDOUR_UI::secondary_clock_value_changed ()
 {
-	if (session) {
-		session->request_locate (secondary_clock.current_time ());
+	if (_session) {
+		_session->request_locate (secondary_clock.current_time ());
 	}
 }
 
 void
 ARDOUR_UI::transport_rec_enable_blink (bool onoff)
 {
-	if (session == 0) {
+	if (_session == 0) {
 		return;
 	}
 
-	Session::RecordState const r = session->record_status ();
-	bool const h = session->have_rec_enabled_diskstream ();
+	Session::RecordState const r = _session->record_status ();
+	bool const h = _session->have_rec_enabled_diskstream ();
 
 	if (r == Session::Enabled || (r == Session::Recording && !h)) {
 		if (onoff) {
@@ -1983,7 +2104,7 @@ ARDOUR_UI::save_template ()
 	prompter.set_name (X_("Prompter"));
 	prompter.set_title (_("Save Mix Template"));
 	prompter.set_prompt (_("Name for mix template:"));
-	prompter.set_initial_text(session->name() + _("-template"));
+	prompter.set_initial_text(_session->name() + _("-template"));
 	prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
 
 	switch (prompter.run()) {
@@ -1991,7 +2112,7 @@ ARDOUR_UI::save_template ()
 		prompter.get_result (name);
 
 		if (name.length()) {
-			session->save_template (name);
+			_session->save_template (name);
 		}
 		break;
 
@@ -2004,7 +2125,7 @@ void
 ARDOUR_UI::edit_metadata ()
 {
 	SessionMetadataEditor dialog;
-	dialog.set_session (session);
+	dialog.set_session (_session);
 	editor->ensure_float (dialog);
 	dialog.run ();
 }
@@ -2013,7 +2134,7 @@ void
 ARDOUR_UI::import_metadata ()
 {
 	SessionMetadataImporter dialog;
-	dialog.set_session (session);
+	dialog.set_session (_session);
 	editor->ensure_float (dialog);
 	dialog.run ();
 }
@@ -2126,8 +2247,8 @@ ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path
 			   true);
 
 
-	msg.set_name (X_("CleanupDialog"));
-	msg.set_title (_("Cleanup Unused Sources"));
+	msg.set_name (X_("OpenExistingDialog"));
+	msg.set_title (_("Open Existing Session"));
 	msg.set_wmclass (X_("existing_session"), "Ardour");
 	msg.set_position (Gtk::WIN_POS_MOUSE);
 	pop_back_splash ();
@@ -2184,12 +2305,14 @@ ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib
 
 		/// @todo some minor tweaks.
 
-		if (_startup->connect_outs_to_master()) {
-			oconnect = AutoConnectMaster;
-		} else if (_startup->connect_outs_to_physical()) {
-			oconnect = AutoConnectPhysical;
-		} else {
-			oconnect = AutoConnectOption (0);
+		oconnect = AutoConnectOption (0);
+
+		if (_startup->connect_outputs ()) {
+			if (_startup->connect_outs_to_master()) {
+				oconnect = AutoConnectMaster;
+			} else if (_startup->connect_outs_to_physical()) {
+				oconnect = AutoConnectPhysical;
+			}
 		}
 
 		nphysin = (uint32_t) _startup->input_limit_count();
@@ -2215,7 +2338,7 @@ ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib
 void
 ARDOUR_UI::idle_load (const Glib::ustring& path)
 {
-	if (session) {
+	if (_session) {
 		if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
 			/* /path/to/foo => /path/to/foo, foo */
 			load_session (path, basename_nosuffix (path));
@@ -2261,8 +2384,9 @@ ARDOUR_UI::loading_message (const std::string& /*msg*/)
 	flush_pending ();
 }
 
+/** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
 int
-ARDOUR_UI::get_session_parameters (bool should_be_new)
+ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new)
 {
 	Glib::ustring session_name;
 	Glib::ustring session_path;
@@ -2289,7 +2413,14 @@ ARDOUR_UI::get_session_parameters (bool should_be_new)
 
 		} else {
 
-			run_startup (should_be_new);
+			bool const apply = run_startup (should_be_new);
+			if (!apply) {
+				if (quit_on_cancel) {
+					exit (1);
+				} else {
+					return ret;
+				}
+			}
 
 			/* if we run the startup dialog again, offer more than just "new session" */
 
@@ -2307,7 +2438,6 @@ ARDOUR_UI::get_session_parameters (bool should_be_new)
 				_session_is_new = true;
 			}
 
-
 			if (session_name[0] == '/' ||
 			    (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
 			    (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
@@ -2359,7 +2489,7 @@ ARDOUR_UI::get_session_parameters (bool should_be_new)
 
 			ret = load_session (session_path, session_name, template_name);
 			if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
-				session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
+				_session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
 				exit (1);
 			}
 		}
@@ -2378,7 +2508,7 @@ ARDOUR_UI::close_session()
 	unload_session (true);
 
 	ARDOUR_COMMAND_LINE::session_name = "";
-	get_session_parameters (false);
+	get_session_parameters (true, false);
 }
 
 int
@@ -2463,14 +2593,14 @@ ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_na
 		goto out;
 	}
 
-	connect_to_session (new_session);
+	set_session (new_session);
 
 	session_loaded = true;
 
 	goto_editor_window ();
 
-	if (session) {
-		session->set_clean ();
+	if (_session) {
+		_session->set_clean ();
 	}
 
 	flush_pending ();
@@ -2522,7 +2652,7 @@ ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_n
 		return -1;
 	}
 
-	connect_to_session (new_session);
+	set_session (new_session);
 
 	session_loaded = true;
 
@@ -2550,7 +2680,7 @@ ARDOUR_UI::show_about ()
 {
 	if (about == 0) {
 		about = new About;
-		about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );
+		about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) );
 	}
 
 	about->show_all ();
@@ -2598,7 +2728,7 @@ ARDOUR_UI::hide_splash ()
 }
 
 void
-ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title,
+ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title,
 				    const string& plural_msg, const string& singular_msg)
 {
 	size_t removed;
@@ -2654,7 +2784,7 @@ require some unused files to continue to exist."));
 
 	dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
 
-	const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
+	const string dead_sound_directory = _session->session_directory().dead_sound_path().to_string();
 
 
 
@@ -2722,7 +2852,7 @@ require some unused files to continue to exist."));
 void
 ARDOUR_UI::cleanup ()
 {
-	if (session == 0) {
+	if (_session == 0) {
 		/* shouldn't happen: menu item is insensitive */
 		return;
 	}
@@ -2753,7 +2883,7 @@ After cleanup, unused audio files will be moved to a \
 		return;
 	}
 
-	Session::cleanup_report rep;
+	ARDOUR::CleanupReport rep;
 
 	editor->prepare_for_cleanup ();
 
@@ -2764,7 +2894,7 @@ After cleanup, unused audio files will be moved to a \
 		act->set_sensitive (false);
 	}
 
-	if (session->cleanup_sources (rep)) {
+	if (_session->cleanup_sources (rep)) {
 		editor->finish_cleanup ();
 		return;
 	}
@@ -2795,14 +2925,14 @@ release an additional\n\
 void
 ARDOUR_UI::flush_trash ()
 {
-	if (session == 0) {
+	if (_session == 0) {
 		/* shouldn't happen: menu item is insensitive */
 		return;
 	}
 
-	Session::cleanup_report rep;
+	ARDOUR::CleanupReport rep;
 
-	if (session->cleanup_trash_sources (rep)) {
+	if (_session->cleanup_trash_sources (rep)) {
 		return;
 	}
 
@@ -2821,12 +2951,12 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
 {
 	int count;
 
-	if (!session) {
+	if (!_session) {
 		return;
 	}
 
 	if (add_route_dialog == 0) {
-		add_route_dialog = new AddRouteDialog (*session);
+		add_route_dialog = new AddRouteDialog (_session);
 		if (float_window) {
 			add_route_dialog->set_transient_for (*float_window);
 		}
@@ -2856,7 +2986,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
 	string template_path = add_route_dialog->track_template();
 
 	if (!template_path.empty()) {
-		session->new_route_from_template (count, template_path);
+		_session->new_route_from_template (count, template_path);
 		return;
 	}
 
@@ -2864,12 +2994,13 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
 	uint32_t output_chan;
 	string name_template = add_route_dialog->name_template ();
 	bool track = add_route_dialog->track ();
+	bool aux = !track && add_route_dialog->aux();
 	RouteGroup* route_group = add_route_dialog->route_group ();
 
 	AutoConnectOption oac = Config->get_output_auto_connect();
 
 	if (oac & AutoConnectMaster) {
-		output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan);
+		output_chan = (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan);
 	} else {
 		output_chan = input_chan;
 	}
@@ -2889,7 +3020,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
 		if (track) {
 			session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
 		} else {
-			session_add_audio_bus (input_chan, output_chan, route_group, count);
+			session_add_audio_bus (aux, input_chan, output_chan, route_group, count);
 		}
 	}
 }
@@ -2899,8 +3030,8 @@ ARDOUR_UI::mixer_settings () const
 {
 	XMLNode* node = 0;
 
-	if (session) {
-		node = session->instant_xml(X_("Mixer"));
+	if (_session) {
+		node = _session->instant_xml(X_("Mixer"));
 	} else {
 		node = Config->instant_xml(X_("Mixer"));
 	}
@@ -2917,8 +3048,8 @@ ARDOUR_UI::editor_settings () const
 {
 	XMLNode* node = 0;
 
-	if (session) {
-		node = session->instant_xml(X_("Editor"));
+	if (_session) {
+		node = _session->instant_xml(X_("Editor"));
 	} else {
 		node = Config->instant_xml(X_("Editor"));
 	}
@@ -2966,17 +3097,17 @@ ARDOUR_UI::halt_on_xrun_message ()
 void
 ARDOUR_UI::xrun_handler(nframes_t where)
 {
-	if (!session) {
+	if (!_session) {
 		return;
 	}
 
-	ENSURE_GUI_THREAD (bind(mem_fun(*this, &ARDOUR_UI::xrun_handler), where));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::xrun_handler, where)
 
-	if (session && Config->get_create_xrun_marker() && session->actively_recording()) {
+	if (_session && Config->get_create_xrun_marker() && _session->actively_recording()) {
 		create_xrun_marker(where);
 	}
 
-	if (session && Config->get_stop_recording_on_xrun() && session->actively_recording()) {
+	if (_session && Config->get_stop_recording_on_xrun() && _session->actively_recording()) {
 		halt_on_xrun_message ();
 	}
 }
@@ -2997,42 +3128,44 @@ ARDOUR_UI::push_buffer_stats (uint32_t capture, uint32_t playback)
 void
 ARDOUR_UI::write_buffer_stats ()
 {
+
+	std::ofstream fout;
 	struct tm tm;
 	char buf[64];
+	char path[PATH_MAX+1];	int fd;
 
-	char* tmplt = (char*)calloc(strlen("ardourXXXXXX"), sizeof(char));
-	int fd = mkstemp (tmplt);
-	if (fd) {
+	strcpy (path, "ardourBufferingXXXXXX");
+
+	if ((fd = mkstemp (path )) < 0) {
 		cerr << X_("cannot find temporary name for ardour buffer stats") << endl;
 		return;
 	}
+	
+	fout.open (path);
+	close (fd);
 
-	FILE* fout = fdopen (fd, "w");
 	if (!fout) {
-		cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), tmplt) << endl;
+		cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), path) << endl;
 		return;
 	}
 
 	for (list<DiskBufferStat>::iterator i = disk_buffer_stats.begin(); i != disk_buffer_stats.end(); ++i) {
-		std::ostringstream ss;
 		localtime_r (&(*i).when, &tm);
 		strftime (buf, sizeof (buf), "%T", &tm);
-		fprintf(fout, "%s %u %u\n", buf, (*i).capture, (*i).playback);
+		fout << buf << ' ' << (*i).capture << ' ' << (*i).playback << endl;
 	}
-
+	
 	disk_buffer_stats.clear ();
 
-	fclose (fout);
-	close (fd);
+	fout.close ();
 
-	cerr << "Ardour buffering statistics can be found in: " << tmplt << endl;
-	free (tmplt);
+	cerr << "Ardour buffering statistics can be found in: " << path << endl;
 }
 
 void
 ARDOUR_UI::disk_overrun_handler ()
 {
-	ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler)
 
 	write_buffer_stats ();
 
@@ -3044,7 +3177,7 @@ was not able to keep up with Ardour.\n\
 \n\
 Specifically, it failed to write data to disk\n\
 quickly enough to keep up with recording.\n"));
-		msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+		msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
 		msg->show ();
 	}
 }
@@ -3052,7 +3185,7 @@ quickly enough to keep up with recording.\n"));
 void
 ARDOUR_UI::disk_underrun_handler ()
 {
-	ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler)
 
 	write_buffer_stats ();
 
@@ -3064,7 +3197,7 @@ was not able to keep up with Ardour.\n\
 \n\
 Specifically, it failed to read data from disk\n\
 quickly enough to keep up with playback.\n"));
-		msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+		msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
 		msg->show ();
 	}
 }
@@ -3079,7 +3212,7 @@ ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
 void
 ARDOUR_UI::session_dialog (std::string msg)
 {
-	ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::session_dialog), msg));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::session_dialog, msg)
 
 	MessageDialog* d;
 
@@ -3219,19 +3352,19 @@ ARDOUR_UI::update_transport_clocks (nframes_t pos)
 void
 ARDOUR_UI::record_state_changed ()
 {
-	ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed));
+	ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
 
-	if (!session || !big_clock_window) {
+	if (!_session || !big_clock_window) {
 		/* why bother - the clock isn't visible */
 		return;
 	}
 
-	Session::RecordState const r = session->record_status ();
-	bool const h = session->have_rec_enabled_diskstream ();
+	Session::RecordState const r = _session->record_status ();
+	bool const h = _session->have_rec_enabled_diskstream ();
 
 	if (r == Session::Recording && h)  {
 		big_clock.set_widget_name ("BigClockRecording");
-        } else {
+	} else {
 		big_clock.set_widget_name ("BigClockNonRecording");
 	}
 }
@@ -3239,8 +3372,8 @@ ARDOUR_UI::record_state_changed ()
 bool
 ARDOUR_UI::first_idle ()
 {
-	if (session) {
-		session->allow_auto_play (true);
+	if (_session) {
+		_session->allow_auto_play (true);
 	}
 
 	if (editor) {
@@ -3260,14 +3393,14 @@ ARDOUR_UI::store_clock_modes ()
 		node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
 	}
 
-	session->add_extra_xml (*node);
-	session->set_dirty ();
+	_session->add_extra_xml (*node);
+	_session->set_dirty ();
 }
 
 
 
 ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp)
-	: Controllable (name), ui (u), type(tp)
+	: Controllable (name,  string() /* missing URI */), ui (u), type(tp)
 {
 
 }