Merged with trunk R1761

[ardour.git] / gtk2_ardour / ardour_ui.cc

diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index 78fad232fb7d9e9cdbc3da3352467fe6eed0321f..de006a8fecab3eb4a3e40e723118bd4e35ef2f85 100644 (file)
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -1,5 +1,5 @@
 /*
 /*

-    Copyright (C) 1999-2002 Paul Davis 
+    Copyright (C) 1999-2007 Paul Davis 

 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by


@@ -15,9 +15,11 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 

-    $Id$

 */
 
 */
 

+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+

 #include <algorithm>
 #include <cmath>
 #include <fcntl.h>
 #include <algorithm>
 #include <cmath>
 #include <fcntl.h>


@@ -28,35 +30,41 @@
 
 #include <iostream>
 
 
 #include <iostream>
 

+#include <sys/resource.h>
+

 #include <gtkmm/messagedialog.h>
 #include <gtkmm/messagedialog.h>

+#include <gtkmm/accelmap.h>

 
 #include <pbd/error.h>
 #include <pbd/compose.h>
 
 #include <pbd/error.h>
 #include <pbd/compose.h>

-#include <pbd/basename.h>

 #include <pbd/pathscanner.h>
 #include <pbd/failed_constructor.h>
 #include <pbd/pathscanner.h>
 #include <pbd/failed_constructor.h>

+#include <pbd/enumwriter.h>
+#include <pbd/stacktrace.h>

 #include <gtkmm2ext/gtk_ui.h>
 #include <gtkmm2ext/gtk_ui.h>

-#include <gtkmm2ext/pix.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/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++/port.h>
 #include <midi++/mmc.h>
 
 #include <ardour/ardour.h>
 
 #include <midi++/port.h>
 #include <midi++/mmc.h>
 
 #include <ardour/ardour.h>

+#include <ardour/profile.h>
+#include <ardour/session_route.h>

 #include <ardour/port.h>
 #include <ardour/audioengine.h>
 #include <ardour/playlist.h>
 #include <ardour/utils.h>
 #include <ardour/port.h>
 #include <ardour/audioengine.h>
 #include <ardour/playlist.h>
 #include <ardour/utils.h>

-#include <ardour/diskstream.h>
-#include <ardour/filesource.h>
+#include <ardour/audio_diskstream.h>
+#include <ardour/audiofilesource.h>

 #include <ardour/recent_sessions.h>
 #include <ardour/recent_sessions.h>

-#include <ardour/session_diskstream.h>

 #include <ardour/port.h>
 #include <ardour/audio_track.h>
 #include <ardour/port.h>
 #include <ardour/audio_track.h>

+#include <ardour/midi_track.h>

 
 #include "actions.h"
 #include "ardour_ui.h"
 
 #include "actions.h"
 #include "ardour_ui.h"


@@ -66,18 +74,17 @@
 #include "mixer_ui.h"
 #include "prompter.h"
 #include "opts.h"
 #include "mixer_ui.h"
 #include "prompter.h"
 #include "opts.h"

-#include "keyboard_target.h"

 #include "add_route_dialog.h"
 #include "new_session_dialog.h"
 #include "about.h"
 #include "utils.h"
 #include "gui_thread.h"
 #include "add_route_dialog.h"
 #include "new_session_dialog.h"
 #include "about.h"
 #include "utils.h"
 #include "gui_thread.h"

-#include "meter_xpms.h"

 #include "color_manager.h"
 
 #include "i18n.h"
 
 using namespace ARDOUR;
 #include "color_manager.h"
 
 #include "i18n.h"
 
 using namespace ARDOUR;

+using namespace PBD;

 using namespace Gtkmm2ext;
 using namespace Gtk;
 using namespace sigc;
 using namespace Gtkmm2ext;
 using namespace Gtk;
 using namespace sigc;


@@ -87,16 +94,16 @@ ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
 sigc::signal<void,bool> ARDOUR_UI::Blink;
 sigc::signal<void>      ARDOUR_UI::RapidScreenUpdate;
 sigc::signal<void>      ARDOUR_UI::SuperRapidScreenUpdate;
 sigc::signal<void,bool> ARDOUR_UI::Blink;
 sigc::signal<void>      ARDOUR_UI::RapidScreenUpdate;
 sigc::signal<void>      ARDOUR_UI::SuperRapidScreenUpdate;

-sigc::signal<void,jack_nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void,nframes_t> ARDOUR_UI::Clock;

 
 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
 
 
 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
 

-       : Gtkmm2ext::UI ("ardour", argcp, argvp, rcfile),
+       : Gtkmm2ext::UI (X_("Ardour"), argcp, argvp, rcfile),

          
          

-         primary_clock (X_("TransportClockDisplay"), true, false, true),
-         secondary_clock (X_("SecondaryClockDisplay"), true, false, true),
-         preroll_clock (X_("PreRollClock"), true, true),
-         postroll_clock (X_("PostRollClock"), true, true),
+         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),

 
          /* adjuster table */
 
 
          /* adjuster table */
 


@@ -109,24 +116,41 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
 
          /* big clock */
 
 
          /* big clock */
 

-         big_clock ("BigClockDisplay", true),
+         big_clock (X_("bigclock"), false, "BigClockNonRecording", false, false, true),

 
          /* transport */
 
 
          /* transport */
 

-         time_master_button (_("time\nmaster")),
-
+         roll_controllable ("transport roll", *this, TransportControllable::Roll),
+         stop_controllable ("transport stop", *this, TransportControllable::Stop),
+         goto_start_controllable ("transport goto start", *this, TransportControllable::GotoStart),
+         goto_end_controllable ("transport goto end", *this, TransportControllable::GotoEnd),
+         auto_loop_controllable ("transport auto loop", *this, TransportControllable::AutoLoop),
+         play_selection_controllable ("transport play selection", *this, TransportControllable::PlaySelection),
+         rec_controllable ("transport rec-enable", *this, TransportControllable::RecordEnable),
+         shuttle_controllable ("shuttle", *this, TransportControllable::ShuttleControl),
+         shuttle_controller_binding_proxy (shuttle_controllable),
+
+         roll_button (roll_controllable),
+         stop_button (stop_controllable),
+         goto_start_button (goto_start_controllable),
+         goto_end_button (goto_end_controllable),
+         auto_loop_button (auto_loop_controllable),
+         play_selection_button (play_selection_controllable),
+         rec_button (rec_controllable),
+         

          shuttle_units_button (_("% ")),
 
          shuttle_units_button (_("% ")),
 

-         punch_in_button (_("punch\nin")),
-         punch_out_button (_("punch\nout")),
-         auto_return_button (_("auto\nreturn")),
-         auto_play_button (_("auto\nplay")),
-         auto_input_button (_("auto\ninput")),
-         click_button (_("click")),
-         auditioning_alert_button (_("AUDITIONING")),
+         punch_in_button (_("Punch In")),
+         punch_out_button (_("Punch Out")),
+         auto_return_button (_("Auto Return")),
+         auto_play_button (_("Auto Play")),
+         auto_input_button (_("Auto Input")),
+         click_button (_("Click")),
+         time_master_button (_("time\nmaster")),
+
+         auditioning_alert_button (_("AUDITION")),

          solo_alert_button (_("SOLO")),
          shown_flag (false)
          solo_alert_button (_("SOLO")),
          shown_flag (false)

-

 {
        using namespace Gtk::Menu_Helpers;
 
 {
        using namespace Gtk::Menu_Helpers;
 


@@ -138,19 +162,14 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
                theArdourUI = this;
        }
 
                theArdourUI = this;
        }
 

-       ActionManager::init ();
-

        /* load colors */
 
        color_manager = new ColorManager();
 
        std::string color_file = ARDOUR::find_config_file("ardour.colors");
        /* load colors */
 
        color_manager = new ColorManager();
 
        std::string color_file = ARDOUR::find_config_file("ardour.colors");

-       
+

        color_manager->load (color_file);
 
        color_manager->load (color_file);
 

-       m_new_session_dialog = 0;
-       m_new_session_dialog_ref = NewSessionDialogFactory::create();
-       m_new_session_dialog_ref->get_widget_derived (NewSessionDialogFactory::top_level_widget_name(), m_new_session_dialog);

        editor = 0;
        mixer = 0;
        session = 0;
        editor = 0;
        mixer = 0;
        session = 0;


@@ -163,14 +182,15 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
        route_params = 0;
        option_editor = 0;
        location_ui = 0;
        route_params = 0;
        option_editor = 0;
        location_ui = 0;

-       sfdb = 0;

        open_session_selector = 0;
        have_configure_timeout = false;
        open_session_selector = 0;
        have_configure_timeout = false;

-       have_disk_overrun_displayed = false;
-       have_disk_underrun_displayed = false;
+       have_disk_speed_dialog_displayed = false;

        _will_create_new_session_automatically = false;
        session_loaded = false;
        last_speed_displayed = -1.0f;
        _will_create_new_session_automatically = false;
        session_loaded = false;
        last_speed_displayed = -1.0f;

+       keybindings_path = ARDOUR::find_config_file ("ardour.bindings");
+
+       can_save_keybindings = false;

 
        last_configure_time.tv_sec = 0;
        last_configure_time.tv_usec = 0;
 
        last_configure_time.tv_sec = 0;
        last_configure_time.tv_usec = 0;


@@ -179,19 +199,14 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
        shuttle_fract = 0.0;
        shuttle_max_speed = 8.0f;
 
        shuttle_fract = 0.0;
        shuttle_max_speed = 8.0f;
 

-       set_shuttle_units (Percentage);
-       set_shuttle_behaviour (Sprung);
-

        shuttle_style_menu = 0;
        shuttle_unit_menu = 0;
 
        gettimeofday (&last_peak_grab, 0);
        gettimeofday (&last_shuttle_request, 0);
 
        shuttle_style_menu = 0;
        shuttle_unit_menu = 0;
 
        gettimeofday (&last_peak_grab, 0);
        gettimeofday (&last_shuttle_request, 0);
 

-       ARDOUR::DiskStream::CannotRecordNoInput.connect (mem_fun(*this, &ARDOUR_UI::cannot_record_no_input));
-       ARDOUR::DiskStream::DeleteSources.connect (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread));
-       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 (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
+       ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));

 
        /* handle pending state with a dialog */
 
 
        /* handle pending state with a dialog */
 


@@ -200,22 +215,6 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
        /* have to wait for AudioEngine and Configuration before proceeding */
 }
 
        /* have to wait for AudioEngine and Configuration before proceeding */
 }
 

