gtk2_ardour/ardour_ui.cc

   1 /*
   2     Copyright (C) 1999-2007 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #define __STDC_FORMAT_MACROS 1
  21 #include <stdint.h>
  22
  23 #include <algorithm>
  24 #include <cmath>
  25 #include <fcntl.h>
  26 #include <signal.h>
  27 #include <unistd.h>
  28 #include <time.h>
  29 #include <cerrno>
  30 #include <fstream>
  31
  32 #include <iostream>
  33
  34 #include <sys/resource.h>
  35
  36 #include <gtkmm/messagedialog.h>
  37 #include <gtkmm/accelmap.h>
  38
  39 #include "pbd/error.h"
  40 #include "pbd/basename.h"
  41 #include "pbd/compose.h"
  42 #include "pbd/failed_constructor.h"
  43 #include "pbd/enumwriter.h"
  44 #include "pbd/memento_command.h"
  45 #include "pbd/file_utils.h"
  46
  47 #include <gtkmm2ext/gtk_ui.h>
  48 #include <gtkmm2ext/utils.h>
  49 #include <gtkmm2ext/click_box.h>
  50 #include <gtkmm2ext/fastmeter.h>
  51 #include <gtkmm2ext/stop_signal.h>
  52 #include <gtkmm2ext/popup.h>
  53 #include <gtkmm2ext/window_title.h>
  54
  55 #include "midi++/manager.h"
  56
  57 #include "ardour/ardour.h"
  58 #include "ardour/profile.h"
  59 #include "ardour/session_directory.h"
  60 #include "ardour/session_route.h"
  61 #include "ardour/session_state_utils.h"
  62 #include "ardour/session_utils.h"
  63 #include "ardour/port.h"
  64 #include "ardour/audioengine.h"
  65 #include "ardour/playlist.h"
  66 #include "ardour/utils.h"
  67 #include "ardour/audio_diskstream.h"
  68 #include "ardour/audiofilesource.h"
  69 #include "ardour/recent_sessions.h"
  70 #include "ardour/port.h"
  71 #include "ardour/audio_track.h"
  72 #include "ardour/midi_track.h"
  73 #include "ardour/filesystem_paths.h"
  74 #include "ardour/filename_extensions.h"
  75
  76 typedef uint64_t microseconds_t;
  77
  78 #include "actions.h"
  79 #include "ardour_ui.h"
  80 #include "public_editor.h"
  81 #include "audio_clock.h"
  82 #include "keyboard.h"
  83 #include "mixer_ui.h"
  84 #include "prompter.h"
  85 #include "opts.h"
  86 #include "add_route_dialog.h"
  87 #include "about.h"
  88 #include "splash.h"
  89 #include "utils.h"
  90 #include "gui_thread.h"
  91 #include "theme_manager.h"
  92 #include "bundle_manager.h"
  93 #include "session_metadata_dialog.h"
  94 #include "gain_meter.h"
  95 #include "route_time_axis.h"
  96 #include "startup.h"
  97 #include "engine_dialog.h"
  98
  99 #include "i18n.h"
 100
 101 using namespace ARDOUR;
 102 using namespace PBD;
 103 using namespace Gtkmm2ext;
 104 using namespace Gtk;
 105 using namespace sigc;
 106
 107 ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
 108 UIConfiguration *ARDOUR_UI::ui_config = 0;
 109
 110 sigc::signal<void,bool> ARDOUR_UI::Blink;
 111 sigc::signal<void>      ARDOUR_UI::RapidScreenUpdate;
 112 sigc::signal<void>      ARDOUR_UI::SuperRapidScreenUpdate;
 113 sigc::signal<void,nframes_t, bool, nframes_t> ARDOUR_UI::Clock;
 114
 115 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
 116
 117         : Gtkmm2ext::UI (X_("Ardour"), argcp, argvp),
 118
 119           primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, false, true),
 120           secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, false, true),
 121           preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true),
 122           postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true),
 123
 124           /* preroll stuff */
 125
 126           preroll_button (_("pre\nroll")),
 127           postroll_button (_("post\nroll")),
 128
 129           /* big clock */
 130
 131           big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
 132
 133           /* transport */
 134
 135           roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll)),
 136           stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop)),
 137           goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart)),
 138           goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd)),
 139           auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop)),
 140           play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection)),
 141           rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable)),
 142           shuttle_controllable (new TransportControllable ("shuttle", *this, TransportControllable::ShuttleControl)),
 143           shuttle_controller_binding_proxy (shuttle_controllable),
 144
 145           roll_button (roll_controllable),
 146           stop_button (stop_controllable),
 147           goto_start_button (goto_start_controllable),
 148           goto_end_button (goto_end_controllable),
 149           auto_loop_button (auto_loop_controllable),
 150           play_selection_button (play_selection_controllable),
 151           rec_button (rec_controllable),
 152
 153           shuttle_units_button (_("% ")),
 154
 155           punch_in_button (_("Punch In")),
 156           punch_out_button (_("Punch Out")),
 157           auto_return_button (_("Auto Return")),
 158           auto_play_button (_("Auto Play")),
 159           auto_input_button (_("Auto Input")),
 160           click_button (_("Click")),
 161           time_master_button (_("time\nmaster")),
 162
 163           auditioning_alert_button (_("AUDITION")),
 164           solo_alert_button (_("SOLO")),
 165           shown_flag (false),
 166           error_log_button (_("Errors"))
 167
 168 {
 169         using namespace Gtk::Menu_Helpers;
 170
 171         Gtkmm2ext::init();
 172
 173
 174 #ifdef TOP_MENUBAR
 175         // _auto_display_errors = false;
 176         /*
 177          * This was commented out as it wasn't defined
 178          * in A3 IIRC.  If this is not needed it should
 179          * be completely removed.
 180          */
 181 #endif
 182
 183         about = 0;
 184         splash = 0;
 185         _startup = 0;
 186
 187         if (theArdourUI == 0) {
 188                 theArdourUI = this;
 189         }
 190
 191         ui_config = new UIConfiguration();
 192         theme_manager = new ThemeManager();
 193
 194         editor = 0;
 195         mixer = 0;
 196         session = 0;
 197         editor = 0;
 198         engine = 0;
 199         _session_is_new = false;
 200         big_clock_window = 0;
 201         session_selector_window = 0;
 202         last_key_press_time = 0;
 203         _will_create_new_session_automatically = false;
 204         add_route_dialog = 0;
 205         route_params = 0;
 206         rc_option_editor = 0;
 207         session_option_editor = 0;
 208         location_ui = 0;
 209         open_session_selector = 0;
 210         have_configure_timeout = false;
 211         have_disk_speed_dialog_displayed = false;
 212         session_loaded = false;
 213         last_speed_displayed = -1.0f;
 214         ignore_dual_punch = false;
 215         _mixer_on_top = false;
 216
 217         roll_button.unset_flags (Gtk::CAN_FOCUS);
 218         stop_button.unset_flags (Gtk::CAN_FOCUS);
 219         goto_start_button.unset_flags (Gtk::CAN_FOCUS);
 220         goto_end_button.unset_flags (Gtk::CAN_FOCUS);
 221         auto_loop_button.unset_flags (Gtk::CAN_FOCUS);
 222         play_selection_button.unset_flags (Gtk::CAN_FOCUS);
 223         rec_button.unset_flags (Gtk::CAN_FOCUS);
 224
 225         last_configure_time= 0;
 226
 227         shuttle_grabbed = false;
 228         shuttle_fract = 0.0;
 229         shuttle_max_speed = 8.0f;
 230
 231         shuttle_style_menu = 0;
 232         shuttle_unit_menu = 0;
 233
 234         // We do not have jack linked in yet so;
 235
 236         last_shuttle_request = last_peak_grab = 0; //  get_microseconds();
 237
 238         ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
 239         ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
 240
 241         /* handle dialog requests */
 242
 243         ARDOUR::Session::Dialog.connect (mem_fun(*this, &ARDOUR_UI::session_dialog));
 244
 245         /* handle pending state with a dialog */
 246
 247         ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
 248
 249         /* handle sr mismatch with a dialog */
 250
 251         ARDOUR::Session::AskAboutSampleRateMismatch.connect (mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
 252
 253         /* lets get this party started */
 254
 255         try {
 256                 if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) {
 257                         throw failed_constructor ();
 258                 }
 259
 260                 setup_gtk_ardour_enums ();
 261                 setup_profile ();
 262
 263                 GainMeter::setup_slider_pix ();
 264                 RouteTimeAxisView::setup_slider_pix ();
 265
 266         } catch (failed_constructor& err) {
 267                 error << _("could not initialize Ardour.") << endmsg;
 268                 // pass it on up
 269                 throw;
 270         }
 271
 272         /* we like keyboards */
 273
 274         keyboard = new Keyboard;
 275
 276         reset_dpi();
 277
 278         starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
 279         stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
 280
 281         platform_setup ();
 282 }
 283
 284 /** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
 285 bool
 286 ARDOUR_UI::run_startup (bool should_be_new)
 287 {
 288         if (_startup == 0) {
 289                 _startup = new ArdourStartup ();
 290         }
 291
 292         _startup->set_new_only (should_be_new);
 293         _startup->present ();
 294
 295         main().run();
 296
 297         /* we don't return here until the startup assistant is finished */
 298
 299         _startup->hide ();
 300
 301         return _startup->applying ();
 302 }
 303
 304 int
 305 ARDOUR_UI::create_engine ()
 306 {
 307         // this gets called every time by new_session()
 308
 309         if (engine) {
 310                 return 0;
 311         }
 312
 313         loading_message (_("Starting audio engine"));
 314
 315         try {
 316                 engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
 317
 318         } catch (...) {
 319
 320                 return -1;
 321         }
 322
 323         engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped));
 324         engine->Running.connect (mem_fun(*this, &ARDOUR_UI::engine_running));
 325         engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
 326         engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
 327
 328         post_engine ();
 329
 330         return 0;
 331 }
 332
 333 void
 334 ARDOUR_UI::post_engine ()
 335 {
 336         /* Things to be done once we create the AudioEngine
 337          */
 338
 339         MIDI::Manager::instance()->set_api_data (engine->jack());
 340         setup_midi ();
 341
 342         ARDOUR::init_post_engine ();
 343
 344         ActionManager::init ();
 345         _tooltips.enable();
 346
 347         if (setup_windows ()) {
 348                 throw failed_constructor ();
 349         }
 350
 351         check_memory_locking();
 352
 353         /* this is the first point at which all the keybindings are available */
 354
 355         if (ARDOUR_COMMAND_LINE::show_key_actions) {
 356                 vector<string> names;
 357                 vector<string> paths;
 358                 vector<string> keys;
 359                 vector<AccelKey> bindings;
 360
 361                 ActionManager::get_all_actions (names, paths, keys, bindings);
 362
 363                 vector<string>::iterator n;
 364                 vector<string>::iterator k;
 365                 for (n = names.begin(), k = keys.begin(); n != names.end(); ++n, ++k) {
 366                         cerr << "Action: " << (*n) << " bound to " << (*k) << endl;
 367                 }
 368
 369                 exit (0);
 370         }
 371
 372         blink_timeout_tag = -1;
 373
 374         /* this being a GUI and all, we want peakfiles */
 375
 376         AudioFileSource::set_build_peakfiles (true);
 377         AudioFileSource::set_build_missing_peakfiles (true);
 378
 379         /* set default clock modes */
 380
 381         if (Profile->get_sae()) {
 382                 primary_clock.set_mode (AudioClock::BBT);
 383                 secondary_clock.set_mode (AudioClock::MinSec);
 384         }  else {
 385                 primary_clock.set_mode (AudioClock::SMPTE);
 386                 secondary_clock.set_mode (AudioClock::BBT);
 387         }
 388
 389         /* start the time-of-day-clock */
 390
 391 #ifndef GTKOSX
 392         /* OS X provides an always visible wallclock, so don't be stupid */
 393         update_wall_clock ();
 394         Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
 395 #endif
 396
 397         update_disk_space ();
 398         update_cpu_load ();
 399         update_sample_rate (engine->frame_rate());
 400
 401         /* now start and maybe save state */
 402
 403         if (do_engine_start () == 0) {
 404                 if (session && _session_is_new) {
 405                         /* we need to retain initial visual
 406                            settings for a new session
 407                         */
 408                         session->save_state ("");
 409                 }
 410         }
 411 }
 412
 413 ARDOUR_UI::~ARDOUR_UI ()
 414 {
 415         save_ardour_state ();
 416
 417         delete keyboard;
 418         delete editor;
 419         delete mixer;
 420         delete add_route_dialog;
 421 }
 422
 423 void
 424 ARDOUR_UI::pop_back_splash ()
 425 {
 426         if (Splash::instance()) {
 427                 // Splash::instance()->pop_back();
 428                 Splash::instance()->hide ();
 429         }
 430 }
 431
 432 gint
 433 ARDOUR_UI::configure_timeout ()
 434 {
 435         if (last_configure_time == 0) {
 436                 /* no configure events yet */
 437                 return TRUE;
 438         }
 439
 440         /* force a gap of 0.5 seconds since the last configure event
 441          */
 442
 443         if (get_microseconds() - last_configure_time < 500000) {
 444                 return TRUE;
 445         } else {
 446                 have_configure_timeout = false;
 447                 save_ardour_state ();
 448                 return FALSE;
 449         }
 450 }
 451
 452 gboolean
 453 ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
 454 {
 455         if (have_configure_timeout) {
 456                 last_configure_time = get_microseconds();
 457         } else {
 458                 Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
 459                 have_configure_timeout = true;
 460         }
 461
 462         return FALSE;
 463 }
 464
 465 void
 466 ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
 467 {
 468         const XMLProperty* prop;
 469
 470         if ((prop = node.property ("roll")) != 0) {
 471                 roll_controllable->set_id (prop->value());
 472         }
 473         if ((prop = node.property ("stop")) != 0) {
 474                 stop_controllable->set_id (prop->value());
 475         }
 476         if ((prop = node.property ("goto-start")) != 0) {
 477                 goto_start_controllable->set_id (prop->value());
 478         }
 479         if ((prop = node.property ("goto-end")) != 0) {
 480                 goto_end_controllable->set_id (prop->value());
 481         }
 482         if ((prop = node.property ("auto-loop")) != 0) {
 483                 auto_loop_controllable->set_id (prop->value());
 484         }
 485         if ((prop = node.property ("play-selection")) != 0) {
 486                 play_selection_controllable->set_id (prop->value());
 487         }
 488         if ((prop = node.property ("rec")) != 0) {
 489                 rec_controllable->set_id (prop->value());
 490         }
 491         if ((prop = node.property ("shuttle")) != 0) {
 492                 shuttle_controllable->set_id (prop->value());
 493         }
 494 }
 495
 496 XMLNode&
 497 ARDOUR_UI::get_transport_controllable_state ()
 498 {
 499         XMLNode* node = new XMLNode(X_("TransportControllables"));
 500         char buf[64];
 501
 502         roll_controllable->id().print (buf, sizeof (buf));
 503         node->add_property (X_("roll"), buf);
 504         stop_controllable->id().print (buf, sizeof (buf));
 505         node->add_property (X_("stop"), buf);
 506         goto_start_controllable->id().print (buf, sizeof (buf));
 507         node->add_property (X_("goto_start"), buf);
 508         goto_end_controllable->id().print (buf, sizeof (buf));
 509         node->add_property (X_("goto_end"), buf);
 510         auto_loop_controllable->id().print (buf, sizeof (buf));
 511         node->add_property (X_("auto_loop"), buf);
 512         play_selection_controllable->id().print (buf, sizeof (buf));
 513         node->add_property (X_("play_selection"), buf);
 514         rec_controllable->id().print (buf, sizeof (buf));
 515         node->add_property (X_("rec"), buf);
 516         shuttle_controllable->id().print (buf, sizeof (buf));
 517         node->add_property (X_("shuttle"), buf);
 518
 519         return *node;
 520 }
 521
 522 void
 523 ARDOUR_UI::save_ardour_state ()
 524 {
 525         if (!keyboard || !mixer || !editor) {
 526                 return;
 527         }
 528
 529         /* XXX this is all a bit dubious. add_extra_xml() uses
 530            a different lifetime model from add_instant_xml().
 531         */
 532
 533         XMLNode* node = new XMLNode (keyboard->get_state());
 534         Config->add_extra_xml (*node);
 535         Config->add_extra_xml (get_transport_controllable_state());
 536         if (_startup && _startup->engine_control() && _startup->engine_control()->was_used()) {
 537                 Config->add_extra_xml (_startup->engine_control()->get_state());
 538         }
 539         Config->save_state();
 540         ui_config->save_state ();
 541
 542         XMLNode enode(static_cast<Stateful*>(editor)->get_state());
 543         XMLNode mnode(mixer->get_state());
 544
 545         if (session) {
 546                 session->add_instant_xml (enode);
 547                 session->add_instant_xml (mnode);
 548         } else {
 549                 Config->add_instant_xml (enode);
 550                 Config->add_instant_xml (mnode);
 551         }
 552
 553         Keyboard::save_keybindings ();
 554 }
 555
 556 gint
 557 ARDOUR_UI::autosave_session ()
 558 {
 559         if (g_main_depth() > 1) {
 560                 /* inside a recursive main loop,
 561                    give up because we may not be able to
 562                    take a lock.
 563                 */
 564                 return 1;
 565         }
 566
 567         if (!Config->get_periodic_safety_backups()) {
 568                 return 1;
 569         }
 570
 571         if (session) {
 572                 session->maybe_write_autosave();
 573         }
 574
 575         return 1;
 576 }
 577
 578 void
 579 ARDOUR_UI::update_autosave ()
 580 {
 581         ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
 582
 583         if (session && session->dirty()) {
 584                 if (_autosave_connection.connected()) {
 585                         _autosave_connection.disconnect();
 586                 }
 587
 588                 _autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session),
 589                                 Config->get_periodic_safety_backup_interval() * 1000);
 590
 591         } else {
 592                 if (_autosave_connection.connected()) {
 593                         _autosave_connection.disconnect();
 594                 }
 595         }
 596 }
 597
 598 void
 599 ARDOUR_UI::backend_audio_error (bool we_set_params, Gtk::Window* toplevel)
 600 {
 601         string title;
 602         if (we_set_params) {
 603                 title = _("Ardour could not start JACK");
 604         } else {
 605                 title = _("Ardour could not connect to JACK.");
 606         }
 607
 608         MessageDialog win (title,
 609                            false,
 610                            Gtk::MESSAGE_INFO,
 611                            Gtk::BUTTONS_NONE);
 612
 613         if (we_set_params) {
 614                 win.set_secondary_text(_("There are several possible reasons:\n\
 615 \n\
 616 1) You requested audio parameters that are not supported..\n\
 617 2) JACK is running as another user.\n\
 618 \n\
 619 Please consider the possibilities, and perhaps try different parameters."));
 620         } else {
 621                 win.set_secondary_text(_("There are several possible reasons:\n\
 622 \n\
 623 1) JACK is not running.\n\
 624 2) JACK is running as another user, perhaps root.\n\
 625 3) There is already another client called \"ardour\".\n\
 626 \n\
 627 Please consider the possibilities, and perhaps (re)start JACK."));
 628         }
 629
 630         if (toplevel) {
 631                 win.set_transient_for (*toplevel);
 632         }
 633
 634         if (we_set_params) {
 635                 win.add_button (Stock::OK, RESPONSE_CLOSE);
 636         } else {
 637                 win.add_button (Stock::QUIT, RESPONSE_CLOSE);
 638         }
 639
 640         win.set_default_response (RESPONSE_CLOSE);
 641
 642         win.show_all ();
 643         win.set_position (Gtk::WIN_POS_CENTER);
 644         pop_back_splash ();
 645
 646         /* we just don't care about the result, but we want to block */
 647
 648         win.run ();
 649 }
 650
 651 void
 652 ARDOUR_UI::startup ()
 653 {
 654         XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
 655
 656         if (audio_setup && _startup && _startup->engine_control()) {
 657                 _startup->engine_control()->set_state (*audio_setup);
 658         }
 659
 660         if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session)) {
 661                 exit (1);
 662         }
 663
 664         use_config ();
 665
 666         goto_editor_window ();
 667
 668         BootMessage (_("Ardour is ready for use"));
 669         show ();
 670 }
 671
 672 void
 673 ARDOUR_UI::no_memory_warning ()
 674 {
 675         XMLNode node (X_("no-memory-warning"));
 676         Config->add_instant_xml (node);
 677 }
 678
 679 void
 680 ARDOUR_UI::check_memory_locking ()
 681 {
 682 #ifdef __APPLE__
 683         /* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
 684         return;
 685 #else // !__APPLE__
 686
 687         XMLNode* memory_warning_node = Config->instant_xml (X_("no-memory-warning"));
 688
 689         if (engine->is_realtime() && memory_warning_node == 0) {
 690
 691                 struct rlimit limits;
 692                 int64_t ram;
 693                 long pages, page_size;
 694
 695                 if ((page_size = sysconf (_SC_PAGESIZE)) < 0 ||(pages = sysconf (_SC_PHYS_PAGES)) < 0) {
 696                         ram = 0;
 697                 } else {
 698                         ram = (int64_t) pages * (int64_t) page_size;
 699                 }
 700
 701                 if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
 702                         return;
 703                 }
 704
 705                 if (limits.rlim_cur != RLIM_INFINITY) {
 706
 707                         if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
 708
 709
 710                                 MessageDialog msg (_("WARNING: Your system has a limit for maximum amount of locked memory. "
 711                                                      "This might cause Ardour to run out of memory before your system "
 712                                                      "runs out of memory. \n\n"
 713                                                      "You can view the memory limit with 'ulimit -l', "
 714                                                      "and it is normally controlled by /etc/security/limits.conf"));
 715
 716                                 VBox* vbox = msg.get_vbox();
 717                                 HBox hbox;
 718                                 CheckButton cb (_("Do not show this window again"));
 719
 720                                 cb.signal_toggled().connect (mem_fun (*this, &ARDOUR_UI::no_memory_warning));
 721
 722                                 hbox.pack_start (cb, true, false);
 723                                 vbox->pack_start (hbox);
 724                                 cb.show();
 725                                 vbox->show();
 726                                 hbox.show ();
 727
 728                                 pop_back_splash ();
 729
 730                                 editor->ensure_float (msg);
 731                                 msg.run ();
 732                         }
 733                 }
 734         }
 735 #endif // !__APPLE__
 736 }
 737
 738
 739 void
 740 ARDOUR_UI::finish()
 741 {
 742         if (session) {
 743
 744                 if (session->transport_rolling()) {
 745                         session->request_stop ();
 746                         usleep (250000);
 747                 }
 748
 749                 if (session->dirty()) {
 750                         switch (ask_about_saving_session(_("quit"))) {
 751                         case -1:
 752                                 return;
 753                                 break;
 754                         case 1:
 755                                 /* use the default name */
 756                                 if (save_state_canfail ("")) {
 757                                         /* failed - don't quit */
 758                                         MessageDialog msg (*editor,
 759                                                            _("\
 760 Ardour was unable to save your session.\n\n\
 761 If you still wish to quit, please use the\n\n\
 762 \"Just quit\" option."));
 763                                         pop_back_splash();
 764                                         msg.run ();
 765                                         return;
 766                                 }
 767                                 break;
 768                         case 0:
 769                                 break;
 770                         }
 771                 }
 772
 773                 session->set_deletion_in_progress ();
 774         }
 775
 776         ArdourDialog::close_all_dialogs ();
 777         engine->stop (true);
 778         save_ardour_state ();
 779         quit ();
 780 }
 781
 782 int
 783 ARDOUR_UI::ask_about_saving_session (const string & what)
 784 {
 785         ArdourDialog window (_("ardour: save session?"));
 786         Gtk::HBox dhbox;  // the hbox for the image and text
 787         Gtk::Label  prompt_label;
 788         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING,  Gtk::ICON_SIZE_DIALOG));
 789
 790         string msg;
 791
 792         msg = string_compose(_("Don't %1"), what);
 793         window.add_button (msg, RESPONSE_REJECT);
 794         msg = string_compose(_("Just %1"), what);
 795         window.add_button (msg, RESPONSE_APPLY);
 796         msg = string_compose(_("Save and %1"), what);
 797         window.add_button (msg, RESPONSE_ACCEPT);
 798
 799         window.set_default_response (RESPONSE_ACCEPT);
 800
 801         Gtk::Button noquit_button (msg);
 802         noquit_button.set_name ("EditorGTKButton");
 803
 804         string prompt;
 805         string type;
 806
 807         if (session->snap_name() == session->name()) {
 808                 type = _("session");
 809         } else {
 810                 type = _("snapshot");
 811         }
 812         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?"),
 813                          type, session->snap_name());
 814
 815         prompt_label.set_text (prompt);
 816         prompt_label.set_name (X_("PrompterLabel"));
 817         prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
 818
 819         dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP);
 820         dhbox.set_homogeneous (false);
 821         dhbox.pack_start (*dimage, false, false, 5);
 822         dhbox.pack_start (prompt_label, true, false, 5);
 823         window.get_vbox()->pack_start (dhbox);
 824
 825         window.set_name (_("Prompter"));
 826         window.set_position (Gtk::WIN_POS_MOUSE);
 827         window.set_modal (true);
 828         window.set_resizable (false);
 829
 830         dhbox.show();
 831         prompt_label.show();
 832         dimage->show();
 833         window.show();
 834         window.set_keep_above (true);
 835         window.present ();
 836
 837         ResponseType r = (ResponseType) window.run();
 838
 839         window.hide ();
 840
 841         switch (r) {
 842         case RESPONSE_ACCEPT: // save and get out of here
 843                 return 1;
 844         case RESPONSE_APPLY:  // get out of here
 845                 return 0;
 846         default:
 847                 break;
 848         }
 849
 850         return -1;
 851 }
 852
 853 gint
 854 ARDOUR_UI::every_second ()
 855 {
 856         update_cpu_load ();
 857         update_buffer_load ();
 858         update_disk_space ();
 859         return TRUE;
 860 }
 861
 862 gint
 863 ARDOUR_UI::every_point_one_seconds ()
 864 {
 865         update_speed_display ();
 866         RapidScreenUpdate(); /* EMIT_SIGNAL */
 867         return TRUE;
 868 }
 869
 870 gint
 871 ARDOUR_UI::every_point_zero_one_seconds ()
 872 {
 873         // august 2007: actual update frequency: 40Hz, not 100Hz
 874
 875         SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
 876         return TRUE;
 877 }
 878
 879 void
 880 ARDOUR_UI::update_sample_rate (nframes_t ignored)
 881 {
 882         char buf[32];
 883
 884         ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::update_sample_rate), ignored));
 885
 886         if (!engine->connected()) {
 887
 888                 snprintf (buf, sizeof (buf), _("disconnected"));
 889
 890         } else {
 891
 892                 nframes_t rate = engine->frame_rate();
 893
 894                 if (fmod (rate, 1000.0) != 0.0) {
 895                         snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"),
 896                                   (float) rate/1000.0f,
 897                                   (engine->frames_per_cycle() / (float) rate) * 1000.0f);
 898                 } else {
 899                         snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"),
 900                                   rate/1000,
 901                                   (engine->frames_per_cycle() / (float) rate) * 1000.0f);
 902                 }
 903         }
 904
 905         sample_rate_label.set_text (buf);
 906 }
 907
 908 void
 909 ARDOUR_UI::update_cpu_load ()
 910 {
 911         char buf[32];
 912         snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load());
 913         cpu_load_label.set_text (buf);
 914 }
 915
 916 void
 917 ARDOUR_UI::update_buffer_load ()
 918 {
 919         char buf[64];
 920         uint32_t c, p;
 921
 922         if (session) {
 923                 c = session->capture_load ();
 924                 p = session->playback_load ();
 925
 926                 push_buffer_stats (c, p);
 927
 928                 snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
 929                           session->playback_load(), session->capture_load());
 930                 buffer_load_label.set_text (buf);
 931         } else {
 932                 buffer_load_label.set_text ("");
 933         }
 934 }
 935
 936 void
 937 ARDOUR_UI::count_recenabled_streams (Route& route)
 938 {
 939         Track* track = dynamic_cast<Track*>(&route);
 940         if (track && track->diskstream()->record_enabled()) {
 941                 rec_enabled_streams += track->n_inputs().n_total();
 942         }
 943 }
 944
 945 void
 946 ARDOUR_UI::update_disk_space()
 947 {
 948         if (session == 0) {
 949                 return;
 950         }
 951
 952         nframes_t frames = session->available_capture_duration();
 953         char buf[64];
 954         nframes_t fr = session->frame_rate();
 955
 956         if (frames == max_frames) {
 957                 strcpy (buf, _("Disk: 24hrs+"));
 958         } else {
 959                 rec_enabled_streams = 0;
 960                 session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
 961
 962                 if (rec_enabled_streams) {
 963                         frames /= rec_enabled_streams;
 964                 }
 965
 966                 int hrs;
 967                 int mins;
 968                 int secs;
 969
 970                 hrs  = frames / (fr * 3600);
 971                 frames -= hrs * fr * 3600;
 972                 mins = frames / (fr * 60);
 973                 frames -= mins * fr * 60;
 974                 secs = frames / fr;
 975
 976                 snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);
 977         }
 978
 979         disk_space_label.set_text (buf);
 980
 981         // An attempt to make the disk space label flash red when space has run out.
 982
 983         if (frames < fr * 60 * 5) {
 984         /*      disk_space_box.style ("disk_space_label_empty"); */
 985         } else {
 986         /*      disk_space_box.style ("disk_space_label"); */
 987         }
 988
 989 }
 990
 991 gint
 992 ARDOUR_UI::update_wall_clock ()
 993 {
 994         time_t now;
 995         struct tm *tm_now;
 996         char buf[16];
 997
 998         time (&now);
 999         tm_now = localtime (&now);
1000
1001         sprintf (buf, "%02d:%02d", tm_now->tm_hour, tm_now->tm_min);
1002         wall_clock_label.set_text (buf);
1003
1004         return TRUE;
1005 }
1006
1007 gint
1008 ARDOUR_UI::session_menu (GdkEventButton */*ev*/)
1009 {
1010         session_popup_menu->popup (0, 0);
1011         return TRUE;
1012 }
1013
1014 void
1015 ARDOUR_UI::redisplay_recent_sessions ()
1016 {
1017         std::vector<sys::path> session_directories;
1018         RecentSessionsSorter cmp;
1019
1020         recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
1021         recent_session_model->clear ();
1022
1023         ARDOUR::RecentSessions rs;
1024         ARDOUR::read_recent_sessions (rs);
1025
1026         if (rs.empty()) {
1027                 recent_session_display.set_model (recent_session_model);
1028                 return;
1029         }
1030         //
1031         // sort them alphabetically
1032         sort (rs.begin(), rs.end(), cmp);
1033
1034         for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
1035                 session_directories.push_back ((*i).second);
1036         }
1037
1038         for (vector<sys::path>::const_iterator i = session_directories.begin();
1039                         i != session_directories.end(); ++i)
1040         {
1041                 std::vector<sys::path> state_file_paths;
1042
1043                 // now get available states for this session
1044
1045                 get_state_files_in_directory (*i, state_file_paths);
1046
1047                 vector<string*>* states;
1048                 vector<const gchar*> item;
1049                 string fullpath = (*i).to_string();
1050
1051                 /* remove any trailing / */
1052
1053                 if (fullpath[fullpath.length()-1] == '/') {
1054                         fullpath = fullpath.substr (0, fullpath.length()-1);
1055                 }
1056
1057                 /* check whether session still exists */
1058                 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
1059                         /* session doesn't exist */
1060                         cerr << "skipping non-existent session " << fullpath << endl;
1061                         continue;
1062                 }
1063
1064                 /* now get available states for this session */
1065
1066                 if ((states = Session::possible_states (fullpath)) == 0) {
1067                         /* no state file? */
1068                         continue;
1069                 }
1070
1071                 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
1072
1073                 Gtk::TreeModel::Row row = *(recent_session_model->append());
1074
1075                 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
1076                 row[recent_session_columns.fullpath] = fullpath;
1077
1078                 if (state_file_names.size() > 1) {
1079
1080                         // add the children
1081
1082                         for (std::vector<std::string>::iterator i2 = state_file_names.begin();
1083                                         i2 != state_file_names.end(); ++i2)
1084                         {
1085
1086                                 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
1087
1088                                 child_row[recent_session_columns.visible_name] = *i2;
1089                                 child_row[recent_session_columns.fullpath] = fullpath;
1090                         }
1091                 }
1092         }
1093
1094         recent_session_display.set_model (recent_session_model);
1095 }
1096
1097 void
1098 ARDOUR_UI::build_session_selector ()
1099 {
1100         session_selector_window = new ArdourDialog (_("Recent Sessions"));
1101
1102         Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
1103
1104         session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
1105         session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
1106         session_selector_window->set_default_response (RESPONSE_ACCEPT);
1107         recent_session_model = TreeStore::create (recent_session_columns);
1108         recent_session_display.set_model (recent_session_model);
1109         recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1110         recent_session_display.set_headers_visible (false);
1111         recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1112         recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
1113
1114         scroller->add (recent_session_display);
1115         scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1116
1117         session_selector_window->set_name ("SessionSelectorWindow");
1118         session_selector_window->set_size_request (200, 400);
1119         session_selector_window->get_vbox()->pack_start (*scroller);
1120
1121         recent_session_display.show();
1122         scroller->show();
1123         //session_selector_window->get_vbox()->show();
1124 }
1125
1126 void
1127 ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColumn* /*col*/)
1128 {
1129         session_selector_window->response (RESPONSE_ACCEPT);
1130 }
1131
1132 void
1133 ARDOUR_UI::open_recent_session ()
1134 {
1135         bool can_return = (session != 0);
1136
1137         if (session_selector_window == 0) {
1138                 build_session_selector ();
1139         }
1140
1141         redisplay_recent_sessions ();
1142
1143         while (true) {
1144
1145                 session_selector_window->set_position (WIN_POS_MOUSE);
1146
1147                 ResponseType r = (ResponseType) session_selector_window->run ();
1148
1149                 switch (r) {
1150                 case RESPONSE_ACCEPT:
1151                         break;
1152                 default:
1153                         if (can_return) {
1154                                 session_selector_window->hide();
1155                                 return;
1156                         } else {
1157                                 exit (1);
1158                         }
1159                 }
1160
1161                 if (recent_session_display.get_selection()->count_selected_rows() == 0) {
1162                         continue;
1163                 }
1164
1165                 session_selector_window->hide();
1166
1167                 Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
1168
1169                 if (i == recent_session_model->children().end()) {
1170                         return;
1171                 }
1172
1173                 Glib::ustring path = (*i)[recent_session_columns.fullpath];
1174                 Glib::ustring state = (*i)[recent_session_columns.visible_name];
1175
1176                 _session_is_new = false;
1177
1178                 if (load_session (path, state) == 0) {
1179                         break;
1180                 }
1181
1182                 can_return = false;
1183         }
1184 }
1185
1186 bool
1187 ARDOUR_UI::check_audioengine ()
1188 {
1189         if (engine) {
1190                 if (!engine->connected()) {
1191                         MessageDialog msg (_("Ardour is not connected to JACK\n"
1192                                              "You cannot open or close sessions in this condition"));
1193                         pop_back_splash ();
1194                         msg.run ();
1195                         return false;
1196                 }
1197                 return true;
1198         } else {
1199                 return false;
1200         }
1201 }
1202
1203 void
1204 ARDOUR_UI::open_session ()
1205 {
1206         if (!check_audioengine()) {
1207                 return;
1208
1209         }
1210
1211         /* popup selector window */
1212
1213         if (open_session_selector == 0) {
1214
1215                 /* ardour sessions are folders */
1216
1217                 open_session_selector = new Gtk::FileChooserDialog (_("Open Session"), FILE_CHOOSER_ACTION_OPEN);
1218                 open_session_selector->add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1219                 open_session_selector->add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
1220                 open_session_selector->set_default_response(Gtk::RESPONSE_ACCEPT);
1221
1222                 FileFilter session_filter;
1223                 session_filter.add_pattern ("*.ardour");
1224                 session_filter.set_name (_("Ardour sessions"));
1225                 open_session_selector->add_filter (session_filter);
1226                 open_session_selector->set_filter (session_filter);
1227         }
1228
1229         int response = open_session_selector->run();
1230         open_session_selector->hide ();
1231
1232         switch (response) {
1233         case RESPONSE_ACCEPT:
1234                 break;
1235         default:
1236                 open_session_selector->hide();
1237                 return;
1238         }
1239
1240         open_session_selector->hide();
1241         string session_path = open_session_selector->get_filename();
1242         string path, name;
1243         bool isnew;
1244
1245         if (session_path.length() > 0) {
1246                 if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
1247                         _session_is_new = isnew;
1248                         load_session (path, name);
1249                 }
1250         }
1251 }
1252
1253
1254 void
1255 ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many)
1256 {
1257         list<boost::shared_ptr<MidiTrack> > tracks;
1258
1259         if (session == 0) {
1260                 warning << _("You cannot add a track without a session already loaded.") << endmsg;
1261                 return;
1262         }
1263
1264         try {
1265                 if (disk) {
1266
1267                         tracks = session->new_midi_track (ARDOUR::Normal, route_group, how_many);
1268
1269                         if (tracks.size() != how_many) {
1270                                 if (how_many == 1) {
1271                                         error << _("could not create a new midi track") << endmsg;
1272                                 } else {
1273                                         error << string_compose (_("could not create %1 new midi tracks"), how_many) << endmsg;
1274                                 }
1275                         }
1276                 } /*else {
1277                         if ((route = session->new_midi_route ()) == 0) {
1278                                 error << _("could not create new midi bus") << endmsg;
1279                         }
1280                 }*/
1281         }
1282
1283         catch (...) {
1284                 MessageDialog msg (*editor,
1285                                    _("There are insufficient JACK ports available\n\
1286 to create a new track or bus.\n\
1287 You should save Ardour, exit and\n\
1288 restart JACK with more ports."));
1289                 msg.run ();
1290         }
1291 }
1292
1293
1294 void
1295 ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
1296 {
1297         list<boost::shared_ptr<AudioTrack> > tracks;
1298         RouteList routes;
1299
1300         if (session == 0) {
1301                 warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
1302                 return;
1303         }
1304
1305         try {
1306                 if (track) {
1307                         tracks = session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
1308
1309                         if (tracks.size() != how_many) {
1310                                 if (how_many == 1) {
1311                                         error << _("could not create a new audio track") << endmsg;
1312                                 } else {
1313                                         error << string_compose (_("could only create %1 of %2 new audio %3"),
1314                                                                  tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
1315                                 }
1316                         }
1317
1318                 } else {
1319
1320                         routes = session->new_audio_route (input_channels, output_channels, route_group, how_many);
1321
1322                         if (routes.size() != how_many) {
1323                                 if (how_many == 1) {
1324                                         error << _("could not create a new audio track") << endmsg;
1325                                 } else {
1326                                         error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
1327                                 }
1328                         }
1329                 }
1330
1331 #if CONTROLOUTS
1332                 if (need_control_room_outs) {
1333                         pan_t pans[2];
1334
1335                         pans[0] = 0.5;
1336                         pans[1] = 0.5;
1337
1338                         route->set_stereo_control_outs (control_lr_channels);
1339                         route->control_outs()->set_stereo_pan (pans, this);
1340                 }
1341 #endif /* CONTROLOUTS */
1342         }
1343
1344         catch (...) {
1345                 MessageDialog msg (*editor,
1346                                    _("There are insufficient JACK ports available\n\
1347 to create a new track or bus.\n\
1348 You should save Ardour, exit and\n\
1349 restart JACK with more ports."));
1350                 pop_back_splash ();
1351                 msg.run ();
1352         }
1353 }
1354
1355 void
1356 ARDOUR_UI::do_transport_locate (nframes_t new_position)
1357 {
1358         nframes_t _preroll = 0;
1359
1360         if (session) {
1361                 // XXX CONFIG_CHANGE FIX - requires AnyTime handling
1362                 // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
1363
1364                 if (new_position > _preroll) {
1365                         new_position -= _preroll;
1366                 } else {
1367                         new_position = 0;
1368                 }
1369
1370                 session->request_locate (new_position);
1371         }
1372 }
1373
1374 void
1375 ARDOUR_UI::transport_goto_start ()
1376 {
1377         if (session) {
1378                 session->goto_start();
1379
1380
1381                 /* force displayed area in editor to start no matter
1382                    what "follow playhead" setting is.
1383                 */
1384
1385                 if (editor) {
1386                         editor->reset_x_origin (session->current_start_frame());
1387                 }
1388         }
1389 }
1390
1391 void
1392 ARDOUR_UI::transport_goto_zero ()
1393 {
1394         if (session) {
1395                 session->request_locate (0);
1396
1397
1398                 /* force displayed area in editor to start no matter
1399                    what "follow playhead" setting is.
1400                 */
1401
1402                 if (editor) {
1403                         editor->reset_x_origin (0);
1404                 }
1405         }
1406 }
1407
1408 void
1409 ARDOUR_UI::transport_goto_wallclock ()
1410 {
1411         if (session && editor) {
1412
1413                 time_t now;
1414                 struct tm tmnow;
1415                 nframes64_t frames;
1416
1417                 time (&now);
1418                 localtime_r (&now, &tmnow);
1419
1420                 frames = tmnow.tm_hour * (60 * 60 * session->frame_rate());
1421                 frames += tmnow.tm_min * (60 * session->frame_rate());
1422                 frames += tmnow.tm_sec * session->frame_rate();
1423
1424                 session->request_locate (frames);
1425
1426                 /* force displayed area in editor to start no matter
1427                    what "follow playhead" setting is.
1428                 */
1429
1430                 if (editor) {
1431                         editor->reset_x_origin (frames - (editor->current_page_frames()/2));
1432                 }
1433         }
1434 }
1435
1436 void
1437 ARDOUR_UI::transport_goto_end ()
1438 {
1439         if (session) {
1440                 nframes_t frame = session->current_end_frame();
1441                 session->request_locate (frame);
1442
1443                 /* force displayed area in editor to start no matter
1444                    what "follow playhead" setting is.
1445                 */
1446
1447                 if (editor) {
1448                         editor->reset_x_origin (frame);
1449                 }
1450         }
1451 }
1452
1453 void
1454 ARDOUR_UI::transport_stop ()
1455 {
1456         if (!session) {
1457                 return;
1458         }
1459
1460         if (session->is_auditioning()) {
1461                 session->cancel_audition ();
1462                 return;
1463         }
1464
1465         if (session->get_play_loop ()) {
1466                 session->request_play_loop (false);
1467         }
1468
1469         session->request_stop ();
1470 }
1471
1472 void
1473 ARDOUR_UI::transport_stop_and_forget_capture ()
1474 {
1475         if (session) {
1476                 session->request_stop (true);
1477         }
1478 }
1479
1480 void
1481 ARDOUR_UI::remove_last_capture()
1482 {
1483         if (editor) {
1484                 editor->remove_last_capture();
1485         }
1486 }
1487
1488 void
1489 ARDOUR_UI::transport_record (bool roll)
1490 {
1491
1492         if (session) {
1493                 switch (session->record_status()) {
1494                 case Session::Disabled:
1495                         if (session->ntracks() == 0) {
1496                                 MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
1497                                 msg.run ();
1498                                 return;
1499                         }
1500                         session->maybe_enable_record ();
1501                         if (roll) {
1502                                 transport_roll ();
1503                         }
1504                         break;
1505                 case Session::Recording:
1506                         if (roll) {
1507                                 session->request_stop();
1508                         } else {
1509                                 session->disable_record (false, true);
1510                         }
1511                         break;
1512
1513                 case Session::Enabled:
1514                         session->disable_record (false, true);
1515                 }
1516         }
1517         //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " session->record_status() = " << session->record_status() << endl;
1518 }
1519
1520 void
1521 ARDOUR_UI::transport_roll ()
1522 {
1523         bool rolling;
1524
1525         if (!session) {
1526                 return;
1527         }
1528
1529         rolling = session->transport_rolling ();
1530
1531         //cerr << "ARDOUR_UI::transport_roll () called session->record_status() = " << session->record_status() << endl;
1532
1533         if (session->get_play_loop()) {
1534                 session->request_play_loop (false);
1535                 auto_loop_button.set_visual_state (1);
1536                 roll_button.set_visual_state (1);
1537         } else if (session->get_play_range ()) {
1538                 session->request_play_range (false);
1539                 play_selection_button.set_visual_state (0);
1540         } else if (rolling) {
1541                 session->request_locate (session->last_transport_start(), true);
1542         }
1543
1544         session->request_transport_speed (1.0f);
1545 }
1546
1547 void
1548 ARDOUR_UI::transport_loop()
1549 {
1550         if (session) {
1551                 if (session->get_play_loop()) {
1552                         if (session->transport_rolling()) {
1553                                 Location * looploc = session->locations()->auto_loop_location();
1554                                 if (looploc) {
1555                                         session->request_locate (looploc->start(), true);
1556                                 }
1557                         }
1558                 }
1559                 else {
1560                         session->request_play_loop (true);
1561                 }
1562         }
1563 }
1564
1565 void
1566 ARDOUR_UI::transport_play_selection ()
1567 {
1568         if (!session) {
1569                 return;
1570         }
1571
1572         if (!session->get_play_range()) {
1573                 session->request_stop ();
1574         }
1575
1576         editor->play_selection ();
1577 }
1578
1579 void
1580 ARDOUR_UI::transport_rewind (int option)
1581 {
1582         float current_transport_speed;
1583
1584         if (session) {
1585                 current_transport_speed = session->transport_speed();
1586
1587                 if (current_transport_speed >= 0.0f) {
1588                         switch (option) {
1589                         case 0:
1590                                 session->request_transport_speed (-1.0f);
1591                                 break;
1592                         case 1:
1593                                 session->request_transport_speed (-4.0f);
1594                                 break;
1595                         case -1:
1596                                 session->request_transport_speed (-0.5f);
1597                                 break;
1598                         }
1599                 } else {
1600                         /* speed up */
1601                         session->request_transport_speed (current_transport_speed * 1.5f);
1602                 }
1603         }
1604 }
1605
1606 void
1607 ARDOUR_UI::transport_forward (int option)
1608 {
1609         float current_transport_speed;
1610
1611         if (session) {
1612                 current_transport_speed = session->transport_speed();
1613
1614                 if (current_transport_speed <= 0.0f) {
1615                         switch (option) {
1616                         case 0:
1617                                 session->request_transport_speed (1.0f);
1618                                 break;
1619                         case 1:
1620                                 session->request_transport_speed (4.0f);
1621                                 break;
1622                         case -1:
1623                                 session->request_transport_speed (0.5f);
1624                                 break;
1625                         }
1626                 } else {
1627                         /* speed up */
1628                         session->request_transport_speed (current_transport_speed * 1.5f);
1629                 }
1630         }
1631 }
1632
1633 void
1634 ARDOUR_UI::toggle_record_enable (uint32_t dstream)
1635 {
1636         if (session == 0) {
1637                 return;
1638         }
1639
1640         boost::shared_ptr<Route> r;
1641
1642         if ((r = session->route_by_remote_id (dstream)) != 0) {
1643
1644                 Track* t;
1645
1646                 if ((t = dynamic_cast<Track*>(r.get())) != 0) {
1647                         t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
1648                 }
1649         }
1650         if (session == 0) {
1651                 return;
1652         }
1653 }
1654
1655 void
1656 ARDOUR_UI::queue_transport_change ()
1657 {
1658         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
1659 }
1660
1661 void
1662 ARDOUR_UI::map_transport_state ()
1663 {
1664         float sp = session->transport_speed();
1665
1666         if (sp == 1.0f) {
1667                 transport_rolling ();
1668         } else if (sp < 0.0f) {
1669                 transport_rewinding ();
1670         } else if (sp > 0.0f) {
1671                 transport_forwarding ();
1672         } else {
1673                 transport_stopped ();
1674         }
1675 }
1676
1677 void
1678 ARDOUR_UI::engine_stopped ()
1679 {
1680         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_stopped));
1681         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1682         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1683 }
1684
1685 void
1686 ARDOUR_UI::engine_running ()
1687 {
1688         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
1689         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
1690         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
1691
1692         Glib::RefPtr<Action> action;
1693         const char* action_name = 0;
1694
1695         switch (engine->frames_per_cycle()) {
1696         case 32:
1697                 action_name = X_("JACKLatency32");
1698                 break;
1699         case 64:
1700                 action_name = X_("JACKLatency64");
1701                 break;
1702         case 128:
1703                 action_name = X_("JACKLatency128");
1704                 break;
1705         case 512:
1706                 action_name = X_("JACKLatency512");
1707                 break;
1708         case 1024:
1709                 action_name = X_("JACKLatency1024");
1710                 break;
1711         case 2048:
1712                 action_name = X_("JACKLatency2048");
1713                 break;
1714         case 4096:
1715                 action_name = X_("JACKLatency4096");
1716                 break;
1717         case 8192:
1718                 action_name = X_("JACKLatency8192");
1719                 break;
1720         default:
1721                 /* XXX can we do anything useful ? */
1722                 break;
1723         }
1724
1725         if (action_name) {
1726
1727                 action = ActionManager::get_action (X_("JACK"), action_name);
1728
1729                 if (action) {
1730                         Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
1731                         ract->set_active ();
1732                 }
1733         }
1734 }
1735
1736 void
1737 ARDOUR_UI::engine_halted ()
1738 {
1739         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
1740
1741         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1742         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1743
1744         update_sample_rate (0);
1745
1746         MessageDialog msg (*editor,
1747                            _("\
1748 JACK has either been shutdown or it\n\
1749 disconnected Ardour because Ardour\n\
1750 was not fast enough. Try to restart\n\
1751 JACK, reconnect and save the session."));
1752         pop_back_splash ();
1753         msg.run ();
1754 }
1755
1756 int32_t
1757 ARDOUR_UI::do_engine_start ()
1758 {
1759         try {
1760                 engine->start();
1761         }
1762
1763         catch (...) {
1764                 engine->stop ();
1765                 error << _("Unable to start the session running")
1766                       << endmsg;
1767                 unload_session ();
1768                 return -2;
1769         }
1770
1771         return 0;
1772 }
1773
1774 void
1775 ARDOUR_UI::setup_theme ()
1776 {
1777         theme_manager->setup_theme();
1778 }
1779
1780 void
1781 ARDOUR_UI::update_clocks ()
1782 {
1783         if (!editor || !editor->dragging_playhead()) {
1784                 Clock (session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
1785         }
1786 }
1787
1788 void
1789 ARDOUR_UI::start_clocking ()
1790 {
1791         clock_signal_connection = RapidScreenUpdate.connect (mem_fun(*this, &ARDOUR_UI::update_clocks));
1792 }
1793
1794 void
1795 ARDOUR_UI::stop_clocking ()
1796 {
1797         clock_signal_connection.disconnect ();
1798 }
1799
1800 void
1801 ARDOUR_UI::toggle_clocking ()
1802 {
1803 #if 0
1804         if (clock_button.get_active()) {
1805                 start_clocking ();
1806         } else {
1807                 stop_clocking ();
1808         }
1809 #endif
1810 }
1811
1812 gint
1813 ARDOUR_UI::_blink (void *arg)
1814
1815 {
1816         ((ARDOUR_UI *) arg)->blink ();
1817         return TRUE;
1818 }
1819
1820 void
1821 ARDOUR_UI::blink ()
1822 {
1823         Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
1824 }
1825
1826 void
1827 ARDOUR_UI::start_blinking ()
1828 {
1829         /* Start the blink signal. Everybody with a blinking widget
1830            uses Blink to drive the widget's state.
1831         */
1832
1833         if (blink_timeout_tag < 0) {
1834                 blink_on = false;
1835                 blink_timeout_tag = g_timeout_add (240, _blink, this);
1836         }
1837 }
1838
1839 void
1840 ARDOUR_UI::stop_blinking ()
1841 {
1842         if (blink_timeout_tag >= 0) {
1843                 g_source_remove (blink_timeout_tag);
1844                 blink_timeout_tag = -1;
1845         }
1846 }
1847
1848
1849 /** Ask the user for the name of a new shapshot and then take it.
1850  */
1851 void
1852 ARDOUR_UI::snapshot_session ()
1853 {
1854         ArdourPrompter prompter (true);
1855         string snapname;
1856         char timebuf[128];
1857         time_t n;
1858         struct tm local_time;
1859
1860         time (&n);
1861         localtime_r (&n, &local_time);
1862         strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
1863
1864         prompter.set_name ("Prompter");
1865         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
1866         prompter.set_title (_("Take Snapshot"));
1867         prompter.set_prompt (_("Name of New Snapshot"));
1868         prompter.set_initial_text (timebuf);
1869
1870         switch (prompter.run()) {
1871         case RESPONSE_ACCEPT:
1872         {
1873                 prompter.get_result (snapname);
1874
1875                 bool do_save = (snapname.length() != 0);
1876
1877                 vector<sys::path> p;
1878                 get_state_files_in_directory (session->session_directory().root_path(), p);
1879                 vector<string> n = get_file_names_no_extension (p);
1880                 if (find (n.begin(), n.end(), snapname) != n.end()) {
1881
1882                         ArdourDialog confirm (_("Confirm snapshot overwrite"), true);
1883                         Label m (_("A snapshot already exists with that name.  Do you want to overwrite it?"));
1884                         confirm.get_vbox()->pack_start (m, true, true);
1885                         confirm.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1886                         confirm.add_button (_("Overwrite"), Gtk::RESPONSE_ACCEPT);
1887                         confirm.show_all ();
1888                         switch (confirm.run()) {
1889                         case RESPONSE_CANCEL:
1890                                 do_save = false;
1891                         }
1892                 }
1893
1894                 if (do_save) {
1895                         save_state (snapname);
1896                 }
1897                 break;
1898         }
1899
1900         default:
1901                 break;
1902         }
1903 }
1904
1905 void
1906 ARDOUR_UI::save_state (const string & name)
1907 {
1908         (void) save_state_canfail (name);
1909 }
1910
1911 int
1912 ARDOUR_UI::save_state_canfail (string name)
1913 {
1914         if (session) {
1915                 int ret;
1916
1917                 if (name.length() == 0) {
1918                         name = session->snap_name();
1919                 }
1920
1921                 if ((ret = session->save_state (name)) != 0) {
1922                         return ret;
1923                 }
1924         }
1925         save_ardour_state (); /* XXX cannot fail? yeah, right ... */
1926         return 0;
1927 }
1928
1929 void
1930 ARDOUR_UI::primary_clock_value_changed ()
1931 {
1932         if (session) {
1933                 session->request_locate (primary_clock.current_time ());
1934         }
1935 }
1936
1937 void
1938 ARDOUR_UI::big_clock_value_changed ()
1939 {
1940         if (session) {
1941                 session->request_locate (big_clock.current_time ());
1942         }
1943 }
1944
1945 void
1946 ARDOUR_UI::secondary_clock_value_changed ()
1947 {
1948         if (session) {
1949                 session->request_locate (secondary_clock.current_time ());
1950         }
1951 }
1952
1953 void
1954 ARDOUR_UI::transport_rec_enable_blink (bool onoff)
1955 {
1956         if (session == 0) {
1957                 return;
1958         }
1959
1960         Session::RecordState const r = session->record_status ();
1961         bool const h = session->have_rec_enabled_diskstream ();
1962
1963         if (r == Session::Enabled || (r == Session::Recording && !h)) {
1964                 if (onoff) {
1965                         rec_button.set_visual_state (2);
1966                 } else {
1967                         rec_button.set_visual_state (0);
1968                 }
1969         } else if (r == Session::Recording && h) {
1970                 rec_button.set_visual_state (1);
1971         } else {
1972                 rec_button.set_visual_state (0);
1973         }
1974 }
1975
1976 void
1977 ARDOUR_UI::save_template ()
1978 {
1979         ArdourPrompter prompter (true);
1980         string name;
1981
1982         if (!check_audioengine()) {
1983                 return;
1984         }
1985
1986         prompter.set_name (X_("Prompter"));
1987         prompter.set_title (_("Save Mix Template"));
1988         prompter.set_prompt (_("Name for mix template:"));
1989         prompter.set_initial_text(session->name() + _("-template"));
1990         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
1991
1992         switch (prompter.run()) {
1993         case RESPONSE_ACCEPT:
1994                 prompter.get_result (name);
1995
1996                 if (name.length()) {
1997                         session->save_template (name);
1998                 }
1999                 break;
2000
2001         default:
2002                 break;
2003         }
2004 }
2005
2006 void
2007 ARDOUR_UI::edit_metadata ()
2008 {
2009         SessionMetadataEditor dialog;
2010         dialog.set_session (session);
2011         editor->ensure_float (dialog);
2012         dialog.run ();
2013 }
2014
2015 void
2016 ARDOUR_UI::import_metadata ()
2017 {
2018         SessionMetadataImporter dialog;
2019         dialog.set_session (session);
2020         editor->ensure_float (dialog);
2021         dialog.run ();
2022 }
2023
2024 void
2025 ARDOUR_UI::fontconfig_dialog ()
2026 {
2027 #ifdef GTKOSX
2028         /* X11 users will always have fontconfig info around, but new GTK-OSX users
2029            may not and it can take a while to build it. Warn them.
2030         */
2031
2032         Glib::ustring fontconfig = Glib::build_filename (Glib::get_home_dir(), ".fontconfig");
2033
2034         if (!Glib::file_test (fontconfig, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
2035                 MessageDialog msg (*_startup,
2036                                    _("Welcome to Ardour.\n\n"
2037                                      "The program will take a bit longer to start up\n"
2038                                      "while the system fonts are checked.\n\n"
2039                                      "This will only be done once, and you will\n"
2040                                      "not see this message again\n"),
2041                                    true,
2042                                    Gtk::MESSAGE_INFO,
2043                                    Gtk::BUTTONS_OK);
2044                 pop_back_splash ();
2045                 msg.show_all ();
2046                 msg.present ();
2047                 msg.run ();
2048         }
2049 #endif
2050 }
2051
2052 void
2053 ARDOUR_UI::parse_cmdline_path (const Glib::ustring& cmdline_path, Glib::ustring& session_name, Glib::ustring& session_path, bool& existing_session)
2054 {
2055         existing_session = false;
2056
2057         if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_DIR)) {
2058                 session_path = cmdline_path;
2059                 existing_session = true;
2060         } else if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_REGULAR)) {
2061                 session_path = Glib::path_get_dirname (string (cmdline_path));
2062                 existing_session = true;
2063         } else {
2064                 /* it doesn't exist, assume the best */
2065                 session_path = Glib::path_get_dirname (string (cmdline_path));
2066         }
2067
2068         session_name = basename_nosuffix (string (cmdline_path));
2069 }
2070
2071 int
2072 ARDOUR_UI::load_cmdline_session (const Glib::ustring& session_name, const Glib::ustring& session_path, bool& existing_session)
2073 {
2074         /* when this is called, the backend audio system must be running */
2075
2076         /* the main idea here is to deal with the fact that a cmdline argument for the session
2077            can be interpreted in different ways - it could be a directory or a file, and before
2078            we load, we need to know both the session directory and the snapshot (statefile) within it
2079            that we are supposed to use.
2080         */
2081
2082         if (session_name.length() == 0 || session_path.length() == 0) {
2083                 return false;
2084         }
2085
2086         if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
2087
2088                 Glib::ustring predicted_session_file;
2089
2090                 predicted_session_file = session_path;
2091                 predicted_session_file += '/';
2092                 predicted_session_file += session_name;
2093                 predicted_session_file += ARDOUR::statefile_suffix;
2094
2095                 if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) {
2096                         existing_session = true;
2097                 }
2098
2099         } else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) {
2100
2101                 if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) {
2102                         /* existing .ardour file */
2103                         existing_session = true;
2104                 }
2105
2106         } else {
2107                 existing_session = false;
2108         }
2109
2110         /* lets just try to load it */
2111
2112         if (create_engine ()) {
2113                 backend_audio_error (false, _startup);
2114                 return -1;
2115         }
2116
2117         return load_session (session_path, session_name);
2118 }
2119
2120 bool
2121 ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path)
2122 {
2123         Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
2124
2125         MessageDialog msg (str,
2126                            false,
2127                            Gtk::MESSAGE_WARNING,
2128                            Gtk::BUTTONS_YES_NO,
2129                            true);
2130
2131
2132         msg.set_name (X_("CleanupDialog"));
2133         msg.set_title (_("Cleanup Unused Sources"));
2134         msg.set_wmclass (X_("existing_session"), "Ardour");
2135         msg.set_position (Gtk::WIN_POS_MOUSE);
2136         pop_back_splash ();
2137
2138         switch (msg.run()) {
2139         case RESPONSE_YES:
2140                 return true;
2141                 break;
2142         }
2143         return false;
2144 }
2145
2146 int
2147 ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& session_name)
2148 {
2149
2150         uint32_t cchns;
2151         uint32_t mchns;
2152         AutoConnectOption iconnect;
2153         AutoConnectOption oconnect;
2154         uint32_t nphysin;
2155         uint32_t nphysout;
2156
2157         if (Profile->get_sae()) {
2158
2159                 cchns = 0;
2160                 mchns = 2;
2161                 iconnect = AutoConnectPhysical;
2162                 oconnect = AutoConnectMaster;
2163                 nphysin = 0; // use all available
2164                 nphysout = 0; // use all available
2165
2166         } else {
2167
2168                 /* get settings from advanced section of NSD */
2169
2170                 if (_startup->create_control_bus()) {
2171                         cchns = (uint32_t) _startup->control_channel_count();
2172                 } else {
2173                         cchns = 0;
2174                 }
2175
2176                 if (_startup->create_master_bus()) {
2177                         mchns = (uint32_t) _startup->master_channel_count();
2178                 } else {
2179                         mchns = 0;
2180                 }
2181
2182                 if (_startup->connect_inputs()) {
2183                         iconnect = AutoConnectPhysical;
2184                 } else {
2185                         iconnect = AutoConnectOption (0);
2186                 }
2187
2188                 /// @todo some minor tweaks.
2189
2190                 oconnect = AutoConnectOption (0);
2191
2192                 if (_startup->connect_outputs ()) {
2193                         if (_startup->connect_outs_to_master()) {
2194                                 oconnect = AutoConnectMaster;
2195                         } else if (_startup->connect_outs_to_physical()) {
2196                                 oconnect = AutoConnectPhysical;
2197                         }
2198                 }
2199
2200                 nphysin = (uint32_t) _startup->input_limit_count();
2201                 nphysout = (uint32_t) _startup->output_limit_count();
2202         }
2203
2204         if (build_session (session_path,
2205                            session_name,
2206                            cchns,
2207                            mchns,
2208                            iconnect,
2209                            oconnect,
2210                            nphysin,
2211                            nphysout,
2212                            engine->frame_rate() * 60 * 5)) {
2213
2214                 return -1;
2215         }
2216
2217         return 0;
2218 }
2219
2220 void
2221 ARDOUR_UI::idle_load (const Glib::ustring& path)
2222 {
2223         if (session) {
2224                 if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
2225                         /* /path/to/foo => /path/to/foo, foo */
2226                         load_session (path, basename_nosuffix (path));
2227                 } else {
2228                         /* /path/to/foo/foo.ardour => /path/to/foo, foo */
2229                         load_session (Glib::path_get_dirname (path), basename_nosuffix (path));
2230                 }
2231         } else {
2232
2233                 ARDOUR_COMMAND_LINE::session_name = path;
2234
2235                 /*
2236                  * new_session_dialog doens't exist in A3
2237                  * Try to remove all references to it to
2238                  * see if it will compile.  NOTE: this will
2239                  * likely cause a runtime issue is my somewhat
2240                  * uneducated guess.
2241                  */
2242
2243                 //if (new_session_dialog) {
2244
2245
2246                         /* make it break out of Dialog::run() and
2247                            start again.
2248                          */
2249
2250                         //new_session_dialog->response (1);
2251                 //}
2252         }
2253 }
2254
2255 void
2256 ARDOUR_UI::end_loading_messages ()
2257 {
2258         // hide_splash ();
2259 }
2260
2261 void
2262 ARDOUR_UI::loading_message (const std::string& /*msg*/)
2263 {
2264         // show_splash ();
2265         // splash->message (msg);
2266         flush_pending ();
2267 }
2268
2269 /** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
2270 int
2271 ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new)
2272 {
2273         Glib::ustring session_name;
2274         Glib::ustring session_path;
2275         Glib::ustring template_name;
2276         int ret = -1;
2277         bool likely_new = false;
2278
2279         while (ret != 0) {
2280
2281                 if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) {
2282
2283                         /* if they named a specific statefile, use it, otherwise they are
2284                            just giving a session folder, and we want to use it as is
2285                            to find the session.
2286                         */
2287
2288                         if (ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix) != string::npos) {
2289                                 session_path = Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name);
2290                         } else {
2291                                 session_path = ARDOUR_COMMAND_LINE::session_name;
2292                         }
2293
2294                         session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name);
2295
2296                 } else {
2297
2298                         bool const apply = run_startup (should_be_new);
2299                         if (!apply) {
2300                                 if (quit_on_cancel) {
2301                                         exit (1);
2302                                 } else {
2303                                         return ret;
2304                                 }
2305                         }
2306
2307                         /* if we run the startup dialog again, offer more than just "new session" */
2308
2309                         should_be_new = false;
2310
2311                         session_name = _startup->session_name (likely_new);
2312
2313                         /* this shouldn't happen, but we catch it just in case it does */
2314
2315                         if (session_name.empty()) {
2316                                 break;
2317                         }
2318                         if (_startup->use_session_template()) {
2319                                 template_name = _startup->session_template_name();
2320                                 _session_is_new = true;
2321                         }
2322
2323                         if (session_name[0] == '/' ||
2324                             (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
2325                             (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
2326
2327                                 session_path = Glib::path_get_dirname (session_name);
2328                                 session_name = Glib::path_get_basename (session_name);
2329
2330                         } else {
2331
2332                                 session_path = _startup->session_folder();
2333                         }
2334                 }
2335
2336                 if (create_engine ()) {
2337                         break;
2338                 }
2339
2340                 if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
2341
2342                         if (likely_new) {
2343
2344                                 Glib::ustring existing = Glib::build_filename (session_path, session_name);
2345
2346                                 if (!ask_about_loading_existing_session (existing)) {
2347                                         ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2348                                         continue;
2349                                 }
2350                         }
2351
2352                         _session_is_new = false;
2353
2354                 } else {
2355
2356                         if (!likely_new) {
2357                                 MessageDialog msg (string_compose (_("There is no existing session at \"%1\""), session_path));
2358                                 msg.run ();
2359                                 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2360                                 continue;
2361                         }
2362
2363                         _session_is_new = true;
2364                 }
2365
2366                 if (likely_new && template_name.empty()) {
2367
2368                         ret = build_session_from_nsd (session_path, session_name);
2369
2370                 } else {
2371
2372                         ret = load_session (session_path, session_name, template_name);
2373                         if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
2374                                 session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
2375                                 exit (1);
2376                         }
2377                 }
2378         }
2379
2380         return ret;
2381 }
2382
2383 void
2384 ARDOUR_UI::close_session()
2385 {
2386         if (!check_audioengine()) {
2387                 return;
2388         }
2389
2390         unload_session (true);
2391
2392         ARDOUR_COMMAND_LINE::session_name = "";
2393         get_session_parameters (true, false);
2394 }
2395
2396 int
2397 ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_name, Glib::ustring mix_template)
2398 {
2399         Session *new_session;
2400         int unload_status;
2401         int retval = -1;
2402
2403         session_loaded = false;
2404
2405         if (!check_audioengine()) {
2406                 return -1;
2407         }
2408
2409         unload_status = unload_session ();
2410
2411         if (unload_status < 0) {
2412                 goto out;
2413         } else if (unload_status > 0) {
2414                 retval = 0;
2415                 goto out;
2416         }
2417
2418         loading_message (_("Please wait while Ardour loads your session"));
2419
2420         try {
2421                 new_session = new Session (*engine, path, snap_name, mix_template);
2422         }
2423
2424         /* this one is special */
2425
2426         catch (AudioEngine::PortRegistrationFailure& err) {
2427
2428                 MessageDialog msg (err.what(),
2429                                    true,
2430                                    Gtk::MESSAGE_INFO,
2431                                    Gtk::BUTTONS_CLOSE);
2432
2433                 msg.set_title (_("Port Registration Error"));
2434                 msg.set_secondary_text (_("Click the Close button to try again."));
2435                 msg.set_position (Gtk::WIN_POS_CENTER);
2436                 pop_back_splash ();
2437                 msg.present ();
2438
2439                 int response = msg.run ();
2440
2441                 msg.hide ();
2442
2443                 switch (response) {
2444                 case RESPONSE_CANCEL:
2445                         exit (1);
2446                 default:
2447                         break;
2448                 }
2449                 goto out;
2450         }
2451
2452         catch (...) {
2453
2454                 MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name),
2455                                    true,
2456                                    Gtk::MESSAGE_INFO,
2457                                    Gtk::BUTTONS_CLOSE);
2458
2459                 msg.set_title (_("Loading Error"));
2460                 msg.set_secondary_text (_("Click the Close button to try again."));
2461                 msg.set_position (Gtk::WIN_POS_CENTER);
2462                 pop_back_splash ();
2463                 msg.present ();
2464
2465                 int response = msg.run ();
2466
2467                 msg.hide ();
2468
2469                 switch (response) {
2470                 case RESPONSE_CANCEL:
2471                         exit (1);
2472                 default:
2473                         break;
2474                 }
2475                 goto out;
2476         }
2477
2478         connect_to_session (new_session);
2479
2480         session_loaded = true;
2481
2482         goto_editor_window ();
2483
2484         if (session) {
2485                 session->set_clean ();
2486         }
2487
2488         flush_pending ();
2489         retval = 0;
2490
2491   out:
2492         return retval;
2493 }
2494
2495 int
2496 ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name,
2497                           uint32_t control_channels,
2498                           uint32_t master_channels,
2499                           AutoConnectOption input_connect,
2500                           AutoConnectOption output_connect,
2501                           uint32_t nphysin,
2502                           uint32_t nphysout,
2503                           nframes_t initial_length)
2504 {
2505         Session *new_session;
2506         int x;
2507
2508         if (!check_audioengine()) {
2509                 return -1;
2510         }
2511
2512         session_loaded = false;
2513
2514         x = unload_session ();
2515
2516         if (x < 0) {
2517                 return -1;
2518         } else if (x > 0) {
2519                 return 0;
2520         }
2521
2522         _session_is_new = true;
2523
2524         try {
2525                 new_session = new Session (*engine, path, snap_name, input_connect, output_connect,
2526                                            control_channels, master_channels, nphysin, nphysout, initial_length);
2527         }
2528
2529         catch (...) {
2530
2531                 MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
2532                 pop_back_splash ();
2533                 msg.run ();
2534                 return -1;
2535         }
2536
2537         connect_to_session (new_session);
2538
2539         session_loaded = true;
2540
2541         new_session->save_state(new_session->name());
2542
2543         return 0;
2544 }
2545
2546 void
2547 ARDOUR_UI::show ()
2548 {
2549         if (editor) {
2550                 editor->show_window ();
2551
2552                 if (!shown_flag) {
2553                         editor->present ();
2554                 }
2555
2556                 shown_flag = true;
2557         }
2558 }
2559
2560 void
2561 ARDOUR_UI::show_about ()
2562 {
2563         if (about == 0) {
2564                 about = new About;
2565                 about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );
2566         }
2567
2568         about->show_all ();
2569 }
2570
2571 void
2572 ARDOUR_UI::hide_about ()
2573 {
2574         if (about) {
2575                 about->get_window()->set_cursor ();
2576                 about->hide ();
2577         }
2578 }
2579
2580 void
2581 ARDOUR_UI::about_signal_response (int /*response*/)
2582 {
2583         hide_about();
2584 }
2585
2586 void
2587 ARDOUR_UI::show_splash ()
2588 {
2589         if (splash == 0) {
2590                 try {
2591                         splash = new Splash;
2592                 } catch (...) {
2593                         return;
2594                 }
2595         }
2596
2597         splash->show ();
2598         splash->present ();
2599         splash->queue_draw ();
2600         splash->get_window()->process_updates (true);
2601         flush_pending ();
2602 }
2603
2604 void
2605 ARDOUR_UI::hide_splash ()
2606 {
2607         if (splash) {
2608                 splash->hide();
2609         }
2610 }
2611
2612 void
2613 ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title,
2614                                     const string& plural_msg, const string& singular_msg)
2615 {
2616         size_t removed;
2617
2618         removed = rep.paths.size();
2619
2620         if (removed == 0) {
2621                 MessageDialog msgd (*editor,
2622                                     _("No audio files were ready for cleanup"),
2623                                     true,
2624                                     Gtk::MESSAGE_INFO,
2625                                     (Gtk::ButtonsType)(Gtk::BUTTONS_OK)  );
2626                 msgd.set_secondary_text (_("If this seems suprising, \n\
2627 check for any existing snapshots.\n\
2628 These may still include regions that\n\
2629 require some unused files to continue to exist."));
2630
2631                 msgd.run ();
2632                 return;
2633         }
2634
2635         ArdourDialog results (_("ardour: cleanup"), true, false);
2636
2637         struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
2638             CleanupResultsModelColumns() {
2639                     add (visible_name);
2640                     add (fullpath);
2641             }
2642             Gtk::TreeModelColumn<Glib::ustring> visible_name;
2643             Gtk::TreeModelColumn<Glib::ustring> fullpath;
2644         };
2645
2646
2647         CleanupResultsModelColumns results_columns;
2648         Glib::RefPtr<Gtk::ListStore> results_model;
2649         Gtk::TreeView results_display;
2650
2651         results_model = ListStore::create (results_columns);
2652         results_display.set_model (results_model);
2653         results_display.append_column (list_title, results_columns.visible_name);
2654
2655         results_display.set_name ("CleanupResultsList");
2656         results_display.set_headers_visible (true);
2657         results_display.set_headers_clickable (false);
2658         results_display.set_reorderable (false);
2659
2660         Gtk::ScrolledWindow list_scroller;
2661         Gtk::Label txt;
2662         Gtk::VBox dvbox;
2663         Gtk::HBox dhbox;  // the hbox for the image and text
2664         Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
2665         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO,  Gtk::ICON_SIZE_DIALOG));
2666
2667         dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
2668
2669         const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
2670
2671
2672
2673
2674         /* subst:
2675            %1 - number of files removed
2676            %2 - location of "dead_sounds"
2677            %3 - size of files affected
2678            %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
2679         */
2680
2681         const char* bprefix;
2682
2683         if (rep.space < 1048576.0f) {
2684                 bprefix = X_("kilo");
2685         } else if (rep.space < 1048576.0f * 1000) {
2686                 bprefix = X_("mega");
2687         } else {
2688                 bprefix = X_("giga");
2689         }
2690
2691         if (removed > 1) {
2692                 txt.set_text (string_compose (plural_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
2693         } else {
2694                 txt.set_text (string_compose (singular_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
2695         }
2696
2697         dhbox.pack_start (*dimage, true, false, 5);
2698         dhbox.pack_start (txt, true, false, 5);
2699
2700         for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
2701                 TreeModel::Row row = *(results_model->append());
2702                 row[results_columns.visible_name] = *i;
2703                 row[results_columns.fullpath] = *i;
2704         }
2705
2706         list_scroller.add (results_display);
2707         list_scroller.set_size_request (-1, 150);
2708         list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
2709
2710         dvbox.pack_start (dhbox, true, false, 5);
2711         dvbox.pack_start (list_scroller, true, false, 5);
2712         ddhbox.pack_start (dvbox, true, false, 5);
2713
2714         results.get_vbox()->pack_start (ddhbox, true, false, 5);
2715         results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
2716         results.set_default_response (RESPONSE_CLOSE);
2717         results.set_position (Gtk::WIN_POS_MOUSE);
2718
2719         results_display.show();
2720         list_scroller.show();
2721         txt.show();
2722         dvbox.show();
2723         dhbox.show();
2724         ddhbox.show();
2725         dimage->show();
2726
2727         //results.get_vbox()->show();
2728         results.set_resizable (false);
2729
2730         results.run ();
2731
2732 }
2733
2734 void
2735 ARDOUR_UI::cleanup ()
2736 {
2737         if (session == 0) {
2738                 /* shouldn't happen: menu item is insensitive */
2739                 return;
2740         }
2741
2742
2743         MessageDialog  checker (_("Are you sure you want to cleanup?"),
2744                                 true,
2745                                 Gtk::MESSAGE_QUESTION,
2746                                 (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
2747
2748         checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
2749 ALL undo/redo information will be lost if you cleanup.\n\
2750 After cleanup, unused audio files will be moved to a \
2751 \"dead sounds\" location."));
2752
2753         checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
2754         checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
2755         checker.set_default_response (RESPONSE_CANCEL);
2756
2757         checker.set_name (_("CleanupDialog"));
2758         checker.set_wmclass (X_("ardour_cleanup"), "Ardour");
2759         checker.set_position (Gtk::WIN_POS_MOUSE);
2760
2761         switch (checker.run()) {
2762         case RESPONSE_ACCEPT:
2763                 break;
2764         default:
2765                 return;
2766         }
2767
2768         Session::cleanup_report rep;
2769
2770         editor->prepare_for_cleanup ();
2771
2772         /* do not allow flush until a session is reloaded */
2773
2774         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
2775         if (act) {
2776                 act->set_sensitive (false);
2777         }
2778
2779         if (session->cleanup_sources (rep)) {
2780                 editor->finish_cleanup ();
2781                 return;
2782         }
2783
2784         editor->finish_cleanup ();
2785
2786         checker.hide();
2787         display_cleanup_results (rep,
2788                                  _("cleaned files"),
2789                                  _("\
2790 The following %1 files were not in use and \n\
2791 have been moved to:\n\
2792 %2. \n\n\
2793 Flushing the wastebasket will \n\
2794 release an additional\n\
2795 %3 %4bytes of disk space.\n"),
2796                                  _("\
2797 The following file was not in use and \n        \
2798 has been moved to:\n                            \
2799 %2. \n\n\
2800 Flushing the wastebasket will \n\
2801 release an additional\n\
2802 %3 %4bytes of disk space.\n"
2803                                          ));
2804
2805 }
2806
2807 void
2808 ARDOUR_UI::flush_trash ()
2809 {
2810         if (session == 0) {
2811                 /* shouldn't happen: menu item is insensitive */
2812                 return;
2813         }
2814
2815         Session::cleanup_report rep;
2816
2817         if (session->cleanup_trash_sources (rep)) {
2818                 return;
2819         }
2820
2821         display_cleanup_results (rep,
2822                                  _("deleted file"),
2823                                  _("The following %1 files were deleted from\n\
2824 %2,\n\
2825 releasing %3 %4bytes of disk space"),
2826                                  _("The following file was deleted from\n\
2827 %2,\n\
2828 releasing %3 %4bytes of disk space"));
2829 }
2830
2831 void
2832 ARDOUR_UI::add_route (Gtk::Window* float_window)
2833 {
2834         int count;
2835
2836         if (!session) {
2837                 return;
2838         }
2839
2840         if (add_route_dialog == 0) {
2841                 add_route_dialog = new AddRouteDialog (*session);
2842                 if (float_window) {
2843                         add_route_dialog->set_transient_for (*float_window);
2844                 }
2845         }
2846
2847         if (add_route_dialog->is_visible()) {
2848                 /* we're already doing this */
2849                 return;
2850         }
2851
2852         ResponseType r = (ResponseType) add_route_dialog->run ();
2853
2854         add_route_dialog->hide();
2855
2856         switch (r) {
2857                 case RESPONSE_ACCEPT:
2858                         break;
2859                 default:
2860                         return;
2861                         break;
2862         }
2863
2864         if ((count = add_route_dialog->count()) <= 0) {
2865                 return;
2866         }
2867
2868         string template_path = add_route_dialog->track_template();
2869
2870         if (!template_path.empty()) {
2871                 session->new_route_from_template (count, template_path);
2872                 return;
2873         }
2874
2875         uint32_t input_chan = add_route_dialog->channels ();
2876         uint32_t output_chan;
2877         string name_template = add_route_dialog->name_template ();
2878         bool track = add_route_dialog->track ();
2879         RouteGroup* route_group = add_route_dialog->route_group ();
2880
2881         AutoConnectOption oac = Config->get_output_auto_connect();
2882
2883         if (oac & AutoConnectMaster) {
2884                 output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan);
2885         } else {
2886                 output_chan = input_chan;
2887         }
2888
2889         /* XXX do something with name template */
2890
2891         if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
2892                 if (track) {
2893                         session_add_midi_track (route_group, count);
2894                 } else  {
2895                         MessageDialog msg (*editor,
2896                                         _("Sorry, MIDI Busses are not supported at this time."));
2897                         msg.run ();
2898                         //session_add_midi_bus();
2899                 }
2900         } else {
2901                 if (track) {
2902                         session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
2903                 } else {
2904                         session_add_audio_bus (input_chan, output_chan, route_group, count);
2905                 }
2906         }
2907 }
2908
2909 XMLNode*
2910 ARDOUR_UI::mixer_settings () const
2911 {
2912         XMLNode* node = 0;
2913
2914         if (session) {
2915                 node = session->instant_xml(X_("Mixer"));
2916         } else {
2917                 node = Config->instant_xml(X_("Mixer"));
2918         }
2919
2920         if (!node) {
2921                 node = new XMLNode (X_("Mixer"));
2922         }
2923
2924         return node;
2925 }
2926
2927 XMLNode*
2928 ARDOUR_UI::editor_settings () const
2929 {
2930         XMLNode* node = 0;
2931
2932         if (session) {
2933                 node = session->instant_xml(X_("Editor"));
2934         } else {
2935                 node = Config->instant_xml(X_("Editor"));
2936         }
2937
2938         if (!node) {
2939                 if (getenv("ARDOUR_INSTANT_XML_PATH")) {
2940                         node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
2941                 }
2942         }
2943
2944         if (!node) {
2945                 node = new XMLNode (X_("Editor"));
2946         }
2947
2948         return node;
2949 }
2950
2951 XMLNode*
2952 ARDOUR_UI::keyboard_settings () const
2953 {
2954         XMLNode* node = 0;
2955
2956         node = Config->extra_xml(X_("Keyboard"));
2957
2958         if (!node) {
2959                 node = new XMLNode (X_("Keyboard"));
2960         }
2961         return node;
2962 }
2963
2964 void
2965 ARDOUR_UI::create_xrun_marker(nframes_t where)
2966 {
2967         editor->mouse_add_new_marker (where, false, true);
2968 }
2969
2970 void
2971 ARDOUR_UI::halt_on_xrun_message ()
2972 {
2973         MessageDialog msg (*editor,
2974                            _("Recording was stopped because your system could not keep up."));
2975         msg.run ();
2976 }
2977
2978 void
2979 ARDOUR_UI::xrun_handler(nframes_t where)
2980 {
2981         if (!session) {
2982                 return;
2983         }
2984
2985         ENSURE_GUI_THREAD (bind(mem_fun(*this, &ARDOUR_UI::xrun_handler), where));
2986
2987         if (session && Config->get_create_xrun_marker() && session->actively_recording()) {
2988                 create_xrun_marker(where);
2989         }
2990
2991         if (session && Config->get_stop_recording_on_xrun() && session->actively_recording()) {
2992                 halt_on_xrun_message ();
2993         }
2994 }
2995
2996 void
2997 ARDOUR_UI::push_buffer_stats (uint32_t capture, uint32_t playback)
2998 {
2999         time_t now;
3000         time (&now);
3001
3002         while (disk_buffer_stats.size() > 60) {
3003                 disk_buffer_stats.pop_front ();
3004         }
3005
3006         disk_buffer_stats.push_back (DiskBufferStat (now, capture, playback));
3007 }
3008
3009 void
3010 ARDOUR_UI::write_buffer_stats ()
3011 {
3012         struct tm tm;
3013         char buf[64];
3014
3015         char* tmplt = (char*)calloc(strlen("ardourXXXXXX"), sizeof(char));
3016         int fd = mkstemp (tmplt);
3017         if (fd) {
3018                 cerr << X_("cannot find temporary name for ardour buffer stats") << endl;
3019                 return;
3020         }
3021
3022         FILE* fout = fdopen (fd, "w");
3023         if (!fout) {
3024                 cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), tmplt) << endl;
3025                 return;
3026         }
3027
3028         for (list<DiskBufferStat>::iterator i = disk_buffer_stats.begin(); i != disk_buffer_stats.end(); ++i) {
3029                 std::ostringstream ss;
3030                 localtime_r (&(*i).when, &tm);
3031                 strftime (buf, sizeof (buf), "%T", &tm);
3032                 fprintf(fout, "%s %u %u\n", buf, (*i).capture, (*i).playback);
3033         }
3034
3035         disk_buffer_stats.clear ();
3036
3037         fclose (fout);
3038         close (fd);
3039
3040         cerr << "Ardour buffering statistics can be found in: " << tmplt << endl;
3041         free (tmplt);
3042 }
3043
3044 void
3045 ARDOUR_UI::disk_overrun_handler ()
3046 {
3047         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
3048
3049         write_buffer_stats ();
3050
3051         if (!have_disk_speed_dialog_displayed) {
3052                 have_disk_speed_dialog_displayed = true;
3053                 MessageDialog* msg = new MessageDialog (*editor, _("\
3054 The disk system on your computer\n\
3055 was not able to keep up with Ardour.\n\
3056 \n\
3057 Specifically, it failed to write data to disk\n\
3058 quickly enough to keep up with recording.\n"));
3059                 msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
3060                 msg->show ();
3061         }
3062 }
3063
3064 void
3065 ARDOUR_UI::disk_underrun_handler ()
3066 {
3067         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
3068
3069         write_buffer_stats ();
3070
3071         if (!have_disk_speed_dialog_displayed) {
3072                 have_disk_speed_dialog_displayed = true;
3073                 MessageDialog* msg = new MessageDialog (*editor,
3074                                    _("The disk system on your computer\n\
3075 was not able to keep up with Ardour.\n\
3076 \n\
3077 Specifically, it failed to read data from disk\n\
3078 quickly enough to keep up with playback.\n"));
3079                 msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
3080                 msg->show ();
3081         }
3082 }
3083
3084 void
3085 ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
3086 {
3087         have_disk_speed_dialog_displayed = false;
3088         delete msg;
3089 }
3090
3091 void
3092 ARDOUR_UI::session_dialog (std::string msg)
3093 {
3094         ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::session_dialog), msg));
3095
3096         MessageDialog* d;
3097
3098         if (editor) {
3099                 d = new MessageDialog (*editor, msg, false, MESSAGE_INFO, BUTTONS_OK, true);
3100         } else {
3101                 d = new MessageDialog (msg, false, MESSAGE_INFO, BUTTONS_OK, true);
3102         }
3103
3104         d->show_all ();
3105         d->run ();
3106         delete d;
3107 }
3108
3109 int
3110 ARDOUR_UI::pending_state_dialog ()
3111 {
3112         HBox* hbox = new HBox();
3113         Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
3114         ArdourDialog dialog (_("Crash Recovery"), true);
3115         Label  message (_("\
3116 This session appears to have been in\n\
3117 middle of recording when ardour or\n\
3118 the computer was shutdown.\n\
3119 \n\
3120 Ardour can recover any captured audio for\n\
3121 you, or it can ignore it. Please decide\n\
3122 what you would like to do.\n"));
3123         image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
3124         hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
3125         hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
3126         dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
3127         dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
3128         dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
3129         dialog.set_default_response (RESPONSE_ACCEPT);
3130         dialog.set_position (WIN_POS_CENTER);
3131         message.show();
3132         image->show();
3133         hbox->show();
3134
3135         switch (dialog.run ()) {
3136         case RESPONSE_ACCEPT:
3137                 return 1;
3138         default:
3139                 return 0;
3140         }
3141 }
3142
3143 int
3144 ARDOUR_UI::sr_mismatch_dialog (nframes_t desired, nframes_t actual)
3145 {
3146         HBox* hbox = new HBox();
3147         Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
3148         ArdourDialog dialog (_("Sample Rate Mismatch"), true);
3149         Label  message (string_compose (_("\
3150 This session was created with a sample rate of %1 Hz\n\
3151 \n\
3152 The audioengine is currently running at %2 Hz\n"), desired, actual));
3153
3154         image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
3155         hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
3156         hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
3157         dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
3158         dialog.add_button (_("Do not load session"), RESPONSE_REJECT);
3159         dialog.add_button (_("Load session anyway"), RESPONSE_ACCEPT);
3160         dialog.set_default_response (RESPONSE_ACCEPT);
3161         dialog.set_position (WIN_POS_CENTER);
3162         message.show();
3163         image->show();
3164         hbox->show();
3165
3166         switch (dialog.run ()) {
3167         case RESPONSE_ACCEPT:
3168                 return 0;
3169         default:
3170                 return 1;
3171         }
3172 }
3173
3174
3175 void
3176 ARDOUR_UI::disconnect_from_jack ()
3177 {
3178         if (engine) {
3179                 if( engine->disconnect_from_jack ()) {
3180                         MessageDialog msg (*editor, _("Could not disconnect from JACK"));
3181                         msg.run ();
3182                 }
3183
3184                 update_sample_rate (0);
3185         }
3186 }
3187
3188 void
3189 ARDOUR_UI::reconnect_to_jack ()
3190 {
3191         if (engine) {
3192                 if (engine->reconnect_to_jack ()) {
3193                         MessageDialog msg (*editor,  _("Could not reconnect to JACK"));
3194                         msg.run ();
3195                 }
3196
3197                 update_sample_rate (0);
3198         }
3199 }
3200
3201 void
3202 ARDOUR_UI::use_config ()
3203 {
3204
3205         XMLNode* node = Config->extra_xml (X_("TransportControllables"));
3206         if (node) {
3207                 set_transport_controllable_state (*node);
3208         }
3209 }
3210
3211 void
3212 ARDOUR_UI::update_transport_clocks (nframes_t pos)
3213 {
3214         if (Config->get_primary_clock_delta_edit_cursor()) {
3215                 primary_clock.set (pos, false, editor->get_preferred_edit_position(), 1);
3216         } else {
3217                 primary_clock.set (pos, 0, true);
3218         }
3219
3220         if (Config->get_secondary_clock_delta_edit_cursor()) {
3221                 secondary_clock.set (pos, false, editor->get_preferred_edit_position(), 2);
3222         } else {
3223                 secondary_clock.set (pos);
3224         }
3225
3226         if (big_clock_window) {
3227                 big_clock.set (pos);
3228         }
3229 }
3230
3231 void
3232 ARDOUR_UI::record_state_changed ()
3233 {
3234         ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed));
3235
3236         if (!session || !big_clock_window) {
3237                 /* why bother - the clock isn't visible */
3238                 return;
3239         }
3240
3241         Session::RecordState const r = session->record_status ();
3242         bool const h = session->have_rec_enabled_diskstream ();
3243
3244         if (r == Session::Recording && h)  {
3245                 big_clock.set_widget_name ("BigClockRecording");
3246         } else {
3247                 big_clock.set_widget_name ("BigClockNonRecording");
3248         }
3249 }
3250
3251 bool
3252 ARDOUR_UI::first_idle ()
3253 {
3254         if (session) {
3255                 session->allow_auto_play (true);
3256         }
3257
3258         if (editor) {
3259                 editor->first_idle();
3260         }
3261
3262         Keyboard::set_can_save_keybindings (true);
3263         return false;
3264 }
3265
3266 void
3267 ARDOUR_UI::store_clock_modes ()
3268 {
3269         XMLNode* node = new XMLNode(X_("ClockModes"));
3270
3271         for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
3272                 node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
3273         }
3274
3275         session->add_extra_xml (*node);
3276         session->set_dirty ();
3277 }
3278
3279
3280
3281 ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp)
3282         : Controllable (name), ui (u), type(tp)
3283 {
3284
3285 }
3286
3287 void
3288 ARDOUR_UI::TransportControllable::set_value (float val)
3289 {
3290         if (type == ShuttleControl) {
3291                 double fract;
3292
3293                 if (val == 0.5f) {
3294                         fract = 0.0;
3295                 } else {
3296                         if (val < 0.5f) {
3297                                 fract = -((0.5f - val)/0.5f);
3298                         } else {
3299                                 fract = ((val - 0.5f)/0.5f);
3300                         }
3301                 }
3302
3303                 ui.set_shuttle_fract (fract);
3304                 return;
3305         }
3306
3307         if (val < 0.5f) {
3308                 /* do nothing: these are radio-style actions */
3309                 return;
3310         }
3311
3312         const char *action = 0;
3313
3314         switch (type) {
3315         case Roll:
3316                 action = X_("Roll");
3317                 break;
3318         case Stop:
3319                 action = X_("Stop");
3320                 break;
3321         case GotoStart:
3322                 action = X_("Goto Start");
3323                 break;
3324         case GotoEnd:
3325                 action = X_("Goto End");
3326                 break;
3327         case AutoLoop:
3328                 action = X_("Loop");
3329                 break;
3330         case PlaySelection:
3331                 action = X_("Play Selection");
3332                 break;
3333         case RecordEnable:
3334                 action = X_("Record");
3335                 break;
3336         default:
3337                 break;
3338         }
3339
3340         if (action == 0) {
3341                 return;
3342         }
3343
3344         Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", action);
3345
3346         if (act) {
3347                 act->activate ();
3348         }
3349 }
3350
3351 float
3352 ARDOUR_UI::TransportControllable::get_value (void) const
3353 {
3354         float val = 0.0f;
3355
3356         switch (type) {
3357         case Roll:
3358                 break;
3359         case Stop:
3360                 break;
3361         case GotoStart:
3362                 break;
3363         case GotoEnd:
3364                 break;
3365         case AutoLoop:
3366                 break;
3367         case PlaySelection:
3368                 break;
3369         case RecordEnable:
3370                 break;
3371         case ShuttleControl:
3372                 break;
3373         default:
3374                 break;
3375         }
3376
3377         return val;
3378 }
3379
3380 void
3381 ARDOUR_UI::TransportControllable::set_id (const string& str)
3382 {
3383         _id = str;
3384 }
3385
3386 void
3387 ARDOUR_UI::setup_profile ()
3388 {
3389         if (gdk_screen_width() < 1200) {
3390                 Profile->set_small_screen ();
3391         }
3392
3393
3394         if (getenv ("ARDOUR_SAE")) {
3395                 Profile->set_sae ();
3396                 Profile->set_single_package ();
3397         }
3398 }
3399