/*
- Copyright (C) 1999-2007 Paul Davis
+ Copyright (C) 1999-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
+#include <time.h>
#include <cerrno>
#include <fstream>
#include <gtkmm/messagedialog.h>
#include <gtkmm/accelmap.h>
-#include <pbd/error.h>
-#include <pbd/misc.h>
-#include <pbd/compose.h>
-#include <pbd/failed_constructor.h>
-#include <pbd/enumwriter.h>
-#include <pbd/memento_command.h>
-#include <pbd/file_utils.h>
-
-#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/utils.h>
-#include <gtkmm2ext/click_box.h>
-#include <gtkmm2ext/fastmeter.h>
-#include <gtkmm2ext/stop_signal.h>
-#include <gtkmm2ext/popup.h>
-#include <gtkmm2ext/window_title.h>
-
-#include <midi++/manager.h>
-
-#include <ardour/ardour.h>
-#include <ardour/profile.h>
-#include <ardour/session_directory.h>
-#include <ardour/session_route.h>
-#include <ardour/session_state_utils.h>
-#include <ardour/session_utils.h>
-#include <ardour/port.h>
-#include <ardour/audioengine.h>
-#include <ardour/playlist.h>
-#include <ardour/utils.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/recent_sessions.h>
-#include <ardour/port.h>
-#include <ardour/audio_track.h>
-#include <ardour/midi_track.h>
-#include <ardour/filesystem_paths.h>
+#include "pbd/error.h"
+#include "pbd/basename.h"
+#include "pbd/compose.h"
+#include "pbd/failed_constructor.h"
+#include "pbd/enumwriter.h"
+#include "pbd/memento_command.h"
+#include "pbd/file_utils.h"
+
+#include "gtkmm2ext/gtk_ui.h"
+#include "gtkmm2ext/utils.h"
+#include "gtkmm2ext/click_box.h"
+#include "gtkmm2ext/fastmeter.h"
+#include "gtkmm2ext/stop_signal.h"
+#include "gtkmm2ext/popup.h"
+#include "gtkmm2ext/window_title.h"
+
+#include "midi++/manager.h"
+
+#include "ardour/ardour.h"
+#include "ardour/profile.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_route.h"
+#include "ardour/session_state_utils.h"
+#include "ardour/session_utils.h"
+#include "ardour/port.h"
+#include "ardour/audioengine.h"
+#include "ardour/playlist.h"
+#include "ardour/utils.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/recent_sessions.h"
+#include "ardour/port.h"
+#include "ardour/audio_track.h"
+#include "ardour/midi_track.h"
+#include "ardour/filesystem_paths.h"
+#include "ardour/filename_extensions.h"
+
+typedef uint64_t microseconds_t;
#include "actions.h"
#include "ardour_ui.h"
#include "prompter.h"
#include "opts.h"
#include "add_route_dialog.h"
-#include "new_session_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 "route_time_axis.h"
+#include "startup.h"
+#include "engine_dialog.h"
+#include "processor_box.h"
#include "i18n.h"
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
UIConfiguration *ARDOUR_UI::ui_config = 0;
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
- : Gtkmm2ext::UI (X_("Ardour"), argcp, argvp),
-
- primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, false, true),
- secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, false, true),
- preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true),
- postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true),
+ : Gtkmm2ext::UI (X_("gui"), argcp, argvp),
- /* adjuster table */
-
- adjuster_table (3, 3),
+ primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, true, false, true),
+ secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, true, false, true),
+ preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, false, true),
+ postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, false, true),
/* preroll stuff */
/* big clock */
- big_clock (X_("bigclock"), false, "BigClockNonRecording", false, false, true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", true, true, false, true),
/* transport */
- roll_controllable ("transport roll", *this, TransportControllable::Roll),
- stop_controllable ("transport stop", *this, TransportControllable::Stop),
- goto_start_controllable ("transport goto start", *this, TransportControllable::GotoStart),
- goto_end_controllable ("transport goto end", *this, TransportControllable::GotoEnd),
- auto_loop_controllable ("transport auto loop", *this, TransportControllable::AutoLoop),
- play_selection_controllable ("transport play selection", *this, TransportControllable::PlaySelection),
- rec_controllable ("transport rec-enable", *this, TransportControllable::RecordEnable),
- shuttle_controllable ("shuttle", *this, TransportControllable::ShuttleControl),
+ 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),
auto_loop_button (auto_loop_controllable),
play_selection_button (play_selection_controllable),
rec_button (rec_controllable),
-
+
shuttle_units_button (_("% ")),
punch_in_button (_("Punch In")),
using namespace Gtk::Menu_Helpers;
Gtkmm2ext::init();
-
+
#ifdef TOP_MENUBAR
- _auto_display_errors = false;
+ // _auto_display_errors = false;
+ /*
+ * This was commented out as it wasn't defined
+ * in A3 IIRC. If this is not needed it should
+ * be completely removed.
+ */
#endif
+
about = 0;
+ splash = 0;
+ _startup = 0;
if (theArdourUI == 0) {
theArdourUI = this;
ui_config = new UIConfiguration();
theme_manager = new ThemeManager();
-
+
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;
- connection_editor = 0;
_will_create_new_session_automatically = false;
- new_session_dialog = 0;
- loading_dialog = 0;
add_route_dialog = 0;
route_params = 0;
- option_editor = 0;
+ rc_option_editor = 0;
+ session_option_editor = 0;
location_ui = 0;
open_session_selector = 0;
have_configure_timeout = false;
have_disk_speed_dialog_displayed = false;
session_loaded = false;
last_speed_displayed = -1.0f;
- ab_direction = true;
-
- sys::path key_bindings_file;
-
- find_file_in_search_path (ardour_search_path() + system_config_search_path(),
- "ardour.bindings", key_bindings_file);
-
- keybindings_path = key_bindings_file.to_string();
-
- /* store all bindings changes in per-user file, no matter where they were loaded from */
- user_keybindings_path = user_config_directory().to_string ();
- user_keybindings_path += '/';
- user_keybindings_path += "ardour.bindings";
+ ignore_dual_punch = false;
+ _mixer_on_top = false;
- can_save_keybindings = false;
+ 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);
- last_configure_time.tv_sec = 0;
- last_configure_time.tv_usec = 0;
+ last_configure_time= 0;
shuttle_grabbed = false;
shuttle_fract = 0.0;
shuttle_style_menu = 0;
shuttle_unit_menu = 0;
- gettimeofday (&last_peak_grab, 0);
- gettimeofday (&last_shuttle_request, 0);
+ // We do not have jack linked in yet so;
+
+ last_shuttle_request = last_peak_grab = 0; // get_microseconds();
+
+ ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context());
+ ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context());
+
+ /* handle dialog requests */
+
+ ARDOUR::Session::Dialog.connect (forever_connections, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
- ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
- ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ /* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
- /* handle pending state with a dialog */
+ ARDOUR::Session::AskAboutPendingState.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::pending_state_dialog, this));
- ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
+ /* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
+
+ ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
/* lets get this party started */
- try {
- ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization);
+ try {
+ if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) {
+ throw failed_constructor ();
+ }
+
setup_gtk_ardour_enums ();
- Config->set_current_owner (ConfigVariableBase::Interface);
setup_profile ();
+ 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;
// pass it on up
- throw err;
- }
+ 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);
+ }
+
+ reset_dpi();
+
+ starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
+ stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
+
+ platform_setup ();
+}
+
+/** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
+bool
+ARDOUR_UI::run_startup (bool should_be_new)
+{
+ if (_startup == 0) {
+ _startup = new ArdourStartup ();
+ }
+
+ _startup->set_new_only (should_be_new);
+ _startup->present ();
+
+ main().run();
- starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
- stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+ _startup->hide ();
- platform_specific ();
+ switch (_startup->response()) {
+ case RESPONSE_OK:
+ return true;
+ default:
+ return false;
+ }
}
int
return 0;
}
- try {
+ loading_message (_("Starting audio engine"));
+
+ try {
engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
} 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, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context());
+ engine->Running.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_running, this), gui_context());
+ engine->Halted.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this), gui_context());
+ engine->SampleRateChanged.connect (forever_connections, ui_bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
post_engine ();
void
ARDOUR_UI::post_engine ()
{
- extern int setup_midi ();
-
/* Things to be done once we create the AudioEngine
*/
MIDI::Manager::instance()->set_api_data (engine->jack());
setup_midi ();
+
+ ARDOUR::init_post_engine ();
ActionManager::init ();
_tooltips.enable();
blink_timeout_tag = -1;
- /* the global configuration object is now valid */
-
- use_config ();
-
/* this being a GUI and all, we want peakfiles */
AudioFileSource::set_build_peakfiles (true);
/* set default clock modes */
- primary_clock.set_mode (AudioClock::SMPTE);
- secondary_clock.set_mode (AudioClock::BBT);
+ if (Profile->get_sae()) {
+ primary_clock.set_mode (AudioClock::BBT);
+ secondary_clock.set_mode (AudioClock::MinSec);
+ } else {
+ 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 */
update_wall_clock ();
- Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
+ Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
#endif
update_disk_space ();
update_cpu_load ();
update_sample_rate (engine->frame_rate());
+ Config->ParameterChanged.connect (forever_connections, ui_bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
+ boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
+ Config->map_parameters (pc);
+
/* now start and maybe save state */
if (do_engine_start () == 0) {
- if (session && _session_is_new) {
- /* we need to retain initial visual
- settings for a new session
+ if (_session && _session_is_new) {
+ /* we need to retain initial visual
+ settings for a new session
*/
- session->save_state ("");
+ _session->save_state ("");
}
}
}
{
save_ardour_state ();
- if (keyboard) {
- delete keyboard;
- }
-
- if (editor) {
- delete editor;
- }
-
- if (mixer) {
- delete mixer;
- }
-
- if (add_route_dialog) {
- delete add_route_dialog;
- }
-
+ delete keyboard;
+ delete editor;
+ delete mixer;
+ delete add_route_dialog;
+}
- if (new_session_dialog) {
- delete new_session_dialog;
+void
+ARDOUR_UI::pop_back_splash ()
+{
+ if (Splash::instance()) {
+ // Splash::instance()->pop_back();
+ Splash::instance()->hide ();
}
}
gint
ARDOUR_UI::configure_timeout ()
{
- struct timeval now;
- struct timeval diff;
-
- if (last_configure_time.tv_sec == 0 && last_configure_time.tv_usec == 0) {
+ if (last_configure_time == 0) {
/* no configure events yet */
return TRUE;
}
- gettimeofday (&now, 0);
- timersub (&now, &last_configure_time, &diff);
-
/* force a gap of 0.5 seconds since the last configure event
*/
- if (diff.tv_sec == 0 && diff.tv_usec < 500000) {
+ if (get_microseconds() - last_configure_time < 500000) {
return TRUE;
} else {
have_configure_timeout = false;
}
gboolean
-ARDOUR_UI::configure_handler (GdkEventConfigure* conf)
+ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
{
if (have_configure_timeout) {
- gettimeofday (&last_configure_time, 0);
+ 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;
}
-
+
return FALSE;
}
const XMLProperty* prop;
if ((prop = node.property ("roll")) != 0) {
- roll_controllable.set_id (prop->value());
+ roll_controllable->set_id (prop->value());
}
if ((prop = node.property ("stop")) != 0) {
- stop_controllable.set_id (prop->value());
+ stop_controllable->set_id (prop->value());
}
- if ((prop = node.property ("goto_start")) != 0) {
- goto_start_controllable.set_id (prop->value());
+ if ((prop = node.property ("goto-start")) != 0) {
+ goto_start_controllable->set_id (prop->value());
}
- if ((prop = node.property ("goto_end")) != 0) {
- goto_end_controllable.set_id (prop->value());
+ if ((prop = node.property ("goto-end")) != 0) {
+ goto_end_controllable->set_id (prop->value());
}
- if ((prop = node.property ("auto_loop")) != 0) {
- auto_loop_controllable.set_id (prop->value());
+ if ((prop = node.property ("auto-loop")) != 0) {
+ auto_loop_controllable->set_id (prop->value());
}
- if ((prop = node.property ("play_selection")) != 0) {
- play_selection_controllable.set_id (prop->value());
+ if ((prop = node.property ("play-selection")) != 0) {
+ play_selection_controllable->set_id (prop->value());
}
if ((prop = node.property ("rec")) != 0) {
- rec_controllable.set_id (prop->value());
+ rec_controllable->set_id (prop->value());
}
if ((prop = node.property ("shuttle")) != 0) {
- shuttle_controllable.set_id (prop->value());
+ shuttle_controllable->set_id (prop->value());
}
}
XMLNode* node = new XMLNode(X_("TransportControllables"));
char buf[64];
- roll_controllable.id().print (buf, sizeof (buf));
+ roll_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("roll"), buf);
- stop_controllable.id().print (buf, sizeof (buf));
+ stop_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("stop"), buf);
- goto_start_controllable.id().print (buf, sizeof (buf));
+ goto_start_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("goto_start"), buf);
- goto_end_controllable.id().print (buf, sizeof (buf));
+ goto_end_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("goto_end"), buf);
- auto_loop_controllable.id().print (buf, sizeof (buf));
+ auto_loop_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("auto_loop"), buf);
- play_selection_controllable.id().print (buf, sizeof (buf));
+ play_selection_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("play_selection"), buf);
- rec_controllable.id().print (buf, sizeof (buf));
+ rec_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("rec"), buf);
- shuttle_controllable.id().print (buf, sizeof (buf));
+ shuttle_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("shuttle"), buf);
return *node;
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<Stateful*>(editor)->get_state());
XMLNode mnode(mixer->get_state());
- if (session) {
- session->add_instant_xml (enode);
- session->add_instant_xml (mnode);
+ if (_session) {
+ _session->add_instant_xml (enode);
+ _session->add_instant_xml (mnode);
} else {
Config->add_instant_xml (enode);
Config->add_instant_xml (mnode);
}
- save_keybindings ();
+ Keyboard::save_keybindings ();
}
gint
ARDOUR_UI::autosave_session ()
{
- if (!Config->get_periodic_safety_backups())
+ if (g_main_depth() > 1) {
+ /* inside a recursive main loop,
+ give up because we may not be able to
+ take a lock.
+ */
return 1;
+ }
- if (session) {
- session->maybe_write_autosave();
+ if (!Config->get_periodic_safety_backups()) {
+ return 1;
}
+ if (_session) {
+ _session->maybe_write_autosave();
+ }
+
return 1;
}
void
ARDOUR_UI::update_autosave ()
{
- ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_autosave)
- if (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 {
if (_autosave_connection.connected()) {
_autosave_connection.disconnect();
- }
+ }
}
}
false,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_NONE);
-
+
if (we_set_params) {
win.set_secondary_text(_("There are several possible reasons:\n\
\n\
win.add_button (Stock::OK, RESPONSE_CLOSE);
} else {
win.add_button (Stock::QUIT, RESPONSE_CLOSE);
- }
+ }
win.set_default_response (RESPONSE_CLOSE);
-
+
win.show_all ();
win.set_position (Gtk::WIN_POS_CENTER);
-
- if (!ARDOUR_COMMAND_LINE::no_splash) {
- hide_splash ();
- }
+ pop_back_splash ();
/* we just don't care about the result, but we want to block */
void
ARDOUR_UI::startup ()
{
- string name, path;
- bool isnew;
-
- new_session_dialog = new NewSessionDialog();
-
- /* If no session name is given: we're not loading a session yet, nor creating a new one */
-
- if (ARDOUR_COMMAND_LINE::session_name.length()) {
-
- /* Load session or start the new session dialog */
-
- if (find_session (ARDOUR_COMMAND_LINE::session_name, path, name, isnew)) {
- error << string_compose(_("could not load command line session \"%1\""),
- ARDOUR_COMMAND_LINE::session_name) << endmsg;
- return;
- }
+ XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
- if (!ARDOUR_COMMAND_LINE::new_session) {
-
- /* Supposed to be loading an existing session, but the session doesn't exist */
-
- if (isnew) {
- error << string_compose (_("\n\nNo session named \"%1\" exists.\n"
- "To create it from the command line, start ardour as \"ardour --new %1"), path)
- << endmsg;
- return;
- }
- }
-
- new_session_dialog->set_session_name (name);
- new_session_dialog->set_session_folder (Glib::path_get_basename (path));
- _session_is_new = isnew;
+ if (audio_setup && _startup && _startup->engine_control()) {
+ _startup->engine_control()->set_state (*audio_setup);
}
- hide_splash ();
-
- bool have_backend = EngineControl::engine_running();
- bool need_nsd;
- bool load_needed = false;
-
- if (have_backend) {
-
- /* backend audio is working */
-
- if (ARDOUR_COMMAND_LINE::session_name.empty() || ARDOUR_COMMAND_LINE::new_session) {
- /* need NSD to get session name and other info */
- need_nsd = true;
- } else {
- need_nsd = false;
- }
-
- } else {
-
- XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
-
- if (audio_setup) {
- new_session_dialog->engine_control.set_state (*audio_setup);
- }
-
- /* no backend audio, must bring up NSD to check configuration */
-
- need_nsd = true;
+ if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session)) {
+ exit (1);
}
- if (need_nsd) {
-
- if (!get_session_parameters (ARDOUR_COMMAND_LINE::session_name, have_backend, ARDOUR_COMMAND_LINE::new_session)) {
- return;
- }
-
- } else {
-
- if (create_engine ()) {
- backend_audio_error (false);
- exit (1);
- }
+ use_config ();
- load_needed = true;
- }
-
- if (load_needed) {
- if (load_session (ARDOUR_COMMAND_LINE::session_name, name)) {
- return;
- }
- }
+ goto_editor_window ();
+ BootMessage (_("Ardour is ready for use"));
show ();
}
if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
return;
}
-
+
if (limits.rlim_cur != RLIM_INFINITY) {
if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
-
+
MessageDialog msg (_("WARNING: Your system has a limit for maximum amount of locked memory. "
"This might cause Ardour to run out of memory before your system "
"runs out of memory. \n\n"
"You can view the memory limit with 'ulimit -l', "
"and it is normally controlled by /etc/security/limits.conf"));
-
+
VBox* vbox = msg.get_vbox();
HBox hbox;
CheckButton cb (_("Do not show this window again"));
-
- cb.signal_toggled().connect (mem_fun (*this, &ARDOUR_UI::no_memory_warning));
-
+
+ cb.signal_toggled().connect (sigc::mem_fun (*this, &ARDOUR_UI::no_memory_warning));
+
hbox.pack_start (cb, true, false);
vbox->pack_start (hbox);
cb.show();
vbox->show();
hbox.show ();
-
+
+ pop_back_splash ();
+
editor->ensure_float (msg);
msg.run ();
}
void
ARDOUR_UI::finish()
{
- if (session && session->dirty()) {
- switch (ask_about_saving_session(_("quit"))) {
- case -1:
- return;
- break;
- case 1:
- /* use the default name */
- if (save_state_canfail ("")) {
- /* failed - don't quit */
- MessageDialog msg (*editor,
- _("\
+ if (_session) {
+
+ if (_session->transport_rolling()) {
+ _session->request_stop ();
+ usleep (250000);
+ }
+
+ if (_session->dirty()) {
+ switch (ask_about_saving_session(_("quit"))) {
+ case -1:
+ return;
+ break;
+ case 1:
+ /* use the default name */
+ if (save_state_canfail ("")) {
+ /* failed - don't quit */
+ MessageDialog msg (*editor,
+ _("\
Ardour was unable to save your session.\n\n\
If you still wish to quit, please use the\n\n\
\"Just quit\" option."));
- msg.run ();
- return;
+ pop_back_splash();
+ msg.run ();
+ return;
+ }
+ break;
+ case 0:
+ break;
}
- break;
- case 0:
- break;
}
- }
- if (session) {
- session->set_deletion_in_progress ();
+ second_connection.disconnect ();
+ point_one_second_connection.disconnect ();
+ point_oh_five_second_connection.disconnect ();
+ point_zero_one_second_connection.disconnect();
+
+ // _session->set_deletion_in_progress ();
+ _session->remove_pending_capture_state ();
+ delete _session;
+ _session = 0;
}
+
+ ArdourDialog::close_all_dialogs ();
engine->stop (true);
- Config->save_state();
- ARDOUR_UI::config()->save_state();
+ save_ardour_state ();
quit ();
}
string prompt;
string type;
- if (session->snap_name() == session->name()) {
+ if (_session->snap_name() == _session->name()) {
type = _("session");
} else {
type = _("snapshot");
}
- prompt = string_compose(_("The %1\"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
- type, session->snap_name());
-
+ 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"));
prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
- dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP)
-;
+ dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP);
dhbox.set_homogeneous (false);
dhbox.pack_start (*dimage, false, false, 5);
dhbox.pack_start (prompt_label, true, false, 5);
prompt_label.show();
dimage->show();
window.show();
-
- save_the_session = 0;
-
window.set_keep_above (true);
window.present ();
return -1;
}
-
+
gint
ARDOUR_UI::every_second ()
{
}
void
-ARDOUR_UI::update_sample_rate (nframes_t ignored)
+ARDOUR_UI::update_sample_rate (nframes_t)
{
char buf[32];
- ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::update_sample_rate), ignored));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_sample_rate, ignored)
if (!engine->connected()) {
} else {
nframes_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), _("%.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), _("%u kHz / %4.1f ms"),
rate/1000,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
}
ARDOUR_UI::update_buffer_load ()
{
char buf[64];
+ uint32_t c, p;
+
+ if (_session) {
+ c = _session->capture_load ();
+ p = _session->playback_load ();
- if (session) {
- snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
- session->playback_load(), session->capture_load());
+ push_buffer_stats (c, p);
+
+ snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
+ _session->playback_load(), _session->capture_load());
buffer_load_label.set_text (buf);
} else {
buffer_load_label.set_text ("");
void
ARDOUR_UI::update_disk_space()
{
- if (session == 0) {
+ if (_session == 0) {
return;
}
- nframes_t frames = session->available_capture_duration();
+ nframes_t frames = _session->available_capture_duration();
char buf[64];
+ nframes_t fr = _session->frame_rate();
if (frames == max_frames) {
strcpy (buf, _("Disk: 24hrs+"));
} else {
- int hrs;
- int mins;
- int secs;
- nframes_t fr = session->frame_rate();
-
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;
}
-
+
+ int hrs;
+ int mins;
+ 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);
}
disk_space_label.set_text (buf);
-}
+
+ // An attempt to make the disk space label flash red when space has run out.
+
+ if (frames < fr * 60 * 5) {
+ /* disk_space_box.style ("disk_space_label_empty"); */
+ } else {
+ /* disk_space_box.style ("disk_space_label"); */
+ }
+
+}
gint
ARDOUR_UI::update_wall_clock ()
}
gint
-ARDOUR_UI::session_menu (GdkEventButton *ev)
+ARDOUR_UI::session_menu (GdkEventButton */*ev*/)
{
session_popup_menu->popup (0, 0);
return TRUE;
{
std::vector<sys::path> session_directories;
RecentSessionsSorter cmp;
-
+
recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
recent_session_model->clear ();
//
// sort them alphabetically
sort (rs.begin(), rs.end(), cmp);
-
+
for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
session_directories.push_back ((*i).second);
}
-
+
for (vector<sys::path>::const_iterator i = session_directories.begin();
i != session_directories.end(); ++i)
{
std::vector<sys::path> state_file_paths;
-
+
// now get available states for this session
get_state_files_in_directory (*i, state_file_paths);
- if (state_file_paths.empty()) {
- // no state file?
+ vector<string*>* states;
+ vector<const gchar*> item;
+ string fullpath = (*i).to_string();
+
+ /* remove any trailing / */
+
+ if (fullpath[fullpath.length()-1] == '/') {
+ fullpath = fullpath.substr (0, fullpath.length()-1);
+ }
+
+ /* check whether session still exists */
+ if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
+ /* session doesn't exist */
+ cerr << "skipping non-existent session " << fullpath << endl;
+ continue;
+ }
+
+ /* now get available states for this session */
+
+ if ((states = Session::possible_states (fullpath)) == 0) {
+ /* no state file? */
continue;
}
-
+
std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
Gtk::TreeModel::Row row = *(recent_session_model->append());
- const string fullpath = (*i).to_string();
-
row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
-
+
if (state_file_names.size() > 1) {
// add the children
void
ARDOUR_UI::build_session_selector ()
{
- session_selector_window = new ArdourDialog ("session selector");
-
+ session_selector_window = new ArdourDialog (_("Recent Sessions"));
+
Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
-
+
session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
session_selector_window->set_default_response (RESPONSE_ACCEPT);
recent_session_display.set_model (recent_session_model);
recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
recent_session_display.set_headers_visible (false);
- recent_session_display.get_selection()->set_mode (SELECTION_SINGLE);
-
- recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
+ recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
+ 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);
}
void
-ARDOUR_UI::recent_session_row_activated (const TreePath& path, TreeViewColumn* col)
+ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColumn* /*col*/)
{
session_selector_window->response (RESPONSE_ACCEPT);
}
void
ARDOUR_UI::open_recent_session ()
{
- /* popup selector window */
+ bool can_return = (_session != 0);
if (session_selector_window == 0) {
build_session_selector ();
redisplay_recent_sessions ();
- ResponseType r = (ResponseType) session_selector_window->run ();
+ while (true) {
- session_selector_window->hide();
+ session_selector_window->set_position (WIN_POS_MOUSE);
- switch (r) {
- case RESPONSE_ACCEPT:
- break;
- default:
- return;
- }
+ ResponseType r = (ResponseType) session_selector_window->run ();
- Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
+ switch (r) {
+ case RESPONSE_ACCEPT:
+ break;
+ default:
+ if (can_return) {
+ session_selector_window->hide();
+ return;
+ } else {
+ exit (1);
+ }
+ }
- if (i == recent_session_model->children().end()) {
- return;
- }
-
- Glib::ustring path = (*i)[recent_session_columns.fullpath];
- Glib::ustring state = (*i)[recent_session_columns.visible_name];
+ if (recent_session_display.get_selection()->count_selected_rows() == 0) {
+ continue;
+ }
- _session_is_new = false;
+ session_selector_window->hide();
- load_session (path, state);
-}
+ Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
-bool
-ARDOUR_UI::filter_ardour_session_dirs (const FileFilter::Info& info)
-{
- struct stat statbuf;
+ if (i == recent_session_model->children().end()) {
+ return;
+ }
- if (stat (info.filename.c_str(), &statbuf) != 0) {
- return false;
- }
+ Glib::ustring path = (*i)[recent_session_columns.fullpath];
+ Glib::ustring state = (*i)[recent_session_columns.visible_name];
- if (!S_ISDIR(statbuf.st_mode)) {
- return false;
- }
+ _session_is_new = false;
- // XXX Portability
-
- string session_file = info.filename;
- session_file += '/';
- session_file += Glib::path_get_basename (info.filename);
- session_file += ".ardour";
-
- if (stat (session_file.c_str(), &statbuf) != 0) {
- return false;
- }
+ if (load_session (path, state) == 0) {
+ break;
+ }
- return S_ISREG (statbuf.st_mode);
+ can_return = false;
+ }
}
bool
if (!engine->connected()) {
MessageDialog msg (_("Ardour is not connected to JACK\n"
"You cannot open or close sessions in this condition"));
+ pop_back_splash ();
msg.run ();
return false;
}
{
if (!check_audioengine()) {
return;
-
+
}
/* popup selector window */
/* 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);
void
-ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)
+ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many)
{
list<boost::shared_ptr<MidiTrack> > tracks;
- if (session == 0) {
+ if (_session == 0) {
warning << _("You cannot add a track without a session already loaded.") << endmsg;
return;
}
- try {
+ try {
if (disk) {
- tracks = session->new_midi_track (ARDOUR::Normal, how_many);
+ tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many);
if (tracks.size() != how_many) {
if (how_many == 1) {
}
}
} /*else {
- if ((route = session->new_midi_route ()) == 0) {
+ if ((route = _session->new_midi_route ()) == 0) {
error << _("could not create new midi bus") << endmsg;
}
}*/
}
catch (...) {
- MessageDialog msg (*editor,
+ MessageDialog msg (*editor,
_("There are insufficient JACK ports available\n\
to create a new track or bus.\n\
You should save Ardour, exit and\n\
void
-ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, uint32_t how_many)
+ARDOUR_UI::session_add_audio_route (bool track, bool aux, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
{
list<boost::shared_ptr<AudioTrack> > tracks;
- Session::RouteList routes;
+ RouteList routes;
- if (session == 0) {
+ if (_session == 0) {
warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
return;
}
- try {
+ try {
if (track) {
- tracks = session->new_audio_track (input_channels, output_channels, mode, how_many);
+ tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
if (tracks.size() != how_many) {
if (how_many == 1) {
error << _("could not create a new audio track") << endmsg;
} else {
- error << string_compose (_("could only create %1 of %2 new audio %3"),
+ error << string_compose (_("could only create %1 of %2 new audio %3"),
tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
}
}
} else {
- routes = session->new_audio_route (input_channels, output_channels, how_many);
+ routes = _session->new_audio_route (aux, input_channels, output_channels, route_group, how_many);
if (routes.size() != how_many) {
if (how_many == 1) {
}
}
}
-
+
#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);
}
}
catch (...) {
- cerr << "About to complain about JACK\n";
- MessageDialog msg (*editor,
+ MessageDialog msg (*editor,
_("There are insufficient JACK ports available\n\
to create a new track or bus.\n\
You should save Ardour, exit and\n\
restart JACK with more ports."));
+ pop_back_splash ();
msg.run ();
}
}
{
nframes_t _preroll = 0;
- if (session) {
+ if (_session) {
// XXX CONFIG_CHANGE FIX - requires AnyTime handling
- // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
+ // _preroll = _session->convert_to_frames_at (new_position, Config->get_preroll());
if (new_position > _preroll) {
new_position -= _preroll;
new_position = 0;
}
- session->request_locate (new_position);
+ _session->request_locate (new_position);
}
}
void
ARDOUR_UI::transport_goto_start ()
{
- if (session) {
- session->goto_start();
+ if (_session) {
+ _session->goto_start();
-
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (session->current_start_frame());
+ editor->center_screen (_session->current_start_frame ());
}
}
}
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.
*/
-
+
if (editor) {
editor->reset_x_origin (0);
}
}
}
+void
+ARDOUR_UI::transport_goto_wallclock ()
+{
+ if (_session && editor) {
+
+ time_t now;
+ struct tm tmnow;
+ nframes64_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();
+
+ _session->request_locate (frames);
+
+ /* force displayed area in editor to start no matter
+ what "follow playhead" setting is.
+ */
+
+ if (editor) {
+ editor->center_screen (frames);
+ }
+ }
+}
+
void
ARDOUR_UI::transport_goto_end ()
{
- if (session) {
- nframes_t frame = session->current_end_frame();
- session->request_locate (frame);
+ if (_session) {
+ nframes_t const frame = _session->current_end_frame();
+ _session->request_locate (frame);
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (frame);
+ editor->center_screen (frame);
}
}
}
void
ARDOUR_UI::transport_stop ()
{
- if (!session) {
+ if (!_session) {
return;
}
- if (session->is_auditioning()) {
- session->cancel_audition ();
+ if (_session->is_auditioning()) {
+ _session->cancel_audition ();
return;
}
-
- if (session->get_play_loop ()) {
- session->request_play_loop (false);
- }
-
- session->request_stop ();
+
+ _session->request_stop ();
}
void
ARDOUR_UI::transport_stop_and_forget_capture ()
{
- if (session) {
- session->request_stop (true);
+ if (_session) {
+ _session->request_stop (true);
}
}
}
void
-ARDOUR_UI::transport_record ()
+ARDOUR_UI::transport_record (bool roll)
{
- if (session) {
- switch (session->record_status()) {
+
+ if (_session) {
+ switch (_session->record_status()) {
case Session::Disabled:
- if (session->ntracks() == 0) {
+ if (_session->ntracks() == 0) {
MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
msg.run ();
return;
}
- session->maybe_enable_record ();
+ _session->maybe_enable_record ();
+ if (roll) {
+ transport_roll ();
+ }
break;
case Session::Recording:
+ if (roll) {
+ _session->request_stop();
+ } else {
+ _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;
}
-void
+void
ARDOUR_UI::transport_roll ()
{
- bool rolling;
+ if (!_session) {
+ return;
+ }
- if (!session) {
+ if (_session->is_auditioning()) {
return;
}
+
+ if (_session->config.get_external_sync()) {
+ switch (_session->config.get_sync_source()) {
+ case JACK:
+ break;
+ default:
+ /* transport controlled by the master */
+ return;
+ }
+ }
- rolling = session->transport_rolling ();
+ bool rolling = _session->transport_rolling();
- 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 (_session->get_play_loop()) {
+ _session->request_play_loop (false, true);
+ } else if (_session->get_play_range () && !join_play_range_button.get_active()) {
+ /* stop playing a range if we currently are */
+ _session->request_play_range (0, true);
}
- session->request_transport_speed (1.0f);
+ if (join_play_range_button.get_active()) {
+ _session->request_play_range (&editor->get_selection().time, true);
+ }
+
+ if (!rolling) {
+ _session->request_transport_speed (1.0f);
+ }
+
+ map_transport_state ();
}
void
-ARDOUR_UI::transport_loop()
+ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode)
{
- if (session) {
- if (session->get_play_loop()) {
- if (session->transport_rolling()) {
- Location * looploc = session->locations()->auto_loop_location();
+
+ if (!_session) {
+ return;
+ }
+
+ if (_session->is_auditioning()) {
+ _session->cancel_audition ();
+ return;
+ }
+
+ if (_session->config.get_external_sync()) {
+ switch (_session->config.get_sync_source()) {
+ case JACK:
+ break;
+ default:
+ /* transport controlled by the master */
+ return;
+ }
+ }
+
+ bool rolling = _session->transport_rolling();
+ bool affect_transport = true;
+
+ if (rolling && roll_out_of_bounded_mode) {
+ /* drop out of loop/range playback but leave transport rolling */
+ if (_session->get_play_loop()) {
+ if (Config->get_seamless_loop()) {
+ /* the disk buffers contain copies of the loop - we can't
+ just keep playing, so stop the transport. the user
+ can restart as they wish.
+ */
+ affect_transport = true;
+ } else {
+ /* disk buffers are normal, so we can keep playing */
+ affect_transport = false;
+ }
+ _session->request_play_loop (false, true);
+ } else if (_session->get_play_range ()) {
+ affect_transport = false;
+ _session->request_play_range (0, true);
+ }
+ }
+
+ if (affect_transport) {
+ if (rolling) {
+ _session->request_stop (with_abort, true);
+ } else {
+ if (join_play_range_button.get_active()) {
+ _session->request_play_range (&editor->get_selection().time, true);
+ }
+
+ _session->request_transport_speed (1.0f);
+ }
+ }
+
+ map_transport_state ();
+}
+
+void
+ARDOUR_UI::toggle_session_auto_loop ()
+{
+ if (_session) {
+ if (_session->get_play_loop()) {
+ if (_session->transport_rolling()) {
+ Location * looploc = _session->locations()->auto_loop_location();
if (looploc) {
- session->request_locate (looploc->start(), true);
+ _session->request_locate (looploc->start(), true);
}
+ } else {
+ _session->request_play_loop (false);
+ }
+ } else {
+ Location * looploc = _session->locations()->auto_loop_location();
+ if (looploc) {
+ _session->request_play_loop (true);
}
- }
- else {
- session->request_play_loop (true);
}
}
}
void
ARDOUR_UI::transport_play_selection ()
{
- if (!session) {
+ if (!_session) {
return;
}
- if (!session->get_play_range()) {
- session->request_stop ();
- }
-
editor->play_selection ();
}
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);
}
}
}
ARDOUR_UI::transport_forward (int option)
{
float current_transport_speed;
-
- if (session) {
- current_transport_speed = session->transport_speed();
-
+
+ if (_session) {
+ current_transport_speed = _session->transport_speed();
+
if (current_transport_speed <= 0.0f) {
switch (option) {
case 0:
- session->request_transport_speed (1.0f);
+ _session->request_transport_speed (1.0f);
break;
case 1:
- session->request_transport_speed (4.0f);
+ _session->request_transport_speed (4.0f);
break;
case -1:
- session->request_transport_speed (0.5f);
+ _session->request_transport_speed (0.5f);
break;
}
} else {
/* speed up */
- session->request_transport_speed (current_transport_speed * 1.5f);
+ _session->request_transport_speed (current_transport_speed * 1.5f);
}
+
}
}
void
ARDOUR_UI::toggle_record_enable (uint32_t dstream)
{
- if (session == 0) {
+ if (_session == 0) {
return;
}
boost::shared_ptr<Route> r;
-
- if ((r = session->route_by_remote_id (dstream)) != 0) {
+
+ if ((r = _session->route_by_remote_id (dstream)) != 0) {
Track* t;
t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
}
}
- if (session == 0) {
+ if (_session == 0) {
return;
}
}
-void
-ARDOUR_UI::queue_transport_change ()
-{
- Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
-}
-
void
ARDOUR_UI::map_transport_state ()
{
- float sp = session->transport_speed();
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::map_transport_state)
+
+ if (!_session) {
+ auto_loop_button.set_visual_state (0);
+ play_selection_button.set_visual_state (0);
+ roll_button.set_visual_state (0);
+ stop_button.set_visual_state (1);
+ return;
+ }
+
+ float sp = _session->transport_speed();
if (sp == 1.0f) {
- transport_rolling ();
- } else if (sp < 0.0f) {
- transport_rewinding ();
- } else if (sp > 0.0f) {
- transport_forwarding ();
+ shuttle_fract = SHUTTLE_FRACT_SPEED1; /* speed = 1.0, believe it or not */
+ shuttle_box.queue_draw ();
+ } else if (sp == 0.0f) {
+ shuttle_fract = 0;
+ shuttle_box.queue_draw ();
+ update_disk_space ();
+ }
+
+ if (sp != 0.0) {
+
+ /* we're rolling */
+
+ if (_session->get_play_range()) {
+
+ play_selection_button.set_visual_state (1);
+ roll_button.set_visual_state (0);
+ auto_loop_button.set_visual_state (0);
+
+ } else if (_session->get_play_loop ()) {
+
+ auto_loop_button.set_visual_state (1);
+ play_selection_button.set_visual_state (0);
+ roll_button.set_visual_state (0);
+
+ } else {
+
+ roll_button.set_visual_state (1);
+ play_selection_button.set_visual_state (0);
+ auto_loop_button.set_visual_state (0);
+ }
+
+ if (join_play_range_button.get_active()) {
+ /* light up both roll and play-selection if they are joined */
+ roll_button.set_visual_state (1);
+ play_selection_button.set_visual_state (1);
+ }
+
+ stop_button.set_visual_state (0);
+
} else {
- transport_stopped ();
+
+ stop_button.set_visual_state (1);
+ roll_button.set_visual_state (0);
+ play_selection_button.set_visual_state (0);
+ auto_loop_button.set_visual_state (0);
}
-}
-void
-ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
-{
- snprintf (buf, sizeof(buf), "%s", ((GlobalClickBox *) arg)->strings[
- (int) adj.get_value()].c_str());
}
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);
}
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);
if (action_name) {
action = ActionManager::get_action (X_("JACK"), action_name);
-
+
if (action) {
Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
ract->set_active ();
void
ARDOUR_UI::engine_halted ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_halted)
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
update_sample_rate (0);
- MessageDialog msg (*editor,
+ MessageDialog msg (*editor,
_("\
JACK has either been shutdown or it\n\
disconnected Ardour because Ardour\n\
-was not fast enough. You can save the\n\
-session and/or try to reconnect to JACK ."));
+was not fast enough. Try to restart\n\
+JACK, reconnect and save the session."));
+ pop_back_splash ();
msg.run ();
}
int32_t
ARDOUR_UI::do_engine_start ()
{
- try {
+ try {
engine->start();
}
unload_session ();
return -2;
}
-
+
return 0;
}
ARDOUR_UI::update_clocks ()
{
if (!editor || !editor->dragging_playhead()) {
- Clock (session->audible_frame(), false, editor->edit_cursor_position(false)); /* 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
{
clock_signal_connection.disconnect ();
}
-
+
void
ARDOUR_UI::toggle_clocking ()
{
*/
if (blink_timeout_tag < 0) {
- blink_on = false;
+ blink_on = false;
blink_timeout_tag = g_timeout_add (240, _blink, this);
}
}
}
}
-void
-ARDOUR_UI::name_io_setup (AudioEngine& engine,
- string& buf,
- IO& io,
- bool in)
-{
- vector<string> connections;
-
- if (in) {
- if (io.n_inputs().n_total() == 0) {
- buf = _("none");
- return;
- }
-
- /* XXX we're not handling multiple ports yet. */
-
- if (io.input(0)->get_connections(connections) == 0) {
- buf = _("off");
- } else {
- buf = connections.front();
- }
-
- } else {
-
- if (io.n_outputs().n_total() == 0) {
- buf = _("none");
- return;
- }
-
- /* XXX we're not handling multiple ports yet. */
-
- if (io.output(0)->get_connections(connections) == 0) {
- buf = _("off");
- } else {
- buf = connections.front();
- }
- }
-}
/** Ask the user for the name of a new shapshot and then take it.
*/
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+ prompter.set_title (_("Take Snapshot"));
prompter.set_prompt (_("Name of New Snapshot"));
prompter.set_initial_text (timebuf);
-
+
switch (prompter.run()) {
case RESPONSE_ACCEPT:
+ {
prompter.get_result (snapname);
- if (snapname.length()){
+
+ bool do_save = (snapname.length() != 0);
+
+ vector<sys::path> p;
+ get_state_files_in_directory (_session->session_directory().root_path(), p);
+ vector<string> n = get_file_names_no_extension (p);
+ if (find (n.begin(), n.end(), snapname) != n.end()) {
+
+ 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);
+ confirm.add_button (_("Overwrite"), Gtk::RESPONSE_ACCEPT);
+ confirm.show_all ();
+ switch (confirm.run()) {
+ case RESPONSE_CANCEL:
+ do_save = false;
+ }
+ }
+
+ if (do_save) {
save_state (snapname);
}
break;
+ }
default:
break;
{
(void) save_state_canfail (name);
}
-
+
int
ARDOUR_UI::save_state_canfail (string name)
{
- if (session) {
+ if (_session) {
int ret;
if (name.length() == 0) {
- name = session->snap_name();
+ name = _session->snap_name();
}
- if ((ret = session->save_state (name)) != 0) {
+ if ((ret = _session->save_state (name)) != 0) {
return ret;
}
}
return 0;
}
-void
-ARDOUR_UI::restore_state (string name)
-{
- if (session) {
- if (name.length() == 0) {
- name = session->name();
- }
- session->restore_state (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::secondary_clock_value_changed ()
+ARDOUR_UI::big_clock_value_changed ()
{
- if (session) {
- session->request_locate (secondary_clock.current_time ());
+ if (_session) {
+ _session->request_locate (big_clock.current_time ());
}
}
void
-ARDOUR_UI::rec_enable_button_blink (bool onoff, AudioDiskstream *dstream, Widget *w)
+ARDOUR_UI::secondary_clock_value_changed ()
{
- if (session && dstream && dstream->record_enabled()) {
-
- Session::RecordState rs;
-
- rs = session->record_status ();
-
- switch (rs) {
- case Session::Disabled:
- case Session::Enabled:
- if (w->get_state() != STATE_SELECTED) {
- w->set_state (STATE_SELECTED);
- }
- break;
-
- case Session::Recording:
- if (w->get_state() != STATE_ACTIVE) {
- w->set_state (STATE_ACTIVE);
- }
- break;
- }
-
- } else {
- if (w->get_state() != STATE_NORMAL) {
- w->set_state (STATE_NORMAL);
- }
+ if (_session) {
+ _session->request_locate (secondary_clock.current_time ());
}
}
void
-ARDOUR_UI::transport_rec_enable_blink (bool onoff)
+ARDOUR_UI::transport_rec_enable_blink (bool onoff)
{
- if (session == 0) {
+ if (_session == 0) {
return;
}
-
- switch (session->record_status()) {
- case Session::Enabled:
+
+ Session::RecordState const r = _session->record_status ();
+ bool const h = _session->have_rec_enabled_diskstream ();
+
+ if (r == Session::Enabled || (r == Session::Recording && !h)) {
if (onoff) {
rec_button.set_visual_state (2);
} else {
rec_button.set_visual_state (0);
}
- break;
-
- case Session::Recording:
+ } else if (r == Session::Recording && h) {
rec_button.set_visual_state (1);
- break;
-
- default:
+ } else {
rec_button.set_visual_state (0);
- break;
}
}
-gint
-ARDOUR_UI::hide_and_quit (GdkEventAny *ev, ArdourDialog *window)
-{
- window->hide();
- Gtk::Main::quit ();
- return TRUE;
-}
-
void
ARDOUR_UI::save_template ()
-
{
ArdourPrompter prompter (true);
string name;
}
prompter.set_name (X_("Prompter"));
+ prompter.set_title (_("Save Mix Template"));
prompter.set_prompt (_("Name for mix template:"));
- prompter.set_initial_text(session->name() + _("-template"));
+ prompter.set_initial_text(_session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
prompter.get_result (name);
-
+
if (name.length()) {
- session->save_template (name);
+ _session->save_template (name);
}
break;
}
}
-bool
-ARDOUR_UI::get_session_parameters (Glib::ustring predetermined_path, bool have_engine, bool should_be_new)
+void
+ARDOUR_UI::edit_metadata ()
{
- string session_name;
- string session_path;
- string template_name;
+ SessionMetadataEditor dialog;
+ dialog.set_session (_session);
+ editor->ensure_float (dialog);
+ dialog.run ();
+}
- if (!loading_dialog) {
- loading_dialog = new MessageDialog (*new_session_dialog,
- "",
- false,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_NONE);
+void
+ARDOUR_UI::import_metadata ()
+{
+ SessionMetadataImporter dialog;
+ 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 ();
}
-
- int response = Gtk::RESPONSE_NONE;
+#endif
+}
- new_session_dialog->set_modal(true);
- new_session_dialog->set_name (predetermined_path);
- new_session_dialog->reset_recent();
- new_session_dialog->set_position (WIN_POS_CENTER);
- new_session_dialog->set_current_page (0);
+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;
- do {
- new_session_dialog->set_have_engine (have_engine);
+ 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));
+ }
- new_session_dialog->show();
- new_session_dialog->present ();
- response = new_session_dialog->run ();
+ session_name = basename_nosuffix (string (cmdline_path));
+}
- _session_is_new = false;
+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 */
- if (response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
+ /* 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) {
- quit();
- }
- new_session_dialog->hide ();
- return false;
+ if (session_name.length() == 0 || session_path.length() == 0) {
+ return false;
+ }
- } else if (response == Gtk::RESPONSE_NONE) {
+ if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
- /* Clear was pressed */
- new_session_dialog->reset();
- continue;
+ 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;
}
- /* first things first ... if we're here to help set up audio parameters
- this is where want to do that.
- */
+ } else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) {
- if (!have_engine) {
- if (new_session_dialog->engine_control.setup_engine ()) {
- new_session_dialog->hide ();
- return false;
- }
+ if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) {
+ /* existing .ardour file */
+ existing_session = true;
}
-#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.
- */
+ } else {
+ existing_session = false;
+ }
- 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 (*new_session_dialog,
- _("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);
- msg.show_all ();
- msg.present ();
- msg.run ();
+ /* 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)
+{
+ Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
+
+ MessageDialog msg (str,
+ false,
+ Gtk::MESSAGE_WARNING,
+ Gtk::BUTTONS_YES_NO,
+ true);
+
+
+ msg.set_name (X_("OpenExistingDialog"));
+ msg.set_title (_("Open Existing Session"));
+ msg.set_wmclass (X_("existing_session"), "Ardour");
+ msg.set_position (Gtk::WIN_POS_MOUSE);
+ pop_back_splash ();
+
+ switch (msg.run()) {
+ case RESPONSE_YES:
+ return true;
+ break;
+ }
+ return false;
+}
+
+int
+ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& session_name)
+{
+
+ uint32_t cchns;
+ uint32_t mchns;
+ AutoConnectOption iconnect;
+ AutoConnectOption oconnect;
+ uint32_t nphysin;
+ uint32_t nphysout;
+
+ if (Profile->get_sae()) {
+
+ cchns = 0;
+ mchns = 2;
+ iconnect = AutoConnectPhysical;
+ oconnect = AutoConnectMaster;
+ nphysin = 0; // use all available
+ nphysout = 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;
}
-#endif
- loading_dialog->set_message (_("Starting audio engine"));
- loading_dialog->show_all ();
- flush_pending ();
-
- if (create_engine ()) {
- backend_audio_error (!have_engine, new_session_dialog);
- loading_dialog->hide ();
- flush_pending ();
- /* audio setup page */
- new_session_dialog->set_current_page (2);
- /* try again */
- response = Gtk::RESPONSE_NONE;
- continue;
+
+ if (_startup->create_master_bus()) {
+ mchns = (uint32_t) _startup->master_channel_count();
+ } else {
+ mchns = 0;
}
- have_engine = true;
-
- /* now handle possible affirmative responses */
+ if (_startup->connect_inputs()) {
+ iconnect = AutoConnectPhysical;
+ } else {
+ iconnect = AutoConnectOption (0);
+ }
- if (response == Gtk::RESPONSE_YES) {
+ /// @todo some minor tweaks.
- /* YES == OPEN from the session selector */
+ oconnect = AutoConnectOption (0);
- session_name = new_session_dialog->session_name();
-
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+ if (_startup->connect_outputs ()) {
+ if (_startup->connect_outs_to_master()) {
+ oconnect = AutoConnectMaster;
+ } else if (_startup->connect_outs_to_physical()) {
+ oconnect = AutoConnectPhysical;
+ }
+ }
- if (session_name[0] == '/' ||
- (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
- (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
- load_session (Glib::path_get_dirname (session_name), session_name);
+ nphysin = (uint32_t) _startup->input_limit_count();
+ nphysout = (uint32_t) _startup->output_limit_count();
+ }
+
+ if (build_session (session_path,
+ session_name,
+ cchns,
+ mchns,
+ iconnect,
+ oconnect,
+ nphysin,
+ nphysout,
+ engine->frame_rate() * 60 * 5)) {
+
+ return -1;
+ }
+
+ return 0;
+}
+
+void
+ARDOUR_UI::idle_load (const Glib::ustring& path)
+{
+ 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));
+ } else {
+ /* /path/to/foo/foo.ardour => /path/to/foo, foo */
+ load_session (Glib::path_get_dirname (path), basename_nosuffix (path));
+ }
+ } else {
+
+ ARDOUR_COMMAND_LINE::session_name = path;
+
+ /*
+ * new_session_dialog doens't exist in A3
+ * Try to remove all references to it to
+ * see if it will compile. NOTE: this will
+ * likely cause a runtime issue is my somewhat
+ * uneducated guess.
+ */
+
+ //if (new_session_dialog) {
+
+
+ /* make it break out of Dialog::run() and
+ start again.
+ */
+
+ //new_session_dialog->response (1);
+ //}
+ }
+}
+
+void
+ARDOUR_UI::end_loading_messages ()
+{
+ // hide_splash ();
+}
+
+void
+ARDOUR_UI::loading_message (const std::string& /*msg*/)
+{
+ // show_splash ();
+ // splash->message (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 quit_on_cancel, bool should_be_new)
+{
+ Glib::ustring session_name;
+ Glib::ustring session_path;
+ Glib::ustring template_name;
+ int ret = -1;
+ bool likely_new = false;
+
+ while (ret != 0) {
+
+ if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) {
+
+ /* if they named a specific statefile, use it, otherwise they are
+ just giving a session folder, and we want to use it as is
+ to find the session.
+ */
+
+ if (ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix) != string::npos) {
+ session_path = Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name);
} else {
- session_path = new_session_dialog->session_folder();
- load_session (session_path, session_name);
+ session_path = ARDOUR_COMMAND_LINE::session_name;
}
-
- } else if (response == Gtk::RESPONSE_OK) {
- /* OK == OPEN button */
+ session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name);
- session_name = new_session_dialog->session_name();
-
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
-
- switch (new_session_dialog->get_current_page()) {
- case 1: /* recent session selector */
- case 2: /* audio engine control */
-
- if (session_name[0] == '/' ||
- (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
- (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
- load_session (Glib::path_get_dirname (session_name), session_name);
+ } else {
+
+ bool const apply = run_startup (should_be_new);
+ if (!apply) {
+ if (quit_on_cancel) {
+ exit (1);
} else {
- session_path = new_session_dialog->session_folder();
- load_session (session_path, session_name);
+ return ret;
}
+ }
+
+ /* if we run the startup dialog again, offer more than just "new session" */
+
+ should_be_new = false;
+
+ session_name = _startup->session_name (likely_new);
+
+ /* this shouldn't happen, but we catch it just in case it does */
+
+ if (session_name.empty()) {
break;
+ }
+ if (_startup->use_session_template()) {
+ template_name = _startup->session_template_name();
+ _session_is_new = true;
+ }
- case 0: /* nominally the "new" session creator, but could be in use for an old session */
+ 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] == '/')) {
- if (new_session_dialog->get_current_page() == 0 && ARDOUR_COMMAND_LINE::session_name.empty()) {
- should_be_new = true;
- }
+ session_path = Glib::path_get_dirname (session_name);
+ session_name = Glib::path_get_basename (session_name);
- /* handle what appear to be paths rather than just a name */
+ } else {
- if (session_name[0] == '/' ||
- (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
- (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
+ session_path = _startup->session_folder();
+ }
+ }
- session_path = Glib::path_get_dirname (session_name);
- session_name = Glib::path_get_basename (session_name);
+ if (create_engine ()) {
+ break;
+ }
- } else {
+ if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
- session_path = new_session_dialog->session_folder();
+ if (likely_new) {
- }
-
- //XXX This is needed because session constructor wants a
- //non-existant path. hopefully this will be fixed at some point.
-
- session_path = Glib::build_filename (session_path, session_name);
-
- if (!should_be_new) {
-
- load_session (session_path, session_name);
- continue; /* leaves while() loop because response != NONE */
-
- } else if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
-
- Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
-
- MessageDialog msg (str,
- false,
- Gtk::MESSAGE_WARNING,
- Gtk::BUTTONS_YES_NO,
- true);
-
-
- msg.set_name (X_("CleanupDialog"));
- msg.set_wmclass (X_("existing_session"), "Ardour");
- msg.set_position (Gtk::WIN_POS_MOUSE);
-
- switch (msg.run()) {
- case RESPONSE_YES:
- new_session_dialog->hide ();
- goto_editor_window ();
- flush_pending ();
- load_session (session_path, session_name);
- goto done;
- break;
- default:
- response = RESPONSE_NONE;
- new_session_dialog->reset ();
- continue;
- }
- }
-
- _session_is_new = true;
-
- if (new_session_dialog->use_session_template()) {
-
- template_name = new_session_dialog->session_template_name();
-
- new_session_dialog->hide ();
- goto_editor_window ();
- flush_pending ();
-
- load_session (session_path, session_name, &template_name);
-
- } else {
+ Glib::ustring existing = Glib::build_filename (session_path, session_name);
- uint32_t cchns;
- uint32_t mchns;
- AutoConnectOption iconnect;
- AutoConnectOption oconnect;
- uint32_t nphysin;
- uint32_t nphysout;
-
- if (Profile->get_sae()) {
-
- cchns = 0;
- mchns = 2;
- iconnect = AutoConnectPhysical;
- oconnect = AutoConnectMaster;
- nphysin = 0; // use all available
- nphysout = 0; // use all available
-
- } else {
-
- /* get settings from advanced section of NSD */
-
- if (new_session_dialog->create_control_bus()) {
- cchns = (uint32_t) new_session_dialog->control_channel_count();
- } else {
- cchns = 0;
- }
-
- if (new_session_dialog->create_master_bus()) {
- mchns = (uint32_t) new_session_dialog->master_channel_count();
- } else {
- mchns = 0;
- }
-
- if (new_session_dialog->connect_inputs()) {
- iconnect = AutoConnectPhysical;
- } else {
- iconnect = AutoConnectOption (0);
- }
-
- /// @todo some minor tweaks.
-
- if (new_session_dialog->connect_outs_to_master()) {
- oconnect = AutoConnectMaster;
- } else if (new_session_dialog->connect_outs_to_physical()) {
- oconnect = AutoConnectPhysical;
- } else {
- oconnect = AutoConnectOption (0);
- }
-
- nphysin = (uint32_t) new_session_dialog->input_limit_count();
- nphysout = (uint32_t) new_session_dialog->output_limit_count();
- }
-
- new_session_dialog->hide ();
- goto_editor_window ();
- flush_pending ();
-
- if (build_session (session_path,
- session_name,
- cchns,
- mchns,
- iconnect,
- oconnect,
- nphysin,
- nphysout,
- engine->frame_rate() * 60 * 5)) {
-
- response = Gtk::RESPONSE_NONE;
- new_session_dialog->reset ();
- continue;
- }
+ if (!ask_about_loading_existing_session (existing)) {
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
}
- break;
+ }
- default:
- break;
+ _session_is_new = false;
+
+ } else {
+
+ if (!likely_new) {
+ MessageDialog msg (string_compose (_("There is no existing session at \"%1\""), session_path));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
}
+
+ _session_is_new = true;
}
-
- } while (response == Gtk::RESPONSE_NONE);
- done:
- show();
- loading_dialog->hide ();
- new_session_dialog->hide();
- return true;
+ if (likely_new && template_name.empty()) {
+
+ ret = build_session_from_nsd (session_path, session_name);
+
+ } else {
+
+ ret = load_session (session_path, session_name, template_name);
+ if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
+ _session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
+ exit (1);
+ }
+ }
+ }
+
+ return ret;
}
void
unload_session (true);
- get_session_parameters ("", true, false);
+ ARDOUR_COMMAND_LINE::session_name = "";
+ get_session_parameters (true, false);
}
int
-ARDOUR_UI::load_session (const string & path, const string & snap_name, string* mix_template)
+ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_name, Glib::ustring mix_template)
{
Session *new_session;
int unload_status;
unload_status = unload_session ();
- if (unload_status < 0) {
- goto out;
- } else if (unload_status > 0) {
- retval = 0;
+ if (unload_status < 0) {
+ goto out;
+ } else if (unload_status > 0) {
+ retval = 0;
+ goto out;
+ }
+
+ loading_message (_("Please wait while Ardour loads your session"));
+
+ try {
+ new_session = new Session (*engine, path, snap_name, mix_template);
+ }
+
+ /* this one is special */
+
+ catch (AudioEngine::PortRegistrationFailure& err) {
+
+ MessageDialog msg (err.what(),
+ true,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_CLOSE);
+
+ msg.set_title (_("Port Registration Error"));
+ msg.set_secondary_text (_("Click the Close button to try again."));
+ 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:
+ break;
+ }
goto out;
}
- /* if it already exists, we must have write access */
+ catch (...) {
- if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
- MessageDialog msg (*editor, _("You do not have write access to this session.\n"
- "This prevents the session from being loaded."));
- msg.run ();
- goto out;
- }
+ MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name),
+ true,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_CLOSE);
- if (loading_dialog) {
- loading_dialog->set_markup (_("Please wait while Ardour loads your session"));
- flush_pending ();
- }
+ msg.set_title (_("Loading Error"));
+ msg.set_secondary_text (_("Click the Close button to try again."));
+ msg.set_position (Gtk::WIN_POS_CENTER);
+ pop_back_splash ();
+ msg.present ();
- disable_screen_updates ();
+ int response = msg.run ();
- try {
- new_session = new Session (*engine, path, snap_name, mix_template);
- }
+ msg.hide ();
- catch (...) {
- error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
+ switch (response) {
+ case RESPONSE_CANCEL:
+ exit (1);
+ default:
+ break;
+ }
goto out;
}
- connect_to_session (new_session);
-
- Config->set_current_owner (ConfigVariableBase::Interface);
+ set_session (new_session);
session_loaded = true;
-
+
goto_editor_window ();
- if (session) {
- session->set_clean ();
+ if (_session) {
+ _session->set_clean ();
}
- editor->edit_cursor_position (true);
- enable_screen_updates ();
flush_pending ();
retval = 0;
}
int
-ARDOUR_UI::build_session (const string & path, const string & snap_name,
+ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name,
uint32_t control_channels,
- uint32_t master_channels,
+ uint32_t master_channels,
AutoConnectOption input_connect,
AutoConnectOption output_connect,
uint32_t nphysin,
} else if (x > 0) {
return 0;
}
-
+
_session_is_new = true;
try {
catch (...) {
MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
+ pop_back_splash ();
msg.run ();
return -1;
}
- connect_to_session (new_session);
+ set_session (new_session);
session_loaded = true;
+
+ new_session->save_state(new_session->name());
+
return 0;
}
{
if (editor) {
editor->show_window ();
-
+
if (!shown_flag) {
editor->present ();
}
}
void
-ARDOUR_UI::show_splash ()
+ARDOUR_UI::show_about ()
{
if (about == 0) {
- about = new About();
- about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );
+ about = new About;
+ about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) );
+ }
+
+ about->show_all ();
+}
+
+void
+ARDOUR_UI::hide_about ()
+{
+ if (about) {
+ about->get_window()->set_cursor ();
+ about->hide ();
}
- about->present();
- flush_pending ();
}
void
-ARDOUR_UI::about_signal_response(int response)
+ARDOUR_UI::about_signal_response (int /*response*/)
{
- hide_splash();
+ hide_about();
+}
+
+void
+ARDOUR_UI::show_splash ()
+{
+ if (splash == 0) {
+ try {
+ splash = new Splash;
+ } catch (...) {
+ return;
+ }
+ }
+
+ splash->show ();
+ splash->present ();
+ splash->queue_draw ();
+ splash->get_window()->process_updates (true);
+ flush_pending ();
}
void
ARDOUR_UI::hide_splash ()
{
- if (about) {
- about->get_window()->set_cursor ();
- about->hide();
+ if (splash) {
+ splash->hide();
}
}
void
-ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, const string & msg)
+ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title,
+ const string& plural_msg, const string& singular_msg)
{
size_t removed;
if (removed == 0) {
MessageDialog msgd (*editor,
- _("No audio files were ready for cleanup"),
+ _("No audio files were ready for cleanup"),
true,
Gtk::MESSAGE_INFO,
(Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
check for any existing snapshots.\n\
These may still include regions that\n\
require some unused files to continue to exist."));
-
+
msgd.run ();
return;
- }
+ }
ArdourDialog results (_("ardour: cleanup"), true, false);
-
+
struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
- CleanupResultsModelColumns() {
+ CleanupResultsModelColumns() {
add (visible_name);
add (fullpath);
}
Gtk::TreeModelColumn<Glib::ustring> fullpath;
};
-
+
CleanupResultsModelColumns results_columns;
Glib::RefPtr<Gtk::ListStore> results_model;
Gtk::TreeView results_display;
-
+
results_model = ListStore::create (results_columns);
results_display.set_model (results_model);
results_display.append_column (list_title, results_columns.visible_name);
dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
- const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
+ const string dead_sound_directory = _session->session_directory().dead_sound_path().to_string();
+
+
+
+
+ /* subst:
+ %1 - number of files removed
+ %2 - location of "dead_sounds"
+ %3 - size of files affected
+ %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
+ */
+
+ const char* bprefix;
if (rep.space < 1048576.0f) {
- if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
- } else {
- txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
- }
+ bprefix = X_("kilo");
+ } else if (rep.space < 1048576.0f * 1000) {
+ bprefix = X_("mega");
} else {
- if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
- } else {
- txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
- }
+ bprefix = X_("giga");
+ }
+
+ if (removed > 1) {
+ txt.set_text (string_compose (plural_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
+ } else {
+ txt.set_text (string_compose (singular_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
}
dhbox.pack_start (*dimage, true, false, 5);
row[results_columns.visible_name] = *i;
row[results_columns.fullpath] = *i;
}
-
+
list_scroller.add (results_display);
list_scroller.set_size_request (-1, 150);
list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
void
ARDOUR_UI::cleanup ()
{
- if (session == 0) {
+ if (_session == 0) {
/* shouldn't happen: menu item is insensitive */
return;
}
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.add_button (Stock::CANCEL, RESPONSE_CANCEL);
checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
checker.set_default_response (RESPONSE_CANCEL);
return;
}
- Session::cleanup_report rep;
+ ARDOUR::CleanupReport rep;
editor->prepare_for_cleanup ();
act->set_sensitive (false);
}
- if (session->cleanup_sources (rep)) {
+ if (_session->cleanup_sources (rep)) {
+ editor->finish_cleanup ();
return;
}
+ editor->finish_cleanup ();
+
checker.hide();
- display_cleanup_results (rep,
+ display_cleanup_results (rep,
_("cleaned files"),
_("\
-The following %1 %2 not in use and \n\
+The following %1 files were not in use and \n\
have been moved to:\n\
-%3. \n\n\
+%2. \n\n\
Flushing the wastebasket will \n\
release an additional\n\
-%4 %5bytes of disk space.\n"
+%3 %4bytes of disk space.\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\
+%3 %4bytes of disk space.\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;
}
- display_cleanup_results (rep,
+ display_cleanup_results (rep,
_("deleted file"),
- _("The following %1 %2 deleted from\n\
-%3,\n\
-releasing %4 %5bytes of disk space"));
+ _("The following %1 files were deleted from\n\
+%2,\n\
+releasing %3 %4bytes of disk space"),
+ _("The following file was deleted from\n\
+%2,\n\
+releasing %3 %4bytes of disk space"));
}
void
{
int count;
- if (!session) {
+ if (!_session) {
return;
}
if (add_route_dialog == 0) {
- add_route_dialog = new AddRouteDialog;
+ add_route_dialog = new AddRouteDialog (_session);
if (float_window) {
add_route_dialog->set_transient_for (*float_window);
}
return;
}
+ string template_path = add_route_dialog->track_template();
+
+ if (!template_path.empty()) {
+ _session->new_route_from_template (count, template_path);
+ return;
+ }
+
uint32_t input_chan = add_route_dialog->channels ();
uint32_t output_chan;
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
+ bool aux = !track && add_route_dialog->aux();
+ RouteGroup* route_group = add_route_dialog->route_group ();
AutoConnectOption oac = Config->get_output_auto_connect();
if (oac & AutoConnectMaster) {
- output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan);
+ output_chan = (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan);
} else {
output_chan = input_chan;
}
if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
- session_add_midi_track(count);
+ session_add_midi_track (route_group, count);
} else {
MessageDialog msg (*editor,
_("Sorry, MIDI Busses are not supported at this time."));
msg.run ();
//session_add_midi_bus();
}
- } else {
+ } else {
if (track) {
- session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
+ session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
} else {
- session_add_audio_bus (input_chan, output_chan, count);
+ session_add_audio_bus (aux, input_chan, output_chan, route_group, count);
}
}
}
{
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"));
}
{
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"));
}
+ if (!node) {
+ if (getenv("ARDOUR_INSTANT_XML_PATH")) {
+ node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
+ }
+ }
+
if (!node) {
node = new XMLNode (X_("Editor"));
}
+
return node;
}
XMLNode* node = 0;
node = Config->extra_xml(X_("Keyboard"));
-
+
if (!node) {
node = new XMLNode (X_("Keyboard"));
}
}
void
-ARDOUR_UI::halt_on_xrun_message ()
+ARDOUR_UI::create_xrun_marker(nframes_t where)
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message));
+ editor->mouse_add_new_marker (where, false, true);
+}
+void
+ARDOUR_UI::halt_on_xrun_message ()
+{
MessageDialog msg (*editor,
_("Recording was stopped because your system could not keep up."));
msg.run ();
}
+void
+ARDOUR_UI::xrun_handler(nframes_t where)
+{
+ if (!_session) {
+ return;
+ }
+
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::xrun_handler, where)
+
+ 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()) {
+ 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 ()
+{
+ std::ofstream fout;
+ struct tm tm;
+ char buf[64];
+ char path[PATH_MAX+1]; int fd;
+
+ strcpy (path, "ardourBufferingXXXXXX");
+
+ if ((fd = mkstemp (path )) < 0) {
+ cerr << X_("cannot find temporary name for ardour buffer stats") << endl;
+ return;
+ }
+
+ fout.open (path);
+ close (fd);
+
+ if (!fout) {
+ cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), path) << endl;
+ return;
+ }
+
+ for (list<DiskBufferStat>::iterator i = disk_buffer_stats.begin(); i != disk_buffer_stats.end(); ++i) {
+ localtime_r (&(*i).when, &tm);
+ strftime (buf, sizeof (buf), "%T", &tm);
+ fout << buf << ' ' << (*i).capture << ' ' << (*i).playback << endl;
+ }
+
+ disk_buffer_stats.clear ();
+
+ fout.close ();
+
+ cerr << "Ardour buffering statistics can be found in: " << path << endl;
+}
+
void
ARDOUR_UI::disk_overrun_handler ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler)
+
+ write_buffer_stats ();
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
\n\
Specifically, it failed to write data to disk\n\
quickly enough to keep up with recording.\n"));
- msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+ msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
msg->show ();
}
}
void
ARDOUR_UI::disk_underrun_handler ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler)
+
+ write_buffer_stats ();
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
\n\
Specifically, it failed to read data from disk\n\
quickly enough to keep up with playback.\n"));
- msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+ msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
msg->show ();
- }
+ }
}
void
-ARDOUR_UI::disk_speed_dialog_gone (int ignored_response, MessageDialog* msg)
+ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
{
have_disk_speed_dialog_displayed = false;
delete msg;
}
+void
+ARDOUR_UI::session_dialog (std::string msg)
+{
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::session_dialog, msg)
+
+ MessageDialog* d;
+
+ if (editor) {
+ d = new MessageDialog (*editor, msg, false, MESSAGE_INFO, BUTTONS_OK, true);
+ } else {
+ d = new MessageDialog (msg, false, MESSAGE_INFO, BUTTONS_OK, true);
+ }
+
+ d->show_all ();
+ d->run ();
+ delete d;
+}
+
int
ARDOUR_UI::pending_state_dialog ()
{
HBox* hbox = new HBox();
Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
- ArdourDialog dialog ("pending state dialog");
+ ArdourDialog dialog (_("Crash Recovery"), true);
Label message (_("\
This session appears to have been in\n\
middle of recording when ardour or\n\
Ardour can recover any captured audio for\n\
you, or it can ignore it. Please decide\n\
what you would like to do.\n"));
-
+ image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
message.show();
image->show();
hbox->show();
- //dialog.get_vbox()->show();
-
+
switch (dialog.run ()) {
case RESPONSE_ACCEPT:
return 1;
return 0;
}
}
-
+
+int
+ARDOUR_UI::sr_mismatch_dialog (nframes_t desired, nframes_t actual)
+{
+ HBox* hbox = new HBox();
+ Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
+ ArdourDialog dialog (_("Sample Rate Mismatch"), true);
+ Label message (string_compose (_("\
+This session was created with a sample rate of %1 Hz\n\
+\n\
+The audioengine is currently running at %2 Hz\n"), desired, actual));
+
+ image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
+ hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
+ hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
+ dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
+ dialog.add_button (_("Do not load session"), RESPONSE_REJECT);
+ dialog.add_button (_("Load session anyway"), RESPONSE_ACCEPT);
+ dialog.set_default_response (RESPONSE_ACCEPT);
+ dialog.set_position (WIN_POS_CENTER);
+ message.show();
+ image->show();
+ hbox->show();
+
+ switch (dialog.run ()) {
+ case RESPONSE_ACCEPT:
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+
void
ARDOUR_UI::disconnect_from_jack ()
{
}
}
-int
-ARDOUR_UI::cmdline_new_session (string path)
-{
- if (path[0] != '/') {
- char buf[PATH_MAX+1];
- string str;
-
- getcwd (buf, sizeof (buf));
- str = buf;
- str += '/';
- str += path;
- path = str;
- }
-
- get_session_parameters (path, false, true);
-
- _will_create_new_session_automatically = false; /* done it */
-
- return FALSE; /* don't call it again */
-}
-
void
ARDOUR_UI::use_config ()
{
- Glib::RefPtr<Action> act;
-
- switch (Config->get_native_file_data_format ()) {
- case FormatFloat:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
- break;
- case FormatInt24:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
- break;
- case FormatInt16:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat16bit"));
- break;
- }
-
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
-
- switch (Config->get_native_file_header_format ()) {
- case BWF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
- break;
- case WAVE:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
- break;
- case WAVE64:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
- break;
- case iXML:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
- break;
- case RF64:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
- break;
- case CAF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
- break;
- case AIFF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
- break;
- }
-
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
XMLNode* node = Config->extra_xml (X_("TransportControllables"));
if (node) {
ARDOUR_UI::update_transport_clocks (nframes_t pos)
{
if (Config->get_primary_clock_delta_edit_cursor()) {
- primary_clock.set (pos, false, editor->edit_cursor_position(false), 'p');
+ primary_clock.set (pos, false, editor->get_preferred_edit_position(), 1);
} else {
primary_clock.set (pos, 0, true);
}
if (Config->get_secondary_clock_delta_edit_cursor()) {
- secondary_clock.set (pos, false, editor->edit_cursor_position(false), 's');
+ secondary_clock.set (pos, false, editor->get_preferred_edit_position(), 2);
} else {
secondary_clock.set (pos);
}
void
ARDOUR_UI::record_state_changed ()
{
- ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
- if (!session || !big_clock_window) {
+ if (!_session || !big_clock_window) {
/* why bother - the clock isn't visible */
return;
}
- switch (session->record_status()) {
- case Session::Recording:
+ 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");
- break;
- default:
+ } else {
big_clock.set_widget_name ("BigClockNonRecording");
- break;
}
}
-void
-ARDOUR_UI::set_keybindings_path (string path)
-{
- keybindings_path = path;
-}
-
-void
-ARDOUR_UI::save_keybindings ()
-{
- if (can_save_keybindings) {
- AccelMap::save (user_keybindings_path);
- }
-}
-
bool
ARDOUR_UI::first_idle ()
{
- if (session) {
- session->allow_auto_play (true);
+ if (_session) {
+ _session->allow_auto_play (true);
}
- can_save_keybindings = true;
+
+ if (editor) {
+ editor->first_idle();
+ }
+
+ Keyboard::set_can_save_keybindings (true);
return false;
}
node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
}
- session->add_extra_xml (*node);
- session->set_dirty ();
+ _session->add_extra_xml (*node);
+ _session->set_dirty ();
}
-
+
ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp)
: Controllable (name), ui (u), type(tp)
{
-
+
}
void
fract = ((val - 0.5f)/0.5f);
}
}
-
+
ui.set_shuttle_fract (fract);
return;
}
ARDOUR_UI::TransportControllable::get_value (void) const
{
float val = 0.0f;
-
+
switch (type) {
case Roll:
break;
}
}
-void
-ARDOUR_UI::disable_all_plugins ()
-{
- if (!session) {
- return;
- }
-
- // session->begin_reversible_command (_("Disable all plugins"));
-
- boost::shared_ptr<Session::RouteList> routes = session->get_routes ();
-
- for (Session::RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
- // XMLNode& before = (*i)->get_redirect_state ();
- // session->add_command (new MementoCommand<Route>(**i, &before, 0));
- (*i)->disable_plugins ();
- // XMLNode& after = (*i)->get_redirect_state ();
- // session->add_command (new MementoCommand<Route>(**i, 0, &after));
-
- }
-
- // session->commit_reversible_command ();
-}
-
-void
-ARDOUR_UI::ab_all_plugins ()
-{
- if (!session) {
- return;
- }
-
- boost::shared_ptr<Session::RouteList> routes = session->get_routes ();
-
- for (Session::RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
- (*i)->ab_plugins (ab_direction);
- }
-
- ab_direction = !ab_direction;
-}