-void
-ARDOUR_UI::cannot_record_no_input (DiskStream* ds)
-{
-       ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::cannot_record_no_input), ds));
-       
-       string msg = string_compose (_("\
-You cannot record-enable\n\
-track %1\n\
-because it has no input connections.\n\
-You would be wasting space recording silence."),
-                             ds->name());
-
-       MessageDialog message (*editor, msg);
-       message.run ();
-}
-

 void
 ARDOUR_UI::set_engine (AudioEngine& e)
 {
 void
 ARDOUR_UI::set_engine (AudioEngine& e)
 {


@@ -226,13 +225,12 @@ ARDOUR_UI::set_engine (AudioEngine& e)
        engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
        engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
 
        engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
        engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
 

+               ActionManager::init ();
+       new_session_dialog = new NewSessionDialog();
+

        _tooltips.enable();
 
        keyboard = new Keyboard;
        _tooltips.enable();
 
        keyboard = new Keyboard;

-       install_keybindings ();
-
-       FastMeter::set_vertical_xpm (v_meter_strip_xpm);
-       FastMeter::set_horizontal_xpm (h_meter_strip_xpm);

 
        if (setup_windows ()) {
                throw failed_constructor ();
 
        if (setup_windows ()) {
                throw failed_constructor ();


@@ -260,14 +258,19 @@ ARDOUR_UI::set_engine (AudioEngine& e)
        
        blink_timeout_tag = -1;
 
        
        blink_timeout_tag = -1;
 

+       /* the global configuration object is now valid */
+
+       use_config ();
+

        /* this being a GUI and all, we want peakfiles */
 
        /* this being a GUI and all, we want peakfiles */
 

-       FileSource::set_build_peakfiles (true);
-       FileSource::set_build_missing_peakfiles (true);
+       AudioFileSource::set_build_peakfiles (true);
+       AudioFileSource::set_build_missing_peakfiles (true);

 
 

-       if (Source::start_peak_thread ()) {
-               throw failed_constructor();
-       }
+       /* set default clock modes */
+
+       primary_clock.set_mode (AudioClock::SMPTE);
+       secondary_clock.set_mode (AudioClock::BBT);

 
        /* start the time-of-day-clock */
        
 
        /* start the time-of-day-clock */
        


@@ -301,8 +304,6 @@ ARDOUR_UI::~ARDOUR_UI ()
        if (add_route_dialog) {
                delete add_route_dialog;
        }
        if (add_route_dialog) {
                delete add_route_dialog;
        }

-
-       Source::stop_peak_thread ();

 }
 
 gint
 }
 
 gint


@@ -344,6 +345,63 @@ ARDOUR_UI::configure_handler (GdkEventConfigure* conf)
        return FALSE;
 }
 
        return FALSE;
 }
 

+void
+ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
+{
+       const XMLProperty* prop;
+
+       if ((prop = node.property ("roll")) != 0) {
+               roll_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("stop")) != 0) {
+               stop_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("goto_start")) != 0) {
+               goto_start_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("goto_end")) != 0) {
+               goto_end_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("auto_loop")) != 0) {
+               auto_loop_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("play_selection")) != 0) {
+               play_selection_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("rec")) != 0) {
+               rec_controllable.set_id (prop->value());
+       }
+       if ((prop = node.property ("shuttle")) != 0) {
+               shuttle_controllable.set_id (prop->value());
+       }
+}
+
+XMLNode&
+ARDOUR_UI::get_transport_controllable_state ()
+{
+       XMLNode* node = new XMLNode(X_("TransportControllables"));
+       char buf[64];
+
+       roll_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("roll"), buf);
+       stop_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("stop"), buf);
+       goto_start_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("goto_start"), buf);
+       goto_end_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("goto_end"), buf);
+       auto_loop_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("auto_loop"), buf);
+       play_selection_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("play_selection"), buf);
+       rec_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("rec"), buf);
+       shuttle_controllable.id().print (buf, sizeof (buf));
+       node->add_property (X_("shuttle"), buf);
+
+       return *node;
+}
+

 void
 ARDOUR_UI::save_ardour_state ()
 {
 void
 ARDOUR_UI::save_ardour_state ()
 {


@@ -357,33 +415,125 @@ ARDOUR_UI::save_ardour_state ()
 
        XMLNode* node = new XMLNode (keyboard->get_state());
        Config->add_extra_xml (*node);
 
        XMLNode* node = new XMLNode (keyboard->get_state());
        Config->add_extra_xml (*node);

+       Config->add_extra_xml (get_transport_controllable_state());

        Config->save_state();
 
        Config->save_state();
 

-       XMLNode& enode (static_cast<Stateful*>(editor)->get_state());
-       XMLNode& mnode (mixer->get_state());
+       XMLNode enode(static_cast<Stateful*>(editor)->get_state());
+       XMLNode mnode(mixer->get_state());

 
        if (session) {
 
        if (session) {

-               session->add_instant_xml(enode, session->path());
-               session->add_instant_xml(mnode, session->path());
+               session->add_instant_xml (enode, session->path());
+               session->add_instant_xml (mnode, session->path());

        } else {
        } else {

-               Config->add_instant_xml(enode, get_user_ardour_path());
-               Config->add_instant_xml(mnode, get_user_ardour_path());
+               Config->add_instant_xml (enode, get_user_ardour_path());
+               Config->add_instant_xml (mnode, get_user_ardour_path());

        }
        }

+
+       save_keybindings ();
+}
+
+gint
+ARDOUR_UI::autosave_session ()
+{
+        if (!Config->get_periodic_safety_backups())
+                return 1;
+        
+        if (session) {
+                session->maybe_write_autosave();
+        }
+
+        return 1;
+}
+
+void
+ARDOUR_UI::update_autosave ()
+{
+        ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
+        
+        if (session->dirty()) {
+                if (_autosave_connection.connected()) {
+                        _autosave_connection.disconnect();
+                }
+
+                _autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session),
+                                                                   Config->get_periodic_safety_backup_interval() * 1000);
+
+        } else {
+                if (_autosave_connection.connected()) {
+                        _autosave_connection.disconnect();
+                }               
+        }

 }
 
 void
 ARDOUR_UI::startup ()
 {
 }
 
 void
 ARDOUR_UI::startup ()
 {

-       /* Once the UI is up and running, start the audio engine. Doing
-          this before the UI is up and running can cause problems
-          when not running with SCHED_FIFO, because the amount of
-          CPU and disk work needed to get the UI started can interfere
-          with the scheduling of the audio thread.
-       */
+       check_memory_locking();
+}
+
+void
+ARDOUR_UI::no_memory_warning ()
+{
+       XMLNode node (X_("no-memory-warning"));
+       Config->add_instant_xml (node, get_user_ardour_path());
+}
+
+void
+ARDOUR_UI::check_memory_locking ()
+{
+#ifdef __APPLE__
+       /* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
+       return;
+#else // !__APPLE__
+
+       XMLNode* memory_warning_node = Config->instant_xml (X_("no-memory-warning"), get_user_ardour_path());
+
+       if (engine->is_realtime() && memory_warning_node == 0) {
+
+               struct rlimit limits;
+               int64_t ram;
+               long pages, page_size;
+
+               if ((page_size = sysconf (_SC_PAGESIZE)) < 0 ||(pages = sysconf (_SC_PHYS_PAGES)) < 0) {
+                       ram = 0;
+               } else {
+                       ram = (int64_t) pages * (int64_t) page_size;
+               }

 
 

-       Glib::signal_idle().connect (mem_fun(*this, &ARDOUR_UI::start_engine));
+               if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
+                       return;
+               }
+               
+               if (limits.rlim_cur != RLIM_INFINITY) {
+
+                       if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
+                       
+
+                               MessageDialog msg (_("WARNING: Your system has a limit for maximum amount of locked memory. "
+                                                    "This might cause Ardour to run out of memory before your system "
+                                                    "runs out of memory. \n\n"
+                                                    "You can view the memory limit with 'ulimit -l', "
+                                                    "and it is normally controlled by /etc/security/limits.conf"));
+                               
+                               VBox* vbox = msg.get_vbox();
+                               HBox hbox;
+                               CheckButton cb (_("Do not show this window again"));
+                               
+                               cb.signal_toggled().connect (mem_fun (*this, &ARDOUR_UI::no_memory_warning));
+                               
+                               hbox.pack_start (cb, true, false);
+                               vbox->pack_start (hbox);
+                               hbox.show_all ();
+                               
+                               editor->ensure_float (msg);
+                               msg.run ();
+                       }
+               }
+       }
+#endif // !__APPLE__

 }
 
 }
 

+

 void
 ARDOUR_UI::finish()
 {
 void
 ARDOUR_UI::finish()
 {


@@ -410,6 +560,11 @@ If you still wish to quit, please use the\n\n\
                }
        }
 
                }
        }
 

+       if (session) {
+               session->set_deletion_in_progress ();
+       }
+       engine->stop (true);
+       Config->save_state();

        quit ();
 }
 
        quit ();
 }
 


@@ -417,15 +572,20 @@ int
 ARDOUR_UI::ask_about_saving_session (const string & what)
 {
        ArdourDialog window (_("ardour: save session?"));
 ARDOUR_UI::ask_about_saving_session (const string & what)
 {
        ArdourDialog window (_("ardour: save session?"));

+       Gtk::HBox dhbox;  // the hbox for the image and text

        Gtk::Label  prompt_label;
        Gtk::Label  prompt_label;

+       Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING,  Gtk::ICON_SIZE_DIALOG));
+

        string msg;
 
        string msg;
 

-       msg = string_compose(_("Save and %1"), what);
-       window.add_button (msg, RESPONSE_ACCEPT);
-       msg = string_compose(_("Just %1"), what);
-       window.add_button (msg, RESPONSE_APPLY);

        msg = string_compose(_("Don't %1"), what);
        window.add_button (msg, RESPONSE_REJECT);
        msg = string_compose(_("Don't %1"), what);
        window.add_button (msg, RESPONSE_REJECT);

+       msg = string_compose(_("Just %1"), what);
+       window.add_button (msg, RESPONSE_APPLY);
+       msg = string_compose(_("Save and %1"), what);
+       window.add_button (msg, RESPONSE_ACCEPT);
+
+       window.set_default_response (RESPONSE_ACCEPT);

 
        Gtk::Button noquit_button (msg);
        noquit_button.set_name ("EditorGTKButton");
 
        Gtk::Button noquit_button (msg);
        noquit_button.set_name ("EditorGTKButton");


@@ -438,23 +598,30 @@ ARDOUR_UI::ask_about_saving_session (const string & what)
        } else {
                type = _("snapshot");
        }
        } else {
                type = _("snapshot");
        }

-       prompt = string_compose(_("The %1\n\"%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?"), 
+       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());
        
        prompt_label.set_text (prompt);
                         type, session->snap_name());
        
        prompt_label.set_text (prompt);

-       prompt_label.set_alignment (0.5, 0.5);

        prompt_label.set_name (X_("PrompterLabel"));
        prompt_label.set_name (X_("PrompterLabel"));

-       
-       window.get_vbox()->pack_start (prompt_label);
+       prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
+
+       dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP)
+;
+       dhbox.set_homogeneous (false);
+       dhbox.pack_start (*dimage, false, false, 5);
+       dhbox.pack_start (prompt_label, true, false, 5);
+       window.get_vbox()->pack_start (dhbox);

 
        window.set_name (_("Prompter"));
        window.set_position (Gtk::WIN_POS_MOUSE);
        window.set_modal (true);
 
        window.set_name (_("Prompter"));
        window.set_position (Gtk::WIN_POS_MOUSE);
        window.set_modal (true);

+       window.set_resizable (false);

        window.show_all ();
 
        save_the_session = 0;
 
        window.show_all ();
 
        save_the_session = 0;
 

-       editor->ensure_float (window);
+       window.set_keep_above (true);
+       window.present ();

 
        ResponseType r = (ResponseType) window.run();
 
 
        ResponseType r = (ResponseType) window.run();
 


@@ -478,27 +645,12 @@ ARDOUR_UI::every_second ()
        update_cpu_load ();
        update_buffer_load ();
        update_disk_space ();
        update_cpu_load ();
        update_buffer_load ();
        update_disk_space ();

-       // update_disk_rate ();

        return TRUE;
 }
 
 gint
 ARDOUR_UI::every_point_one_seconds ()
 {
        return TRUE;
 }
 
 gint
 ARDOUR_UI::every_point_one_seconds ()
 {

-       struct timeval now;
-       struct timeval diff;
-       
-       /* do not attempt to grab peak power more than once per cycle.
-        */
-
-       gettimeofday (&now, 0);
-       timersub (&now, &last_peak_grab, &diff);
-
-       if ((diff.tv_usec + (diff.tv_sec * 1000000)) >= engine->usecs_per_cycle()) {
-               IO::GrabPeakPower(); /* EMIT_SIGNAL */
-               last_peak_grab = now;
-       } 
-

        update_speed_display ();
        RapidScreenUpdate(); /* EMIT_SIGNAL */
        return TRUE;
        update_speed_display ();
        RapidScreenUpdate(); /* EMIT_SIGNAL */
        return TRUE;


@@ -512,7 +664,7 @@ ARDOUR_UI::every_point_zero_one_seconds ()
 }
 
 void
 }
 
 void

