X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui.cc;h=382d8b7ca4716a6ad48fc594b70dfd135b28789b;hb=5ef06dd439088226683beff5c6fc1d5af55a014b;hp=423f9de14a9fa4bbed2fcd1c2e01c51ca6a3fe0b;hpb=bb9cc45cd22af67ac275a5e73accbe14fee664d8;p=ardour.git diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc index 423f9de14a..382d8b7ca4 100644 --- a/gtk2_ardour/ardour_ui.cc +++ b/gtk2_ardour/ardour_ui.cc @@ -17,7 +17,10 @@ */ -#define __STDC_FORMAT_MACROS 1 +#ifdef WAF_BUILD +#include "gtk2ardour-config.h" +#endif + #include #include @@ -42,20 +45,24 @@ #include "pbd/failed_constructor.h" #include "pbd/enumwriter.h" #include "pbd/memento_command.h" +#include "pbd/openuri.h" #include "pbd/file_utils.h" -#include -#include -#include -#include -#include -#include -#include +#include "gtkmm2ext/application.h" +#include "gtkmm2ext/bindings.h" +#include "gtkmm2ext/gtk_ui.h" +#include "gtkmm2ext/utils.h" +#include "gtkmm2ext/click_box.h" +#include "gtkmm2ext/fastmeter.h" +#include "gtkmm2ext/popup.h" +#include "gtkmm2ext/window_title.h" #include "midi++/manager.h" #include "ardour/ardour.h" +#include "ardour/callback.h" #include "ardour/profile.h" +#include "ardour/plugin_manager.h" #include "ardour/session_directory.h" #include "ardour/session_route.h" #include "ardour/session_state_utils.h" @@ -72,29 +79,41 @@ #include "ardour/midi_track.h" #include "ardour/filesystem_paths.h" #include "ardour/filename_extensions.h" +#include "ardour/process_thread.h" typedef uint64_t microseconds_t; +#include "about.h" #include "actions.h" +#include "add_route_dialog.h" +#include "ambiguous_file_dialog.h" #include "ardour_ui.h" -#include "public_editor.h" #include "audio_clock.h" +#include "bundle_manager.h" +#include "engine_dialog.h" +#include "gain_meter.h" +#include "global_port_matrix.h" +#include "gui_object.h" +#include "gui_thread.h" #include "keyboard.h" +#include "location_ui.h" +#include "missing_file_dialog.h" +#include "missing_plugin_dialog.h" #include "mixer_ui.h" -#include "prompter.h" #include "opts.h" -#include "add_route_dialog.h" -#include "about.h" -#include "splash.h" -#include "utils.h" -#include "gui_thread.h" -#include "theme_manager.h" -#include "bundle_manager.h" -#include "session_metadata_dialog.h" -#include "gain_meter.h" +#include "processor_box.h" +#include "prompter.h" +#include "public_editor.h" #include "route_time_axis.h" +#include "session_metadata_dialog.h" +#include "shuttle_control.h" +#include "speaker_dialog.h" +#include "splash.h" #include "startup.h" -#include "engine_dialog.h" +#include "theme_manager.h" +#include "time_axis_view_item.h" +#include "utils.h" +#include "window_proxy.h" #include "i18n.h" @@ -102,7 +121,6 @@ using namespace ARDOUR; using namespace PBD; using namespace Gtkmm2ext; using namespace Gtk; -using namespace sigc; ARDOUR_UI *ARDOUR_UI::theArdourUI = 0; UIConfiguration *ARDOUR_UI::ui_config = 0; @@ -110,60 +128,44 @@ UIConfiguration *ARDOUR_UI::ui_config = 0; sigc::signal ARDOUR_UI::Blink; sigc::signal ARDOUR_UI::RapidScreenUpdate; sigc::signal ARDOUR_UI::SuperRapidScreenUpdate; -sigc::signal ARDOUR_UI::Clock; - -ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[]) +sigc::signal ARDOUR_UI::Clock; - : Gtkmm2ext::UI (X_("Ardour"), argcp, argvp), +bool could_be_a_valid_path (const string& path); - primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, false, true), - secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, false, true), - preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true), - postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true), +ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[]) - /* preroll stuff */ + : Gtkmm2ext::UI (PROGRAM_NAME, argcp, argvp) - preroll_button (_("pre\nroll")), - postroll_button (_("post\nroll")), + , gui_object_state (new GUIObjectState) + , primary_clock (new AudioClock (X_("primary"), false, X_("transport"), true, true, false, true)) + , secondary_clock (new AudioClock (X_("secondary"), false, X_("secondary"), true, true, false, true)) /* big clock */ - big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true), + , big_clock (new AudioClock (X_("bigclock"), false, "big", true, true, false, false)) /* transport */ - roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll)), - stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop)), - goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart)), - goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd)), - auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop)), - play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection)), - rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable)), - shuttle_controllable (new TransportControllable ("shuttle", *this, TransportControllable::ShuttleControl)), - shuttle_controller_binding_proxy (shuttle_controllable), - - roll_button (roll_controllable), - stop_button (stop_controllable), - goto_start_button (goto_start_controllable), - goto_end_button (goto_end_controllable), - auto_loop_button (auto_loop_controllable), - play_selection_button (play_selection_controllable), - rec_button (rec_controllable), - - shuttle_units_button (_("% ")), - - punch_in_button (_("Punch In")), - punch_out_button (_("Punch Out")), - auto_return_button (_("Auto Return")), - auto_play_button (_("Auto Play")), - auto_input_button (_("Auto Input")), - click_button (_("Click")), - time_master_button (_("time\nmaster")), - - auditioning_alert_button (_("AUDITION")), - solo_alert_button (_("SOLO")), - shown_flag (false), - error_log_button (_("Errors")) + , roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll)) + , stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop)) + , goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart)) + , goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd)) + , auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop)) + , play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection)) + , rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable)) + + , auto_return_button (ArdourButton::led_default_elements) + , auto_play_button (ArdourButton::led_default_elements) + , auto_input_button (ArdourButton::led_default_elements) + + , auditioning_alert_button (_("audition")) + , solo_alert_button (_("solo")) + , feedback_alert_button (_("feedback")) + + , error_log_button (_("Errors")) + + , _status_bar_visibility (X_("status-bar")) + , _feedback_exists (false) { using namespace Gtk::Menu_Helpers; @@ -191,18 +193,22 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[]) ui_config = new UIConfiguration(); theme_manager = new ThemeManager(); + key_editor = 0; + editor = 0; mixer = 0; - session = 0; editor = 0; engine = 0; _session_is_new = false; big_clock_window = 0; + big_clock_height = 0; + big_clock_resize_in_progress = false; session_selector_window = 0; last_key_press_time = 0; _will_create_new_session_automatically = false; add_route_dialog = 0; route_params = 0; + bundle_manager = 0; rc_option_editor = 0; session_option_editor = 0; location_ui = 0; @@ -210,49 +216,71 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[]) have_configure_timeout = false; have_disk_speed_dialog_displayed = false; session_loaded = false; - last_speed_displayed = -1.0f; ignore_dual_punch = false; - _mixer_on_top = false; + original_big_clock_width = -1; + original_big_clock_height = -1; + original_big_clock_font_size = 0; + + roll_button.set_controllable (roll_controllable); + stop_button.set_controllable (stop_controllable); + goto_start_button.set_controllable (goto_start_controllable); + goto_end_button.set_controllable (goto_end_controllable); + auto_loop_button.set_controllable (auto_loop_controllable); + play_selection_button.set_controllable (play_selection_controllable); + rec_button.set_controllable (rec_controllable); + + roll_button.set_name ("transport button"); + stop_button.set_name ("transport button"); + goto_start_button.set_name ("transport button"); + goto_end_button.set_name ("transport button"); + auto_loop_button.set_name ("transport button"); + play_selection_button.set_name ("transport button"); + rec_button.set_name ("transport recenable button"); + join_play_range_button.set_name ("transport button"); + midi_panic_button.set_name ("transport button"); + + goto_start_button.set_tweaks (ArdourButton::ShowClick); + goto_end_button.set_tweaks (ArdourButton::ShowClick); + midi_panic_button.set_tweaks (ArdourButton::ShowClick); + + last_configure_time= 0; + last_peak_grab = 0; - roll_button.unset_flags (Gtk::CAN_FOCUS); - stop_button.unset_flags (Gtk::CAN_FOCUS); - goto_start_button.unset_flags (Gtk::CAN_FOCUS); - goto_end_button.unset_flags (Gtk::CAN_FOCUS); - auto_loop_button.unset_flags (Gtk::CAN_FOCUS); - play_selection_button.unset_flags (Gtk::CAN_FOCUS); - rec_button.unset_flags (Gtk::CAN_FOCUS); + ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context()); + ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context()); - last_configure_time= 0; + /* handle dialog requests */ - shuttle_grabbed = false; - shuttle_fract = 0.0; - shuttle_max_speed = 8.0f; + ARDOUR::Session::Dialog.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context()); - shuttle_style_menu = 0; - shuttle_unit_menu = 0; + /* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */ - // We do not have jack linked in yet so; + ARDOUR::Session::AskAboutPendingState.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::pending_state_dialog, this)); - last_shuttle_request = last_peak_grab = 0; // get_microseconds(); + /* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */ - ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler)); - ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler)); + ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2)); - /* handle dialog requests */ + /* handle requests to quit (coming from JACK session) */ + + ARDOUR::Session::Quit.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::finish, this), gui_context ()); + + /* tell the user about feedback */ - ARDOUR::Session::Dialog.connect (mem_fun(*this, &ARDOUR_UI::session_dialog)); + ARDOUR::Session::FeedbackDetected.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::feedback_detected, this), gui_context ()); + ARDOUR::Session::SuccessfulGraphSort.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::successful_graph_sort, this), gui_context ()); - /* handle pending state with a dialog */ + /* handle requests to deal with missing files */ - ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog)); + ARDOUR::Session::MissingFile.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::missing_file, this, _1, _2, _3)); - /* handle sr mismatch with a dialog */ + /* and ambiguous files */ - ARDOUR::Session::AskAboutSampleRateMismatch.connect (mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog)); + ARDOUR::FileSource::AmbiguousFileName.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::ambiguous_file, this, _1, _2, _3)); /* lets get this party started */ - try { + try { if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) { throw failed_constructor (); } @@ -262,40 +290,89 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[]) GainMeter::setup_slider_pix (); RouteTimeAxisView::setup_slider_pix (); + SendProcessorEntry::setup_slider_pix (); + SessionEvent::create_per_thread_pool ("GUI", 512); } catch (failed_constructor& err) { - error << _("could not initialize Ardour.") << endmsg; + error << string_compose (_("could not initialize %1."), PROGRAM_NAME) << endmsg; // pass it on up throw; } /* we like keyboards */ - keyboard = new Keyboard; + keyboard = new ArdourKeyboard(*this); + + XMLNode* node = ARDOUR_UI::instance()->keyboard_settings(); + if (node) { + keyboard->set_state (*node, Stateful::loading_state_version); + } + + /* we don't like certain modifiers */ + Bindings::set_ignored_state (GDK_LOCK_MASK|GDK_MOD2_MASK|GDK_MOD3_MASK); reset_dpi(); - starting.connect (mem_fun(*this, &ARDOUR_UI::startup)); - stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown)); + TimeAxisViewItem::set_constant_heights (); + + /* The following must happen after ARDOUR::init() so that Config is set up */ + + location_ui = new ActionWindowProxy (X_("locations"), Config->extra_xml (X_("UI")), X_("ToggleLocations")); + big_clock_window = new ActionWindowProxy (X_("bigclock"), Config->extra_xml (X_("UI")), X_("ToggleBigClock")); + speaker_config_window = new ActionWindowProxy (X_("speakerconf"), Config->extra_xml (X_("UI")), X_("toggle-speaker-config")); + + for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) { + _global_port_matrix[*i] = new ActionWindowProxy ( + string_compose ("GlobalPortMatrix-%1", (*i).to_string()), + Config->extra_xml (X_("UI")), + string_compose ("toggle-%1-connection-manager", (*i).to_string()) + ); + } + + setup_clock (); + + SpeakerDialog* s = new SpeakerDialog (); + s->signal_unmap().connect (sigc::bind (sigc::ptr_fun (&ActionManager::uncheck_toggleaction), X_("/Common/toggle-speaker-config"))); + speaker_config_window->set (s); + + starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup)); + stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown)); - platform_setup (); + _process_thread = new ProcessThread (); + _process_thread->init (); + + DPIReset.connect (sigc::mem_fun (*this, &ARDOUR_UI::resize_text_widgets)); } -void -ARDOUR_UI::run_startup (bool should_be_new) +/** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */ +bool +ARDOUR_UI::run_startup (bool should_be_new, string load_template) { - if (_startup == 0) { - _startup = new ArdourStartup (); + delete _startup; + _startup = new ArdourStartup (); + + XMLNode* audio_setup = Config->extra_xml ("AudioSetup"); + + if (audio_setup && _startup->engine_control()) { + _startup->engine_control()->set_state (*audio_setup); } _startup->set_new_only (should_be_new); + if (!load_template.empty()) { + _startup->set_load_template( load_template ); + } _startup->present (); main().run(); - /* we don't return here until the startup assistant is finished */ - _startup->hide (); + + switch (_startup->response()) { + case RESPONSE_OK: + return true; + default: + return false; + } } int @@ -310,17 +387,20 @@ ARDOUR_UI::create_engine () loading_message (_("Starting audio engine")); try { - engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name); + engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name, ARDOUR_COMMAND_LINE::jack_session_uuid); } catch (...) { return -1; } - engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped)); - engine->Running.connect (mem_fun(*this, &ARDOUR_UI::engine_running)); - engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted)); - engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate)); + engine->Stopped.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context()); + engine->Running.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_running, this), gui_context()); + engine->SampleRateChanged.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context()); + + engine->Halted.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false)); + + ARDOUR::Port::set_connecting_blocked (ARDOUR_COMMAND_LINE::no_connect_ports); post_engine (); @@ -333,18 +413,24 @@ ARDOUR_UI::post_engine () /* Things to be done once we create the AudioEngine */ - MIDI::Manager::instance()->set_api_data (engine->jack()); - setup_midi (); - ARDOUR::init_post_engine (); + /* load up the UI manager */ + ActionManager::init (); + _tooltips.enable(); if (setup_windows ()) { throw failed_constructor (); } + /* Do this after setup_windows (), as that's when the _status_bar_visibility is created */ + XMLNode* n = Config->extra_xml (X_("UI")); + if (n) { + _status_bar_visibility.set_state (*n); + } + check_memory_locking(); /* this is the first point at which all the keybindings are available */ @@ -352,10 +438,11 @@ ARDOUR_UI::post_engine () if (ARDOUR_COMMAND_LINE::show_key_actions) { vector names; vector paths; + vector tooltips; vector keys; vector bindings; - ActionManager::get_all_actions (names, paths, keys, bindings); + ActionManager::get_all_actions (names, paths, tooltips, keys, bindings); vector::iterator n; vector::iterator k; @@ -376,41 +463,43 @@ ARDOUR_UI::post_engine () /* set default clock modes */ if (Profile->get_sae()) { - primary_clock.set_mode (AudioClock::BBT); - secondary_clock.set_mode (AudioClock::MinSec); + primary_clock->set_mode (AudioClock::BBT); + secondary_clock->set_mode (AudioClock::MinSec); } else { - primary_clock.set_mode (AudioClock::SMPTE); - secondary_clock.set_mode (AudioClock::BBT); + primary_clock->set_mode (AudioClock::Timecode); + secondary_clock->set_mode (AudioClock::BBT); } /* start the time-of-day-clock */ #ifndef GTKOSX - /* OS X provides an always visible wallclock, so don't be stupid */ + /* OS X provides a nearly-always visible wallclock, so don't be stupid */ update_wall_clock (); - Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000); + Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000); #endif update_disk_space (); update_cpu_load (); update_sample_rate (engine->frame_rate()); + Config->ParameterChanged.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context()); + boost::function pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1)); + Config->map_parameters (pc); + /* now start and maybe save state */ if (do_engine_start () == 0) { - if (session && _session_is_new) { + if (_session && _session_is_new) { /* we need to retain initial visual settings for a new session */ - session->save_state (""); + _session->save_state (""); } } } ARDOUR_UI::~ARDOUR_UI () { - save_ardour_state (); - delete keyboard; delete editor; delete mixer; @@ -431,18 +520,19 @@ ARDOUR_UI::configure_timeout () { if (last_configure_time == 0) { /* no configure events yet */ - return TRUE; + return true; } /* force a gap of 0.5 seconds since the last configure event */ if (get_microseconds() - last_configure_time < 500000) { - return TRUE; + return true; } else { have_configure_timeout = false; + cerr << "config event-driven save\n"; save_ardour_state (); - return FALSE; + return false; } } @@ -452,7 +542,7 @@ ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/) if (have_configure_timeout) { last_configure_time = get_microseconds(); } else { - Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100); + Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::configure_timeout), 100); have_configure_timeout = true; } @@ -486,8 +576,9 @@ ARDOUR_UI::set_transport_controllable_state (const XMLNode& node) rec_controllable->set_id (prop->value()); } if ((prop = node.property ("shuttle")) != 0) { - shuttle_controllable->set_id (prop->value()); + shuttle_box->controllable()->set_id (prop->value()); } + } XMLNode& @@ -510,45 +601,12 @@ ARDOUR_UI::get_transport_controllable_state () node->add_property (X_("play_selection"), buf); rec_controllable->id().print (buf, sizeof (buf)); node->add_property (X_("rec"), buf); - shuttle_controllable->id().print (buf, sizeof (buf)); + shuttle_box->controllable()->id().print (buf, sizeof (buf)); node->add_property (X_("shuttle"), buf); return *node; } -void -ARDOUR_UI::save_ardour_state () -{ - if (!keyboard || !mixer || !editor) { - return; - } - - /* XXX this is all a bit dubious. add_extra_xml() uses - a different lifetime model from add_instant_xml(). - */ - - XMLNode* node = new XMLNode (keyboard->get_state()); - Config->add_extra_xml (*node); - Config->add_extra_xml (get_transport_controllable_state()); - if (_startup && _startup->engine_control() && _startup->engine_control()->was_used()) { - Config->add_extra_xml (_startup->engine_control()->get_state()); - } - Config->save_state(); - ui_config->save_state (); - - XMLNode enode(static_cast(editor)->get_state()); - XMLNode mnode(mixer->get_state()); - - if (session) { - session->add_instant_xml (enode); - session->add_instant_xml (mnode); - } else { - Config->add_instant_xml (enode); - Config->add_instant_xml (mnode); - } - - Keyboard::save_keybindings (); -} gint ARDOUR_UI::autosave_session () @@ -561,13 +619,13 @@ ARDOUR_UI::autosave_session () return 1; } - if (!Config->get_periodic_safety_backups()) { - return 1; + if (!Config->get_periodic_safety_backups()) { + return 1; } - if (session) { - session->maybe_write_autosave(); - } + if (_session) { + _session->maybe_write_autosave(); + } return 1; } @@ -575,14 +633,14 @@ ARDOUR_UI::autosave_session () void ARDOUR_UI::update_autosave () { - ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_autosave) - if (session && session->dirty()) { + if (_session && _session->dirty()) { if (_autosave_connection.connected()) { _autosave_connection.disconnect(); } - _autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session), + _autosave_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &ARDOUR_UI::autosave_session), Config->get_periodic_safety_backup_interval() * 1000); } else { @@ -597,9 +655,9 @@ ARDOUR_UI::backend_audio_error (bool we_set_params, Gtk::Window* toplevel) { string title; if (we_set_params) { - title = _("Ardour could not start JACK"); + title = string_compose (_("%1 could not start JACK"), PROGRAM_NAME); } else { - title = _("Ardour could not connect to JACK."); + title = string_compose (_("%1 could not connect to JACK."), PROGRAM_NAME); } MessageDialog win (title, @@ -632,7 +690,7 @@ Please consider the possibilities, and perhaps (re)start JACK.")); win.add_button (Stock::OK, RESPONSE_CLOSE); } else { win.add_button (Stock::QUIT, RESPONSE_CLOSE); - } + } win.set_default_response (RESPONSE_CLOSE); @@ -648,13 +706,18 @@ Please consider the possibilities, and perhaps (re)start JACK.")); void ARDOUR_UI::startup () { - XMLNode* audio_setup = Config->extra_xml ("AudioSetup"); + Application* app = Application::instance (); - if (audio_setup && _startup && _startup->engine_control()) { - _startup->engine_control()->set_state (*audio_setup); - } + app->ShouldQuit.connect (sigc::mem_fun (*this, &ARDOUR_UI::queue_finish)); + app->ShouldLoad.connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_load)); + +#ifdef PHONE_HOME + call_the_mothership (VERSIONSTRING); +#endif + + app->ready (); - if (get_session_parameters (ARDOUR_COMMAND_LINE::new_session)) { + if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session, ARDOUR_COMMAND_LINE::load_template)) { exit (1); } @@ -662,8 +725,21 @@ ARDOUR_UI::startup () goto_editor_window (); - BootMessage (_("Ardour is ready for use")); - show (); + /* Add the window proxies here; their addition may cause windows to be opened, and we want them + to be opened on top of the editor window that goto_editor_window() just opened. + */ + add_window_proxy (location_ui); + add_window_proxy (big_clock_window); + for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) { + add_window_proxy (_global_port_matrix[*i]); + } + + /* We have to do this here since goto_editor_window() ends up calling show_all() on the + * editor window, and we may want stuff to be hidden. + */ + _status_bar_visibility.update (); + + BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME)); } void @@ -703,18 +779,20 @@ ARDOUR_UI::check_memory_locking () if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) { - - MessageDialog msg (_("WARNING: Your system has a limit for maximum amount of locked memory. " - "This might cause Ardour to run out of memory before your system " - "runs out of memory. \n\n" - "You can view the memory limit with 'ulimit -l', " - "and it is normally controlled by /etc/security/limits.conf")); + MessageDialog msg ( + string_compose ( + _("WARNING: Your system has a limit for maximum amount of locked memory. " + "This might cause %1 to run out of memory before your system " + "runs out of memory. \n\n" + "You can view the memory limit with 'ulimit -l', " + "and it is normally controlled by /etc/security/limits.conf"), + PROGRAM_NAME).c_str()); VBox* vbox = msg.get_vbox(); HBox hbox; CheckButton cb (_("Do not show this window again")); - cb.signal_toggled().connect (mem_fun (*this, &ARDOUR_UI::no_memory_warning)); + cb.signal_toggled().connect (sigc::mem_fun (*this, &ARDOUR_UI::no_memory_warning)); hbox.pack_start (cb, true, false); vbox->pack_start (hbox); @@ -733,18 +811,36 @@ ARDOUR_UI::check_memory_locking () } +void +ARDOUR_UI::queue_finish () +{ + Glib::signal_idle().connect (mem_fun (*this, &ARDOUR_UI::idle_finish)); +} + +bool +ARDOUR_UI::idle_finish () +{ + finish (); + return false; /* do not call again */ +} + void ARDOUR_UI::finish() { - if (session) { + if (_session) { + int tries = 0; - if (session->transport_rolling()) { - session->request_stop (); - usleep (250000); + if (_session->transport_rolling() && (++tries < 8)) { + _session->request_stop (false, true); + usleep (10000); } - if (session->dirty()) { - switch (ask_about_saving_session(_("quit"))) { + if (_session->dirty()) { + vector actions; + actions.push_back (_("Don't quit")); + actions.push_back (_("Just quit")); + actions.push_back (_("Save and quit")); + switch (ask_about_saving_session(actions)) { case -1: return; break; @@ -767,31 +863,46 @@ If you still wish to quit, please use the\n\n\ } } - session->set_deletion_in_progress (); + second_connection.disconnect (); + point_one_second_connection.disconnect (); + point_oh_five_second_connection.disconnect (); + point_zero_one_second_connection.disconnect(); + } + + /* Save state before deleting the session, as that causes some + windows to be destroyed before their visible state can be + saved. + */ + save_ardour_state (); + + if (_session) { + // _session->set_deletion_in_progress (); + _session->set_clean (); + _session->remove_pending_capture_state (); + delete _session; + _session = 0; } ArdourDialog::close_all_dialogs (); engine->stop (true); - save_ardour_state (); quit (); } int -ARDOUR_UI::ask_about_saving_session (const string & what) +ARDOUR_UI::ask_about_saving_session (const vector& actions) { - ArdourDialog window (_("ardour: save session?")); + ArdourDialog window (_("Unsaved Session")); Gtk::HBox dhbox; // the hbox for the image and text Gtk::Label prompt_label; Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING, Gtk::ICON_SIZE_DIALOG)); string msg; - msg = string_compose(_("Don't %1"), what); - window.add_button (msg, RESPONSE_REJECT); - msg = string_compose(_("Just %1"), what); - window.add_button (msg, RESPONSE_APPLY); - msg = string_compose(_("Save and %1"), what); - window.add_button (msg, RESPONSE_ACCEPT); + assert (actions.size() >= 3); + + window.add_button (actions[0], RESPONSE_REJECT); + window.add_button (actions[1], RESPONSE_APPLY); + window.add_button (actions[2], RESPONSE_ACCEPT); window.set_default_response (RESPONSE_ACCEPT); @@ -799,15 +910,14 @@ ARDOUR_UI::ask_about_saving_session (const string & what) noquit_button.set_name ("EditorGTKButton"); string prompt; - string type; - if (session->snap_name() == session->name()) { - type = _("session"); + if (_session->snap_name() == _session->name()) { + 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?"), + _session->snap_name()); } else { - type = _("snapshot"); + 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?"), + _session->snap_name()); } - prompt = string_compose(_("The %1 \"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"), - type, session->snap_name()); prompt_label.set_text (prompt); prompt_label.set_name (X_("PrompterLabel")); @@ -859,7 +969,7 @@ ARDOUR_UI::every_second () gint ARDOUR_UI::every_point_one_seconds () { - update_speed_display (); + shuttle_box->update_speed_display (); RapidScreenUpdate(); /* EMIT_SIGNAL */ return TRUE; } @@ -874,11 +984,11 @@ ARDOUR_UI::every_point_zero_one_seconds () } void -ARDOUR_UI::update_sample_rate (nframes_t ignored) +ARDOUR_UI::update_sample_rate (framecnt_t) { - char buf[32]; + char buf[64]; - ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::update_sample_rate), ignored)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_sample_rate, ignored) if (!engine->connected()) { @@ -886,45 +996,114 @@ ARDOUR_UI::update_sample_rate (nframes_t ignored) } else { - nframes_t rate = engine->frame_rate(); + framecnt_t rate = engine->frame_rate(); if (fmod (rate, 1000.0) != 0.0) { - snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"), + snprintf (buf, sizeof (buf), _("JACK: %.1f kHz / %4.1f ms"), (float) rate/1000.0f, (engine->frames_per_cycle() / (float) rate) * 1000.0f); } else { - snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"), + snprintf (buf, sizeof (buf), _("JACK: %" PRId64 " kHz / %4.1f ms"), rate/1000, (engine->frames_per_cycle() / (float) rate) * 1000.0f); } } - sample_rate_label.set_text (buf); + sample_rate_label.set_markup (buf); } void -ARDOUR_UI::update_cpu_load () +ARDOUR_UI::update_format () { - char buf[32]; - snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load()); - cpu_load_label.set_text (buf); + if (!_session) { + format_label.set_text (""); + return; + } + + stringstream s; + s << _("File:") << X_(" "); + + switch (_session->config.get_native_file_header_format ()) { + case BWF: + s << _("BWF"); + break; + case WAVE: + s << _("WAV"); + break; + case WAVE64: + s << _("WAV64"); + break; + case CAF: + s << _("CAF"); + break; + case AIFF: + s << _("AIFF"); + break; + case iXML: + s << _("iXML"); + break; + case RF64: + s << _("RF64"); + break; + } + + s << " "; + + switch (_session->config.get_native_file_data_format ()) { + case FormatFloat: + s << _("32-float"); + break; + case FormatInt24: + s << _("24-int"); + break; + case FormatInt16: + s << _("16-int"); + break; + } + + s << X_(""); + + format_label.set_markup (s.str ()); } void -ARDOUR_UI::update_buffer_load () +ARDOUR_UI::update_cpu_load () { char buf[64]; - uint32_t c, p; - if (session) { - c = session->capture_load (); - p = session->playback_load (); + /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets + should also be changed. + */ + + float const c = engine->get_cpu_load (); + snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), c >= 90 ? X_("red") : X_("green"), c); + cpu_load_label.set_markup (buf); +} + +void +ARDOUR_UI::update_buffer_load () +{ + char buf[256]; - push_buffer_stats (c, p); + uint32_t const playback = _session ? _session->playback_load () : 100; + uint32_t const capture = _session ? _session->capture_load () : 100; - snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"), - session->playback_load(), session->capture_load()); - buffer_load_label.set_text (buf); + /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets + should also be changed. + */ + + if (_session) { + snprintf ( + buf, sizeof (buf), + _("Buffers: p:%" PRIu32 "%% " + "c:%" PRIu32 "%%"), + playback <= 5 ? X_("red") : X_("green"), + playback, + capture <= 5 ? X_("red") : X_("green"), + capture + ); + + buffer_load_label.set_markup (buf); } else { buffer_load_label.set_text (""); } @@ -934,7 +1113,7 @@ void ARDOUR_UI::count_recenabled_streams (Route& route) { Track* track = dynamic_cast(&route); - if (track && track->diskstream()->record_enabled()) { + if (track && track->record_enabled()) { rec_enabled_streams += track->n_inputs().n_total(); } } @@ -942,19 +1121,19 @@ ARDOUR_UI::count_recenabled_streams (Route& route) void ARDOUR_UI::update_disk_space() { - if (session == 0) { + if (_session == 0) { return; } - nframes_t frames = session->available_capture_duration(); + framecnt_t frames = _session->available_capture_duration(); char buf[64]; - nframes_t fr = session->frame_rate(); + framecnt_t fr = _session->frame_rate(); - if (frames == max_frames) { - strcpy (buf, _("Disk: 24hrs+")); + if (frames == max_framecnt) { + snprintf (buf, sizeof (buf), _("Disk: 24hrs+")); } else { rec_enabled_streams = 0; - session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams); + _session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams); if (rec_enabled_streams) { frames /= rec_enabled_streams; @@ -965,15 +1144,27 @@ ARDOUR_UI::update_disk_space() int secs; hrs = frames / (fr * 3600); - frames -= hrs * fr * 3600; - mins = frames / (fr * 60); - frames -= mins * fr * 60; - secs = frames / fr; - snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs); + if (hrs > 24) { + snprintf (buf, sizeof (buf), _("Disk: >24 hrs")); + } else { + frames -= hrs * fr * 3600; + mins = frames / (fr * 60); + frames -= mins * fr * 60; + secs = frames / fr; + + bool const low = (hrs == 0 && mins <= 30); + + snprintf ( + buf, sizeof(buf), + _("Disk: %02dh:%02dm:%02ds"), + low ? X_("red") : X_("green"), + hrs, mins, secs + ); + } } - disk_space_label.set_text (buf); + disk_space_label.set_markup (buf); // An attempt to make the disk space label flash red when space has run out. @@ -1029,7 +1220,7 @@ ARDOUR_UI::redisplay_recent_sessions () sort (rs.begin(), rs.end(), cmp); for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) { - session_directories.push_back ((*i).second); + session_directories.push_back ((*i).second); } for (vector::const_iterator i = session_directories.begin(); @@ -1106,7 +1297,7 @@ ARDOUR_UI::build_session_selector () recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name); recent_session_display.set_headers_visible (false); recent_session_display.get_selection()->set_mode (SELECTION_BROWSE); - recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated)); + recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ARDOUR_UI::recent_session_row_activated)); scroller->add (recent_session_display); scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC); @@ -1129,7 +1320,7 @@ ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColum void ARDOUR_UI::open_recent_session () { - bool can_return = (session != 0); + bool can_return = (_session != 0); if (session_selector_window == 0) { build_session_selector (); @@ -1167,8 +1358,8 @@ ARDOUR_UI::open_recent_session () return; } - Glib::ustring path = (*i)[recent_session_columns.fullpath]; - Glib::ustring state = (*i)[recent_session_columns.visible_name]; + std::string path = (*i)[recent_session_columns.fullpath]; + std::string state = (*i)[recent_session_columns.visible_name]; _session_is_new = false; @@ -1185,8 +1376,10 @@ ARDOUR_UI::check_audioengine () { if (engine) { if (!engine->connected()) { - MessageDialog msg (_("Ardour is not connected to JACK\n" - "You cannot open or close sessions in this condition")); + MessageDialog msg (string_compose ( + _("%1 is not connected to JACK\n" + "You cannot open or close sessions in this condition"), + PROGRAM_NAME)); pop_back_splash (); msg.run (); return false; @@ -1211,14 +1404,14 @@ ARDOUR_UI::open_session () /* ardour sessions are folders */ - open_session_selector = new Gtk::FileChooserDialog (_("open session"), FILE_CHOOSER_ACTION_OPEN); + open_session_selector = new Gtk::FileChooserDialog (_("Open Session"), FILE_CHOOSER_ACTION_OPEN); open_session_selector->add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL); open_session_selector->add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT); open_session_selector->set_default_response(Gtk::RESPONSE_ACCEPT); FileFilter session_filter; session_filter.add_pattern ("*.ardour"); - session_filter.set_name (_("Ardour sessions")); + session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME)); open_session_selector->add_filter (session_filter); open_session_selector->set_filter (session_filter); } @@ -1249,11 +1442,11 @@ ARDOUR_UI::open_session () void -ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many) +ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many, string const & name_template) { list > tracks; - if (session == 0) { + if (_session == 0) { warning << _("You cannot add a track without a session already loaded.") << endmsg; return; } @@ -1261,7 +1454,7 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t try { if (disk) { - tracks = session->new_midi_track (ARDOUR::Normal, route_group, how_many); + tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many, name_template); if (tracks.size() != how_many) { if (how_many == 1) { @@ -1271,7 +1464,7 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t } } } /*else { - if ((route = session->new_midi_route ()) == 0) { + if ((route = _session->new_midi_route ()) == 0) { error << _("could not create new midi bus") << endmsg; } }*/ @@ -1279,29 +1472,37 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t catch (...) { MessageDialog msg (*editor, - _("There are insufficient JACK ports available\n\ + string_compose (_("There are insufficient JACK ports available\n\ to create a new track or bus.\n\ -You should save Ardour, exit and\n\ -restart JACK with more ports.")); +You should save %1, exit and\n\ +restart JACK with more ports."), PROGRAM_NAME)); msg.run (); } } void -ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many) +ARDOUR_UI::session_add_audio_route ( + bool track, + int32_t input_channels, + int32_t output_channels, + ARDOUR::TrackMode mode, + RouteGroup* route_group, + uint32_t how_many, + string const & name_template + ) { list > tracks; RouteList routes; - if (session == 0) { + if (_session == 0) { warning << _("You cannot add a track or bus without a session already loaded.") << endmsg; return; } try { if (track) { - tracks = session->new_audio_track (input_channels, output_channels, mode, route_group, how_many); + tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many, name_template); if (tracks.size() != how_many) { if (how_many == 1) { @@ -1314,49 +1515,37 @@ ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t } else { - routes = session->new_audio_route (input_channels, output_channels, route_group, how_many); + routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many, name_template); if (routes.size() != how_many) { if (how_many == 1) { - error << _("could not create a new audio track") << endmsg; + error << _("could not create a new audio bus") << endmsg; } else { - error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg; + error << string_compose (_("could not create %1 new audio busses"), how_many) << endmsg; } } } - -#if CONTROLOUTS - if (need_control_room_outs) { - pan_t pans[2]; - - pans[0] = 0.5; - pans[1] = 0.5; - - route->set_stereo_control_outs (control_lr_channels); - route->control_outs()->set_stereo_pan (pans, this); - } -#endif /* CONTROLOUTS */ } catch (...) { MessageDialog msg (*editor, - _("There are insufficient JACK ports available\n\ + string_compose (_("There are insufficient JACK ports available\n\ to create a new track or bus.\n\ -You should save Ardour, exit and\n\ -restart JACK with more ports.")); +You should save %1, exit and\n\ +restart JACK with more ports."), PROGRAM_NAME)); pop_back_splash (); msg.run (); } } void -ARDOUR_UI::do_transport_locate (nframes_t new_position) +ARDOUR_UI::do_transport_locate (framepos_t new_position, bool with_roll) { - nframes_t _preroll = 0; + framecnt_t _preroll = 0; - if (session) { + if (_session) { // XXX CONFIG_CHANGE FIX - requires AnyTime handling - // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll()); + // _preroll = _session->convert_to_frames_at (new_position, Config->get_preroll()); if (new_position > _preroll) { new_position -= _preroll; @@ -1364,23 +1553,22 @@ ARDOUR_UI::do_transport_locate (nframes_t new_position) new_position = 0; } - session->request_locate (new_position); + _session->request_locate (new_position, with_roll); } } void ARDOUR_UI::transport_goto_start () { - if (session) { - session->goto_start(); - + if (_session) { + _session->goto_start(); /* force displayed area in editor to start no matter what "follow playhead" setting is. */ if (editor) { - editor->reset_x_origin (session->current_start_frame()); + editor->center_screen (_session->current_start_frame ()); } } } @@ -1388,9 +1576,8 @@ ARDOUR_UI::transport_goto_start () void ARDOUR_UI::transport_goto_zero () { - if (session) { - session->request_locate (0); - + if (_session) { + _session->request_locate (0); /* force displayed area in editor to start no matter what "follow playhead" setting is. @@ -1405,27 +1592,27 @@ ARDOUR_UI::transport_goto_zero () void ARDOUR_UI::transport_goto_wallclock () { - if (session && editor) { + if (_session && editor) { time_t now; struct tm tmnow; - nframes64_t frames; + framepos_t frames; time (&now); localtime_r (&now, &tmnow); - frames = tmnow.tm_hour * (60 * 60 * session->frame_rate()); - frames += tmnow.tm_min * (60 * session->frame_rate()); - frames += tmnow.tm_sec * session->frame_rate(); + frames = tmnow.tm_hour * (60 * 60 * _session->frame_rate()); + frames += tmnow.tm_min * (60 * _session->frame_rate()); + frames += tmnow.tm_sec * _session->frame_rate(); - session->request_locate (frames); + _session->request_locate (frames, _session->transport_rolling ()); /* force displayed area in editor to start no matter what "follow playhead" setting is. */ if (editor) { - editor->reset_x_origin (frames - (editor->current_page_frames()/2)); + editor->center_screen (frames); } } } @@ -1433,16 +1620,16 @@ ARDOUR_UI::transport_goto_wallclock () void ARDOUR_UI::transport_goto_end () { - if (session) { - nframes_t frame = session->current_end_frame(); - session->request_locate (frame); + if (_session) { + framepos_t const frame = _session->current_end_frame(); + _session->request_locate (frame); /* force displayed area in editor to start no matter what "follow playhead" setting is. */ if (editor) { - editor->reset_x_origin (frame); + editor->center_screen (frame); } } } @@ -1450,27 +1637,23 @@ ARDOUR_UI::transport_goto_end () void ARDOUR_UI::transport_stop () { - if (!session) { + if (!_session) { return; } - if (session->is_auditioning()) { - session->cancel_audition (); + if (_session->is_auditioning()) { + _session->cancel_audition (); return; } - if (session->get_play_loop ()) { - session->request_play_loop (false); - } - - session->request_stop (); + _session->request_stop (false, true); } void ARDOUR_UI::transport_stop_and_forget_capture () { - if (session) { - session->request_stop (true); + if (_session) { + _session->request_stop (true, true); } } @@ -1486,88 +1669,175 @@ void ARDOUR_UI::transport_record (bool roll) { - if (session) { - switch (session->record_status()) { + if (_session) { + switch (_session->record_status()) { case Session::Disabled: - if (session->ntracks() == 0) { - MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu.")); + if (_session->ntracks() == 0) { + MessageDialog msg (*editor, _("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.")); msg.run (); return; } - session->maybe_enable_record (); + _session->maybe_enable_record (); if (roll) { transport_roll (); } break; case Session::Recording: if (roll) { - session->request_stop(); + _session->request_stop(); } else { - session->disable_record (false, true); + _session->disable_record (false, true); } break; case Session::Enabled: - session->disable_record (false, true); + _session->disable_record (false, true); } } - //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " session->record_status() = " << session->record_status() << endl; + //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " _session->record_status() = " << _session->record_status() << endl; } void ARDOUR_UI::transport_roll () { - bool rolling; + if (!_session) { + return; + } - if (!session) { + if (_session->is_auditioning()) { return; } - rolling = session->transport_rolling (); +#if 0 + if (_session->config.get_external_sync()) { + switch (_session->config.get_sync_source()) { + case JACK: + break; + default: + /* transport controlled by the master */ + return; + } + } +#endif + + bool rolling = _session->transport_rolling(); - //cerr << "ARDOUR_UI::transport_roll () called session->record_status() = " << session->record_status() << endl; + if (_session->get_play_loop()) { + /* XXX it is not possible to just leave seamless loop and keep + playing at present (nov 4th 2009) + */ + if (!Config->get_seamless_loop()) { + _session->request_play_loop (false, true); + } + } else if (_session->get_play_range () && !join_play_range_button.active_state()) { + /* stop playing a range if we currently are */ + _session->request_play_range (0, true); + } - if (session->get_play_loop()) { - session->request_play_loop (false); - auto_loop_button.set_visual_state (1); - roll_button.set_visual_state (1); - } else if (session->get_play_range ()) { - session->request_play_range (false); - play_selection_button.set_visual_state (0); - } else if (rolling) { - session->request_locate (session->last_transport_start(), true); + if (join_play_range_button.active_state()) { + _session->request_play_range (&editor->get_selection().time, true); } - session->request_transport_speed (1.0f); + if (!rolling) { + _session->request_transport_speed (1.0f); + } } void -ARDOUR_UI::transport_loop() +ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode) { - if (session) { - if (session->get_play_loop()) { - if (session->transport_rolling()) { - Location * looploc = session->locations()->auto_loop_location(); - if (looploc) { - session->request_locate (looploc->start(), true); - } + + if (!_session) { + return; + } + + if (_session->is_auditioning()) { + _session->cancel_audition (); + return; + } + + if (_session->config.get_external_sync()) { + switch (_session->config.get_sync_source()) { + case JACK: + break; + default: + /* transport controlled by the master */ + return; + } + } + + bool rolling = _session->transport_rolling(); + bool affect_transport = true; + + if (rolling && roll_out_of_bounded_mode) { + /* drop out of loop/range playback but leave transport rolling */ + if (_session->get_play_loop()) { + if (Config->get_seamless_loop()) { + /* the disk buffers contain copies of the loop - we can't + just keep playing, so stop the transport. the user + can restart as they wish. + */ + affect_transport = true; + } else { + /* disk buffers are normal, so we can keep playing */ + affect_transport = false; } + _session->request_play_loop (false, true); + } else if (_session->get_play_range ()) { + affect_transport = false; + _session->request_play_range (0, true); } - else { - session->request_play_loop (true); + } + + if (affect_transport) { + if (rolling) { + _session->request_stop (with_abort, true); + } else { + if (join_play_range_button.active_state()) { + _session->request_play_range (&editor->get_selection().time, true); + } + + _session->request_transport_speed (1.0f); } } } void -ARDOUR_UI::transport_play_selection () +ARDOUR_UI::toggle_session_auto_loop () { - if (!session) { + if (!_session) { return; } - if (!session->get_play_range()) { - session->request_stop (); + if (_session->get_play_loop()) { + + if (_session->transport_rolling()) { + + Location * looploc = _session->locations()->auto_loop_location(); + + if (looploc) { + _session->request_locate (looploc->start(), true); + _session->request_play_loop (false); + } + + } else { + _session->request_play_loop (false); + } + } else { + + Location * looploc = _session->locations()->auto_loop_location(); + + if (looploc) { + _session->request_play_loop (true); + } + } +} + +void +ARDOUR_UI::transport_play_selection () +{ + if (!_session) { + return; } editor->play_selection (); @@ -1578,24 +1848,24 @@ ARDOUR_UI::transport_rewind (int option) { float current_transport_speed; - if (session) { - current_transport_speed = session->transport_speed(); + if (_session) { + current_transport_speed = _session->transport_speed(); if (current_transport_speed >= 0.0f) { switch (option) { case 0: - session->request_transport_speed (-1.0f); + _session->request_transport_speed (-1.0f); break; case 1: - session->request_transport_speed (-4.0f); + _session->request_transport_speed (-4.0f); break; case -1: - session->request_transport_speed (-0.5f); + _session->request_transport_speed (-0.5f); break; } } else { /* speed up */ - session->request_transport_speed (current_transport_speed * 1.5f); + _session->request_transport_speed (current_transport_speed * 1.5f); } } } @@ -1605,76 +1875,111 @@ ARDOUR_UI::transport_forward (int option) { float current_transport_speed; - if (session) { - current_transport_speed = session->transport_speed(); + if (_session) { + current_transport_speed = _session->transport_speed(); if (current_transport_speed <= 0.0f) { switch (option) { case 0: - session->request_transport_speed (1.0f); + _session->request_transport_speed (1.0f); break; case 1: - session->request_transport_speed (4.0f); + _session->request_transport_speed (4.0f); break; case -1: - session->request_transport_speed (0.5f); + _session->request_transport_speed (0.5f); break; } } else { /* speed up */ - session->request_transport_speed (current_transport_speed * 1.5f); + _session->request_transport_speed (current_transport_speed * 1.5f); } + } } void -ARDOUR_UI::toggle_record_enable (uint32_t dstream) +ARDOUR_UI::toggle_record_enable (uint32_t rid) { - if (session == 0) { + if (_session == 0) { return; } boost::shared_ptr r; - if ((r = session->route_by_remote_id (dstream)) != 0) { + if ((r = _session->route_by_remote_id (rid)) != 0) { Track* t; if ((t = dynamic_cast(r.get())) != 0) { - t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled()); + t->set_record_enabled (!t->record_enabled(), this); } } - if (session == 0) { + if (_session == 0) { return; } } -void -ARDOUR_UI::queue_transport_change () -{ - Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state)); -} - void ARDOUR_UI::map_transport_state () { - float sp = session->transport_speed(); + if (!_session) { + auto_loop_button.unset_active_state (); + play_selection_button.unset_active_state (); + roll_button.unset_active_state (); + stop_button.set_active_state (Gtkmm2ext::Active); + return; + } + + shuttle_box->map_transport_state (); + + float sp = _session->transport_speed(); + + if (sp != 0.0f) { + + /* we're rolling */ + + if (_session->get_play_range()) { + + play_selection_button.set_active_state (Gtkmm2ext::Active); + roll_button.unset_active_state (); + auto_loop_button.unset_active_state (); + + } else if (_session->get_play_loop ()) { + + auto_loop_button.set_active_state (Gtkmm2ext::Active); + play_selection_button.unset_active_state (); + roll_button.unset_active_state (); + + } else { + + roll_button.set_active_state (Gtkmm2ext::Active); + play_selection_button.unset_active_state (); + auto_loop_button.unset_active_state (); + } + + if (join_play_range_button.active_state()) { + /* light up both roll and play-selection if they are joined */ + roll_button.set_active_state (Gtkmm2ext::Active); + play_selection_button.set_active_state (Gtkmm2ext::Active); + } + + stop_button.unset_active_state (); - if (sp == 1.0f) { - transport_rolling (); - } else if (sp < 0.0f) { - transport_rewinding (); - } else if (sp > 0.0f) { - transport_forwarding (); } else { - transport_stopped (); + + stop_button.set_active_state (Gtkmm2ext::Active); + roll_button.unset_active_state (); + play_selection_button.unset_active_state (); + auto_loop_button.unset_active_state (); + update_disk_space (); } } void ARDOUR_UI::engine_stopped () { - ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_stopped)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_stopped) ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false); ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true); } @@ -1682,7 +1987,7 @@ ARDOUR_UI::engine_stopped () void ARDOUR_UI::engine_running () { - ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_running) ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true); ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false); @@ -1731,23 +2036,46 @@ ARDOUR_UI::engine_running () } void -ARDOUR_UI::engine_halted () +ARDOUR_UI::engine_halted (const char* reason, bool free_reason) { - ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted)); + if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) { + /* we can't rely on the original string continuing to exist when we are called + again in the GUI thread, so make a copy and note that we need to + free it later. + */ + char *copy = strdup (reason); + Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&ARDOUR_UI::engine_halted, this, copy, true)); + return; + } ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false); ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true); update_sample_rate (0); - MessageDialog msg (*editor, - _("\ + string msgstr; + + /* if the reason is a non-empty string, it means that the backend was shutdown + rather than just Ardour. + */ + + if (strlen (reason)) { + msgstr = string_compose (_("The audio backend (JACK) was shutdown because:\n\n%1"), reason); + } else { + msgstr = string_compose (_("\ JACK has either been shutdown or it\n\ -disconnected Ardour because Ardour\n\ +disconnected %1 because %1\n\ was not fast enough. Try to restart\n\ -JACK, reconnect and save the session.")); +JACK, reconnect and save the session."), PROGRAM_NAME); + } + + MessageDialog msg (*editor, msgstr); pop_back_splash (); msg.run (); + + if (free_reason) { + free ((char*) reason); + } } int32_t @@ -1778,14 +2106,14 @@ void ARDOUR_UI::update_clocks () { if (!editor || !editor->dragging_playhead()) { - Clock (session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */ + Clock (_session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */ } } void ARDOUR_UI::start_clocking () { - clock_signal_connection = RapidScreenUpdate.connect (mem_fun(*this, &ARDOUR_UI::update_clocks)); + clock_signal_connection = RapidScreenUpdate.connect (sigc::mem_fun(*this, &ARDOUR_UI::update_clocks)); } void @@ -1845,24 +2173,30 @@ ARDOUR_UI::stop_blinking () /** Ask the user for the name of a new shapshot and then take it. */ + void -ARDOUR_UI::snapshot_session () +ARDOUR_UI::snapshot_session (bool switch_to_it) { ArdourPrompter prompter (true); string snapname; - char timebuf[128]; - time_t n; - struct tm local_time; - - time (&n); - localtime_r (&n, &local_time); - strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time); prompter.set_name ("Prompter"); prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT); - prompter.set_prompt (_("Name of New Snapshot")); - prompter.set_initial_text (timebuf); + prompter.set_title (_("Take Snapshot")); + prompter.set_prompt (_("Name of new snapshot")); + if (!switch_to_it) { + char timebuf[128]; + time_t n; + struct tm local_time; + + time (&n); + localtime_r (&n, &local_time); + strftime (timebuf, sizeof(timebuf), "%FT%H.%M.%S", &local_time); + prompter.set_initial_text (timebuf); + } + + again: switch (prompter.run()) { case RESPONSE_ACCEPT: { @@ -1870,12 +2204,33 @@ ARDOUR_UI::snapshot_session () bool do_save = (snapname.length() != 0); + if (do_save) { + if (snapname.find ('/') != string::npos) { + MessageDialog msg (_("To ensure compatibility with various systems\n" + "snapshot names may not contain a '/' character")); + msg.run (); + goto again; + } + if (snapname.find ('\\') != string::npos) { + MessageDialog msg (_("To ensure compatibility with various systems\n" + "snapshot names may not contain a '\\' character")); + msg.run (); + goto again; + } + if (snapname.find (':') != string::npos) { + MessageDialog msg (_("To ensure compatibility with various systems\n" + "snapshot names may not contain a ':' character")); + msg.run (); + goto again; + } + } + vector p; - get_state_files_in_directory (session->session_directory().root_path(), p); + get_state_files_in_directory (_session->session_directory().root_path(), p); vector n = get_file_names_no_extension (p); if (find (n.begin(), n.end(), snapname) != n.end()) { - ArdourDialog confirm (_("Confirm snapshot overwrite"), true); + ArdourDialog confirm (_("Confirm Snapshot Overwrite"), true); Label m (_("A snapshot already exists with that name. Do you want to overwrite it?")); confirm.get_vbox()->pack_start (m, true, true); confirm.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL); @@ -1888,8 +2243,75 @@ ARDOUR_UI::snapshot_session () } if (do_save) { - save_state (snapname); + save_state (snapname, switch_to_it); + } + break; + } + + default: + break; + } +} + +/** Ask the user for the name of a new shapshot and then take it. + */ + +void +ARDOUR_UI::rename_session () +{ + if (!_session) { + return; + } + + ArdourPrompter prompter (true); + string name; + + prompter.set_name ("Prompter"); + prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT); + prompter.set_title (_("Rename Session")); + prompter.set_prompt (_("New session name")); + + again: + switch (prompter.run()) { + case RESPONSE_ACCEPT: + { + prompter.get_result (name); + + bool do_rename = (name.length() != 0); + + if (do_rename) { + if (name.find ('/') != string::npos) { + MessageDialog msg (_("To ensure compatibility with various systems\n" + "session names may not contain a '/' character")); + msg.run (); + goto again; + } + if (name.find ('\\') != string::npos) { + MessageDialog msg (_("To ensure compatibility with various systems\n" + "session names may not contain a '\\' character")); + msg.run (); + goto again; + } + + switch (_session->rename (name)) { + case -1: { + MessageDialog msg (_("That name is already in use by another directory/folder. Please try again.")); + msg.set_position (WIN_POS_MOUSE); + msg.run (); + goto again; + break; + } + case 0: + break; + default: { + MessageDialog msg (_("Renaming this session failed.\nThings could be seriously messed up at this point")); + msg.set_position (WIN_POS_MOUSE); + msg.run (); + break; + } + } } + break; } @@ -1899,25 +2321,38 @@ ARDOUR_UI::snapshot_session () } void -ARDOUR_UI::save_state (const string & name) +ARDOUR_UI::save_state (const string & name, bool switch_to_it) { - (void) save_state_canfail (name); + XMLNode* node = new XMLNode (X_("UI")); + + for (list::iterator i = _window_proxies.begin(); i != _window_proxies.end(); ++i) { + if (!(*i)->rc_configured()) { + node->add_child_nocopy (*((*i)->get_state ())); + } + } + + node->add_child_nocopy (gui_object_state->get_state()); + + _session->add_extra_xml (*node); + + save_state_canfail (name, switch_to_it); } int -ARDOUR_UI::save_state_canfail (string name) +ARDOUR_UI::save_state_canfail (string name, bool switch_to_it) { - if (session) { + if (_session) { int ret; if (name.length() == 0) { - name = session->snap_name(); + name = _session->snap_name(); } - if ((ret = session->save_state (name)) != 0) { + if ((ret = _session->save_state (name, false, switch_to_it)) != 0) { return ret; } } + save_ardour_state (); /* XXX cannot fail? yeah, right ... */ return 0; } @@ -1925,53 +2360,56 @@ ARDOUR_UI::save_state_canfail (string name) void ARDOUR_UI::primary_clock_value_changed () { - if (session) { - session->request_locate (primary_clock.current_time ()); + if (_session) { + _session->request_locate (primary_clock->current_time ()); } } void ARDOUR_UI::big_clock_value_changed () { - if (session) { - session->request_locate (big_clock.current_time ()); + if (_session) { + _session->request_locate (big_clock->current_time ()); } } void ARDOUR_UI::secondary_clock_value_changed () { - if (session) { - session->request_locate (secondary_clock.current_time ()); + if (_session) { + _session->request_locate (secondary_clock->current_time ()); } } void ARDOUR_UI::transport_rec_enable_blink (bool onoff) { - if (session == 0) { + if (_session == 0) { + return; + } + + if (_session->step_editing()) { return; } - Session::RecordState const r = session->record_status (); - bool const h = session->have_rec_enabled_diskstream (); + Session::RecordState const r = _session->record_status (); + bool const h = _session->have_rec_enabled_track (); if (r == Session::Enabled || (r == Session::Recording && !h)) { if (onoff) { - rec_button.set_visual_state (2); + rec_button.set_active_state (Active); } else { - rec_button.set_visual_state (0); + rec_button.set_active_state (Mid); } } else if (r == Session::Recording && h) { - rec_button.set_visual_state (1); + rec_button.set_active_state (Mid); } else { - rec_button.set_visual_state (0); + rec_button.unset_active_state (); } } void ARDOUR_UI::save_template () - { ArdourPrompter prompter (true); string name; @@ -1981,8 +2419,9 @@ ARDOUR_UI::save_template () } prompter.set_name (X_("Prompter")); - prompter.set_prompt (_("Name for mix template:")); - prompter.set_initial_text(session->name() + _("-template")); + prompter.set_title (_("Save Template")); + prompter.set_prompt (_("Name for template:")); + prompter.set_initial_text(_session->name() + _("-template")); prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT); switch (prompter.run()) { @@ -1990,7 +2429,7 @@ ARDOUR_UI::save_template () prompter.get_result (name); if (name.length()) { - session->save_template (name); + _session->save_template (name); } break; @@ -2003,7 +2442,7 @@ void ARDOUR_UI::edit_metadata () { SessionMetadataEditor dialog; - dialog.set_session (session); + dialog.set_session (_session); editor->ensure_float (dialog); dialog.run (); } @@ -2012,111 +2451,15 @@ void ARDOUR_UI::import_metadata () { SessionMetadataImporter dialog; - dialog.set_session (session); + dialog.set_session (_session); editor->ensure_float (dialog); dialog.run (); } -void -ARDOUR_UI::fontconfig_dialog () -{ -#ifdef GTKOSX - /* X11 users will always have fontconfig info around, but new GTK-OSX users - may not and it can take a while to build it. Warn them. - */ - - Glib::ustring fontconfig = Glib::build_filename (Glib::get_home_dir(), ".fontconfig"); - - if (!Glib::file_test (fontconfig, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) { - MessageDialog msg (*_startup, - _("Welcome to Ardour.\n\n" - "The program will take a bit longer to start up\n" - "while the system fonts are checked.\n\n" - "This will only be done once, and you will\n" - "not see this message again\n"), - true, - Gtk::MESSAGE_INFO, - Gtk::BUTTONS_OK); - pop_back_splash (); - msg.show_all (); - msg.present (); - msg.run (); - } -#endif -} - -void -ARDOUR_UI::parse_cmdline_path (const Glib::ustring& cmdline_path, Glib::ustring& session_name, Glib::ustring& session_path, bool& existing_session) -{ - existing_session = false; - - if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_DIR)) { - session_path = cmdline_path; - existing_session = true; - } else if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_REGULAR)) { - session_path = Glib::path_get_dirname (string (cmdline_path)); - existing_session = true; - } else { - /* it doesn't exist, assume the best */ - session_path = Glib::path_get_dirname (string (cmdline_path)); - } - - session_name = basename_nosuffix (string (cmdline_path)); -} - -int -ARDOUR_UI::load_cmdline_session (const Glib::ustring& session_name, const Glib::ustring& session_path, bool& existing_session) -{ - /* when this is called, the backend audio system must be running */ - - /* the main idea here is to deal with the fact that a cmdline argument for the session - can be interpreted in different ways - it could be a directory or a file, and before - we load, we need to know both the session directory and the snapshot (statefile) within it - that we are supposed to use. - */ - - if (session_name.length() == 0 || session_path.length() == 0) { - return false; - } - - if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) { - - Glib::ustring predicted_session_file; - - predicted_session_file = session_path; - predicted_session_file += '/'; - predicted_session_file += session_name; - predicted_session_file += ARDOUR::statefile_suffix; - - if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) { - existing_session = true; - } - - } else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) { - - if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) { - /* existing .ardour file */ - existing_session = true; - } - - } else { - existing_session = false; - } - - /* lets just try to load it */ - - if (create_engine ()) { - backend_audio_error (false, _startup); - return -1; - } - - return load_session (session_path, session_name); -} - bool -ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path) +ARDOUR_UI::ask_about_loading_existing_session (const std::string& session_path) { - Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path); + std::string str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path); MessageDialog msg (str, false, @@ -2125,8 +2468,9 @@ ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path true); - msg.set_name (X_("CleanupDialog")); - msg.set_wmclass (X_("existing_session"), "Ardour"); + msg.set_name (X_("OpenExistingDialog")); + msg.set_title (_("Open Existing Session")); + msg.set_wmclass (X_("existing_session"), PROGRAM_NAME); msg.set_position (Gtk::WIN_POS_MOUSE); pop_back_splash (); @@ -2139,71 +2483,49 @@ ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path } int -ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& session_name) +ARDOUR_UI::build_session_from_nsd (const std::string& session_path, const std::string& session_name) { - - uint32_t cchns; - uint32_t mchns; - AutoConnectOption iconnect; - AutoConnectOption oconnect; - uint32_t nphysin; - uint32_t nphysout; + BusProfile bus_profile; if (Profile->get_sae()) { - cchns = 0; - mchns = 2; - iconnect = AutoConnectPhysical; - oconnect = AutoConnectMaster; - nphysin = 0; // use all available - nphysout = 0; // use all available + bus_profile.master_out_channels = 2; + bus_profile.input_ac = AutoConnectPhysical; + bus_profile.output_ac = AutoConnectMaster; + bus_profile.requested_physical_in = 0; // use all available + bus_profile.requested_physical_out = 0; // use all available } else { /* get settings from advanced section of NSD */ - if (_startup->create_control_bus()) { - cchns = (uint32_t) _startup->control_channel_count(); - } else { - cchns = 0; - } - if (_startup->create_master_bus()) { - mchns = (uint32_t) _startup->master_channel_count(); + bus_profile.master_out_channels = (uint32_t) _startup->master_channel_count(); } else { - mchns = 0; + bus_profile.master_out_channels = 0; } if (_startup->connect_inputs()) { - iconnect = AutoConnectPhysical; + bus_profile.input_ac = AutoConnectPhysical; } else { - iconnect = AutoConnectOption (0); + bus_profile.input_ac = AutoConnectOption (0); } - /// @todo some minor tweaks. + bus_profile.output_ac = AutoConnectOption (0); - if (_startup->connect_outs_to_master()) { - oconnect = AutoConnectMaster; - } else if (_startup->connect_outs_to_physical()) { - oconnect = AutoConnectPhysical; - } else { - oconnect = AutoConnectOption (0); + if (_startup->connect_outputs ()) { + if (_startup->connect_outs_to_master()) { + bus_profile.output_ac = AutoConnectMaster; + } else if (_startup->connect_outs_to_physical()) { + bus_profile.output_ac = AutoConnectPhysical; + } } - nphysin = (uint32_t) _startup->input_limit_count(); - nphysout = (uint32_t) _startup->output_limit_count(); + bus_profile.requested_physical_in = (uint32_t) _startup->input_limit_count(); + bus_profile.requested_physical_out = (uint32_t) _startup->output_limit_count(); } - if (build_session (session_path, - session_name, - cchns, - mchns, - iconnect, - oconnect, - nphysin, - nphysout, - engine->frame_rate() * 60 * 5)) { - + if (build_session (session_path, session_name, bus_profile)) { return -1; } @@ -2211,9 +2533,9 @@ ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib } void -ARDOUR_UI::idle_load (const Glib::ustring& path) +ARDOUR_UI::idle_load (const std::string& path) { - if (session) { + if (_session) { if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) { /* /path/to/foo => /path/to/foo, foo */ load_session (path, basename_nosuffix (path)); @@ -2259,15 +2581,21 @@ ARDOUR_UI::loading_message (const std::string& /*msg*/) flush_pending (); } +/** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */ int -ARDOUR_UI::get_session_parameters (bool should_be_new) +ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new, string load_template) { - Glib::ustring session_name; - Glib::ustring session_path; - Glib::ustring template_name; + string session_name; + string session_path; + string template_name; int ret = -1; bool likely_new = false; + if (!load_template.empty()) { + should_be_new = true; + template_name = load_template; + } + while (ret != 0) { if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) { @@ -2277,17 +2605,28 @@ ARDOUR_UI::get_session_parameters (bool should_be_new) to find the session. */ - if (ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix) != string::npos) { + string::size_type suffix = ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix); + + if (suffix != string::npos) { session_path = Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name); + session_name = ARDOUR_COMMAND_LINE::session_name.substr (0, suffix); + session_name = Glib::path_get_basename (session_name); } else { session_path = ARDOUR_COMMAND_LINE::session_name; + session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name); } - session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name); - } else { - run_startup (should_be_new); + bool const apply = run_startup (should_be_new, load_template); + + if (!apply) { + if (quit_on_cancel) { + exit (1); + } else { + return ret; + } + } /* if we run the startup dialog again, offer more than just "new session" */ @@ -2295,20 +2634,30 @@ ARDOUR_UI::get_session_parameters (bool should_be_new) session_name = _startup->session_name (likely_new); + string::size_type suffix = session_name.find (statefile_suffix); + + if (suffix != string::npos) { + session_name = session_name.substr (0, suffix); + } + /* this shouldn't happen, but we catch it just in case it does */ if (session_name.empty()) { - break; + continue; } + if (_startup->use_session_template()) { template_name = _startup->session_template_name(); _session_is_new = true; } + if (session_name[0] == G_DIR_SEPARATOR || + (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == G_DIR_SEPARATOR) || + (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == G_DIR_SEPARATOR)) { - if (session_name[0] == '/' || - (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') || - (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) { + /* absolute path or cwd-relative path specified for session name: infer session folder + from what was given. + */ session_path = Glib::path_get_dirname (session_name); session_name = Glib::path_get_basename (session_name); @@ -2316,6 +2665,24 @@ ARDOUR_UI::get_session_parameters (bool should_be_new) } else { session_path = _startup->session_folder(); + + if (session_name.find ('/') != string::npos) { + MessageDialog msg (*_startup, + _("To ensure compatibility with various systems\n" + "session names may not contain a '/' character")); + msg.run (); + ARDOUR_COMMAND_LINE::session_name = ""; // cancel that + continue; + } + + if (session_name.find ('\\') != string::npos) { + MessageDialog msg (*_startup, + _("To ensure compatibility with various systems\n" + "session names may not contain a '\\' character")); + msg.run (); + ARDOUR_COMMAND_LINE::session_name = ""; // cancel that + continue; + } } } @@ -2327,7 +2694,7 @@ ARDOUR_UI::get_session_parameters (bool should_be_new) if (likely_new) { - Glib::ustring existing = Glib::build_filename (session_path, session_name); + std::string existing = Glib::build_filename (session_path, session_name); if (!ask_about_loading_existing_session (existing)) { ARDOUR_COMMAND_LINE::session_name = ""; // cancel that @@ -2346,6 +2713,24 @@ ARDOUR_UI::get_session_parameters (bool should_be_new) continue; } + if (session_name.find ('/') != std::string::npos) { + MessageDialog msg (*_startup, + _("To ensure compatibility with various systems\n" + "session names may not contain a '/' character")); + msg.run (); + ARDOUR_COMMAND_LINE::session_name = ""; // cancel that + continue; + } + + if (session_name.find ('\\') != std::string::npos) { + MessageDialog msg (*_startup, + _("To ensure compatibility with various systems\n" + "session names may not contain a '\\' character")); + msg.run (); + ARDOUR_COMMAND_LINE::session_name = ""; // cancel that + continue; + } + _session_is_new = true; } @@ -2356,6 +2741,16 @@ ARDOUR_UI::get_session_parameters (bool should_be_new) } else { ret = load_session (session_path, session_name, template_name); + + if (ret == -2) { + /* not connected to the AudioEngine, so quit to avoid an infinite loop */ + exit (1); + } + + if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) { + _session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false); + exit (1); + } } } @@ -2369,14 +2764,24 @@ ARDOUR_UI::close_session() return; } - unload_session (true); + if (unload_session (true)) { + return; + } ARDOUR_COMMAND_LINE::session_name = ""; - get_session_parameters (false); + + if (get_session_parameters (true, false)) { + exit (1); + } + + goto_editor_window (); } +/** @param snap_name Snapshot name (without .ardour suffix). + * @return -2 if the load failed because we are not connected to the AudioEngine. + */ int -ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_name, Glib::ustring mix_template) +ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name, std::string mix_template) { Session *new_session; int unload_status; @@ -2385,7 +2790,7 @@ ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_na session_loaded = false; if (!check_audioengine()) { - return -1; + return -2; } unload_status = unload_session (); @@ -2397,10 +2802,10 @@ ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_na goto out; } - loading_message (_("Please wait while Ardour loads your session")); + loading_message (string_compose (_("Please wait while %1 loads your session"), PROGRAM_NAME)); try { - new_session = new Session (*engine, path, snap_name, mix_template); + new_session = new Session (*engine, path, snap_name, 0, mix_template); } /* this one is special */ @@ -2433,38 +2838,59 @@ ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_na catch (...) { - MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name), - true, - Gtk::MESSAGE_INFO, - Gtk::BUTTONS_CLOSE); + MessageDialog msg (string_compose( + _("Session \"%1 (snapshot %2)\" did not load successfully"), + path, snap_name), + true, + Gtk::MESSAGE_INFO, + BUTTONS_OK); msg.set_title (_("Loading Error")); - msg.set_secondary_text (_("Click the Close button to try again.")); + msg.set_secondary_text (_("Click the Refresh button to try again.")); + msg.add_button (Stock::REFRESH, 1); msg.set_position (Gtk::WIN_POS_CENTER); pop_back_splash (); msg.present (); int response = msg.run (); - msg.hide (); - switch (response) { - case RESPONSE_CANCEL: - exit (1); - default: + case 1: break; + default: + exit (1); } + + msg.hide (); + goto out; } - connect_to_session (new_session); + { + list const u = new_session->unknown_processors (); + if (!u.empty()) { + MissingPluginDialog d (_session, u); + d.run (); + } + } + + /* Now the session been created, add the transport controls */ + new_session->add_controllable(roll_controllable); + new_session->add_controllable(stop_controllable); + new_session->add_controllable(goto_start_controllable); + new_session->add_controllable(goto_end_controllable); + new_session->add_controllable(auto_loop_controllable); + new_session->add_controllable(play_selection_controllable); + new_session->add_controllable(rec_controllable); + + set_session (new_session); session_loaded = true; goto_editor_window (); - if (session) { - session->set_clean (); + if (_session) { + _session->set_clean (); } flush_pending (); @@ -2475,14 +2901,7 @@ ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_na } int -ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name, - uint32_t control_channels, - uint32_t master_channels, - AutoConnectOption input_connect, - AutoConnectOption output_connect, - uint32_t nphysin, - uint32_t nphysout, - nframes_t initial_length) +ARDOUR_UI::build_session (const std::string& path, const std::string& snap_name, BusProfile& bus_profile) { Session *new_session; int x; @@ -2504,8 +2923,7 @@ ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_n _session_is_new = true; try { - new_session = new Session (*engine, path, snap_name, input_connect, output_connect, - control_channels, master_channels, nphysin, nphysout, initial_length); + new_session = new Session (*engine, path, snap_name, &bus_profile); } catch (...) { @@ -2516,7 +2934,26 @@ ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_n return -1; } - connect_to_session (new_session); + /* Give the new session the default GUI state, if such things exist */ + + XMLNode* n; + n = Config->instant_xml (X_("Editor")); + if (n) { + new_session->add_instant_xml (*n, false); + } + n = Config->instant_xml (X_("Mixer")); + if (n) { + new_session->add_instant_xml (*n, false); + } + + /* Put the playhead at 0 and scroll fully left */ + n = new_session->instant_xml (X_("Editor")); + if (n) { + n->add_property (X_("playhead"), X_("0")); + n->add_property (X_("left-frame"), X_("0")); + } + + set_session (new_session); session_loaded = true; @@ -2526,17 +2963,13 @@ ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_n } void -ARDOUR_UI::show () +ARDOUR_UI::launch_chat () { - if (editor) { - editor->show_window (); - - if (!shown_flag) { - editor->present (); - } - - shown_flag = true; - } +#ifdef __APPLE__ + open_uri("http://webchat.freenode.net/?channels=ardour-osx"); +#else + open_uri("http://webchat.freenode.net/?channels=ardour"); +#endif } void @@ -2544,17 +2977,30 @@ ARDOUR_UI::show_about () { if (about == 0) { about = new About; - about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) ); + about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) ); } + about->set_transient_for(*editor); about->show_all (); } +void +ARDOUR_UI::launch_manual () +{ + PBD::open_uri("http://ardour.org/flossmanual"); +} + +void +ARDOUR_UI::launch_reference () +{ + PBD::open_uri("http://ardour.org/refmanual"); +} + void ARDOUR_UI::hide_about () { if (about) { - about->get_window()->set_cursor (); + about->get_window()->set_cursor (); about->hide (); } } @@ -2592,7 +3038,7 @@ ARDOUR_UI::hide_splash () } void -ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, +ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title, const string& plural_msg, const string& singular_msg) { size_t removed; @@ -2601,10 +3047,11 @@ ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* l if (removed == 0) { MessageDialog msgd (*editor, - _("No audio files were ready for cleanup"), + _("No files were ready for clean-up"), true, Gtk::MESSAGE_INFO, - (Gtk::ButtonsType)(Gtk::BUTTONS_OK) ); + Gtk::BUTTONS_OK); + msgd.set_title (_("Clean-up")); msgd.set_secondary_text (_("If this seems suprising, \n\ check for any existing snapshots.\n\ These may still include regions that\n\ @@ -2614,15 +3061,15 @@ require some unused files to continue to exist.")); return; } - ArdourDialog results (_("ardour: cleanup"), true, false); + ArdourDialog results (_("Clean-up"), true, false); struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord { CleanupResultsModelColumns() { add (visible_name); add (fullpath); } - Gtk::TreeModelColumn visible_name; - Gtk::TreeModelColumn fullpath; + Gtk::TreeModelColumn visible_name; + Gtk::TreeModelColumn fullpath; }; @@ -2648,32 +3095,36 @@ require some unused files to continue to exist.")); dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP); - const string dead_sound_directory = session->session_directory().dead_sound_path().to_string(); - - - + const string dead_directory = _session->session_directory().dead_path().to_string(); /* subst: %1 - number of files removed - %2 - location of "dead_sounds" + %2 - location of "dead" %3 - size of files affected %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga) */ const char* bprefix; + double space_adjusted = 0; - if (rep.space < 1048576.0f) { + if (rep.space < 1000) { + bprefix = X_(""); + space_adjusted = rep.space; + } else if (rep.space < 1000000) { bprefix = X_("kilo"); - } else if (rep.space < 1048576.0f * 1000) { + space_adjusted = truncf((float)rep.space / 1000.0); + } else if (rep.space < 1000000 * 1000) { bprefix = X_("mega"); + space_adjusted = truncf((float)rep.space / (1000.0 * 1000.0)); } else { bprefix = X_("giga"); + space_adjusted = truncf((float)rep.space / (1000.0 * 1000 * 1000.0)); } if (removed > 1) { - txt.set_text (string_compose (plural_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix)); + txt.set_text (string_compose (plural_msg, removed, dead_directory, space_adjusted, bprefix)); } else { - txt.set_text (string_compose (singular_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix)); + txt.set_text (string_compose (singular_msg, removed, dead_directory, space_adjusted, bprefix)); } dhbox.pack_start (*dimage, true, false, 5); @@ -2716,28 +3167,29 @@ require some unused files to continue to exist.")); void ARDOUR_UI::cleanup () { - if (session == 0) { + if (_session == 0) { /* shouldn't happen: menu item is insensitive */ return; } - MessageDialog checker (_("Are you sure you want to cleanup?"), + MessageDialog checker (_("Are you sure you want to clean-up?"), true, Gtk::MESSAGE_QUESTION, - (Gtk::ButtonsType)(Gtk::BUTTONS_NONE)); + Gtk::BUTTONS_NONE); + + checker.set_title (_("Clean-up")); - checker.set_secondary_text(_("Cleanup is a destructive operation.\n\ -ALL undo/redo information will be lost if you cleanup.\n\ -After cleanup, unused audio files will be moved to a \ -\"dead sounds\" location.")); + checker.set_secondary_text(_("Clean-up is a destructive operation.\n\ +ALL undo/redo information will be lost if you clean-up.\n\ +Clean-up will move all unused files to a \"dead\" location.")); checker.add_button (Stock::CANCEL, RESPONSE_CANCEL); - checker.add_button (_("Clean Up"), RESPONSE_ACCEPT); + checker.add_button (_("Clean-up"), RESPONSE_ACCEPT); checker.set_default_response (RESPONSE_CANCEL); checker.set_name (_("CleanupDialog")); - checker.set_wmclass (X_("ardour_cleanup"), "Ardour"); + checker.set_wmclass (X_("ardour_cleanup"), PROGRAM_NAME); checker.set_position (Gtk::WIN_POS_MOUSE); switch (checker.run()) { @@ -2747,7 +3199,7 @@ After cleanup, unused audio files will be moved to a \ return; } - Session::cleanup_report rep; + ARDOUR::CleanupReport rep; editor->prepare_for_cleanup (); @@ -2758,7 +3210,7 @@ After cleanup, unused audio files will be moved to a \ act->set_sensitive (false); } - if (session->cleanup_sources (rep)) { + if (_session->cleanup_sources (rep)) { editor->finish_cleanup (); return; } @@ -2767,20 +3219,22 @@ After cleanup, unused audio files will be moved to a \ checker.hide(); display_cleanup_results (rep, - _("cleaned files"), + _("Cleaned Files"), _("\ The following %1 files were not in use and \n\ -have been moved to:\n\ -%2. \n\n\ -Flushing the wastebasket will \n\ -release an additional\n\ +have been moved to:\n\n\ +%2\n\n\ +After a restart of Ardour,\n\n\ +Session -> Clean-up -> Flush Wastebasket\n\n\ +will release an additional\n\ %3 %4bytes of disk space.\n"), _("\ -The following file was not in use and \n \ +The following file was not in use and \n\ has been moved to:\n \ -%2. \n\n\ -Flushing the wastebasket will \n\ -release an additional\n\ +%2\n\n\ +After a restart of Ardour,\n\n\ +Session -> Clean-up -> Flush Wastebasket\n\n\ +will release an additional\n\ %3 %4bytes of disk space.\n" )); @@ -2789,14 +3243,14 @@ release an additional\n\ void ARDOUR_UI::flush_trash () { - if (session == 0) { + if (_session == 0) { /* shouldn't happen: menu item is insensitive */ return; } - Session::cleanup_report rep; + ARDOUR::CleanupReport rep; - if (session->cleanup_trash_sources (rep)) { + if (_session->cleanup_trash_sources (rep)) { return; } @@ -2815,12 +3269,12 @@ ARDOUR_UI::add_route (Gtk::Window* float_window) { int count; - if (!session) { + if (!_session) { return; } if (add_route_dialog == 0) { - add_route_dialog = new AddRouteDialog (*session); + add_route_dialog = new AddRouteDialog (_session); if (float_window) { add_route_dialog->set_transient_for (*float_window); } @@ -2850,7 +3304,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window) string template_path = add_route_dialog->track_template(); if (!template_path.empty()) { - session->new_route_from_template (count, template_path); + _session->new_route_from_template (count, template_path); return; } @@ -2863,7 +3317,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window) AutoConnectOption oac = Config->get_output_auto_connect(); if (oac & AutoConnectMaster) { - output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan); + output_chan = (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan); } else { output_chan = input_chan; } @@ -2872,7 +3326,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window) if (add_route_dialog->type() == ARDOUR::DataType::MIDI) { if (track) { - session_add_midi_track (route_group, count); + session_add_midi_track (route_group, count, name_template); } else { MessageDialog msg (*editor, _("Sorry, MIDI Busses are not supported at this time.")); @@ -2881,9 +3335,9 @@ ARDOUR_UI::add_route (Gtk::Window* float_window) } } else { if (track) { - session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count); + session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count, name_template); } else { - session_add_audio_bus (input_chan, output_chan, route_group, count); + session_add_audio_bus (input_chan, output_chan, route_group, count, name_template); } } } @@ -2893,8 +3347,8 @@ ARDOUR_UI::mixer_settings () const { XMLNode* node = 0; - if (session) { - node = session->instant_xml(X_("Mixer")); + if (_session) { + node = _session->instant_xml(X_("Mixer")); } else { node = Config->instant_xml(X_("Mixer")); } @@ -2911,8 +3365,8 @@ ARDOUR_UI::editor_settings () const { XMLNode* node = 0; - if (session) { - node = session->instant_xml(X_("Editor")); + if (_session) { + node = _session->instant_xml(X_("Editor")); } else { node = Config->instant_xml(X_("Editor")); } @@ -2940,11 +3394,12 @@ ARDOUR_UI::keyboard_settings () const if (!node) { node = new XMLNode (X_("Keyboard")); } + return node; } void -ARDOUR_UI::create_xrun_marker(nframes_t where) +ARDOUR_UI::create_xrun_marker (framepos_t where) { editor->mouse_add_new_marker (where, false, true); } @@ -2958,87 +3413,37 @@ ARDOUR_UI::halt_on_xrun_message () } void -ARDOUR_UI::xrun_handler(nframes_t where) +ARDOUR_UI::xrun_handler (framepos_t where) { - if (!session) { + if (!_session) { return; } - ENSURE_GUI_THREAD (bind(mem_fun(*this, &ARDOUR_UI::xrun_handler), where)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::xrun_handler, where) - if (session && Config->get_create_xrun_marker() && session->actively_recording()) { + if (_session && Config->get_create_xrun_marker() && _session->actively_recording()) { create_xrun_marker(where); } - if (session && Config->get_stop_recording_on_xrun() && session->actively_recording()) { + if (_session && Config->get_stop_recording_on_xrun() && _session->actively_recording()) { halt_on_xrun_message (); } } -void -ARDOUR_UI::push_buffer_stats (uint32_t capture, uint32_t playback) -{ - time_t now; - time (&now); - - while (disk_buffer_stats.size() > 60) { - disk_buffer_stats.pop_front (); - } - - disk_buffer_stats.push_back (DiskBufferStat (now, capture, playback)); -} - -void -ARDOUR_UI::write_buffer_stats () -{ - struct tm tm; - char buf[64]; - - char* tmplt = (char*)calloc(strlen("ardourXXXXXX"), sizeof(char)); - int fd = mkstemp (tmplt); - if (fd) { - cerr << X_("cannot find temporary name for ardour buffer stats") << endl; - return; - } - - FILE* fout = fdopen (fd, "w"); - if (!fout) { - cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), tmplt) << endl; - return; - } - - for (list::iterator i = disk_buffer_stats.begin(); i != disk_buffer_stats.end(); ++i) { - std::ostringstream ss; - localtime_r (&(*i).when, &tm); - strftime (buf, sizeof (buf), "%T", &tm); - fprintf(fout, "%s %u %u\n", buf, (*i).capture, (*i).playback); - } - - disk_buffer_stats.clear (); - - fclose (fout); - close (fd); - - cerr << "Ardour buffering statistics can be found in: " << tmplt << endl; - free (tmplt); -} - void ARDOUR_UI::disk_overrun_handler () { - ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler)); - - write_buffer_stats (); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler) if (!have_disk_speed_dialog_displayed) { have_disk_speed_dialog_displayed = true; - MessageDialog* msg = new MessageDialog (*editor, _("\ + MessageDialog* msg = new MessageDialog (*editor, string_compose (_("\ The disk system on your computer\n\ -was not able to keep up with Ardour.\n\ +was not able to keep up with %1.\n\ \n\ Specifically, it failed to write data to disk\n\ -quickly enough to keep up with recording.\n")); - msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg)); +quickly enough to keep up with recording.\n"), PROGRAM_NAME)); + msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg)); msg->show (); } } @@ -3046,19 +3451,17 @@ quickly enough to keep up with recording.\n")); void ARDOUR_UI::disk_underrun_handler () { - ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler)); - - write_buffer_stats (); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler) if (!have_disk_speed_dialog_displayed) { have_disk_speed_dialog_displayed = true; - MessageDialog* msg = new MessageDialog (*editor, - _("The disk system on your computer\n\ -was not able to keep up with Ardour.\n\ + MessageDialog* msg = new MessageDialog ( + *editor, string_compose (_("The disk system on your computer\n\ +was not able to keep up with %1.\n\ \n\ Specifically, it failed to read data from disk\n\ -quickly enough to keep up with playback.\n")); - msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg)); +quickly enough to keep up with playback.\n"), PROGRAM_NAME)); + msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg)); msg->show (); } } @@ -3073,7 +3476,7 @@ ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg) void ARDOUR_UI::session_dialog (std::string msg) { - ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::session_dialog), msg)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::session_dialog, msg) MessageDialog* d; @@ -3123,7 +3526,7 @@ what you would like to do.\n")); } int -ARDOUR_UI::sr_mismatch_dialog (nframes_t desired, nframes_t actual) +ARDOUR_UI::sr_mismatch_dialog (framecnt_t desired, framecnt_t actual) { HBox* hbox = new HBox(); Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG); @@ -3183,7 +3586,6 @@ ARDOUR_UI::reconnect_to_jack () void ARDOUR_UI::use_config () { - XMLNode* node = Config->extra_xml (X_("TransportControllables")); if (node) { set_transport_controllable_state (*node); @@ -3191,50 +3593,63 @@ ARDOUR_UI::use_config () } void -ARDOUR_UI::update_transport_clocks (nframes_t pos) +ARDOUR_UI::update_transport_clocks (framepos_t pos) { if (Config->get_primary_clock_delta_edit_cursor()) { - primary_clock.set (pos, false, editor->get_preferred_edit_position(), 1); + primary_clock->set (pos, false, editor->get_preferred_edit_position()); } else { - primary_clock.set (pos, 0, true); + primary_clock->set (pos); } if (Config->get_secondary_clock_delta_edit_cursor()) { - secondary_clock.set (pos, false, editor->get_preferred_edit_position(), 2); + secondary_clock->set (pos, false, editor->get_preferred_edit_position()); } else { - secondary_clock.set (pos); + secondary_clock->set (pos); } - if (big_clock_window) { - big_clock.set (pos); + if (big_clock_window->get()) { + big_clock->set (pos); + } +} + + +void +ARDOUR_UI::step_edit_status_change (bool yn) +{ + // XXX should really store pre-step edit status of things + // we make insensitive + + if (yn) { + rec_button.set_active_state (Mid); + rec_button.set_sensitive (false); + } else { + rec_button.unset_active_state ();; + rec_button.set_sensitive (true); } } void ARDOUR_UI::record_state_changed () { - ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed)); + ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed); - if (!session || !big_clock_window) { + if (!_session || !big_clock_window->get()) { /* why bother - the clock isn't visible */ return; } - Session::RecordState const r = session->record_status (); - bool const h = session->have_rec_enabled_diskstream (); - - if (r == Session::Recording && h) { - big_clock.set_widget_name ("BigClockRecording"); - } else { - big_clock.set_widget_name ("BigClockNonRecording"); + if (_session->record_status () == Session::Recording && _session->have_rec_enabled_track ()) { + big_clock->set_active (true); + } else { + big_clock->set_active (false); } } bool ARDOUR_UI::first_idle () { - if (session) { - session->allow_auto_play (true); + if (_session) { + _session->allow_auto_play (true); } if (editor) { @@ -3251,15 +3666,19 @@ ARDOUR_UI::store_clock_modes () XMLNode* node = new XMLNode(X_("ClockModes")); for (vector::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) { - node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode())); + XMLNode* child = new XMLNode (X_("Clock")); + + child->add_property (X_("name"), (*x)->name()); + child->add_property (X_("mode"), enum_2_string ((*x)->mode())); + child->add_property (X_("on"), ((*x)->off() ? X_("no") : X_("yes"))); + + node->add_child_nocopy (*child); } - session->add_extra_xml (*node); - session->set_dirty (); + _session->add_extra_xml (*node); + _session->set_dirty (); } - - ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp) : Controllable (name), ui (u), type(tp) { @@ -3267,26 +3686,9 @@ ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOU } void -ARDOUR_UI::TransportControllable::set_value (float val) +ARDOUR_UI::TransportControllable::set_value (double val) { - if (type == ShuttleControl) { - double fract; - - if (val == 0.5f) { - fract = 0.0; - } else { - if (val < 0.5f) { - fract = -((0.5f - val)/0.5f); - } else { - fract = ((val - 0.5f)/0.5f); - } - } - - ui.set_shuttle_fract (fract); - return; - } - - if (val < 0.5f) { + if (val < 0.5) { /* do nothing: these are radio-style actions */ return; } @@ -3330,10 +3732,10 @@ ARDOUR_UI::TransportControllable::set_value (float val) } } -float +double ARDOUR_UI::TransportControllable::get_value (void) const { - float val = 0.0f; + float val = 0.0; switch (type) { case Roll: @@ -3350,8 +3752,6 @@ ARDOUR_UI::TransportControllable::get_value (void) const break; case RecordEnable: break; - case ShuttleControl: - break; default: break; } @@ -3359,12 +3759,6 @@ ARDOUR_UI::TransportControllable::get_value (void) const return val; } -void -ARDOUR_UI::TransportControllable::set_id (const string& str) -{ - _id = str; -} - void ARDOUR_UI::setup_profile () { @@ -3379,3 +3773,128 @@ ARDOUR_UI::setup_profile () } } +void +ARDOUR_UI::toggle_translations () +{ + using namespace Glib; + + RefPtr act = ActionManager::get_action (X_("Main"), X_("EnableTranslation")); + if (act) { + RefPtr ract = RefPtr::cast_dynamic (act); + if (ract) { + + string i18n_killer = ARDOUR::translation_kill_path(); + + bool already_enabled = !ARDOUR::translations_are_disabled (); + + if (ract->get_active ()) { +/* we don't care about errors */ + int fd = ::open (i18n_killer.c_str(), O_RDONLY|O_CREAT, 0644); + close (fd); + } else { +/* we don't care about errors */ + unlink (i18n_killer.c_str()); + } + + if (already_enabled != ract->get_active()) { + MessageDialog win (already_enabled ? _("Translations disabled") : _("Translations enabled"), + false, + Gtk::MESSAGE_WARNING, + Gtk::BUTTONS_OK); + win.set_secondary_text (string_compose (_("You must restart %1 for this to take effect."), PROGRAM_NAME)); + win.set_position (Gtk::WIN_POS_CENTER); + win.present (); + win.run (); + } + } + } +} + +/** Add a window proxy to our list, so that its state will be saved. + * This call also causes the window to be created and opened if its + * state was saved as `visible'. + */ +void +ARDOUR_UI::add_window_proxy (WindowProxyBase* p) +{ + _window_proxies.push_back (p); + p->maybe_show (); +} + +/** Remove a window proxy from our list. Must be called if a WindowProxy + * is deleted, to prevent hanging pointers. + */ +void +ARDOUR_UI::remove_window_proxy (WindowProxyBase* p) +{ + _window_proxies.remove (p); +} + +int +ARDOUR_UI::missing_file (Session*s, std::string str, DataType type) +{ + MissingFileDialog dialog (s, str, type); + + dialog.show (); + dialog.present (); + + int result = dialog.run (); + dialog.hide (); + + switch (result) { + case RESPONSE_OK: + break; + default: + return 1; // quit entire session load + } + + result = dialog.get_action (); + + return result; +} + +int +ARDOUR_UI::ambiguous_file (std::string file, std::string /*path*/, std::vector hits) +{ + AmbiguousFileDialog dialog (file, hits); + + dialog.show (); + dialog.present (); + + dialog.run (); + return dialog.get_which (); +} + +/** Allocate our thread-local buffers */ +void +ARDOUR_UI::get_process_buffers () +{ + _process_thread->get_buffers (); +} + +/** Drop our thread-local buffers */ +void +ARDOUR_UI::drop_process_buffers () +{ + _process_thread->drop_buffers (); +} + +void +ARDOUR_UI::feedback_detected () +{ + _feedback_exists = true; +} + +void +ARDOUR_UI::successful_graph_sort () +{ + _feedback_exists = false; +} + +void +ARDOUR_UI::midi_panic () +{ + if (_session) { + _session->midi_panic(); + } +}