#include <gtkmm/accelmap.h>
#include <pbd/error.h>
+#include <pbd/misc.h>
+#include <pbd/basename.h>
#include <pbd/compose.h>
#include <pbd/failed_constructor.h>
#include <pbd/enumwriter.h>
#include <gtkmm2ext/popup.h>
#include <gtkmm2ext/window_title.h>
-#include <midi++/port.h>
-#include <midi++/mmc.h>
+#include <midi++/manager.h>
#include <ardour/ardour.h>
#include <ardour/profile.h>
#include <ardour/audio_track.h>
#include <ardour/midi_track.h>
#include <ardour/filesystem_paths.h>
+#include <ardour/filename_extensions.h>
#include "actions.h"
#include "ardour_ui.h"
#include "utils.h"
#include "gui_thread.h"
#include "theme_manager.h"
-
+#include "bundle_manager.h"
#include "i18n.h"
/* big clock */
- big_clock (X_("bigclock"), false, "BigClockNonRecording", false, false, true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
/* transport */
auditioning_alert_button (_("AUDITION")),
solo_alert_button (_("SOLO")),
- shown_flag (false)
+ shown_flag (false),
+ error_log_button (_("Errors"))
+
{
using namespace Gtk::Menu_Helpers;
Gtkmm2ext::init();
+
+#ifdef TOP_MENUBAR
+ _auto_display_errors = false;
+#endif
about = 0;
if (theArdourUI == 0) {
editor = 0;
mixer = 0;
session = 0;
+ editor = 0;
_session_is_new = false;
big_clock_window = 0;
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;
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::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
- /* have to wait for AudioEngine and Configuration before proceeding */
+ /* lets get this party started */
+
+ try {
+ ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization);
+ setup_gtk_ardour_enums ();
+ Config->set_current_owner (ConfigVariableBase::Interface);
+ setup_profile ();
+
+ } catch (failed_constructor& err) {
+ error << _("could not initialize Ardour.") << endmsg;
+ // pass it on up
+ throw err;
+ }
+
+ /* we like keyboards */
+
+ keyboard = new Keyboard;
+
+ starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
+ stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+
+ platform_setup ();
}
-void
-ARDOUR_UI::set_engine (AudioEngine& e)
+int
+ARDOUR_UI::create_engine ()
{
- engine = &e;
+ // this gets called every time by new_session()
+
+ if (engine) {
+ return 0;
+ }
+
+ 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));
- ActionManager::init ();
- new_session_dialog = new NewSessionDialog();
+ post_engine ();
- _tooltips.enable();
+ return 0;
+}
- keyboard = new Keyboard;
+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 ();
+
+ ActionManager::init ();
+ _tooltips.enable();
if (setup_windows ()) {
throw failed_constructor ();
}
+
+ check_memory_locking();
- if (GTK_ARDOUR::show_key_actions) {
+ /* this is the first point at which all the keybindings are available */
+
+ if (ARDOUR_COMMAND_LINE::show_key_actions) {
vector<string> names;
vector<string> paths;
vector<string> keys;
exit (0);
}
- /* start with timecode, metering enabled
- */
-
blink_timeout_tag = -1;
/* the global configuration object is now valid */
/* 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);
+#endif
update_disk_space ();
update_cpu_load ();
update_sample_rate (engine->frame_rate());
- starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
- stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+ /* 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
+ */
+ session->save_state ("");
+ }
+ }
}
ARDOUR_UI::~ARDOUR_UI ()
if (add_route_dialog) {
delete add_route_dialog;
}
+
+
+ if (new_session_dialog) {
+ delete new_session_dialog;
+ }
}
gint
Config->add_extra_xml (*node);
Config->add_extra_xml (get_transport_controllable_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);
+ session->add_instant_xml (mnode);
} else {
Config->add_instant_xml (enode);
Config->add_instant_xml (mnode);
}
}
+void
+ARDOUR_UI::backend_audio_error (bool we_set_params, Gtk::Window* toplevel)
+{
+ string title;
+ if (we_set_params) {
+ title = _("Ardour could not start JACK");
+ } else {
+ title = _("Ardour could not connect to JACK.");
+ }
+
+ MessageDialog win (title,
+ false,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_NONE);
+
+ if (we_set_params) {
+ win.set_secondary_text(_("There are several possible reasons:\n\
+\n\
+1) You requested audio parameters that are not supported..\n\
+2) JACK is running as another user.\n\
+\n\
+Please consider the possibilities, and perhaps try different parameters."));
+ } else {
+ win.set_secondary_text(_("There are several possible reasons:\n\
+\n\
+1) JACK is not running.\n\
+2) JACK is running as another user, perhaps root.\n\
+3) There is already another client called \"ardour\".\n\
+\n\
+Please consider the possibilities, and perhaps (re)start JACK."));
+ }
+
+ if (toplevel) {
+ win.set_transient_for (*toplevel);
+ }
+
+ if (we_set_params) {
+ 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 ();
+ }
+
+ /* we just don't care about the result, but we want to block */
+
+ win.run ();
+}
+
void
ARDOUR_UI::startup ()
{
- check_memory_locking();
+ 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)) {
+
+ MessageDialog msg (string_compose(_("Could not find command line session \"%1\""),
+ ARDOUR_COMMAND_LINE::session_name),
+ true,
+ Gtk::MESSAGE_ERROR,
+ Gtk::BUTTONS_OK);
+
+ msg.set_position (Gtk::WIN_POS_MOUSE);
+ msg.present ();
+ msg.run ();
+
+ exit (1);
+ }
+
+ if (!ARDOUR_COMMAND_LINE::new_session) {
+
+ /* Supposed to be loading an existing session, but the session doesn't exist */
+
+ if (isnew) {
+ MessageDialog msg (string_compose (_("\n\nNo session named \"%1\" exists.\n"
+ "To create it from the command line, start ardour as:\n ardour --new %1"), path),
+ true,
+ Gtk::MESSAGE_ERROR,
+ Gtk::BUTTONS_OK);
+
+ msg.set_position (Gtk::WIN_POS_MOUSE);
+ msg.present ();
+ msg.run ();
+
+ exit (1);
+ }
+ }
+ }
+
+ hide_splash ();
+
+ bool have_backend = EngineControl::engine_running();
+ XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
+
+ if (audio_setup) {
+ new_session_dialog->engine_control.set_state (*audio_setup);
+ }
+
+ if (!get_session_parameters (ARDOUR_COMMAND_LINE::session_name, have_backend, ARDOUR_COMMAND_LINE::new_session)) {
+ return;
+ }
+
+ show ();
}
void
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 (2500000);
+ }
+
+ 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;
+ msg.run ();
+ return;
+ }
+ break;
+ case 0:
+ break;
}
- break;
- case 0:
- break;
}
- }
-
- if (session) {
+
session->set_deletion_in_progress ();
}
+
engine->stop (true);
Config->save_state();
ARDOUR_UI::config()->save_state();
gint
ARDOUR_UI::every_point_zero_one_seconds ()
{
+ // august 2007: actual update frequency: 40Hz, not 100Hz
+
SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
return TRUE;
}
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.get_selection()->set_mode (SELECTION_BROWSE);
recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
scroller->add (recent_session_display);
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->set_position (WIN_POS_MOUSE);
- session_selector_window->hide();
+ ResponseType r = (ResponseType) session_selector_window->run ();
+
+ switch (r) {
+ case RESPONSE_ACCEPT:
+ break;
+ default:
+ if (can_return) {
+ session_selector_window->hide();
+ return;
+ } else {
+ exit (1);
+ }
+ }
- switch (r) {
- case RESPONSE_ACCEPT:
- break;
- default:
- return;
- }
+ if (recent_session_display.get_selection()->count_selected_rows() == 0) {
+ continue;
+ }
+
+ session_selector_window->hide();
- Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
+ Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
+
+ 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];
+
+ _session_is_new = false;
+
+ if (load_session (path, state) == 0) {
+ break;
+ }
- if (i == recent_session_model->children().end()) {
- return;
+ can_return = false;
}
-
- Glib::ustring path = (*i)[recent_session_columns.fullpath];
- Glib::ustring state = (*i)[recent_session_columns.visible_name];
-
- _session_is_new = false;
-
- load_session (path, state);
}
bool
open_session_selector = new Gtk::FileChooserDialog (_("open session"), FILE_CHOOSER_ACTION_OPEN);
open_session_selector->add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
open_session_selector->add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
+ open_session_selector->set_default_response(Gtk::RESPONSE_ACCEPT);
FileFilter session_filter;
session_filter.add_pattern ("*.ardour");
}
catch (...) {
- cerr << "About to complain about JACK\n";
MessageDialog msg (*editor,
_("There are insufficient JACK ports available\n\
to create a new track or bus.\n\
}
void
-ARDOUR_UI::transport_record ()
+ARDOUR_UI::transport_record (bool roll)
{
if (session) {
switch (session->record_status()) {
return;
}
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);
}
theme_manager->setup_theme();
}
-gint
-ARDOUR_UI::start_engine ()
-{
- if (do_engine_start () == 0) {
- if (session && _session_is_new) {
- /* we need to retain initial visual
- settings for a new session
- */
- session->save_state ("");
- }
- }
-
- return FALSE;
-}
-
void
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 */
}
}
IO& io,
bool in)
{
+ vector<string> connections;
+
if (in) {
if (io.n_inputs().n_total() == 0) {
buf = _("none");
/* XXX we're not handling multiple ports yet. */
- const char **connections = io.input(0)->get_connections();
-
- if (connections == 0 || connections[0] == '\0') {
+ if (io.input(0)->get_connections(connections) == 0) {
buf = _("off");
} else {
- buf = connections[0];
+ buf = connections.front();
}
- free (connections);
-
} else {
if (io.n_outputs().n_total() == 0) {
/* XXX we're not handling multiple ports yet. */
- const char **connections = io.output(0)->get_connections();
-
- if (connections == 0 || connections[0] == '\0') {
+ if (io.output(0)->get_connections(connections) == 0) {
buf = _("off");
} else {
- buf = connections[0];
+ buf = connections.front();
}
-
- free (connections);
}
}
}
}
+void
+ARDOUR_UI::big_clock_value_changed ()
+{
+ if (session) {
+ session->request_locate (big_clock.current_time ());
+ }
+}
+
void
ARDOUR_UI::secondary_clock_value_changed ()
{
}
}
+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 (*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 ();
+ }
+#endif
+}
+
bool
-ARDOUR_UI::new_session (std::string predetermined_path)
+ARDOUR_UI::get_session_parameters (Glib::ustring predetermined_path, bool have_engine, bool should_be_new)
{
- string session_name;
- string session_path;
+ bool existing_session = false;
+ Glib::ustring session_name;
+ Glib::ustring session_path;
+ Glib::ustring template_name;
- if (!check_audioengine()) {
- return false;
+ if (!loading_dialog) {
+ loading_dialog = new MessageDialog (*new_session_dialog,
+ "",
+ false,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_NONE);
}
+
int response = Gtk::RESPONSE_NONE;
- new_session_dialog->set_modal(true);
- new_session_dialog->set_name (predetermined_path);
- new_session_dialog->reset_recent();
- new_session_dialog->show();
- new_session_dialog->set_current_page (0);
+ if (predetermined_path.length()) {
+
+ /* before we start, lets see if the given path looks like
+ an existing ardour session. if it does, skip the
+ tabs that we don't need
+ */
- do {
- response = new_session_dialog->run ();
+ if (Glib::file_test (predetermined_path, Glib::FILE_TEST_IS_DIR)) {
+ session_path = predetermined_path;
+ existing_session = true;
+ } else if (Glib::file_test (predetermined_path, Glib::FILE_TEST_IS_REGULAR)) {
+ session_path = Glib::path_get_dirname (string (predetermined_path));
+ existing_session = true;
+ } else {
+ /* it doesn't exist, assume the best */
+ session_path = Glib::path_get_dirname (string (predetermined_path));
+ }
+
+ session_name = basename_nosuffix (string (predetermined_path));
- if (!check_audioengine()) {
- new_session_dialog->hide ();
- return false;
+ new_session_dialog->set_session_name (session_name);
+ new_session_dialog->set_session_folder (session_path);
+ new_session_dialog->set_modal (true);
+
+ if (existing_session) {
+
+ if (session_name.length() == 0 || session_path.length() == 0) {
+ error << string_compose (_("Ardour cannot understand \"%1\" as a session name"), predetermined_path) << endmsg;
+ return false;
+ }
+
+ if (Glib::file_test (predetermined_path, Glib::FILE_TEST_IS_DIR)) {
+ Glib::ustring predicted_session_file;
+
+ predicted_session_file = predetermined_path;
+ predicted_session_file += '/';
+ predicted_session_file += session_name;
+ predicted_session_file += ARDOUR::statefile_suffix;
+
+ if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) {
+ existing_session = true;
+ }
+
+ } else if (Glib::file_test (predetermined_path, Glib::FILE_TEST_EXISTS)) {
+
+ if (predetermined_path.find (ARDOUR::statefile_suffix) == predetermined_path.length() - 7) {
+ /* existing .ardour file */
+ existing_session = true;
+ }
+ } else {
+ existing_session = false;
+ }
+
+ if (existing_session && have_engine) {
+ /* lets just try to load it */
+
+ 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 ();
+ return false;
+ }
+
+ if (load_session (session_path, session_name) == 0) {
+ goto done;
+ }
+ }
}
+ }
+ /* loading failed, or we need the NSD for something */
+
+ new_session_dialog->set_position (WIN_POS_CENTER);
+ new_session_dialog->set_current_page (0);
+ new_session_dialog->set_existing_session (existing_session);
+ new_session_dialog->reset_recent();
+
+ do {
+ new_session_dialog->set_have_engine (have_engine);
+ new_session_dialog->present ();
+ response = new_session_dialog->run ();
+ loading_dialog->hide ();
+
_session_is_new = false;
+
+ /* handle possible negative responses */
if (response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
-
+
if (!session) {
quit();
}
new_session_dialog->hide ();
return false;
-
+
} else if (response == Gtk::RESPONSE_NONE) {
+ /* "Clear" was pressed */
+
+ goto try_again;
+ }
+
+ fontconfig_dialog();
- /* Clear was pressed */
- new_session_dialog->reset();
+ /* if we're here to help set up audio parameters this is where want to do that.
+ */
- } else if (response == Gtk::RESPONSE_YES) {
+ if (!have_engine) {
+ if (new_session_dialog->engine_control.setup_engine ()) {
+ new_session_dialog->hide ();
+ return false;
+ }
- /* YES == OPEN, but there's no enum for that */
+ loading_dialog->set_message (_("Starting audio engine"));
+ loading_dialog->show_all ();
+ flush_pending ();
+ }
- session_name = new_session_dialog->session_name();
+ if (create_engine ()) {
+ backend_audio_error (!have_engine, new_session_dialog);
+ loading_dialog->hide ();
+ flush_pending ();
+ /* audio setup page */
+ new_session_dialog->set_existing_session (false);
+ new_session_dialog->set_current_page (2);
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
+ loading_dialog->hide ();
+ have_engine = true;
+
+ /* now handle possible affirmative responses */
+
+ if (response == Gtk::RESPONSE_YES) {
+ /* YES == OPEN from the session selector */
+
+ session_name = new_session_dialog->session_name();
+
if (session_name.empty()) {
response = Gtk::RESPONSE_NONE;
- continue;
+ goto try_again;
}
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);
+ (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
+ if (load_session (Glib::path_get_dirname (session_name), session_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
} else {
session_path = new_session_dialog->session_folder();
- load_session (session_path, session_name);
+ if (load_session (session_path, session_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
}
-
+
} else if (response == Gtk::RESPONSE_OK) {
+ /* OK == OPEN button */
+
session_name = new_session_dialog->session_name();
+
+ if (session_name.empty()) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
- if (!new_session_dialog->on_new_session_page ()) {
+ switch (new_session_dialog->which_page()) {
+ case NewSessionDialog::OpenPage:
+ case NewSessionDialog::EnginePage:
- /* XXX this is a bit of a hack..
- i really want the new sesion dialog to return RESPONSE_YES
- if we're on page 1 (the load page)
- Unfortunately i can't see how atm..
- */
+ 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 (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+ if (load_session (Glib::path_get_dirname (session_name), session_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
- if (session_name[0] == '/' ||
- (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
- (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
- load_session (Glib::path_get_dirname (session_name), session_name);
} else {
session_path = new_session_dialog->session_folder();
- load_session (session_path, session_name);
+ cerr << "there\n";
+ if (load_session (session_path, session_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
}
+ break;
- } else {
+ case NewSessionDialog::NewPage: /* nominally the "new" session creator, but could be in use for an old session */
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+ cerr << "on page zero\n";
+
+ if (new_session_dialog->get_current_page() == 0 && ARDOUR_COMMAND_LINE::session_name.empty()) {
+ should_be_new = true;
+ }
+
+ /* handle what appear to be paths rather than just a name */
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_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
session_path = Glib::path_get_dirname (session_name);
session_name = Glib::path_get_basename (session_name);
//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 (g_file_test (session_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
+ if (!should_be_new) {
+
+ if (load_session (session_path, session_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
+ 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);
+ false,
+ Gtk::MESSAGE_WARNING,
+ Gtk::BUTTONS_YES_NO,
+ true);
msg.set_name (X_("CleanupDialog"));
msg.set_wmclass (X_("existing_session"), "Ardour");
msg.set_position (Gtk::WIN_POS_MOUSE);
-
+
switch (msg.run()) {
- case RESPONSE_YES:
- load_session (session_path, session_name);
- goto done;
- break;
- default:
- response = RESPONSE_NONE;
- new_session_dialog->reset ();
- continue;
+ case RESPONSE_YES:
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
+ if (load_session (session_path, session_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+ goto done;
+ break;
+ default:
+ response = RESPONSE_NONE;
+ new_session_dialog->reset ();
+ new_session_dialog->set_existing_session (false);
+ loading_dialog->hide ();
+ continue;
}
- }
+ }
- _session_is_new = true;
+ _session_is_new = true;
+
+ if (new_session_dialog->use_session_template()) {
- std::string template_name = new_session_dialog->session_template_name();
+ template_name = new_session_dialog->session_template_name();
- if (new_session_dialog->use_session_template()) {
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
- load_session (session_path, session_name, &template_name);
+ if (load_session (session_path, session_name, template_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
} else {
uint32_t cchns;
uint32_t mchns;
AutoConnectOption iconnect;
AutoConnectOption oconnect;
+ uint32_t nphysin;
+ uint32_t nphysout;
+
+ if (Profile->get_sae()) {
- if (new_session_dialog->create_control_bus()) {
- cchns = (uint32_t) new_session_dialog->control_channel_count();
- } else {
cchns = 0;
- }
+ mchns = 2;
+ iconnect = AutoConnectPhysical;
+ oconnect = AutoConnectMaster;
+ nphysin = 0; // use all available
+ nphysout = 0; // use all available
- 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);
+ /* 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();
}
- /// @todo some minor tweaks.
-
- if (new_session_dialog->connect_outs_to_master()) {
- oconnect = AutoConnectMaster;
- } else if (new_session_dialog->connect_outs_to_physical()) {
- oconnect = AutoConnectPhysical;
- } else {
- oconnect = AutoConnectOption (0);
- }
-
- uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
- uint32_t nphysout = (uint32_t) new_session_dialog->output_limit_count();
-
- if (!build_session (session_path,
- session_name,
- cchns,
- mchns,
- iconnect,
- oconnect,
- nphysin,
- nphysout,
- engine->frame_rate() * 60 * 5)) {
-
+ 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;
+ goto try_again;
}
+
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
}
+ break;
+
+ default:
+ break;
}
}
+ try_again:
+ if (response == Gtk::RESPONSE_NONE) {
+ loading_dialog->hide ();
+ new_session_dialog->set_existing_session (false);
+ new_session_dialog->reset ();
+ }
+
} while (response == Gtk::RESPONSE_NONE);
done:
show();
- new_session_dialog->get_window()->set_cursor();
+ loading_dialog->hide ();
new_session_dialog->hide();
return true;
}
return;
}
- unload_session();
- new_session ();
+ unload_session (true);
+
+ 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;
+ int retval = -1;
+
session_loaded = false;
-
+
if (!check_audioengine()) {
return -1;
}
- if(!unload_session ()) return -1;
+ unload_status = unload_session ();
+
+ if (unload_status < 0) {
+ goto out;
+ } else if (unload_status > 0) {
+ retval = 0;
+ goto out;
+ }
/* if it already exists, we must have write access */
- if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
+ if (Glib::file_test (path.c_str(), Glib::FILE_TEST_EXISTS) && ::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 ();
- return -1;
+ goto out;
}
+ if (loading_dialog) {
+ loading_dialog->set_markup (_("Please wait while Ardour loads your session"));
+ flush_pending ();
+ }
+
+ disable_screen_updates ();
+
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_OK_CANCEL);
+
+ msg.set_title (_("Loading Error"));
+ msg.set_secondary_text (_("Click the OK button to try again."));
+ msg.set_position (Gtk::WIN_POS_CENTER);
+ msg.present ();
+
+ int response = msg.run ();
+
+ msg.hide ();
+
+ switch (response) {
+ case RESPONSE_CANCEL:
+ exit (1);
+ default:
+ break;
+ }
+ goto out;
+ }
+
catch (...) {
- error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
- return -1;
+ MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name),
+ true,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_OK_CANCEL);
+
+ msg.set_title (_("Loading Error"));
+ msg.set_secondary_text (_("Click the OK button to try again."));
+ msg.set_position (Gtk::WIN_POS_CENTER);
+ msg.present ();
+
+ int response = msg.run ();
+
+ msg.hide ();
+
+ switch (response) {
+ case RESPONSE_CANCEL:
+ exit (1);
+ default:
+ break;
+ }
+ goto out;
}
connect_to_session (new_session);
session->set_clean ();
}
- editor->edit_cursor_position (true);
- return 0;
+ enable_screen_updates ();
+ flush_pending ();
+ retval = 0;
+
+ out:
+ return retval;
}
-bool
-ARDOUR_UI::build_session (const string & path, const string & snap_name,
+int
+ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name,
uint32_t control_channels,
uint32_t master_channels,
AutoConnectOption input_connect,
nframes_t initial_length)
{
Session *new_session;
+ int x;
if (!check_audioengine()) {
- return false;
+ return -1;
}
session_loaded = false;
- if (!unload_session ()) return false;
+ x = unload_session ();
+
+ if (x < 0) {
+ return -1;
+ } else if (x > 0) {
+ return 0;
+ }
_session_is_new = true;
MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
msg.run ();
- return false;
+ return -1;
}
connect_to_session (new_session);
session_loaded = true;
- return true;
+ return 0;
}
void
int
ARDOUR_UI::pending_state_dialog ()
{
- ArdourDialog dialog ("pending state dialog");
+ HBox* hbox = new HBox();
+ Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_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"));
-
- dialog.get_vbox()->pack_start (message);
- dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
+ 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 (_("Ignore crash data"), RESPONSE_REJECT);
-
+ dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
+ dialog.set_default_response (RESPONSE_ACCEPT);
dialog.set_position (WIN_POS_CENTER);
message.show();
- //dialog.get_vbox()->show();
-
+ image->show();
+ hbox->show();
+
switch (dialog.run ()) {
case RESPONSE_ACCEPT:
return 1;
path = str;
}
- new_session (path);
-
+ get_session_parameters (path, false, true);
+
+ _will_create_new_session_automatically = false; /* done it */
+
return FALSE; /* don't call it again */
}
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);
}
if (gdk_screen_width() < 1200) {
Profile->set_small_screen ();
}
-}
-
-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));
-
+ if (getenv ("ARDOUR_SAE")) {
+ Profile->set_sae ();
+ Profile->set_single_package ();
}
-
- // 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;
-}
projects / ardour.git / blobdiff