-ARDOUR_UI::update_sample_rate (jack_nframes_t ignored)
+ARDOUR_UI::update_sample_rate (nframes_t ignored)

 {
        char buf[32];
 
 {
        char buf[32];
 


@@ -524,14 +676,14 @@ ARDOUR_UI::update_sample_rate (jack_nframes_t ignored)
 
        } else {
 
 
        } else {
 

-               jack_nframes_t rate = engine->frame_rate();
+               nframes_t rate = engine->frame_rate();

                
                if (fmod (rate, 1000.0) != 0.0) {
                
                if (fmod (rate, 1000.0) != 0.0) {

-                       snprintf (buf, sizeof (buf), _("SR: %.1f kHz / %4.1f msecs"), 
+                       snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"), 

                                  (float) rate/1000.0f,
                                  (engine->frames_per_cycle() / (float) rate) * 1000.0f);
                } else {
                                  (float) rate/1000.0f,
                                  (engine->frames_per_cycle() / (float) rate) * 1000.0f);
                } else {

-                       snprintf (buf, sizeof (buf), _("SR: %u kHz / %4.1f msecs"), 
+                       snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"), 

                                  rate/1000,
                                  (engine->frames_per_cycle() / (float) rate) * 1000.0f);
                }
                                  rate/1000,
                                  (engine->frames_per_cycle() / (float) rate) * 1000.0f);
                }


@@ -544,24 +696,10 @@ void
 ARDOUR_UI::update_cpu_load ()
 {
        char buf[32];
 ARDOUR_UI::update_cpu_load ()
 {
        char buf[32];

-       snprintf (buf, sizeof (buf), _("DSP Load: %.1f%%"), engine->get_cpu_load());
+       snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load());

        cpu_load_label.set_text (buf);
 }
 
        cpu_load_label.set_text (buf);
 }
 

-void
-ARDOUR_UI::update_disk_rate ()
-{
-       char buf[64];
-
-       if (session) {
-               snprintf (buf, sizeof (buf), _("Disk r:%5.1f w:%5.1f MB/s"), 
-                         session->read_data_rate()/1048576.0f, session->write_data_rate()/1048576.0f);
-               disk_rate_label.set_text (buf);
-       } else {
-               disk_rate_label.set_text ("");
-       }
-}
-

 void
 ARDOUR_UI::update_buffer_load ()
 {
 void
 ARDOUR_UI::update_buffer_load ()
 {


@@ -577,10 +715,11 @@ ARDOUR_UI::update_buffer_load ()
 }
 
 void
 }
 
 void

-ARDOUR_UI::count_recenabled_diskstreams (DiskStream& ds)
+ARDOUR_UI::count_recenabled_streams (Route& route)

 {
 {

-       if (ds.record_enabled()) {
-               rec_enabled_diskstreams++;
+       Track* track = dynamic_cast<Track*>(&route);
+       if (track && track->diskstream()->record_enabled()) {
+               rec_enabled_streams += track->n_inputs().get_total();

        }
 }
 
        }
 }
 


@@ -591,32 +730,22 @@ ARDOUR_UI::update_disk_space()
                return;
        }
 
                return;
        }
 

-       jack_nframes_t frames = session->available_capture_duration();
+       nframes_t frames = session->available_capture_duration();

        char buf[64];
 
        if (frames == max_frames) {
        char buf[64];
 
        if (frames == max_frames) {

-               strcpy (buf, _("space: 24hrs+"));
+               strcpy (buf, _("Disk: 24hrs+"));

        } else {
                int hrs;
                int mins;
                int secs;
        } else {
                int hrs;
                int mins;
                int secs;

-               jack_nframes_t fr = session->frame_rate();
+               nframes_t fr = session->frame_rate();

                
                

-               if (session->actively_recording()){
-                       
-                       rec_enabled_diskstreams = 0;
-                       session->foreach_diskstream (this, &ARDOUR_UI::count_recenabled_diskstreams);
-                       
-                       if (rec_enabled_diskstreams) {
-                               frames /= rec_enabled_diskstreams;
-                       }
-                       
-               } else {
-                       
-                       /* hmmm. shall we divide by the route count? or the diskstream count?
-                          or what? for now, do nothing ...
-                       */
-                       
+               rec_enabled_streams = 0;
+               session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
+               
+               if (rec_enabled_streams) {
+                       frames /= rec_enabled_streams;

                }
                
                hrs  = frames / (fr * 3600);
                }
                
                hrs  = frames / (fr * 3600);


@@ -625,7 +754,7 @@ ARDOUR_UI::update_disk_space()
                frames -= mins * fr * 60;
                secs = frames / fr;
                
                frames -= mins * fr * 60;
                secs = frames / fr;
                

-               snprintf (buf, sizeof(buf), _("space: %02dh:%02dm:%02ds"), hrs, mins, secs);
+               snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);

        }
 
        disk_space_label.set_text (buf);
        }
 
        disk_space_label.set_text (buf);


@@ -646,40 +775,6 @@ ARDOUR_UI::update_wall_clock ()
 
        return TRUE;
 }
 
        return TRUE;
 }

-void
-ARDOUR_UI::control_methods_adjusted ()
-
-{
-       int which_method;
-
-       which_method = (int) online_control_button->adjustment.get_value();
-       switch (which_method) {
-       case 0:
-               allow_mmc_and_local ();
-               break;
-       case 1:
-               allow_mmc_only ();
-               break;
-       case 2:
-               allow_local_only ();
-               break;
-       default:
-               fatal << _("programming error: impossible control method") << endmsg;
-       }
-}
-       
-
-void
-ARDOUR_UI::mmc_device_id_adjusted ()
-
-{
-#if 0
-       if (mmc) {
-               int dev_id = (int) mmc_id_button->adjustment.get_value();
-               mmc->set_device_id (dev_id);
-       }
-#endif
-}

 
 gint
 ARDOUR_UI::session_menu (GdkEventButton *ev)
 
 gint
 ARDOUR_UI::session_menu (GdkEventButton *ev)


@@ -735,7 +830,7 @@ ARDOUR_UI::redisplay_recent_sessions ()
 
                TreeModel::Row row = *(recent_session_model->append());
 
 
                TreeModel::Row row = *(recent_session_model->append());
 

-               row[recent_session_columns.visible_name] = PBD::basename (fullpath);
+               row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);

                row[recent_session_columns.fullpath] = fullpath;
 
                if (states->size() > 1) {
                row[recent_session_columns.fullpath] = fullpath;
 
                if (states->size() > 1) {


@@ -768,12 +863,15 @@ ARDOUR_UI::build_session_selector ()
        Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
        
        session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
        Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
        
        session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);

-       session_selector_window->add_button (Stock::OK, RESPONSE_ACCEPT);
-
+       session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
+       session_selector_window->set_default_response (RESPONSE_ACCEPT);

        recent_session_model = TreeStore::create (recent_session_columns);
        recent_session_display.set_model (recent_session_model);
        recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
        recent_session_display.set_headers_visible (false);
        recent_session_model = TreeStore::create (recent_session_columns);
        recent_session_display.set_model (recent_session_model);
        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_SINGLE);
+
+       recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));

 
        scroller->add (recent_session_display);
        scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 
        scroller->add (recent_session_display);
        scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);


@@ -784,6 +882,12 @@ ARDOUR_UI::build_session_selector ()
        session_selector_window->show_all_children();
 }
 
        session_selector_window->show_all_children();
 }
 

+void
+ARDOUR_UI::recent_session_row_activated (const TreePath& path, TreeViewColumn* col)
+{
+       session_selector_window->response (RESPONSE_ACCEPT);
+}
+

 void
 ARDOUR_UI::open_recent_session ()
 {
 void
 ARDOUR_UI::open_recent_session ()
 {


@@ -833,9 +937,11 @@ ARDOUR_UI::filter_ardour_session_dirs (const FileFilter::Info& info)
                return false;
        }
 
                return false;
        }
 

+        // XXX Portability
+        

        string session_file = info.filename;
        session_file += '/';
        string session_file = info.filename;
        session_file += '/';

-       session_file += PBD::basename (info.filename);
+       session_file += Glib::path_get_basename (info.filename);

        session_file += ".ardour";
        
        if (stat (session_file.c_str(), &statbuf) != 0) {
        session_file += ".ardour";
        
        if (stat (session_file.c_str(), &statbuf) != 0) {


@@ -845,9 +951,30 @@ ARDOUR_UI::filter_ardour_session_dirs (const FileFilter::Info& info)
        return S_ISREG (statbuf.st_mode);
 }
 
        return S_ISREG (statbuf.st_mode);
 }
 

