#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
+#include <time.h>
#include <cerrno>
#include <fstream>
#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 <ardour/filesystem_paths.h>
#include <ardour/filename_extensions.h>
+typedef uint64_t microseconds_t;
+
#include "actions.h"
#include "ardour_ui.h"
#include "public_editor.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 "i18n.h"
preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true),
postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true),
- /* adjuster table */
-
- adjuster_table (3, 3),
-
/* preroll stuff */
preroll_button (_("pre\nroll")),
/* 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),
#ifdef TOP_MENUBAR
_auto_display_errors = false;
#endif
+
about = 0;
splash = 0;
mixer = 0;
session = 0;
editor = 0;
+ engine = 0;
_session_is_new = false;
big_clock_window = 0;
session_selector_window = 0;
have_disk_speed_dialog_displayed = false;
session_loaded = false;
last_speed_displayed = -1.0f;
-
- sys::path key_bindings_file;
+ ignore_dual_punch = false;
+ _mixer_on_top = false;
- find_file_in_search_path (ardour_search_path() + system_config_search_path(),
- "ardour.bindings", key_bindings_file);
+ 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);
- 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";
-
- can_save_keybindings = false;
-
- 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 (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ /* handle dialog requests */
+
+ ARDOUR::Session::Dialog.connect (mem_fun(*this, &ARDOUR_UI::session_dialog));
+
/* handle pending state with a dialog */
ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
+ /* handle sr mismatch with a dialog */
+
+ ARDOUR::Session::AskAboutSampleRateMismatch.connect (mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
+
/* lets get this party started */
try {
Config->set_current_owner (ConfigVariableBase::Interface);
setup_profile ();
+ GainMeter::setup_slider_pix ();
+ RouteTimeAxisView::setup_slider_pix ();
+
} catch (failed_constructor& err) {
error << _("could not initialize Ardour.") << endmsg;
// pass it on up
keyboard = new Keyboard;
+ reset_dpi();
+
starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
void
ARDOUR_UI::post_engine ()
{
- extern int setup_midi ();
-
/* Things to be done once we create the AudioEngine
*/
/* 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::SMPTE);
+ secondary_clock.set_mode (AudioClock::BBT);
+ }
/* start the time-of-day-clock */
{
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;
+ delete new_session_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;
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);
have_configure_timeout = true;
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;
XMLNode* node = new XMLNode (keyboard->get_state());
Config->add_extra_xml (*node);
Config->add_extra_xml (get_transport_controllable_state());
+ if (new_session_dialog && 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 ();
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;
}
win.show_all ();
win.set_position (Gtk::WIN_POS_CENTER);
-
- hide_splash ();
+ pop_back_splash ();
/* we just don't care about the result, but we want to block */
ARDOUR_UI::startup ()
{
string name, path;
-
+
new_session_dialog = new NewSessionDialog();
bool backend_audio_is_running = EngineControl::engine_running();
return;
}
+ BootMessage (_("Ardour is ready for use"));
show ();
}
cb.show();
vbox->show();
hbox.show ();
+
+ pop_back_splash ();
editor->ensure_float (msg);
msg.run ();
Ardour was unable to save your session.\n\n\
If you still wish to quit, please use the\n\n\
\"Just quit\" option."));
+ pop_back_splash();
msg.run ();
return;
}
session->set_deletion_in_progress ();
}
+ ArdourDialog::close_all_dialogs ();
engine->stop (true);
- Config->save_state();
- ARDOUR_UI::config()->save_state();
+ save_ardour_state ();
quit ();
}
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 ();
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);
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
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;
}
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;
}
}
-bool
-ARDOUR_UI::filter_ardour_session_dirs (const FileFilter::Info& info)
-{
- struct stat statbuf;
-
- if (stat (info.filename.c_str(), &statbuf) != 0) {
- return false;
- }
-
- if (!S_ISDIR(statbuf.st_mode)) {
- return 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;
- }
-
- return S_ISREG (statbuf.st_mode);
-}
-
bool
ARDOUR_UI::check_audioengine ()
{
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;
}
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 ();
}
}
}
void
-ARDOUR_UI::transport_goto_start ()
+ARDOUR_UI::transport_goto_start ()
{
if (session) {
session->goto_start();
}
}
+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->reset_x_origin (frames - (editor->current_page_frames()/2));
+ }
+ }
+}
+
void
ARDOUR_UI::transport_goto_end ()
{
void
ARDOUR_UI::transport_record (bool roll)
{
+
if (session) {
switch (session->record_status()) {
case Session::Disabled:
session->disable_record (false, true);
}
}
+ //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " session->record_status() = " << session->record_status() << endl;
}
void
rolling = session->transport_rolling ();
+ //cerr << "ARDOUR_UI::transport_roll () called session->record_status() = " << session->record_status() << endl;
+
if (session->get_play_loop()) {
session->request_play_loop (false);
auto_loop_button.set_visual_state (1);
_("\
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 ();
}
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 ()
{
}
}
-void
-ARDOUR_UI::rec_enable_button_blink (bool onoff, AudioDiskstream *dstream, Widget *w)
-{
- 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);
- }
- }
-}
-
void
ARDOUR_UI::transport_rec_enable_blink (bool onoff)
{
}
}
-gint
-ARDOUR_UI::hide_and_quit (GdkEventAny *ev, ArdourDialog *window)
-{
- window->hide();
- Gtk::Main::quit ();
- return TRUE;
-}
-
void
ARDOUR_UI::save_template ()
}
}
+void
+ARDOUR_UI::edit_metadata ()
+{
+ SessionMetadataEditor dialog;
+ dialog.set_session (session);
+ editor->ensure_float (dialog);
+ dialog.run ();
+}
+
+void
+ARDOUR_UI::import_metadata ()
+{
+ SessionMetadataImporter dialog;
+ dialog.set_session (session);
+ editor->ensure_float (dialog);
+ dialog.run ();
+}
+
void
ARDOUR_UI::fontconfig_dialog ()
{
true,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_OK);
+ pop_back_splash ();
msg.show_all ();
msg.present ();
msg.run ();
msg.set_name (X_("CleanupDialog"));
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;
splash->message (msg);
flush_pending ();
}
-
+
+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;
+
+ if (new_session_dialog) {
+
+
+ /* make it break out of Dialog::run() and
+ start again.
+ */
+
+ new_session_dialog->response (1);
+ }
+ }
+}
+
+/** @param offer_quit true to offer a Cancel button, otherwise call it Quit */
bool
-ARDOUR_UI::get_session_parameters (bool backend_audio_is_running, bool should_be_new)
+ARDOUR_UI::get_session_parameters (bool backend_audio_is_running, bool should_be_new, bool offer_cancel)
{
bool existing_session = false;
Glib::ustring session_name;
Glib::ustring session_path;
Glib::ustring template_name;
+ int response;
- int response = Gtk::RESPONSE_NONE;
+ begin:
+ response = Gtk::RESPONSE_NONE;
if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
new_session_dialog->set_current_page (0);
new_session_dialog->set_existing_session (existing_session);
new_session_dialog->reset_recent();
-
- /* get this out of the way */
-
- hide_splash ();
+ new_session_dialog->set_offer_cancel (offer_cancel);
do {
new_session_dialog->set_have_engine (backend_audio_is_running);
/* handle possible negative responses */
switch (response) {
+ case 1:
+ /* sent by idle_load, meaning restart the whole process again */
+ new_session_dialog->hide();
+ new_session_dialog->reset();
+ goto begin;
+ break;
+
case Gtk::RESPONSE_CANCEL:
case Gtk::RESPONSE_DELETE_EVENT:
if (!session) {
+ if (engine && engine->running()) {
+ engine->stop (true);
+ }
quit();
}
new_session_dialog->hide ();
fontconfig_dialog();
if (!backend_audio_is_running) {
- if (new_session_dialog->engine_control.setup_engine ()) {
- new_session_dialog->hide ();
+ int ret = new_session_dialog->engine_control.setup_engine ();
+ if (ret < 0) {
return false;
- }
+ } else if (ret > 0) {
+ response = Gtk::RESPONSE_REJECT;
+ goto try_again;
+ }
}
if (create_engine ()) {
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 = Glib::path_get_dirname (session_name);
session_name = Glib::path_get_basename (session_name);
session_path = new_session_dialog->session_folder();
}
+ template_name = Glib::ustring();
switch (new_session_dialog->which_page()) {
case NewSessionDialog::OpenPage:
loadit:
new_session_dialog->hide ();
-
- if (load_session (session_path, session_name)) {
+
+ if (load_session (session_path, session_name, template_name)) {
/* force a retry */
response = Gtk::RESPONSE_NONE;
}
}
}
- } while (response == Gtk::RESPONSE_NONE);
+ } while (response == Gtk::RESPONSE_NONE || response == Gtk::RESPONSE_REJECT);
done:
show();
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."));
+ pop_back_splash ();
msg.run ();
goto out;
}
loading_message (_("Please wait while Ardour loads your session"));
- disable_screen_updates ();
try {
new_session = new Session (*engine, path, snap_name, mix_template);
MessageDialog msg (err.what(),
true,
Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_OK_CANCEL);
+ Gtk::BUTTONS_CLOSE);
- msg.set_title (_("Loading Error"));
- msg.set_secondary_text (_("Click the OK button to try again."));
+ 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 ();
MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name),
true,
Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_OK_CANCEL);
+ Gtk::BUTTONS_CLOSE);
msg.set_title (_("Loading Error"));
- msg.set_secondary_text (_("Click the OK button to try again."));
+ 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 ();
session->set_clean ();
}
- enable_screen_updates ();
flush_pending ();
retval = 0;
catch (...) {
MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
+ pop_back_splash ();
msg.run ();
return -1;
}
connect_to_session (new_session);
session_loaded = true;
+
+ new_session->save_state(new_session->name());
+
return 0;
}
}
splash->show ();
+ splash->present ();
splash->queue_draw ();
splash->get_window()->process_updates (true);
flush_pending ();
}
if (session->cleanup_sources (rep)) {
+ editor->finish_cleanup ();
return;
}
+
+ editor->finish_cleanup ();
checker.hide();
display_cleanup_results (rep,
%4 %5bytes of disk space.\n"
));
-
-
}
void
}
/* XXX do something with name template */
-
+
if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
session_add_midi_track(count);
} 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;
}
}
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 (bind(mem_fun(*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::disk_overrun_handler ()
{
delete msg;
}
+void
+ARDOUR_UI::session_dialog (std::string msg)
+{
+ ENSURE_GUI_THREAD (bind (mem_fun(*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 ()
{
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 ()
}
}
-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);
}
- can_save_keybindings = true;
+
+ if (editor) {
+ editor->first_idle();
+ }
+
+ Keyboard::set_can_save_keybindings (true);
return false;
}
projects / ardour.git / blobdiff