#include <gtkmm/accelmap.h>
#include <pbd/error.h>
+#include <pbd/basename.h>
#include <pbd/compose.h>
+#include <pbd/misc.h>
#include <pbd/pathscanner.h>
#include <pbd/failed_constructor.h>
#include <pbd/enumwriter.h>
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),
/* 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
+
+ if (getenv ("ARDOUR_DEBUG_UPDATES")) {
+ gdk_window_set_debug_updates (true);
+ }
about = 0;
route_params = 0;
option_editor = 0;
location_ui = 0;
+ key_editor = 0;
open_session_selector = 0;
have_configure_timeout = false;
have_disk_speed_dialog_displayed = false;
_will_create_new_session_automatically = false;
session_loaded = false;
+ loading_dialog = 0;
last_speed_displayed = -1.0f;
keybindings_path = ARDOUR::find_config_file ("ardour.bindings");
stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
}
-gint
-ARDOUR_UI::start_backend_audio ()
-{
- if (new_session_dialog->engine_control.start_engine ()) {
- return -1;
- }
-
- return 0;
-}
-
-void
+int
ARDOUR_UI::create_engine ()
{
// this gets called every time by new_session()
if (engine) {
- return;
+ return 0;
}
try {
engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
- } catch (AudioEngine::NoBackendAvailable& err) {
- backend_audio_error ();
- cerr << "engine not started\n";
- error << string_compose (_("Could not connect to JACK server as \"%1\""), ARDOUR_COMMAND_LINE::jack_client_name) << endmsg;
- exit (1);
+
+ } catch (...) {
+
+ return -1;
}
engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped));
engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
post_engine ();
+
+ return 0;
}
void
/* 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());
+ platform_specific ();
+
/* now start and maybe save state */
if (do_engine_start () == 0) {
Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
have_configure_timeout = true;
}
-
+
return FALSE;
}
XMLNode* node = new XMLNode (keyboard->get_state());
Config->add_extra_xml (*node);
Config->add_extra_xml (get_transport_controllable_state());
+ if (new_session_dialog) {
+ if (new_session_dialog->engine_control.was_used()) {
+ Config->add_extra_xml (new_session_dialog->engine_control.get_state());
+ }
+ }
Config->save_state();
+ ui_config->save_state ();
XMLNode enode(static_cast<Stateful*>(editor)->get_state());
XMLNode mnode(mixer->get_state());
}
void
-ARDOUR_UI::backend_audio_error ()
+ARDOUR_UI::backend_audio_error (bool we_set_params, Gtk::Window* toplevel)
{
- MessageDialog win (_("Ardour could not connect to JACK."),
- false,
- Gtk::MESSAGE_INFO,
- (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
-win.set_secondary_text(_("There are several possible reasons:\n\
+ 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.add_button (Stock::QUIT, RESPONSE_CLOSE);
win.set_default_response (RESPONSE_CLOSE);
win.show_all ();
void
ARDOUR_UI::startup ()
{
- using namespace ARDOUR_COMMAND_LINE;
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 (session_name.length()) {
+
+ if (ARDOUR_COMMAND_LINE::session_name.length()) {
/* Load session or start the new session dialog */
- if (Session::find_session (session_name, path, name, isnew)) {
- error << string_compose(_("could not load command line session \"%1\""), session_name) << endmsg;
- return;
+ if (Session::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) {
- 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;
+ 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);
}
}
-
- new_session_dialog->set_session_name (name);
- new_session_dialog->set_session_folder (Glib::path_get_basename (path));
- _session_is_new = isnew;
}
hide_splash ();
bool have_backend = EngineControl::engine_running();
- bool need_nsd;
- bool load_needed = false;
-
- if (have_backend) {
-
- /* backend audio is working */
-
- if (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 {
-
- /* no backend audio, must bring up NSD to check configuration */
-
- need_nsd = true;
- }
-
- if (need_nsd) {
-
- if (!new_session (session_name,have_backend)) {
- return;
- }
-
- } else {
-
- load_needed = true;
+ XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
+
+ if (audio_setup) {
+ new_session_dialog->engine_control.set_state (*audio_setup);
}
- create_engine ();
-
- if (load_needed) {
- if (load_session (session_name, name)) {
- return;
- }
+ if (!get_session_parameters (ARDOUR_COMMAND_LINE::session_name, have_backend, ARDOUR_COMMAND_LINE::new_session)) {
+ return;
}
-
+
show ();
}
vbox->pack_start (hbox);
hbox.show_all ();
- editor->ensure_float (msg);
msg.run ();
}
}
session->set_deletion_in_progress ();
}
engine->stop (true);
- Config->save_state();
- ARDOUR_UI::config()->save_state();
+ save_ardour_state ();
quit ();
}
return -1;
}
-gint
+int
ARDOUR_UI::every_second ()
{
update_cpu_load ();
gint
ARDOUR_UI::every_point_zero_one_seconds ()
{
+ // august 2007: actual update frequency: 40Hz, not 100Hz
+
SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
return TRUE;
}
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");
}
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);
}
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::big_clock_value_changed ()
+{
+ if (session) {
+ session->request_locate (big_clock.current_time ());
+ }
+}
+
void
ARDOUR_UI::secondary_clock_value_changed ()
{
}
}
-bool
-ARDOUR_UI::new_session (Glib::ustring predetermined_path, bool have_engine)
+void
+ARDOUR_UI::fontconfig_dialog ()
{
- string session_name;
- string session_path;
+#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::get_session_parameters (Glib::ustring predetermined_path, bool have_engine, bool should_be_new)
+{
+ bool existing_session = false;
+ Glib::ustring session_name;
+ Glib::ustring session_path;
+ Glib::ustring template_name;
+
+ 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()) {
- do {
+ /* 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
+ */
- new_session_dialog->set_have_engine (have_engine);
+ if (Glib::file_test (predetermined_path, Glib::FILE_TEST_IS_DIR)) {
+ session_path = predetermined_path;
+ } else {
+ session_path = Glib::path_get_dirname (string (predetermined_path));
+ }
- response = new_session_dialog->run ();
+ session_name = basename_nosuffix (string (predetermined_path));
+
+ 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;
+ }
+ new_session_dialog->set_session_name (session_name);
+ new_session_dialog->set_session_folder (session_path);
+
+ cerr << "Set name to " << session_name << " and dir to " << session_path << endl;
+
+ 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 += Session::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 (Session::statefile_suffix()) == predetermined_path.length() - 7) {
+ /* existing .ardour file */
+ existing_session = true;
+ }
+ }
+
+ new_session_dialog->set_modal (true);
+ }
+
+ 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 */
- new_session_dialog->reset();
- continue;
+ /* "Clear" was pressed */
+
+ goto try_again;
}
- /* first things first ... we need an audio engine running */
+ fontconfig_dialog();
+
+ /* if we're here to help set up audio parameters this is where want to do that.
+ */
if (!have_engine) {
- if (start_backend_audio ()) {
+ if (new_session_dialog->engine_control.setup_engine ()) {
new_session_dialog->hide ();
return false;
- }
- have_engine = true;
- }
+ }
- cerr << "startingengine\n";
+ loading_dialog->set_message (_("Starting audio engine"));
+ loading_dialog->show_all ();
+ flush_pending ();
+ }
- create_engine ();
+ 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 open session tab */
+ /* 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);
+ 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 from new session tab */
+ /* OK == OPEN button */
session_name = new_session_dialog->session_name();
-
- if (new_session_dialog->get_current_page() == 1) {
-
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+
+ if (session_name.empty()) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
+ cerr << "nsd now on page " << new_session_dialog->get_current_page() << endl;
+ 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);
+ 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 {
+ break;
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+ case 0: /* nominally the "new" session creator, but could be in use for an old session */
+
+ 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 */
//non-existant path. hopefully this will be fixed at some point.
session_path = Glib::build_filename (session_path, session_name);
-
- if (Glib::file_test (session_path, Glib::FileTest (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);
switch (msg.run()) {
case RESPONSE_YES:
- load_session (session_path, session_name);
+ 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;
-
- std::string template_name = new_session_dialog->session_template_name();
if (new_session_dialog->use_session_template()) {
-
- load_session (session_path, session_name, &template_name);
+
+ template_name = new_session_dialog->session_template_name();
+
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
+
+ if (load_session (session_path, session_name, template_name)) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
} else {
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;
}
void
-ARDOUR_UI::close_session()
+ARDOUR_UI::close_session ()
{
if (!check_audioengine()) {
return;
}
- unload_session();
- new_session ("", true);
+ 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 x;
+ int unload_status;
+ int retval = -1;
+
session_loaded = false;
-
+
if (!check_audioengine()) {
return -1;
}
- x = unload_session ();
+ unload_status = unload_session ();
- if (x < 0) {
- return -1;
- } else if (x > 0) {
- return 0;
+ 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);
}
catch (...) {
+ 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 ();
- error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
- return -1;
+ 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;
}
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,
AutoConnectOption input_connect,
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), 1);
+ 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), 2);
+ secondary_clock.set (pos, false, editor->get_preferred_edit_position(), 2);
} else {
secondary_clock.set (pos);
}
}
}
-void
-ARDOUR_UI::audioengine_setup ()
-{
-}