+bool
+ARDOUR_UI::check_audioengine ()
+{
+       if (engine) {
+               if (!engine->connected()) {
+                       MessageDialog msg (_("Ardour is not connected to JACK\n"
+                                            "You cannot open or close sessions in this condition"));
+                       msg.run ();
+                       return false;
+               }
+               return true;
+       } else {
+               return false;
+       }
+}
+

 void
 ARDOUR_UI::open_session ()
 {
 void
 ARDOUR_UI::open_session ()
 {

+       if (!check_audioengine()) {
+               return;
+               
+       }
+

        /* popup selector window */
 
        if (open_session_selector == 0) {
        /* popup selector window */
 
        if (open_session_selector == 0) {


@@ -891,29 +1018,79 @@ ARDOUR_UI::open_session ()
 
 
 void
 
 
 void

-ARDOUR_UI::session_add_midi_track ()
+ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)

 {
 {

-       cerr << _("Patience is a virtue.\n");
+       list<boost::shared_ptr<MidiTrack> > tracks;
+
+       if (session == 0) {
+               warning << _("You cannot add a track without a session already loaded.") << endmsg;
+               return;
+       }
+
+       try { 
+               if (disk) {
+
+                       tracks = session->new_midi_track (ARDOUR::Normal, how_many);
+
+                       if (tracks.size() != how_many) {
+                               if (how_many == 1) {
+                                       error << _("could not create a new midi track") << endmsg;
+                               } else {
+                                       error << string_compose (_("could not create %1 new midi tracks"), how_many) << endmsg;
+                               }
+                       }
+               } /*else {
+                       if ((route = session->new_midi_route ()) == 0) {
+                               error << _("could not create new midi bus") << endmsg;
+                       }
+               }*/
+       }
+
+       catch (...) {
+               MessageDialog msg (*editor, 
+                                  _("There are insufficient JACK ports available\n\
+to create a new track or bus.\n\
+You should save Ardour, exit and\n\
+restart JACK with more ports."));
+               msg.run ();
+       }

 }
 
 }
 

+

 void
 void

-ARDOUR_UI::session_add_audio_route (bool disk, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode)
+ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, uint32_t how_many)

 {
 {

-       Route* route;
+       list<boost::shared_ptr<AudioTrack> > tracks;
+       Session::RouteList routes;

 
        if (session == 0) {
 
        if (session == 0) {

-               warning << _("You cannot add a track without a session already loaded.") << endmsg;
+               warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;

                return;
        }
 
        try { 
                return;
        }
 
        try { 

-               if (disk) {
-                       if ((route = session->new_audio_track (input_channels, output_channels, mode)) == 0) {
-                               error << _("could not create new audio track") << endmsg;
+               if (track) {
+                       tracks = session->new_audio_track (input_channels, output_channels, mode, how_many);
+
+                       if (tracks.size() != how_many) {
+                               if (how_many == 1) {
+                                       error << _("could not create a new audio track") << endmsg;
+                               } else {
+                                       error << string_compose (_("could only create %1 of %2 new audio %3"), 
+                                                                tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
+                               }

                        }
                        }

+

                } else {
                } else {

-                       if ((route = session->new_audio_route (input_channels, output_channels)) == 0) {
-                               error << _("could not create new audio bus") << endmsg;
+
+                       routes = session->new_audio_route (input_channels, output_channels, how_many);
+
+                       if (routes.size() != how_many) {
+                               if (how_many == 1) {
+                                       error << _("could not create a new audio track") << endmsg;
+                               } else {
+                                       error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
+                               }

                        }
                }
                
                        }
                }
                


@@ -931,6 +1108,7 @@ ARDOUR_UI::session_add_audio_route (bool disk, int32_t input_channels, int32_t o
        }
 
        catch (...) {
        }
 
        catch (...) {

+               cerr << "About to complain about JACK\n";

                MessageDialog msg (*editor, 
                                   _("There are insufficient JACK ports available\n\
 to create a new track or bus.\n\
                MessageDialog msg (*editor, 
                                   _("There are insufficient JACK ports available\n\
 to create a new track or bus.\n\


@@ -941,17 +1119,13 @@ restart JACK with more ports."));
 }
 
 void
 }
 
 void

-ARDOUR_UI::diskstream_added (DiskStream* ds)
-{
-}
-
-void
-ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
+ARDOUR_UI::do_transport_locate (nframes_t new_position)

 {
 {

-       jack_nframes_t _preroll;
+       nframes_t _preroll = 0;

 
        if (session) {
 
        if (session) {

-               _preroll = session->convert_to_frames_at (new_position, session->preroll);
+               // XXX CONFIG_CHANGE FIX - requires AnyTime handling
+               // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());

 
                if (new_position > _preroll) {
                        new_position -= _preroll;
 
                if (new_position > _preroll) {
                        new_position -= _preroll;


@@ -975,7 +1149,7 @@ ARDOUR_UI::transport_goto_start ()
                */
                
                if (editor) {
                */
                
                if (editor) {

-                       editor->reposition_x_origin (session->current_start_frame());
+                       editor->reset_x_origin (session->current_start_frame());

                }
        }
 }
                }
        }
 }


@@ -992,7 +1166,7 @@ ARDOUR_UI::transport_goto_zero ()
                */
                
                if (editor) {
                */
                
                if (editor) {

-                       editor->reposition_x_origin (0);
+                       editor->reset_x_origin (0);

                }
        }
 }
                }
        }
 }


@@ -1001,7 +1175,7 @@ void
 ARDOUR_UI::transport_goto_end ()
 {
        if (session) {
 ARDOUR_UI::transport_goto_end ()
 {
        if (session) {

-               jack_nframes_t frame = session->current_end_frame();
+               nframes_t frame = session->current_end_frame();

                session->request_locate (frame);
 
                /* force displayed area in editor to start no matter
                session->request_locate (frame);
 
                /* force displayed area in editor to start no matter


@@ -1009,7 +1183,7 @@ ARDOUR_UI::transport_goto_end ()
                */
                
                if (editor) {
                */
                
                if (editor) {

-                       editor->reposition_x_origin (frame);
+                       editor->reset_x_origin (frame);

                }
        }
 }
                }
        }
 }


@@ -1026,8 +1200,8 @@ ARDOUR_UI::transport_stop ()
                return;
        }
        
                return;
        }
        

-       if (session->get_auto_loop()) {
-               session->request_auto_loop (false);
+       if (session->get_play_loop ()) {
+               session->request_play_loop (false);

        }
        
        session->request_stop ();
        }
        
        session->request_stop ();


@@ -1056,8 +1230,7 @@ ARDOUR_UI::transport_record ()
                switch (session->record_status()) {
                case Session::Disabled:
                        if (session->ntracks() == 0) {
                switch (session->record_status()) {
                case Session::Disabled:
                        if (session->ntracks() == 0) {

-                               string txt = _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu.");
-                               MessageDialog msg (*editor, txt);
+                               MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));

                                msg.run ();
                                return;
                        }
                                msg.run ();
                                return;
                        }


@@ -1081,13 +1254,13 @@ ARDOUR_UI::transport_roll ()
 
        rolling = session->transport_rolling ();
 
 
        rolling = session->transport_rolling ();
 

-       if (session->get_auto_loop()) {
-               session->request_auto_loop (false);
-               auto_loop_button.set_active (false);
-               roll_button.set_active (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);
        } else if (session->get_play_range ()) {
                session->request_play_range (false);

-               play_selection_button.set_active (false);
+               play_selection_button.set_visual_state (0);

        } else if (rolling) {
                session->request_locate (session->last_transport_start(), true);
        }
        } else if (rolling) {
                session->request_locate (session->last_transport_start(), true);
        }


@@ -1099,7 +1272,7 @@ void
 ARDOUR_UI::transport_loop()
 {
        if (session) {
 ARDOUR_UI::transport_loop()
 {
        if (session) {

-               if (session->get_auto_loop()) {
+               if (session->get_play_loop()) {

                        if (session->transport_rolling()) {
                                Location * looploc = session->locations()->auto_loop_location();
                                if (looploc) {
                        if (session->transport_rolling()) {
                                Location * looploc = session->locations()->auto_loop_location();
                                if (looploc) {


@@ -1108,7 +1281,7 @@ ARDOUR_UI::transport_loop()
                        }
                }
                else {
                        }
                }
                else {

-                       session->request_auto_loop (true);
+                       session->request_play_loop (true);

                }
        }
 }
                }
        }
 }


@@ -1182,32 +1355,25 @@ ARDOUR_UI::transport_forward (int option)
 }
 
 void
 }
 
 void

-ARDOUR_UI::toggle_monitor_enable (guint32 dstream)
+ARDOUR_UI::toggle_record_enable (uint32_t dstream)

 {
        if (session == 0) {
                return;
        }
 
 {
        if (session == 0) {
                return;
        }
 

-       DiskStream *ds;
+       boost::shared_ptr<Route> r;
+       
+       if ((r = session->route_by_remote_id (dstream)) != 0) {

 
 

-       if ((ds = session->diskstream_by_id (dstream)) != 0) {
-               Port *port = ds->io()->input (0);
-               port->request_monitor_input (!port->monitoring_input());
-       }
-}
+               Track* t;

 
 

-void
-ARDOUR_UI::toggle_record_enable (guint32 dstream)
-{
+               if ((t = dynamic_cast<Track*>(r.get())) != 0) {
+                       t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
+               }
+       }

        if (session == 0) {
                return;
        }
        if (session == 0) {
                return;
        }

-
-       DiskStream *ds;
-
-       if ((ds = session->diskstream_by_id (dstream)) != 0) {
-               ds->set_record_enabled (!ds->record_enabled(), this);
-       }

 }
 
 void
 }
 
 void


@@ -1232,32 +1398,6 @@ ARDOUR_UI::map_transport_state ()
        }
 }
 
        }
 }
 

-void
-ARDOUR_UI::send_all_midi_feedback ()
-{
-       if (session) {
-               session->send_all_midi_feedback();
-       }
-}
-
-void
-ARDOUR_UI::allow_local_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_and_local ()
-{
-
-}
-

 void
 ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
 {
 void
 ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
 {


@@ -1273,31 +1413,73 @@ ARDOUR_UI::engine_stopped ()
        ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
 }
 
        ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
 }
 

-

 void
 ARDOUR_UI::engine_running ()
 {
        ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
        ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
        ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
 void
 ARDOUR_UI::engine_running ()
 {
        ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
        ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
        ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);

-}
-
-void
-ARDOUR_UI::engine_halted ()
-{
-       ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
-
-       ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
-       ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);

 
 

-       update_sample_rate (0);
+       Glib::RefPtr<Action> action;
+       char* action_name = 0;

 
 

