*/
-#define __STDC_FORMAT_MACROS 1
+#ifdef WAF_BUILD
+#include "gtk2ardour-config.h"
+#endif
+
#include <stdint.h>
#include <algorithm>
#include "pbd/openuri.h"
#include "pbd/file_utils.h"
+#include "gtkmm2ext/application.h"
+#include "gtkmm2ext/bindings.h"
#include "gtkmm2ext/gtk_ui.h"
#include "gtkmm2ext/utils.h"
#include "gtkmm2ext/click_box.h"
typedef uint64_t microseconds_t;
+#include "about.h"
#include "actions.h"
+#include "add_route_dialog.h"
+#include "ambiguous_file_dialog.h"
#include "ardour_ui.h"
-#include "public_editor.h"
#include "audio_clock.h"
+#include "bundle_manager.h"
+#include "engine_dialog.h"
+#include "gain_meter.h"
+#include "global_port_matrix.h"
+#include "gui_thread.h"
#include "keyboard.h"
+#include "location_ui.h"
+#include "missing_file_dialog.h"
+#include "missing_plugin_dialog.h"
#include "mixer_ui.h"
-#include "prompter.h"
#include "opts.h"
-#include "add_route_dialog.h"
-#include "about.h"
-#include "splash.h"
-#include "utils.h"
-#include "gui_thread.h"
-#include "theme_manager.h"
-#include "bundle_manager.h"
-#include "session_metadata_dialog.h"
-#include "gain_meter.h"
+#include "processor_box.h"
+#include "prompter.h"
+#include "public_editor.h"
#include "route_time_axis.h"
+#include "session_metadata_dialog.h"
+#include "speaker_dialog.h"
+#include "splash.h"
#include "startup.h"
-#include "engine_dialog.h"
-#include "processor_box.h"
+#include "theme_manager.h"
#include "time_axis_view_item.h"
+#include "utils.h"
+#include "window_proxy.h"
#include "i18n.h"
sigc::signal<void,bool> ARDOUR_UI::Blink;
sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
-sigc::signal<void,nframes_t, bool, nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void, framepos_t, bool, framepos_t> ARDOUR_UI::Clock;
+
+bool could_be_a_valid_path (const string& path);
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
auditioning_alert_button (_("AUDITION")),
solo_alert_button (_("SOLO")),
- shown_flag (false),
+
error_log_button (_("Errors"))
{
session_loaded = false;
last_speed_displayed = -1.0f;
ignore_dual_punch = false;
- _mixer_on_top = false;
- original_big_clock_width = -1;
- original_big_clock_height = -1;
- original_big_clock_font_size = 0;
+ original_big_clock_width = -1;
+ original_big_clock_height = -1;
+ original_big_clock_font_size = 0;
roll_button.unset_flags (Gtk::CAN_FOCUS);
stop_button.unset_flags (Gtk::CAN_FOCUS);
shuttle_style_menu = 0;
shuttle_unit_menu = 0;
- // We do not have jack linked in yet so;
+ // We do not have jack linked in yet so;
last_shuttle_request = last_peak_grab = 0; // get_microseconds();
ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
+ /* handle requests to quit (coming from JACK session) */
+
+ ARDOUR::Session::Quit.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::finish, this), gui_context ());
+
+ /* handle requests to deal with missing files */
+
+ ARDOUR::Session::MissingFile.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::missing_file, this, _1, _2, _3));
+
+ /* and ambiguous files */
+
+ ARDOUR::FileSource::AmbiguousFileName.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::ambiguous_file, this, _1, _2, _3));
+
/* lets get this party started */
try {
keyboard = new ArdourKeyboard(*this);
+
XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
if (node) {
keyboard->set_state (*node, Stateful::loading_state_version);
}
+ /* we don't like certain modifiers */
+ Bindings::set_ignored_state (GDK_LOCK_MASK|GDK_MOD2_MASK|GDK_MOD3_MASK);
+
reset_dpi();
- TimeAxisViewItem::set_constant_heights ();
+ TimeAxisViewItem::set_constant_heights ();
+
+ /* The following must happen after ARDOUR::init() so that Config is set up */
+
+ location_ui = new ActionWindowProxy<LocationUIWindow> (X_("locations"), Config->extra_xml (X_("UI")), X_("ToggleLocations"));
+ big_clock_window = new ActionWindowProxy<Gtk::Window> (X_("bigclock"), Config->extra_xml (X_("UI")), X_("ToggleBigClock"));
+ speaker_config_window = new ActionWindowProxy<SpeakerDialog> (X_("speakerconf"), Config->extra_xml (X_("UI")), X_("toggle-speaker-config"));
+
+ for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
+ _global_port_matrix[*i] = new ActionWindowProxy<GlobalPortMatrixWindow> (
+ string_compose ("GlobalPortMatrix-%1", (*i).to_string()),
+ Config->extra_xml (X_("UI")),
+ string_compose ("toggle-%1-connection-manager", (*i).to_string())
+ );
+ }
+
+ setup_clock ();
+ speaker_config_window->set (new SpeakerDialog);
starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
}
_startup->set_new_only (should_be_new);
- if (!load_template.empty()) {
- _startup->set_load_template( load_template );
- }
+ if (!load_template.empty()) {
+ _startup->set_load_template( load_template );
+ }
_startup->present ();
main().run();
engine->Halted.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
- ARDOUR::Port::set_connecting_blocked (ARDOUR_COMMAND_LINE::no_connect_ports);
+ ARDOUR::Port::set_connecting_blocked (ARDOUR_COMMAND_LINE::no_connect_ports);
post_engine ();
if (ARDOUR_COMMAND_LINE::show_key_actions) {
vector<string> names;
vector<string> paths;
+ vector<string> tooltips;
vector<string> keys;
vector<AccelKey> bindings;
- ActionManager::get_all_actions (names, paths, keys, bindings);
+ ActionManager::get_all_actions (names, paths, tooltips, keys, bindings);
vector<string>::iterator n;
vector<string>::iterator k;
return true;
} else {
have_configure_timeout = false;
- cerr << "config event-driven save\n";
+ cerr << "config event-driven save\n";
save_ardour_state ();
return false;
}
return 1;
}
- if (!Config->get_periodic_safety_backups()) {
- return 1;
+ if (!Config->get_periodic_safety_backups()) {
+ return 1;
}
- if (_session) {
- _session->maybe_write_autosave();
- }
+ if (_session) {
+ _session->maybe_write_autosave();
+ }
return 1;
}
void
ARDOUR_UI::startup ()
{
+ Application* app = Application::instance ();
+
+ app->ShouldQuit.connect (sigc::mem_fun (*this, &ARDOUR_UI::queue_finish));
+ app->ShouldLoad.connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_load));
#ifdef PHONE_HOME
- call_the_mothership (VERSIONSTRING);
+ call_the_mothership (VERSIONSTRING);
#endif
+ app->ready ();
+
if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session, ARDOUR_COMMAND_LINE::load_template)) {
exit (1);
}
goto_editor_window ();
+ /* Add the window proxies here; their addition may cause windows to be opened, and we want them
+ to be opened on top of the editor window that goto_editor_window() just opened.
+ */
+ add_window_proxy (location_ui);
+ add_window_proxy (big_clock_window);
+ for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
+ add_window_proxy (_global_port_matrix[*i]);
+ }
+
BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
- show ();
}
void
if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
- MessageDialog msg (string_compose (_("WARNING: Your system has a limit for maximum amount of locked memory. "
- "This might cause %1 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"),
- PROGRAM_NAME).c_str());
+ MessageDialog msg (
+ string_compose (_("WARNING: Your system has a limit for maximum amount of locked memory. "
+ "This might cause %1 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"),
+ PROGRAM_NAME).c_str());
VBox* vbox = msg.get_vbox();
HBox hbox;
ARDOUR_UI::finish()
{
if (_session) {
- int tries = 0;
+ int tries = 0;
if (_session->transport_rolling() && (++tries < 8)) {
_session->request_stop (false, true);
point_one_second_connection.disconnect ();
point_oh_five_second_connection.disconnect ();
point_zero_one_second_connection.disconnect();
-
- _session->set_clean ();
+ }
+
+ /* Save state before deleting the session, as that causes some
+ windows to be destroyed before their visible state can be
+ saved.
+ */
+ save_ardour_state ();
+
+ if (_session) {
// _session->set_deletion_in_progress ();
+ _session->set_clean ();
_session->remove_pending_capture_state ();
delete _session;
_session = 0;
}
- cerr << "Save before quit\n";
- save_ardour_state ();
-
ArdourDialog::close_all_dialogs ();
engine->stop (true);
quit ();
}
void
-ARDOUR_UI::update_sample_rate (nframes_t)
+ARDOUR_UI::update_sample_rate (framecnt_t)
{
char buf[32];
} else {
- nframes_t rate = engine->frame_rate();
+ framecnt_t rate = engine->frame_rate();
if (fmod (rate, 1000.0) != 0.0) {
snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"),
(float) rate/1000.0f,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
} else {
- snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"),
+ snprintf (buf, sizeof (buf), _("%" PRId64 " kHz / %4.1f ms"),
rate/1000,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
}
return;
}
- nframes_t frames = _session->available_capture_duration();
+ framecnt_t frames = _session->available_capture_duration();
char buf[64];
- nframes_t fr = _session->frame_rate();
+ framecnt_t fr = _session->frame_rate();
- if (frames == max_frames) {
+ if (frames == max_framecnt) {
strcpy (buf, _("Disk: 24hrs+"));
} else {
rec_enabled_streams = 0;
sort (rs.begin(), rs.end(), cmp);
for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
- session_directories.push_back ((*i).second);
+ session_directories.push_back ((*i).second);
}
for (vector<sys::path>::const_iterator i = session_directories.begin();
return;
}
- Glib::ustring path = (*i)[recent_session_columns.fullpath];
- Glib::ustring state = (*i)[recent_session_columns.visible_name];
+ std::string path = (*i)[recent_session_columns.fullpath];
+ std::string state = (*i)[recent_session_columns.visible_name];
_session_is_new = false;
if (engine) {
if (!engine->connected()) {
MessageDialog msg (string_compose (_("%1 is not connected to JACK\n"
- "You cannot open or close sessions in this condition"),
- PROGRAM_NAME));
+ "You cannot open or close sessions in this condition"),
+ PROGRAM_NAME));
pop_back_splash ();
msg.run ();
return false;
void
-ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many)
+ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many, string const & name_template)
{
list<boost::shared_ptr<MidiTrack> > tracks;
try {
if (disk) {
- tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many);
+ tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many, name_template);
if (tracks.size() != how_many) {
if (how_many == 1) {
void
-ARDOUR_UI::session_add_audio_route (bool track, bool aux, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+ARDOUR_UI::session_add_audio_route (
+ bool track,
+ int32_t input_channels,
+ int32_t output_channels,
+ ARDOUR::TrackMode mode,
+ RouteGroup* route_group,
+ uint32_t how_many,
+ string const & name_template
+ )
{
list<boost::shared_ptr<AudioTrack> > tracks;
RouteList routes;
try {
if (track) {
- tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
+ tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many, name_template);
if (tracks.size() != how_many) {
if (how_many == 1) {
} else {
- routes = _session->new_audio_route (aux, input_channels, output_channels, route_group, how_many);
+ routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many, name_template);
if (routes.size() != how_many) {
if (how_many == 1) {
}
void
-ARDOUR_UI::do_transport_locate (nframes_t new_position)
+ARDOUR_UI::do_transport_locate (framepos_t new_position, bool with_roll)
{
- nframes_t _preroll = 0;
+ framecnt_t _preroll = 0;
if (_session) {
// XXX CONFIG_CHANGE FIX - requires AnyTime handling
new_position = 0;
}
- _session->request_locate (new_position);
+ _session->request_locate (new_position, with_roll);
}
}
time_t now;
struct tm tmnow;
- nframes64_t frames;
+ framepos_t frames;
time (&now);
localtime_r (&now, &tmnow);
ARDOUR_UI::transport_goto_end ()
{
if (_session) {
- nframes_t const frame = _session->current_end_frame();
+ framepos_t const frame = _session->current_end_frame();
_session->request_locate (frame);
/* force displayed area in editor to start no matter
if (_session->is_auditioning()) {
return;
}
-
+
+#if 0
if (_session->config.get_external_sync()) {
switch (_session->config.get_sync_source()) {
case JACK:
return;
}
}
+#endif
bool rolling = _session->transport_rolling();
/* XXX it is not possible to just leave seamless loop and keep
playing at present (nov 4th 2009)
*/
- if (!Config->get_seamless_loop()) {
- _session->request_play_loop (false, true);
- }
+ if (!Config->get_seamless_loop()) {
+ _session->request_play_loop (false, true);
+ }
} else if (_session->get_play_range () && !join_play_range_button.get_active()) {
/* stop playing a range if we currently are */
_session->request_play_range (0, true);
return;
}
+#if 0
if (_session->config.get_external_sync()) {
switch (_session->config.get_sync_source()) {
case JACK:
return;
}
}
+#endif
bool rolling = _session->transport_rolling();
bool affect_transport = true;
_session->request_play_loop (false, true);
} else if (_session->get_play_range ()) {
affect_transport = false;
- _session->request_play_range (0, true);
+ _session->request_play_range (0, true);
}
}
void
ARDOUR_UI::toggle_session_auto_loop ()
{
- if (_session) {
- if (_session->get_play_loop()) {
- if (_session->transport_rolling()) {
- Location * looploc = _session->locations()->auto_loop_location();
- if (looploc) {
- _session->request_locate (looploc->start(), true);
- }
- } else {
- _session->request_play_loop (false);
- }
- } else {
+ if (!_session) {
+ return;
+ }
+
+ if (_session->get_play_loop()) {
+
+ if (_session->transport_rolling()) {
+
Location * looploc = _session->locations()->auto_loop_location();
+
if (looploc) {
- _session->request_play_loop (true);
+ _session->request_locate (looploc->start(), true);
+ _session->request_play_loop (false);
}
+
+ } else {
+ _session->request_play_loop (false);
+ }
+ } else {
+
+ Location * looploc = _session->locations()->auto_loop_location();
+
+ if (looploc) {
+ _session->request_play_loop (true);
}
}
}
void
ARDOUR_UI::engine_halted (const char* reason, bool free_reason)
{
- if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) {
- /* we can't rely on the original string continuing to exist when we are called
- again in the GUI thread, so make a copy and note that we need to
- free it later.
- */
- char *copy = strdup (reason);
- Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&ARDOUR_UI::engine_halted, this, copy, true));
- return;
- }
+ if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) {
+ /* we can't rely on the original string continuing to exist when we are called
+ again in the GUI thread, so make a copy and note that we need to
+ free it later.
+ */
+ char *copy = strdup (reason);
+ Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&ARDOUR_UI::engine_halted, this, copy, true));
+ return;
+ }
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
update_sample_rate (0);
- string msgstr;
+ string msgstr;
/* if the reason is a non-empty string, it means that the backend was shutdown
rather than just Ardour.
pop_back_splash ();
msg.run ();
- if (free_reason) {
- free ((char*) reason);
- }
+ if (free_reason) {
+ free ((char*) reason);
+ }
}
int32_t
prompter.set_title (_("Take Snapshot"));
prompter.set_prompt (_("Name of new snapshot"));
- if (!switch_to_it) {
- char timebuf[128];
- time_t n;
- struct tm local_time;
+ if (!switch_to_it) {
+ char timebuf[128];
+ time_t n;
+ struct tm local_time;
- time (&n);
- localtime_r (&n, &local_time);
- strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
- prompter.set_initial_text (timebuf);
- }
+ time (&n);
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
+ prompter.set_initial_text (timebuf);
+ }
again:
switch (prompter.run()) {
bool do_save = (snapname.length() != 0);
- if (do_save) {
- if (snapname.find ('/') != string::npos) {
- MessageDialog msg (_("To ensure compatibility with various systems\n"
- "snapshot names may not contain a '/' character"));
- msg.run ();
- goto again;
- }
- if (snapname.find ('\\') != string::npos) {
- MessageDialog msg (_("To ensure compatibility with various systems\n"
- "snapshot names may not contain a '\\' character"));
- msg.run ();
- goto again;
- }
- }
+ if (do_save) {
+ if (snapname.find ('/') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "snapshot names may not contain a '/' character"));
+ msg.run ();
+ goto again;
+ }
+ if (snapname.find ('\\') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "snapshot names may not contain a '\\' character"));
+ msg.run ();
+ goto again;
+ }
+ }
vector<sys::path> p;
get_state_files_in_directory (_session->session_directory().root_path(), p);
void
ARDOUR_UI::save_state (const string & name, bool switch_to_it)
{
+ XMLNode* node = new XMLNode (X_("UI"));
+
+ for (list<WindowProxyBase*>::iterator i = _window_proxies.begin(); i != _window_proxies.end(); ++i) {
+ if (!(*i)->rc_configured()) {
+ node->add_child_nocopy (*((*i)->get_state ()));
+ }
+ }
+
+ _session->add_extra_xml (*node);
+
save_state_canfail (name, switch_to_it);
}
return ret;
}
}
- cerr << "SS canfail\n";
+ cerr << "SS canfail\n";
save_ardour_state (); /* XXX cannot fail? yeah, right ... */
return 0;
}
return;
}
- if (_session->step_editing()) {
- return;
- }
+ if (_session->step_editing()) {
+ return;
+ }
Session::RecordState const r = _session->record_status ();
bool const h = _session->have_rec_enabled_track ();
}
prompter.set_name (X_("Prompter"));
- prompter.set_title (_("Save Mix Template"));
- prompter.set_prompt (_("Name for mix template:"));
+ prompter.set_title (_("Save Template"));
+ prompter.set_prompt (_("Name for template:"));
prompter.set_initial_text(_session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
may not and it can take a while to build it. Warn them.
*/
- Glib::ustring fontconfig = Glib::build_filename (Glib::get_home_dir(), ".fontconfig");
+ std::string fontconfig = Glib::build_filename (Glib::get_home_dir(), ".fontconfig");
if (!Glib::file_test (fontconfig, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
MessageDialog msg (*_startup,
- string_compose (_("Welcome to %1.\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"), PROGRAM_NAME),
- true,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_OK);
+ string_compose (_("Welcome to %1.\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"), PROGRAM_NAME),
+ true,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_OK);
pop_back_splash ();
msg.show_all ();
msg.present ();
}
void
-ARDOUR_UI::parse_cmdline_path (const Glib::ustring& cmdline_path, Glib::ustring& session_name, Glib::ustring& session_path, bool& existing_session)
+ARDOUR_UI::parse_cmdline_path (const std::string& cmdline_path, std::string& session_name, std::string& session_path, bool& existing_session)
{
existing_session = false;
}
int
-ARDOUR_UI::load_cmdline_session (const Glib::ustring& session_name, const Glib::ustring& session_path, bool& existing_session)
+ARDOUR_UI::load_cmdline_session (const std::string& session_name, const std::string& session_path, bool& existing_session)
{
/* when this is called, the backend audio system must be running */
if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
- Glib::ustring predicted_session_file;
+ std::string predicted_session_file;
predicted_session_file = session_path;
predicted_session_file += '/';
}
bool
-ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path)
+ARDOUR_UI::ask_about_loading_existing_session (const std::string& session_path)
{
- Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
+ std::string str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
MessageDialog msg (str,
false,
}
int
-ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& session_name)
+ARDOUR_UI::build_session_from_nsd (const std::string& session_path, const std::string& session_name)
{
- BusProfile bus_profile;
+ BusProfile bus_profile;
if (Profile->get_sae()) {
}
void
-ARDOUR_UI::idle_load (const Glib::ustring& path)
+ARDOUR_UI::idle_load (const std::string& path)
{
if (_session) {
if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
int
ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new, string load_template)
{
- Glib::ustring session_name;
- Glib::ustring session_path;
- Glib::ustring template_name;
+ string session_name;
+ string session_path;
+ string template_name;
int ret = -1;
bool likely_new = false;
- if (! load_template.empty()) {
- should_be_new = true;
- template_name = load_template;
- }
+ if (! load_template.empty()) {
+ should_be_new = true;
+ template_name = load_template;
+ }
while (ret != 0) {
} else {
bool const apply = run_startup (should_be_new, load_template);
+
if (!apply) {
if (quit_on_cancel) {
exit (1);
/* this shouldn't happen, but we catch it just in case it does */
if (session_name.empty()) {
- break;
+ continue;
}
+
if (_startup->use_session_template()) {
template_name = _startup->session_template_name();
_session_is_new = true;
}
- if (session_name[0] == '/' ||
- (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
- (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
+ if (session_name[0] == G_DIR_SEPARATOR ||
+ (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == G_DIR_SEPARATOR) ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == G_DIR_SEPARATOR)) {
- /* absolute path or cwd-relative path specified for session name: infer session folder
- from what was given.
- */
+ /* absolute path or cwd-relative path specified for session name: infer session folder
+ from what was given.
+ */
session_path = Glib::path_get_dirname (session_name);
session_name = Glib::path_get_basename (session_name);
} else {
session_path = _startup->session_folder();
+
+ if (session_name.find ('/') != string::npos) {
+ MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
+
+ if (session_name.find ('\\') != string::npos) {
+ MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
}
}
if (likely_new) {
- Glib::ustring existing = Glib::build_filename (session_path, session_name);
+ std::string existing = Glib::build_filename (session_path, session_name);
if (!ask_about_loading_existing_session (existing)) {
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
}
- if (session_name.find ('/') != Glib::ustring::npos) {
- MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
- "session names may not contain a '/' character"));
- msg.run ();
+ if (session_name.find ('/') != std::string::npos) {
+ MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
+ msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
- continue;
- }
+ continue;
+ }
- if (session_name.find ('\\') != Glib::ustring::npos) {
- MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
- "session names may not contain a '\\' character"));
- msg.run ();
+ if (session_name.find ('\\') != std::string::npos) {
+ MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
+ msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
- continue;
- }
+ continue;
+ }
_session_is_new = true;
}
} else {
ret = load_session (session_path, session_name, template_name);
+
+ if (ret == -2) {
+ /* not connected to the AudioEngine, so quit to avoid an infinite loop */
+ exit (1);
+ }
+
if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
_session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
exit (1);
}
if (unload_session (true)) {
- return;
- }
+ return;
+ }
ARDOUR_COMMAND_LINE::session_name = "";
}
goto_editor_window ();
- show ();
}
+/** @return -2 if the load failed because we are not connected to the AudioEngine */
int
-ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_name, Glib::ustring mix_template)
+ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name, std::string mix_template)
{
Session *new_session;
int unload_status;
session_loaded = false;
if (!check_audioengine()) {
- return -1;
+ return -2;
}
unload_status = unload_session ();
goto out;
}
- loading_message (string_compose (_("Please wait while %1loads your session"), PROGRAM_NAME));
+ loading_message (string_compose (_("Please wait while %1 loads your session"), PROGRAM_NAME));
try {
new_session = new Session (*engine, path, snap_name, 0, mix_template);
catch (...) {
- MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name),
- true,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_CLOSE);
+ MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"),path, snap_name),
+ true,
+ Gtk::MESSAGE_INFO,
+ BUTTONS_OK);
msg.set_title (_("Loading Error"));
- msg.set_secondary_text (_("Click the Close button to try again."));
+ msg.set_secondary_text (_("Click the Refresh button to try again."));
+ msg.add_button (Stock::REFRESH, 1);
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:
+ case 1:
break;
+ default:
+ exit (1);
}
+
+ msg.hide ();
+
goto out;
}
+ {
+ list<string> const u = new_session->unknown_processors ();
+ if (!u.empty()) {
+ MissingPluginDialog d (_session, u);
+ d.run ();
+ }
+ }
+
/* Now the session been created, add the transport controls */
new_session->add_controllable(roll_controllable);
new_session->add_controllable(stop_controllable);
}
int
-ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name, BusProfile& bus_profile)
+ARDOUR_UI::build_session (const std::string& path, const std::string& snap_name, BusProfile& bus_profile)
{
Session *new_session;
int x;
return -1;
}
+ /* Give the new session the default GUI state, if such things exist */
+
+ XMLNode* n;
+ n = Config->instant_xml (X_("Editor"));
+ if (n) {
+ new_session->add_instant_xml (*n, false);
+ }
+ n = Config->instant_xml (X_("Mixer"));
+ if (n) {
+ new_session->add_instant_xml (*n, false);
+ }
+
+ /* Put the playhead at 0 and scroll fully left */
+ n = new_session->instant_xml (X_("Editor"));
+ if (n) {
+ n->add_property (X_("playhead"), X_("0"));
+ n->add_property (X_("left-frame"), X_("0"));
+ }
+
set_session (new_session);
session_loaded = true;
return 0;
}
-void
-ARDOUR_UI::show ()
-{
- if (editor) {
- editor->show_window ();
-
- if (!shown_flag) {
- editor->present ();
- }
-
- shown_flag = true;
- }
-}
-
void
ARDOUR_UI::launch_chat ()
{
#ifdef __APPLE__
- open_uri("http://webchat.freenode.net/?channels=ardour-osx");
+ open_uri("http://webchat.freenode.net/?channels=ardour-osx");
#else
- open_uri("http://webchat.freenode.net/?channels=ardour");
+ open_uri("http://webchat.freenode.net/?channels=ardour");
#endif
}
about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) );
}
- about->set_transient_for(*editor);
+ about->set_transient_for(*editor);
about->show_all ();
}
ARDOUR_UI::hide_about ()
{
if (about) {
- about->get_window()->set_cursor ();
+ about->get_window()->set_cursor ();
about->hide ();
}
}
if (removed == 0) {
MessageDialog msgd (*editor,
- _("No audio files were ready for cleanup"),
+ _("No files were ready for cleanup"),
true,
Gtk::MESSAGE_INFO,
(Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
add (visible_name);
add (fullpath);
}
- Gtk::TreeModelColumn<Glib::ustring> visible_name;
- Gtk::TreeModelColumn<Glib::ustring> fullpath;
+ Gtk::TreeModelColumn<std::string> visible_name;
+ Gtk::TreeModelColumn<std::string> fullpath;
};
dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
- const string dead_sound_directory = _session->session_directory().dead_sound_path().to_string();
+ const string dead_directory = _session->session_directory().dead_path().to_string();
/* subst:
%1 - number of files removed
- %2 - location of "dead_sounds"
+ %2 - location of "dead"
%3 - size of files affected
%4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
*/
const char* bprefix;
- double space_adjusted = 0;
-
- if (rep.space < 100000.0f) {
- bprefix = X_("kilo");
- } else if (rep.space < 1000000.0f * 1000) {
+ double space_adjusted = 0;
+
+ if (rep.space < 1000) {
+ bprefix = X_("");
+ space_adjusted = rep.space;
+ } else if (rep.space < 1000000) {
+ bprefix = X_("kilo");
+ space_adjusted = truncf((float)rep.space / 1000.0);
+ } else if (rep.space < 1000000 * 1000) {
bprefix = X_("mega");
- space_adjusted = truncf((float)rep.space / 1000.0);
+ space_adjusted = truncf((float)rep.space / (1000.0 * 1000.0));
} else {
bprefix = X_("giga");
- space_adjusted = truncf((float)rep.space / (1000000.0 * 1000));
+ space_adjusted = truncf((float)rep.space / (1000.0 * 1000 * 1000.0));
}
if (removed > 1) {
- txt.set_text (string_compose (plural_msg, removed, _session->path() + "dead_sounds", space_adjusted, bprefix));
+ txt.set_text (string_compose (plural_msg, removed, dead_directory, space_adjusted, bprefix));
} else {
- txt.set_text (string_compose (singular_msg, removed, _session->path() + "dead_sounds", space_adjusted, bprefix));
+ txt.set_text (string_compose (singular_msg, removed, dead_directory, space_adjusted, bprefix));
}
dhbox.pack_start (*dimage, true, false, 5);
results.run ();
-}
+}
void
ARDOUR_UI::cleanup ()
checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
ALL undo/redo information will be lost if you cleanup.\n\
-After cleanup, unused audio files will be moved to a \
-\"dead sounds\" location."));
+Cleanup will move all unused files to a \"dead\" location."));
checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
_("cleaned files"),
_("\
The following %1 files were not in use and \n\
-have been moved to:\n\
-%2. \n\n\
-Flushing the wastebasket will \n\
-release an additional\n\
+have been moved to:\n\n\
+%2\n\n\
+After a restart of Ardour,\n\n\
+Session -> Cleanup -> Flush Wastebasket\n\n\
+will release an additional\n\
%3 %4bytes of disk space.\n"),
_("\
The following file was not in use and \n \
has been moved to:\n \
-%2. \n\n\
-Flushing the wastebasket will \n\
-release an additional\n\
+%2\n\n\
+After a restart of Ardour,\n\n\
+Session -> Cleanup -> Flush Wastebasket\n\n\
+will release an additional\n\
%3 %4bytes of disk space.\n"
));
uint32_t output_chan;
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
- bool aux = !track && add_route_dialog->aux();
RouteGroup* route_group = add_route_dialog->route_group ();
AutoConnectOption oac = Config->get_output_auto_connect();
if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
- session_add_midi_track (route_group, count);
+ session_add_midi_track (route_group, count, name_template);
} else {
MessageDialog msg (*editor,
_("Sorry, MIDI Busses are not supported at this time."));
}
} else {
if (track) {
- session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
+ session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count, name_template);
} else {
- session_add_audio_bus (aux, input_chan, output_chan, route_group, count);
+ session_add_audio_bus (input_chan, output_chan, route_group, count, name_template);
}
}
}
} 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_("Keyboard"));
}
+
return node;
}
void
-ARDOUR_UI::create_xrun_marker(nframes_t where)
+ARDOUR_UI::create_xrun_marker (framepos_t where)
{
editor->mouse_add_new_marker (where, false, true);
}
}
void
-ARDOUR_UI::xrun_handler(nframes_t where)
+ARDOUR_UI::xrun_handler (framepos_t where)
{
if (!_session) {
return;
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
MessageDialog* msg = new MessageDialog (*editor,
- string_compose (_("The disk system on your computer\n\
+ string_compose (_("The disk system on your computer\n\
was not able to keep up with %1.\n\
\n\
Specifically, it failed to read data from disk\n\
}
int
-ARDOUR_UI::sr_mismatch_dialog (nframes_t desired, nframes_t actual)
+ARDOUR_UI::sr_mismatch_dialog (framecnt_t desired, framecnt_t actual)
{
HBox* hbox = new HBox();
Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
void
ARDOUR_UI::use_config ()
{
-
XMLNode* node = Config->extra_xml (X_("TransportControllables"));
if (node) {
set_transport_controllable_state (*node);
}
-
- node = Config->extra_xml (X_("UI"));
-
- if (node) {
- const XMLProperty* prop = node->property (X_("show-big-clock"));
- Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleBigClock"));
- if (act) {
- Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- tact->set_active (string_is_affirmative (prop->value()));
- }
- }
}
void
-ARDOUR_UI::update_transport_clocks (nframes_t pos)
+ARDOUR_UI::update_transport_clocks (framepos_t pos)
{
if (Config->get_primary_clock_delta_edit_cursor()) {
primary_clock.set (pos, false, editor->get_preferred_edit_position(), 1);
secondary_clock.set (pos);
}
- if (big_clock_window) {
+ if (big_clock_window->get()) {
big_clock.set (pos);
}
}
void
ARDOUR_UI::step_edit_status_change (bool yn)
{
- // XXX should really store pre-step edit status of things
- // we make insensitive
+ // XXX should really store pre-step edit status of things
+ // we make insensitive
- if (yn) {
- rec_button.set_visual_state (3);
- rec_button.set_sensitive (false);
- } else {
- rec_button.set_visual_state (0);
- rec_button.set_sensitive (true);
- }
+ if (yn) {
+ rec_button.set_visual_state (3);
+ rec_button.set_sensitive (false);
+ } else {
+ rec_button.set_visual_state (0);
+ rec_button.set_sensitive (true);
+ }
}
void
{
ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
- if (!_session || !big_clock_window) {
+ if (!_session || !big_clock_window->get()) {
/* why bother - the clock isn't visible */
return;
}
void
ARDOUR_UI::toggle_translations ()
{
- using namespace Glib;
+ using namespace Glib;
-
RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("EnableTranslation"));
- if (act) {
- RefPtr<ToggleAction> ract = RefPtr<ToggleAction>::cast_dynamic (act);
- if (ract) {
+ RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("EnableTranslation"));
+ if (act) {
+ RefPtr<ToggleAction> ract = RefPtr<ToggleAction>::cast_dynamic (act);
+ if (ract) {
- string i18n_killer = ARDOUR::translation_kill_path();
+ string i18n_killer = ARDOUR::translation_kill_path();
- bool already_enabled = !ARDOUR::translations_are_disabled ();
+ bool already_enabled = !ARDOUR::translations_are_disabled ();
- if (ract->get_active ()) {
+ if (ract->get_active ()) {
/* we don't care about errors */
- int fd = ::open (i18n_killer.c_str(), O_RDONLY|O_CREAT, 0644);
- close (fd);
- } else {
+ int fd = ::open (i18n_killer.c_str(), O_RDONLY|O_CREAT, 0644);
+ close (fd);
+ } else {
/* we don't care about errors */
- unlink (i18n_killer.c_str());
- }
+ unlink (i18n_killer.c_str());
+ }
- if (already_enabled != ract->get_active()) {
- MessageDialog win (already_enabled ? _("Translations disabled") : _("Translations enabled"),
- false,
- Gtk::MESSAGE_WARNING,
- Gtk::BUTTONS_OK);
- win.set_secondary_text (string_compose (_("You must restart %1 for this to take effect."), PROGRAM_NAME));
- win.set_position (Gtk::WIN_POS_CENTER);
- win.present ();
- win.run ();
- }
- }
- }
+ if (already_enabled != ract->get_active()) {
+ MessageDialog win (already_enabled ? _("Translations disabled") : _("Translations enabled"),
+ false,
+ Gtk::MESSAGE_WARNING,
+ Gtk::BUTTONS_OK);
+ win.set_secondary_text (string_compose (_("You must restart %1 for this to take effect."), PROGRAM_NAME));
+ win.set_position (Gtk::WIN_POS_CENTER);
+ win.present ();
+ win.run ();
+ }
+ }
+ }
}
+
+/** Add a window proxy to our list, so that its state will be saved.
+ * This call also causes the window to be created and opened if its
+ * state was saved as `visible'.
+ */
+void
+ARDOUR_UI::add_window_proxy (WindowProxyBase* p)
+{
+ _window_proxies.push_back (p);
+ p->maybe_show ();
+}
+
+/** Remove a window proxy from our list. Must be called if a WindowProxy
+ * is deleted, to prevent hanging pointers.
+ */
+void
+ARDOUR_UI::remove_window_proxy (WindowProxyBase* p)
+{
+ _window_proxies.remove (p);
+}
+
+int
+ARDOUR_UI::missing_file (Session*s, std::string str, DataType type)
+{
+ MissingFileDialog dialog (s, str, type);
+
+ dialog.show ();
+ dialog.present ();
+
+ int result = dialog.run ();
+ dialog.hide ();
+
+ switch (result) {
+ case RESPONSE_OK:
+ break;
+ default:
+ return 1; // quit entire session load
+ }
+
+ result = dialog.get_action ();
+
+ return result;
+}
+
+int
+ARDOUR_UI::ambiguous_file (std::string file, std::string path, std::vector<std::string> hits)
+{
+ AmbiguousFileDialog dialog (file, hits);
+
+ dialog.show ();
+ dialog.present ();
+
+ dialog.run ();
+ return dialog.get_which ();
+}
projects / ardour.git / blobdiff