gtk2_ardour/ardour_ui.cc

   1 /*
   2     Copyright (C) 1999-2013 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 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #include "gtk2ardour-version.h"
  23 #endif
  24
  25 #include <algorithm>
  26 #include <cmath>
  27 #include <iostream>
  28 #include <cerrno>
  29
  30 #include <stdarg.h>
  31
  32 #ifndef PLATFORM_WINDOWS
  33 #include <sys/resource.h>
  34 #endif
  35
  36 #ifdef __FreeBSD__
  37 #include <sys/types.h>
  38 #include <sys/sysctl.h>
  39 #endif
  40
  41 #include <stdint.h>
  42 #include <fcntl.h>
  43 #include <signal.h>
  44 #include <unistd.h>
  45 #include <time.h>
  46
  47 #include <glib.h>
  48 #include "pbd/gstdio_compat.h"
  49
  50 #include <gtkmm/accelmap.h>
  51 #include <gtkmm/messagedialog.h>
  52 #include <gtkmm/stock.h>
  53 #include <gtkmm/uimanager.h>
  54
  55 #include "pbd/error.h"
  56 #include "pbd/basename.h"
  57 #include "pbd/compose.h"
  58 #include "pbd/convert.h"
  59 #include "pbd/failed_constructor.h"
  60 #include "pbd/file_archive.h"
  61 #include "pbd/enumwriter.h"
  62 #include "pbd/memento_command.h"
  63 #include "pbd/openuri.h"
  64 #include "pbd/stl_delete.h"
  65 #include "pbd/types_convert.h"
  66 #include "pbd/unwind.h"
  67 #include "pbd/file_utils.h"
  68 #include "pbd/localtime_r.h"
  69 #include "pbd/pthread_utils.h"
  70 #include "pbd/replace_all.h"
  71 #include "pbd/scoped_file_descriptor.h"
  72 #include "pbd/xml++.h"
  73
  74 #include "gtkmm2ext/application.h"
  75 #include "gtkmm2ext/bindings.h"
  76 #include "gtkmm2ext/gtk_ui.h"
  77 #include "gtkmm2ext/utils.h"
  78 #include "gtkmm2ext/window_title.h"
  79
  80 #include "widgets/fastmeter.h"
  81 #include "widgets/prompter.h"
  82
  83 #include "ardour/ardour.h"
  84 #include "ardour/audio_backend.h"
  85 #include "ardour/audio_track.h"
  86 #include "ardour/audioengine.h"
  87 #include "ardour/audiofilesource.h"
  88 #include "ardour/automation_watch.h"
  89 #include "ardour/disk_reader.h"
  90 #include "ardour/disk_writer.h"
  91 #include "ardour/filename_extensions.h"
  92 #include "ardour/filesystem_paths.h"
  93 #include "ardour/ltc_file_reader.h"
  94 #include "ardour/midi_track.h"
  95 #include "ardour/port.h"
  96 #include "ardour/plugin_manager.h"
  97 #include "ardour/process_thread.h"
  98 #include "ardour/profile.h"
  99 #include "ardour/recent_sessions.h"
 100 #include "ardour/record_enable_control.h"
 101 #include "ardour/revision.h"
 102 #include "ardour/session_directory.h"
 103 #include "ardour/session_route.h"
 104 #include "ardour/session_state_utils.h"
 105 #include "ardour/session_utils.h"
 106 #include "ardour/source_factory.h"
 107 #include "ardour/slave.h"
 108 #include "ardour/system_exec.h"
 109 #include "ardour/track.h"
 110 #include "ardour/vca_manager.h"
 111 #include "ardour/utils.h"
 112
 113 #include "LuaBridge/LuaBridge.h"
 114
 115 #ifdef WINDOWS_VST_SUPPORT
 116 #include <fst.h>
 117 #endif
 118 #ifdef AUDIOUNIT_SUPPORT
 119 #include "ardour/audio_unit.h"
 120 #endif
 121
 122 // fix for OSX (nsm.h has a check function, AU/Apple defines check)
 123 #ifdef check
 124 #undef check
 125 #endif
 126
 127 #include "temporal/time.h"
 128
 129 typedef uint64_t microseconds_t;
 130
 131 #include "about.h"
 132 #include "editing.h"
 133 #include "enums_convert.h"
 134 #include "actions.h"
 135 #include "add_route_dialog.h"
 136 #include "ambiguous_file_dialog.h"
 137 #include "ardour_ui.h"
 138 #include "audio_clock.h"
 139 #include "audio_region_view.h"
 140 #include "big_clock_window.h"
 141 #include "big_transport_window.h"
 142 #include "bundle_manager.h"
 143 #include "duplicate_routes_dialog.h"
 144 #include "debug.h"
 145 #include "engine_dialog.h"
 146 #include "export_video_dialog.h"
 147 #include "export_video_infobox.h"
 148 #include "gain_meter.h"
 149 #include "global_port_matrix.h"
 150 #include "gui_object.h"
 151 #include "gui_thread.h"
 152 #include "idleometer.h"
 153 #include "keyboard.h"
 154 #include "keyeditor.h"
 155 #include "location_ui.h"
 156 #include "lua_script_manager.h"
 157 #include "luawindow.h"
 158 #include "main_clock.h"
 159 #include "missing_file_dialog.h"
 160 #include "missing_plugin_dialog.h"
 161 #include "mixer_ui.h"
 162 #include "meterbridge.h"
 163 #include "meter_patterns.h"
 164 #include "mouse_cursors.h"
 165 #include "nsm.h"
 166 #include "opts.h"
 167 #include "pingback.h"
 168 #include "processor_box.h"
 169 #include "public_editor.h"
 170 #include "rc_option_editor.h"
 171 #include "route_time_axis.h"
 172 #include "route_params_ui.h"
 173 #include "save_as_dialog.h"
 174 #include "save_template_dialog.h"
 175 #include "script_selector.h"
 176 #include "session_archive_dialog.h"
 177 #include "session_dialog.h"
 178 #include "session_metadata_dialog.h"
 179 #include "session_option_editor.h"
 180 #include "speaker_dialog.h"
 181 #include "splash.h"
 182 #include "startup.h"
 183 #include "template_dialog.h"
 184 #include "time_axis_view_item.h"
 185 #include "time_info_box.h"
 186 #include "timers.h"
 187 #include "utils.h"
 188 #include "utils_videotl.h"
 189 #include "video_server_dialog.h"
 190 #include "add_video_dialog.h"
 191 #include "transcode_video_dialog.h"
 192
 193 #include "pbd/i18n.h"
 194
 195 using namespace ARDOUR;
 196 using namespace ARDOUR_UI_UTILS;
 197 using namespace PBD;
 198 using namespace Gtkmm2ext;
 199 using namespace ArdourWidgets;
 200 using namespace Gtk;
 201 using namespace std;
 202 using namespace Editing;
 203
 204 ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
 205
 206 sigc::signal<void, samplepos_t> ARDOUR_UI::Clock;
 207 sigc::signal<void> ARDOUR_UI::CloseAllDialogs;
 208
 209 static bool
 210 ask_about_configuration_copy (string const & old_dir, string const & new_dir, int version)
 211 {
 212         MessageDialog msg (string_compose (_("%1 %2.x has discovered configuration files from %1 %3.x.\n\n"
 213                                              "Would you like these files to be copied and used for %1 %2.x?\n\n"
 214                                              "(This will require you to restart %1.)"),
 215                                            PROGRAM_NAME, PROGRAM_VERSION, version),
 216                            false, /* no markup */
 217                            Gtk::MESSAGE_INFO,
 218                            Gtk::BUTTONS_YES_NO,
 219                            true /* modal, though it hardly matters since it is the only window */
 220         );
 221
 222         msg.set_default_response (Gtk::RESPONSE_YES);
 223         msg.show_all ();
 224
 225         return (msg.run() == Gtk::RESPONSE_YES);
 226 }
 227
 228 static void
 229 libxml_generic_error_func (void* /* parsing_context*/,
 230                            const char* msg,
 231                            ...)
 232 {
 233         va_list ap;
 234         char buf[2048];
 235
 236         va_start (ap, msg);
 237         vsnprintf (buf, sizeof (buf), msg, ap);
 238         error << buf << endmsg;
 239         va_end (ap);
 240 }
 241
 242 static void
 243 libxml_structured_error_func (void* /* parsing_context*/,
 244                               xmlErrorPtr err)
 245 {
 246         string msg;
 247
 248         if (err->message)
 249                 msg = err->message;
 250
 251         replace_all (msg, "\n", "");
 252
 253         if (!msg.empty()) {
 254                 if (err->file && err->line) {
 255                         error << X_("XML error: ") << msg << " in " << err->file << " at line " << err->line;
 256
 257                         if (err->int2) {
 258                                 error << ':' << err->int2;
 259                         }
 260
 261                         error << endmsg;
 262                 } else {
 263                         error << X_("XML error: ") << msg << endmsg;
 264                 }
 265         }
 266 }
 267
 268
 269 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], const char* localedir)
 270         : Gtkmm2ext::UI (PROGRAM_NAME, X_("gui"), argcp, argvp)
 271         , session_loaded (false)
 272         , session_load_in_progress (false)
 273         , gui_object_state (new GUIObjectState)
 274         , primary_clock   (new MainClock (X_("primary"),   X_("transport"), true ))
 275         , secondary_clock (new MainClock (X_("secondary"), X_("secondary"), false))
 276         , big_clock (new AudioClock (X_("bigclock"), false, "big", true, true, false, false))
 277         , video_timeline(0)
 278         , global_actions (X_("global"))
 279         , ignore_dual_punch (false)
 280         , main_window_visibility (0)
 281         , editor (0)
 282         , mixer (0)
 283         , nsm (0)
 284         , _was_dirty (false)
 285         , _mixer_on_top (false)
 286         , _initial_verbose_plugin_scan (false)
 287         , first_time_engine_run (true)
 288         , secondary_clock_spacer (0)
 289         , auto_input_button (ArdourButton::led_default_elements)
 290         , time_info_box (0)
 291         , auto_return_button (ArdourButton::led_default_elements)
 292         , follow_edits_button (ArdourButton::led_default_elements)
 293         , auditioning_alert_button (_("Audition"))
 294         , solo_alert_button (_("Solo"))
 295         , feedback_alert_button (_("Feedback"))
 296         , error_alert_button ( ArdourButton::just_led_default_elements )
 297         , editor_meter_peak_display()
 298         , editor_meter(0)
 299         , _suspend_editor_meter_callbacks (false)
 300         , _numpad_locate_happening (false)
 301         , _session_is_new (false)
 302         , last_key_press_time (0)
 303         , save_as_dialog (0)
 304         , meterbridge (0)
 305         , luawindow (0)
 306         , rc_option_editor (0)
 307         , speaker_config_window (X_("speaker-config"), _("Speaker Configuration"))
 308         , add_route_dialog (X_("add-routes"), _("Add Tracks/Busses"))
 309         , about (X_("about"), _("About"))
 310         , location_ui (X_("locations"), S_("Ranges|Locations"))
 311         , route_params (X_("inspector"), _("Tracks and Busses"))
 312         , audio_midi_setup (X_("audio-midi-setup"), _("Audio/MIDI Setup"))
 313         , export_video_dialog (X_("video-export"), _("Video Export Dialog"))
 314         , lua_script_window (X_("script-manager"), _("Script Manager"))
 315         , idleometer (X_("idle-o-meter"), _("Idle'o'Meter"))
 316         , session_option_editor (X_("session-options-editor"), _("Properties"), boost::bind (&ARDOUR_UI::create_session_option_editor, this))
 317         , add_video_dialog (X_("add-video"), _("Add Video"), boost::bind (&ARDOUR_UI::create_add_video_dialog, this))
 318         , bundle_manager (X_("bundle-manager"), _("Bundle Manager"), boost::bind (&ARDOUR_UI::create_bundle_manager, this))
 319         , big_clock_window (X_("big-clock"), _("Big Clock"), boost::bind (&ARDOUR_UI::create_big_clock_window, this))
 320         , big_transport_window (X_("big-transport"), _("Transport Controls"), boost::bind (&ARDOUR_UI::create_big_transport_window, this))
 321         , audio_port_matrix (X_("audio-connection-manager"), _("Audio Connections"), boost::bind (&ARDOUR_UI::create_global_port_matrix, this, ARDOUR::DataType::AUDIO))
 322         , midi_port_matrix (X_("midi-connection-manager"), _("MIDI Connections"), boost::bind (&ARDOUR_UI::create_global_port_matrix, this, ARDOUR::DataType::MIDI))
 323         , key_editor (X_("key-editor"), _("Keyboard Shortcuts"), boost::bind (&ARDOUR_UI::create_key_editor, this))
 324         , video_server_process (0)
 325         , splash (0)
 326         , have_configure_timeout (false)
 327         , last_configure_time (0)
 328         , last_peak_grab (0)
 329         , have_disk_speed_dialog_displayed (false)
 330         , _status_bar_visibility (X_("status-bar"))
 331         , _feedback_exists (false)
 332         , _log_not_acknowledged (LogLevelNone)
 333         , duplicate_routes_dialog (0)
 334         , editor_visibility_button (S_("Window|Editor"))
 335         , mixer_visibility_button (S_("Window|Mixer"))
 336         , prefs_visibility_button (S_("Window|Preferences"))
 337 {
 338         Gtkmm2ext::init (localedir);
 339
 340         UIConfiguration::instance().post_gui_init ();
 341
 342         if (ARDOUR::handle_old_configuration_files (boost::bind (ask_about_configuration_copy, _1, _2, _3))) {
 343                 {
 344                         /* "touch" the been-here-before path now that config has been migrated */
 345                         PBD::ScopedFileDescriptor fout (g_open (been_here_before_path ().c_str(), O_CREAT|O_TRUNC|O_RDWR, 0666));
 346                 }
 347                 MessageDialog msg (string_compose (_("Your configuration files were copied. You can now restart %1."), PROGRAM_NAME), true);
 348                 msg.run ();
 349                 /* configuration was modified, exit immediately */
 350                 _exit (0);
 351         }
 352
 353
 354         if (string (VERSIONSTRING).find (".pre") != string::npos) {
 355                 /* check this is not being run from ./ardev etc. */
 356                 if (!running_from_source_tree ()) {
 357                         pre_release_dialog ();
 358                 }
 359         }
 360
 361         if (theArdourUI == 0) {
 362                 theArdourUI = this;
 363         }
 364
 365         /* track main window visibility */
 366
 367         main_window_visibility = new VisibilityTracker (_main_window);
 368
 369         /* stop libxml from spewing to stdout/stderr */
 370
 371         xmlSetGenericErrorFunc (this, libxml_generic_error_func);
 372         xmlSetStructuredErrorFunc (this, libxml_structured_error_func);
 373
 374         UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
 375         boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
 376         UIConfiguration::instance().map_parameters (pc);
 377
 378         transport_ctrl.setup (this);
 379
 380         ARDOUR::DiskWriter::Overrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context());
 381         ARDOUR::DiskReader::Underrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context());
 382
 383         ARDOUR::Session::VersionMismatch.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_format_mismatch, this, _1, _2), gui_context());
 384
 385         /* handle dialog requests */
 386
 387         ARDOUR::Session::Dialog.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
 388
 389         /* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
 390
 391         ARDOUR::Session::AskAboutPendingState.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::pending_state_dialog, this));
 392
 393         /* handle Audio/MIDI setup when session requires it */
 394
 395         ARDOUR::Session::AudioEngineSetupRequired.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::do_audio_midi_setup, this, _1));
 396
 397         /* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
 398
 399         ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
 400
 401         /* handle sr mismatch with a dialog - cross-thread from engine */
 402         ARDOUR::Session::NotifyAboutSampleRateMismatch.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::sr_mismatch_message, this, _1, _2), gui_context ());
 403
 404         /* handle requests to quit (coming from JACK session) */
 405
 406         ARDOUR::Session::Quit.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::finish, this), gui_context ());
 407
 408         /* tell the user about feedback */
 409
 410         ARDOUR::Session::FeedbackDetected.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::feedback_detected, this), gui_context ());
 411         ARDOUR::Session::SuccessfulGraphSort.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::successful_graph_sort, this), gui_context ());
 412
 413         /* handle requests to deal with missing files */
 414
 415         ARDOUR::Session::MissingFile.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::missing_file, this, _1, _2, _3));
 416
 417         /* and ambiguous files */
 418
 419         ARDOUR::FileSource::AmbiguousFileName.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::ambiguous_file, this, _1, _2));
 420
 421         /* also plugin scan messages */
 422         ARDOUR::PluginScanMessage.connect (forever_connections, MISSING_INVALIDATOR, boost::bind(&ARDOUR_UI::plugin_scan_dialog, this, _1, _2, _3), gui_context());
 423         ARDOUR::PluginScanTimeout.connect (forever_connections, MISSING_INVALIDATOR, boost::bind(&ARDOUR_UI::plugin_scan_timeout, this, _1), gui_context());
 424
 425         ARDOUR::GUIIdle.connect (forever_connections, MISSING_INVALIDATOR, boost::bind(&ARDOUR_UI::gui_idle_handler, this), gui_context());
 426
 427         Config->ParameterChanged.connect ( forever_connections, MISSING_INVALIDATOR, boost::bind(&ARDOUR_UI::set_flat_buttons, this), gui_context() );
 428         set_flat_buttons();
 429
 430         /* lets get this party started */
 431
 432         setup_gtk_ardour_enums ();
 433         setup_profile ();
 434
 435         SessionEvent::create_per_thread_pool ("GUI", 4096);
 436
 437         /* we like keyboards */
 438
 439         keyboard = new ArdourKeyboard(*this);
 440
 441         XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
 442         if (node) {
 443                 keyboard->set_state (*node, Stateful::loading_state_version);
 444         }
 445
 446         UIConfiguration::instance().reset_dpi ();
 447
 448         TimeAxisViewItem::set_constant_heights ();
 449
 450         /* Set this up so that our window proxies can register actions */
 451
 452         ActionManager::init ();
 453
 454         /* The following must happen after ARDOUR::init() so that Config is set up */
 455
 456         const XMLNode* ui_xml = Config->extra_xml (X_("UI"));
 457
 458         if (ui_xml) {
 459                 key_editor.set_state (*ui_xml, 0);
 460                 session_option_editor.set_state (*ui_xml, 0);
 461                 speaker_config_window.set_state (*ui_xml, 0);
 462                 about.set_state (*ui_xml, 0);
 463                 add_route_dialog.set_state (*ui_xml, 0);
 464                 add_video_dialog.set_state (*ui_xml, 0);
 465                 route_params.set_state (*ui_xml, 0);
 466                 bundle_manager.set_state (*ui_xml, 0);
 467                 location_ui.set_state (*ui_xml, 0);
 468                 big_clock_window.set_state (*ui_xml, 0);
 469                 big_transport_window.set_state (*ui_xml, 0);
 470                 audio_port_matrix.set_state (*ui_xml, 0);
 471                 midi_port_matrix.set_state (*ui_xml, 0);
 472                 export_video_dialog.set_state (*ui_xml, 0);
 473                 lua_script_window.set_state (*ui_xml, 0);
 474                 idleometer.set_state (*ui_xml, 0);
 475         }
 476
 477         /* Separate windows */
 478
 479         WM::Manager::instance().register_window (&key_editor);
 480         WM::Manager::instance().register_window (&session_option_editor);
 481         WM::Manager::instance().register_window (&speaker_config_window);
 482         WM::Manager::instance().register_window (&about);
 483         WM::Manager::instance().register_window (&add_route_dialog);
 484         WM::Manager::instance().register_window (&add_video_dialog);
 485         WM::Manager::instance().register_window (&route_params);
 486         WM::Manager::instance().register_window (&audio_midi_setup);
 487         WM::Manager::instance().register_window (&export_video_dialog);
 488         WM::Manager::instance().register_window (&lua_script_window);
 489         WM::Manager::instance().register_window (&bundle_manager);
 490         WM::Manager::instance().register_window (&location_ui);
 491         WM::Manager::instance().register_window (&big_clock_window);
 492         WM::Manager::instance().register_window (&big_transport_window);
 493         WM::Manager::instance().register_window (&audio_port_matrix);
 494         WM::Manager::instance().register_window (&midi_port_matrix);
 495         WM::Manager::instance().register_window (&idleometer);
 496
 497         /* do not retain position for add route dialog */
 498         add_route_dialog.set_state_mask (WindowProxy::Size);
 499
 500         /* Trigger setting up the color scheme and loading the GTK RC file */
 501
 502         UIConfiguration::instance().load_rc_file (false);
 503
 504         _process_thread = new ProcessThread ();
 505         _process_thread->init ();
 506
 507         UIConfiguration::instance().DPIReset.connect (sigc::mem_fun (*this, &ARDOUR_UI::resize_text_widgets));
 508
 509         attach_to_engine ();
 510 }
 511
 512 void
 513 ARDOUR_UI::pre_release_dialog ()
 514 {
 515         ArdourDialog d (_("Pre-Release Warning"), true, false);
 516         d.add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
 517
 518         Label* label = manage (new Label);
 519         label->set_markup (string_compose (_("<b>Welcome to this pre-release build of %1 %2</b>\n\n\
 520 There are still several issues and bugs to be worked on,\n\
 521 as well as general workflow improvements, before this can be considered\n\
 522 release software. So, a few guidelines:\n\
 523 \n\
 524 1) Please do <b>NOT</b> use this software with the expectation that it is stable or reliable\n\
 525    though it may be so, depending on your workflow.\n\
 526 2) Please wait for a helpful writeup of new features.\n\
 527 3) <b>Please do NOT use the forums at ardour.org to report issues</b>.\n\
 528 4) Please <b>DO</b> use the bugtracker at http://tracker.ardour.org/ to report issues\n\
 529    making sure to note the product version number as 6.0-pre.\n\
 530 5) Please <b>DO</b> use the ardour-users mailing list to discuss ideas and pass on comments.\n\
 531 6) Please <b>DO</b> join us on IRC for real time discussions about %1 %2. You\n\
 532    can get there directly from within the program via the Help->Chat menu option.\n\
 533 \n\
 534 Full information on all the above can be found on the support page at\n\
 535 \n\
 536                 http://ardour.org/support\n\
 537 "), PROGRAM_NAME, VERSIONSTRING));
 538
 539         d.get_vbox()->set_border_width (12);
 540         d.get_vbox()->pack_start (*label, false, false, 12);
 541         d.get_vbox()->show_all ();
 542
 543         d.run ();
 544 }
 545
 546 GlobalPortMatrixWindow*
 547 ARDOUR_UI::create_global_port_matrix (ARDOUR::DataType type)
 548 {
 549         if (!_session) {
 550                 return 0;
 551         }
 552         return new GlobalPortMatrixWindow (_session, type);
 553 }
 554
 555 void
 556 ARDOUR_UI::attach_to_engine ()
 557 {
 558         AudioEngine::instance()->Running.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_running, this), gui_context());
 559         ARDOUR::Port::set_connecting_blocked (ARDOUR_COMMAND_LINE::no_connect_ports);
 560 }
 561
 562 void
 563 ARDOUR_UI::engine_stopped ()
 564 {
 565         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_stopped)
 566         ActionManager::set_sensitive (ActionManager::engine_sensitive_actions, false);
 567         ActionManager::set_sensitive (ActionManager::engine_opposite_sensitive_actions, true);
 568         update_sample_rate (0);
 569         update_cpu_load ();
 570 }
 571
 572 void
 573 ARDOUR_UI::engine_running ()
 574 {
 575         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_running)
 576         if (first_time_engine_run) {
 577                 post_engine();
 578                 first_time_engine_run = false;
 579         }
 580
 581         if (_session) {
 582                 _session->reset_xrun_count ();
 583         }
 584         update_disk_space ();
 585         update_cpu_load ();
 586         update_xrun_count ();
 587         update_sample_rate (AudioEngine::instance()->sample_rate());
 588         update_timecode_format ();
 589         update_peak_thread_work ();
 590         ActionManager::set_sensitive (ActionManager::engine_sensitive_actions, true);
 591         ActionManager::set_sensitive (ActionManager::engine_opposite_sensitive_actions, false);
 592 }
 593
 594 void
 595 ARDOUR_UI::engine_halted (const char* reason, bool free_reason)
 596 {
 597         if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) {
 598                 /* we can't rely on the original string continuing to exist when we are called
 599                    again in the GUI thread, so make a copy and note that we need to
 600                    free it later.
 601                 */
 602                 char *copy = strdup (reason);
 603                 Gtkmm2ext::UI::instance()->call_slot (MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_halted, this, copy, true));
 604                 return;
 605         }
 606
 607         ActionManager::set_sensitive (ActionManager::engine_sensitive_actions, false);
 608         ActionManager::set_sensitive (ActionManager::engine_opposite_sensitive_actions, true);
 609
 610         update_sample_rate (0);
 611
 612         string msgstr;
 613
 614         /* if the reason is a non-empty string, it means that the backend was shutdown
 615            rather than just Ardour.
 616         */
 617
 618         if (strlen (reason)) {
 619                 msgstr = string_compose (_("The audio backend was shutdown because:\n\n%1"), reason);
 620         } else {
 621                 msgstr = string_compose (_("\
 622 The audio backend has either been shutdown or it\n\
 623 disconnected %1 because %1\n\
 624 was not fast enough. Try to restart\n\
 625 the audio backend and save the session."), PROGRAM_NAME);
 626         }
 627
 628         MessageDialog msg (_main_window, msgstr);
 629         pop_back_splash (msg);
 630         msg.run ();
 631
 632         if (free_reason) {
 633                 free (const_cast<char*> (reason));
 634         }
 635 }
 636
 637 void
 638 ARDOUR_UI::post_engine ()
 639 {
 640         /* Things to be done once (and once ONLY) after we have a backend running in the AudioEngine
 641          */
 642 #ifdef AUDIOUNIT_SUPPORT
 643         std::string au_msg;
 644         if (AUPluginInfo::au_get_crashlog(au_msg)) {
 645                 popup_error(_("Audio Unit Plugin Scan Failed. Automatic AU scanning has been disabled. Please see the log window for further details."));
 646                 error << _("Audio Unit Plugin Scan Failed:") << endmsg;
 647                 info << au_msg << endmsg;
 648         }
 649 #endif
 650
 651         ARDOUR::init_post_engine ();
 652
 653         /* connect to important signals */
 654
 655         AudioEngine::instance()->Stopped.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context());
 656         AudioEngine::instance()->SampleRateChanged.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
 657         AudioEngine::instance()->BufferSizeChanged.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
 658         AudioEngine::instance()->Halted.connect_same_thread (halt_connection, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
 659         AudioEngine::instance()->BecameSilent.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::audioengine_became_silent, this), gui_context());
 660
 661         if (setup_windows ()) {
 662                 throw failed_constructor ();
 663         }
 664
 665         transport_ctrl.map_actions ();
 666
 667         /* Do this after setup_windows (), as that's when the _status_bar_visibility is created */
 668         XMLNode* n = Config->extra_xml (X_("UI"));
 669         if (n) {
 670                 _status_bar_visibility.set_state (*n);
 671         }
 672
 673         check_memory_locking();
 674
 675         /* this is the first point at which all the possible actions are
 676          * available, because some of the available actions are dependent on
 677          * aspects of the engine/backend.
 678          */
 679
 680         if (ARDOUR_COMMAND_LINE::show_key_actions) {
 681                 stringstream sstr;
 682                 Bindings::save_all_bindings_as_html (sstr);
 683
 684                 if (sstr.str().empty()) {
 685                         return;
 686                 }
 687                 gchar* file_name;
 688                 GError *err = NULL;
 689                 gint fd;
 690
 691                 if ((fd = g_file_open_tmp ("akprintXXXXXX.html", &file_name, &err)) < 0) {
 692                         if (err) {
 693                                 error << string_compose (_("Could not open temporary file to print bindings (%1)"), err->message) << endmsg;
 694                                 g_error_free (err);
 695                         }
 696                         return;
 697                 }
 698
 699 #ifdef PLATFORM_WINDOWS
 700                 ::close (fd);
 701 #endif
 702
 703                 err = NULL;
 704
 705                 if (!g_file_set_contents (file_name, sstr.str().c_str(), sstr.str().size(), &err)) {
 706 #ifndef PLATFORM_WINDOWS
 707                         ::close (fd);
 708 #endif
 709                         g_unlink (file_name);
 710                         if (err) {
 711                                 error << string_compose (_("Could not save bindings to file (%1)"), err->message) << endmsg;
 712                                 g_error_free (err);
 713                         }
 714                         return;
 715                 }
 716
 717 #ifndef PLATFORM_WINDOWS
 718                 ::close (fd);
 719 #endif
 720
 721                 PBD::open_uri (string_compose ("file:///%1", file_name));
 722
 723                 halt_connection.disconnect ();
 724                 AudioEngine::instance()->stop ();
 725                 exit (0);
 726
 727         }
 728
 729         if (ARDOUR_COMMAND_LINE::show_actions) {
 730
 731
 732                 vector<string> paths;
 733                 vector<string> labels;
 734                 vector<string> tooltips;
 735                 vector<string> keys;
 736                 vector<Glib::RefPtr<Gtk::Action> > actions;
 737                 string ver_in = revision;
 738                 string ver = ver_in.substr(0, ver_in.find("-"));
 739
 740                 stringstream output;
 741                 output << "\n<h2>Menu actions</h2>" << endl;
 742                 output << "<p>\n  Every single menu item in " << PROGRAM_NAME << "'s GUI is accessible by control" << endl;
 743                 output << "  surfaces or scripts.\n</p>\n" << endl;
 744                 output << "<p>\n  The list below shows all available values of <em>action-name</em> as of" << endl;
 745                 output << "  " << PROGRAM_NAME << " " << ver << ". You can get the current list at any" << endl;
 746                 output << "  time by running " << PROGRAM_NAME << " with the -A flag.\n</p>\n" << endl;
 747                 output << "<table class=\"dl\">\n  <thead>" << endl;
 748                 output << "      <tr><th>Action Name</th><th>Menu Name</th></tr>" << endl;
 749                 output << "  </thead>\n  <tbody>" << endl;
 750
 751                 Gtkmm2ext::ActionMap::get_all_actions (paths, labels, tooltips, keys, actions);
 752
 753                 vector<string>::iterator p;
 754                 vector<string>::iterator l;
 755
 756                 for (p = paths.begin(), l = labels.begin(); p != paths.end(); ++p, ++l) {
 757                         output << "     <tr><th><kbd class=\"osc\">" << (*p).substr (10, string::npos);
 758                         output << "</kbd></th><td>" << *l << "</td></tr>" << endl;
 759                 }
 760                 output << "  </tbody>\n  </table>" << endl;
 761
 762                 // output this mess to a browser for easiest X-platform use
 763                 // it is not pretty HTML, but it works and it's main purpose
 764                 // is to create raw html to fit in Ardour's manual with no editing
 765                 gchar* file_name;
 766                 GError *err = NULL;
 767                 gint fd;
 768
 769                 if ((fd = g_file_open_tmp ("list-of-menu-actionsXXXXXX.html", &file_name, &err)) < 0) {
 770                         if (err) {
 771                                 error << string_compose (_("Could not open temporary file to print bindings (%1)"), err->message) << endmsg;
 772                                 g_error_free (err);
 773                         }
 774                         return;
 775                 }
 776
 777 #ifdef PLATFORM_WINDOWS
 778                 ::close (fd);
 779 #endif
 780
 781                 err = NULL;
 782
 783                 if (!g_file_set_contents (file_name, output.str().c_str(), output.str().size(), &err)) {
 784 #ifndef PLATFORM_WINDOWS
 785                         ::close (fd);
 786 #endif
 787                         g_unlink (file_name);
 788                         if (err) {
 789                                 error << string_compose (_("Could not save bindings to file (%1)"), err->message) << endmsg;
 790                                 g_error_free (err);
 791                         }
 792                         return;
 793                 }
 794
 795 #ifndef PLATFORM_WINDOWS
 796                 ::close (fd);
 797 #endif
 798
 799                 PBD::open_uri (string_compose ("file:///%1", file_name));
 800
 801                 halt_connection.disconnect ();
 802                 AudioEngine::instance()->stop ();
 803                 exit (0);
 804         }
 805
 806         /* this being a GUI and all, we want peakfiles */
 807
 808         AudioFileSource::set_build_peakfiles (true);
 809         AudioFileSource::set_build_missing_peakfiles (true);
 810
 811         /* set default clock modes */
 812
 813         primary_clock->set_mode (AudioClock::Timecode);
 814         secondary_clock->set_mode (AudioClock::BBT);
 815
 816         /* start the time-of-day-clock */
 817
 818 #ifndef __APPLE__
 819         /* OS X provides a nearly-always visible wallclock, so don't be stupid */
 820         update_wall_clock ();
 821         Glib::signal_timeout().connect_seconds (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 1);
 822 #endif
 823
 824         {
 825                 DisplaySuspender ds;
 826                 Config->ParameterChanged.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
 827                 boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
 828                 Config->map_parameters (pc);
 829
 830                 UIConfiguration::instance().map_parameters (pc);
 831         }
 832 }
 833
 834 ARDOUR_UI::~ARDOUR_UI ()
 835 {
 836         UIConfiguration::instance().save_state();
 837
 838         stop_video_server();
 839
 840         if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
 841                 // don't bother at 'real' exit. the OS cleans up for us.
 842                 delete big_clock; big_clock = 0;
 843                 delete primary_clock; primary_clock = 0;
 844                 delete secondary_clock; secondary_clock = 0;
 845                 delete _process_thread; _process_thread = 0;
 846                 delete time_info_box; time_info_box = 0;
 847                 delete meterbridge; meterbridge = 0;
 848                 delete luawindow; luawindow = 0;
 849                 delete editor; editor = 0;
 850                 delete mixer; mixer = 0;
 851                 delete rc_option_editor; rc_option_editor = 0; // failed to wrap object warning
 852                 delete nsm; nsm = 0;
 853                 delete gui_object_state; gui_object_state = 0;
 854                 delete main_window_visibility;
 855                 FastMeter::flush_pattern_cache ();
 856                 ArdourFader::flush_pattern_cache ();
 857         }
 858
 859 #ifndef NDEBUG
 860         /* Small trick to flush main-thread event pool.
 861          * Other thread-pools are destroyed at pthread_exit(),
 862          * but tmain thread termination is too late to trigger Pool::~Pool()
 863          */
 864         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Clear, SessionEvent::Immediate, 0, 0); // get the pool reference, values don't matter since the event is never queued.
 865         delete ev->event_pool();
 866 #endif
 867 }
 868
 869 void
 870 ARDOUR_UI::pop_back_splash (Gtk::Window& win)
 871 {
 872         if (Splash::instance()) {
 873                 Splash::instance()->pop_back_for (win);
 874         }
 875 }
 876
 877 gint
 878 ARDOUR_UI::configure_timeout ()
 879 {
 880         if (last_configure_time == 0) {
 881                 /* no configure events yet */
 882                 return true;
 883         }
 884
 885         /* force a gap of 0.5 seconds since the last configure event
 886          */
 887
 888         if (get_microseconds() - last_configure_time < 500000) {
 889                 return true;
 890         } else {
 891                 have_configure_timeout = false;
 892                 save_ardour_state ();
 893                 return false;
 894         }
 895 }
 896
 897 gboolean
 898 ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
 899 {
 900         if (have_configure_timeout) {
 901                 last_configure_time = get_microseconds();
 902         } else {
 903                 Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
 904                 have_configure_timeout = true;
 905         }
 906
 907         return FALSE;
 908 }
 909
 910 void
 911 ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
 912 {
 913         std::string str;
 914
 915         if (node.get_property ("roll", str)){
 916                 roll_controllable->set_id (str);
 917         }
 918         if (node.get_property ("stop", str)) {
 919                 stop_controllable->set_id (str);
 920         }
 921         if (node.get_property ("goto-start", str)) {
 922                 goto_start_controllable->set_id (str);
 923         }
 924         if (node.get_property ("goto-end", str)) {
 925                 goto_end_controllable->set_id (str);
 926         }
 927         if (node.get_property ("auto-loop", str)) {
 928                 auto_loop_controllable->set_id (str);
 929         }
 930         if (node.get_property ("play-selection", str)) {
 931                 play_selection_controllable->set_id (str);
 932         }
 933         if (node.get_property ("rec", str)) {
 934                 rec_controllable->set_id (str);
 935         }
 936         if (node.get_property ("shuttle", str)) {
 937                 shuttle_box.controllable()->set_id (str);
 938         }
 939 }
 940
 941 XMLNode&
 942 ARDOUR_UI::get_transport_controllable_state ()
 943 {
 944         XMLNode* node = new XMLNode(X_("TransportControllables"));
 945
 946         node->set_property (X_("roll"), roll_controllable->id());
 947         node->set_property (X_("stop"), stop_controllable->id());
 948         node->set_property (X_("goto-start"), goto_start_controllable->id());
 949         node->set_property (X_("goto-end"), goto_end_controllable->id());
 950         node->set_property (X_("auto-loop"), auto_loop_controllable->id());
 951         node->set_property (X_("play-selection"), play_selection_controllable->id());
 952         node->set_property (X_("rec"), rec_controllable->id());
 953         node->set_property (X_("shuttle"), shuttle_box.controllable()->id());
 954
 955         return *node;
 956 }
 957
 958 void
 959 ARDOUR_UI::save_session_at_its_request (std::string snapshot_name)
 960 {
 961         if (_session) {
 962                 _session->save_state (snapshot_name);
 963         }
 964 }
 965
 966 gint
 967 ARDOUR_UI::autosave_session ()
 968 {
 969         if (g_main_depth() > 1) {
 970                 /* inside a recursive main loop,
 971                    give up because we may not be able to
 972                    take a lock.
 973                 */
 974                 return 1;
 975         }
 976
 977         if (!Config->get_periodic_safety_backups()) {
 978                 return 1;
 979         }
 980
 981         if (_session) {
 982                 _session->maybe_write_autosave();
 983         }
 984
 985         return 1;
 986 }
 987
 988 void
 989 ARDOUR_UI::session_dirty_changed ()
 990 {
 991         update_autosave ();
 992         update_title ();
 993 }
 994
 995 void
 996 ARDOUR_UI::update_autosave ()
 997 {
 998         if (_session && _session->dirty()) {
 999                 if (_autosave_connection.connected()) {
1000                         _autosave_connection.disconnect();
1001                 }
1002
1003                 _autosave_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &ARDOUR_UI::autosave_session),
1004                                 Config->get_periodic_safety_backup_interval() * 1000);
1005
1006         } else {
1007                 if (_autosave_connection.connected()) {
1008                         _autosave_connection.disconnect();
1009                 }
1010         }
1011 }
1012
1013 void
1014 ARDOUR_UI::check_announcements ()
1015 {
1016 #ifdef PHONE_HOME
1017         string _annc_filename;
1018
1019 #ifdef __APPLE__
1020         _annc_filename = PROGRAM_NAME "_announcements_osx_";
1021 #elif defined PLATFORM_WINDOWS
1022         _annc_filename = PROGRAM_NAME "_announcements_windows_";
1023 #else
1024         _annc_filename = PROGRAM_NAME "_announcements_linux_";
1025 #endif
1026         _annc_filename.append (VERSIONSTRING);
1027
1028         _announce_string = "";
1029
1030         std::string path = Glib::build_filename (user_config_directory(), _annc_filename);
1031         FILE* fin = g_fopen (path.c_str(), "rb");
1032         if (fin) {
1033                 while (!feof (fin)) {
1034                         char tmp[1024];
1035                         size_t len;
1036                         if ((len = fread (tmp, sizeof(char), 1024, fin)) == 0 || ferror (fin)) {
1037                                 break;
1038                         }
1039                         _announce_string.append (tmp, len);
1040                 }
1041                 fclose (fin);
1042         }
1043
1044         pingback (VERSIONSTRING, path);
1045 #endif
1046 }
1047
1048 static bool
1049 _hide_splash (gpointer arg)
1050 {
1051         ((ARDOUR_UI*)arg)->hide_splash();
1052         return false;
1053 }
1054
1055 int
1056 ARDOUR_UI::starting ()
1057 {
1058         Application* app = Application::instance ();
1059         const char *nsm_url;
1060         bool brand_new_user = ArdourStartup::required ();
1061
1062         app->ShouldQuit.connect (sigc::mem_fun (*this, &ARDOUR_UI::queue_finish));
1063         app->ShouldLoad.connect (sigc::mem_fun (*this, &ARDOUR_UI::load_from_application_api));
1064
1065         if (ARDOUR_COMMAND_LINE::check_announcements) {
1066                 check_announcements ();
1067         }
1068
1069         app->ready ();
1070
1071         /* we need to create this early because it may need to set the
1072          *  audio backend end up.
1073          */
1074
1075         try {
1076                 audio_midi_setup.get (true);
1077         } catch (...) {
1078                 std::cerr << "audio-midi engine setup failed."<< std::endl;
1079                 return -1;
1080         }
1081
1082         if ((nsm_url = g_getenv ("NSM_URL")) != 0) {
1083                 nsm = new NSM_Client;
1084                 if (!nsm->init (nsm_url)) {
1085                         /* the ardour executable may have different names:
1086                          *
1087                          * waf's obj.target for distro versions: eg ardour4, ardourvst4
1088                          * Ardour4, Mixbus3 for bundled versions + full path on OSX & windows
1089                          * argv[0] does not apply since we need the wrapper-script (not the binary itself)
1090                          *
1091                          * The wrapper startup script should set the environment variable 'ARDOUR_SELF'
1092                          */
1093                         const char *process_name = g_getenv ("ARDOUR_SELF");
1094                         nsm->announce (PROGRAM_NAME, ":dirty:", process_name ? process_name : "ardour6");
1095
1096                         unsigned int i = 0;
1097                         // wait for announce reply from nsm server
1098                         for ( i = 0; i < 5000; ++i) {
1099                                 nsm->check ();
1100
1101                                 Glib::usleep (i);
1102                                 if (nsm->is_active()) {
1103                                         break;
1104                                 }
1105                         }
1106                         if (i == 5000) {
1107                                 error << _("NSM server did not announce itself") << endmsg;
1108                                 return -1;
1109                         }
1110                         // wait for open command from nsm server
1111                         for ( i = 0; i < 5000; ++i) {
1112                                 nsm->check ();
1113                                 Glib::usleep (1000);
1114                                 if (nsm->client_id ()) {
1115                                         break;
1116                                 }
1117                         }
1118
1119                         if (i == 5000) {
1120                                 error << _("NSM: no client ID provided") << endmsg;
1121                                 return -1;
1122                         }
1123
1124                         if (_session && nsm) {
1125                                 _session->set_nsm_state( nsm->is_active() );
1126                         } else {
1127                                 error << _("NSM: no session created") << endmsg;
1128                                 return -1;
1129                         }
1130
1131                         // nsm requires these actions disabled
1132                         vector<string> action_names;
1133                         action_names.push_back("SaveAs");
1134                         action_names.push_back("Rename");
1135                         action_names.push_back("New");
1136                         action_names.push_back("Open");
1137                         action_names.push_back("Recent");
1138                         action_names.push_back("Close");
1139
1140                         for (vector<string>::const_iterator n = action_names.begin(); n != action_names.end(); ++n) {
1141                                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), (*n).c_str());
1142                                 if (act) {
1143                                         act->set_sensitive (false);
1144                                 }
1145                         }
1146
1147                 } else {
1148                         delete nsm;
1149                         nsm = 0;
1150                         error << _("NSM: initialization failed") << endmsg;
1151                         return -1;
1152                 }
1153
1154         } else  {
1155
1156                 if (brand_new_user) {
1157                         _initial_verbose_plugin_scan = true;
1158                         ArdourStartup s;
1159                         s.present ();
1160                         main().run();
1161                         s.hide ();
1162                         _initial_verbose_plugin_scan = false;
1163                         switch (s.response ()) {
1164                         case Gtk::RESPONSE_OK:
1165                                 break;
1166                         default:
1167                                 return -1;
1168                         }
1169                 }
1170
1171                 // TODO: maybe IFF brand_new_user
1172                 if (ARDOUR::Profile->get_mixbus () && Config->get_copy_demo_sessions ()) {
1173                         std::string dspd (Config->get_default_session_parent_dir());
1174                         Searchpath ds (ARDOUR::ardour_data_search_path());
1175                         ds.add_subdirectory_to_paths ("sessions");
1176                         vector<string> demos;
1177                         find_files_matching_pattern (demos, ds, ARDOUR::session_archive_suffix);
1178
1179                         ARDOUR::RecentSessions rs;
1180                         ARDOUR::read_recent_sessions (rs);
1181
1182                         for (vector<string>::iterator i = demos.begin(); i != demos.end (); ++i) {
1183                                 /* "demo-session" must be inside "demo-session.<session_archive_suffix>" */
1184                                 std::string name = basename_nosuffix (basename_nosuffix (*i));
1185                                 std::string path = Glib::build_filename (dspd, name);
1186                                 /* skip if session-dir already exists */
1187                                 if (Glib::file_test(path.c_str(), Glib::FILE_TEST_IS_DIR)) {
1188                                         continue;
1189                                 }
1190                                 /* skip sessions that are already in 'recent'.
1191                                  * eg. a new user changed <session-default-dir> shorly after installation
1192                                  */
1193                                 for (ARDOUR::RecentSessions::iterator r = rs.begin(); r != rs.end(); ++r) {
1194                                         if ((*r).first == name) {
1195                                                 continue;
1196                                         }
1197                                 }
1198                                 try {
1199                                         PBD::FileArchive ar (*i);
1200                                         if (0 == ar.inflate (dspd)) {
1201                                                 store_recent_sessions (name, path);
1202                                                 info << string_compose (_("Copied Demo Session %1."), name) << endmsg;
1203                                         }
1204                                 } catch (...) {}
1205                         }
1206                 }
1207
1208 #ifdef NO_PLUGIN_STATE
1209
1210                 ARDOUR::RecentSessions rs;
1211                 ARDOUR::read_recent_sessions (rs);
1212
1213                 string path = Glib::build_filename (user_config_directory(), ".iknowaboutfreeversion");
1214
1215                 if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS) && !rs.empty()) {
1216
1217                         /* already used Ardour, have sessions ... warn about plugin state */
1218
1219                         ArdourDialog d (_("Free/Demo Version Warning"), true);
1220                         Label l;
1221                         Button b (string_compose (_("Subscribe and support development of %1"), PROGRAM_NAME));
1222                         CheckButton c (_("Don't warn me about this again"));
1223
1224                         l.set_markup (string_compose (_("<span weight=\"bold\" size=\"large\">%1</span>\n\n<b>%2</b>\n\n<i>%3</i>\n\n%4"),
1225                                                       string_compose (_("This is a free/demo version of %1"), PROGRAM_NAME),
1226                                                       _("It will not restore OR save any plugin settings"),
1227                                                       _("If you load an existing session with plugin settings\n"
1228                                                         "they will not be used and will be lost."),
1229                                                       _("To get full access to updates without this limitation\n"
1230                                                         "consider becoming a subscriber for a low cost every month.")));
1231                         l.set_justify (JUSTIFY_CENTER);
1232
1233                         b.signal_clicked().connect (mem_fun(*this, &ARDOUR_UI::launch_subscribe));
1234
1235                         d.get_vbox()->pack_start (l, true, true);
1236                         d.get_vbox()->pack_start (b, false, false, 12);
1237                         d.get_vbox()->pack_start (c, false, false, 12);
1238
1239                         d.add_button (_("Quit now"), RESPONSE_CANCEL);
1240                         d.add_button (string_compose (_("Continue using %1"), PROGRAM_NAME), RESPONSE_OK);
1241
1242                         d.show_all ();
1243
1244                         c.signal_toggled().connect (sigc::hide_return (sigc::bind (sigc::ptr_fun (toggle_file_existence), path)));
1245
1246                         if (d.run () != RESPONSE_OK) {
1247                                 _exit (0);
1248                         }
1249                 }
1250 #endif
1251
1252                 /* go get a session */
1253
1254                 const bool new_session_required = (ARDOUR_COMMAND_LINE::new_session || brand_new_user);
1255
1256                 if (get_session_parameters (false, new_session_required, ARDOUR_COMMAND_LINE::load_template)) {
1257                         std::cerr << "Cannot get session parameters."<< std::endl;
1258                         return -1;
1259                 }
1260         }
1261
1262         use_config ();
1263
1264         WM::Manager::instance().show_visible ();
1265
1266         /* We have to do this here since goto_editor_window() ends up calling show_all() on the
1267          * editor window, and we may want stuff to be hidden.
1268          */
1269         _status_bar_visibility.update ();
1270
1271         BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
1272
1273         /* all other dialogs are created conditionally */
1274
1275         return 0;
1276 }
1277
1278 void
1279 ARDOUR_UI::check_memory_locking ()
1280 {
1281 #if defined(__APPLE__) || defined(PLATFORM_WINDOWS)
1282         /* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
1283         return;
1284 #else // !__APPLE__
1285
1286         XMLNode* memory_warning_node = Config->instant_xml (X_("no-memory-warning"));
1287
1288         if (AudioEngine::instance()->is_realtime() && memory_warning_node == 0) {
1289
1290                 struct rlimit limits;
1291                 int64_t ram;
1292                 long pages, page_size;
1293 #ifdef __FreeBSD__
1294                 size_t pages_len=sizeof(pages);
1295                 if ((page_size = getpagesize()) < 0 ||
1296                                 sysctlbyname("hw.availpages", &pages, &pages_len, NULL, 0))
1297 #else
1298                 if ((page_size = sysconf (_SC_PAGESIZE)) < 0 ||(pages = sysconf (_SC_PHYS_PAGES)) < 0)
1299 #endif
1300                 {
1301                         ram = 0;
1302                 } else {
1303                         ram = (int64_t) pages * (int64_t) page_size;
1304                 }
1305
1306                 if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
1307                         return;
1308                 }
1309
1310                 if (limits.rlim_cur != RLIM_INFINITY) {
1311
1312                         if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
1313
1314                                 MessageDialog msg (
1315                                         string_compose (
1316                                                 _("WARNING: Your system has a limit for maximum amount of locked memory. "
1317                                                   "This might cause %1 to run out of memory before your system "
1318                                                   "runs out of memory. \n\n"
1319                                                   "You can view the memory limit with 'ulimit -l', "
1320                                                   "and it is normally controlled by %2"),
1321                                                 PROGRAM_NAME,
1322 #ifdef __FreeBSD__
1323                                                 X_("/etc/login.conf")
1324 #else
1325                                                 X_(" /etc/security/limits.conf")
1326 #endif
1327                                         ).c_str());
1328
1329                                 msg.set_default_response (RESPONSE_OK);
1330
1331                                 VBox* vbox = msg.get_vbox();
1332                                 HBox hbox;
1333                                 CheckButton cb (_("Do not show this window again"));
1334                                 hbox.pack_start (cb, true, false);
1335                                 vbox->pack_start (hbox);
1336                                 cb.show();
1337                                 vbox->show();
1338                                 hbox.show ();
1339
1340                                 pop_back_splash (msg);
1341
1342                                 msg.run ();
1343
1344                                 if (cb.get_active()) {
1345                                         XMLNode node (X_("no-memory-warning"));
1346                                         Config->add_instant_xml (node);
1347                                 }
1348                         }
1349                 }
1350         }
1351 #endif // !__APPLE__
1352 }
1353
1354
1355 void
1356 ARDOUR_UI::queue_finish ()
1357 {
1358         Glib::signal_idle().connect (mem_fun (*this, &ARDOUR_UI::idle_finish));
1359 }
1360
1361 bool
1362 ARDOUR_UI::idle_finish ()
1363 {
1364         finish ();
1365         return false; /* do not call again */
1366 }
1367
1368 void
1369 ARDOUR_UI::finish()
1370 {
1371         if (_session) {
1372                 ARDOUR_UI::instance()->video_timeline->sync_session_state();
1373
1374                 if (_session->dirty()) {
1375                         vector<string> actions;
1376                         actions.push_back (_("Don't quit"));
1377                         actions.push_back (_("Just quit"));
1378                         actions.push_back (_("Save and quit"));
1379                         switch (ask_about_saving_session(actions)) {
1380                         case -1:
1381                                 return;
1382                                 break;
1383                         case 1:
1384                                 /* use the default name */
1385                                 if (save_state_canfail ("")) {
1386                                         /* failed - don't quit */
1387                                         MessageDialog msg (_main_window,
1388                                                            string_compose (_("\
1389 %1 was unable to save your session.\n\n\
1390 If you still wish to quit, please use the\n\n\
1391 \"Just quit\" option."), PROGRAM_NAME));
1392                                         pop_back_splash(msg);
1393                                         msg.run ();
1394                                         return;
1395                                 }
1396                                 break;
1397                         case 0:
1398                                 break;
1399                         }
1400                 }
1401
1402                 second_connection.disconnect ();
1403                 point_one_second_connection.disconnect ();
1404                 point_zero_something_second_connection.disconnect();
1405                 fps_connection.disconnect();
1406         }
1407
1408         delete ARDOUR_UI::instance()->video_timeline;
1409         ARDOUR_UI::instance()->video_timeline = NULL;
1410         stop_video_server();
1411
1412         /* Save state before deleting the session, as that causes some
1413            windows to be destroyed before their visible state can be
1414            saved.
1415         */
1416         save_ardour_state ();
1417
1418         if (key_editor.get (false)) {
1419                 key_editor->disconnect ();
1420         }
1421
1422         close_all_dialogs ();
1423
1424         if (_session) {
1425                 _session->set_clean ();
1426                 _session->remove_pending_capture_state ();
1427                 delete _session;
1428                 _session = 0;
1429         }
1430
1431         halt_connection.disconnect ();
1432         AudioEngine::instance()->stop ();
1433 #ifdef WINDOWS_VST_SUPPORT
1434         fst_stop_threading();
1435 #endif
1436         quit ();
1437 }
1438
1439 int
1440 ARDOUR_UI::ask_about_saving_session (const vector<string>& actions)
1441 {
1442         ArdourDialog window (_("Unsaved Session"));
1443         Gtk::HBox dhbox;  // the hbox for the image and text
1444         Gtk::Label  prompt_label;
1445         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING,  Gtk::ICON_SIZE_DIALOG));
1446
1447         string msg;
1448
1449         assert (actions.size() >= 3);
1450
1451         window.add_button (actions[0], RESPONSE_REJECT);
1452         window.add_button (actions[1], RESPONSE_APPLY);
1453         window.add_button (actions[2], RESPONSE_ACCEPT);
1454
1455         window.set_default_response (RESPONSE_ACCEPT);
1456
1457         Gtk::Button noquit_button (msg);
1458         noquit_button.set_name ("EditorGTKButton");
1459
1460         string prompt;
1461
1462         if (_session->snap_name() == _session->name()) {
1463                 prompt = string_compose(_("The session \"%1\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
1464                                         _session->snap_name());
1465         } else {
1466                 prompt = string_compose(_("The snapshot \"%1\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
1467                                         _session->snap_name());
1468         }
1469
1470         prompt_label.set_text (prompt);
1471         prompt_label.set_name (X_("PrompterLabel"));
1472         prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
1473
1474         dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP);
1475         dhbox.set_homogeneous (false);
1476         dhbox.pack_start (*dimage, false, false, 5);
1477         dhbox.pack_start (prompt_label, true, false, 5);
1478         window.get_vbox()->pack_start (dhbox);
1479
1480         window.set_name (_("Prompter"));
1481         window.set_modal (true);
1482         window.set_resizable (false);
1483
1484         dhbox.show();
1485         prompt_label.show();
1486         dimage->show();
1487         window.show();
1488         window.present ();
1489
1490         ResponseType r = (ResponseType) window.run();
1491
1492         window.hide ();
1493
1494         switch (r) {
1495         case RESPONSE_ACCEPT: // save and get out of here
1496                 return 1;
1497         case RESPONSE_APPLY:  // get out of here
1498                 return 0;
1499         default:
1500                 break;
1501         }
1502
1503         return -1;
1504 }
1505
1506
1507 void
1508 ARDOUR_UI::every_second ()
1509 {
1510         update_cpu_load ();
1511         update_xrun_count ();
1512         update_buffer_load ();
1513         update_disk_space ();
1514         update_timecode_format ();
1515         update_peak_thread_work ();
1516
1517         if (nsm && nsm->is_active ()) {
1518                 nsm->check ();
1519
1520                 if (!_was_dirty && _session->dirty ()) {
1521                         nsm->is_dirty ();
1522                         _was_dirty = true;
1523                 }
1524                 else if (_was_dirty && !_session->dirty ()){
1525                         nsm->is_clean ();
1526                         _was_dirty = false;
1527                 }
1528         }
1529 }
1530
1531 void
1532 ARDOUR_UI::every_point_one_seconds ()
1533 {
1534         if (editor) editor->build_region_boundary_cache();
1535 }
1536
1537 void
1538 ARDOUR_UI::every_point_zero_something_seconds ()
1539 {
1540         // august 2007: actual update frequency: 25Hz (40ms), not 100Hz
1541
1542         if (editor_meter && UIConfiguration::instance().get_show_editor_meter() && editor_meter_peak_display.is_mapped ()) {
1543                 float mpeak = editor_meter->update_meters();
1544                 if (mpeak > editor_meter_max_peak) {
1545                         if (mpeak >= UIConfiguration::instance().get_meter_peak()) {
1546                                 editor_meter_peak_display.set_active_state ( Gtkmm2ext::ExplicitActive );
1547                         }
1548                 }
1549         }
1550 }
1551
1552 void
1553 ARDOUR_UI::set_fps_timeout_connection ()
1554 {
1555         unsigned int interval = 40;
1556         if (!_session) return;
1557         if (_session->timecode_frames_per_second() != 0) {
1558                 /* ideally we'll use a select() to sleep and not accumulate
1559                  * idle time to provide a regular periodic signal.
1560                  * See linux_vst_gui_support.cc 'elapsed_time_ms'.
1561                  * However, that'll require a dedicated thread and cross-thread
1562                  * signals to the GUI Thread..
1563                  */
1564                 interval = floor(500. /* update twice per FPS, since Glib::signal_timeout is very irregular */
1565                                 * _session->sample_rate() / _session->nominal_sample_rate()
1566                                 / _session->timecode_frames_per_second()
1567                                 );
1568 #ifdef PLATFORM_WINDOWS
1569                 // the smallest windows scheduler time-slice is ~15ms.
1570                 // periodic GUI timeouts shorter than that will cause
1571                 // WaitForSingleObject to spinlock (100% of one CPU Core)
1572                 // and gtk never enters idle mode.
1573                 // also changing timeBeginPeriod(1) does not affect that in
1574                 // any beneficial way, so we just limit the max rate for now.
1575                 interval = std::max(30u, interval); // at most ~33Hz.
1576 #else
1577                 interval = std::max(8u, interval); // at most 120Hz.
1578 #endif
1579         }
1580         fps_connection.disconnect();
1581         Timers::set_fps_interval (interval);
1582 }
1583
1584 void
1585 ARDOUR_UI::update_sample_rate (samplecnt_t)
1586 {
1587         char buf[64];
1588
1589         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_sample_rate, ignored)
1590
1591         if (!AudioEngine::instance()->connected()) {
1592
1593                 snprintf (buf, sizeof (buf), "%s", _("Audio: <span foreground=\"red\">none</span>"));
1594
1595         } else {
1596
1597                 samplecnt_t rate = AudioEngine::instance()->sample_rate();
1598
1599                 if (rate == 0) {
1600                         /* no sample rate available */
1601                         snprintf (buf, sizeof (buf), "%s", _("Audio: <span foreground=\"red\">none</span>"));
1602                 } else {
1603
1604                         if (fmod (rate, 1000.0) != 0.0) {
1605                                 snprintf (buf, sizeof (buf), _("Audio: <span foreground=\"green\">%.1f kHz / %4.1f ms</span>"),
1606                                           (float) rate / 1000.0f,
1607                                           (AudioEngine::instance()->usecs_per_cycle() / 1000.0f));
1608                         } else {
1609                                 snprintf (buf, sizeof (buf), _("Audio: <span foreground=\"green\">%" PRId64 " kHz / %4.1f ms</span>"),
1610                                           rate/1000,
1611                                           (AudioEngine::instance()->usecs_per_cycle() / 1000.0f));
1612                         }
1613                 }
1614         }
1615         sample_rate_label.set_markup (buf);
1616 }
1617
1618 void
1619 ARDOUR_UI::update_format ()
1620 {
1621         if (!_session) {
1622                 format_label.set_text ("");
1623                 return;
1624         }
1625
1626         stringstream s;
1627         s << _("File:") << X_(" <span foreground=\"green\">");
1628
1629         switch (_session->config.get_native_file_header_format ()) {
1630         case BWF:
1631                 s << _("BWF");
1632                 break;
1633         case WAVE:
1634                 s << _("WAV");
1635                 break;
1636         case WAVE64:
1637                 s << _("WAV64");
1638                 break;
1639         case CAF:
1640                 s << _("CAF");
1641                 break;
1642         case AIFF:
1643                 s << _("AIFF");
1644                 break;
1645         case iXML:
1646                 s << _("iXML");
1647                 break;
1648         case RF64:
1649                 s << _("RF64");
1650                 break;
1651         case RF64_WAV:
1652                 s << _("RF64/WAV");
1653                 break;
1654         case MBWF:
1655                 s << _("MBWF");
1656                 break;
1657         }
1658
1659         s << " ";
1660
1661         switch (_session->config.get_native_file_data_format ()) {
1662         case FormatFloat:
1663                 s << _("32-float");
1664                 break;
1665         case FormatInt24:
1666                 s << _("24-int");
1667                 break;
1668         case FormatInt16:
1669                 s << _("16-int");
1670                 break;
1671         }
1672
1673         s << X_("</span>");
1674
1675         format_label.set_markup (s.str ());
1676 }
1677
1678 void
1679 ARDOUR_UI::update_xrun_count ()
1680 {
1681         char buf[64];
1682
1683         /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
1684            should also be changed.
1685         */
1686
1687         if (_session) {
1688                 const unsigned int x = _session->get_xrun_count ();
1689                 dsp_load_indicator.set_xrun_count (x);
1690                 if (x > 9999) {
1691                         snprintf (buf, sizeof (buf), _("X: <span foreground=\"%s\">&gt;10K</span>"), X_("red"));
1692                 } else {
1693                         snprintf (buf, sizeof (buf), _("X: <span foreground=\"%s\">%u</span>"), x > 0 ? X_("red") : X_("green"), x);
1694                 }
1695         } else {
1696                 snprintf (buf, sizeof (buf), _("X: <span foreground=\"%s\">?</span>"), X_("yellow"));
1697                 dsp_load_indicator.set_xrun_count (UINT_MAX);
1698         }
1699         xrun_label.set_markup (buf);
1700         set_tip (xrun_label, _("Audio dropouts. Shift+click to reset"));
1701 }
1702
1703 void
1704 ARDOUR_UI::update_cpu_load ()
1705 {
1706         char buf[64];
1707
1708         /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
1709            should also be changed.
1710         */
1711
1712         double const c = AudioEngine::instance()->get_dsp_load ();
1713         dsp_load_indicator.set_dsp_load (c);
1714         snprintf (buf, sizeof (buf), _("DSP: <span foreground=\"%s\">%5.1f%%</span>"), c >= 90 ? X_("red") : X_("green"), c);
1715         cpu_load_label.set_markup (buf);
1716 }
1717
1718 void
1719 ARDOUR_UI::update_peak_thread_work ()
1720 {
1721         char buf[64];
1722         const int c = SourceFactory::peak_work_queue_length ();
1723         if (c > 0) {
1724                 snprintf (buf, sizeof (buf), _("PkBld: <span foreground=\"%s\">%d</span>"), c >= 2 ? X_("red") : X_("green"), c);
1725                 peak_thread_work_label.set_markup (buf);
1726         } else {
1727                 peak_thread_work_label.set_markup (X_(""));
1728         }
1729 }
1730
1731 void
1732 ARDOUR_UI::update_buffer_load ()
1733 {
1734         char buf[256];
1735
1736         uint32_t const playback = _session ? _session->playback_load () : 100;
1737         uint32_t const capture = _session ? _session->capture_load () : 100;
1738
1739         /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
1740            should also be changed.
1741         */
1742
1743         if (_session) {
1744                 snprintf (
1745                         buf, sizeof (buf),
1746                         _("Buffers: <span foreground=\"green\">p:</span><span foreground=\"%s\">%" PRIu32 "%%</span> "
1747                                    "<span foreground=\"green\">c:</span><span foreground=\"%s\">%" PRIu32 "%%</span>"),
1748                         playback <= 5 ? X_("red") : X_("green"),
1749                         playback,
1750                         capture <= 5 ? X_("red") : X_("green"),
1751                         capture
1752                         );
1753
1754                 buffer_load_label.set_markup (buf);
1755         } else {
1756                 buffer_load_label.set_text ("");
1757         }
1758 }
1759
1760 void
1761 ARDOUR_UI::count_recenabled_streams (Route& route)
1762 {
1763         Track* track = dynamic_cast<Track*>(&route);
1764         if (track && track->rec_enable_control()->get_value()) {
1765                 rec_enabled_streams += track->n_inputs().n_total();
1766         }
1767 }
1768
1769 void
1770 ARDOUR_UI::update_disk_space()
1771 {
1772         if (_session == 0) {
1773                 disk_space_indicator.set_available_disk_sec (-1);
1774                 return;
1775         }
1776
1777         boost::optional<samplecnt_t> opt_samples = _session->available_capture_duration();
1778         char buf[64];
1779         samplecnt_t fr = _session->sample_rate();
1780
1781         if (fr == 0) {
1782                 /* skip update - no SR available */
1783                 disk_space_indicator.set_available_disk_sec (-1);
1784                 return;
1785         }
1786
1787         if (!opt_samples) {
1788                 /* Available space is unknown */
1789                 snprintf (buf, sizeof (buf), "%s", _("Disk: <span foreground=\"green\">Unknown</span>"));
1790                 disk_space_indicator.set_available_disk_sec (-1);
1791         } else if (opt_samples.get_value_or (0) == max_samplecnt) {
1792                 snprintf (buf, sizeof (buf), "%s", _("Disk: <span foreground=\"green\">24hrs+</span>"));
1793                 disk_space_indicator.set_available_disk_sec (max_samplecnt);
1794         } else {
1795                 rec_enabled_streams = 0;
1796                 _session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams, false);
1797
1798                 samplecnt_t samples = opt_samples.get_value_or (0);
1799
1800                 if (rec_enabled_streams) {
1801                         samples /= rec_enabled_streams;
1802                 }
1803
1804                 int hrs;
1805                 int mins;
1806                 int secs;
1807
1808                 disk_space_indicator.set_available_disk_sec (samples / (float)fr);
1809
1810                 hrs  = samples / (fr * 3600);
1811
1812                 if (hrs > 24) {
1813                         snprintf (buf, sizeof (buf), "%s", _("Disk: <span foreground=\"green\">&gt;24 hrs</span>"));
1814                 } else {
1815                         samples -= hrs * fr * 3600;
1816                         mins = samples / (fr * 60);
1817                         samples -= mins * fr * 60;
1818                         secs = samples / fr;
1819
1820                         bool const low = (hrs == 0 && mins <= 30);
1821
1822                         snprintf (
1823                                 buf, sizeof(buf),
1824                                 _("Disk: <span foreground=\"%s\">%02dh:%02dm:%02ds</span>"),
1825                                 low ? X_("red") : X_("green"),
1826                                 hrs, mins, secs
1827                                 );
1828                 }
1829         }
1830
1831         disk_space_label.set_markup (buf);
1832 }
1833
1834 void
1835 ARDOUR_UI::update_timecode_format ()
1836 {
1837         char buf[64];
1838
1839         if (_session) {
1840                 bool matching;
1841                 TimecodeSlave* tcslave;
1842                 SyncSource sync_src = Config->get_sync_source();
1843
1844                 if ((sync_src == LTC || sync_src == MTC) && (tcslave = dynamic_cast<TimecodeSlave*>(_session->slave())) != 0) {
1845                         matching = (tcslave->apparent_timecode_format() == _session->config.get_timecode_format());
1846                 } else {
1847                         matching = true;
1848                 }
1849
1850                 snprintf (buf, sizeof (buf), S_("Timecode|TC: <span foreground=\"%s\">%s</span>"),
1851                           matching ? X_("green") : X_("red"),
1852                           Timecode::timecode_format_name (_session->config.get_timecode_format()).c_str());
1853         } else {
1854                 snprintf (buf, sizeof (buf), "TC: n/a");
1855         }
1856
1857         timecode_format_label.set_markup (buf);
1858 }
1859
1860 gint
1861 ARDOUR_UI::update_wall_clock ()
1862 {
1863         time_t now;
1864         struct tm *tm_now;
1865         static int last_min = -1;
1866
1867         time (&now);
1868         tm_now = localtime (&now);
1869         if (last_min != tm_now->tm_min) {
1870                 char buf[16];
1871                 sprintf (buf, "%02d:%02d", tm_now->tm_hour, tm_now->tm_min);
1872                 wall_clock_label.set_text (buf);
1873                 last_min = tm_now->tm_min;
1874         }
1875
1876         return TRUE;
1877 }
1878
1879 void
1880 ARDOUR_UI::open_recent_session ()
1881 {
1882         bool can_return = (_session != 0);
1883
1884         SessionDialog recent_session_dialog;
1885
1886         while (true) {
1887
1888                 ResponseType r = (ResponseType) recent_session_dialog.run ();
1889
1890                 switch (r) {
1891                 case RESPONSE_ACCEPT:
1892                         break;
1893                 default:
1894                         if (can_return) {
1895                                 recent_session_dialog.hide();
1896                                 return;
1897                         } else {
1898                                 exit (1);
1899                         }
1900                 }
1901
1902                 recent_session_dialog.hide();
1903
1904                 bool should_be_new;
1905
1906                 std::string path = recent_session_dialog.session_folder();
1907                 std::string state = recent_session_dialog.session_name (should_be_new);
1908
1909                 if (should_be_new == true) {
1910                         continue;
1911                 }
1912
1913                 _session_is_new = false;
1914
1915                 if (load_session (path, state) == 0) {
1916                         break;
1917                 }
1918
1919                 can_return = false;
1920         }
1921 }
1922
1923 bool
1924 ARDOUR_UI::check_audioengine (Gtk::Window& parent)
1925 {
1926         if (!AudioEngine::instance()->connected()) {
1927                 MessageDialog msg (parent, string_compose (
1928                                            _("%1 is not connected to any audio backend.\n"
1929                                            "You cannot open or close sessions in this condition"),
1930                                            PROGRAM_NAME));
1931                 pop_back_splash (msg);
1932                 msg.run ();
1933                 return false;
1934         }
1935         return true;
1936 }
1937
1938 void
1939 ARDOUR_UI::open_session ()
1940 {
1941         if (!check_audioengine (_main_window)) {
1942                 return;
1943         }
1944
1945         /* ardour sessions are folders */
1946         Gtk::FileChooserDialog open_session_selector(_("Open Session"), FILE_CHOOSER_ACTION_OPEN);
1947         open_session_selector.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1948         open_session_selector.add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
1949         open_session_selector.set_default_response(Gtk::RESPONSE_ACCEPT);
1950
1951         if (_session) {
1952                 string session_parent_dir = Glib::path_get_dirname(_session->path());
1953                 open_session_selector.set_current_folder(session_parent_dir);
1954         } else {
1955                 open_session_selector.set_current_folder(Config->get_default_session_parent_dir());
1956         }
1957
1958         Gtkmm2ext::add_volume_shortcuts (open_session_selector);
1959         try {
1960                 /* add_shortcut_folder throws an exception if the folder being added already has a shortcut */
1961                 string default_session_folder = Config->get_default_session_parent_dir();
1962                 open_session_selector.add_shortcut_folder (default_session_folder);
1963         }
1964         catch (Glib::Error const& e) {
1965                 std::cerr << "open_session_selector.add_shortcut_folder() threw Glib::Error " << e.what() << std::endl;
1966         }
1967
1968         FileFilter session_filter;
1969         session_filter.add_pattern (string_compose(X_("*%1"), ARDOUR::statefile_suffix));
1970         session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
1971         open_session_selector.add_filter (session_filter);
1972
1973         FileFilter archive_filter;
1974         archive_filter.add_pattern (string_compose(X_("*%1"), ARDOUR::session_archive_suffix));
1975         archive_filter.set_name (_("Session Archives"));
1976
1977         open_session_selector.add_filter (archive_filter);
1978
1979         open_session_selector.set_filter (session_filter);
1980
1981         int response = open_session_selector.run();
1982         open_session_selector.hide ();
1983
1984         if (response == Gtk::RESPONSE_CANCEL) {
1985                 return;
1986         }
1987
1988         string session_path = open_session_selector.get_filename();
1989         string path, name;
1990         bool isnew;
1991
1992         if (session_path.length() > 0) {
1993                 int rv = ARDOUR::inflate_session (session_path,
1994                                 Config->get_default_session_parent_dir(), path, name);
1995                 if (rv == 0) {
1996                         _session_is_new = false;
1997                         load_session (path, name);
1998                 }
1999                 else if (rv < 0) {
2000                         MessageDialog msg (_main_window,
2001                                         string_compose (_("Extracting session-archive failed: %1"), inflate_error (rv)));
2002                         msg.run ();
2003                 }
2004                 else if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
2005                         _session_is_new = isnew;
2006                         load_session (path, name);
2007                 }
2008         }
2009 }
2010
2011 void
2012 ARDOUR_UI::session_add_mixed_track (
2013                 const ChanCount& input,
2014                 const ChanCount& output,
2015                 RouteGroup* route_group,
2016                 uint32_t how_many,
2017                 const string& name_template,
2018                 bool strict_io,
2019                 PluginInfoPtr instrument,
2020                 Plugin::PresetRecord* pset,
2021                 ARDOUR::PresentationInfo::order_t order)
2022 {
2023         assert (_session);
2024
2025         if (Profile->get_mixbus ()) {
2026                 strict_io = true;
2027         }
2028
2029         try {
2030                 list<boost::shared_ptr<MidiTrack> > tracks;
2031                 tracks = _session->new_midi_track (input, output, strict_io, instrument, pset, route_group, how_many, name_template, order, ARDOUR::Normal);
2032
2033                 if (tracks.size() != how_many) {
2034                         error << string_compose(P_("could not create %1 new mixed track", "could not create %1 new mixed tracks", how_many), how_many) << endmsg;
2035                 }
2036         }
2037
2038         catch (...) {
2039                 display_insufficient_ports_message ();
2040                 return;
2041         }
2042 }
2043
2044 void
2045 ARDOUR_UI::session_add_midi_bus (
2046                 RouteGroup* route_group,
2047                 uint32_t how_many,
2048                 const string& name_template,
2049                 bool strict_io,
2050                 PluginInfoPtr instrument,
2051                 Plugin::PresetRecord* pset,
2052                 ARDOUR::PresentationInfo::order_t order)
2053 {
2054         if (_session == 0) {
2055                 warning << _("You cannot add a track without a session already loaded.") << endmsg;
2056                 return;
2057         }
2058
2059         if (Profile->get_mixbus ()) {
2060                 strict_io = true;
2061         }
2062
2063         try {
2064                 RouteList routes;
2065                 routes = _session->new_midi_route (route_group, how_many, name_template, strict_io, instrument, pset, PresentationInfo::MidiBus, order);
2066                 if (routes.size() != how_many) {
2067                         error << string_compose(P_("could not create %1 new Midi Bus", "could not create %1 new Midi Busses", how_many), how_many) << endmsg;
2068                 }
2069
2070         }
2071         catch (...) {
2072                 display_insufficient_ports_message ();
2073                 return;
2074         }
2075 }
2076
2077 void
2078 ARDOUR_UI::session_add_midi_route (
2079                 bool disk,
2080                 RouteGroup* route_group,
2081                 uint32_t how_many,
2082                 const string& name_template,
2083                 bool strict_io,
2084                 PluginInfoPtr instrument,
2085                 Plugin::PresetRecord* pset,
2086                 ARDOUR::PresentationInfo::order_t order)
2087 {
2088         ChanCount one_midi_channel;
2089         one_midi_channel.set (DataType::MIDI, 1);
2090
2091         if (disk) {
2092                 session_add_mixed_track (one_midi_channel, one_midi_channel, route_group, how_many, name_template, strict_io, instrument, pset, order);
2093         } else {
2094                 session_add_midi_bus (route_group, how_many, name_template, strict_io, instrument, pset, order);
2095         }
2096 }
2097
2098 void
2099 ARDOUR_UI::session_add_audio_route (
2100         bool track,
2101         int32_t input_channels,
2102         int32_t output_channels,
2103         ARDOUR::TrackMode mode,
2104         RouteGroup* route_group,
2105         uint32_t how_many,
2106         string const & name_template,
2107         bool strict_io,
2108         ARDOUR::PresentationInfo::order_t order)
2109 {
2110         list<boost::shared_ptr<AudioTrack> > tracks;
2111         RouteList routes;
2112
2113         assert (_session);
2114
2115         try {
2116                 if (track) {
2117                         tracks = _session->new_audio_track (input_channels, output_channels, route_group, how_many, name_template, order, mode);
2118
2119                         if (tracks.size() != how_many) {
2120                                 error << string_compose (P_("could not create %1 new audio track", "could not create %1 new audio tracks", how_many), how_many)
2121                                       << endmsg;
2122                         }
2123
2124                 } else {
2125
2126                         routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many, name_template, PresentationInfo::AudioBus, order);
2127
2128                         if (routes.size() != how_many) {
2129                                 error << string_compose (P_("could not create %1 new audio bus", "could not create %1 new audio busses", how_many), how_many)
2130                                       << endmsg;
2131                         }
2132                 }
2133         }
2134
2135         catch (...) {
2136                 display_insufficient_ports_message ();
2137                 return;
2138         }
2139
2140         if (strict_io) {
2141                 for (list<boost::shared_ptr<AudioTrack> >::iterator i = tracks.begin(); i != tracks.end(); ++i) {
2142                         (*i)->set_strict_io (true);
2143                 }
2144                 for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
2145                         (*i)->set_strict_io (true);
2146                 }
2147         }
2148 }
2149
2150 void
2151 ARDOUR_UI::display_insufficient_ports_message ()
2152 {
2153         MessageDialog msg (_main_window,
2154                         string_compose (_("There are insufficient ports available\n\
2155 to create a new track or bus.\n\
2156 You should save %1, exit and\n\
2157 restart with more ports."), PROGRAM_NAME));
2158         pop_back_splash (msg);
2159         msg.run ();
2160 }
2161
2162 void
2163 ARDOUR_UI::transport_goto_start ()
2164 {
2165         if (_session) {
2166                 _session->goto_start();
2167
2168                 /* force displayed area in editor to start no matter
2169                    what "follow playhead" setting is.
2170                 */
2171
2172                 if (editor) {
2173                         editor->center_screen (_session->current_start_sample ());
2174                 }
2175         }
2176 }
2177
2178 void
2179 ARDOUR_UI::transport_goto_zero ()
2180 {
2181         if (_session) {
2182                 _session->request_locate (0);
2183
2184                 /* force displayed area in editor to start no matter
2185                    what "follow playhead" setting is.
2186                 */
2187
2188                 if (editor) {
2189                         editor->reset_x_origin (0);
2190                 }
2191         }
2192 }
2193
2194 void
2195 ARDOUR_UI::transport_goto_wallclock ()
2196 {
2197         if (_session && editor) {
2198
2199                 time_t now;
2200                 struct tm tmnow;
2201                 samplepos_t samples;
2202
2203                 time (&now);
2204                 localtime_r (&now, &tmnow);
2205
2206                 samplecnt_t sample_rate = _session->sample_rate();
2207
2208                 if (sample_rate == 0) {
2209                         /* no frame rate available */
2210                         return;
2211                 }
2212
2213                 samples = tmnow.tm_hour * (60 * 60 * sample_rate);
2214                 samples += tmnow.tm_min * (60 * sample_rate);
2215                 samples += tmnow.tm_sec * sample_rate;
2216
2217                 _session->request_locate (samples, _session->transport_rolling ());
2218
2219                 /* force displayed area in editor to start no matter
2220                    what "follow playhead" setting is.
2221                 */
2222
2223                 if (editor) {
2224                         editor->center_screen (samples);
2225                 }
2226         }
2227 }
2228
2229 void
2230 ARDOUR_UI::transport_goto_end ()
2231 {
2232         if (_session) {
2233                 samplepos_t const sample = _session->current_end_sample();
2234                 _session->request_locate (sample);
2235
2236                 /* force displayed area in editor to start no matter
2237                    what "follow playhead" setting is.
2238                 */
2239
2240                 if (editor) {
2241                         editor->center_screen (sample);
2242                 }
2243         }
2244 }
2245
2246 void
2247 ARDOUR_UI::transport_stop ()
2248 {
2249         if (!_session) {
2250                 return;
2251         }
2252
2253         if (_session->is_auditioning()) {
2254                 _session->cancel_audition ();
2255                 return;
2256         }
2257
2258         _session->request_stop (false, true);
2259 }
2260
2261 /** Check if any tracks are record enabled. If none are, record enable all of them.
2262  * @return true if track record-enabled status was changed, false otherwise.
2263  */
2264 bool
2265 ARDOUR_UI::trx_record_enable_all_tracks ()
2266 {
2267         if (!_session) {
2268                 return false;
2269         }
2270
2271         boost::shared_ptr<RouteList> rl = _session->get_tracks ();
2272         bool none_record_enabled = true;
2273
2274         for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) {
2275                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*r);
2276                 assert (t);
2277
2278                 if (t->rec_enable_control()->get_value()) {
2279                         none_record_enabled = false;
2280                         break;
2281                 }
2282         }
2283
2284         if (none_record_enabled) {
2285                 _session->set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), 1.0, Controllable::NoGroup);
2286         }
2287
2288         return none_record_enabled;
2289 }
2290
2291 void
2292 ARDOUR_UI::transport_record (bool roll)
2293 {
2294         if (_session) {
2295                 switch (_session->record_status()) {
2296                 case Session::Disabled:
2297                         if (_session->ntracks() == 0) {
2298                                 MessageDialog msg (_main_window, _("Please create one or more tracks before trying to record.\nYou can do this with the \"Add Track or Bus\" option in the Session menu."));
2299                                 msg.run ();
2300                                 return;
2301                         }
2302                         if (Profile->get_trx()) {
2303                                 roll = trx_record_enable_all_tracks ();
2304                         }
2305                         _session->maybe_enable_record ();
2306                         if (roll) {
2307                                 transport_roll ();
2308                         }
2309                         break;
2310                 case Session::Recording:
2311                         if (roll) {
2312                                 _session->request_stop();
2313                         } else {
2314                                 _session->disable_record (false, true);
2315                         }
2316                         break;
2317
2318                 case Session::Enabled:
2319                         _session->disable_record (false, true);
2320                 }
2321         }
2322 }
2323
2324 void
2325 ARDOUR_UI::transport_roll ()
2326 {
2327         if (!_session) {
2328                 return;
2329         }
2330
2331         if (_session->is_auditioning()) {
2332                 return;
2333         }
2334
2335 #if 0
2336         if (_session->config.get_external_sync()) {
2337                 switch (Config->get_sync_source()) {
2338                 case Engine:
2339                         break;
2340                 default:
2341                         /* transport controlled by the master */
2342                         return;
2343                 }
2344         }
2345 #endif
2346
2347         bool rolling = _session->transport_rolling();
2348
2349         if (_session->get_play_loop()) {
2350
2351                 /* If loop playback is not a mode, then we should cancel
2352                    it when this action is requested. If it is a mode
2353                    we just leave it in place.
2354                 */
2355
2356                 if (!Config->get_loop_is_mode()) {
2357                         /* XXX it is not possible to just leave seamless loop and keep
2358                            playing at present (nov 4th 2009)
2359                         */
2360                         if (!Config->get_seamless_loop()) {
2361                                 /* stop loop playback and stop rolling */
2362                                 _session->request_play_loop (false, true);
2363                         } else if (rolling) {
2364                                 /* stop loop playback but keep rolling */
2365                                 _session->request_play_loop (false, false);
2366                         }
2367                 }
2368
2369         } else if (_session->get_play_range () ) {
2370                 /* stop playing a range if we currently are */
2371                 _session->request_play_range (0, true);
2372         }
2373
2374         if (!rolling) {
2375                 _session->request_transport_speed (1.0f);
2376         }
2377 }
2378
2379 bool
2380 ARDOUR_UI::get_smart_mode() const
2381 {
2382         return ( editor->get_smart_mode() );
2383 }
2384
2385
2386 void
2387 ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode)
2388 {
2389         if (!_session) {
2390                 return;
2391         }
2392
2393         if (_session->is_auditioning()) {
2394                 _session->cancel_audition ();
2395                 return;
2396         }
2397
2398         if (_session->config.get_external_sync()) {
2399                 switch (Config->get_sync_source()) {
2400                 case Engine:
2401                         break;
2402                 default:
2403                         /* transport controlled by the master */
2404                         return;
2405                 }
2406         }
2407
2408         bool rolling = _session->transport_rolling();
2409         bool affect_transport = true;
2410
2411         if (rolling && roll_out_of_bounded_mode) {
2412                 /* drop out of loop/range playback but leave transport rolling */
2413                 if (_session->get_play_loop()) {
2414                         if (_session->actively_recording()) {
2415
2416                                 /* just stop using the loop, then actually stop
2417                                  * below
2418                                  */
2419                                 _session->request_play_loop (false, affect_transport);
2420
2421                         } else {
2422                                 if (Config->get_seamless_loop()) {
2423                                         /* the disk buffers contain copies of the loop - we can't
2424                                            just keep playing, so stop the transport. the user
2425                                            can restart as they wish.
2426                                         */
2427                                         affect_transport = true;
2428                                 } else {
2429                                         /* disk buffers are normal, so we can keep playing */
2430                                         affect_transport = false;
2431                                 }
2432                                 _session->request_play_loop (false, affect_transport);
2433                         }
2434                 } else if (_session->get_play_range ()) {
2435                         affect_transport = false;
2436                         _session->request_play_range (0, true);
2437                 }
2438         }
2439
2440         if (affect_transport) {
2441                 if (rolling) {
2442                         _session->request_stop (with_abort, true);
2443
2444                 } else if (!with_abort) { /* with_abort == true means the
2445                                            * command was intended to stop
2446                                            * transport, not start.
2447                                            */
2448
2449                         /* the only external sync condition we can be in here
2450                          * would be Engine (JACK) sync, in which case we still
2451                          * want to do this.
2452                          */
2453
2454                         if (UIConfiguration::instance().get_follow_edits() && ( editor->get_selection().time.front().start == _session->transport_sample() ) ) {  //if playhead is exactly at the start of a range, we can assume it was placed there by follow_edits
2455                                 _session->request_play_range (&editor->get_selection().time, true);
2456                                 _session->set_requested_return_sample( editor->get_selection().time.front().start );  //force an auto-return here
2457                         }
2458                         _session->request_transport_speed (1.0f);
2459                 }
2460         }
2461 }
2462
2463 void
2464 ARDOUR_UI::toggle_session_auto_loop ()
2465 {
2466         if (!_session) {
2467                 return;
2468         }
2469
2470         Location * looploc = _session->locations()->auto_loop_location();
2471
2472         if (!looploc) {
2473                 return;
2474         }
2475
2476         if (_session->get_play_loop()) {
2477
2478                 /* looping enabled, our job is to disable it */
2479
2480                 _session->request_play_loop (false);
2481
2482         } else {
2483
2484                 /* looping not enabled, our job is to enable it.
2485
2486                    loop-is-NOT-mode: this action always starts the transport rolling.
2487                    loop-IS-mode:     this action simply sets the loop play mechanism, but
2488                                         does not start transport.
2489                 */
2490                 if (Config->get_loop_is_mode()) {
2491                         _session->request_play_loop (true, false);
2492                 } else {
2493                         _session->request_play_loop (true, true);
2494                 }
2495         }
2496
2497         //show the loop markers
2498         looploc->set_hidden (false, this);
2499 }
2500
2501 void
2502 ARDOUR_UI::transport_play_selection ()
2503 {
2504         if (!_session) {
2505                 return;
2506         }
2507
2508         editor->play_selection ();
2509 }
2510
2511 void
2512 ARDOUR_UI::transport_play_preroll ()
2513 {
2514         if (!_session) {
2515                 return;
2516         }
2517         editor->play_with_preroll ();
2518 }
2519
2520 void
2521 ARDOUR_UI::transport_rec_preroll ()
2522 {
2523         if (!_session) {
2524                 return;
2525         }
2526         editor->rec_with_preroll ();
2527 }
2528
2529 void
2530 ARDOUR_UI::transport_rec_count_in ()
2531 {
2532         if (!_session) {
2533                 return;
2534         }
2535         editor->rec_with_count_in ();
2536 }
2537
2538 void
2539 ARDOUR_UI::transport_rewind (int option)
2540 {
2541         float current_transport_speed;
2542
2543         if (_session) {
2544                 current_transport_speed = _session->transport_speed();
2545
2546                 if (current_transport_speed >= 0.0f) {
2547                         switch (option) {
2548                         case 0:
2549                                 _session->request_transport_speed (-1.0f);
2550                                 break;
2551                         case 1:
2552                                 _session->request_transport_speed (-4.0f);
2553                                 break;
2554                         case -1:
2555                                 _session->request_transport_speed (-0.5f);
2556                                 break;
2557                         }
2558                 } else {
2559                         /* speed up */
2560                         _session->request_transport_speed (current_transport_speed * 1.5f);
2561                 }
2562         }
2563 }
2564
2565 void
2566 ARDOUR_UI::transport_forward (int option)
2567 {
2568         if (!_session) {
2569                 return;
2570         }
2571
2572         float current_transport_speed = _session->transport_speed();
2573
2574         if (current_transport_speed <= 0.0f) {
2575                 switch (option) {
2576                 case 0:
2577                         _session->request_transport_speed (1.0f);
2578                         break;
2579                 case 1:
2580                         _session->request_transport_speed (4.0f);
2581                         break;
2582                 case -1:
2583                         _session->request_transport_speed (0.5f);
2584                         break;
2585                 }
2586         } else {
2587                 /* speed up */
2588                 _session->request_transport_speed (current_transport_speed * 1.5f);
2589         }
2590 }
2591
2592 void
2593 ARDOUR_UI::toggle_record_enable (uint16_t rid)
2594 {
2595         if (!_session) {
2596                 return;
2597         }
2598
2599         boost::shared_ptr<Route> r;
2600
2601         if ((r = _session->get_remote_nth_route (rid)) != 0) {
2602
2603                 boost::shared_ptr<Track> t;
2604
2605                 if ((t = boost::dynamic_pointer_cast<Track>(r)) != 0) {
2606                         t->rec_enable_control()->set_value (!t->rec_enable_control()->get_value(), Controllable::UseGroup);
2607                 }
2608         }
2609 }
2610
2611 void
2612 ARDOUR_UI::map_transport_state ()
2613 {
2614         if (!_session) {
2615                 layered_button.set_sensitive (false);
2616                 return;
2617         }
2618
2619         shuttle_box.map_transport_state ();
2620
2621         float sp = _session->transport_speed();
2622
2623         if (sp != 0.0f) {
2624                 layered_button.set_sensitive (!_session->actively_recording ());
2625         } else {
2626                 layered_button.set_sensitive (true);
2627                 update_disk_space ();
2628         }
2629 }
2630
2631 void
2632 ARDOUR_UI::blink_handler (bool blink_on)
2633 {
2634         sync_blink (blink_on);
2635
2636         if (!UIConfiguration::instance().get_blink_alert_indicators()) {
2637                 blink_on = true;
2638         }
2639         error_blink (blink_on);
2640         solo_blink (blink_on);
2641         audition_blink (blink_on);
2642         feedback_blink (blink_on);
2643 }
2644
2645 void
2646 ARDOUR_UI::update_clocks ()
2647 {
2648         if (!_session) return;
2649
2650         if (editor && !editor->dragging_playhead()) {
2651                 Clock (_session->audible_sample()); /* EMIT_SIGNAL */
2652         }
2653 }
2654
2655 void
2656 ARDOUR_UI::start_clocking ()
2657 {
2658         if (UIConfiguration::instance().get_super_rapid_clock_update()) {
2659                 clock_signal_connection = Timers::fps_connect (sigc::mem_fun(*this, &ARDOUR_UI::update_clocks));
2660         } else {
2661                 clock_signal_connection = Timers::rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::update_clocks));
2662         }
2663 }
2664
2665 void
2666 ARDOUR_UI::stop_clocking ()
2667 {
2668         clock_signal_connection.disconnect ();
2669 }
2670
2671 bool
2672 ARDOUR_UI::save_as_progress_update (float fraction, int64_t cnt, int64_t total, Gtk::Label* label, Gtk::ProgressBar* bar)
2673 {
2674         char buf[256];
2675
2676         snprintf (buf, sizeof (buf), _("Copied %" PRId64 " of %" PRId64), cnt, total);
2677
2678         label->set_text (buf);
2679         bar->set_fraction (fraction);
2680
2681         /* process events, redraws, etc. */
2682
2683         while (gtk_events_pending()) {
2684                 gtk_main_iteration ();
2685         }
2686
2687         return true; /* continue with save-as */
2688 }
2689
2690 void
2691 ARDOUR_UI::save_session_as ()
2692 {
2693         if (!_session) {
2694                 return;
2695         }
2696
2697         if (_session->dirty()) {
2698                 vector<string> actions;
2699                 actions.push_back (_("Abort save-as"));
2700                 actions.push_back (_("Don't save now, just save-as"));
2701                 actions.push_back (_("Save it first"));
2702                 switch (ask_about_saving_session(actions)) {
2703                         case -1:
2704                                 return;
2705                                 break;
2706                         case 1:
2707                                 if (save_state_canfail ("")) {
2708                                         MessageDialog msg (_main_window,
2709                                                         string_compose (_("\
2710 %1 was unable to save your session.\n\n\
2711 If you still wish to proceeed, please use the\n\n\
2712 \"Don't save now\" option."), PROGRAM_NAME));
2713                                         pop_back_splash(msg);
2714                                         msg.run ();
2715                                         return;
2716                                 }
2717                                 // no break
2718                         case 0:
2719                                 _session->remove_pending_capture_state ();
2720                                 break;
2721                 }
2722         }
2723
2724         if (!save_as_dialog) {
2725                 save_as_dialog = new SaveAsDialog;
2726         }
2727
2728         save_as_dialog->set_name (_session->name());
2729
2730         int response = save_as_dialog->run ();
2731
2732         save_as_dialog->hide ();
2733
2734         switch (response) {
2735         case Gtk::RESPONSE_OK:
2736                 break;
2737         default:
2738                 return;
2739         }
2740
2741
2742         Session::SaveAs sa;
2743
2744         sa.new_parent_folder = save_as_dialog->new_parent_folder ();
2745         sa.new_name = save_as_dialog->new_name ();
2746         sa.switch_to = save_as_dialog->switch_to();
2747         sa.copy_media = save_as_dialog->copy_media();
2748         sa.copy_external = save_as_dialog->copy_external();
2749         sa.include_media = save_as_dialog->include_media ();
2750
2751         /* Only bother with a progress dialog if we're going to copy
2752            media into the save-as target. Without that choice, this
2753            will be very fast because we're only talking about a few kB's to
2754            perhaps a couple of MB's of data.
2755         */
2756
2757         ArdourDialog progress_dialog (_("Save As"), true);
2758         ScopedConnection c;
2759
2760         if (sa.include_media && sa.copy_media) {
2761
2762                 Gtk::Label* label = manage (new Gtk::Label());
2763                 Gtk::ProgressBar* progress_bar = manage (new Gtk::ProgressBar ());
2764
2765                 progress_dialog.get_vbox()->pack_start (*label);
2766                 progress_dialog.get_vbox()->pack_start (*progress_bar);
2767                 label->show ();
2768                 progress_bar->show ();
2769
2770                 /* this signal will be emitted from within this, the calling thread,
2771                  * after every file is copied. It provides information on percentage
2772                  * complete (in terms of total data to copy), the number of files
2773                  * copied so far, and the total number to copy.
2774                  */
2775
2776                 sa.Progress.connect_same_thread (c, boost::bind (&ARDOUR_UI::save_as_progress_update, this, _1, _2, _3, label, progress_bar));
2777
2778                 progress_dialog.show_all ();
2779                 progress_dialog.present ();
2780         }
2781
2782         if (_session->save_as (sa)) {
2783                 /* ERROR MESSAGE */
2784                 MessageDialog msg (string_compose (_("Save As failed: %1"), sa.failure_message));
2785                 msg.run ();
2786         }
2787
2788         /* the logic here may seem odd: why isn't the condition sa.switch_to ?
2789          * the trick is this: if the new session was copy with media included,
2790          * then Session::save_as() will have already done a neat trick to avoid
2791          * us having to unload and load the new state. But if the media was not
2792          * included, then this is required (it avoids us having to otherwise
2793          * drop all references to media (sources).
2794          */
2795
2796         if (!sa.include_media && sa.switch_to) {
2797                 unload_session (false);
2798                 load_session (sa.final_session_folder_name, sa.new_name);
2799         }
2800 }
2801
2802 void
2803 ARDOUR_UI::archive_session ()
2804 {
2805         if (!_session) {
2806                 return;
2807         }
2808
2809         time_t n;
2810         time (&n);
2811         Glib::DateTime gdt (Glib::DateTime::create_now_local (n));
2812
2813         SessionArchiveDialog sad;
2814         sad.set_name (_session->name() + gdt.format ("_%F_%H%M%S"));
2815         int response = sad.run ();
2816
2817         if (response != Gtk::RESPONSE_OK) {
2818                 sad.hide ();
2819                 return;
2820         }
2821
2822         if (_session->archive_session (sad.target_folder(), sad.name(), sad.encode_option (), sad.compression_level (), sad.only_used_sources (), &sad)) {
2823                 MessageDialog msg (_("Session Archiving failed."));
2824                 msg.run ();
2825         }
2826 }
2827
2828 void
2829 ARDOUR_UI::quick_snapshot_session (bool switch_to_it)
2830 {
2831                 char timebuf[128];
2832                 time_t n;
2833                 struct tm local_time;
2834
2835                 time (&n);
2836                 localtime_r (&n, &local_time);
2837                 strftime (timebuf, sizeof(timebuf), "%FT%H.%M.%S", &local_time);
2838                 if (switch_to_it && _session->dirty ()) {
2839                         save_state_canfail ("");
2840                 }
2841
2842                 save_state (timebuf, switch_to_it);
2843 }
2844
2845
2846 bool
2847 ARDOUR_UI::process_snapshot_session_prompter (Prompter& prompter, bool switch_to_it)
2848 {
2849         string snapname;
2850
2851         prompter.get_result (snapname);
2852
2853         bool do_save = (snapname.length() != 0);
2854
2855         if (do_save) {
2856                 char illegal = Session::session_name_is_legal(snapname);
2857                 if (illegal) {
2858                         MessageDialog msg (string_compose (_("To ensure compatibility with various systems\n"
2859                                                              "snapshot names may not contain a '%1' character"), illegal));
2860                         msg.run ();
2861                         return false;
2862                 }
2863         }
2864
2865         vector<std::string> p;
2866         get_state_files_in_directory (_session->session_directory().root_path(), p);
2867         vector<string> n = get_file_names_no_extension (p);
2868
2869         if (find (n.begin(), n.end(), snapname) != n.end()) {
2870
2871                 do_save = overwrite_file_dialog (prompter,
2872                                                  _("Confirm Snapshot Overwrite"),
2873                                                  _("A snapshot already exists with that name. Do you want to overwrite it?"));
2874         }
2875
2876         if (do_save) {
2877                 save_state (snapname, switch_to_it);
2878         }
2879         else {
2880                 return false;
2881         }
2882
2883         return true;
2884 }
2885
2886
2887 /** Ask the user for the name of a new snapshot and then take it.
2888  */
2889
2890 void
2891 ARDOUR_UI::snapshot_session (bool switch_to_it)
2892 {
2893         if (switch_to_it && _session->dirty()) {
2894                 vector<string> actions;
2895                 actions.push_back (_("Abort saving snapshot"));
2896                 actions.push_back (_("Don't save now, just snapshot"));
2897                 actions.push_back (_("Save it first"));
2898                 switch (ask_about_saving_session(actions)) {
2899                         case -1:
2900                                 return;
2901                                 break;
2902                         case 1:
2903                                 if (save_state_canfail ("")) {
2904                                         MessageDialog msg (_main_window,
2905                                                         string_compose (_("\
2906 %1 was unable to save your session.\n\n\
2907 If you still wish to proceeed, please use the\n\n\
2908 \"Don't save now\" option."), PROGRAM_NAME));
2909                                         pop_back_splash(msg);
2910                                         msg.run ();
2911                                         return;
2912                                 }
2913                                 // no break
2914                         case 0:
2915                                 _session->remove_pending_capture_state ();
2916                                 break;
2917                 }
2918         }
2919
2920         Prompter prompter (true);
2921         prompter.set_name ("Prompter");
2922         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
2923         if (switch_to_it) {
2924                 prompter.set_title (_("Snapshot and switch"));
2925                 prompter.set_prompt (_("New session name"));
2926         } else {
2927                 prompter.set_title (_("Take Snapshot"));
2928                 prompter.set_prompt (_("Name of new snapshot"));
2929         }
2930
2931         if (switch_to_it) {
2932                 prompter.set_initial_text (_session->snap_name());
2933         } else {
2934                 Glib::DateTime tm (g_date_time_new_now_local ());
2935                 prompter.set_initial_text (tm.format ("%FT%H.%M.%S"));
2936         }
2937
2938         bool finished = false;
2939         while (!finished) {
2940                 switch (prompter.run()) {
2941                 case RESPONSE_ACCEPT:
2942                 {
2943                         finished = process_snapshot_session_prompter (prompter, switch_to_it);
2944                         break;
2945                 }
2946
2947                 default:
2948                         finished = true;
2949                         break;
2950                 }
2951         }
2952 }
2953
2954 /** Ask the user for a new session name and then rename the session to it.
2955  */
2956
2957 void
2958 ARDOUR_UI::rename_session ()
2959 {
2960         if (!_session) {
2961                 return;
2962         }
2963
2964         Prompter prompter (true);
2965         string name;
2966
2967         prompter.set_name ("Prompter");
2968         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
2969         prompter.set_title (_("Rename Session"));
2970         prompter.set_prompt (_("New session name"));
2971
2972   again:
2973         switch (prompter.run()) {
2974         case RESPONSE_ACCEPT:
2975         {
2976                 prompter.get_result (name);
2977
2978                 bool do_rename = (name.length() != 0);
2979
2980                 if (do_rename) {
2981                         char illegal = Session::session_name_is_legal (name);
2982
2983                         if (illegal) {
2984                                 MessageDialog msg (string_compose (_("To ensure compatibility with various systems\n"
2985                                                                      "session names may not contain a '%1' character"), illegal));
2986                                 msg.run ();
2987                                 goto again;
2988                         }
2989
2990                         switch (_session->rename (name)) {
2991                         case -1: {
2992                                 MessageDialog msg (_("That name is already in use by another directory/folder. Please try again."));
2993                                 msg.set_position (WIN_POS_MOUSE);
2994                                 msg.run ();
2995                                 goto again;
2996                                 break;
2997                         }
2998                         case 0:
2999                                 break;
3000                         default: {
3001                                 MessageDialog msg (_("Renaming this session failed.\nThings could be seriously messed up at this point"));
3002                                 msg.set_position (WIN_POS_MOUSE);
3003                                 msg.run ();
3004                                 break;
3005                         }
3006                         }
3007                 }
3008
3009                 break;
3010         }
3011
3012         default:
3013                 break;
3014         }
3015 }
3016
3017 void
3018 ARDOUR_UI::save_state (const string & name, bool switch_to_it)
3019 {
3020         if (!_session || _session->deletion_in_progress()) {
3021                 return;
3022         }
3023
3024         XMLNode* node = new XMLNode (X_("UI"));
3025
3026         WM::Manager::instance().add_state (*node);
3027
3028         node->add_child_nocopy (gui_object_state->get_state());
3029
3030         _session->add_extra_xml (*node);
3031
3032         if (export_video_dialog) {
3033                 _session->add_extra_xml (export_video_dialog->get_state());
3034         }
3035
3036         save_state_canfail (name, switch_to_it);
3037 }
3038
3039 int
3040 ARDOUR_UI::save_state_canfail (string name, bool switch_to_it)
3041 {
3042         if (_session) {
3043                 int ret;
3044
3045                 if ((ret = _session->save_state (name, false, switch_to_it)) != 0) {
3046                         return ret;
3047                 }
3048         }
3049
3050         save_ardour_state (); /* XXX cannot fail? yeah, right ... */
3051         return 0;
3052 }
3053
3054 void
3055 ARDOUR_UI::primary_clock_value_changed ()
3056 {
3057         if (_session) {
3058                 _session->request_locate (primary_clock->current_time ());
3059         }
3060 }
3061
3062 void
3063 ARDOUR_UI::big_clock_value_changed ()
3064 {
3065         if (_session) {
3066                 _session->request_locate (big_clock->current_time ());
3067         }
3068 }
3069
3070 void
3071 ARDOUR_UI::secondary_clock_value_changed ()
3072 {
3073         if (_session) {
3074                 _session->request_locate (secondary_clock->current_time ());
3075         }
3076 }
3077 void
3078 ARDOUR_UI::save_template_dialog_response (int response, SaveTemplateDialog* d)
3079 {
3080         if (response == RESPONSE_ACCEPT) {
3081                 const string name = d->get_template_name ();
3082                 const string desc = d->get_description ();
3083
3084                 int failed = _session->save_template (name, desc);
3085
3086                 if (failed == -2) { /* file already exists. */
3087                         bool overwrite = overwrite_file_dialog (*d,
3088                                                                 _("Confirm Template Overwrite"),
3089                                                                 _("A template already exists with that name. Do you want to overwrite it?"));
3090
3091                         if (overwrite) {
3092                                 _session->save_template (name, desc, true);
3093                         }
3094                         else {
3095                                 d->show ();
3096                                 return;
3097                         }
3098                 }
3099         }
3100         delete d;
3101 }
3102
3103 void
3104 ARDOUR_UI::save_template ()
3105 {
3106         if (!check_audioengine (_main_window)) {
3107                 return;
3108         }
3109
3110         const std::string desc = SessionMetadata::Metadata()->description ();
3111         SaveTemplateDialog* d = new SaveTemplateDialog (_session->name (), desc);
3112         d->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::save_template_dialog_response), d));
3113         d->show ();
3114 }
3115
3116 void ARDOUR_UI::manage_templates ()
3117 {
3118         TemplateDialog td;
3119         td.run();
3120 }
3121
3122 void
3123 ARDOUR_UI::edit_metadata ()
3124 {
3125         SessionMetadataEditor dialog;
3126         dialog.set_session (_session);
3127         dialog.grab_focus ();
3128         dialog.run ();
3129 }
3130
3131 void
3132 ARDOUR_UI::import_metadata ()
3133 {
3134         SessionMetadataImporter dialog;
3135         dialog.set_session (_session);
3136         dialog.run ();
3137 }
3138
3139 bool
3140 ARDOUR_UI::ask_about_loading_existing_session (const std::string& session_path)
3141 {
3142         std::string str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
3143
3144         MessageDialog msg (str,
3145                            false,
3146                            Gtk::MESSAGE_WARNING,
3147                            Gtk::BUTTONS_YES_NO,
3148                            true);
3149
3150
3151         msg.set_name (X_("OpenExistingDialog"));
3152         msg.set_title (_("Open Existing Session"));
3153         msg.set_wmclass (X_("existing_session"), PROGRAM_NAME);
3154         msg.set_position (Gtk::WIN_POS_CENTER);
3155         pop_back_splash (msg);
3156
3157         switch (msg.run()) {
3158         case RESPONSE_YES:
3159                 return true;
3160                 break;
3161         }
3162         return false;
3163 }
3164
3165 int
3166 ARDOUR_UI::build_session_from_dialog (SessionDialog& sd, const std::string& session_path, const std::string& session_name)
3167 {
3168         BusProfile bus_profile;
3169
3170         if (nsm) {
3171                 bus_profile.master_out_channels = 2;
3172         } else {
3173                 /* get settings from advanced section of NSD */
3174                 bus_profile.master_out_channels = (uint32_t) sd.master_channel_count();
3175         }
3176
3177         // NULL profile: no master, no monitor
3178         if (build_session (session_path, session_name, bus_profile.master_out_channels > 0 ? &bus_profile : NULL)) {
3179                 return -1;
3180         }
3181
3182         return 0;
3183 }
3184
3185 void
3186 ARDOUR_UI::load_from_application_api (const std::string& path)
3187 {
3188         /* OS X El Capitan (and probably later) now somehow passes the command
3189            line arguments to an app via the openFile delegate protocol. Ardour
3190            already does its own command line processing, and having both
3191            pathways active causes crashes. So, if the command line was already
3192            set, do nothing here.
3193         */
3194
3195         if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
3196                 return;
3197         }
3198
3199         ARDOUR_COMMAND_LINE::session_name = path;
3200
3201         /* Cancel SessionDialog if it's visible to make OSX delegates work.
3202          *
3203          * ARDOUR_UI::starting connects app->ShouldLoad signal and then shows a SessionDialog
3204          * race-condition:
3205          *  - ShouldLoad does not arrive in time, ARDOUR_COMMAND_LINE::session_name is empty:
3206          *    -> ARDOUR_UI::get_session_parameters starts a SessionDialog.
3207          *  - ShouldLoad signal arrives, this function is called and sets ARDOUR_COMMAND_LINE::session_name
3208          *    -> SessionDialog is not displayed
3209          */
3210
3211         if (_session_dialog) {
3212                 std::string session_name = basename_nosuffix (ARDOUR_COMMAND_LINE::session_name);
3213                 std::string session_path = path;
3214                 if (Glib::file_test (session_path, Glib::FILE_TEST_IS_REGULAR)) {
3215                         session_path = Glib::path_get_dirname (session_path);
3216                 }
3217                 // signal the existing dialog in ARDOUR_UI::get_session_parameters()
3218                 _session_dialog->set_provided_session (session_name, session_path);
3219                 _session_dialog->response (RESPONSE_NONE);
3220                 _session_dialog->hide();
3221                 return;
3222         }
3223
3224         int rv;
3225         if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
3226                 /* /path/to/foo => /path/to/foo, foo */
3227                 rv = load_session (path, basename_nosuffix (path));
3228         } else {
3229                 /* /path/to/foo/foo.ardour => /path/to/foo, foo */
3230                 rv =load_session (Glib::path_get_dirname (path), basename_nosuffix (path));
3231         }
3232
3233         // if load_session fails -> pop up SessionDialog.
3234         if (rv) {
3235                 ARDOUR_COMMAND_LINE::session_name = "";
3236
3237                 if (get_session_parameters (true, false)) {
3238                         exit (1);
3239                 }
3240         }
3241 }
3242
3243 /** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
3244 int
3245 ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new, string load_template)
3246 {
3247         string session_name;
3248         string session_path;
3249         string template_name;
3250         int ret = -1;
3251         bool likely_new = false;
3252         bool cancel_not_quit;
3253
3254         /* deal with any existing DIRTY session now, rather than later. don't
3255          * treat a non-dirty session this way, so that it stays visible
3256          * as we bring up the new session dialog.
3257          */
3258
3259         if (_session && ARDOUR_UI::instance()->video_timeline) {
3260                 ARDOUR_UI::instance()->video_timeline->sync_session_state();
3261         }
3262
3263         /* if there is already a session, relabel the button
3264            on the SessionDialog so that we don't Quit directly
3265         */
3266         cancel_not_quit = (_session != 0) && !quit_on_cancel;
3267
3268         if (_session && _session->dirty()) {
3269                 if (unload_session (false)) {
3270                         /* unload cancelled by user */
3271                         return 0;
3272                 }
3273                 ARDOUR_COMMAND_LINE::session_name = "";
3274         }
3275
3276         if (!load_template.empty()) {
3277                 should_be_new = true;
3278                 template_name = load_template;
3279         }
3280
3281         session_name = basename_nosuffix (ARDOUR_COMMAND_LINE::session_name);
3282         session_path = ARDOUR_COMMAND_LINE::session_name;
3283
3284         if (!session_path.empty()) {
3285                 if (Glib::file_test (session_path.c_str(), Glib::FILE_TEST_EXISTS)) {
3286                         if (Glib::file_test (session_path.c_str(), Glib::FILE_TEST_IS_REGULAR)) {
3287                                 /* session/snapshot file, change path to be dir */
3288                                 session_path = Glib::path_get_dirname (session_path);
3289                         }
3290                 }
3291         }
3292
3293         SessionDialog session_dialog (should_be_new, session_name, session_path, load_template, cancel_not_quit);
3294
3295         _session_dialog = &session_dialog;
3296         while (ret != 0) {
3297
3298                 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
3299
3300                         /* if they named a specific statefile, use it, otherwise they are
3301                            just giving a session folder, and we want to use it as is
3302                            to find the session.
3303                         */
3304
3305                         string::size_type suffix = ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix);
3306
3307                         if (suffix != string::npos) {
3308                                 session_path = Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name);
3309                                 session_name = ARDOUR_COMMAND_LINE::session_name.substr (0, suffix);
3310                                 session_name = Glib::path_get_basename (session_name);
3311                         } else {
3312                                 session_path = ARDOUR_COMMAND_LINE::session_name;
3313                                 session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name);
3314                         }
3315                 } else {
3316                         session_path = "";
3317                         session_name = "";
3318                         session_dialog.clear_given ();
3319                 }
3320
3321                 if (should_be_new || session_name.empty()) {
3322                         /* need the dialog to get info from user */
3323
3324                         cerr << "run dialog\n";
3325
3326                         switch (session_dialog.run()) {
3327                         case RESPONSE_ACCEPT:
3328                                 break;
3329                         case RESPONSE_NONE:
3330                                 /* this is used for async * app->ShouldLoad(). */
3331                                 continue; // while loop
3332                                 break;
3333                         default:
3334                                 if (quit_on_cancel) {
3335                                         ARDOUR_UI::finish ();
3336                                         Gtkmm2ext::Application::instance()->cleanup();
3337                                         ARDOUR::cleanup ();
3338                                         pthread_cancel_all ();
3339                                         return -1; // caller is responsible to call exit()
3340                                 } else {
3341                                         return ret;
3342                                 }
3343                         }
3344
3345                         session_dialog.hide ();
3346                 }
3347
3348                 /* if we run the startup dialog again, offer more than just "new session" */
3349
3350                 should_be_new = false;
3351
3352                 session_name = session_dialog.session_name (likely_new);
3353                 session_path = session_dialog.session_folder ();
3354
3355                 if (nsm) {
3356                         likely_new = true;
3357                 }
3358
3359                 if (!likely_new) {
3360                         int rv = ARDOUR::inflate_session (session_name,
3361                                         Config->get_default_session_parent_dir(), session_path, session_name);
3362                         if (rv < 0) {
3363                                 MessageDialog msg (session_dialog,
3364                                         string_compose (_("Extracting session-archive failed: %1"), inflate_error (rv)));
3365                                 msg.run ();
3366                                 continue;
3367                         }
3368                         else if (rv == 0) {
3369                                 session_dialog.set_provided_session (session_name, session_path);
3370                         }
3371                 }
3372
3373                 // XXX check archive, inflate
3374                 string::size_type suffix = session_name.find (statefile_suffix);
3375
3376                 if (suffix != string::npos) {
3377                         session_name = session_name.substr (0, suffix);
3378                 }
3379
3380                 /* this shouldn't happen, but we catch it just in case it does */
3381
3382                 if (session_name.empty()) {
3383                         continue;
3384                 }
3385
3386                 if (session_dialog.use_session_template()) {
3387                         template_name = session_dialog.session_template_name();
3388                         _session_is_new = true;
3389                 }
3390
3391                 if (session_name[0] == G_DIR_SEPARATOR ||
3392 #ifdef PLATFORM_WINDOWS
3393                    (session_name.length() > 3 && session_name[1] == ':' && session_name[2] == G_DIR_SEPARATOR)
3394 #else
3395                    (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == G_DIR_SEPARATOR) ||
3396                    (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == G_DIR_SEPARATOR)
3397 #endif
3398                 )
3399                 {
3400
3401                         /* absolute path or cwd-relative path specified for session name: infer session folder
3402                            from what was given.
3403                         */
3404
3405                         session_path = Glib::path_get_dirname (session_name);
3406                         session_name = Glib::path_get_basename (session_name);
3407
3408                 } else {
3409
3410                         session_path = session_dialog.session_folder();
3411
3412                         char illegal = Session::session_name_is_legal (session_name);
3413
3414                         if (illegal) {
3415                                 MessageDialog msg (session_dialog,
3416                                                    string_compose (_("To ensure compatibility with various systems\n"
3417                                                                      "session names may not contain a '%1' character"),
3418                                                                    illegal));
3419                                 msg.run ();
3420                                 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
3421                                 continue;
3422                         }
3423                 }
3424
3425                 if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
3426
3427
3428                         if (likely_new && !nsm) {
3429
3430                                 std::string existing = Glib::build_filename (session_path, session_name);
3431
3432                                 if (!ask_about_loading_existing_session (existing)) {
3433                                         ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
3434                                         continue;
3435                                 }
3436                         }
3437
3438                         _session_is_new = false;
3439
3440                 } else {
3441
3442                         if (!likely_new) {
3443                                 pop_back_splash (session_dialog);
3444                                 MessageDialog msg (string_compose (_("There is no existing session at \"%1\""), session_path));
3445                                 msg.run ();
3446                                 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
3447                                 continue;
3448                         }
3449
3450                         char illegal = Session::session_name_is_legal(session_name);
3451
3452                         if (illegal) {
3453                                 pop_back_splash (session_dialog);
3454                                 MessageDialog msg (session_dialog, string_compose(_("To ensure compatibility with various systems\n"
3455                                                                                     "session names may not contain a '%1' character"), illegal));
3456                                 msg.run ();
3457                                 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
3458                                 continue;
3459                         }
3460
3461                         _session_is_new = true;
3462                 }
3463
3464                 if (!template_name.empty() && template_name.substr (0, 11) == "urn:ardour:") {
3465
3466                         ret = build_session_from_dialog (session_dialog, session_path, session_name);
3467                         meta_session_setup (template_name.substr (11));
3468
3469                 } else if (likely_new && template_name.empty()) {
3470
3471                         ret = build_session_from_dialog (session_dialog, session_path, session_name);
3472
3473                 } else {
3474
3475                         ret = load_session (session_path, session_name, template_name);
3476
3477                         if (ret == -2) {
3478                                 /* not connected to the AudioEngine, so quit to avoid an infinite loop */
3479                                 exit (1);
3480                         }
3481
3482                         if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
3483                                 _session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
3484                                 exit (1);
3485                         }
3486
3487                         /* clear this to avoid endless attempts to load the
3488                            same session.
3489                         */
3490
3491                         ARDOUR_COMMAND_LINE::session_name = "";
3492                 }
3493         }
3494
3495         _session_dialog = NULL;
3496
3497         return ret;
3498 }
3499
3500 void
3501 ARDOUR_UI::close_session()
3502 {
3503         if (!check_audioengine (_main_window)) {
3504                 return;
3505         }
3506
3507         if (unload_session (true)) {
3508                 return;
3509         }
3510
3511         ARDOUR_COMMAND_LINE::session_name = "";
3512
3513         if (get_session_parameters (true, false)) {
3514                 exit (1);
3515         }
3516 }
3517
3518 /** @param snap_name Snapshot name (without .ardour suffix).
3519  *  @return -2 if the load failed because we are not connected to the AudioEngine.
3520  */
3521 int
3522 ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name, std::string mix_template)
3523 {
3524         /* load_session calls flush_pending() which allows
3525          * GUI interaction and potentially loading another session
3526          * (that was easy via snapshot sidebar).
3527          * Recursing into load_session() from load_session() and recusive
3528          * event loops causes all kind of crashes.
3529          */
3530         assert (!session_load_in_progress);
3531         if (session_load_in_progress) {
3532                 return -1;
3533         }
3534         PBD::Unwinder<bool> lsu (session_load_in_progress, true);
3535
3536         Session *new_session;
3537         int unload_status;
3538         int retval = -1;
3539
3540         if (_session) {
3541                 unload_status = unload_session ();
3542
3543                 if (unload_status < 0) {
3544                         goto out;
3545                 } else if (unload_status > 0) {
3546                         retval = 0;
3547                         goto out;
3548                 }
3549         }
3550
3551         session_loaded = false;
3552
3553         loading_message (string_compose (_("Please wait while %1 loads your session"), PROGRAM_NAME));
3554
3555         try {
3556                 new_session = new Session (*AudioEngine::instance(), path, snap_name, 0, mix_template);
3557         }
3558
3559         /* this one is special */
3560
3561         catch (AudioEngine::PortRegistrationFailure const& err) {
3562
3563                 MessageDialog msg (err.what(),
3564                                    true,
3565                                    Gtk::MESSAGE_INFO,
3566                                    Gtk::BUTTONS_CLOSE);
3567
3568                 msg.set_title (_("Port Registration Error"));
3569                 msg.set_secondary_text (_("Click the Close button to try again."));
3570                 msg.set_position (Gtk::WIN_POS_CENTER);
3571                 pop_back_splash (msg);
3572                 msg.present ();
3573
3574                 int response = msg.run ();
3575
3576                 msg.hide ();
3577
3578                 switch (response) {
3579                 case RESPONSE_CANCEL:
3580                         exit (1);
3581                 default:
3582                         break;
3583                 }
3584                 goto out;
3585         }
3586         catch (SessionException const& e) {
3587                 MessageDialog msg (string_compose(
3588                                            _("Session \"%1 (snapshot %2)\" did not load successfully:\n%3"),
3589                                            path, snap_name, e.what()),
3590                                    true,
3591                                    Gtk::MESSAGE_INFO,
3592                                    BUTTONS_OK);
3593
3594                 msg.set_title (_("Loading Error"));
3595                 msg.set_position (Gtk::WIN_POS_CENTER);
3596                 pop_back_splash (msg);
3597                 msg.present ();
3598
3599                 dump_errors (cerr);
3600
3601                 (void) msg.run ();
3602                 msg.hide ();
3603
3604                 goto out;
3605         }
3606         catch (...) {
3607
3608                 MessageDialog msg (string_compose(
3609                                            _("Session \"%1 (snapshot %2)\" did not load successfully."),
3610                                            path, snap_name),
3611                                    true,
3612                                    Gtk::MESSAGE_INFO,
3613                                    BUTTONS_OK);
3614
3615                 msg.set_title (_("Loading Error"));
3616                 msg.set_position (Gtk::WIN_POS_CENTER);
3617                 pop_back_splash (msg);
3618                 msg.present ();
3619
3620                 dump_errors (cerr);
3621
3622                 (void) msg.run ();
3623                 msg.hide ();
3624
3625                 goto out;
3626         }
3627
3628         {
3629                 list<string> const u = new_session->unknown_processors ();
3630                 if (!u.empty()) {
3631                         MissingPluginDialog d (_session, u);
3632                         d.run ();
3633                 }
3634         }
3635
3636         if (!new_session->writable()) {
3637                 MessageDialog msg (_("This session has been opened in read-only mode.\n\nYou will not be able to record or save."),
3638                                    true,
3639                                    Gtk::MESSAGE_INFO,
3640                                    BUTTONS_OK);
3641
3642                 msg.set_title (_("Read-only Session"));
3643                 msg.set_position (Gtk::WIN_POS_CENTER);
3644                 pop_back_splash (msg);
3645                 msg.present ();
3646                 (void) msg.run ();
3647                 msg.hide ();
3648         }
3649
3650
3651         /* Now the session been created, add the transport controls */
3652         new_session->add_controllable(roll_controllable);
3653         new_session->add_controllable(stop_controllable);
3654         new_session->add_controllable(goto_start_controllable);
3655         new_session->add_controllable(goto_end_controllable);
3656         new_session->add_controllable(auto_loop_controllable);
3657         new_session->add_controllable(play_selection_controllable);
3658         new_session->add_controllable(rec_controllable);
3659
3660         set_session (new_session);
3661
3662         session_loaded = true;
3663
3664         if (_session) {
3665                 _session->set_clean ();
3666         }
3667
3668 #ifdef WINDOWS_VST_SUPPORT
3669         fst_stop_threading();
3670 #endif
3671
3672         {
3673                 Timers::TimerSuspender t;
3674                 flush_pending (10);
3675         }
3676
3677 #ifdef WINDOWS_VST_SUPPORT
3678         fst_start_threading();
3679 #endif
3680         retval = 0;
3681
3682         if (!mix_template.empty ()) {
3683                 /* if mix_template is given, assume this is a new session */
3684                 string metascript = Glib::build_filename (mix_template, "template.lua");
3685                 meta_session_setup (metascript);
3686         }
3687
3688
3689   out:
3690         /* For successful session load the splash is hidden by ARDOUR_UI::first_idle,
3691          * which is queued by set_session().
3692          * If session-loading fails we hide it explicitly.
3693          * This covers both cases in a central place.
3694          */
3695         if (retval) {
3696                 hide_splash ();
3697         }
3698         return retval;
3699 }
3700
3701 int
3702 ARDOUR_UI::build_session (const std::string& path, const std::string& snap_name, BusProfile* bus_profile)
3703 {
3704         Session *new_session;
3705         int x;
3706
3707         session_loaded = false;
3708         x = unload_session ();
3709
3710         if (x < 0) {
3711                 return -1;
3712         } else if (x > 0) {
3713                 return 0;
3714         }
3715
3716         _session_is_new = true;
3717
3718         try {
3719                 new_session = new Session (*AudioEngine::instance(), path, snap_name, bus_profile);
3720         }
3721
3722         catch (SessionException const& e) {
3723                 cerr << "Here are the errors associated with this failed session:\n";
3724                 dump_errors (cerr);
3725                 cerr << "---------\n";
3726                 MessageDialog msg (string_compose(_("Could not create session in \"%1\": %2"), path, e.what()));
3727                 msg.set_title (_("Loading Error"));
3728                 msg.set_position (Gtk::WIN_POS_CENTER);
3729                 pop_back_splash (msg);
3730                 msg.run ();
3731                 return -1;
3732         }
3733         catch (...) {
3734                 cerr << "Here are the errors associated with this failed session:\n";
3735                 dump_errors (cerr);
3736                 cerr << "---------\n";
3737                 MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
3738                 msg.set_title (_("Loading Error"));
3739                 msg.set_position (Gtk::WIN_POS_CENTER);
3740                 pop_back_splash (msg);
3741                 msg.run ();
3742                 return -1;
3743         }
3744
3745         /* Give the new session the default GUI state, if such things exist */
3746
3747         XMLNode* n;
3748         n = Config->instant_xml (X_("Editor"));
3749         if (n) {
3750                 n->remove_nodes_and_delete ("Selection"); // no not apply selection to new sessions.
3751                 new_session->add_instant_xml (*n, false);
3752         }
3753         n = Config->instant_xml (X_("Mixer"));
3754         if (n) {
3755                 new_session->add_instant_xml (*n, false);
3756         }
3757
3758         n = Config->instant_xml (X_("Preferences"));
3759         if (n) {
3760                 new_session->add_instant_xml (*n, false);
3761         }
3762
3763         /* Put the playhead at 0 and scroll fully left */
3764         n = new_session->instant_xml (X_("Editor"));
3765         if (n) {
3766                 n->set_property (X_("playhead"), X_("0"));
3767                 n->set_property (X_("left-frame"), X_("0"));
3768         }
3769
3770         set_session (new_session);
3771
3772         session_loaded = true;
3773
3774         new_session->save_state(new_session->name());
3775
3776         return 0;
3777 }
3778
3779
3780 static void _lua_print (std::string s) {
3781 #ifndef NDEBUG
3782         std::cout << "LuaInstance: " << s << "\n";
3783 #endif
3784         PBD::info << "LuaInstance: " << s << endmsg;
3785 }
3786
3787 std::map<std::string, std::string>
3788 ARDOUR_UI::route_setup_info (const std::string& script_path)
3789 {
3790         std::map<std::string, std::string> rv;
3791
3792         if (!Glib::file_test (script_path, Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR)) {
3793                 return rv;
3794         }
3795
3796         LuaState lua;
3797         lua.Print.connect (&_lua_print);
3798         lua.sandbox (true);
3799
3800         lua_State* L = lua.getState();
3801         LuaInstance::register_classes (L);
3802         LuaBindings::set_session (L, _session);
3803         luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
3804         lua_setglobal (L, "Editor");
3805
3806         lua.do_command ("function ardour () end");
3807         lua.do_file (script_path);
3808
3809         try {
3810                 luabridge::LuaRef fn = luabridge::getGlobal (L, "route_setup");
3811                 if (!fn.isFunction ()) {
3812                         return rv;
3813                 }
3814                 luabridge::LuaRef rs = fn ();
3815                 if (!rs.isTable ()) {
3816                         return rv;
3817                 }
3818                 for (luabridge::Iterator i(rs); !i.isNil (); ++i) {
3819                         if (!i.key().isString()) {
3820                                 continue;
3821                         }
3822                         std::string key = i.key().tostring();
3823                         if (i.value().isString() || i.value().isNumber() || i.value().isBoolean()) {
3824                                 rv[key] = i.value().tostring();
3825                         }
3826                 }
3827         } catch (luabridge::LuaException const& e) {
3828                 cerr << "LuaException:" << e.what () << endl;
3829         } catch (...) { }
3830         return rv;
3831 }
3832
3833 void
3834 ARDOUR_UI::meta_route_setup (const std::string& script_path)
3835 {
3836         if (!Glib::file_test (script_path, Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR)) {
3837                 return;
3838         }
3839         assert (add_route_dialog);
3840
3841         int count;
3842         if ((count = add_route_dialog->count()) <= 0) {
3843                 return;
3844         }
3845
3846         LuaState lua;
3847         lua.Print.connect (&_lua_print);
3848         lua.sandbox (true);
3849
3850         lua_State* L = lua.getState();
3851         LuaInstance::register_classes (L);
3852         LuaBindings::set_session (L, _session);
3853         luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
3854         lua_setglobal (L, "Editor");
3855
3856         lua.do_command ("function ardour () end");
3857         lua.do_file (script_path);
3858
3859         luabridge::LuaRef args (luabridge::newTable (L));
3860
3861         args["name"]       = add_route_dialog->name_template ();
3862         args["insert_at"]  = translate_order (add_route_dialog->insert_at());
3863         args["group"]      = add_route_dialog->route_group ();
3864         args["strict_io"]  = add_route_dialog->use_strict_io ();
3865         args["instrument"] = add_route_dialog->requested_instrument ();
3866         args["track_mode"] = add_route_dialog->mode ();
3867         args["channels"]   = add_route_dialog->channel_count ();
3868         args["how_many"]   = count;
3869
3870         try {
3871                 luabridge::LuaRef fn = luabridge::getGlobal (L, "factory");
3872                 if (fn.isFunction()) {
3873                         fn (args)();
3874                 }
3875         } catch (luabridge::LuaException const& e) {
3876                 cerr << "LuaException:" << e.what () << endl;
3877         } catch (...) {
3878                 display_insufficient_ports_message ();
3879         }
3880 }
3881
3882 void
3883 ARDOUR_UI::meta_session_setup (const std::string& script_path)
3884 {
3885         if (!Glib::file_test (script_path, Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR)) {
3886                 return;
3887         }
3888
3889         LuaState lua;
3890         lua.Print.connect (&_lua_print);
3891         lua.sandbox (true);
3892
3893         lua_State* L = lua.getState();
3894         LuaInstance::register_classes (L);
3895         LuaBindings::set_session (L, _session);
3896         luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
3897         lua_setglobal (L, "Editor");
3898
3899         lua.do_command ("function ardour () end");
3900         lua.do_file (script_path);
3901
3902         try {
3903                 luabridge::LuaRef fn = luabridge::getGlobal (L, "factory");
3904                 if (fn.isFunction()) {
3905                         fn ()();
3906                 }
3907         } catch (luabridge::LuaException const& e) {
3908                 cerr << "LuaException:" << e.what () << endl;
3909         } catch (...) {
3910                 display_insufficient_ports_message ();
3911         }
3912 }
3913
3914 void
3915 ARDOUR_UI::launch_chat ()
3916 {
3917         MessageDialog dialog(_("<b>Just ask and wait for an answer.\nIt may take from minutes to hours.</b>"), true);
3918
3919         dialog.set_title (_("About the Chat"));
3920         dialog.set_secondary_text (_("When you're inside the chat just ask your question and wait for an answer. The chat is occupied by real people with real lives so many of them are passively online and might not read your question before minutes or hours later.\nSo please be patient and wait for an answer.\n\nYou should just leave the chat window open and check back regularly until someone has answered your question."));
3921
3922         switch (dialog.run()) {
3923         case RESPONSE_OK:
3924 #ifdef __APPLE__
3925                 open_uri("http://webchat.freenode.net/?channels=ardour-osx");
3926 #elif defined PLATFORM_WINDOWS
3927                 open_uri("http://webchat.freenode.net/?channels=ardour-windows");
3928 #else
3929                 open_uri("http://webchat.freenode.net/?channels=ardour");
3930 #endif
3931                 break;
3932         default:
3933                 break;
3934         }
3935 }
3936
3937 void
3938 ARDOUR_UI::launch_manual ()
3939 {
3940         PBD::open_uri (Config->get_tutorial_manual_url());
3941 }
3942
3943 void
3944 ARDOUR_UI::launch_reference ()
3945 {
3946         PBD::open_uri (Config->get_reference_manual_url());
3947 }
3948
3949 void
3950 ARDOUR_UI::launch_tracker ()
3951 {
3952         PBD::open_uri ("http://tracker.ardour.org");
3953 }
3954
3955 void
3956 ARDOUR_UI::launch_subscribe ()
3957 {
3958         PBD::open_uri ("https://community.ardour.org/s/subscribe");
3959 }
3960
3961 void
3962 ARDOUR_UI::launch_cheat_sheet ()
3963 {
3964 #ifdef __APPLE__
3965         PBD::open_uri ("http://manual.ardour.org/files/a3_mnemonic_cheat_sheet_osx.pdf");
3966 #else
3967         PBD::open_uri ("http://manual.ardour.org/files/a3_mnemonic_cheatsheet.pdf");
3968 #endif
3969 }
3970
3971 void
3972 ARDOUR_UI::launch_website ()
3973 {
3974         PBD::open_uri ("http://ardour.org");
3975 }
3976
3977 void
3978 ARDOUR_UI::launch_website_dev ()
3979 {
3980         PBD::open_uri ("http://ardour.org/development.html");
3981 }
3982
3983 void
3984 ARDOUR_UI::launch_forums ()
3985 {
3986         PBD::open_uri ("https://community.ardour.org/forums");
3987 }
3988
3989 void
3990 ARDOUR_UI::launch_howto_report ()
3991 {
3992         PBD::open_uri ("http://ardour.org/reporting_bugs");
3993 }
3994
3995 void
3996 ARDOUR_UI::loading_message (const std::string& msg)
3997 {
3998         if (ARDOUR_COMMAND_LINE::no_splash) {
3999                 return;
4000         }
4001
4002         if (!splash) {
4003                 show_splash ();
4004         }
4005
4006         splash->message (msg);
4007 }
4008
4009 void
4010 ARDOUR_UI::show_splash ()
4011 {
4012         if (splash == 0) {
4013                 try {
4014                         splash = new Splash;
4015                 } catch (...) {
4016                         return;
4017                 }
4018         }
4019
4020         splash->display ();
4021 }
4022
4023 void
4024 ARDOUR_UI::hide_splash ()
4025 {
4026         delete splash;
4027         splash = 0;
4028 }
4029
4030 void
4031 ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title, const bool msg_delete)
4032 {
4033         size_t removed;
4034
4035         removed = rep.paths.size();
4036
4037         if (removed == 0) {
4038                 MessageDialog msgd (_main_window,
4039                                     _("No files were ready for clean-up"),
4040                                     true,
4041                                     Gtk::MESSAGE_INFO,
4042                                     Gtk::BUTTONS_OK);
4043                 msgd.set_title (_("Clean-up"));
4044                 msgd.set_secondary_text (_("If this seems surprising, \n\
4045 check for any existing snapshots.\n\
4046 These may still include regions that\n\
4047 require some unused files to continue to exist."));
4048
4049                 msgd.run ();
4050                 return;
4051         }
4052
4053         ArdourDialog results (_("Clean-up"), true, false);
4054
4055         struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
4056                 CleanupResultsModelColumns() {
4057                         add (visible_name);
4058                         add (fullpath);
4059                 }
4060                 Gtk::TreeModelColumn<std::string> visible_name;
4061                 Gtk::TreeModelColumn<std::string> fullpath;
4062         };
4063
4064
4065         CleanupResultsModelColumns results_columns;
4066         Glib::RefPtr<Gtk::ListStore> results_model;
4067         Gtk::TreeView results_display;
4068
4069         results_model = ListStore::create (results_columns);
4070         results_display.set_model (results_model);
4071         results_display.append_column (list_title, results_columns.visible_name);
4072
4073         results_display.set_name ("CleanupResultsList");
4074         results_display.set_headers_visible (true);
4075         results_display.set_headers_clickable (false);
4076         results_display.set_reorderable (false);
4077
4078         Gtk::ScrolledWindow list_scroller;
4079         Gtk::Label txt;
4080         Gtk::VBox dvbox;
4081         Gtk::HBox dhbox;  // the hbox for the image and text
4082         Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
4083         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO,  Gtk::ICON_SIZE_DIALOG));
4084
4085         dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
4086
4087         const string dead_directory = _session->session_directory().dead_path();
4088
4089         /* subst:
4090            %1 - number of files removed
4091            %2 - location of "dead"
4092            %3 - size of files affected
4093            %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
4094         */
4095
4096         const char* bprefix;
4097         double space_adjusted = 0;
4098
4099         if (rep.space < 1000) {
4100                 bprefix = X_("");
4101                 space_adjusted = rep.space;
4102         } else if (rep.space < 1000000) {
4103                 bprefix = _("kilo");
4104                 space_adjusted = floorf((float)rep.space / 1000.0);
4105         } else if (rep.space < 1000000 * 1000) {
4106                 bprefix = _("mega");
4107                 space_adjusted = floorf((float)rep.space / (1000.0 * 1000.0));
4108         } else {
4109                 bprefix = _("giga");
4110                 space_adjusted = floorf((float)rep.space / (1000.0 * 1000 * 1000.0));
4111         }
4112
4113         if (msg_delete) {
4114                 txt.set_markup (string_compose (P_("\
4115 The following file was deleted from %2,\n\
4116 releasing %3 %4bytes of disk space", "\
4117 The following %1 files were deleted from %2,\n\
4118 releasing %3 %4bytes of disk space", removed),
4119                                         removed, Gtkmm2ext::markup_escape_text (dead_directory), space_adjusted, bprefix, PROGRAM_NAME));
4120         } else {
4121                 txt.set_markup (string_compose (P_("\
4122 The following file was not in use and \n\
4123 has been moved to: %2\n\n\
4124 After a restart of %5\n\n\
4125 <span face=\"mono\">Session -> Clean-up -> Flush Wastebasket</span>\n\n\
4126 will release an additional %3 %4bytes of disk space.\n", "\
4127 The following %1 files were not in use and \n\
4128 have been moved to: %2\n\n\
4129 After a restart of %5\n\n\
4130 <span face=\"mono\">Session -> Clean-up -> Flush Wastebasket</span>\n\n\
4131 will release an additional %3 %4bytes of disk space.\n", removed),
4132                                         removed, Gtkmm2ext::markup_escape_text (dead_directory), space_adjusted, bprefix, PROGRAM_NAME));
4133         }
4134
4135         dhbox.pack_start (*dimage, true, false, 5);
4136         dhbox.pack_start (txt, true, false, 5);
4137
4138         for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
4139                 TreeModel::Row row = *(results_model->append());
4140                 row[results_columns.visible_name] = *i;
4141                 row[results_columns.fullpath] = *i;
4142         }
4143
4144         list_scroller.add (results_display);
4145         list_scroller.set_size_request (-1, 150);
4146         list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
4147
4148         dvbox.pack_start (dhbox, true, false, 5);
4149         dvbox.pack_start (list_scroller, true, false, 5);
4150         ddhbox.pack_start (dvbox, true, false, 5);
4151
4152         results.get_vbox()->pack_start (ddhbox, true, false, 5);
4153         results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
4154         results.set_default_response (RESPONSE_CLOSE);
4155         results.set_position (Gtk::WIN_POS_MOUSE);
4156
4157         results_display.show();
4158         list_scroller.show();
4159         txt.show();
4160         dvbox.show();
4161         dhbox.show();
4162         ddhbox.show();
4163         dimage->show();
4164
4165         //results.get_vbox()->show();
4166         results.set_resizable (false);
4167
4168         results.run ();
4169
4170 }
4171
4172 void
4173 ARDOUR_UI::cleanup ()
4174 {
4175         if (_session == 0) {
4176                 /* shouldn't happen: menu item is insensitive */
4177                 return;
4178         }
4179
4180
4181         MessageDialog checker (_("Are you sure you want to clean-up?"),
4182                                 true,
4183                                 Gtk::MESSAGE_QUESTION,
4184                                 Gtk::BUTTONS_NONE);
4185
4186         checker.set_title (_("Clean-up"));
4187
4188         checker.set_secondary_text(_("Clean-up is a destructive operation.\n\
4189 ALL undo/redo information will be lost if you clean-up.\n\
4190 Clean-up will move all unused files to a \"dead\" location."));
4191
4192         checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
4193         checker.add_button (_("Clean-up"), RESPONSE_ACCEPT);
4194         checker.set_default_response (RESPONSE_CANCEL);
4195
4196         checker.set_name (_("CleanupDialog"));
4197         checker.set_wmclass (X_("ardour_cleanup"), PROGRAM_NAME);
4198         checker.set_position (Gtk::WIN_POS_MOUSE);
4199
4200         switch (checker.run()) {
4201         case RESPONSE_ACCEPT:
4202                 break;
4203         default:
4204                 return;
4205         }
4206
4207         ARDOUR::CleanupReport rep;
4208
4209         editor->prepare_for_cleanup ();
4210
4211         /* do not allow flush until a session is reloaded */
4212
4213         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
4214         if (act) {
4215                 act->set_sensitive (false);
4216         }
4217
4218         if (_session->cleanup_sources (rep)) {
4219                 editor->finish_cleanup ();
4220                 return;
4221         }
4222
4223         editor->finish_cleanup ();
4224
4225         checker.hide();
4226         display_cleanup_results (rep, _("Cleaned Files"), false);
4227 }
4228
4229 void
4230 ARDOUR_UI::flush_trash ()
4231 {
4232         if (_session == 0) {
4233                 /* shouldn't happen: menu item is insensitive */
4234                 return;
4235         }
4236
4237         ARDOUR::CleanupReport rep;
4238
4239         if (_session->cleanup_trash_sources (rep)) {
4240                 return;
4241         }
4242
4243         display_cleanup_results (rep, _("deleted file"), true);
4244 }
4245
4246 void
4247 ARDOUR_UI::cleanup_peakfiles ()
4248 {
4249         if (_session == 0) {
4250                 /* shouldn't happen: menu item is insensitive */
4251                 return;
4252         }
4253
4254         if (! _session->can_cleanup_peakfiles ()) {
4255                 return;
4256         }
4257
4258         // get all region-views in this session
4259         RegionSelection rs;
4260         TrackViewList empty;
4261         empty.clear();
4262         editor->get_regions_after(rs, (samplepos_t) 0, empty);
4263         std::list<RegionView*> views = rs.by_layer();
4264
4265         // remove displayed audio-region-views waveforms
4266         for (list<RegionView*>::iterator i = views.begin(); i != views.end(); ++i) {
4267                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*i);
4268                 if (!arv) { continue ; }
4269                 arv->delete_waves();
4270         }
4271
4272         // cleanup peak files:
4273         // - stop pending peakfile threads
4274         // - close peakfiles if any
4275         // - remove peak dir in session
4276         // - setup peakfiles (background thread)
4277         _session->cleanup_peakfiles ();
4278
4279         // re-add waves to ARV
4280         for (list<RegionView*>::iterator i = views.begin(); i != views.end(); ++i) {
4281                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*i);
4282                 if (!arv) { continue ; }
4283                 arv->create_waves();
4284         }
4285 }
4286
4287 PresentationInfo::order_t
4288 ARDOUR_UI::translate_order (RouteDialogs::InsertAt place)
4289 {
4290         if (editor->get_selection().tracks.empty()) {
4291                 return place == RouteDialogs::First ? 0 : PresentationInfo::max_order;
4292         }
4293
4294         PresentationInfo::order_t order_hint = PresentationInfo::max_order;
4295
4296         /*
4297           we want the new routes to have their order keys set starting from
4298           the highest order key in the selection + 1 (if available).
4299         */
4300
4301         if (place == RouteDialogs::AfterSelection) {
4302                 RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView*> (editor->get_selection().tracks.back());
4303                 if (rtav) {
4304                         order_hint = rtav->route()->presentation_info().order();
4305                         order_hint++;
4306                 }
4307         } else if (place == RouteDialogs::BeforeSelection) {
4308                 RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView*> (editor->get_selection().tracks.front());
4309                 if (rtav) {
4310                         order_hint = rtav->route()->presentation_info().order();
4311                 }
4312         } else if (place == RouteDialogs::First) {
4313                 order_hint = 0;
4314         } else {
4315                 /* leave order_hint at max_order */
4316         }
4317
4318         return order_hint;
4319 }
4320
4321 void
4322 ARDOUR_UI::start_duplicate_routes ()
4323 {
4324         if (!duplicate_routes_dialog) {
4325                 duplicate_routes_dialog = new DuplicateRouteDialog;
4326         }
4327
4328         if (duplicate_routes_dialog->restart (_session)) {
4329                 return;
4330         }
4331
4332         duplicate_routes_dialog->present ();
4333 }
4334
4335 void
4336 ARDOUR_UI::add_route ()
4337 {
4338         if (!add_route_dialog.get (false)) {
4339                 add_route_dialog->signal_response().connect (sigc::mem_fun (*this, &ARDOUR_UI::add_route_dialog_response));
4340         }
4341
4342         if (!_session) {
4343                 return;
4344         }
4345
4346         if (add_route_dialog->is_visible()) {
4347                 /* we're already doing this */
4348                 return;
4349         }
4350
4351         add_route_dialog->set_position (WIN_POS_MOUSE);
4352         add_route_dialog->present();
4353 }
4354
4355 void
4356 ARDOUR_UI::add_route_dialog_response (int r)
4357 {
4358         if (!_session) {
4359                 warning << _("You cannot add tracks or busses without a session already loaded.") << endmsg;
4360                 return;
4361         }
4362
4363         int count;
4364
4365         switch (r) {
4366         case AddRouteDialog::Add:
4367                 add_route_dialog->reset_name_edited ();
4368                 break;
4369         case AddRouteDialog::AddAndClose:
4370                 add_route_dialog->ArdourDialog::on_response (r);
4371                 break;
4372         default:
4373                 add_route_dialog->ArdourDialog::on_response (r);
4374                 return;
4375         }
4376
4377         std::string template_path = add_route_dialog->get_template_path();
4378         if (!template_path.empty() && template_path.substr (0, 11) == "urn:ardour:") {
4379                 meta_route_setup (template_path.substr (11));
4380                 return;
4381         }
4382
4383         if ((count = add_route_dialog->count()) <= 0) {
4384                 return;
4385         }
4386
4387         PresentationInfo::order_t order = translate_order (add_route_dialog->insert_at());
4388         const string name_template = add_route_dialog->name_template ();
4389         DisplaySuspender ds;
4390
4391         if (!template_path.empty ()) {
4392                 if (add_route_dialog->name_template_is_default ()) {
4393                         _session->new_route_from_template (count, order, template_path, string ());
4394                 } else {
4395                         _session->new_route_from_template (count, order, template_path, name_template);
4396                 }
4397                 return;
4398         }
4399
4400         ChanCount input_chan= add_route_dialog->channels ();
4401         ChanCount output_chan;
4402         PluginInfoPtr instrument = add_route_dialog->requested_instrument ();
4403         RouteGroup* route_group = add_route_dialog->route_group ();
4404         AutoConnectOption oac = Config->get_output_auto_connect();
4405         bool strict_io = add_route_dialog->use_strict_io ();
4406
4407         if (oac & AutoConnectMaster) {
4408                 output_chan.set (DataType::AUDIO, (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan.n_audio()));
4409                 output_chan.set (DataType::MIDI, 0);
4410         } else {
4411                 output_chan = input_chan;
4412         }
4413
4414         /* XXX do something with name template */
4415
4416         Session::ProcessorChangeBlocker pcb (_session);
4417
4418         switch (add_route_dialog->type_wanted()) {
4419         case AddRouteDialog::AudioTrack:
4420                 session_add_audio_route (true, input_chan.n_audio(), output_chan.n_audio(), add_route_dialog->mode(), route_group, count, name_template, strict_io, order);
4421                 break;
4422         case AddRouteDialog::MidiTrack:
4423                 session_add_midi_route (true, route_group, count, name_template, strict_io, instrument, 0, order);
4424                 break;
4425         case AddRouteDialog::MixedTrack:
4426                 session_add_mixed_track (input_chan, output_chan, route_group, count, name_template, strict_io, instrument, 0, order);
4427                 break;
4428         case AddRouteDialog::AudioBus:
4429                 session_add_audio_route (false, input_chan.n_audio(), output_chan.n_audio(), ARDOUR::Normal, route_group, count, name_template, strict_io, order);
4430                 break;
4431         case AddRouteDialog::MidiBus:
4432                 session_add_midi_bus (route_group, count, name_template, strict_io, instrument, 0, order);
4433                 break;
4434         case AddRouteDialog::VCAMaster:
4435                 _session->vca_manager().create_vca (count, name_template);
4436                 break;
4437         }
4438 }
4439
4440 void
4441 ARDOUR_UI::stop_video_server (bool ask_confirm)
4442 {
4443         if (!video_server_process && ask_confirm) {
4444                 warning << string_compose (_("Video-Server was not launched by %1. The request to stop it is ignored."), PROGRAM_NAME) << endmsg;
4445         }
4446         if (video_server_process) {
4447                 if(ask_confirm) {
4448                         ArdourDialog confirm (_("Stop Video-Server"), true);
4449                         Label m (_("Do you really want to stop the Video Server?"));
4450                         confirm.get_vbox()->pack_start (m, true, true);
4451                         confirm.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4452                         confirm.add_button (_("Yes, Stop It"), Gtk::RESPONSE_ACCEPT);
4453                         confirm.show_all ();
4454                         if (confirm.run() == RESPONSE_CANCEL) {
4455                                 return;
4456                         }
4457                 }
4458                 delete video_server_process;
4459                 video_server_process =0;
4460         }
4461 }
4462
4463 void
4464 ARDOUR_UI::start_video_server_menu (Gtk::Window* float_window)
4465 {
4466   ARDOUR_UI::start_video_server( float_window, true);
4467 }
4468
4469 bool
4470 ARDOUR_UI::start_video_server (Gtk::Window* float_window, bool popup_msg)
4471 {
4472         if (!_session) {
4473                 return false;
4474         }
4475         if (popup_msg) {
4476                 if (ARDOUR_UI::instance()->video_timeline->check_server()) {
4477                         if (video_server_process) {
4478                                 popup_error(_("The Video Server is already started."));
4479                         } else {
4480                                 popup_error(_("An external Video Server is configured and can be reached. Not starting a new instance."));
4481                         }
4482                 }
4483         }
4484
4485         int firsttime = 0;
4486         while (!ARDOUR_UI::instance()->video_timeline->check_server()) {
4487                 if (firsttime++) {
4488                         warning << _("Could not connect to the Video Server. Start it or configure its access URL in Preferences.") << endmsg;
4489                 }
4490                 VideoServerDialog *video_server_dialog = new VideoServerDialog (_session);
4491                 if (float_window) {
4492                         video_server_dialog->set_transient_for (*float_window);
4493                 }
4494
4495                 if (!Config->get_show_video_server_dialog() && firsttime < 2) {
4496                         video_server_dialog->hide();
4497                 } else {
4498                         ResponseType r = (ResponseType) video_server_dialog->run ();
4499                         video_server_dialog->hide();
4500                         if (r != RESPONSE_ACCEPT) { return false; }
4501                         if (video_server_dialog->show_again()) {
4502                                 Config->set_show_video_server_dialog(false);
4503                         }
4504                 }
4505
4506                 std::string icsd_exec = video_server_dialog->get_exec_path();
4507                 std::string icsd_docroot = video_server_dialog->get_docroot();
4508 #ifndef PLATFORM_WINDOWS
4509                 if (icsd_docroot.empty()) {
4510                         icsd_docroot = VideoUtils::video_get_docroot (Config);
4511                 }
4512 #endif
4513
4514                 GStatBuf sb;
4515 #ifdef PLATFORM_WINDOWS
4516                 if (VideoUtils::harvid_version >= 0x000802 && icsd_docroot.empty()) {
4517                         /* OK, allow all drive letters */
4518                 } else
4519 #endif
4520                 if (g_lstat (icsd_docroot.c_str(), &sb) != 0 || !S_ISDIR(sb.st_mode)) {
4521                         warning << _("Specified docroot is not an existing directory.") << endmsg;
4522                         continue;
4523                 }
4524 #ifndef PLATFORM_WINDOWS
4525                 if ( (g_lstat (icsd_exec.c_str(), &sb) != 0)
4526                      || (sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0 ) {
4527                         warning << _("Given Video Server is not an executable file.") << endmsg;
4528                         continue;
4529                 }
4530 #else
4531                 if ( (g_lstat (icsd_exec.c_str(), &sb) != 0)
4532                      || (sb.st_mode & (S_IXUSR)) == 0 ) {
4533                         warning << _("Given Video Server is not an executable file.") << endmsg;
4534                         continue;
4535                 }
4536 #endif
4537
4538                 char **argp;
4539                 argp=(char**) calloc(9,sizeof(char*));
4540                 argp[0] = strdup(icsd_exec.c_str());
4541                 argp[1] = strdup("-P");
4542                 argp[2] = (char*) calloc(16,sizeof(char)); snprintf(argp[2], 16, "%s", video_server_dialog->get_listenaddr().c_str());
4543                 argp[3] = strdup("-p");
4544                 argp[4] = (char*) calloc(6,sizeof(char)); snprintf(argp[4], 6, "%i", video_server_dialog->get_listenport());
4545                 argp[5] = strdup("-C");
4546                 argp[6] = (char*) calloc(6,sizeof(char)); snprintf(argp[6], 6, "%i", video_server_dialog->get_cachesize());
4547                 argp[7] = strdup(icsd_docroot.c_str());
4548                 argp[8] = 0;
4549                 stop_video_server();
4550
4551 #ifdef PLATFORM_WINDOWS
4552                 if (VideoUtils::harvid_version >= 0x000802 && icsd_docroot.empty()) {
4553                         /* OK, allow all drive letters */
4554                 } else
4555 #endif
4556                 if (icsd_docroot == X_("/") || icsd_docroot == X_("C:\\")) {
4557                         Config->set_video_advanced_setup(false);
4558                 } else {
4559                         std::string url_str = "http://127.0.0.1:" + to_string(video_server_dialog->get_listenport()) + "/";
4560                         Config->set_video_server_url(url_str);
4561                         Config->set_video_server_docroot(icsd_docroot);
4562                         Config->set_video_advanced_setup(true);
4563                 }
4564
4565                 if (video_server_process) {
4566                         delete video_server_process;
4567                 }
4568
4569                 video_server_process = new ARDOUR::SystemExec(icsd_exec, argp);
4570                 if (video_server_process->start()) {
4571                         warning << _("Cannot launch the video-server") << endmsg;
4572                         continue;
4573                 }
4574                 int timeout = 120; // 6 sec
4575                 while (!ARDOUR_UI::instance()->video_timeline->check_server()) {
4576                         Glib::usleep (50000);
4577                         gui_idle_handler();
4578                         if (--timeout <= 0 || !video_server_process->is_running()) break;
4579                 }
4580                 if (timeout <= 0) {
4581                         warning << _("Video-server was started but does not respond to requests...") << endmsg;
4582                 } else {
4583                         if (!ARDOUR_UI::instance()->video_timeline->check_server_docroot()) {
4584                                 delete video_server_process;
4585                                 video_server_process = 0;
4586                         }
4587                 }
4588         }
4589         return true;
4590 }
4591
4592 void
4593 ARDOUR_UI::add_video (Gtk::Window* float_window)
4594 {
4595         if (!_session) {
4596                 return;
4597         }
4598
4599         if (!start_video_server(float_window, false)) {
4600                 warning << _("Could not connect to the Video Server. Start it or configure its access URL in Preferences.") << endmsg;
4601                 return;
4602         }
4603
4604         if (float_window) {
4605                 add_video_dialog->set_transient_for (*float_window);
4606         }
4607
4608         if (add_video_dialog->is_visible()) {
4609                 /* we're already doing this */
4610                 return;
4611         }
4612
4613         ResponseType r = (ResponseType) add_video_dialog->run ();
4614         add_video_dialog->hide();
4615         if (r != RESPONSE_ACCEPT) { return; }
4616
4617         bool local_file, orig_local_file;
4618         std::string path = add_video_dialog->file_name(local_file);
4619
4620         std::string orig_path = path;
4621         orig_local_file = local_file;
4622
4623         bool auto_set_session_fps = add_video_dialog->auto_set_session_fps();
4624
4625         if (local_file && !Glib::file_test(path, Glib::FILE_TEST_EXISTS)) {
4626                 warning << string_compose(_("could not open %1"), path) << endmsg;
4627                 return;
4628         }
4629         if (!local_file && path.length() == 0) {
4630                 warning << _("no video-file selected") << endmsg;
4631                 return;
4632         }
4633
4634         std::string audio_from_video;
4635         bool detect_ltc = false;
4636
4637         switch (add_video_dialog->import_option()) {
4638                 case VTL_IMPORT_TRANSCODE:
4639                         {
4640                                 TranscodeVideoDialog *transcode_video_dialog;
4641                                 transcode_video_dialog = new TranscodeVideoDialog (_session, path);
4642                                 ResponseType r = (ResponseType) transcode_video_dialog->run ();
4643                                 transcode_video_dialog->hide();
4644                                 if (r != RESPONSE_ACCEPT) {
4645                                         delete transcode_video_dialog;
4646                                         return;
4647                                 }
4648
4649                                 audio_from_video = transcode_video_dialog->get_audiofile();
4650
4651                                 if (!audio_from_video.empty() && transcode_video_dialog->detect_ltc()) {
4652                                         detect_ltc = true;
4653                                 }
4654                                 else if (!audio_from_video.empty()) {
4655                                         editor->embed_audio_from_video(
4656                                                         audio_from_video,
4657                                                         video_timeline->get_offset(),
4658                                                         (transcode_video_dialog->import_option() != VTL_IMPORT_NO_VIDEO)
4659                                                         );
4660                                 }
4661                                 switch (transcode_video_dialog->import_option()) {
4662                                         case VTL_IMPORT_TRANSCODED:
4663                                                 path = transcode_video_dialog->get_filename();
4664                                                 local_file = true;
4665                                                 break;
4666                                         case VTL_IMPORT_REFERENCE:
4667                                                 break;
4668                                         default:
4669                                                 delete transcode_video_dialog;
4670                                                 return;
4671                                 }
4672                                 delete transcode_video_dialog;
4673                         }
4674                         break;
4675                 default:
4676                 case VTL_IMPORT_NONE:
4677                         break;
4678         }
4679
4680         /* strip _session->session_directory().video_path() from video file if possible */
4681         if (local_file && !path.compare(0, _session->session_directory().video_path().size(), _session->session_directory().video_path())) {
4682                  path=path.substr(_session->session_directory().video_path().size());
4683                  if (path.at(0) == G_DIR_SEPARATOR) {
4684                          path=path.substr(1);
4685                  }
4686         }
4687
4688         video_timeline->set_update_session_fps(auto_set_session_fps);
4689
4690         if (video_timeline->video_file_info(path, local_file)) {
4691                 XMLNode* node = new XMLNode(X_("Videotimeline"));
4692                 node->set_property (X_("Filename"), path);
4693                 node->set_property (X_("AutoFPS"), auto_set_session_fps);
4694                 node->set_property (X_("LocalFile"), local_file);
4695                 if (orig_local_file) {
4696                         node->set_property (X_("OriginalVideoFile"), orig_path);
4697                 } else {
4698                         node->remove_property (X_("OriginalVideoFile"));
4699                 }
4700                 _session->add_extra_xml (*node);
4701                 _session->set_dirty ();
4702
4703                 if (!audio_from_video.empty() && detect_ltc) {
4704                         std::vector<LTCFileReader::LTCMap> ltc_seq;
4705
4706                         try {
4707                                 /* TODO ask user about TV standard (LTC alignment if any) */
4708                                 LTCFileReader ltcr (audio_from_video, video_timeline->get_video_file_fps());
4709                                 /* TODO ASK user which channel:  0 .. ltcr->channels() - 1 */
4710
4711                                 ltc_seq = ltcr.read_ltc (/*channel*/ 0, /*max LTC samples to decode*/ 15);
4712
4713                                 /* TODO seek near end of file, and read LTC until end.
4714                                  * if it fails to find any LTC samples, scan complete file
4715                                  *
4716                                  * calculate drift of LTC compared to video-duration,
4717                                  * ask user for reference (timecode from start/mid/end)
4718                                  */
4719                         } catch (...) {
4720                                 // LTCFileReader will have written error messages
4721                         }
4722
4723                         ::g_unlink(audio_from_video.c_str());
4724
4725                         if (ltc_seq.size() == 0) {
4726                                 PBD::error << _("No LTC detected, video will not be aligned.") << endmsg;
4727                         } else {
4728                                 /* the very first TC in the file is somteimes not aligned properly */
4729                                 int i = ltc_seq.size() -1;
4730                                 ARDOUR::sampleoffset_t video_start_offset =
4731                                         _session->nominal_sample_rate() * (ltc_seq[i].timecode_sec - ltc_seq[i].framepos_sec);
4732                                 PBD::info << string_compose (_("Align video-start to %1 [samples]"), video_start_offset) << endmsg;
4733                                 video_timeline->set_offset(video_start_offset);
4734                         }
4735                 }
4736
4737                 _session->maybe_update_session_range(
4738                         std::max(video_timeline->get_offset(), (ARDOUR::sampleoffset_t) 0),
4739                         std::max(video_timeline->get_offset() + video_timeline->get_duration(), (ARDOUR::sampleoffset_t) 0));
4740
4741
4742                 if (add_video_dialog->launch_xjadeo() && local_file) {
4743                         editor->set_xjadeo_sensitive(true);
4744                         editor->toggle_xjadeo_proc(1);
4745                 } else {
4746                         editor->toggle_xjadeo_proc(0);
4747                 }
4748                 editor->toggle_ruler_video(true);
4749         }
4750 }
4751
4752 void
4753 ARDOUR_UI::remove_video ()
4754 {
4755         video_timeline->close_session();
4756         editor->toggle_ruler_video(false);
4757
4758         /* reset state */
4759         video_timeline->set_offset_locked(false);
4760         video_timeline->set_offset(0);
4761
4762         /* delete session state */
4763         XMLNode* node = new XMLNode(X_("Videotimeline"));
4764         _session->add_extra_xml(*node);
4765         node = new XMLNode(X_("Videomonitor"));
4766         _session->add_extra_xml(*node);
4767         node = new XMLNode(X_("Videoexport"));
4768         _session->add_extra_xml(*node);
4769         stop_video_server();
4770 }
4771
4772 void
4773 ARDOUR_UI::flush_videotimeline_cache (bool localcacheonly)
4774 {
4775         if (localcacheonly) {
4776                 video_timeline->vmon_update();
4777         } else {
4778                 video_timeline->flush_cache();
4779         }
4780         editor->queue_visual_videotimeline_update();
4781 }
4782
4783 void
4784 ARDOUR_UI::export_video (bool range)
4785 {
4786         if (ARDOUR::Config->get_show_video_export_info()) {
4787                 ExportVideoInfobox infobox (_session);
4788                 Gtk::ResponseType rv = (Gtk::ResponseType) infobox.run();
4789                 if (infobox.show_again()) {
4790                         ARDOUR::Config->set_show_video_export_info(false);
4791                 }
4792                 switch (rv) {
4793                         case GTK_RESPONSE_YES:
4794                                 PBD::open_uri (ARDOUR::Config->get_reference_manual_url() + "/video-timeline/operations/#export");
4795                                 break;
4796                         default:
4797                                 break;
4798                 }
4799         }
4800         export_video_dialog->set_session (_session);
4801         export_video_dialog->apply_state(editor->get_selection().time, range);
4802         export_video_dialog->run ();
4803         export_video_dialog->hide ();
4804 }
4805
4806 XMLNode*
4807 ARDOUR_UI::preferences_settings () const
4808 {
4809         XMLNode* node = 0;
4810
4811         if (_session) {
4812                 node = _session->instant_xml(X_("Preferences"));
4813         } else {
4814                 node = Config->instant_xml(X_("Preferences"));
4815         }
4816
4817         if (!node) {
4818                 node = new XMLNode (X_("Preferences"));
4819         }
4820
4821         return node;
4822 }
4823
4824 XMLNode*
4825 ARDOUR_UI::mixer_settings () const
4826 {
4827         XMLNode* node = 0;
4828
4829         if (_session) {
4830                 node = _session->instant_xml(X_("Mixer"));
4831         } else {
4832                 node = Config->instant_xml(X_("Mixer"));
4833         }
4834
4835         if (!node) {
4836                 node = new XMLNode (X_("Mixer"));
4837         }
4838
4839         return node;
4840 }
4841
4842 XMLNode*
4843 ARDOUR_UI::main_window_settings () const
4844 {
4845         XMLNode* node = 0;
4846
4847         if (_session) {
4848                 node = _session->instant_xml(X_("Main"));
4849         } else {
4850                 node = Config->instant_xml(X_("Main"));
4851         }
4852
4853         if (!node) {
4854                 if (getenv("ARDOUR_INSTANT_XML_PATH")) {
4855                         node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
4856                 }
4857         }
4858
4859         if (!node) {
4860                 node = new XMLNode (X_("Main"));
4861         }
4862
4863         return node;
4864 }
4865
4866 XMLNode*
4867 ARDOUR_UI::editor_settings () const
4868 {
4869         XMLNode* node = 0;
4870
4871         if (_session) {
4872                 node = _session->instant_xml(X_("Editor"));
4873         } else {
4874                 node = Config->instant_xml(X_("Editor"));
4875         }
4876
4877         if (!node) {
4878                 if (getenv("ARDOUR_INSTANT_XML_PATH")) {
4879                         node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
4880                 }
4881         }
4882
4883         if (!node) {
4884                 node = new XMLNode (X_("Editor"));
4885         }
4886
4887         return node;
4888 }
4889
4890 XMLNode*
4891 ARDOUR_UI::keyboard_settings () const
4892 {
4893         XMLNode* node = 0;
4894
4895         node = Config->extra_xml(X_("Keyboard"));
4896
4897         if (!node) {
4898                 node = new XMLNode (X_("Keyboard"));
4899         }
4900
4901         return node;
4902 }
4903
4904 void
4905 ARDOUR_UI::create_xrun_marker (samplepos_t where)
4906 {
4907         if (_session) {
4908                 Location *location = new Location (*_session, where, where, _("xrun"), Location::IsMark, 0);
4909                 _session->locations()->add (location);
4910         }
4911 }
4912
4913 void
4914 ARDOUR_UI::halt_on_xrun_message ()
4915 {
4916         cerr << "HALT on xrun\n";
4917         MessageDialog msg (_main_window, _("Recording was stopped because your system could not keep up."));
4918         msg.run ();
4919 }
4920
4921 void
4922 ARDOUR_UI::xrun_handler (samplepos_t where)
4923 {
4924         if (!_session) {
4925                 return;
4926         }
4927
4928         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::xrun_handler, where)
4929
4930         if (_session && Config->get_create_xrun_marker() && _session->actively_recording()) {
4931                 create_xrun_marker(where);
4932         }
4933
4934         if (_session && Config->get_stop_recording_on_xrun() && _session->actively_recording()) {
4935                 halt_on_xrun_message ();
4936         }
4937 }
4938
4939 void
4940 ARDOUR_UI::disk_overrun_handler ()
4941 {
4942         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler)
4943
4944         if (!have_disk_speed_dialog_displayed) {
4945                 have_disk_speed_dialog_displayed = true;
4946                 MessageDialog* msg = new MessageDialog (_main_window, string_compose (_("\
4947 The disk system on your computer\n\
4948 was not able to keep up with %1.\n\
4949 \n\
4950 Specifically, it failed to write data to disk\n\
4951 quickly enough to keep up with recording.\n"), PROGRAM_NAME));
4952                 msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
4953                 msg->show ();
4954         }
4955 }
4956
4957
4958 /* TODO: this is getting elaborate enough to warrant being split into a dedicated class */
4959 static MessageDialog *scan_dlg = NULL;
4960 static ProgressBar   *scan_pbar = NULL;
4961 static HBox          *scan_tbox = NULL;
4962 static Gtk::Button   *scan_timeout_button;
4963
4964 void
4965 ARDOUR_UI::cancel_plugin_scan ()
4966 {
4967         PluginManager::instance().cancel_plugin_scan();
4968 }
4969
4970 void
4971 ARDOUR_UI::cancel_plugin_timeout ()
4972 {
4973         PluginManager::instance().cancel_plugin_timeout();
4974         scan_timeout_button->set_sensitive (false);
4975 }
4976
4977 void
4978 ARDOUR_UI::plugin_scan_timeout (int timeout)
4979 {
4980         if (!scan_dlg || !scan_dlg->is_mapped() || !scan_pbar) {
4981                 return;
4982         }
4983         if (timeout > 0) {
4984                 scan_pbar->set_sensitive (false);
4985                 scan_timeout_button->set_sensitive (true);
4986                 scan_pbar->set_fraction ((float) timeout / (float) Config->get_vst_scan_timeout());
4987                 scan_tbox->show();
4988         } else {
4989                 scan_pbar->set_sensitive (false);
4990                 scan_timeout_button->set_sensitive (false);
4991         }
4992         gui_idle_handler();
4993 }
4994
4995 void
4996 ARDOUR_UI::plugin_scan_dialog (std::string type, std::string plugin, bool can_cancel)
4997 {
4998         if (type == X_("closeme") && !(scan_dlg && scan_dlg->is_mapped())) {
4999                 return;
5000         }
5001
5002         const bool cancelled = PluginManager::instance().cancelled();
5003         if (type != X_("closeme") && (!UIConfiguration::instance().get_show_plugin_scan_window()) && !_initial_verbose_plugin_scan) {
5004                 if (cancelled && scan_dlg->is_mapped()) {
5005                         scan_dlg->hide();
5006                         gui_idle_handler();
5007                         return;
5008                 }
5009                 if (cancelled || !can_cancel) {
5010                         return;
5011                 }
5012         }
5013
5014         static Gtk::Button *cancel_button;
5015         if (!scan_dlg) {
5016                 scan_dlg = new MessageDialog("", false, MESSAGE_INFO, BUTTONS_NONE); // TODO manage
5017                 VBox* vbox = scan_dlg->get_vbox();
5018                 vbox->set_size_request(400,-1);
5019                 scan_dlg->set_title (_("Scanning for plugins"));
5020
5021                 cancel_button = manage(new Gtk::Button(_("Cancel plugin scan")));
5022                 cancel_button->set_name ("EditorGTKButton");
5023                 cancel_button->signal_clicked().connect ( mem_fun (*this, &ARDOUR_UI::cancel_plugin_scan) );
5024                 cancel_button->show();
5025
5026                 scan_dlg->get_vbox()->pack_start ( *cancel_button, PACK_SHRINK);
5027
5028                 scan_tbox = manage( new HBox() );
5029
5030                 scan_timeout_button = manage(new Gtk::Button(_("Stop Timeout")));
5031                 scan_timeout_button->set_name ("EditorGTKButton");
5032                 scan_timeout_button->signal_clicked().connect ( mem_fun (*this, &ARDOUR_UI::cancel_plugin_timeout) );
5033                 scan_timeout_button->show();
5034
5035                 scan_pbar = manage(new ProgressBar());
5036                 scan_pbar->set_orientation(Gtk::PROGRESS_RIGHT_TO_LEFT);
5037                 scan_pbar->set_text(_("Scan Timeout"));
5038                 scan_pbar->show();
5039
5040                 scan_tbox->pack_start (*scan_pbar, PACK_EXPAND_WIDGET, 4);
5041                 scan_tbox->pack_start (*scan_timeout_button, PACK_SHRINK, 4);
5042
5043                 scan_dlg->get_vbox()->pack_start (*scan_tbox, PACK_SHRINK, 4);
5044         }
5045
5046         assert(scan_dlg && scan_tbox && cancel_button);
5047
5048         if (type == X_("closeme")) {
5049                 scan_tbox->hide();
5050                 scan_dlg->hide();
5051         } else {
5052                 scan_dlg->set_message(type + ": " + Glib::path_get_basename(plugin));
5053                 scan_dlg->show();
5054         }
5055         if (!can_cancel || !cancelled) {
5056                 scan_timeout_button->set_sensitive(false);
5057         }
5058         cancel_button->set_sensitive(can_cancel && !cancelled);
5059
5060         gui_idle_handler();
5061 }
5062
5063 void
5064 ARDOUR_UI::gui_idle_handler ()
5065 {
5066         int timeout = 30;
5067         /* due to idle calls, gtk_events_pending() may always return true */
5068         while (gtk_events_pending() && --timeout) {
5069                 gtk_main_iteration ();
5070         }
5071 }
5072
5073 void
5074 ARDOUR_UI::disk_underrun_handler ()
5075 {
5076         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler)
5077
5078         if (!have_disk_speed_dialog_displayed) {
5079                 have_disk_speed_dialog_displayed = true;
5080                 MessageDialog* msg = new MessageDialog (
5081                         _main_window, string_compose (_("The disk system on your computer\n\
5082 was not able to keep up with %1.\n\
5083 \n\
5084 Specifically, it failed to read data from disk\n\
5085 quickly enough to keep up with playback.\n"), PROGRAM_NAME));
5086                 msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
5087                 msg->show ();
5088         }
5089 }
5090
5091 void
5092 ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
5093 {
5094         have_disk_speed_dialog_displayed = false;
5095         delete msg;
5096 }
5097
5098 void
5099 ARDOUR_UI::session_dialog (std::string msg)
5100 {
5101         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::session_dialog, msg)
5102
5103         MessageDialog* d;
5104
5105         d = new MessageDialog (msg, false, MESSAGE_INFO, BUTTONS_OK, true);
5106         d->show_all ();
5107         d->run ();
5108         delete d;
5109 }
5110
5111 int
5112 ARDOUR_UI::pending_state_dialog ()
5113 {
5114         HBox* hbox = manage (new HBox());
5115         Image* image = manage (new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG));
5116         ArdourDialog dialog (_("Crash Recovery"), true);
5117         Label  message (string_compose (_("\
5118 This session appears to have been in the\n\
5119 middle of recording when %1 or\n\
5120 the computer was shutdown.\n\
5121 \n\
5122 %1 can recover any captured audio for\n\
5123 you, or it can ignore it. Please decide\n\
5124 what you would like to do.\n"), PROGRAM_NAME));
5125         image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
5126         hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
5127         hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
5128         dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
5129         dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
5130         dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
5131         dialog.set_default_response (RESPONSE_ACCEPT);
5132         dialog.set_position (WIN_POS_CENTER);
5133         message.show();
5134         image->show();
5135         hbox->show();
5136
5137         switch (dialog.run ()) {
5138         case RESPONSE_ACCEPT:
5139                 return 1;
5140         default:
5141                 return 0;
5142         }
5143 }
5144
5145 int
5146 ARDOUR_UI::sr_mismatch_dialog (samplecnt_t desired, samplecnt_t actual)
5147 {
5148         HBox* hbox = new HBox();
5149         Image* image = new Image (Stock::DIALOG_WARNING, ICON_SIZE_DIALOG);
5150         ArdourDialog dialog (_("Sample Rate Mismatch"), true);
5151         Label  message (string_compose (_("\
5152 This session was created with a sample rate of %1 Hz, but\n\
5153 %2 is currently running at %3 Hz.  If you load this session,\n\
5154 audio may be played at the wrong sample rate.\n"), desired, PROGRAM_NAME, actual));
5155
5156         image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
5157         hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
5158         hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
5159         dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
5160         dialog.add_button (_("Do not load session"), RESPONSE_REJECT);
5161         dialog.add_button (_("Load session anyway"), RESPONSE_ACCEPT);
5162         dialog.set_default_response (RESPONSE_ACCEPT);
5163         dialog.set_position (WIN_POS_CENTER);
5164         message.show();
5165         image->show();
5166         hbox->show();
5167
5168         switch (dialog.run()) {
5169         case RESPONSE_ACCEPT:
5170                 return 0;
5171         default:
5172                 break;
5173         }
5174
5175         return 1;
5176 }
5177
5178 void
5179 ARDOUR_UI::sr_mismatch_message (samplecnt_t desired, samplecnt_t actual)
5180 {
5181         MessageDialog msg (string_compose (_("\
5182 This session was created with a sample rate of %1 Hz, but\n\
5183 %2 is currently running at %3 Hz.\n\
5184 Audio will be recorded and played at the wrong sample rate.\n\
5185 Re-Configure the Audio Engine in\n\
5186 Menu > Window > Audio/Midi Setup"),
5187                                 desired, PROGRAM_NAME, actual),
5188                         true,
5189                         Gtk::MESSAGE_WARNING);
5190         msg.run ();
5191 }
5192
5193 void
5194 ARDOUR_UI::use_config ()
5195 {
5196         XMLNode* node = Config->extra_xml (X_("TransportControllables"));
5197         if (node) {
5198                 set_transport_controllable_state (*node);
5199         }
5200 }
5201
5202 void
5203 ARDOUR_UI::update_transport_clocks (samplepos_t pos)
5204 {
5205         switch (UIConfiguration::instance().get_primary_clock_delta_mode()) {
5206                 case NoDelta:
5207                         primary_clock->set (pos);
5208                         break;
5209                 case DeltaEditPoint:
5210                         primary_clock->set (pos, false, editor->get_preferred_edit_position (EDIT_IGNORE_PHEAD));
5211                         break;
5212                 case DeltaOriginMarker:
5213                         {
5214                                 Location* loc = _session->locations()->clock_origin_location ();
5215                                 primary_clock->set (pos, false, loc ? loc->start() : 0);
5216                         }
5217                         break;
5218         }
5219
5220         switch (UIConfiguration::instance().get_secondary_clock_delta_mode()) {
5221                 case NoDelta:
5222                         secondary_clock->set (pos);
5223                         break;
5224                 case DeltaEditPoint:
5225                         secondary_clock->set (pos, false, editor->get_preferred_edit_position (EDIT_IGNORE_PHEAD));
5226                         break;
5227                 case DeltaOriginMarker:
5228                         {
5229                                 Location* loc = _session->locations()->clock_origin_location ();
5230                                 secondary_clock->set (pos, false, loc ? loc->start() : 0);
5231                         }
5232                         break;
5233         }
5234
5235         if (big_clock_window) {
5236                 big_clock->set (pos);
5237         }
5238         ARDOUR_UI::instance()->video_timeline->manual_seek_video_monitor(pos);
5239 }
5240
5241
5242 void
5243 ARDOUR_UI::record_state_changed ()
5244 {
5245         ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
5246
5247         if (!_session) {
5248                 /* why bother - the clock isn't visible */
5249                 return;
5250         }
5251
5252         ActionManager::set_sensitive (ActionManager::rec_sensitive_actions, !_session->actively_recording());
5253
5254         if (big_clock_window) {
5255                 if (_session->record_status () == Session::Recording && _session->have_rec_enabled_track ()) {
5256                         big_clock->set_active (true);
5257                 } else {
5258                         big_clock->set_active (false);
5259                 }
5260         }
5261
5262 }
5263
5264 bool
5265 ARDOUR_UI::first_idle ()
5266 {
5267         if (_session) {
5268                 _session->allow_auto_play (true);
5269         }
5270
5271         if (editor) {
5272                 editor->first_idle();
5273         }
5274
5275         /* in 1 second, hide the splash screen
5276          *
5277          * Consider hiding it *now*. If a user opens opens a dialog
5278          * during that one second while the splash is still visible,
5279          * the dialog will push-back the splash.
5280          * Closing the dialog later will pop it back.
5281          */
5282         Glib::signal_timeout().connect (sigc::bind (sigc::ptr_fun (_hide_splash), this), 1000);
5283
5284         Keyboard::set_can_save_keybindings (true);
5285         return false;
5286 }
5287
5288 void
5289 ARDOUR_UI::store_clock_modes ()
5290 {
5291         XMLNode* node = new XMLNode(X_("ClockModes"));
5292
5293         for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
5294                 XMLNode* child = new XMLNode (X_("Clock"));
5295
5296                 child->set_property (X_("name"), (*x)->name());
5297                 child->set_property (X_("mode"), (*x)->mode());
5298                 child->set_property (X_("on"), (*x)->on());
5299
5300                 node->add_child_nocopy (*child);
5301         }
5302
5303         _session->add_extra_xml (*node);
5304         _session->set_dirty ();
5305 }
5306
5307 void
5308 ARDOUR_UI::setup_profile ()
5309 {
5310         if (gdk_screen_width() < 1200 || getenv ("ARDOUR_NARROW_SCREEN")) {
5311                 Profile->set_small_screen ();
5312         }
5313
5314         if (g_getenv ("TRX")) {
5315                 Profile->set_trx ();
5316         }
5317
5318         if (g_getenv ("MIXBUS")) {
5319                 Profile->set_mixbus ();
5320         }
5321 }
5322
5323 int
5324 ARDOUR_UI::missing_file (Session*s, std::string str, DataType type)
5325 {
5326         MissingFileDialog dialog (s, str, type);
5327
5328         dialog.show ();
5329         dialog.present ();
5330
5331         int result = dialog.run ();
5332         dialog.hide ();
5333
5334         switch (result) {
5335         case RESPONSE_OK:
5336                 break;
5337         default:
5338                 return 1; // quit entire session load
5339         }
5340
5341         result = dialog.get_action ();
5342
5343         return result;
5344 }
5345
5346 int
5347 ARDOUR_UI::ambiguous_file (std::string file, std::vector<std::string> hits)
5348 {
5349         AmbiguousFileDialog dialog (file, hits);
5350
5351         dialog.show ();
5352         dialog.present ();
5353
5354         dialog.run ();
5355
5356         return dialog.get_which ();
5357 }
5358
5359 /** Allocate our thread-local buffers */
5360 void
5361 ARDOUR_UI::get_process_buffers ()
5362 {
5363         _process_thread->get_buffers ();
5364 }
5365
5366 /** Drop our thread-local buffers */
5367 void
5368 ARDOUR_UI::drop_process_buffers ()
5369 {
5370         _process_thread->drop_buffers ();
5371 }
5372
5373 void
5374 ARDOUR_UI::feedback_detected ()
5375 {
5376         _feedback_exists = true;
5377 }
5378
5379 void
5380 ARDOUR_UI::successful_graph_sort ()
5381 {
5382         _feedback_exists = false;
5383 }
5384
5385 void
5386 ARDOUR_UI::midi_panic ()
5387 {
5388         if (_session) {
5389                 _session->midi_panic();
5390         }
5391 }
5392
5393 void
5394 ARDOUR_UI::session_format_mismatch (std::string xml_path, std::string backup_path)
5395 {
5396         const char* start_big = "<span size=\"x-large\" weight=\"bold\">";
5397         const char* end_big = "</span>";
5398         const char* start_mono = "<tt>";
5399         const char* end_mono = "</tt>";
5400
5401         MessageDialog msg (string_compose (_("%4This is a session from an older version of %3%5\n\n"
5402                                              "%3 has copied the old session file\n\n%6%1%7\n\nto\n\n%6%2%7\n\n"
5403                                              "From now on, use the backup copy with older versions of %3"),
5404                                            xml_path, backup_path, PROGRAM_NAME,
5405                                            start_big, end_big,
5406                                            start_mono, end_mono), true);
5407
5408         msg.run ();
5409 }
5410
5411 void
5412 ARDOUR_UI::add_editor_meter_type_item (Menu_Helpers::MenuList& items, RadioMenuItem::Group& group, string const & name, MeterType type)
5413 {
5414         using namespace Menu_Helpers;
5415
5416         items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (editor_meter, &LevelMeterHBox::set_meter_type), type)));
5417         RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
5418         i->set_active (editor_meter->meter_type () == type);
5419 }
5420
5421 void
5422 ARDOUR_UI::popup_editor_meter_menu (GdkEventButton* ev)
5423 {
5424         using namespace Gtk::Menu_Helpers;
5425
5426         Gtk::Menu* m = manage (new Menu);
5427         MenuList& items = m->items ();
5428
5429         RadioMenuItem::Group group;
5430
5431         _suspend_editor_meter_callbacks = true;
5432         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterPeak), MeterPeak);
5433         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterPeak0dB), MeterPeak0dB);
5434         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterKrms),  MeterKrms);
5435         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC1DIN), MeterIEC1DIN);
5436         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC1NOR), MeterIEC1NOR);
5437         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC2BBC), MeterIEC2BBC);
5438         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC2EBU), MeterIEC2EBU);
5439         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK20), MeterK20);
5440         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK14), MeterK14);
5441         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK12), MeterK12);
5442         add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterVU),  MeterVU);
5443
5444         m->popup (ev->button, ev->time);
5445         _suspend_editor_meter_callbacks = false;
5446 }
5447
5448 bool
5449 ARDOUR_UI::editor_meter_button_press (GdkEventButton* ev)
5450 {
5451         if (ev->button == 3 && editor_meter) {
5452                 popup_editor_meter_menu (ev);
5453                 return true;
5454         }
5455         return false;
5456 }
5457
5458 void
5459 ARDOUR_UI::reset_peak_display ()
5460 {
5461         if (!_session || !_session->master_out() || !editor_meter) return;
5462         editor_meter->clear_meters();
5463         editor_meter_max_peak = -INFINITY;
5464         editor_meter_peak_display.set_active_state ( Gtkmm2ext::Off );
5465 }
5466
5467 void
5468 ARDOUR_UI::reset_group_peak_display (RouteGroup* group)
5469 {
5470         if (!_session || !_session->master_out()) return;
5471         if (group == _session->master_out()->route_group()) {
5472                 reset_peak_display ();
5473         }
5474 }
5475
5476 void
5477 ARDOUR_UI::reset_route_peak_display (Route* route)
5478 {
5479         if (!_session || !_session->master_out()) return;
5480         if (_session->master_out().get() == route) {
5481                 reset_peak_display ();
5482         }
5483 }
5484
5485 int
5486 ARDOUR_UI::do_audio_midi_setup (uint32_t desired_sample_rate)
5487 {
5488         audio_midi_setup->set_desired_sample_rate (desired_sample_rate);
5489         audio_midi_setup->set_position (WIN_POS_CENTER);
5490
5491         if (desired_sample_rate != 0) {
5492                 if (Config->get_try_autostart_engine () || getenv ("TRY_AUTOSTART_ENGINE")) {
5493                         audio_midi_setup->try_autostart ();
5494                         if (ARDOUR::AudioEngine::instance()->running()) {
5495                                 return 0;
5496                         }
5497                 }
5498         }
5499
5500         while (true) {
5501                 int response = audio_midi_setup->run();
5502                 switch (response) {
5503                 case Gtk::RESPONSE_DELETE_EVENT:
5504                         // after latency callibration engine may run,
5505                         // Running() signal was emitted, but dialog will not
5506                         // have emitted a response. The user needs to close
5507                         // the dialog -> Gtk::RESPONSE_DELETE_EVENT
5508                         if (!AudioEngine::instance()->running()) {
5509                                 return -1;
5510                         }
5511                         // fall through
5512                 default:
5513                         if (!AudioEngine::instance()->running()) {
5514                                 continue;
5515                         }
5516                         audio_midi_setup->hide ();
5517                         return 0;
5518                 }
5519         }
5520 }
5521
5522
5523 gint
5524 ARDOUR_UI::transport_numpad_timeout ()
5525 {
5526         _numpad_locate_happening = false;
5527         if (_numpad_timeout_connection.connected() )
5528                 _numpad_timeout_connection.disconnect();
5529         return 1;
5530 }
5531
5532 void
5533 ARDOUR_UI::transport_numpad_decimal ()
5534 {
5535         _numpad_timeout_connection.disconnect();
5536
5537         if (_numpad_locate_happening) {
5538                 if (editor) editor->goto_nth_marker(_pending_locate_num - 1);
5539                 _numpad_locate_happening = false;
5540         } else {
5541                 _pending_locate_num = 0;
5542                 _numpad_locate_happening = true;
5543                 _numpad_timeout_connection = Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::transport_numpad_timeout), 2*1000);
5544         }
5545 }
5546
5547 void
5548 ARDOUR_UI::transport_numpad_event (int num)
5549 {
5550         if ( _numpad_locate_happening ) {
5551                 _pending_locate_num = _pending_locate_num*10 + num;
5552         } else {
5553                 switch (num) {
5554                         case 0:  toggle_roll(false, false);             break;
5555                         case 1:  transport_rewind(1);                           break;
5556                         case 2:  transport_forward(1);                          break;
5557                         case 3:  transport_record(true);                        break;
5558                         case 4:  toggle_session_auto_loop();            break;
5559                         case 5:  transport_record(false); toggle_session_auto_loop();   break;
5560                         case 6:  toggle_punch();                                        break;
5561                         case 7:  toggle_click();                                break;
5562                         case 8:  toggle_auto_return();                  break;
5563                         case 9:  toggle_follow_edits();         break;
5564                 }
5565         }
5566 }
5567
5568 void
5569 ARDOUR_UI::set_flat_buttons ()
5570 {
5571         CairoWidget::set_flat_buttons( UIConfiguration::instance().get_flat_buttons() );
5572 }
5573
5574 void
5575 ARDOUR_UI::audioengine_became_silent ()
5576 {
5577         MessageDialog msg (string_compose (_("This is a free/demo copy of %1. It has just switched to silent mode."), PROGRAM_NAME),
5578                            true,
5579                            Gtk::MESSAGE_WARNING,
5580                            Gtk::BUTTONS_NONE,
5581                            true);
5582
5583         msg.set_title (string_compose (_("%1 is now silent"), PROGRAM_NAME));
5584
5585         Gtk::Label pay_label (string_compose (_("Please consider paying for a copy of %1 - you can pay whatever you want."), PROGRAM_NAME));
5586         Gtk::Label subscribe_label (_("Better yet become a subscriber - subscriptions start at US$1 per month."));
5587         Gtk::Button pay_button (_("Pay for a copy (via the web)"));
5588         Gtk::Button subscribe_button (_("Become a subscriber (via the web)"));
5589         Gtk::HBox pay_button_box;
5590         Gtk::HBox subscribe_button_box;
5591
5592         pay_button_box.pack_start (pay_button, true, false);
5593         subscribe_button_box.pack_start (subscribe_button, true, false);
5594
5595         bool (*openuri)(const char*) = PBD::open_uri; /* this forces selection of the const char* variant of PBD::open_uri(), which we need to avoid ambiguity below */
5596
5597         pay_button.signal_clicked().connect (sigc::hide_return (sigc::bind (sigc::ptr_fun (openuri), (const char*) "https://ardour.org/download")));
5598         subscribe_button.signal_clicked().connect (sigc::hide_return (sigc::bind (sigc::ptr_fun (openuri), (const char*) "https://community.ardour.org/s/subscribe")));
5599
5600         msg.get_vbox()->pack_start (pay_label);
5601         msg.get_vbox()->pack_start (pay_button_box);
5602         msg.get_vbox()->pack_start (subscribe_label);
5603         msg.get_vbox()->pack_start (subscribe_button_box);
5604
5605         msg.get_vbox()->show_all ();
5606
5607         msg.add_button (_("Remain silent"), Gtk::RESPONSE_CANCEL);
5608         msg.add_button (_("Save and quit"), Gtk::RESPONSE_NO);
5609         msg.add_button (_("Give me more time"), Gtk::RESPONSE_YES);
5610
5611         int r = msg.run ();
5612
5613         switch (r) {
5614         case Gtk::RESPONSE_YES:
5615                 AudioEngine::instance()->reset_silence_countdown ();
5616                 break;
5617
5618         case Gtk::RESPONSE_NO:
5619                 /* save and quit */
5620                 save_state_canfail ("");
5621                 exit (0);
5622                 break;
5623
5624         case Gtk::RESPONSE_CANCEL:
5625         default:
5626                 /* don't reset, save session and exit */
5627                 break;
5628         }
5629 }
5630
5631 void
5632 ARDOUR_UI::hide_application ()
5633 {
5634         Application::instance ()-> hide ();
5635 }
5636
5637 void
5638 ARDOUR_UI::setup_toplevel_window (Gtk::Window& window, const string& name, void* owner)
5639 {
5640         /* icons, titles, WM stuff */
5641
5642         static list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
5643
5644         if (window_icons.empty()) {
5645                 Glib::RefPtr<Gdk::Pixbuf> icon;
5646                 if ((icon = ::get_icon (PROGRAM_NAME "-icon_16px"))) {
5647                         window_icons.push_back (icon);
5648                 }
5649                 if ((icon = ::get_icon (PROGRAM_NAME "-icon_22px"))) {
5650                         window_icons.push_back (icon);
5651                 }
5652                 if ((icon = ::get_icon (PROGRAM_NAME "-icon_32px"))) {
5653                         window_icons.push_back (icon);
5654                 }
5655                 if ((icon = ::get_icon (PROGRAM_NAME "-icon_48px"))) {
5656                         window_icons.push_back (icon);
5657                 }
5658         }
5659
5660         if (!window_icons.empty()) {
5661                 window.set_default_icon_list (window_icons);
5662         }
5663
5664         Gtkmm2ext::WindowTitle title (Glib::get_application_name());
5665
5666         if (!name.empty()) {
5667                 title += name;
5668         }
5669
5670         window.set_title (title.get_string());
5671         window.set_wmclass (string_compose (X_("%1_%1"), downcase (std::string(PROGRAM_NAME)), downcase (name)), PROGRAM_NAME);
5672
5673         window.set_flags (CAN_FOCUS);
5674         window.add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
5675
5676         /* This is a hack to ensure that GTK-accelerators continue to
5677          * work. Once we switch over to entirely native bindings, this will be
5678          * unnecessary and should be removed
5679          */
5680         window.add_accel_group (ActionManager::ui_manager->get_accel_group());
5681
5682         window.signal_configure_event().connect (sigc::mem_fun (*this, &ARDOUR_UI::configure_handler));
5683         window.signal_window_state_event().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::tabbed_window_state_event_handler), owner));
5684         window.signal_key_press_event().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::key_event_handler), &window), false);
5685         window.signal_key_release_event().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::key_event_handler), &window), false);
5686 }
5687
5688 bool
5689 ARDOUR_UI::key_event_handler (GdkEventKey* ev, Gtk::Window* event_window)
5690 {
5691         Gtkmm2ext::Bindings* bindings = 0;
5692         Gtk::Window* window = 0;
5693
5694         /* until we get ardour bindings working, we are not handling key
5695          * releases yet.
5696          */
5697
5698         if (ev->type != GDK_KEY_PRESS) {
5699                 return false;
5700         }
5701
5702         if (event_window == &_main_window) {
5703
5704                 window = event_window;
5705
5706                 /* find current tab contents */
5707
5708                 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page());
5709
5710                 /* see if it uses the ardour binding system */
5711
5712                 if (w) {
5713                         bindings = reinterpret_cast<Gtkmm2ext::Bindings*>(w->get_data ("ardour-bindings"));
5714                 }
5715
5716                 DEBUG_TRACE (DEBUG::Accelerators, string_compose ("main window key event, bindings = %1, global = %2\n", bindings, &global_bindings));
5717
5718         } else {
5719
5720                 window = event_window;
5721
5722                 /* see if window uses ardour binding system */
5723
5724                 bindings = reinterpret_cast<Gtkmm2ext::Bindings*>(window->get_data ("ardour-bindings"));
5725         }
5726
5727         /* An empty binding set is treated as if it doesn't exist */
5728
5729         if (bindings && bindings->empty()) {
5730                 bindings = 0;
5731         }
5732
5733         return key_press_focus_accelerator_handler (*window, ev, bindings);
5734 }
5735
5736 static Gtkmm2ext::Bindings*
5737 get_bindings_from_widget_heirarchy (GtkWidget** w)
5738 {
5739         void* p = NULL;
5740
5741         while (*w) {
5742                 if ((p = g_object_get_data (G_OBJECT(*w), "ardour-bindings")) != 0) {
5743                         break;
5744                 }
5745                 *w = gtk_widget_get_parent (*w);
5746         }
5747
5748         return reinterpret_cast<Gtkmm2ext::Bindings*> (p);
5749 }
5750
5751 bool
5752 ARDOUR_UI::key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev, Gtkmm2ext::Bindings* bindings)
5753 {
5754         GtkWindow* win = window.gobj();
5755         GtkWidget* focus = gtk_window_get_focus (win);
5756         GtkWidget* binding_widget = focus;
5757         bool special_handling_of_unmodified_accelerators = false;
5758         const guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK));
5759
5760         if (focus) {
5761
5762                 /* some widget has keyboard focus */
5763
5764                 if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) {
5765
5766                         /* A particular kind of focusable widget currently has keyboard
5767                          * focus. All unmodified key events should go to that widget
5768                          * first and not be used as an accelerator by default
5769                          */
5770
5771                         special_handling_of_unmodified_accelerators = true;
5772
5773                 } else {
5774
5775                         Gtkmm2ext::Bindings* focus_bindings = get_bindings_from_widget_heirarchy (&binding_widget);
5776                         if (focus_bindings) {
5777                                 bindings = focus_bindings;
5778                                 DEBUG_TRACE (DEBUG::Accelerators, string_compose ("Switch bindings based on focus widget, now using %1\n", bindings->name()));
5779                         }
5780                 }
5781         }
5782
5783         DEBUG_TRACE (DEBUG::Accelerators, string_compose ("Win = %1 [title = %9] focus = %7 (%8) Key event: code = %2  state = %3 special handling ? %4 magic widget focus ? %5 focus widget %6 named %7 mods ? %8\n",
5784                                                           win,
5785                                                           ev->keyval,
5786                                                           Gtkmm2ext::show_gdk_event_state (ev->state),
5787                                                           special_handling_of_unmodified_accelerators,
5788                                                           Keyboard::some_magic_widget_has_focus(),
5789                                                           focus,
5790                                                           (focus ? gtk_widget_get_name (focus) : "no focus widget"),
5791                                                           ((ev->state & mask) ? "yes" : "no"),
5792                                                           window.get_title()));
5793
5794         /* This exists to allow us to override the way GTK handles
5795            key events. The normal sequence is:
5796
5797            a) event is delivered to a GtkWindow
5798            b) accelerators/mnemonics are activated
5799            c) if (b) didn't handle the event, propagate to
5800                the focus widget and/or focus chain
5801
5802            The problem with this is that if the accelerators include
5803            keys without modifiers, such as the space bar or the
5804            letter "e", then pressing the key while typing into
5805            a text entry widget results in the accelerator being
5806            activated, instead of the desired letter appearing
5807            in the text entry.
5808
5809            There is no good way of fixing this, but this
5810            represents a compromise. The idea is that
5811            key events involving modifiers (not Shift)
5812            get routed into the activation pathway first, then
5813            get propagated to the focus widget if necessary.
5814
5815            If the key event doesn't involve modifiers,
5816            we deliver to the focus widget first, thus allowing
5817            it to get "normal text" without interference
5818            from acceleration.
5819
5820            Of course, this can also be problematic: if there
5821            is a widget with focus, then it will swallow
5822            all "normal text" accelerators.
5823         */
5824
5825
5826         if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) {
5827
5828                 /* no special handling or there are modifiers in effect: accelerate first */
5829
5830                 DEBUG_TRACE (DEBUG::Accelerators, "\tactivate, then propagate\n");
5831                 DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tevent send-event:%1 time:%2 length:%3 name %7 string:%4 hardware_keycode:%5 group:%6\n",
5832                                                                   ev->send_event, ev->time, ev->length, ev->string, ev->hardware_keycode, ev->group, gdk_keyval_name (ev->keyval)));
5833
5834                 DEBUG_TRACE (DEBUG::Accelerators, "\tsending to window\n");
5835                 KeyboardKey k (ev->state, ev->keyval);
5836
5837                 while (bindings) {
5838
5839                         DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tusing Ardour bindings %1 @ %2 for this event\n", bindings->name(), bindings));
5840
5841                         if (bindings->activate (k, Bindings::Press)) {
5842                                 DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
5843                                 return true;
5844                         }
5845
5846                         if (binding_widget) {
5847                                 binding_widget = gtk_widget_get_parent (binding_widget);
5848                                 if (binding_widget) {
5849                                         bindings = get_bindings_from_widget_heirarchy (&binding_widget);
5850                                 } else {
5851                                         bindings = 0;
5852                                 }
5853                         } else {
5854                                 bindings = 0;
5855                         }
5856                 }
5857
5858                 DEBUG_TRACE (DEBUG::Accelerators, "\tnot yet handled, try global bindings\n");
5859
5860                 if (global_bindings && global_bindings->activate (k, Bindings::Press)) {
5861                         DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
5862                         return true;
5863                 }
5864
5865                 DEBUG_TRACE (DEBUG::Accelerators, "\tnot accelerated, now propagate\n");
5866
5867                 if (gtk_window_propagate_key_event (win, ev)) {
5868                         DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate handled\n");
5869                         return true;
5870                 }
5871
5872         } else {
5873
5874                 /* no modifiers, propagate first */
5875
5876                 DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate, then activate\n");
5877
5878                 if (gtk_window_propagate_key_event (win, ev)) {
5879                         DEBUG_TRACE (DEBUG::Accelerators, "\thandled by propagate\n");
5880                         return true;
5881                 }
5882
5883                 DEBUG_TRACE (DEBUG::Accelerators, "\tpropagation didn't handle, so activate\n");
5884                 KeyboardKey k (ev->state, ev->keyval);
5885
5886                 while (bindings) {
5887
5888                         DEBUG_TRACE (DEBUG::Accelerators, "\tusing Ardour bindings for this window\n");
5889
5890
5891                         if (bindings->activate (k, Bindings::Press)) {
5892                                 DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
5893                                 return true;
5894                         }
5895
5896                         if (binding_widget) {
5897                                 binding_widget = gtk_widget_get_parent (binding_widget);
5898                                 if (binding_widget) {
5899                                         bindings = get_bindings_from_widget_heirarchy (&binding_widget);
5900                                 } else {
5901                                         bindings = 0;
5902                                 }
5903                         } else {
5904                                 bindings = 0;
5905                         }
5906                 }
5907
5908                 DEBUG_TRACE (DEBUG::Accelerators, "\tnot yet handled, try global bindings\n");
5909
5910                 if (global_bindings && global_bindings->activate (k, Bindings::Press)) {
5911                         DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
5912                         return true;
5913                 }
5914         }
5915
5916         DEBUG_TRACE (DEBUG::Accelerators, "\tnot handled\n");
5917         return true;
5918 }
5919
5920 void
5921 ARDOUR_UI::load_bindings ()
5922 {
5923         if ((global_bindings = Bindings::get_bindings (X_("Global"), global_actions)) == 0) {
5924                 error << _("Global keybindings are missing") << endmsg;
5925         }
5926 }
5927
5928 void
5929 ARDOUR_UI::cancel_solo ()
5930 {
5931         if (_session) {
5932                 _session->cancel_all_solo ();
5933         }
5934 }
5935
5936 void
5937 ARDOUR_UI::reset_focus (Gtk::Widget* w)
5938 {
5939         /* this resets focus to the first focusable parent of the given widget,
5940          * or, if there is no focusable parent, cancels focus in the toplevel
5941          * window that the given widget is packed into (if there is one).
5942          */
5943
5944         if (!w) {
5945                 return;
5946         }
5947
5948         Gtk::Widget* top = w->get_toplevel();
5949
5950         if (!top || !top->is_toplevel()) {
5951                 return;
5952         }
5953
5954         w = w->get_parent ();
5955
5956         while (w) {
5957
5958                 if (w->is_toplevel()) {
5959                         /* Setting the focus widget to a Gtk::Window causes all
5960                          * subsequent calls to ::has_focus() on the nominal
5961                          * focus widget in that window to return
5962                          * false. Workaround: never set focus to the toplevel
5963                          * itself.
5964                          */
5965                         break;
5966                 }
5967
5968                 if (w->get_can_focus ()) {
5969                         Gtk::Window* win = dynamic_cast<Gtk::Window*> (top);
5970                         win->set_focus (*w);
5971                         return;
5972                 }
5973                 w = w->get_parent ();
5974         }
5975
5976         if (top == &_main_window) {
5977
5978         }
5979
5980         /* no focusable parent found, cancel focus in top level window.
5981            C++ API cannot be used for this. Thanks, references.
5982         */
5983
5984         gtk_window_set_focus (GTK_WINDOW(top->gobj()), 0);
5985
5986 }