-       MessageDialog msg (*editor, 
-                          _("\
-JACK has either been shutdown or it\n\
-disconnected Ardour because Ardour\n\
-was not fast enough. You can save the\n\
-session and/or try to reconnect to JACK ."));
+       switch (engine->frames_per_cycle()) {
+       case 32:
+               action_name = X_("JACKLatency32");
+               break;
+       case 64:
+               action_name = X_("JACKLatency64");
+               break;
+       case 128:
+               action_name = X_("JACKLatency128");
+               break;
+       case 512:
+               action_name = X_("JACKLatency512");
+               break;
+       case 1024:
+               action_name = X_("JACKLatency1024");
+               break;
+       case 2048:
+               action_name = X_("JACKLatency2048");
+               break;
+       case 4096:
+               action_name = X_("JACKLatency4096");
+               break;
+       case 8192:
+               action_name = X_("JACKLatency8192");
+               break;
+       default:
+               /* XXX can we do anything useful ? */
+               break;
+       }
+
+       if (action_name) {
+
+               action = ActionManager::get_action (X_("JACK"), action_name);
+               
+               if (action) {
+                       Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
+                       ract->set_active ();
+               }
+       }
+}
+
+void
+ARDOUR_UI::engine_halted ()
+{
+       ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
+
+       ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
+       ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
+
+       update_sample_rate (0);
+
+       MessageDialog msg (*editor, 
+                          _("\
+JACK has either been shutdown or it\n\
+disconnected Ardour because Ardour\n\
+was not fast enough. You can save the\n\
+session and/or try to reconnect to JACK ."));

        msg.run ();
 }
 
        msg.run ();
 }
 


@@ -1308,14 +1490,6 @@ ARDOUR_UI::do_engine_start ()
                engine->start();
        }
 
                engine->start();
        }
 

-       catch (AudioEngine::PortRegistrationFailure& err) {
-               engine->stop ();
-               error << _("Unable to create all required ports")
-                     << endmsg;
-               unload_session ();
-               return -1;
-       }
-

        catch (...) {
                engine->stop ();
                error << _("Unable to start the session running")
        catch (...) {
                engine->stop ();
                error << _("Unable to start the session running")


@@ -1337,14 +1511,6 @@ ARDOUR_UI::start_engine ()
                        */
                        session->save_state ("");
                }
                        */
                        session->save_state ("");
                }

-
-               /* there is too much going on, in too many threads, for us to 
-                  end up with a clean session. So wait 1 second after loading,
-                  and fix it up. its ugly, but until i come across a better
-                  solution, its what we have.
-               */
-
-               Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::make_session_clean), 1000);

        }
 
        return FALSE;
        }
 
        return FALSE;


@@ -1353,7 +1519,9 @@ ARDOUR_UI::start_engine ()
 void
 ARDOUR_UI::update_clocks ()
 {
 void
 ARDOUR_UI::update_clocks ()
 {

-        Clock (session->audible_frame()); /* EMIT_SIGNAL */
+       if (!editor || !editor->dragging_playhead()) {
+               Clock (session->audible_frame()); /* EMIT_SIGNAL */
+       }

 }
 
 void
 }
 
 void


@@ -1391,7 +1559,7 @@ ARDOUR_UI::_blink (void *arg)
 void
 ARDOUR_UI::blink ()
 {
 void
 ARDOUR_UI::blink ()
 {

-        Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
+       Blink (blink_on = !blink_on); /* EMIT_SIGNAL */

 }
 
 void
 }
 
 void


@@ -1403,7 +1571,7 @@ ARDOUR_UI::start_blinking ()
 
        if (blink_timeout_tag < 0) {
                blink_on = false;       
 
        if (blink_timeout_tag < 0) {
                blink_on = false;       

-               blink_timeout_tag = gtk_timeout_add (240, _blink, this);
+               blink_timeout_tag = g_timeout_add (240, _blink, this);

        }
 }
 
        }
 }
 


@@ -1411,68 +1579,11 @@ void
 ARDOUR_UI::stop_blinking ()
 {
        if (blink_timeout_tag >= 0) {
 ARDOUR_UI::stop_blinking ()
 {
        if (blink_timeout_tag >= 0) {

-               gtk_timeout_remove (blink_timeout_tag);
+               g_source_remove (blink_timeout_tag);

                blink_timeout_tag = -1;
        }
 }
 
                blink_timeout_tag = -1;
        }
 }
 

