/*
- Copyright (C) 1999-2002 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
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
#include <algorithm>
#include <cmath>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
+#include <time.h>
#include <cerrno>
#include <fstream>
#include <iostream>
+#include <sys/resource.h>
+
#include <gtkmm/messagedialog.h>
#include <gtkmm/accelmap.h>
#include <pbd/error.h>
+#include <pbd/basename.h>
#include <pbd/compose.h>
-#include <pbd/pathscanner.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++/port.h>
-#include <midi++/mmc.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/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 "mixer_ui.h"
#include "prompter.h"
#include "opts.h"
-#include "keyboard_target.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 "color_manager.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"
using namespace sigc;
ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
+UIConfiguration *ARDOUR_UI::ui_config = 0;
sigc::signal<void,bool> ARDOUR_UI::Blink;
sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
-sigc::signal<void,jack_nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void,nframes_t, bool, nframes_t> ARDOUR_UI::Clock;
-ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
+ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
- : Gtkmm2ext::UI ("ardour", argcp, argvp, rcfile),
+ : Gtkmm2ext::UI (X_("Ardour"), argcp, argvp),
- primary_clock (X_("TransportClockDisplay"), true, false, true),
- secondary_clock (X_("SecondaryClockDisplay"), true, false, true),
- preroll_clock (X_("PreRollClock"), true, true),
- postroll_clock (X_("PostRollClock"), true, true),
-
- /* adjuster table */
-
- adjuster_table (3, 3),
+ 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),
/* preroll stuff */
/* big clock */
- big_clock ("BigClockDisplay", true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
/* transport */
- time_master_button (_("time\nmaster")),
-
+ roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll)),
+ stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop)),
+ goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart)),
+ goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd)),
+ auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop)),
+ play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection)),
+ rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable)),
+ shuttle_controllable (new TransportControllable ("shuttle", *this, TransportControllable::ShuttleControl)),
+ shuttle_controller_binding_proxy (shuttle_controllable),
+
+ roll_button (roll_controllable),
+ stop_button (stop_controllable),
+ goto_start_button (goto_start_controllable),
+ goto_end_button (goto_end_controllable),
+ auto_loop_button (auto_loop_controllable),
+ play_selection_button (play_selection_controllable),
+ rec_button (rec_controllable),
+
shuttle_units_button (_("% ")),
punch_in_button (_("Punch In")),
punch_out_button (_("Punch Out")),
auto_return_button (_("Auto Return")),
- auto_play_button (_("Autuo Play")),
+ auto_play_button (_("Auto Play")),
auto_input_button (_("Auto Input")),
click_button (_("Click")),
+ time_master_button (_("time\nmaster")),
+
auditioning_alert_button (_("AUDITION")),
solo_alert_button (_("SOLO")),
- shown_flag (false)
+ shown_flag (false),
+ error_log_button (_("Errors"))
+
{
using namespace Gtk::Menu_Helpers;
Gtkmm2ext::init();
+
+#ifdef TOP_MENUBAR
+ _auto_display_errors = false;
+#endif
+
about = 0;
+ splash = 0;
+
+ if (ARDOUR_COMMAND_LINE::session_name.length()) {
+ /* only show this if we're not going to post the new session dialog */
+ show_splash ();
+ }
if (theArdourUI == 0) {
theArdourUI = this;
}
- ActionManager::init ();
-
- /* load colors */
-
- color_manager = new ColorManager();
-
- std::string color_file = ARDOUR::find_config_file("ardour.colors");
+ ui_config = new UIConfiguration();
+ theme_manager = new ThemeManager();
- color_manager->load (color_file);
-
- m_new_session_dialog = new NewSessionDialog();
editor = 0;
mixer = 0;
session = 0;
+ editor = 0;
+ engine = 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;
add_route_dialog = 0;
route_params = 0;
option_editor = 0;
location_ui = 0;
- sfdb = 0;
open_session_selector = 0;
have_configure_timeout = false;
- have_disk_overrun_displayed = false;
- have_disk_underrun_displayed = false;
- _will_create_new_session_automatically = false;
+ have_disk_speed_dialog_displayed = false;
session_loaded = false;
last_speed_displayed = -1.0f;
+ ignore_dual_punch = false;
+ _mixer_on_top = 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_max_speed = 8.0f;
- set_shuttle_units (Percentage);
- set_shuttle_behaviour (Sprung);
-
shuttle_style_menu = 0;
shuttle_unit_menu = 0;
- gettimeofday (&last_peak_grab, 0);
- gettimeofday (&last_shuttle_request, 0);
-
- ARDOUR::AudioDiskstream::DeleteSources.connect (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread));
+ // 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));
- /* have to wait for AudioEngine and Configuration before proceeding */
+ /* handle sr mismatch with a dialog */
+
+ ARDOUR::Session::AskAboutSampleRateMismatch.connect (mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
+
+ /* lets get this party started */
+
+ 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 ();
+
+ } catch (failed_constructor& err) {
+ error << _("could not initialize Ardour.") << endmsg;
+ // pass it on up
+ throw;
+ }
+
+ /* we like keyboards */
+
+ keyboard = new Keyboard;
+
+ reset_dpi();
+
+ 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;
+ }
+
+ 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));
- _tooltips.enable();
+ post_engine ();
- keyboard = new Keyboard;
+ return 0;
+}
+
+void
+ARDOUR_UI::post_engine ()
+{
+ /* 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 */
AudioFileSource::set_build_peakfiles (true);
AudioFileSource::set_build_missing_peakfiles (true);
- if (AudioSource::start_peak_thread ()) {
- throw failed_constructor();
+ /* set default clock modes */
+
+ 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 */
+#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 ()
{
save_ardour_state ();
- if (keyboard) {
- delete keyboard;
- }
-
- if (editor) {
- delete editor;
- }
-
- if (mixer) {
- delete mixer;
- }
+ delete keyboard;
+ delete editor;
+ delete mixer;
+ delete add_route_dialog;
+ delete new_session_dialog;
+}
- if (add_route_dialog) {
- delete add_route_dialog;
+void
+ARDOUR_UI::pop_back_splash ()
+{
+ if (Splash::instance()) {
+ // Splash::instance()->pop_back();
+ Splash::instance()->hide ();
}
-
- AudioSource::stop_peak_thread ();
}
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;
return FALSE;
}
+void
+ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
+{
+ const XMLProperty* prop;
+
+ if ((prop = node.property ("roll")) != 0) {
+ roll_controllable->set_id (prop->value());
+ }
+ if ((prop = node.property ("stop")) != 0) {
+ 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-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 ("play-selection")) != 0) {
+ play_selection_controllable->set_id (prop->value());
+ }
+ if ((prop = node.property ("rec")) != 0) {
+ rec_controllable->set_id (prop->value());
+ }
+ if ((prop = node.property ("shuttle")) != 0) {
+ shuttle_controllable->set_id (prop->value());
+ }
+}
+
+XMLNode&
+ARDOUR_UI::get_transport_controllable_state ()
+{
+ XMLNode* node = new XMLNode(X_("TransportControllables"));
+ char buf[64];
+
+ roll_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("roll"), buf);
+ stop_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("stop"), buf);
+ goto_start_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("goto_start"), buf);
+ goto_end_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("goto_end"), buf);
+ auto_loop_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("auto_loop"), buf);
+ play_selection_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("play_selection"), buf);
+ rec_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("rec"), buf);
+ shuttle_controllable->id().print (buf, sizeof (buf));
+ node->add_property (X_("shuttle"), buf);
+
+ return *node;
+}
+
void
ARDOUR_UI::save_ardour_state ()
{
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 ();
XMLNode enode(static_cast<Stateful*>(editor)->get_state());
XMLNode mnode(mixer->get_state());
if (session) {
- session->add_instant_xml (enode, session->path());
- session->add_instant_xml (mnode, session->path());
+ session->add_instant_xml (enode);
+ session->add_instant_xml (mnode);
+ } else {
+ Config->add_instant_xml (enode);
+ Config->add_instant_xml (mnode);
+ }
+
+ Keyboard::save_keybindings ();
+}
+
+gint
+ARDOUR_UI::autosave_session ()
+{
+ 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 (!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));
+
+ if (session->dirty()) {
+ if (_autosave_connection.connected()) {
+ _autosave_connection.disconnect();
+ }
+
+ _autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session),
+ Config->get_periodic_safety_backup_interval() * 1000);
+
} else {
- Config->add_instant_xml (enode, get_user_ardour_path());
- Config->add_instant_xml (mnode, get_user_ardour_path());
+ if (_autosave_connection.connected()) {
+ _autosave_connection.disconnect();
+ }
+ }
+}
+
+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);
}
- /* keybindings */
+ 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);
+ pop_back_splash ();
+
+ /* we just don't care about the result, but we want to block */
- AccelMap::save ("ardour.saved_bindings");
+ win.run ();
}
void
ARDOUR_UI::startup ()
{
- /* Once the UI is up and running, start the audio engine. Doing
- this before the UI is up and running can cause problems
- when not running with SCHED_FIFO, because the amount of
- CPU and disk work needed to get the UI started can interfere
- with the scheduling of the audio thread.
- */
+ string name, path;
+
+ new_session_dialog = new NewSessionDialog();
- Glib::signal_idle().connect (mem_fun(*this, &ARDOUR_UI::start_engine));
+ bool backend_audio_is_running = 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 (backend_audio_is_running, ARDOUR_COMMAND_LINE::new_session)) {
+ return;
+ }
+
+ BootMessage (_("Ardour is ready for use"));
+ show ();
}
void
-ARDOUR_UI::finish()
+ARDOUR_UI::no_memory_warning ()
+{
+ XMLNode node (X_("no-memory-warning"));
+ Config->add_instant_xml (node);
+}
+
+void
+ARDOUR_UI::check_memory_locking ()
{
- if (session && session->dirty()) {
- switch (ask_about_saving_session(_("quit"))) {
- case -1:
+#ifdef __APPLE__
+ /* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
+ return;
+#else // !__APPLE__
+
+ XMLNode* memory_warning_node = Config->instant_xml (X_("no-memory-warning"));
+
+ if (engine->is_realtime() && memory_warning_node == 0) {
+
+ struct rlimit limits;
+ int64_t ram;
+ long pages, page_size;
+
+ if ((page_size = sysconf (_SC_PAGESIZE)) < 0 ||(pages = sysconf (_SC_PHYS_PAGES)) < 0) {
+ ram = 0;
+ } else {
+ ram = (int64_t) pages * (int64_t) page_size;
+ }
+
+ if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
return;
- break;
- case 1:
- /* use the default name */
- if (save_state_canfail ("")) {
- /* failed - don't quit */
- MessageDialog msg (*editor,
- _("\
+ }
+
+ 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));
+
+ 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 ();
+ }
+ }
+ }
+#endif // !__APPLE__
+}
+
+
+void
+ARDOUR_UI::finish()
+{
+ 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;
+ pop_back_splash();
+ msg.run ();
+ return;
+ }
+ break;
+ case 0:
+ break;
}
- break;
- case 0:
- break;
}
+
+ session->set_deletion_in_progress ();
}
- Config->save_state();
+
+ ArdourDialog::close_all_dialogs ();
+ engine->stop (true);
+ 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);
window.set_position (Gtk::WIN_POS_MOUSE);
window.set_modal (true);
window.set_resizable (false);
- window.show_all ();
-
- save_the_session = 0;
- editor->ensure_float (window);
+ dhbox.show();
+ prompt_label.show();
+ dimage->show();
+ window.show();
+ window.set_keep_above (true);
+ window.present ();
ResponseType r = (ResponseType) window.run();
gint
ARDOUR_UI::every_point_zero_one_seconds ()
{
+ // august 2007: actual update frequency: 40Hz, not 100Hz
+
SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
return TRUE;
}
void
-ARDOUR_UI::update_sample_rate (jack_nframes_t ignored)
+ARDOUR_UI::update_sample_rate (nframes_t ignored)
{
char buf[32];
} else {
- jack_nframes_t rate = engine->frame_rate();
+ nframes_t rate = engine->frame_rate();
if (fmod (rate, 1000.0) != 0.0) {
- snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f msecs"),
+ 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 msecs"),
+ snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"),
rate/1000,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
}
ARDOUR_UI::update_cpu_load ()
{
char buf[32];
- snprintf (buf, sizeof (buf), _("DSP: %.1f%%"), engine->get_cpu_load());
+ snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load());
cpu_load_label.set_text (buf);
}
}
void
-ARDOUR_UI::count_recenabled_diskstreams (Route& route)
+ARDOUR_UI::count_recenabled_streams (Route& route)
{
Track* track = dynamic_cast<Track*>(&route);
- if (track && track->diskstream().record_enabled()) {
- rec_enabled_diskstreams++;
+ if (track && track->diskstream()->record_enabled()) {
+ rec_enabled_streams += track->n_inputs().n_total();
}
}
return;
}
- jack_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;
- jack_nframes_t fr = session->frame_rate();
+ rec_enabled_streams = 0;
+ session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
- if (session->actively_recording()){
-
- rec_enabled_diskstreams = 0;
- session->foreach_route (this, &ARDOUR_UI::count_recenabled_diskstreams);
-
- if (rec_enabled_diskstreams) {
- frames /= rec_enabled_diskstreams;
- }
-
- } else {
-
- /* hmmm. shall we divide by the route count? or the diskstream count?
- or what? for now, do nothing ...
- */
-
+ 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
return TRUE;
}
-void
-ARDOUR_UI::control_methods_adjusted ()
-
-{
- int which_method;
-
- which_method = (int) online_control_button->adjustment.get_value();
- switch (which_method) {
- case 0:
- allow_mmc_and_local ();
- break;
- case 1:
- allow_mmc_only ();
- break;
- case 2:
- allow_local_only ();
- break;
- default:
- fatal << _("programming error: impossible control method") << endmsg;
- }
-}
-
-
-void
-ARDOUR_UI::mmc_device_id_adjusted ()
-
-{
-#if 0
- if (mmc) {
- int dev_id = (int) mmc_id_button->adjustment.get_value();
- mmc->set_device_id (dev_id);
- }
-#endif
-}
gint
ARDOUR_UI::session_menu (GdkEventButton *ev)
void
ARDOUR_UI::redisplay_recent_sessions ()
{
- vector<string *> *sessions;
- vector<string *>::iterator i;
+ std::vector<sys::path> session_directories;
RecentSessionsSorter cmp;
recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
recent_session_model->clear ();
- RecentSessions rs;
+ ARDOUR::RecentSessions rs;
ARDOUR::read_recent_sessions (rs);
if (rs.empty()) {
recent_session_display.set_model (recent_session_model);
return;
}
-
- /* sort them alphabetically */
+ //
+ // sort them alphabetically
sort (rs.begin(), rs.end(), cmp);
- sessions = new vector<string*>;
-
- for (RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
- sessions->push_back (new string ((*i).second));
+
+ 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
- for (i = sessions->begin(); i != sessions->end(); ++i) {
+ get_state_files_in_directory (*i, state_file_paths);
vector<string*>* states;
vector<const gchar*> item;
- string fullpath = *(*i);
+ string fullpath = (*i).to_string();
/* remove any trailing / */
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));
- TreeModel::Row row = *(recent_session_model->append());
+ Gtk::TreeModel::Row row = *(recent_session_model->append());
row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
+
+ if (state_file_names.size() > 1) {
- if (states->size() > 1) {
+ // add the children
- /* add the children */
-
- for (vector<string*>::iterator i2 = states->begin(); i2 != states->end(); ++i2) {
-
- TreeModel::Row child_row = *(recent_session_model->append (row.children()));
+ for (std::vector<std::string>::iterator i2 = state_file_names.begin();
+ i2 != state_file_names.end(); ++i2)
+ {
- child_row[recent_session_columns.visible_name] = **i2;
- child_row[recent_session_columns.fullpath] = fullpath;
+ Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
- delete *i2;
+ child_row[recent_session_columns.visible_name] = *i2;
+ child_row[recent_session_columns.fullpath] = fullpath;
}
}
-
- delete states;
}
recent_session_display.set_model (recent_session_model);
- delete sessions;
}
void
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);
session_selector_window->set_name ("SessionSelectorWindow");
session_selector_window->set_size_request (200, 400);
session_selector_window->get_vbox()->pack_start (*scroller);
- session_selector_window->show_all_children();
+
+ recent_session_display.show();
+ scroller->show();
+ //session_selector_window->get_vbox()->show();
}
void
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
-ARDOUR_UI::filter_ardour_session_dirs (const FileFilter::Info& info)
+ARDOUR_UI::check_audioengine ()
{
- 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) {
+ if (engine) {
+ 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;
+ }
+ return true;
+ } else {
return false;
}
-
- return S_ISREG (statbuf.st_mode);
}
void
ARDOUR_UI::open_session ()
{
+ if (!check_audioengine()) {
+ return;
+
+ }
+
/* popup selector window */
if (open_session_selector == 0) {
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");
bool isnew;
if (session_path.length() > 0) {
- if (Session::find_session (session_path, path, name, isnew) == 0) {
+ if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
_session_is_new = isnew;
load_session (path, name);
}
void
-ARDOUR_UI::session_add_midi_track ()
+ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)
{
- cerr << _("Patience is a virtue.\n");
+ list<boost::shared_ptr<MidiTrack> > tracks;
+
+ if (session == 0) {
+ warning << _("You cannot add a track without a session already loaded.") << endmsg;
+ return;
+ }
+
+ try {
+ if (disk) {
+
+ tracks = session->new_midi_track (ARDOUR::Normal, how_many);
+
+ if (tracks.size() != how_many) {
+ if (how_many == 1) {
+ error << _("could not create a new midi track") << endmsg;
+ } else {
+ error << string_compose (_("could not create %1 new midi tracks"), how_many) << endmsg;
+ }
+ }
+ } /*else {
+ if ((route = session->new_midi_route ()) == 0) {
+ error << _("could not create new midi bus") << endmsg;
+ }
+ }*/
+ }
+
+ catch (...) {
+ 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."));
+ msg.run ();
+ }
}
+
void
-ARDOUR_UI::session_add_audio_route (bool disk, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode)
+ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, uint32_t how_many)
{
- boost::shared_ptr<Route> route;
+ list<boost::shared_ptr<AudioTrack> > tracks;
+ RouteList routes;
if (session == 0) {
- warning << _("You cannot add a track without a session already loaded.") << endmsg;
+ warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
return;
}
try {
- if (disk) {
- if ((route = session->new_audio_track (input_channels, output_channels, mode)) == 0) {
- error << _("could not create new audio track") << endmsg;
+ if (track) {
+ tracks = session->new_audio_track (input_channels, output_channels, mode, 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"),
+ tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
+ }
}
+
} else {
- if ((route = session->new_audio_route (input_channels, output_channels)) == 0) {
- error << _("could not create new audio bus") << endmsg;
+
+ routes = session->new_audio_route (input_channels, output_channels, how_many);
+
+ if (routes.size() != how_many) {
+ if (how_many == 1) {
+ error << _("could not create a new audio track") << endmsg;
+ } else {
+ error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
+ }
}
}
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::diskstream_added (Diskstream* ds)
-{
-}
-
-void
-ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
+ARDOUR_UI::do_transport_locate (nframes_t new_position)
{
- jack_nframes_t _preroll;
+ nframes_t _preroll = 0;
if (session) {
- _preroll = session->convert_to_frames_at (new_position, session->preroll);
+ // XXX CONFIG_CHANGE FIX - requires AnyTime handling
+ // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
if (new_position > _preroll) {
new_position -= _preroll;
}
void
-ARDOUR_UI::transport_goto_start ()
+ARDOUR_UI::transport_goto_start ()
{
if (session) {
session->goto_start();
*/
if (editor) {
- editor->reposition_x_origin (session->current_start_frame());
+ editor->reset_x_origin (session->current_start_frame());
}
}
}
*/
if (editor) {
- editor->reposition_x_origin (0);
+ 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->reset_x_origin (frames - (editor->current_page_frames()/2));
}
}
}
ARDOUR_UI::transport_goto_end ()
{
if (session) {
- jack_nframes_t frame = session->current_end_frame();
+ nframes_t frame = session->current_end_frame();
session->request_locate (frame);
/* force displayed area in editor to start no matter
*/
if (editor) {
- editor->reposition_x_origin (frame);
+ editor->reset_x_origin (frame);
}
}
}
return;
}
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (session->get_play_loop ()) {
+ session->request_play_loop (false);
}
session->request_stop ();
}
void
-ARDOUR_UI::transport_record ()
+ARDOUR_UI::transport_record (bool roll)
{
+
if (session) {
switch (session->record_status()) {
case Session::Disabled:
if (session->ntracks() == 0) {
- string txt = _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu.");
- MessageDialog msg (*editor, txt);
+ MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
msg.run ();
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 (true);
+ 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 ();
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
- auto_loop_button.set_active (false);
- roll_button.set_active (true);
+ //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);
+ roll_button.set_visual_state (1);
} else if (session->get_play_range ()) {
session->request_play_range (false);
- play_selection_button.set_active (false);
+ play_selection_button.set_visual_state (0);
} else if (rolling) {
session->request_locate (session->last_transport_start(), true);
}
ARDOUR_UI::transport_loop()
{
if (session) {
- if (session->get_auto_loop()) {
+ if (session->get_play_loop()) {
if (session->transport_rolling()) {
Location * looploc = session->locations()->auto_loop_location();
if (looploc) {
}
}
else {
- session->request_auto_loop (true);
+ session->request_play_loop (true);
}
}
}
Track* t;
if ((t = dynamic_cast<Track*>(r.get())) != 0) {
- t->diskstream().set_record_enabled (!t->diskstream().record_enabled());
+ t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
}
}
if (session == 0) {
}
}
-void
-ARDOUR_UI::allow_local_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_and_local ()
-{
-
-}
-
void
ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
{
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
}
-
void
ARDOUR_UI::engine_running ()
{
ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
+
+ Glib::RefPtr<Action> action;
+ const char* action_name = 0;
+
+ switch (engine->frames_per_cycle()) {
+ case 32:
+ action_name = X_("JACKLatency32");
+ break;
+ case 64:
+ action_name = X_("JACKLatency64");
+ break;
+ case 128:
+ action_name = X_("JACKLatency128");
+ break;
+ case 512:
+ action_name = X_("JACKLatency512");
+ break;
+ case 1024:
+ action_name = X_("JACKLatency1024");
+ break;
+ case 2048:
+ action_name = X_("JACKLatency2048");
+ break;
+ case 4096:
+ action_name = X_("JACKLatency4096");
+ break;
+ case 8192:
+ action_name = X_("JACKLatency8192");
+ break;
+ default:
+ /* XXX can we do anything useful ? */
+ break;
+ }
+
+ 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
_("\
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 ();
}
engine->start();
}
- catch (AudioEngine::PortRegistrationFailure& err) {
- engine->stop ();
- error << _("Unable to create all required ports")
- << endmsg;
- unload_session ();
- return -1;
- }
-
catch (...) {
engine->stop ();
error << _("Unable to start the session running")
return 0;
}
-gint
-ARDOUR_UI::start_engine ()
+void
+ARDOUR_UI::setup_theme ()
{
- if (do_engine_start () == 0) {
- if (session && _session_is_new) {
- /* we need to retain initial visual
- settings for a new session
- */
- session->save_state ("");
- session->save_history ("");
- }
-
- /* there is too much going on, in too many threads, for us to
- end up with a clean session. So wait 1 second after loading,
- and fix it up. its ugly, but until i come across a better
- solution, its what we have.
- */
-
- Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::make_session_clean), 1000);
- }
-
- return FALSE;
+ theme_manager->setup_theme();
}
void
ARDOUR_UI::update_clocks ()
{
- Clock (session->audible_frame()); /* EMIT_SIGNAL */
+ if (!editor || !editor->dragging_playhead()) {
+ Clock (session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
+ }
}
void
void
ARDOUR_UI::blink ()
{
- Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
+ Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
}
void
if (blink_timeout_tag < 0) {
blink_on = false;
- blink_timeout_tag = gtk_timeout_add (240, _blink, this);
+ blink_timeout_tag = g_timeout_add (240, _blink, this);
}
}
ARDOUR_UI::stop_blinking ()
{
if (blink_timeout_tag >= 0) {
- gtk_timeout_remove (blink_timeout_tag);
+ g_source_remove (blink_timeout_tag);
blink_timeout_tag = -1;
}
}
IO& io,
bool in)
{
+ vector<string> connections;
+
if (in) {
- if (io.n_inputs() == 0) {
+ if (io.n_inputs().n_total() == 0) {
buf = _("none");
return;
}
/* 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() == 0) {
+ if (io.n_outputs().n_total() == 0) {
buf = _("none");
return;
}
/* 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);
}
}
+/** Ask the user for the name of a new shapshot and then take it.
+ */
void
ARDOUR_UI::snapshot_session ()
{
ArdourPrompter prompter (true);
string snapname;
- string now;
+ char timebuf[128];
time_t n;
+ struct tm local_time;
time (&n);
- now = ctime (&n);
- now = now.substr (20, 4) + now.substr (3, 16) + " (" + now.substr (0, 3) + ")";
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
prompter.set_prompt (_("Name of New Snapshot"));
- prompter.set_initial_text (now);
+ prompter.set_initial_text (timebuf);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
}
if ((ret = session->save_state (name)) != 0) {
- session->save_history (name);
return ret;
}
}
}
void
-ARDOUR_UI::restore_state (string name)
+ARDOUR_UI::primary_clock_value_changed ()
{
if (session) {
- if (name.length() == 0) {
- name = session->name();
- }
- session->restore_state (name);
- session->restore_history (name);
+ session->request_locate (primary_clock.current_time ());
}
}
void
-ARDOUR_UI::primary_clock_value_changed ()
+ARDOUR_UI::big_clock_value_changed ()
{
if (session) {
- session->request_locate (primary_clock.current_time ());
+ session->request_locate (big_clock.current_time ());
}
}
}
}
-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)
{
switch (session->record_status()) {
case Session::Enabled:
if (onoff) {
- rec_button.set_state (1);
+ rec_button.set_visual_state (2);
} else {
- rec_button.set_state (0);
+ rec_button.set_visual_state (0);
}
break;
case Session::Recording:
- rec_button.set_state (2);
+ rec_button.set_visual_state (1);
break;
default:
- rec_button.set_state (0);
+ 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::start_keyboard_prefix ()
-{
- keyboard->start_prefix();
-}
-
void
ARDOUR_UI::save_template ()
ArdourPrompter prompter (true);
string name;
+ if (!check_audioengine()) {
+ return;
+ }
+
prompter.set_name (X_("Prompter"));
prompter.set_prompt (_("Name for mix template:"));
prompter.set_initial_text(session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
}
void
-ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
+ARDOUR_UI::edit_metadata ()
{
- m_new_session_dialog->show();
- m_new_session_dialog->set_modal(true);
- m_new_session_dialog->set_name(predetermined_path);
- m_new_session_dialog->reset_recent();
+ SessionMetadataEditor dialog;
+ dialog.set_session (session);
+ editor->ensure_float (dialog);
+ dialog.run ();
+}
- int response = Gtk::RESPONSE_CANCEL;
+void
+ARDOUR_UI::import_metadata ()
+{
+ SessionMetadataImporter dialog;
+ dialog.set_session (session);
+ editor->ensure_float (dialog);
+ dialog.run ();
+}
- do {
- response = m_new_session_dialog->run ();
- if(response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
- quit();
- return;
+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);
+ pop_back_splash ();
+ msg.show_all ();
+ msg.present ();
+ msg.run ();
+ }
+#endif
+}
- } else if (response == Gtk::RESPONSE_NONE) {
- /* Clear was pressed */
- m_new_session_dialog->reset();
+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;
- } else if (response == Gtk::RESPONSE_YES) {
- /* YES == OPEN, but there's no enum for that */
- std::string session_name = m_new_session_dialog->session_name();
- std::string session_path = m_new_session_dialog->session_folder();
- load_session (session_path, session_name);
+ if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_DIR)) {
+ session_path = cmdline_path;
+ existing_session = true;
+ } else if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_REGULAR)) {
+ session_path = Glib::path_get_dirname (string (cmdline_path));
+ existing_session = true;
+ } else {
+ /* it doesn't exist, assume the best */
+ session_path = Glib::path_get_dirname (string (cmdline_path));
+ }
+
+ session_name = basename_nosuffix (string (cmdline_path));
+}
+int
+ARDOUR_UI::load_cmdline_session (const Glib::ustring& session_name, const Glib::ustring& session_path, bool& existing_session)
+{
+ /* when this is called, the backend audio system must be running */
- } else if (response == Gtk::RESPONSE_OK) {
- if (m_new_session_dialog->get_current_page() == 1) {
+ /* 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.
+ */
- /* 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..
- */
- std::string session_name = m_new_session_dialog->session_name();
- std::string session_path = m_new_session_dialog->session_folder();
- load_session (session_path, session_name);
+ if (session_name.length() == 0 || session_path.length() == 0) {
+ return false;
+ }
+
+ if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
- } else {
+ Glib::ustring predicted_session_file;
+
+ predicted_session_file = session_path;
+ predicted_session_file += '/';
+ predicted_session_file += session_name;
+ predicted_session_file += ARDOUR::statefile_suffix;
+
+ if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) {
+ existing_session = true;
+ }
+
+ } else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) {
+
+ if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) {
+ /* existing .ardour file */
+ existing_session = true;
+ }
- _session_is_new = true;
-
- std::string session_name = m_new_session_dialog->session_name();
- std::string session_path = m_new_session_dialog->session_folder();
-
+ } else {
+ existing_session = false;
+ }
+
+ /* lets just try to load it */
+
+ if (create_engine ()) {
+ backend_audio_error (false, new_session_dialog);
+ 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_("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;
+ 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 (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();
+ }
+
+ if (build_session (session_path,
+ session_name,
+ cchns,
+ mchns,
+ iconnect,
+ oconnect,
+ nphysin,
+ nphysout,
+ engine->frame_rate() * 60 * 5)) {
+
+ return -1;
+ }
- //XXX This is needed because session constructor wants a
- //non-existant path. hopefully this will be fixed at some point.
+ return 0;
+}
+
+void
+ARDOUR_UI::end_loading_messages ()
+{
+ // hide_splash ();
+}
+
+void
+ARDOUR_UI::loading_message (const std::string& msg)
+{
+ show_splash ();
+ 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, bool offer_cancel)
+{
+ bool existing_session = false;
+ Glib::ustring session_name;
+ Glib::ustring session_path;
+ Glib::ustring template_name;
+ int response;
+
+ begin:
+ response = Gtk::RESPONSE_NONE;
+
+ if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
+
+ parse_cmdline_path (ARDOUR_COMMAND_LINE::session_name, session_name, session_path, existing_session);
+
+ /* don't ever reuse this */
+
+ ARDOUR_COMMAND_LINE::session_name = string();
+
+ if (existing_session && backend_audio_is_running) {
+
+ /* just load the thing already */
+
+ if (load_cmdline_session (session_name, session_path, existing_session) == 0) {
+ return true;
+ }
+ }
+
+ /* make the NSD use whatever information we have */
+
+ new_session_dialog->set_session_name (session_name);
+ new_session_dialog->set_session_folder (session_path);
+ }
+
+ /* loading failed, or we need the NSD for something */
+
+ new_session_dialog->set_modal (false);
+ 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();
+ new_session_dialog->set_offer_cancel (offer_cancel);
+
+ do {
+ new_session_dialog->set_have_engine (backend_audio_is_running);
+ new_session_dialog->present ();
+ end_loading_messages ();
+ response = new_session_dialog->run ();
+
+ _session_is_new = false;
+
+ /* 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 ();
+ return false;
- session_path = Glib::build_filename(session_path, session_name);
+ case Gtk::RESPONSE_NONE:
+ /* "Clear" was pressed */
+ goto try_again;
+ }
+
+ fontconfig_dialog();
+
+ if (!backend_audio_is_running) {
+ 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 ()) {
+
+ backend_audio_error (!backend_audio_is_running, new_session_dialog);
+ flush_pending ();
+
+ new_session_dialog->set_existing_session (false);
+ new_session_dialog->set_current_page (2);
+
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
+ backend_audio_is_running = true;
- std::string template_name = m_new_session_dialog->session_template_name();
+ if (response == Gtk::RESPONSE_OK) {
+
+ session_name = new_session_dialog->session_name();
+
+ if (session_name.empty()) {
+ response = Gtk::RESPONSE_NONE;
+ goto try_again;
+ }
+
+ /* if the user mistakenly typed path information into the session filename entry,
+ convert what they typed into a path & a name
+ */
- if (m_new_session_dialog->use_session_template()) {
-
- load_session (session_path, session_name, &template_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_path = Glib::path_get_dirname (session_name);
+ session_name = Glib::path_get_basename (session_name);
} else {
+
+ session_path = new_session_dialog->session_folder();
+ }
+
+ template_name = Glib::ustring();
+ switch (new_session_dialog->which_page()) {
+
+ case NewSessionDialog::OpenPage:
+ case NewSessionDialog::EnginePage:
+ goto loadit;
+ break;
+
+ case NewSessionDialog::NewPage: /* nominally the "new" session creator, but could be in use for an old session */
- uint32_t cchns;
- uint32_t mchns;
- Session::AutoConnectOption iconnect;
- Session::AutoConnectOption oconnect;
+ should_be_new = true;
- if (m_new_session_dialog->create_control_bus()) {
- cchns = (uint32_t) m_new_session_dialog->control_channel_count();
- } else {
- cchns = 0;
- }
+ //XXX This is needed because session constructor wants a
+ //non-existant path. hopefully this will be fixed at some point.
- if (m_new_session_dialog->create_master_bus()) {
- mchns = (uint32_t) m_new_session_dialog->master_channel_count();
- } else {
- mchns = 0;
+ 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 (ask_about_loading_existing_session (session_path)) {
+ goto loadit;
+ } else {
+ response = RESPONSE_NONE;
+ goto try_again;
+ }
}
-
- if (m_new_session_dialog->connect_inputs()) {
- iconnect = Session::AutoConnectPhysical;
+
+ _session_is_new = true;
+
+ if (new_session_dialog->use_session_template()) {
+
+ template_name = new_session_dialog->session_template_name();
+ goto loadit;
+
} else {
- iconnect = Session::AutoConnectOption (0);
+ if (build_session_from_nsd (session_path, session_name)) {
+ response = RESPONSE_NONE;
+ goto try_again;
+ }
+ goto done;
}
+ break;
- /// @todo some minor tweaks.
+ default:
+ break;
+ }
+
+ loadit:
+ new_session_dialog->hide ();
- if (m_new_session_dialog->connect_outs_to_master()) {
- oconnect = Session::AutoConnectMaster;
- } else if (m_new_session_dialog->connect_outs_to_physical()) {
- oconnect = Session::AutoConnectPhysical;
- } else {
- oconnect = Session::AutoConnectOption (0);
- }
-
- uint32_t nphysin = (uint32_t) m_new_session_dialog->input_limit_count();
- uint32_t nphysout = (uint32_t) m_new_session_dialog->output_limit_count();
-
- build_session (session_path,
- session_name,
- cchns,
- mchns,
- iconnect,
- oconnect,
- nphysin,
- nphysout,
- engine->frame_rate() * 60 * 5);
+ if (load_session (session_path, session_name, template_name)) {
+ /* force a retry */
+ response = Gtk::RESPONSE_NONE;
+ }
+
+ try_again:
+ if (response == Gtk::RESPONSE_NONE) {
+ new_session_dialog->set_existing_session (false);
+ new_session_dialog->reset ();
}
- }
}
-
- } while (response == Gtk::RESPONSE_NONE);
- m_new_session_dialog->hide();
- show();
-}
+ } while (response == Gtk::RESPONSE_NONE || response == Gtk::RESPONSE_REJECT);
+
+ done:
+ show();
+ new_session_dialog->hide();
+ new_session_dialog->reset();
+ goto_editor_window ();
+ return true;
+}
void
ARDOUR_UI::close_session()
{
- unload_session();
- new_session ();
+ if (!check_audioengine()) {
+ return;
+ }
+
+ 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;
- x = unload_session ();
- if (x < 0) {
+ if (!check_audioengine()) {
return -1;
- } else if (x > 0) {
- return 0;
+ }
+
+ 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)) {
- MessageDialog msg (*editor, _("\
-You do not have write access to this session.\n\
-This prevents the session from being loaded."));
+ 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 ();
- return -1;
+ 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;
+ }
+
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_CLOSE);
+
+ 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 ();
+
+ int response = msg.run ();
+
+ msg.hide ();
+
+ switch (response) {
+ case RESPONSE_CANCEL:
+ exit (1);
+ default:
+ break;
+ }
+ goto out;
}
connect_to_session (new_session);
- //if (engine->running()) {
- //mixer->show_window();
- //}
+ Config->set_current_owner (ConfigVariableBase::Interface);
+
session_loaded = true;
- return 0;
-}
+
+ goto_editor_window ();
-int
-ARDOUR_UI::make_session_clean ()
-{
if (session) {
session->set_clean ();
}
- show ();
+ flush_pending ();
+ retval = 0;
- return FALSE;
+ 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,
- Session::AutoConnectOption input_connect,
- Session::AutoConnectOption output_connect,
+ AutoConnectOption input_connect,
+ AutoConnectOption output_connect,
uint32_t nphysin,
uint32_t nphysout,
- jack_nframes_t initial_length)
+ nframes_t initial_length)
{
Session *new_session;
int x;
+ if (!check_audioengine()) {
+ return -1;
+ }
+
session_loaded = false;
+
x = unload_session ();
+
if (x < 0) {
return -1;
} else if (x > 0) {
catch (...) {
- error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
+ MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
+ pop_back_splash ();
+ msg.run ();
return -1;
}
connect_to_session (new_session);
- //if (engine->running()) {
- //mixer->show_window();
- //}
session_loaded = true;
+
+ new_session->save_state(new_session->name());
+
return 0;
}
{
if (editor) {
editor->show_window ();
+
+ if (!shown_flag) {
+ editor->present ();
+ }
+
shown_flag = true;
}
+}
- if (session && mixer) {
- // mixer->show_window ();
+void
+ARDOUR_UI::show_about ()
+{
+ if (about == 0) {
+ about = new About;
+ about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );
}
-
+
+ about->show_all ();
+}
+
+void
+ARDOUR_UI::hide_about ()
+{
if (about) {
- about->present ();
+ about->get_window()->set_cursor ();
+ about->hide ();
}
}
+void
+ARDOUR_UI::about_signal_response(int response)
+{
+ hide_about();
+}
+
void
ARDOUR_UI::show_splash ()
{
- if (about == 0) {
- about = new About();
+ if (splash == 0) {
+ try {
+ splash = new Splash;
+ } catch (...) {
+ return;
+ }
}
- about->present();
+
+ splash->show ();
+ splash->present ();
+ splash->queue_draw ();
+ splash->get_window()->process_updates (true);
+ flush_pending ();
}
void
ARDOUR_UI::hide_splash ()
{
- if (about) {
- // about->hide();
+ if (splash) {
+ splash->hide();
}
}
_("No audio files were ready for cleanup"),
true,
Gtk::MESSAGE_INFO,
- (Gtk::ButtonsType)(Gtk::BUTTONS_CLOSE) );
+ (Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
msgd.set_secondary_text (_("If this seems suprising, \n\
check for any existing snapshots.\n\
These may still include regions that\n\
dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
+ const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
+
if (rep.space < 1048576.0f) {
if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
+ 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"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
+ txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
}
} else {
if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
+ 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"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
+ txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
}
}
results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
results.set_default_response (RESPONSE_CLOSE);
results.set_position (Gtk::WIN_POS_MOUSE);
- results.show_all_children ();
+
+ results_display.show();
+ list_scroller.show();
+ txt.show();
+ dvbox.show();
+ dhbox.show();
+ ddhbox.show();
+ dimage->show();
+
+ //results.get_vbox()->show();
results.set_resizable (false);
results.run ();
checker.set_default_response (RESPONSE_CANCEL);
checker.set_name (_("CleanupDialog"));
- checker.set_wmclass (_("ardour_cleanup"), "Ardour");
+ checker.set_wmclass (X_("ardour_cleanup"), "Ardour");
checker.set_position (Gtk::WIN_POS_MOUSE);
switch (checker.run()) {
editor->prepare_for_cleanup ();
+ /* do not allow flush until a session is reloaded */
+
+ Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
+ if (act) {
+ act->set_sensitive (false);
+ }
+
if (session->cleanup_sources (rep)) {
+ editor->finish_cleanup ();
return;
}
+
+ editor->finish_cleanup ();
+
checker.hide();
display_cleanup_results (rep,
_("cleaned files"),
release an additional\n\
%4 %5bytes of disk space.\n"
));
+
}
void
}
void
-ARDOUR_UI::add_route ()
+ARDOUR_UI::add_route (Gtk::Window* float_window)
{
int count;
if (add_route_dialog == 0) {
add_route_dialog = new AddRouteDialog;
- editor->ensure_float (*add_route_dialog);
+ if (float_window) {
+ add_route_dialog->set_transient_for (*float_window);
+ }
}
if (add_route_dialog->is_visible()) {
}
ResponseType r = (ResponseType) add_route_dialog->run ();
-
+
add_route_dialog->hide();
switch (r) {
- case RESPONSE_ACCEPT:
- break;
- default:
- return;
- break;
+ case RESPONSE_ACCEPT:
+ break;
+ default:
+ return;
+ break;
}
if ((count = add_route_dialog->count()) <= 0) {
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
- Session::AutoConnectOption oac = session->get_output_auto_connect();
+ AutoConnectOption oac = Config->get_output_auto_connect();
- if (oac & Session::AutoConnectMaster) {
- output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
+ if (oac & AutoConnectMaster) {
+ output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan);
} else {
output_chan = input_chan;
}
/* XXX do something with name template */
-
- while (count) {
+
+ if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
- session_add_audio_track (input_chan, output_chan, add_route_dialog->mode());
- } else {
- session_add_audio_bus (input_chan, output_chan);
+ session_add_midi_track(count);
+ } else {
+ MessageDialog msg (*editor,
+ _("Sorry, MIDI Busses are not supported at this time."));
+ msg.run ();
+ //session_add_midi_bus();
}
- --count;
-
- while (Main::events_pending()) {
- Main::iteration ();
+ } else {
+ if (track) {
+ session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
+ } else {
+ session_add_audio_bus (input_chan, output_chan, count);
}
}
}
XMLNode* node = 0;
if (session) {
- node = session->instant_xml(X_("Mixer"), session->path());
+ node = session->instant_xml(X_("Mixer"));
} else {
- node = Config->instant_xml(X_("Mixer"), get_user_ardour_path());
+ node = Config->instant_xml(X_("Mixer"));
}
if (!node) {
XMLNode* node = 0;
if (session) {
- node = session->instant_xml(X_("Editor"), session->path());
+ node = session->instant_xml(X_("Editor"));
} else {
- node = Config->instant_xml(X_("Editor"), get_user_ardour_path());
+ 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::delete_sources_in_the_right_thread (list<ARDOUR::Source*>* deletion_list)
+void
+ARDOUR_UI::xrun_handler(nframes_t where)
{
- ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread), deletion_list));
+ if (!session) {
+ return;
+ }
+
+ ENSURE_GUI_THREAD (bind(mem_fun(*this, &ARDOUR_UI::xrun_handler), where));
- for (list<Source*>::iterator i = deletion_list->begin(); i != deletion_list->end(); ++i) {
- delete *i;
+ if (session && Config->get_create_xrun_marker() && session->actively_recording()) {
+ create_xrun_marker(where);
}
- delete deletion_list;
+ if (session && Config->get_stop_recording_on_xrun() && session->actively_recording()) {
+ halt_on_xrun_message ();
+ }
}
void
ARDOUR_UI::disk_overrun_handler ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
- if (!have_disk_overrun_displayed) {
- have_disk_overrun_displayed = true;
- MessageDialog msg (*editor, X_("diskrate dialog"), _("\
+ if (!have_disk_speed_dialog_displayed) {
+ have_disk_speed_dialog_displayed = true;
+ MessageDialog* msg = new MessageDialog (*editor, _("\
The disk system on your computer\n\
was not able to keep up with Ardour.\n\
\n\
Specifically, it failed to write data to disk\n\
quickly enough to keep up with recording.\n"));
- msg.run ();
- have_disk_overrun_displayed = false;
+ msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+ msg->show ();
}
}
{
ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
- if (!have_disk_underrun_displayed) {
- have_disk_underrun_displayed = true;
- MessageDialog msg (*editor,
- (_("The disk system on your computer\n\
+ if (!have_disk_speed_dialog_displayed) {
+ have_disk_speed_dialog_displayed = true;
+ MessageDialog* msg = new MessageDialog (*editor,
+ _("The disk system on your computer\n\
was not able to keep up with Ardour.\n\
\n\
Specifically, it failed to read data from disk\n\
-quickly enough to keep up with playback.\n")));
- msg.run ();
- have_disk_underrun_displayed = false;
+quickly enough to keep up with playback.\n"));
+ msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+ msg->show ();
}
}
void
-ARDOUR_UI::disk_underrun_message_gone ()
+ARDOUR_UI::disk_speed_dialog_gone (int ignored_response, MessageDialog* msg)
{
- have_disk_underrun_displayed = false;
+ have_disk_speed_dialog_displayed = false;
+ delete msg;
}
void
-ARDOUR_UI::disk_overrun_message_gone ()
+ARDOUR_UI::session_dialog (std::string msg)
{
- have_disk_underrun_displayed = false;
-}
+ 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 ()
{
- 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);
- dialog.show_all ();
-
+ message.show();
+ image->show();
+ hbox->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 ()
}
void
-ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
-{
- engine->request_buffer_size (nframes);
- update_sample_rate (0);
-}
-
-int
-ARDOUR_UI::cmdline_new_session (string path)
+ARDOUR_UI::use_config ()
{
- if (path[0] != '/') {
- char buf[PATH_MAX+1];
- string str;
+ Glib::RefPtr<Action> act;
- getcwd (buf, sizeof (buf));
- str = buf;
- str += '/';
- str += path;
- path = str;
+ 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;
}
- new_session (false, path);
-
- _will_create_new_session_automatically = false; /* done it */
- return FALSE; /* don't call it again */
-}
+ if (act) {
+ Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+ ract->set_active ();
+ }
-void
-ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
-{
- Glib::RefPtr<Action> act;
-
- switch (hf) {
+ switch (Config->get_native_file_header_format ()) {
case BWF:
act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
break;
if (act) {
Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
- Config->set_native_file_header_format (hf);
- if (session) {
- session->reset_native_file_format ();
- }
- }
+ ract->set_active ();
+ }
+
+ XMLNode* node = Config->extra_xml (X_("TransportControllables"));
+ if (node) {
+ set_transport_controllable_state (*node);
}
}
void
-ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
+ARDOUR_UI::update_transport_clocks (nframes_t pos)
{
- Glib::RefPtr<Action> act;
-
- switch (sf) {
- case FormatFloat:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
+ if (Config->get_primary_clock_delta_edit_cursor()) {
+ 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->get_preferred_edit_position(), 2);
+ } else {
+ secondary_clock.set (pos);
+ }
+
+ if (big_clock_window) {
+ big_clock.set (pos);
+ }
+}
+
+void
+ARDOUR_UI::record_state_changed ()
+{
+ ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed));
+
+ if (!session || !big_clock_window) {
+ /* why bother - the clock isn't visible */
+ return;
+ }
+
+ switch (session->record_status()) {
+ case Session::Recording:
+ big_clock.set_widget_name ("BigClockRecording");
break;
- case FormatInt24:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
+ default:
+ big_clock.set_widget_name ("BigClockNonRecording");
break;
}
+}
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
+bool
+ARDOUR_UI::first_idle ()
+{
+ if (session) {
+ session->allow_auto_play (true);
+ }
- if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
- Config->set_native_file_data_format (sf);
- if (session) {
- session->reset_native_file_format ();
- }
- }
+ if (editor) {
+ editor->first_idle();
}
+
+ Keyboard::set_can_save_keybindings (true);
+ return false;
}
void
-ARDOUR_UI::use_config ()
+ARDOUR_UI::store_clock_modes ()
{
- Glib::RefPtr<Action> act;
+ XMLNode* node = new XMLNode(X_("ClockModes"));
- switch (Config->get_native_file_data_format ()) {
- case FormatFloat:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
+ for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
+ node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
+ }
+
+ 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
+ARDOUR_UI::TransportControllable::set_value (float val)
+{
+ if (type == ShuttleControl) {
+ double fract;
+
+ if (val == 0.5f) {
+ fract = 0.0;
+ } else {
+ if (val < 0.5f) {
+ fract = -((0.5f - val)/0.5f);
+ } else {
+ fract = ((val - 0.5f)/0.5f);
+ }
+ }
+
+ ui.set_shuttle_fract (fract);
+ return;
+ }
+
+ if (val < 0.5f) {
+ /* do nothing: these are radio-style actions */
+ return;
+ }
+
+ const char *action = 0;
+
+ switch (type) {
+ case Roll:
+ action = X_("Roll");
break;
- case FormatInt24:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
+ case Stop:
+ action = X_("Stop");
+ break;
+ case GotoStart:
+ action = X_("Goto Start");
+ break;
+ case GotoEnd:
+ action = X_("Goto End");
+ break;
+ case AutoLoop:
+ action = X_("Loop");
+ break;
+ case PlaySelection:
+ action = X_("Play Selection");
+ break;
+ case RecordEnable:
+ action = X_("Record");
break;
+ default:
+ break;
+ }
+
+ if (action == 0) {
+ return;
}
+ Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", action);
+
if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
+ act->activate ();
+ }
+}
- switch (Config->get_native_file_header_format ()) {
- case BWF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
+float
+ARDOUR_UI::TransportControllable::get_value (void) const
+{
+ float val = 0.0f;
+
+ switch (type) {
+ case Roll:
break;
- case WAVE:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
+ case Stop:
break;
- case WAVE64:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
+ case GotoStart:
break;
- case iXML:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
+ case GotoEnd:
break;
- case RF64:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
+ case AutoLoop:
break;
- case CAF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
+ case PlaySelection:
break;
- case AIFF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
+ case RecordEnable:
+ break;
+ case ShuttleControl:
+ break;
+ default:
break;
}
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
+ return val;
+}
+
+void
+ARDOUR_UI::TransportControllable::set_id (const string& str)
+{
+ _id = str;
+}
+
+void
+ARDOUR_UI::setup_profile ()
+{
+ if (gdk_screen_width() < 1200) {
+ Profile->set_small_screen ();
+ }
+
+
+ if (getenv ("ARDOUR_SAE")) {
+ Profile->set_sae ();
+ Profile->set_single_package ();
+ }
}
+