-
-void
-ARDOUR_UI::add_diskstream_to_menu (DiskStream& dstream)
-{
-       using namespace Gtk;
-       using namespace Menu_Helpers;
-
-       if (dstream.hidden()) {
-               return;
-       }
-
-       MenuList& items = diskstream_menu->items();
-       items.push_back (MenuElem (dstream.name(), bind (mem_fun(*this, &ARDOUR_UI::diskstream_selected), (gint32) dstream.id())));
-}
-       
-void
-ARDOUR_UI::diskstream_selected (gint32 id)
-{
-       selected_dstream = id;
-       Main::quit ();
-}
-
-gint32
-ARDOUR_UI::select_diskstream (GdkEventButton *ev)
-{
-       using namespace Gtk;
-       using namespace Menu_Helpers;
-
-       if (session == 0) {
-               return -1;
-       }
-
-       diskstream_menu = new Menu();
-       diskstream_menu->set_name ("ArdourContextMenu");
-       using namespace Gtk;
-       using namespace Menu_Helpers;
-
-       MenuList& items = diskstream_menu->items();
-       items.push_back (MenuElem (_("No Stream"), (bind (mem_fun(*this, &ARDOUR_UI::diskstream_selected), -1))));
-
-       session->foreach_diskstream (this, &ARDOUR_UI::add_diskstream_to_menu);
-
-       if (ev) {
-               diskstream_menu->popup (ev->button, ev->time);
-       } else {
-               diskstream_menu->popup (0, 0);
-       }
-
-       selected_dstream = -1;
-
-       Main::run ();
-
-       delete diskstream_menu;
-
-       return selected_dstream;
-}
-

 void
 ARDOUR_UI::name_io_setup (AudioEngine& engine, 
                          string& buf,
 void
 ARDOUR_UI::name_io_setup (AudioEngine& engine, 
                          string& buf,


@@ -1480,7 +1591,7 @@ ARDOUR_UI::name_io_setup (AudioEngine& engine,
                          bool in)
 {
        if (in) {
                          bool in)
 {
        if (in) {

-               if (io.n_inputs() == 0) {
+               if (io.n_inputs().get_total() == 0) {

                        buf = _("none");
                        return;
                }
                        buf = _("none");
                        return;
                }


@@ -1499,7 +1610,7 @@ ARDOUR_UI::name_io_setup (AudioEngine& engine,
 
        } else {
 
 
        } else {
 

-               if (io.n_outputs() == 0) {
+               if (io.n_outputs().get_total() == 0) {

                        buf = _("none");
                        return;
                }
                        buf = _("none");
                        return;
                }


@@ -1518,21 +1629,25 @@ ARDOUR_UI::name_io_setup (AudioEngine& engine,
        }
 }
 
        }
 }
 

+/** Ask the user for the name of a new shapshot and then take it.
+ */

 void
 ARDOUR_UI::snapshot_session ()
 {
        ArdourPrompter prompter (true);
        string snapname;
 void
 ARDOUR_UI::snapshot_session ()
 {
        ArdourPrompter prompter (true);
        string snapname;

-       string now;
+       char timebuf[128];

        time_t n;
        time_t n;

+       struct tm local_time;

 
        time (&n);
 
        time (&n);

-       now = ctime (&n);
-       now = now.substr (0, now.length() - 1);
+       localtime_r (&n, &local_time);
+       strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);

 
        prompter.set_name ("Prompter");
 
        prompter.set_name ("Prompter");

-       prompter.set_prompt (_("Name for snapshot"));
-       prompter.set_initial_text (now);
+       prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+       prompter.set_prompt (_("Name of New Snapshot"));
+       prompter.set_initial_text (timebuf);

        
        switch (prompter.run()) {
        case RESPONSE_ACCEPT:
        
        switch (prompter.run()) {
        case RESPONSE_ACCEPT:


@@ -1599,7 +1714,7 @@ ARDOUR_UI::secondary_clock_value_changed ()
 }
 
 void
 }
 
 void

-ARDOUR_UI::rec_enable_button_blink (bool onoff, DiskStream *dstream, Widget *w)
+ARDOUR_UI::rec_enable_button_blink (bool onoff, AudioDiskstream *dstream, Widget *w)

 {
        if (session && dstream && dstream->record_enabled()) {
 
 {
        if (session && dstream && dstream->record_enabled()) {
 


@@ -1639,18 +1754,18 @@ ARDOUR_UI::transport_rec_enable_blink (bool onoff)
        switch (session->record_status()) {
        case Session::Enabled:
                if (onoff) {
        switch (session->record_status()) {
        case Session::Enabled:
                if (onoff) {

-                       rec_button.set_state (1);
+                       rec_button.set_visual_state (2);

                } else {
                } else {

-                       rec_button.set_state (0);
+                       rec_button.set_visual_state (0);

                }
                break;
 
        case Session::Recording:
                }
                break;
 
        case Session::Recording:

-               rec_button.set_state (2);
+               rec_button.set_visual_state (1);

                break;
 
        default:
                break;
 
        default:

-               rec_button.set_state (0);
+               rec_button.set_visual_state (0);

                break;
        }
 }
                break;
        }
 }


@@ -1663,12 +1778,6 @@ ARDOUR_UI::hide_and_quit (GdkEventAny *ev, ArdourDialog *window)
        return TRUE;
 }
 
        return TRUE;
 }
 

-void
-ARDOUR_UI::start_keyboard_prefix ()
-{
-       keyboard->start_prefix();
-}
-

 void
 ARDOUR_UI::save_template ()
 
 void
 ARDOUR_UI::save_template ()
 


@@ -1679,7 +1788,8 @@ ARDOUR_UI::save_template ()
        prompter.set_name (X_("Prompter"));
        prompter.set_prompt (_("Name for mix template:"));
        prompter.set_initial_text(session->name() + _("-template"));
        prompter.set_name (X_("Prompter"));
        prompter.set_prompt (_("Name for mix template:"));
        prompter.set_initial_text(session->name() + _("-template"));

-       
+       prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+

        switch (prompter.run()) {
        case RESPONSE_ACCEPT:
                prompter.get_result (name);
        switch (prompter.run()) {
        case RESPONSE_ACCEPT:
                prompter.get_result (name);


@@ -1694,89 +1804,227 @@ ARDOUR_UI::save_template ()
        }
 }
 
        }
 }
 

-void
-ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
+bool
+ARDOUR_UI::new_session (std::string predetermined_path)

 {
 {

-       m_new_session_dialog->show_all();
-       m_new_session_dialog->set_transient_for(*editor);
-       m_new_session_dialog->set_name(predetermined_path);
+       string session_name;
+       string session_path;

 
 

-       int response = Gtk::RESPONSE_CANCEL;
+       if (!check_audioengine()) {
+               return false;
+       }
+
+       int response = Gtk::RESPONSE_NONE;
+
+       new_session_dialog->set_modal(true);
+       new_session_dialog->set_name (predetermined_path);
+       new_session_dialog->reset_recent();
+       new_session_dialog->show();
+       new_session_dialog->set_current_page (0);

 
        do {
 
        do {

-               response = m_new_session_dialog->run ();
-       
-               if(response == Gtk::RESPONSE_OK) {
+               response = new_session_dialog->run ();

 
 

-                       _session_is_new = true;
-                       
-                       std::string session_name = m_new_session_dialog->session_name();
-                       std::string session_path = m_new_session_dialog->session_folder();
+               if (!check_audioengine()) {
+                       new_session_dialog->hide ();
+                       return false;
+               }
+               
+               _session_is_new = false;
+
+               if (response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
+
+                       if (!session) {
+                               quit();
+                       }
+                       new_session_dialog->hide ();
+                       return false;
+
+               } else if (response == Gtk::RESPONSE_NONE) {
+
+                       /* Clear was pressed */
+                       new_session_dialog->reset();
+
+               } else if (response == Gtk::RESPONSE_YES) {
+
+                       /* YES  == OPEN, but there's no enum for that */
+
+                       session_name = new_session_dialog->session_name();

                        
                        

-                       /*
-                         XXX This is needed because session constructor wants a 
-                         non-existant path. hopefully this will be fixed at some point.
-                       */
-                       session_path = Glib::build_filename(session_path, session_name);
+                       if (session_name.empty()) {
+                               response = Gtk::RESPONSE_NONE;
+                               continue;
+                       } 
+
+                       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] == '/')) {
+                               load_session (Glib::path_get_dirname (session_name), session_name);
+                       } else {
+                               session_path = new_session_dialog->session_folder();
+                               load_session (session_path, session_name);
+                       }

                        
                        

-                       std::string template_name = m_new_session_dialog->session_template_name();
+               } else if (response == Gtk::RESPONSE_OK) {
+
+                       session_name = new_session_dialog->session_name();

                        
                        

-                       if (m_new_session_dialog->use_session_template()) {
-                               
-                               load_session (session_path, session_name, &template_name);
-                               
-                       } else {
+                       if (new_session_dialog->get_current_page() == 1) {
+                 
+                               /* XXX this is a bit of a hack.. 
+                                  i really want the new sesion dialog to return RESPONSE_YES
+                                  if we're on page 1 (the load page)
+                                  Unfortunately i can't see how atm.. 
+                               */

                                
                                

-                               uint32_t cchns;
-                               uint32_t mchns;
-                               Session::AutoConnectOption iconnect;
-                               Session::AutoConnectOption oconnect;
+                               if (session_name.empty()) {
+                                       response = Gtk::RESPONSE_NONE;
+                                       continue;
+                               } 

                                
                                

-                               if (m_new_session_dialog->create_control_bus()) {
-                                       cchns = (uint32_t) m_new_session_dialog->control_channel_count();
+                               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] == '/')) {
+                                       load_session (Glib::path_get_dirname (session_name), session_name);

                                } else {
                                } else {

-                                       cchns = 0;
+                                       session_path = new_session_dialog->session_folder();
+                                       load_session (session_path, session_name);

                                }
                                }

-                               
-                               if (m_new_session_dialog->create_master_bus()) {
-                                       mchns = (uint32_t) m_new_session_dialog->master_channel_count();
+                       
+                       } else {
+
+                               if (session_name.empty()) {
+                                       response = Gtk::RESPONSE_NONE;
+                                       continue;
+                               } 
+
+                               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] == '/')) {
+
+                                       session_path = Glib::path_get_dirname (session_name);
+                                       session_name = Glib::path_get_basename (session_name);
+

                                } else {
                                } else {

-                                       mchns = 0;
+
+                                       session_path = new_session_dialog->session_folder();
+

                                }
                                
                                }
                                

-                               if (m_new_session_dialog->connect_inputs()) {
-                                       iconnect = Session::AutoConnectPhysical;
-                               } else {
-                                       iconnect = Session::AutoConnectOption (0);
-                               }
+                               //XXX This is needed because session constructor wants a 
+                               //non-existant path. hopefully this will be fixed at some point.

                                
                                

-                               /// @todo some minor tweaks.
+                               session_path = Glib::build_filename (session_path, session_name);
+                                               
+                               if (g_file_test (session_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
+
+                                       Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
+
+                                       MessageDialog msg (str,
+                                                          false,
+                                                          Gtk::MESSAGE_WARNING,
+                                                          Gtk::BUTTONS_YES_NO,
+                                                          true);
+
+
+                                       msg.set_name (X_("CleanupDialog"));
+                                       msg.set_wmclass (X_("existing_session"), "Ardour");
+                                       msg.set_position (Gtk::WIN_POS_MOUSE);
+                                       
+                                       switch (msg.run()) {
+                                       case RESPONSE_YES:
+                                               load_session (session_path, session_name);
+                                               goto done;
+                                               break;
+                                       default:
+                                               response = RESPONSE_NONE;
+                                               new_session_dialog->reset ();
+                                               continue;
+                                       }
+                               }

 
 

-                               if (m_new_session_dialog->connect_outs_to_master()) {
-                                       oconnect = Session::AutoConnectMaster;
-                               } else if (m_new_session_dialog->connect_outs_to_physical()) {
-                                       oconnect = Session::AutoConnectPhysical;
+                               _session_is_new = true;
+
+                               std::string template_name = new_session_dialog->session_template_name();
+                                               
+                               if (new_session_dialog->use_session_template()) {
+                                                       
+                                       load_session (session_path, session_name, &template_name);
+                         

                                } else {
                                } else {

-                                       oconnect = Session::AutoConnectOption (0);
-                               } 
-                               
-                               uint32_t nphysin = (uint32_t) m_new_session_dialog->input_limit_count();
-                               uint32_t nphysout = (uint32_t) m_new_session_dialog->output_limit_count();
-                               
-                               build_session (session_path,
-                                              session_name,
-                                              cchns,
-                                              mchns,
-                                              iconnect,
-                                              oconnect,
-                                              nphysin,
-                                              nphysout, 
-                                              engine->frame_rate() * 60 * 5);
-                       }               
+                                                       
+                                       uint32_t cchns;
+                                       uint32_t mchns;
+                                       AutoConnectOption iconnect;
+                                       AutoConnectOption oconnect;
+                                                       
+                                       if (new_session_dialog->create_control_bus()) {
+                                               cchns = (uint32_t) new_session_dialog->control_channel_count();
+                                       } else {
+                                               cchns = 0;
+                                       }
+                                                       
+                                       if (new_session_dialog->create_master_bus()) {
+                                               mchns = (uint32_t) new_session_dialog->master_channel_count();
+                                       } else {
+                                               mchns = 0;
+                                       }
+                                                       
+                                       if (new_session_dialog->connect_inputs()) {
+                                               iconnect = AutoConnectPhysical;
+                                       } else {
+                                               iconnect = AutoConnectOption (0);
+                                       }
+                                                       
+                                       /// @todo some minor tweaks.
+                                                       
+                                       if (new_session_dialog->connect_outs_to_master()) {
+                                               oconnect = AutoConnectMaster;
+                                       } else if (new_session_dialog->connect_outs_to_physical()) {
+                                               oconnect = AutoConnectPhysical;
+                                       } else {
+                                               oconnect = AutoConnectOption (0);
+                                       } 
+                                                       
+                                       uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
+                                       uint32_t nphysout = (uint32_t) new_session_dialog->output_limit_count();
+                                                       
+                                       if (build_session (session_path,
+                                                          session_name,
+                                                          cchns,
+                                                          mchns,
+                                                          iconnect,
+                                                          oconnect,
+                                                          nphysin,
+                                                          nphysout, 
+                                                          engine->frame_rate() * 60 * 5)) {
+
+                                               response = Gtk::RESPONSE_NONE;
+                                               new_session_dialog->reset ();
+                                               continue;
+                                       }
+                               }
+                       }

                }
                }

+               
+       } while (response == Gtk::RESPONSE_NONE);
+
+  done:
+       show();
+       new_session_dialog->get_window()->set_cursor();
+       new_session_dialog->hide();
+       return true;
+}
+
+void
+ARDOUR_UI::close_session()
+{
+       if (!check_audioengine()) {
+               return;
+       }

 
 

-       } while(response == Gtk::RESPONSE_HELP);
-       m_new_session_dialog->hide_all();
+       unload_session();
+       new_session ();

 }
 
 int
 }
 
 int


@@ -1785,6 +2033,11 @@ ARDOUR_UI::load_session (const string & path, const string & snap_name, string*
        Session *new_session;
        int x;
        session_loaded = false;
        Session *new_session;
        int x;
        session_loaded = false;

+       
+       if (!check_audioengine()) {
+               return -1;
+       }
+

        x = unload_session ();
 
        if (x < 0) {
        x = unload_session ();
 
        if (x < 0) {


@@ -1796,9 +2049,8 @@ ARDOUR_UI::load_session (const string & path, const string & snap_name, string*
        /* if it already exists, we must have write access */
 
        if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
        /* if it already exists, we must have write access */
 
        if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {

-               MessageDialog msg (*editor, _("\
-You do not have write access to this session.\n\
-This prevents the session from being loaded."));
+               MessageDialog msg (*editor, _("You do not have write access to this session.\n"
+                                             "This prevents the session from being loaded."));

                msg.run ();
                return -1;
        }
                msg.run ();
                return -1;
        }


@@ -1815,38 +2067,41 @@ This prevents the session from being loaded."));
 
        connect_to_session (new_session);
 
 
        connect_to_session (new_session);
 

-       //if (engine->running()) {
-       //mixer->show_window();
-       //}
+       Config->set_current_owner (ConfigVariableBase::Interface);
+

        session_loaded = true;
        session_loaded = true;

-       return 0;
-}
+       
+       goto_editor_window ();

 
 

-int
-ARDOUR_UI::make_session_clean ()
-{

        if (session) {
                session->set_clean ();
        }
 
        if (session) {
                session->set_clean ();
        }
 

-       return FALSE;
+       editor->edit_cursor_position (true);
+       return 0;

 }
 
 int
 ARDOUR_UI::build_session (const string & path, const string & snap_name, 
                          uint32_t control_channels,
                          uint32_t master_channels, 
 }
 
 int
 ARDOUR_UI::build_session (const string & path, const string & snap_name, 
                          uint32_t control_channels,
                          uint32_t master_channels, 

-                         Session::AutoConnectOption input_connect,
-                         Session::AutoConnectOption output_connect,
+                         AutoConnectOption input_connect,
+                         AutoConnectOption output_connect,

                          uint32_t nphysin,
                          uint32_t nphysout,
                          uint32_t nphysin,
                          uint32_t nphysout,

-                         jack_nframes_t initial_length)
+                         nframes_t initial_length)

 {
        Session *new_session;
        int x;
 
 {
        Session *new_session;
        int x;
 

+       if (!check_audioengine()) {
+               return -1;
+       }
+

        session_loaded = false;
        session_loaded = false;

+

        x = unload_session ();
        x = unload_session ();

+

        if (x < 0) {
                return -1;
        } else if (x > 0) {
        if (x < 0) {
                return -1;
        } else if (x > 0) {


@@ -1862,15 +2117,13 @@ ARDOUR_UI::build_session (const string & path, const string & snap_name,
 
        catch (...) {
 
 
        catch (...) {
 

-               error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
+               MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
+               msg.run ();

                return -1;
        }
 
        connect_to_session (new_session);
 
                return -1;
        }
 
        connect_to_session (new_session);
 

-       //if (engine->running()) {
-       //mixer->show_window();
-       //}

        session_loaded = true;
        return 0;
 }
        session_loaded = true;
        return 0;
 }


@@ -1880,15 +2133,12 @@ ARDOUR_UI::show ()
 {
        if (editor) {
                editor->show_window ();
 {
        if (editor) {
                editor->show_window ();

-               shown_flag = true;
-       }
+               
+               if (!shown_flag) {
+                       editor->present ();
+               }

 
 

-       if (session && mixer) {
-               // mixer->show_window ();
-       }
-       
-       if (about) {
-               about->present ();
+               shown_flag = true;

        }
 }
 
        }
 }
 


@@ -1897,15 +2147,24 @@ ARDOUR_UI::show_splash ()
 {
        if (about == 0) {
                about = new About();
 {
        if (about == 0) {
                about = new About();

+               about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );

        }
        about->present();
        }
        about->present();

+       flush_pending ();
+}
+
+void
+ARDOUR_UI::about_signal_response(int response)
+{
+       hide_splash();

 }
 
 void
 ARDOUR_UI::hide_splash ()
 {
        if (about) {
 }
 
 void
 ARDOUR_UI::hide_splash ()
 {
        if (about) {

-               // about->hide();
+               about->get_window()->set_cursor ();
+               about->hide();

        }
 }
 
        }
 }
 


@@ -1917,17 +2176,21 @@ ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* l
        removed = rep.paths.size();
 
        if (removed == 0) {
        removed = rep.paths.size();
 
        if (removed == 0) {

-               MessageDialog msg (*editor, X_("cleanupresults"),
-                                  _("\
-No audio files were ready for cleanup\n\n\
-If this seems suprising, check for any existing\n\
-snapshots. These may still include regions that\n\
+               MessageDialog msgd (*editor,
+                                   _("No audio files were ready for cleanup"), 
+                                   true,
+                                   Gtk::MESSAGE_INFO,
+                                   (Gtk::ButtonsType)(Gtk::BUTTONS_OK)  );
+               msgd.set_secondary_text (_("If this seems suprising, \n\
+check for any existing snapshots.\n\
+These may still include regions that\n\

 require some unused files to continue to exist."));
 require some unused files to continue to exist."));

-               msg.run ();
+       
+               msgd.run ();

                return;
        } 
 
                return;
        } 
 

-       ArdourDialog results (_("ardour: cleanup"), true);
+       ArdourDialog results (_("ardour: cleanup"), true, false);

        
        struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
            CleanupResultsModelColumns() { 
        
        struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
            CleanupResultsModelColumns() { 


@@ -1939,34 +2202,45 @@ require some unused files to continue to exist."));
        };
 
        
        };
 
        

-       Glib::RefPtr<Gtk::ListStore> results_model;

        CleanupResultsModelColumns results_columns;
        CleanupResultsModelColumns results_columns;

+       Glib::RefPtr<Gtk::ListStore> results_model;

        Gtk::TreeView results_display;
        
        results_model = ListStore::create (results_columns);
        results_display.set_model (results_model);
        results_display.append_column (list_title, results_columns.visible_name);
        Gtk::TreeView results_display;
        
        results_model = ListStore::create (results_columns);
        results_display.set_model (results_model);
        results_display.append_column (list_title, results_columns.visible_name);

+
+       results_display.set_name ("CleanupResultsList");

        results_display.set_headers_visible (true);
        results_display.set_headers_visible (true);

+       results_display.set_headers_clickable (false);
+       results_display.set_reorderable (false);

 
        Gtk::ScrolledWindow list_scroller;
        Gtk::Label txt;
 
        Gtk::ScrolledWindow list_scroller;
        Gtk::Label txt;

+       Gtk::VBox dvbox;
+       Gtk::HBox dhbox;  // the hbox for the image and text
+       Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
+       Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO,  Gtk::ICON_SIZE_DIALOG));
+
+       dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);

 
        if (rep.space < 1048576.0f) {
                if (removed > 1) {
 
        if (rep.space < 1048576.0f) {
                if (removed > 1) {

-                       txt.set_text (string_compose (msg, removed, _("files"), (float) rep.space / 1024.0f, "kilo"));
+                 txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));

                } else {
                } else {

-                       txt.set_text (string_compose (msg, removed, _("file"), (float) rep.space / 1024.0f, "kilo"));
+                       txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));

                }
        } else {
                if (removed > 1) {
                }
        } else {
                if (removed > 1) {

-                       txt.set_text (string_compose (msg, removed, _("files"), (float) rep.space / 1048576.0f, "mega"));
+                       txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));

                } else {
                } else {

-                       txt.set_text (string_compose (msg, removed, _("file"), (float) rep.space / 1048576.0f, "mega"));
+                       txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));

                }
        }
 
                }
        }
 

-       results.get_vbox()->pack_start (txt, false, false);
-       
+       dhbox.pack_start (*dimage, true, false, 5);
+       dhbox.pack_start (txt, true, false, 5);
+

        for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
                TreeModel::Row row = *(results_model->append());
                row[results_columns.visible_name] = *i;
        for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
                TreeModel::Row row = *(results_model->append());
                row[results_columns.visible_name] = *i;


@@ -1974,14 +2248,22 @@ require some unused files to continue to exist."));
        }
        
        list_scroller.add (results_display);
        }
        
        list_scroller.add (results_display);

-       list_scroller.set_size_request (-1, 250);
+       list_scroller.set_size_request (-1, 150);

        list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
        list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);

-       
-       results.get_vbox()->pack_start (list_scroller, true, true);
-       results.add_button (Stock::OK, RESPONSE_ACCEPT);
+
+       dvbox.pack_start (dhbox, true, false, 5);
+       dvbox.pack_start (list_scroller, true, false, 5);
+       ddhbox.pack_start (dvbox, true, false, 5);
+
+       results.get_vbox()->pack_start (ddhbox, true, false, 5);
+       results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
+       results.set_default_response (RESPONSE_CLOSE);

        results.set_position (Gtk::WIN_POS_MOUSE);
        results.set_position (Gtk::WIN_POS_MOUSE);

+       results.show_all_children ();
+       results.set_resizable (false);

 
        results.run ();
 
        results.run ();

+

 }
 
 void
 }
 
 void


@@ -1992,18 +2274,23 @@ ARDOUR_UI::cleanup ()
                return;
        }
 
                return;
        }
 

-       ArdourDialog checker (_("ardour cleanup"));
-       Gtk::Label label (_("\
-Cleanup is a destructive operation.\n\
+
+       MessageDialog  checker (_("Are you sure you want to cleanup?"),
+                               true,
+                               Gtk::MESSAGE_QUESTION,
+                               (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
+
+       checker.set_secondary_text(_("Cleanup is a destructive operation.\n\

 ALL undo/redo information will be lost if you cleanup.\n\
 ALL undo/redo information will be lost if you cleanup.\n\

-Unused audio files will be moved to a \"dead sounds\" location."));
+After cleanup, unused audio files will be moved to a \
+\"dead sounds\" location."));

        
        

-       checker.get_vbox()->pack_start (label, false, false);
-       checker.add_button (Stock::OK, RESPONSE_ACCEPT);

        checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
        checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);

+       checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
+       checker.set_default_response (RESPONSE_CANCEL);

 
        checker.set_name (_("CleanupDialog"));
 
        checker.set_name (_("CleanupDialog"));

-       checker.set_wmclass (_("ardour_cleanup"), "Ardour");
+       checker.set_wmclass (X_("ardour_cleanup"), "Ardour");

        checker.set_position (Gtk::WIN_POS_MOUSE);
 
        switch (checker.run()) {
        checker.set_position (Gtk::WIN_POS_MOUSE);
 
        switch (checker.run()) {


@@ -2017,18 +2304,31 @@ Unused audio files will be moved to a \"dead sounds\" location."));
 
        editor->prepare_for_cleanup ();
 
 
        editor->prepare_for_cleanup ();
 

+       /* do not allow flush until a session is reloaded */
+
+       Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
+       if (act) {
+               act->set_sensitive (false);
+       }
+

        if (session->cleanup_sources (rep)) {
                return;
        }
 
        if (session->cleanup_sources (rep)) {
                return;
        }
 

+       checker.hide();

        display_cleanup_results (rep, 
                                 _("cleaned files"),
                                 _("\
        display_cleanup_results (rep, 
                                 _("cleaned files"),
                                 _("\

-The following %1 %2 were not in use.\n\
-The next time you flush the wastebasket\n\
-it will release an additional %3 %4bytes\n\
-of disk space"
+The following %1 %2 not in use and \n\
+have been moved to:\n\
+%3. \n\n\
+Flushing the wastebasket will \n\
+release an additional\n\
+%4 %5bytes of disk space.\n"

                                         ));
                                         ));

+
+
+

 }
 
 void
 }
 
 void


@@ -2047,11 +2347,13 @@ ARDOUR_UI::flush_trash ()
 
        display_cleanup_results (rep, 
                                 _("deleted file"),
 
        display_cleanup_results (rep, 
                                 _("deleted file"),

-                                _("The following %1 file%2 were deleted, releasing %3 %4bytes of disk space"));
+                                _("The following %1 %2 deleted from\n\
+%3,\n\
+releasing %4 %5bytes of disk space"));

 }
 
 void
 }
 
 void

-ARDOUR_UI::add_route ()
+ARDOUR_UI::add_route (Gtk::Window* float_window)

 {
        int count;
 
 {
        int count;
 


@@ -2061,7 +2363,9 @@ ARDOUR_UI::add_route ()
 
        if (add_route_dialog == 0) {
                add_route_dialog = new AddRouteDialog;
 
        if (add_route_dialog == 0) {
                add_route_dialog = new AddRouteDialog;

-               editor->ensure_float (*add_route_dialog);
+               if (float_window) {
+                       add_route_dialog->set_transient_for (*float_window);
+               }

        }
 
        if (add_route_dialog->is_visible()) {
        }
 
        if (add_route_dialog->is_visible()) {


@@ -2070,15 +2374,15 @@ ARDOUR_UI::add_route ()
        }
 
        ResponseType r = (ResponseType) add_route_dialog->run ();
        }
 
        ResponseType r = (ResponseType) add_route_dialog->run ();

-       
+

        add_route_dialog->hide();
 
        switch (r) {
        add_route_dialog->hide();
 
        switch (r) {

-       case RESPONSE_ACCEPT:
-               break;
-       default:
-               return;
-               break;
+               case RESPONSE_ACCEPT:
+                       break;
+               default:
+                       return;
+                       break;

        }
 
        if ((count = add_route_dialog->count()) <= 0) {
        }
 
        if ((count = add_route_dialog->count()) <= 0) {


@@ -2090,26 +2394,30 @@ ARDOUR_UI::add_route ()
        string name_template = add_route_dialog->name_template ();
        bool track = add_route_dialog->track ();
 
        string name_template = add_route_dialog->name_template ();
        bool track = add_route_dialog->track ();
 

-       Session::AutoConnectOption oac = session->get_output_auto_connect();
+       AutoConnectOption oac = Config->get_output_auto_connect();

 
 

-       if (oac & Session::AutoConnectMaster) {
-               output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
+       if (oac & AutoConnectMaster) {
+               output_chan = (session->master_out() ? session->master_out()->n_inputs().get(DataType::AUDIO) : input_chan);

        } else {
                output_chan = input_chan;
        }
 
        /* XXX do something with name template */
 
        } else {
                output_chan = input_chan;
        }
 
        /* XXX do something with name template */
 

-       while (count) {
+       if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {

                if (track) {
                if (track) {

-                       session_add_audio_track (input_chan, output_chan, add_route_dialog->mode());
-               } else {
-                       session_add_audio_bus (input_chan, output_chan);
+                       session_add_midi_track(count);
+               } else  {
+                       MessageDialog msg (*editor,
+                                       _("Sorry, MIDI Busses are not supported at this time."));
+                       msg.run ();
+                       //session_add_midi_bus();

                }
                }

-               --count;
-               
-               while (Main::events_pending()) {
-                       Main::iteration ();
+       } else { 
+               if (track) {
+                       session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
+               } else {
+                       session_add_audio_bus (input_chan, output_chan, count);

                }
        }
 }
                }
        }
 }


@@ -2172,33 +2480,21 @@ ARDOUR_UI::halt_on_xrun_message ()
        msg.run ();
 }
 
        msg.run ();
 }
 

-void 
-ARDOUR_UI::delete_sources_in_the_right_thread (list<ARDOUR::Source*>* deletion_list)
-{
-       ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread), deletion_list));
-
-       for (list<Source*>::iterator i = deletion_list->begin(); i != deletion_list->end(); ++i) {
-               delete *i;
-       }
-
-       delete deletion_list;
-}
-

 void
 ARDOUR_UI::disk_overrun_handler ()
 {
 void
 ARDOUR_UI::disk_overrun_handler ()
 {

-       ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+       ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));

 
 

-       if (!have_disk_overrun_displayed) {
-               have_disk_overrun_displayed = true;
-               MessageDialog msg (*editor, X_("diskrate dialog"), _("\
+       if (!have_disk_speed_dialog_displayed) {
+               have_disk_speed_dialog_displayed = true;
+               MessageDialog* msg = new MessageDialog (*editor, _("\

 The disk system on your computer\n\
 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"));
 The disk system on your computer\n\
 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.run ();
-               have_disk_overrun_displayed = false;
+               msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+               msg->show_all ();

        }
 }
 
        }
 }
 


@@ -2207,29 +2503,24 @@ ARDOUR_UI::disk_underrun_handler ()
 {
        ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
 
 {
        ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
 

-       if (!have_disk_underrun_displayed) {
-               have_disk_underrun_displayed = true;
-               MessageDialog msg (*editor,
-                       (_("The disk system on your computer\n\
+       if (!have_disk_speed_dialog_displayed) {
+               have_disk_speed_dialog_displayed = true;
+               MessageDialog* msg = new MessageDialog (*editor,
+                                  _("The disk system on your computer\n\

 was not able to keep up with Ardour.\n\
 \n\
 Specifically, it failed to read data from disk\n\
 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.run ();
-               have_disk_underrun_displayed = false;
+quickly enough to keep up with playback.\n"));
+               msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+               msg->show_all ();

        } 
 }
 
 void
        } 
 }
 
 void

-ARDOUR_UI::disk_underrun_message_gone ()
+ARDOUR_UI::disk_speed_dialog_gone (int ignored_response, MessageDialog* msg)

 {
 {

-       have_disk_underrun_displayed = false;
-}
-
-void
-ARDOUR_UI::disk_overrun_message_gone ()
-{
-       have_disk_underrun_displayed = false;
+       have_disk_speed_dialog_displayed = false;
+       delete msg;

 }
 
 int
 }
 
 int


@@ -2254,15 +2545,12 @@ what you would like to do.\n"));
        
        switch (dialog.run ()) {
        case RESPONSE_ACCEPT:
        
        switch (dialog.run ()) {
        case RESPONSE_ACCEPT:

-               break;
-       default:

                return 1;
                return 1;

+       default:
+               return 0;

        }
        }

-
-       return 0;

 }
        
 }
        

-       

 void
 ARDOUR_UI::disconnect_from_jack ()
 {
 void
 ARDOUR_UI::disconnect_from_jack ()
 {


@@ -2289,13 +2577,6 @@ ARDOUR_UI::reconnect_to_jack ()
        }
 }
 
        }
 }
 

-void
-ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
-{
-       engine->request_buffer_size (nframes);
-       update_sample_rate (0);
-}
-

 int
 ARDOUR_UI::cmdline_new_session (string path)
 {
 int
 ARDOUR_UI::cmdline_new_session (string path)
 {


@@ -2310,8 +2591,245 @@ ARDOUR_UI::cmdline_new_session (string path)
                path = str;
        }
 
                path = str;
        }
 

-       new_session (false, path);
+       new_session (path);

 
        _will_create_new_session_automatically = false; /* done it */
        return FALSE; /* don't call it again */
 }
 
        _will_create_new_session_automatically = false; /* done it */
        return FALSE; /* don't call it again */
 }

+
+void
+ARDOUR_UI::use_config ()
+{
+       Glib::RefPtr<Action> act;
+
+       switch (Config->get_native_file_data_format ()) {
+       case FormatFloat:
+               act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
+               break;
+       case FormatInt24:
+               act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
+               break;
+       }
+
+       if (act) {
+               Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+               ract->set_active ();
+       }       
+
+       switch (Config->get_native_file_header_format ()) {
+       case BWF:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
+               break;
+       case WAVE:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
+               break;
+       case WAVE64:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
+               break;
+       case iXML:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
+               break;
+       case RF64:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
+               break;
+       case CAF:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
+               break;
+       case AIFF:
+               act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
+               break;
+       }
+
+       if (act) {
+               Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+               ract->set_active ();
+       }       
+
+       XMLNode* node = Config->extra_xml (X_("TransportControllables"));
+       if (node) {
+               set_transport_controllable_state (*node);
+       }
+}
+
+void
+ARDOUR_UI::update_transport_clocks (nframes_t pos)
+{
+       primary_clock.set (pos);
+       secondary_clock.set (pos);
+
+       if (big_clock_window) {
+               big_clock.set (pos);
+       }
+}
+
+void
+ARDOUR_UI::record_state_changed ()
+{
+       ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed));
+
+       if (!session || !big_clock_window) {
+               /* why bother - the clock isn't visible */
+               return;
+       }
+
+       switch (session->record_status()) {
+       case Session::Recording:
+               big_clock.set_widget_name ("BigClockRecording");
+               break;
+       default:
+               big_clock.set_widget_name ("BigClockNonRecording");
+               break;
+       }
+}
+
+void
+ARDOUR_UI::set_keybindings_path (string path)
+{
+       keybindings_path = path;
+}
+
+void
+ARDOUR_UI::save_keybindings ()
+{
+       if (can_save_keybindings) {
+               AccelMap::save (keybindings_path);
+       } 
+}
+
+bool
+ARDOUR_UI::first_idle ()
+{
+       if (session) {
+               session->allow_auto_play (true);
+       }
+       can_save_keybindings = true;
+       return false;
+}
+
+void
+ARDOUR_UI::store_clock_modes ()
+{
+       XMLNode* node = new XMLNode(X_("ClockModes"));
+
+       for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
+               node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
+       }
+
+       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)
+{
+       
+}
+
+void
+ARDOUR_UI::TransportControllable::set_value (float val)
+{
+       if (type == ShuttleControl) {
+               double fract;
+
+               if (val == 0.5f) {
+                       fract = 0.0;
+               } else {
+                       if (val < 0.5f) {
+                               fract = -((0.5f - val)/0.5f);
+                       } else {
+                               fract = ((val - 0.5f)/0.5f);
+                       }
+               }
+               
+               ui.set_shuttle_fract (fract);
+               return;
+       }
+
+       if (val < 0.5f) {
+               /* do nothing: these are radio-style actions */
+               return;
+       }
+
+       char *action = 0;
+
+       switch (type) {
+       case Roll:
+               action = X_("Roll");
+               break;
+       case Stop:
+               action = X_("Stop");
+               break;
+       case GotoStart:
+               action = X_("Goto Start");
+               break;
+       case GotoEnd:
+               action = X_("Goto End");
+               break;
+       case AutoLoop:
+               action = X_("Loop");
+               break;
+       case PlaySelection:
+               action = X_("Play Selection");
+               break;
+       case RecordEnable:
+               action = X_("Record");
+               break;
+       default:
+               break;
+       }
+
+       if (action == 0) {
+               return;
+       }
+
+       Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", action);
+
+       if (act) {
+               act->activate ();
+       }
+}
+
+float
+ARDOUR_UI::TransportControllable::get_value (void) const
+{
+       float val = 0.0f;
+       
+       switch (type) {
+       case Roll:
+               break;
+       case Stop:
+               break;
+       case GotoStart:
+               break;
+       case GotoEnd:
+               break;
+       case AutoLoop:
+               break;
+       case PlaySelection:
+               break;
+       case RecordEnable:
+               break;
+       case ShuttleControl:
+               break;
+       default:
+               break;
+       }
+
+       return val;
+}
+
+void
+ARDOUR_UI::TransportControllable::set_id (const string& str)
+{
+       _id = str;
+}
+
+void
+ARDOUR_UI::setup_profile ()
+{
+       if (gdk_screen_width() < 1200) {
+               Profile->set_small_screen ();
+       }
+}