#include <sys/resource.h>
#endif
+#ifdef __FreeBSD__
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif
+
#include <stdint.h>
#include <fcntl.h>
#include <signal.h>
#include <glib.h>
#include "pbd/gstdio_compat.h"
-#include <gtkmm/messagedialog.h>
#include <gtkmm/accelmap.h>
+#include <gtkmm/messagedialog.h>
+#include <gtkmm/stock.h>
+#include <gtkmm/uimanager.h>
#include "pbd/error.h"
#include "pbd/basename.h"
#include "pbd/compose.h"
+#include "pbd/convert.h"
#include "pbd/failed_constructor.h"
+#include "pbd/file_archive.h"
#include "pbd/enumwriter.h"
#include "pbd/memento_command.h"
#include "pbd/openuri.h"
#include "pbd/stl_delete.h"
+#include "pbd/types_convert.h"
+#include "pbd/unwind.h"
#include "pbd/file_utils.h"
#include "pbd/localtime_r.h"
#include "pbd/pthread_utils.h"
#include "pbd/replace_all.h"
+#include "pbd/scoped_file_descriptor.h"
#include "pbd/xml++.h"
#include "gtkmm2ext/application.h"
#include "gtkmm2ext/bindings.h"
#include "gtkmm2ext/gtk_ui.h"
#include "gtkmm2ext/utils.h"
-#include "gtkmm2ext/click_box.h"
-#include "gtkmm2ext/fastmeter.h"
-#include "gtkmm2ext/popup.h"
#include "gtkmm2ext/window_title.h"
+#include "widgets/fastmeter.h"
+#include "widgets/prompter.h"
+
#include "ardour/ardour.h"
#include "ardour/audio_backend.h"
+#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/audiofilesource.h"
#include "ardour/automation_watch.h"
#include "ardour/filename_extensions.h"
#include "ardour/filesystem_paths.h"
#include "ardour/ltc_file_reader.h"
+#include "ardour/midi_track.h"
#include "ardour/port.h"
#include "ardour/plugin_manager.h"
#include "ardour/process_thread.h"
#include "ardour/profile.h"
#include "ardour/recent_sessions.h"
+#include "ardour/record_enable_control.h"
+#include "ardour/revision.h"
#include "ardour/session_directory.h"
#include "ardour/session_route.h"
#include "ardour/session_state_utils.h"
#include "ardour/source_factory.h"
#include "ardour/slave.h"
#include "ardour/system_exec.h"
+#include "ardour/track.h"
+#include "ardour/vca_manager.h"
+#include "ardour/utils.h"
+
+#include "LuaBridge/LuaBridge.h"
#ifdef WINDOWS_VST_SUPPORT
#include <fst.h>
#include "ardour/audio_unit.h"
#endif
+// fix for OSX (nsm.h has a check function, AU/Apple defines check)
+#ifdef check
+#undef check
+#endif
+
#include "timecode/time.h"
typedef uint64_t microseconds_t;
#include "about.h"
#include "editing.h"
+#include "enums_convert.h"
#include "actions.h"
#include "add_route_dialog.h"
#include "ambiguous_file_dialog.h"
#include "audio_region_view.h"
#include "big_clock_window.h"
#include "bundle_manager.h"
+#include "duplicate_routes_dialog.h"
+#include "debug.h"
#include "engine_dialog.h"
#include "export_video_dialog.h"
#include "export_video_infobox.h"
#include "global_port_matrix.h"
#include "gui_object.h"
#include "gui_thread.h"
+#include "idleometer.h"
#include "keyboard.h"
#include "keyeditor.h"
#include "location_ui.h"
+#include "lua_script_manager.h"
+#include "luawindow.h"
#include "main_clock.h"
#include "missing_file_dialog.h"
#include "missing_plugin_dialog.h"
#include "mixer_ui.h"
#include "meterbridge.h"
+#include "meter_patterns.h"
#include "mouse_cursors.h"
#include "nsm.h"
#include "opts.h"
#include "pingback.h"
#include "processor_box.h"
-#include "prompter.h"
#include "public_editor.h"
#include "rc_option_editor.h"
#include "route_time_axis.h"
#include "route_params_ui.h"
#include "save_as_dialog.h"
+#include "script_selector.h"
+#include "session_archive_dialog.h"
#include "session_dialog.h"
#include "session_metadata_dialog.h"
#include "session_option_editor.h"
-#include "shuttle_control.h"
#include "speaker_dialog.h"
#include "splash.h"
#include "startup.h"
-#include "theme_manager.h"
+#include "template_dialog.h"
#include "time_axis_view_item.h"
+#include "time_info_box.h"
#include "timers.h"
#include "utils.h"
+#include "utils_videotl.h"
#include "video_server_dialog.h"
#include "add_video_dialog.h"
#include "transcode_video_dialog.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace ARDOUR;
using namespace ARDOUR_UI_UTILS;
using namespace PBD;
using namespace Gtkmm2ext;
+using namespace ArdourWidgets;
using namespace Gtk;
using namespace std;
using namespace Editing;
ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
sigc::signal<void, framepos_t, bool, framepos_t> ARDOUR_UI::Clock;
-sigc::signal<void> ARDOUR_UI::CloseAllDialogs;
+sigc::signal<void> ARDOUR_UI::CloseAllDialogs;
static bool
ask_about_configuration_copy (string const & old_dir, string const & new_dir, int version)
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_YES_NO,
true /* modal, though it hardly matters since it is the only window */
- );
+ );
msg.set_default_response (Gtk::RESPONSE_YES);
msg.show_all ();
static void
libxml_generic_error_func (void* /* parsing_context*/,
- const char* msg,
- ...)
+ const char* msg,
+ ...)
{
va_list ap;
char buf[2048];
replace_all (msg, "\n", "");
- if (err->file && err->line) {
- error << X_("XML error: ") << msg << " in " << err->file << " at line " << err->line;
+ if (!msg.empty()) {
+ if (err->file && err->line) {
+ error << X_("XML error: ") << msg << " in " << err->file << " at line " << err->line;
+
+ if (err->int2) {
+ error << ':' << err->int2;
+ }
- if (err->int2) {
- error << ':' << err->int2;
+ error << endmsg;
+ } else {
+ error << X_("XML error: ") << msg << endmsg;
}
}
- error << endmsg;
}
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], const char* localedir)
-
- : Gtkmm2ext::UI (PROGRAM_NAME, argcp, argvp)
+ : Gtkmm2ext::UI (PROGRAM_NAME, X_("gui"), argcp, argvp)
, session_loaded (false)
+ , session_load_in_progress (false)
, gui_object_state (new GUIObjectState)
, primary_clock (new MainClock (X_("primary"), X_("transport"), true ))
, secondary_clock (new MainClock (X_("secondary"), X_("secondary"), false))
, big_clock (new AudioClock (X_("bigclock"), false, "big", true, true, false, false))
, video_timeline(0)
+ , global_actions (X_("global"))
, ignore_dual_punch (false)
+ , main_window_visibility (0)
, editor (0)
, mixer (0)
, nsm (0)
, _mixer_on_top (false)
, _initial_verbose_plugin_scan (false)
, first_time_engine_run (true)
+ , secondary_clock_spacer (0)
, 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))
, 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))
+ , auto_input_button (ArdourButton::led_default_elements)
+ , time_info_box (0)
, auto_return_button (ArdourButton::led_default_elements)
, follow_edits_button (ArdourButton::led_default_elements)
- , auto_input_button (ArdourButton::led_default_elements)
, auditioning_alert_button (_("Audition"))
, solo_alert_button (_("Solo"))
, feedback_alert_button (_("Feedback"))
, error_alert_button ( ArdourButton::just_led_default_elements )
- , editor_meter(0)
, editor_meter_peak_display()
+ , editor_meter(0)
+ , _suspend_editor_meter_callbacks (false)
, _numpad_locate_happening (false)
, _session_is_new (false)
, last_key_press_time (0)
, save_as_dialog (0)
, meterbridge (0)
+ , luawindow (0)
+ , rc_option_editor (0)
, speaker_config_window (X_("speaker-config"), _("Speaker Configuration"))
- , key_editor (X_("key-editor"), _("Key Bindings"))
- , rc_option_editor (X_("rc-options-editor"), _("Preferences"))
, add_route_dialog (X_("add-routes"), _("Add Tracks/Busses"))
, about (X_("about"), _("About"))
- , location_ui (X_("locations"), _("Locations"))
+ , location_ui (X_("locations"), S_("Ranges|Locations"))
, route_params (X_("inspector"), _("Tracks and Busses"))
, audio_midi_setup (X_("audio-midi-setup"), _("Audio/MIDI Setup"))
, export_video_dialog (X_("video-export"), _("Video Export Dialog"))
+ , lua_script_window (X_("script-manager"), _("Script Manager"))
+ , idleometer (X_("idle-o-meter"), _("Idle'o'Meter"))
, session_option_editor (X_("session-options-editor"), _("Properties"), boost::bind (&ARDOUR_UI::create_session_option_editor, this))
- , add_video_dialog (X_("add-video"), _("Add Tracks/Busses"), boost::bind (&ARDOUR_UI::create_add_video_dialog, this))
+ , add_video_dialog (X_("add-video"), _("Add Video"), boost::bind (&ARDOUR_UI::create_add_video_dialog, this))
, bundle_manager (X_("bundle-manager"), _("Bundle Manager"), boost::bind (&ARDOUR_UI::create_bundle_manager, this))
, big_clock_window (X_("big-clock"), _("Big Clock"), boost::bind (&ARDOUR_UI::create_big_clock_window, this))
, audio_port_matrix (X_("audio-connection-manager"), _("Audio Connections"), boost::bind (&ARDOUR_UI::create_global_port_matrix, this, ARDOUR::DataType::AUDIO))
, midi_port_matrix (X_("midi-connection-manager"), _("MIDI Connections"), boost::bind (&ARDOUR_UI::create_global_port_matrix, this, ARDOUR::DataType::MIDI))
+ , key_editor (X_("key-editor"), _("Keyboard Shortcuts"), boost::bind (&ARDOUR_UI::create_key_editor, this))
, video_server_process (0)
, splash (0)
, have_configure_timeout (false)
, _status_bar_visibility (X_("status-bar"))
, _feedback_exists (false)
, _log_not_acknowledged (LogLevelNone)
+ , duplicate_routes_dialog (0)
+ , editor_visibility_button (S_("Window|Editor"))
+ , mixer_visibility_button (S_("Window|Mixer"))
+ , prefs_visibility_button (S_("Window|Preferences"))
{
Gtkmm2ext::init (localedir);
UIConfiguration::instance().post_gui_init ();
if (ARDOUR::handle_old_configuration_files (boost::bind (ask_about_configuration_copy, _1, _2, _3))) {
+ {
+ /* "touch" the been-here-before path now that config has been migrated */
+ PBD::ScopedFileDescriptor fout (g_open (been_here_before_path ().c_str(), O_CREAT|O_TRUNC|O_RDWR, 0666));
+ }
MessageDialog msg (string_compose (_("Your configuration files were copied. You can now restart %1."), PROGRAM_NAME), true);
msg.run ();
/* configuration was modified, exit immediately */
_exit (0);
}
+
+ if (string (VERSIONSTRING).find (".pre") != string::npos) {
+ /* check this is not being run from ./ardev etc. */
+ if (!running_from_source_tree ()) {
+ pre_release_dialog ();
+ }
+ }
+
if (theArdourUI == 0) {
theArdourUI = this;
}
+ /* track main window visibility */
+
+ main_window_visibility = new VisibilityTracker (_main_window);
+
/* stop libxml from spewing to stdout/stderr */
xmlSetGenericErrorFunc (this, libxml_generic_error_func);
ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
+ /* handle sr mismatch with a dialog - cross-thread from engine */
+ ARDOUR::Session::NotifyAboutSampleRateMismatch.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::sr_mismatch_message, this, _1, _2), gui_context ());
+
/* handle requests to quit (coming from JACK session) */
ARDOUR::Session::Quit.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::finish, this), gui_context ());
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);
-
UIConfiguration::instance().reset_dpi ();
TimeAxisViewItem::set_constant_heights ();
- /* Set this up so that our window proxies can register actions */
+ /* Set this up so that our window proxies can register actions */
ActionManager::init ();
const XMLNode* ui_xml = Config->extra_xml (X_("UI"));
if (ui_xml) {
- key_editor.set_state (*ui_xml);
- rc_option_editor.set_state (*ui_xml);
- session_option_editor.set_state (*ui_xml);
- speaker_config_window.set_state (*ui_xml);
- about.set_state (*ui_xml);
- add_route_dialog.set_state (*ui_xml);
- add_video_dialog.set_state (*ui_xml);
- route_params.set_state (*ui_xml);
- bundle_manager.set_state (*ui_xml);
- location_ui.set_state (*ui_xml);
- big_clock_window.set_state (*ui_xml);
- audio_port_matrix.set_state (*ui_xml);
- midi_port_matrix.set_state (*ui_xml);
- export_video_dialog.set_state (*ui_xml);
- }
+ key_editor.set_state (*ui_xml, 0);
+ session_option_editor.set_state (*ui_xml, 0);
+ speaker_config_window.set_state (*ui_xml, 0);
+ about.set_state (*ui_xml, 0);
+ add_route_dialog.set_state (*ui_xml, 0);
+ add_video_dialog.set_state (*ui_xml, 0);
+ route_params.set_state (*ui_xml, 0);
+ bundle_manager.set_state (*ui_xml, 0);
+ location_ui.set_state (*ui_xml, 0);
+ big_clock_window.set_state (*ui_xml, 0);
+ audio_port_matrix.set_state (*ui_xml, 0);
+ midi_port_matrix.set_state (*ui_xml, 0);
+ export_video_dialog.set_state (*ui_xml, 0);
+ lua_script_window.set_state (*ui_xml, 0);
+ idleometer.set_state (*ui_xml, 0);
+ }
+
+ /* Separate windows */
WM::Manager::instance().register_window (&key_editor);
- WM::Manager::instance().register_window (&rc_option_editor);
WM::Manager::instance().register_window (&session_option_editor);
WM::Manager::instance().register_window (&speaker_config_window);
WM::Manager::instance().register_window (&about);
WM::Manager::instance().register_window (&route_params);
WM::Manager::instance().register_window (&audio_midi_setup);
WM::Manager::instance().register_window (&export_video_dialog);
+ WM::Manager::instance().register_window (&lua_script_window);
WM::Manager::instance().register_window (&bundle_manager);
WM::Manager::instance().register_window (&location_ui);
WM::Manager::instance().register_window (&big_clock_window);
WM::Manager::instance().register_window (&audio_port_matrix);
WM::Manager::instance().register_window (&midi_port_matrix);
+ WM::Manager::instance().register_window (&idleometer);
+
+ /* do not retain position for add route dialog */
+ add_route_dialog.set_state_mask (WindowProxy::Size);
/* Trigger setting up the color scheme and loading the GTK RC file */
attach_to_engine ();
}
+void
+ARDOUR_UI::pre_release_dialog ()
+{
+ ArdourDialog d (_("Pre-Release Warning"), true, false);
+ d.add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
+
+ Label* label = manage (new Label);
+ label->set_markup (string_compose (_("<b>Welcome to this pre-release build of %1 %2</b>\n\n\
+There are still several issues and bugs to be worked on,\n\
+as well as general workflow improvements, before this can be considered\n\
+release software. So, a few guidelines:\n\
+\n\
+1) Please do <b>NOT</b> use this software with the expectation that it is stable or reliable\n\
+ though it may be so, depending on your workflow.\n\
+2) Please wait for a helpful writeup of new features.\n\
+3) <b>Please do NOT use the forums at ardour.org to report issues</b>.\n\
+4) Please <b>DO</b> use the bugtracker at http://tracker.ardour.org/ to report issues\n\
+ making sure to note the product version number as 5.0-pre.\n\
+5) Please <b>DO</b> use the ardour-users mailing list to discuss ideas and pass on comments.\n\
+6) Please <b>DO</b> join us on IRC for real time discussions about %1 %2. You\n\
+ can get there directly from within the program via the Help->Chat menu option.\n\
+\n\
+Full information on all the above can be found on the support page at\n\
+\n\
+ http://ardour.org/support\n\
+"), PROGRAM_NAME, VERSIONSTRING));
+
+ d.get_vbox()->set_border_width (12);
+ d.get_vbox()->pack_start (*label, false, false, 12);
+ d.get_vbox()->show_all ();
+
+ d.run ();
+}
+
GlobalPortMatrixWindow*
ARDOUR_UI::create_global_port_matrix (ARDOUR::DataType type)
{
the audio backend and save the session."), PROGRAM_NAME);
}
- MessageDialog msg (*editor, msgstr);
+ MessageDialog msg (_main_window, msgstr);
pop_back_splash (msg);
msg.run ();
check_memory_locking();
- /* this is the first point at which all the keybindings are available */
+ /* this is the first point at which all the possible actions are
+ * available, because some of the available actions are dependent on
+ * aspects of the engine/backend.
+ */
if (ARDOUR_COMMAND_LINE::show_key_actions) {
- vector<string> names;
+ stringstream sstr;
+ Bindings::save_all_bindings_as_html (sstr);
+
+ if (sstr.str().empty()) {
+ return;
+ }
+ gchar* file_name;
+ GError *err = NULL;
+ gint fd;
+
+ if ((fd = g_file_open_tmp ("akprintXXXXXX.html", &file_name, &err)) < 0) {
+ if (err) {
+ error << string_compose (_("Could not open temporary file to print bindings (%1)"), err->message) << endmsg;
+ g_error_free (err);
+ }
+ return;
+ }
+
+#ifdef PLATFORM_WINDOWS
+ ::close (fd);
+#endif
+
+ err = NULL;
+
+ if (!g_file_set_contents (file_name, sstr.str().c_str(), sstr.str().size(), &err)) {
+#ifndef PLATFORM_WINDOWS
+ ::close (fd);
+#endif
+ g_unlink (file_name);
+ if (err) {
+ error << string_compose (_("Could not save bindings to file (%1)"), err->message) << endmsg;
+ g_error_free (err);
+ }
+ return;
+ }
+
+#ifndef PLATFORM_WINDOWS
+ ::close (fd);
+#endif
+
+ PBD::open_uri (string_compose ("file:///%1", file_name));
+
+ halt_connection.disconnect ();
+ AudioEngine::instance()->stop ();
+ exit (0);
+
+ }
+
+ if (ARDOUR_COMMAND_LINE::show_actions) {
+
+
vector<string> paths;
+ vector<string> labels;
vector<string> tooltips;
vector<string> keys;
- vector<AccelKey> bindings;
-
- ActionManager::get_all_actions (names, paths, tooltips, keys, bindings);
+ vector<Glib::RefPtr<Gtk::Action> > actions;
+ string ver_in = revision;
+ string ver = ver_in.substr(0, ver_in.find("-"));
+
+ stringstream output;
+ output << "\n<h2>Menu actions</h2>" << endl;
+ output << "<p>\n Every single menu item in " << PROGRAM_NAME << "'s GUI is accessible by control" << endl;
+ output << " surfaces or scripts.\n</p>\n" << endl;
+ output << "<p>\n The list below shows all available values of <em>action-name</em> as of" << endl;
+ output << " " << PROGRAM_NAME << " " << ver << ". You can get the current list at any" << endl;
+ output << " time by running " << PROGRAM_NAME << " with the -A flag.\n</p>\n" << endl;
+ output << "<table class=\"dl\">\n <thead>" << endl;
+ output << " <tr><th>Action Name</th><th>Menu Name</th></tr>" << endl;
+ output << " </thead>\n <tbody>" << endl;
+
+ Gtkmm2ext::ActionMap::get_all_actions (paths, labels, tooltips, keys, actions);
- vector<string>::iterator n;
- vector<string>::iterator k;
vector<string>::iterator p;
- for (n = names.begin(), k = keys.begin(), p = paths.begin(); n != names.end(); ++n, ++k, ++p) {
- cout << "Action: '" << (*n) << "' bound to '" << (*k) << "' Path: '" << (*p) << "'" << endl;
+ vector<string>::iterator l;
+
+ for (p = paths.begin(), l = labels.begin(); p != paths.end(); ++p, ++l) {
+ output << " <tr><th><kbd class=\"osc\">" << (*p).substr (9, string::npos);
+ output << "</kbd></th><td>" << *l << "</td></tr>" << endl;
+ }
+ output << " </tbody>\n </table>" << endl;
+
+ // output this mess to a browser for easiest X-platform use
+ // it is not pretty HTML, but it works and it's main purpose
+ // is to create raw html to fit in Ardour's manual with no editing
+ gchar* file_name;
+ GError *err = NULL;
+ gint fd;
+
+ if ((fd = g_file_open_tmp ("akprintXXXXXX.html", &file_name, &err)) < 0) {
+ if (err) {
+ error << string_compose (_("Could not open temporary file to print bindings (%1)"), err->message) << endmsg;
+ g_error_free (err);
+ }
+ return;
+ }
+
+#ifdef PLATFORM_WINDOWS
+ ::close (fd);
+#endif
+
+ err = NULL;
+
+ if (!g_file_set_contents (file_name, output.str().c_str(), output.str().size(), &err)) {
+#ifndef PLATFORM_WINDOWS
+ ::close (fd);
+#endif
+ g_unlink (file_name);
+ if (err) {
+ error << string_compose (_("Could not save bindings to file (%1)"), err->message) << endmsg;
+ g_error_free (err);
+ }
+ return;
}
+#ifndef PLATFORM_WINDOWS
+ ::close (fd);
+#endif
+
+ PBD::open_uri (string_compose ("file:///%1", file_name));
+
halt_connection.disconnect ();
AudioEngine::instance()->stop ();
exit (0);
/* 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::Timecode);
- secondary_clock->set_mode (AudioClock::BBT);
- }
+ primary_clock->set_mode (AudioClock::Timecode);
+ secondary_clock->set_mode (AudioClock::BBT);
/* start the time-of-day-clock */
-#ifndef GTKOSX
+#ifndef __APPLE__
/* OS X provides a nearly-always visible wallclock, so don't be stupid */
update_wall_clock ();
Glib::signal_timeout().connect_seconds (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 1);
if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
// don't bother at 'real' exit. the OS cleans up for us.
- delete big_clock;
- delete primary_clock;
- delete secondary_clock;
- delete _process_thread;
- delete meterbridge;
- delete editor;
- delete mixer;
- delete nsm;
- delete gui_object_state;
+ delete big_clock; big_clock = 0;
+ delete primary_clock; primary_clock = 0;
+ delete secondary_clock; secondary_clock = 0;
+ delete _process_thread; _process_thread = 0;
+ delete time_info_box; time_info_box = 0;
+ delete meterbridge; meterbridge = 0;
+ delete luawindow; luawindow = 0;
+ delete editor; editor = 0;
+ delete mixer; mixer = 0;
+ delete rc_option_editor; rc_option_editor = 0; // failed to wrap object warning
+ delete nsm; nsm = 0;
+ delete gui_object_state; gui_object_state = 0;
+ delete main_window_visibility;
FastMeter::flush_pattern_cache ();
- PixFader::flush_pattern_cache ();
+ ArdourFader::flush_pattern_cache ();
}
#ifndef NDEBUG
void
ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
{
- const XMLProperty* prop;
+ std::string str;
- if ((prop = node.property ("roll")) != 0) {
- roll_controllable->set_id (prop->value());
+ if (node.get_property ("roll", str)){
+ roll_controllable->set_id (str);
}
- if ((prop = node.property ("stop")) != 0) {
- stop_controllable->set_id (prop->value());
+ if (node.get_property ("stop", str)) {
+ stop_controllable->set_id (str);
}
- if ((prop = node.property ("goto-start")) != 0) {
- goto_start_controllable->set_id (prop->value());
+ if (node.get_property ("goto-start", str)) {
+ goto_start_controllable->set_id (str);
}
- if ((prop = node.property ("goto-end")) != 0) {
- goto_end_controllable->set_id (prop->value());
+ if (node.get_property ("goto-end", str)) {
+ goto_end_controllable->set_id (str);
}
- if ((prop = node.property ("auto-loop")) != 0) {
- auto_loop_controllable->set_id (prop->value());
+ if (node.get_property ("auto-loop", str)) {
+ auto_loop_controllable->set_id (str);
}
- if ((prop = node.property ("play-selection")) != 0) {
- play_selection_controllable->set_id (prop->value());
+ if (node.get_property ("play-selection", str)) {
+ play_selection_controllable->set_id (str);
}
- if ((prop = node.property ("rec")) != 0) {
- rec_controllable->set_id (prop->value());
+ if (node.get_property ("rec", str)) {
+ rec_controllable->set_id (str);
}
- if ((prop = node.property ("shuttle")) != 0) {
- shuttle_box->controllable()->set_id (prop->value());
+ if (node.get_property ("shuttle", str)) {
+ shuttle_box.controllable()->set_id (str);
}
}
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_box->controllable()->id().print (buf, sizeof (buf));
- node->add_property (X_("shuttle"), buf);
+ node->set_property (X_("roll"), roll_controllable->id());
+ node->set_property (X_("stop"), stop_controllable->id());
+ node->set_property (X_("goto-start"), goto_start_controllable->id());
+ node->set_property (X_("goto-end"), goto_end_controllable->id());
+ node->set_property (X_("auto-loop"), auto_loop_controllable->id());
+ node->set_property (X_("play-selection"), play_selection_controllable->id());
+ node->set_property (X_("rec"), rec_controllable->id());
+ node->set_property (X_("shuttle"), shuttle_box.controllable()->id());
return *node;
}
}
void
-ARDOUR_UI::update_autosave ()
+ARDOUR_UI::session_dirty_changed ()
{
- ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_autosave)
+ update_autosave ();
+ update_title ();
+}
+void
+ARDOUR_UI::update_autosave ()
+{
if (_session && _session->dirty()) {
if (_autosave_connection.connected()) {
_autosave_connection.disconnect();
#endif
}
+static bool
+_hide_splash (gpointer arg)
+{
+ ((ARDOUR_UI*)arg)->hide_splash();
+ return false;
+}
+
int
ARDOUR_UI::starting ()
{
}
}
+ // TODO: maybe IFF brand_new_user
+ if (ARDOUR::Profile->get_mixbus () && Config->get_copy_demo_sessions ()) {
+ std::string dspd (Config->get_default_session_parent_dir());
+ Searchpath ds (ARDOUR::ardour_data_search_path());
+ ds.add_subdirectory_to_paths ("sessions");
+ vector<string> demos;
+ find_files_matching_pattern (demos, ds, "*.tar.xz");
+
+ ARDOUR::RecentSessions rs;
+ ARDOUR::read_recent_sessions (rs);
+
+ for (vector<string>::iterator i = demos.begin(); i != demos.end (); ++i) {
+ /* "demo-session" must be inside "demo-session.tar.xz"
+ * strip ".tar.xz"
+ */
+ std::string name = basename_nosuffix (basename_nosuffix (*i));
+ std::string path = Glib::build_filename (dspd, name);
+ /* skip if session-dir already exists */
+ if (Glib::file_test(path.c_str(), Glib::FILE_TEST_IS_DIR)) {
+ continue;
+ }
+ /* skip sessions that are already in 'recent'.
+ * eg. a new user changed <session-default-dir> shorly after installation
+ */
+ for (ARDOUR::RecentSessions::iterator r = rs.begin(); r != rs.end(); ++r) {
+ if ((*r).first == name) {
+ continue;
+ }
+ }
+ try {
+ PBD::FileArchive ar (*i);
+ if (0 == ar.inflate (dspd)) {
+ store_recent_sessions (name, path);
+ info << string_compose (_("Copied Demo Session %1."), name) << endmsg;
+ }
+ } catch (...) {}
+ }
+ }
+
#ifdef NO_PLUGIN_STATE
ARDOUR::RecentSessions rs;
use_config ();
- goto_editor_window ();
-
WM::Manager::instance().show_visible ();
/* We have to do this here since goto_editor_window() ends up calling show_all() on the
_status_bar_visibility.update ();
BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
+
+ /* all other dialogs are created conditionally */
+
return 0;
}
pop_back_splash (msg);
- editor->ensure_float (msg);
msg.run ();
if (cb.get_active()) {
/* use the default name */
if (save_state_canfail ("")) {
/* failed - don't quit */
- MessageDialog msg (*editor,
+ MessageDialog msg (_main_window,
string_compose (_("\
%1 was unable to save your session.\n\n\
If you still wish to quit, please use the\n\n\
*/
save_ardour_state ();
+ if (key_editor.get (false)) {
+ key_editor->disconnect ();
+ }
+
close_all_dialogs ();
if (_session) {
{
// august 2007: actual update frequency: 25Hz (40ms), not 100Hz
- if (editor_meter && UIConfiguration::instance().get_show_editor_meter()) {
+ if (editor_meter && UIConfiguration::instance().get_show_editor_meter() && editor_meter_peak_display.is_mapped ()) {
float mpeak = editor_meter->update_meters();
if (mpeak > editor_meter_max_peak) {
if (mpeak >= UIConfiguration::instance().get_meter_peak()) {
ARDOUR_UI::count_recenabled_streams (Route& route)
{
Track* track = dynamic_cast<Track*>(&route);
- if (track && track->record_enabled()) {
+ if (track && track->rec_enable_control()->get_value()) {
rec_enabled_streams += track->n_inputs().n_total();
}
}
{
if (!AudioEngine::instance()->connected()) {
MessageDialog msg (parent, string_compose (
- _("%1 is not connected to any audio backend.\n"
- "You cannot open or close sessions in this condition"),
- PROGRAM_NAME));
+ _("%1 is not connected to any audio backend.\n"
+ "You cannot open or close sessions in this condition"),
+ PROGRAM_NAME));
pop_back_splash (msg);
msg.run ();
return false;
void
ARDOUR_UI::open_session ()
{
- if (!check_audioengine(*editor)) {
+ if (!check_audioengine (_main_window)) {
return;
}
session_filter.add_pattern (string_compose(X_("*%1"), ARDOUR::statefile_suffix));
session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
open_session_selector.add_filter (session_filter);
+
+ FileFilter archive_filter;
+ archive_filter.add_pattern (X_("*.tar.xz"));
+ archive_filter.set_name (_("Session Archives"));
+
+ open_session_selector.add_filter (archive_filter);
+
open_session_selector.set_filter (session_filter);
int response = open_session_selector.run();
bool isnew;
if (session_path.length() > 0) {
- if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
+ int rv = ARDOUR::inflate_session (session_path,
+ Config->get_default_session_parent_dir(), path, name);
+ if (rv == 0) {
+ _session_is_new = false;
+ load_session (path, name);
+ }
+ else if (rv < 0) {
+ MessageDialog msg (_main_window,
+ string_compose (_("Extracting session-archive failed: %1"), inflate_error (rv)));
+ msg.run ();
+ }
+ else if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
_session_is_new = isnew;
load_session (path, name);
}
}
}
-
void
-ARDOUR_UI::session_add_mixed_track (const ChanCount& input, const ChanCount& output, RouteGroup* route_group,
- uint32_t how_many, const string& name_template, PluginInfoPtr instrument)
+ARDOUR_UI::session_add_vca (const string& name_template, uint32_t n)
{
- list<boost::shared_ptr<MidiTrack> > tracks;
+ if (!_session) {
+ return;
+ }
+
+ _session->vca_manager().create_vca (n, name_template);
+}
+void
+ARDOUR_UI::session_add_mixed_track (
+ const ChanCount& input,
+ const ChanCount& output,
+ RouteGroup* route_group,
+ uint32_t how_many,
+ const string& name_template,
+ bool strict_io,
+ PluginInfoPtr instrument,
+ Plugin::PresetRecord* pset,
+ ARDOUR::PresentationInfo::order_t order)
+{
if (_session == 0) {
warning << _("You cannot add a track without a session already loaded.") << endmsg;
return;
}
+ if (Profile->get_mixbus ()) {
+ strict_io = true;
+ }
+
try {
- tracks = _session->new_midi_track (input, output, instrument, ARDOUR::Normal, route_group, how_many, name_template);
+ list<boost::shared_ptr<MidiTrack> > tracks;
+ tracks = _session->new_midi_track (input, output, strict_io, instrument, pset, route_group, how_many, name_template, order, ARDOUR::Normal);
if (tracks.size() != how_many) {
error << string_compose(P_("could not create %1 new mixed track", "could not create %1 new mixed tracks", how_many), how_many) << endmsg;
}
catch (...) {
- MessageDialog msg (*editor,
- string_compose (_("There are insufficient ports available\n\
-to create a new track or bus.\n\
-You should save %1, exit and\n\
-restart with more ports."), PROGRAM_NAME));
- msg.run ();
+ display_insufficient_ports_message ();
+ return;
}
}
+void
+ARDOUR_UI::session_add_midi_bus (
+ RouteGroup* route_group,
+ uint32_t how_many,
+ const string& name_template,
+ bool strict_io,
+ PluginInfoPtr instrument,
+ Plugin::PresetRecord* pset,
+ ARDOUR::PresentationInfo::order_t order)
+{
+ if (_session == 0) {
+ warning << _("You cannot add a track without a session already loaded.") << endmsg;
+ return;
+ }
+
+ if (Profile->get_mixbus ()) {
+ strict_io = true;
+ }
+
+ try {
+ RouteList routes;
+ routes = _session->new_midi_route (route_group, how_many, name_template, strict_io, instrument, pset, PresentationInfo::MidiBus, order);
+ if (routes.size() != how_many) {
+ error << string_compose(P_("could not create %1 new Midi Bus", "could not create %1 new Midi Busses", how_many), how_many) << endmsg;
+ }
+
+ }
+ catch (...) {
+ display_insufficient_ports_message ();
+ return;
+ }
+}
void
-ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many, const string& name_template, PluginInfoPtr instrument)
+ARDOUR_UI::session_add_midi_route (
+ bool disk,
+ RouteGroup* route_group,
+ uint32_t how_many,
+ const string& name_template,
+ bool strict_io,
+ PluginInfoPtr instrument,
+ Plugin::PresetRecord* pset,
+ ARDOUR::PresentationInfo::order_t order)
{
ChanCount one_midi_channel;
one_midi_channel.set (DataType::MIDI, 1);
if (disk) {
- session_add_mixed_track (one_midi_channel, one_midi_channel, route_group, how_many, name_template, instrument);
+ session_add_mixed_track (one_midi_channel, one_midi_channel, route_group, how_many, name_template, strict_io, instrument, pset, order);
+ } else {
+ session_add_midi_bus (route_group, how_many, name_template, strict_io, instrument, pset, order);
}
}
ARDOUR::TrackMode mode,
RouteGroup* route_group,
uint32_t how_many,
- string const & name_template
- )
+ string const & name_template,
+ bool strict_io,
+ ARDOUR::PresentationInfo::order_t order)
{
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, name_template);
+ tracks = _session->new_audio_track (input_channels, output_channels, route_group, how_many, name_template, order, mode);
if (tracks.size() != how_many) {
error << string_compose (P_("could not create %1 new audio track", "could not create %1 new audio tracks", how_many), how_many)
} else {
- routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many, name_template);
+ routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many, name_template, PresentationInfo::AudioBus, order);
if (routes.size() != how_many) {
error << string_compose (P_("could not create %1 new audio bus", "could not create %1 new audio busses", how_many), how_many)
}
catch (...) {
- MessageDialog msg (*editor,
- string_compose (_("There are insufficient ports available\n\
+ display_insufficient_ports_message ();
+ return;
+ }
+
+ if (strict_io) {
+ for (list<boost::shared_ptr<AudioTrack> >::iterator i = tracks.begin(); i != tracks.end(); ++i) {
+ (*i)->set_strict_io (true);
+ }
+ for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ (*i)->set_strict_io (true);
+ }
+ }
+}
+
+void
+ARDOUR_UI::display_insufficient_ports_message ()
+{
+ MessageDialog msg (_main_window,
+ string_compose (_("There are insufficient ports available\n\
to create a new track or bus.\n\
You should save %1, exit and\n\
restart with more ports."), PROGRAM_NAME));
- pop_back_splash (msg);
- msg.run ();
- }
+ pop_back_splash (msg);
+ msg.run ();
}
void
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*r);
assert (t);
- if (t->record_enabled()) {
+ if (t->rec_enable_control()->get_value()) {
none_record_enabled = false;
break;
}
}
if (none_record_enabled) {
- _session->set_record_enabled (rl, true, Session::rt_cleanup);
+ _session->set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), 1.0, Controllable::NoGroup);
}
return none_record_enabled;
switch (_session->record_status()) {
case Session::Disabled:
if (_session->ntracks() == 0) {
- MessageDialog msg (*editor, _("Please create one or more tracks before trying to record.\nYou can do this with the \"Add Track or Bus\" option in the Session menu."));
+ MessageDialog msg (_main_window, _("Please create one or more tracks before trying to record.\nYou can do this with the \"Add Track or Bus\" option in the Session menu."));
msg.run ();
return;
}
if (affect_transport) {
if (rolling) {
_session->request_stop (with_abort, true);
- } else if (!_session->config.get_external_sync()) {
+
+ } else if (!with_abort) { /* with_abort == true means the
+ * command was intended to stop
+ * transport, not start.
+ */
+
+ /* the only external sync condition we can be in here
+ * would be Engine (JACK) sync, in which case we still
+ * want to do this.
+ */
+
if (UIConfiguration::instance().get_follow_edits() && ( editor->get_selection().time.front().start == _session->transport_frame() ) ) { //if playhead is exactly at the start of a range, we can assume it was placed there by follow_edits
_session->request_play_range (&editor->get_selection().time, true);
_session->set_requested_return_frame( editor->get_selection().time.front().start ); //force an auto-return here
void
ARDOUR_UI::toggle_session_auto_loop ()
{
+ if (!_session) {
+ return;
+ }
+
Location * looploc = _session->locations()->auto_loop_location();
- if (!_session || !looploc) {
+ if (!looploc) {
return;
}
editor->play_with_preroll ();
}
+void
+ARDOUR_UI::transport_rec_preroll ()
+{
+ if (!_session) {
+ return;
+ }
+ editor->rec_with_preroll ();
+}
+
+void
+ARDOUR_UI::transport_rec_count_in ()
+{
+ if (!_session) {
+ return;
+ }
+ editor->rec_with_count_in ();
+}
+
void
ARDOUR_UI::transport_rewind (int option)
{
float current_transport_speed;
- if (_session) {
+ if (_session) {
current_transport_speed = _session->transport_speed();
if (current_transport_speed >= 0.0f) {
}
void
-ARDOUR_UI::toggle_record_enable (uint32_t rid)
+ARDOUR_UI::toggle_record_enable (uint16_t rid)
{
if (!_session) {
return;
boost::shared_ptr<Route> r;
- if ((r = _session->route_by_remote_id (rid)) != 0) {
+ if ((r = _session->get_remote_nth_route (rid)) != 0) {
- Track* t;
+ boost::shared_ptr<Track> t;
- if ((t = dynamic_cast<Track*>(r.get())) != 0) {
- t->set_record_enabled (!t->record_enabled(), this);
+ if ((t = boost::dynamic_pointer_cast<Track>(r)) != 0) {
+ t->rec_enable_control()->set_value (!t->rec_enable_control()->get_value(), Controllable::UseGroup);
}
}
}
play_selection_button.unset_active_state ();
roll_button.unset_active_state ();
stop_button.set_active_state (Gtkmm2ext::ExplicitActive);
+ layered_button.set_sensitive (false);
return;
}
- shuttle_box->map_transport_state ();
+ shuttle_box.map_transport_state ();
float sp = _session->transport_speed();
roll_button.set_active (true);
play_selection_button.set_active (true);
}
+ layered_button.set_sensitive (!_session->actively_recording ());
stop_button.set_active (false);
} else {
+ layered_button.set_sensitive (true);
stop_button.set_active (true);
roll_button.set_active (false);
play_selection_button.set_active (false);
ARDOUR_UI::blink_handler (bool blink_on)
{
transport_rec_enable_blink (blink_on);
- solo_blink (blink_on);
sync_blink (blink_on);
+
+ if (!UIConfiguration::instance().get_blink_alert_indicators()) {
+ blink_on = true;
+ }
+ error_blink (blink_on);
+ solo_blink (blink_on);
audition_blink (blink_on);
feedback_blink (blink_on);
- error_blink (blink_on);
}
void
return;
}
+ if (_session->dirty()) {
+ vector<string> actions;
+ actions.push_back (_("Abort save-as"));
+ actions.push_back (_("Don't save now, just save-as"));
+ actions.push_back (_("Save it first"));
+ switch (ask_about_saving_session(actions)) {
+ case -1:
+ return;
+ break;
+ case 1:
+ if (save_state_canfail ("")) {
+ MessageDialog msg (_main_window,
+ string_compose (_("\
+%1 was unable to save your session.\n\n\
+If you still wish to proceeed, please use the\n\n\
+\"Don't save now\" option."), PROGRAM_NAME));
+ pop_back_splash(msg);
+ msg.run ();
+ return;
+ }
+ // no break
+ case 0:
+ _session->remove_pending_capture_state ();
+ break;
+ }
+ }
+
if (!save_as_dialog) {
save_as_dialog = new SaveAsDialog;
}
}
- Session::SaveAs sa;
+ Session::SaveAs sa;
sa.new_parent_folder = save_as_dialog->new_parent_folder ();
sa.new_name = save_as_dialog->new_name ();
*/
ArdourDialog progress_dialog (_("Save As"), true);
+ ScopedConnection c;
if (sa.include_media && sa.copy_media) {
- Gtk::Label label;
- Gtk::ProgressBar progress_bar;
+ Gtk::Label* label = manage (new Gtk::Label());
+ Gtk::ProgressBar* progress_bar = manage (new Gtk::ProgressBar ());
- progress_dialog.get_vbox()->pack_start (label);
- progress_dialog.get_vbox()->pack_start (progress_bar);
- label.show ();
- progress_bar.show ();
+ progress_dialog.get_vbox()->pack_start (*label);
+ progress_dialog.get_vbox()->pack_start (*progress_bar);
+ label->show ();
+ progress_bar->show ();
/* this signal will be emitted from within this, the calling thread,
* after every file is copied. It provides information on percentage
* copied so far, and the total number to copy.
*/
- ScopedConnection c;
-
- sa.Progress.connect_same_thread (c, boost::bind (&ARDOUR_UI::save_as_progress_update, this, _1, _2, _3, &label, &progress_bar));
+ sa.Progress.connect_same_thread (c, boost::bind (&ARDOUR_UI::save_as_progress_update, this, _1, _2, _3, label, progress_bar));
progress_dialog.show_all ();
progress_dialog.present ();
msg.run ();
}
- if (!sa.include_media) {
+ /* the logic here may seem odd: why isn't the condition sa.switch_to ?
+ * the trick is this: if the new session was copy with media included,
+ * then Session::save_as() will have already done a neat trick to avoid
+ * us having to unload and load the new state. But if the media was not
+ * included, then this is required (it avoids us having to otherwise
+ * drop all references to media (sources).
+ */
+
+ if (!sa.include_media && sa.switch_to) {
unload_session (false);
load_session (sa.final_session_folder_name, sa.new_name);
}
}
+void
+ARDOUR_UI::archive_session ()
+{
+ if (!_session) {
+ return;
+ }
+
+ time_t n;
+ time (&n);
+ Glib::DateTime gdt (Glib::DateTime::create_now_local (n));
+
+ SessionArchiveDialog sad;
+ sad.set_name (_session->name() + gdt.format ("_%F_%H%M%S"));
+ int response = sad.run ();
+
+ if (response != Gtk::RESPONSE_OK) {
+ sad.hide ();
+ return;
+ }
+
+ if (_session->archive_session (sad.target_folder(), sad.name(), sad.encode_option (), sad.only_used_sources (), &sad)) {
+ MessageDialog msg (_("Session Archiving failed."));
+ msg.run ();
+ }
+}
+
+void
+ARDOUR_UI::quick_snapshot_session (bool 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%H.%M.%S", &local_time);
+ if (switch_to_it && _session->dirty ()) {
+ save_state_canfail ("");
+ }
+
+ save_state (timebuf, switch_to_it);
+}
+
+
bool
-ARDOUR_UI::process_snapshot_session_prompter (ArdourPrompter& prompter, bool switch_to_it)
+ARDOUR_UI::process_snapshot_session_prompter (Prompter& prompter, bool switch_to_it)
{
string snapname;
char illegal = Session::session_name_is_legal(snapname);
if (illegal) {
MessageDialog msg (string_compose (_("To ensure compatibility with various systems\n"
- "snapshot names may not contain a '%1' character"), illegal));
+ "snapshot names may not contain a '%1' character"), illegal));
msg.run ();
return false;
}
void
ARDOUR_UI::snapshot_session (bool switch_to_it)
{
- ArdourPrompter prompter (true);
-
- prompter.set_name ("Prompter");
- prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- if (switch_to_it) {
- prompter.set_title (_("Save as..."));
- prompter.set_prompt (_("New session name"));
- } else {
- prompter.set_title (_("Take Snapshot"));
- prompter.set_prompt (_("Name of new snapshot"));
- }
+ if (switch_to_it && _session->dirty()) {
+ vector<string> actions;
+ actions.push_back (_("Abort saving snapshot"));
+ actions.push_back (_("Don't save now, just snapshot"));
+ actions.push_back (_("Save it first"));
+ switch (ask_about_saving_session(actions)) {
+ case -1:
+ return;
+ break;
+ case 1:
+ if (save_state_canfail ("")) {
+ MessageDialog msg (_main_window,
+ string_compose (_("\
+%1 was unable to save your session.\n\n\
+If you still wish to proceeed, please use the\n\n\
+\"Don't save now\" option."), PROGRAM_NAME));
+ pop_back_splash(msg);
+ msg.run ();
+ return;
+ }
+ // no break
+ case 0:
+ _session->remove_pending_capture_state ();
+ break;
+ }
+ }
- if (!switch_to_it) {
- char timebuf[128];
- time_t n;
- struct tm local_time;
+ Prompter prompter (true);
+ prompter.set_name ("Prompter");
+ prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+ if (switch_to_it) {
+ prompter.set_title (_("Snapshot and switch"));
+ prompter.set_prompt (_("New session name"));
+ } else {
+ prompter.set_title (_("Take Snapshot"));
+ prompter.set_prompt (_("Name of new snapshot"));
+ }
- time (&n);
- localtime_r (&n, &local_time);
- strftime (timebuf, sizeof(timebuf), "%FT%H.%M.%S", &local_time);
- prompter.set_initial_text (timebuf);
+ if (switch_to_it) {
+ prompter.set_initial_text (_session->snap_name());
+ } else {
+ Glib::DateTime tm (g_date_time_new_now_local ());
+ prompter.set_initial_text (tm.format ("%FT%H.%M.%S"));
}
bool finished = false;
return;
}
- ArdourPrompter prompter (true);
+ Prompter prompter (true);
string name;
prompter.set_name ("Prompter");
if (illegal) {
MessageDialog msg (string_compose (_("To ensure compatibility with various systems\n"
- "session names may not contain a '%1' character"), illegal));
+ "session names may not contain a '%1' character"), illegal));
msg.run ();
goto again;
}
}
bool
-ARDOUR_UI::process_save_template_prompter (ArdourPrompter& prompter)
+ARDOUR_UI::process_save_template_prompter (Prompter& prompter)
{
string name;
void
ARDOUR_UI::save_template ()
{
- ArdourPrompter prompter (true);
+ Prompter prompter (true);
- if (!check_audioengine(*editor)) {
+ if (!check_audioengine (_main_window)) {
return;
}
}
}
+void ARDOUR_UI::manage_templates ()
+{
+ TemplateDialog td;
+ td.run();
+}
+
void
ARDOUR_UI::edit_metadata ()
{
{
BusProfile bus_profile;
- if (nsm || Profile->get_sae()) {
+ if (nsm) {
bus_profile.master_out_channels = 2;
bus_profile.input_ac = AutoConnectPhysical;
void
ARDOUR_UI::load_from_application_api (const std::string& path)
{
+ /* OS X El Capitan (and probably later) now somehow passes the command
+ line arguments to an app via the openFile delegate protocol. Ardour
+ already does its own command line processing, and having both
+ pathways active causes crashes. So, if the command line was already
+ set, do nothing here.
+ */
+
+ if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
+ return;
+ }
+
ARDOUR_COMMAND_LINE::session_name = path;
+ /* Cancel SessionDialog if it's visible to make OSX delegates work.
+ *
+ * ARDOUR_UI::starting connects app->ShouldLoad signal and then shows a SessionDialog
+ * race-condition:
+ * - ShouldLoad does not arrive in time, ARDOUR_COMMAND_LINE::session_name is empty:
+ * -> ARDOUR_UI::get_session_parameters starts a SessionDialog.
+ * - ShouldLoad signal arrives, this function is called and sets ARDOUR_COMMAND_LINE::session_name
+ * -> SessionDialog is not displayed
+ */
+
+ if (_session_dialog) {
+ std::string session_name = basename_nosuffix (ARDOUR_COMMAND_LINE::session_name);
+ std::string session_path = path;
+ if (Glib::file_test (session_path, Glib::FILE_TEST_IS_REGULAR)) {
+ session_path = Glib::path_get_dirname (session_path);
+ }
+ // signal the existing dialog in ARDOUR_UI::get_session_parameters()
+ _session_dialog->set_provided_session (session_name, session_path);
+ _session_dialog->response (RESPONSE_NONE);
+ _session_dialog->hide();
+ return;
+ }
+
+ int rv;
if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
/* /path/to/foo => /path/to/foo, foo */
- load_session (path, basename_nosuffix (path));
+ rv = 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));
+ rv =load_session (Glib::path_get_dirname (path), basename_nosuffix (path));
+ }
+
+ // if load_session fails -> pop up SessionDialog.
+ if (rv) {
+ ARDOUR_COMMAND_LINE::session_name = "";
+
+ if (get_session_parameters (true, false)) {
+ exit (1);
+ }
}
}
/* if there is already a session, relabel the button
on the SessionDialog so that we don't Quit directly
*/
- cancel_not_quit = (_session != 0);
+ cancel_not_quit = (_session != 0) && !quit_on_cancel;
if (_session && _session->dirty()) {
if (unload_session (false)) {
SessionDialog session_dialog (should_be_new, session_name, session_path, load_template, cancel_not_quit);
+ _session_dialog = &session_dialog;
while (ret != 0) {
if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
switch (session_dialog.run()) {
case RESPONSE_ACCEPT:
break;
+ case RESPONSE_NONE:
+ /* this is used for async * app->ShouldLoad(). */
+ continue; // while loop
+ break;
default:
if (quit_on_cancel) {
- // JE - Currently (July 2014) this section can only get reached if the
- // user quits from the main 'Session Setup' dialog (i.e. reaching this
- // point does NOT indicate an abnormal termination). Therefore, let's
- // behave gracefully (i.e. let's do some cleanup) before we call exit()
+ ARDOUR_UI::finish ();
+ Gtkmm2ext::Application::instance()->cleanup();
ARDOUR::cleanup ();
pthread_cancel_all ();
-
- exit (1);
+ return -1; // caller is responsible to call exit()
} else {
return ret;
}
session_path = session_dialog.session_folder ();
if (nsm) {
- likely_new = true;
+ likely_new = true;
+ }
+
+ if (!likely_new) {
+ int rv = ARDOUR::inflate_session (session_name,
+ Config->get_default_session_parent_dir(), session_path, session_name);
+ if (rv < 0) {
+ MessageDialog msg (session_dialog,
+ string_compose (_("Extracting session-archive failed: %1"), inflate_error (rv)));
+ msg.run ();
+ continue;
+ }
+ else if (rv == 0) {
+ session_dialog.set_provided_session (session_name, session_path);
+ }
}
+ // XXX check archive, inflate
string::size_type suffix = session_name.find (statefile_suffix);
if (suffix != string::npos) {
if (session_name[0] == G_DIR_SEPARATOR ||
#ifdef PLATFORM_WINDOWS
- (session_name.length() > 3 && session_name[1] == ':' && session_name[2] == G_DIR_SEPARATOR)
+ (session_name.length() > 3 && session_name[1] == ':' && session_name[2] == G_DIR_SEPARATOR)
#else
- (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)
+ (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)
#endif
- )
+ )
{
/* absolute path or cwd-relative path specified for session name: infer session folder
if (illegal) {
MessageDialog msg (session_dialog,
- string_compose (_("To ensure compatibility with various systems\n"
- "session names may not contain a '%1' character"),
- illegal));
+ string_compose (_("To ensure compatibility with various systems\n"
+ "session names may not contain a '%1' character"),
+ illegal));
msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
if (illegal) {
pop_back_splash (session_dialog);
MessageDialog msg (session_dialog, string_compose(_("To ensure compatibility with various systems\n"
- "session names may not contain a '%1' character"), illegal));
+ "session names may not contain a '%1' character"), illegal));
msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
_session_is_new = true;
}
- if (likely_new && template_name.empty()) {
+ if (!template_name.empty() && template_name.substr (0, 11) == "urn:ardour:") {
+
+ ret = build_session_from_dialog (session_dialog, session_path, session_name);
+ meta_session_setup (template_name.substr (11));
+
+ } else if (likely_new && template_name.empty()) {
ret = build_session_from_dialog (session_dialog, session_path, session_name);
}
}
+ _session_dialog = NULL;
+
return ret;
}
void
ARDOUR_UI::close_session()
{
- if (!check_audioengine(*editor)) {
+ if (!check_audioengine (_main_window)) {
return;
}
if (get_session_parameters (true, false)) {
exit (1);
}
-
- goto_editor_window ();
}
/** @param snap_name Snapshot name (without .ardour suffix).
int
ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name, std::string mix_template)
{
+ /* load_session calls flush_pending() which allows
+ * GUI interaction and potentially loading another session
+ * (that was easy via snapshot sidebar).
+ * Recursing into load_session() from load_session() and recusive
+ * event loops causes all kind of crashes.
+ */
+ assert (!session_load_in_progress);
+ if (session_load_in_progress) {
+ return -1;
+ }
+ PBD::Unwinder<bool> lsu (session_load_in_progress, true);
+
Session *new_session;
int unload_status;
int retval = -1;
catch (...) {
MessageDialog msg (string_compose(
- _("Session \"%1 (snapshot %2)\" did not load successfully"),
- path, snap_name),
+ _("Session \"%1 (snapshot %2)\" did not load successfully"),
+ path, snap_name),
true,
Gtk::MESSAGE_INFO,
BUTTONS_OK);
session_loaded = true;
- goto_editor_window ();
-
if (_session) {
_session->set_clean ();
}
{
Timers::TimerSuspender t;
- flush_pending ();
+ flush_pending (10);
}
#ifdef WINDOWS_VST_SUPPORT
#endif
retval = 0;
+ if (!mix_template.empty ()) {
+ /* if mix_template is given, assume this is a new session */
+ string metascript = Glib::build_filename (mix_template, "template.lua");
+ meta_session_setup (metascript);
+ }
+
+
out:
+ /* For successful session load the splash is hidden by ARDOUR_UI::first_idle,
+ * which is queued by set_session().
+ * If session-loading fails we hide it explicitly.
+ * This covers both cases in a central place.
+ */
+ if (retval) {
+ hide_splash ();
+ }
return retval;
}
}
catch (SessionException e) {
+ cerr << "Here are the errors associated with this failed session:\n";
dump_errors (cerr);
+ cerr << "---------\n";
MessageDialog msg (string_compose(_("Could not create session in \"%1\": %2"), path, e.what()));
msg.set_title (_("Loading Error"));
msg.set_position (Gtk::WIN_POS_CENTER);
return -1;
}
catch (...) {
+ cerr << "Here are the errors associated with this failed session:\n";
dump_errors (cerr);
+ cerr << "---------\n";
MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
msg.set_title (_("Loading Error"));
msg.set_position (Gtk::WIN_POS_CENTER);
new_session->add_instant_xml (*n, false);
}
+ n = Config->instant_xml (X_("Preferences"));
+ 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"));
+ n->set_property (X_("playhead"), X_("0"));
+ n->set_property (X_("left-frame"), X_("0"));
}
set_session (new_session);
return 0;
}
+void
+ARDOUR_UI::meta_session_setup (const std::string& script_path)
+{
+ if (!Glib::file_test (script_path, Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR)) {
+ return;
+ }
+
+ LuaState lua;
+ lua.sandbox (true);
+
+ lua_State* L = lua.getState();
+ LuaInstance::register_classes (L);
+ LuaBindings::set_session (L, _session);
+ luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
+ lua_setglobal (L, "Editor");
+
+ lua.do_command ("function ardour () end");
+ lua.do_file (script_path);
+
+ try {
+ luabridge::LuaRef fn = luabridge::getGlobal (L, "session_setup");
+ if (fn.isFunction()) {
+ fn ();
+ }
+ } catch (luabridge::LuaException const& e) { }
+}
+
void
ARDOUR_UI::launch_chat ()
{
+ MessageDialog dialog(_("<b>Just ask and wait for an answer.\nIt may take from minutes to hours.</b>"), true);
+
+ dialog.set_title (_("About the Chat"));
+ dialog.set_secondary_text (_("When you're inside the chat just ask your question and wait for an answer. The chat is occupied by real people with real lives so many of them are passively online and might not read your question before minutes or hours later.\nSo please be patient and wait for an answer.\n\nYou should just leave the chat window open and check back regularly until someone has answered your question."));
+
+ switch (dialog.run()) {
+ case RESPONSE_OK:
#ifdef __APPLE__
- open_uri("http://webchat.freenode.net/?channels=ardour-osx");
+ open_uri("http://webchat.freenode.net/?channels=ardour-osx");
#elif defined PLATFORM_WINDOWS
- open_uri("http://webchat.freenode.net/?channels=ardour-windows");
+ open_uri("http://webchat.freenode.net/?channels=ardour-windows");
#else
- open_uri("http://webchat.freenode.net/?channels=ardour");
+ open_uri("http://webchat.freenode.net/?channels=ardour");
#endif
+ break;
+ default:
+ break;
+ }
}
void
void
ARDOUR_UI::launch_tracker ()
{
- PBD::open_uri ("http://tracker.ardour.org/bug_report_page.php");
+ PBD::open_uri ("http://tracker.ardour.org");
}
void
void
ARDOUR_UI::hide_splash ()
{
- delete splash;
- splash = 0;
+ delete splash;
+ splash = 0;
}
void
removed = rep.paths.size();
if (removed == 0) {
- MessageDialog msgd (*editor,
- _("No files were ready for clean-up"),
- true,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_OK);
+ MessageDialog msgd (_main_window,
+ _("No files were ready for clean-up"),
+ true,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_OK);
msgd.set_title (_("Clean-up"));
- msgd.set_secondary_text (_("If this seems suprising, \n\
+ msgd.set_secondary_text (_("If this seems surprising, \n\
check for any existing snapshots.\n\
These may still include regions that\n\
require some unused files to continue to exist."));
ArdourDialog results (_("Clean-up"), true, false);
struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
- CleanupResultsModelColumns() {
- add (visible_name);
- add (fullpath);
- }
- Gtk::TreeModelColumn<std::string> visible_name;
- Gtk::TreeModelColumn<std::string> fullpath;
+ CleanupResultsModelColumns() {
+ add (visible_name);
+ add (fullpath);
+ }
+ Gtk::TreeModelColumn<std::string> visible_name;
+ Gtk::TreeModelColumn<std::string> fullpath;
};
}
}
-void
-ARDOUR_UI::setup_order_hint (AddRouteDialog::InsertAt place)
+PresentationInfo::order_t
+ARDOUR_UI::translate_order (RouteDialogs::InsertAt place)
{
- uint32_t order_hint = UINT32_MAX;
-
if (editor->get_selection().tracks.empty()) {
- return;
+ return place == RouteDialogs::First ? 0 : PresentationInfo::max_order;
}
+ PresentationInfo::order_t order_hint = PresentationInfo::max_order;
+
/*
we want the new routes to have their order keys set starting from
the highest order key in the selection + 1 (if available).
*/
- if (place == AddRouteDialog::AfterSelection) {
+ if (place == RouteDialogs::AfterSelection) {
RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView*> (editor->get_selection().tracks.back());
if (rtav) {
- order_hint = rtav->route()->order_key();
+ order_hint = rtav->route()->presentation_info().order();
order_hint++;
}
- } else if (place == AddRouteDialog::BeforeSelection) {
+ } else if (place == RouteDialogs::BeforeSelection) {
RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView*> (editor->get_selection().tracks.front());
if (rtav) {
- order_hint = rtav->route()->order_key();
+ order_hint = rtav->route()->presentation_info().order();
}
- } else if (place == AddRouteDialog::First) {
+ } else if (place == RouteDialogs::First) {
order_hint = 0;
} else {
- /* leave order_hint at UINT32_MAX */
- }
-
- if (order_hint == UINT32_MAX) {
- /** AddRouteDialog::Last or selection with first/last not a RouteTimeAxisView
- * not setting an order hint will place new routes last.
- */
- return;
+ /* leave order_hint at max_order */
}
- _session->set_order_hint (order_hint);
-
- /* create a gap in the existing route order keys to accomodate new routes.*/
- boost::shared_ptr <RouteList> rd = _session->get_routes();
- for (RouteList::iterator ri = rd->begin(); ri != rd->end(); ++ri) {
- boost::shared_ptr<Route> rt (*ri);
+ return order_hint;
+}
- if (rt->is_monitor()) {
- continue;
- }
+void
+ARDOUR_UI::start_duplicate_routes ()
+{
+ if (!duplicate_routes_dialog) {
+ duplicate_routes_dialog = new DuplicateRouteDialog;
+ }
- if (rt->order_key () >= order_hint) {
- rt->set_order_key (rt->order_key () + add_route_dialog->count());
- }
+ if (duplicate_routes_dialog->restart (_session)) {
+ return;
}
+
+ duplicate_routes_dialog->present ();
}
void
-ARDOUR_UI::add_route (Gtk::Window* /* ignored */)
+ARDOUR_UI::add_route ()
{
- int count;
+ if (!add_route_dialog.get (false)) {
+ add_route_dialog->signal_response().connect (sigc::mem_fun (*this, &ARDOUR_UI::add_route_dialog_response));
+ }
if (!_session) {
return;
return;
}
- ResponseType r = (ResponseType) add_route_dialog->run ();
+ add_route_dialog->set_position (WIN_POS_MOUSE);
+ add_route_dialog->present();
+}
- add_route_dialog->hide();
+void
+ARDOUR_UI::add_route_dialog_response (int r)
+{
+ int count;
switch (r) {
- case RESPONSE_ACCEPT:
- break;
- default:
- return;
- break;
+ case AddRouteDialog::Add:
+ break;
+ case AddRouteDialog::AddAndClose:
+ add_route_dialog->ArdourDialog::on_response (r);
+ break;
+ default:
+ add_route_dialog->ArdourDialog::on_response (r);
+ return;
}
if ((count = add_route_dialog->count()) <= 0) {
return;
}
- setup_order_hint(add_route_dialog->insert_at());
-
+ PresentationInfo::order_t order = translate_order (add_route_dialog->insert_at());
string template_path = add_route_dialog->track_template();
DisplaySuspender ds;
if (!template_path.empty()) {
if (add_route_dialog->name_template_is_default()) {
- _session->new_route_from_template (count, template_path, string());
+ _session->new_route_from_template (count, order, template_path, string());
} else {
- _session->new_route_from_template (count, template_path, add_route_dialog->name_template());
+ _session->new_route_from_template (count, order, template_path, add_route_dialog->name_template());
}
return;
}
PluginInfoPtr instrument = add_route_dialog->requested_instrument ();
RouteGroup* route_group = add_route_dialog->route_group ();
AutoConnectOption oac = Config->get_output_auto_connect();
+ bool strict_io = add_route_dialog->use_strict_io ();
if (oac & AutoConnectMaster) {
output_chan.set (DataType::AUDIO, (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan.n_audio()));
/* XXX do something with name template */
+ Session::ProcessorChangeBlocker pcb (_session);
+
switch (add_route_dialog->type_wanted()) {
case AddRouteDialog::AudioTrack:
- session_add_audio_track (input_chan.n_audio(), output_chan.n_audio(), add_route_dialog->mode(), route_group, count, name_template);
+ session_add_audio_track (input_chan.n_audio(), output_chan.n_audio(), add_route_dialog->mode(), route_group, count, name_template, strict_io, order);
break;
case AddRouteDialog::MidiTrack:
- session_add_midi_track (route_group, count, name_template, instrument);
+ session_add_midi_track (route_group, count, name_template, strict_io, instrument, 0, order);
break;
case AddRouteDialog::MixedTrack:
- session_add_mixed_track (input_chan, output_chan, route_group, count, name_template, instrument);
+ session_add_mixed_track (input_chan, output_chan, route_group, count, name_template, strict_io, instrument, 0, order);
break;
case AddRouteDialog::AudioBus:
- session_add_audio_bus (input_chan.n_audio(), output_chan.n_audio(), route_group, count, name_template);
+ session_add_audio_bus (input_chan.n_audio(), output_chan.n_audio(), route_group, count, name_template, strict_io, order);
+ break;
+ case AddRouteDialog::MidiBus:
+ session_add_midi_bus (route_group, count, name_template, strict_io, instrument, 0, order);
+ break;
+ case AddRouteDialog::VCAMaster:
+ session_add_vca (name_template, count);
break;
}
}
std::string icsd_exec = video_server_dialog->get_exec_path();
std::string icsd_docroot = video_server_dialog->get_docroot();
- if (icsd_docroot.empty()) {
#ifndef PLATFORM_WINDOWS
- icsd_docroot = X_("/");
-#else
- icsd_docroot = X_("C:\\");
-#endif
+ if (icsd_docroot.empty()) {
+ icsd_docroot = VideoUtils::video_get_docroot (Config);
}
+#endif
GStatBuf sb;
+#ifdef PLATFORM_WINDOWS
+ if (VideoUtils::harvid_version >= 0x000802 && icsd_docroot.empty()) {
+ /* OK, allow all drive letters */
+ } else
+#endif
if (g_lstat (icsd_docroot.c_str(), &sb) != 0 || !S_ISDIR(sb.st_mode)) {
warning << _("Specified docroot is not an existing directory.") << endmsg;
continue;
argp[8] = 0;
stop_video_server();
+#ifdef PLATFORM_WINDOWS
+ if (VideoUtils::harvid_version >= 0x000802 && icsd_docroot.empty()) {
+ /* OK, allow all drive letters */
+ } else
+#endif
if (icsd_docroot == X_("/") || icsd_docroot == X_("C:\\")) {
Config->set_video_advanced_setup(false);
} else {
- std::ostringstream osstream;
- osstream << "http://127.0.0.1:" << video_server_dialog->get_listenport() << "/";
- Config->set_video_server_url(osstream.str());
+ std::string url_str = "http://127.0.0.1:" + to_string(video_server_dialog->get_listenport()) + "/";
+ Config->set_video_server_url(url_str);
Config->set_video_server_docroot(icsd_docroot);
Config->set_video_advanced_setup(true);
}
if (video_timeline->video_file_info(path, local_file)) {
XMLNode* node = new XMLNode(X_("Videotimeline"));
- node->add_property (X_("Filename"), path);
- node->add_property (X_("AutoFPS"), auto_set_session_fps?X_("1"):X_("0"));
- node->add_property (X_("LocalFile"), local_file?X_("1"):X_("0"));
+ node->set_property (X_("Filename"), path);
+ node->set_property (X_("AutoFPS"), auto_set_session_fps);
+ node->set_property (X_("LocalFile"), local_file);
if (orig_local_file) {
- node->add_property (X_("OriginalVideoFile"), orig_path);
+ node->set_property (X_("OriginalVideoFile"), orig_path);
} else {
node->remove_property (X_("OriginalVideoFile"));
}
export_video_dialog->hide ();
}
+XMLNode*
+ARDOUR_UI::preferences_settings () const
+{
+ XMLNode* node = 0;
+
+ if (_session) {
+ node = _session->instant_xml(X_("Preferences"));
+ } else {
+ node = Config->instant_xml(X_("Preferences"));
+ }
+
+ if (!node) {
+ node = new XMLNode (X_("Preferences"));
+ }
+
+ return node;
+}
+
XMLNode*
ARDOUR_UI::mixer_settings () const
{
return node;
}
+XMLNode*
+ARDOUR_UI::main_window_settings () const
+{
+ XMLNode* node = 0;
+
+ if (_session) {
+ node = _session->instant_xml(X_("Main"));
+ } else {
+ node = Config->instant_xml(X_("Main"));
+ }
+
+ if (!node) {
+ if (getenv("ARDOUR_INSTANT_XML_PATH")) {
+ node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
+ }
+ }
+
+ if (!node) {
+ node = new XMLNode (X_("Main"));
+ }
+
+ return node;
+}
+
XMLNode*
ARDOUR_UI::editor_settings () const
{
ARDOUR_UI::create_xrun_marker (framepos_t where)
{
if (_session) {
- Location *location = new Location (*_session, where, where, _("xrun"), Location::IsMark);
+ Location *location = new Location (*_session, where, where, _("xrun"), Location::IsMark, 0);
_session->locations()->add (location);
}
}
void
ARDOUR_UI::halt_on_xrun_message ()
{
- cerr << "HALT on xrun\n";
- MessageDialog msg (*editor, _("Recording was stopped because your system could not keep up."));
+ cerr << "HALT on xrun\n";
+ MessageDialog msg (_main_window, _("Recording was stopped because your system could not keep up."));
msg.run ();
}
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
- MessageDialog* msg = new MessageDialog (*editor, string_compose (_("\
+ MessageDialog* msg = new MessageDialog (_main_window, string_compose (_("\
The disk system on your computer\n\
was not able to keep up with %1.\n\
\n\
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\
+ _main_window, 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\
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 = new MessageDialog (msg, false, MESSAGE_INFO, BUTTONS_OK, true);
d->show_all ();
d->run ();
delete d;
int
ARDOUR_UI::sr_mismatch_dialog (framecnt_t desired, framecnt_t actual)
{
- HBox* hbox = new HBox();
+ HBox* hbox = new HBox();
Image* image = new Image (Stock::DIALOG_WARNING, ICON_SIZE_DIALOG);
ArdourDialog dialog (_("Sample Rate Mismatch"), true);
Label message (string_compose (_("\
case RESPONSE_ACCEPT:
return 0;
default:
- break;
+ break;
}
- return 1;
+ return 1;
+}
+
+void
+ARDOUR_UI::sr_mismatch_message (framecnt_t desired, framecnt_t actual)
+{
+ MessageDialog msg (string_compose (_("\
+This session was created with a sample rate of %1 Hz, but\n\
+%2 is currently running at %3 Hz.\n\
+Audio will be recorded and played at the wrong sample rate.\n\
+Re-Configure the Audio Engine in\n\
+Menu > Window > Audio/Midi Setup"),
+ desired, PROGRAM_NAME, actual),
+ true,
+ Gtk::MESSAGE_WARNING);
+ msg.run ();
}
void
{
ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
- if (!_session || !big_clock_window) {
+ if (!_session) {
/* why bother - the clock isn't visible */
return;
}
- if (_session->record_status () == Session::Recording && _session->have_rec_enabled_track ()) {
- big_clock->set_active (true);
- } else {
- big_clock->set_active (false);
+ ActionManager::set_sensitive (ActionManager::rec_sensitive_actions, !_session->actively_recording());
+
+ if (big_clock_window) {
+ if (_session->record_status () == Session::Recording && _session->have_rec_enabled_track ()) {
+ big_clock->set_active (true);
+ } else {
+ big_clock->set_active (false);
+ }
}
+
}
bool
editor->first_idle();
}
+ /* in 1 second, hide the splash screen
+ *
+ * Consider hiding it *now*. If a user opens opens a dialog
+ * during that one second while the splash is still visible,
+ * the dialog will push-back the splash.
+ * Closing the dialog later will pop it back.
+ */
+ Glib::signal_timeout().connect (sigc::bind (sigc::ptr_fun (_hide_splash), this), 1000);
+
Keyboard::set_can_save_keybindings (true);
return false;
}
for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
XMLNode* child = new XMLNode (X_("Clock"));
- child->add_property (X_("name"), (*x)->name());
- child->add_property (X_("mode"), enum_2_string ((*x)->mode()));
- child->add_property (X_("on"), ((*x)->off() ? X_("no") : X_("yes")));
+ child->set_property (X_("name"), (*x)->name());
+ child->set_property (X_("mode"), (*x)->mode());
+ child->set_property (X_("on"), (*x)->on());
node->add_child_nocopy (*child);
}
}
void
-ARDOUR_UI::TransportControllable::set_value (double val)
+ARDOUR_UI::TransportControllable::set_value (double val, PBD::Controllable::GroupControlDisposition /*group_override*/)
{
if (val < 0.5) {
/* do nothing: these are radio-style actions */
Profile->set_small_screen ();
}
- if (g_getenv ("ARDOUR_SAE")) {
- Profile->set_sae ();
- Profile->set_single_package ();
- }
-
if (g_getenv ("TRX")) {
Profile->set_trx ();
}
const char* end_mono = "</tt>";
MessageDialog msg (string_compose (_("%4This is a session from an older version of %3%5\n\n"
- "%3 has copied the old session file\n\n%6%1%7\n\nto\n\n%6%2%7\n\n"
- "From now on, use the -2000 version with older versions of %3"),
- xml_path, backup_path, PROGRAM_NAME,
- start_big, end_big,
- start_mono, end_mono), true);
+ "%3 has copied the old session file\n\n%6%1%7\n\nto\n\n%6%2%7\n\n"
+ "From now on, use the backup copy with older versions of %3"),
+ xml_path, backup_path, PROGRAM_NAME,
+ start_big, end_big,
+ start_mono, end_mono), true);
msg.run ();
}
+void
+ARDOUR_UI::add_editor_meter_type_item (Menu_Helpers::MenuList& items, RadioMenuItem::Group& group, string const & name, MeterType type)
+{
+ using namespace Menu_Helpers;
+
+ items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (editor_meter, &LevelMeterHBox::set_meter_type), type)));
+ RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
+ i->set_active (editor_meter->meter_type () == type);
+}
+
+void
+ARDOUR_UI::popup_editor_meter_menu (GdkEventButton* ev)
+{
+ using namespace Gtk::Menu_Helpers;
+
+ Gtk::Menu* m = manage (new Menu);
+ MenuList& items = m->items ();
+
+ RadioMenuItem::Group group;
+
+ _suspend_editor_meter_callbacks = true;
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterPeak), MeterPeak);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterPeak0dB), MeterPeak0dB);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterKrms), MeterKrms);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC1DIN), MeterIEC1DIN);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC1NOR), MeterIEC1NOR);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC2BBC), MeterIEC2BBC);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterIEC2EBU), MeterIEC2EBU);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK20), MeterK20);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK14), MeterK14);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterK12), MeterK12);
+ add_editor_meter_type_item (items, group, ArdourMeter::meter_type_string(MeterVU), MeterVU);
+
+ m->popup (ev->button, ev->time);
+ _suspend_editor_meter_callbacks = false;
+}
+
+bool
+ARDOUR_UI::editor_meter_button_press (GdkEventButton* ev)
+{
+ if (ev->button == 3 && editor_meter) {
+ popup_editor_meter_menu (ev);
+ return true;
+ }
+ return false;
+}
void
ARDOUR_UI::reset_peak_display ()
audio_midi_setup->set_desired_sample_rate (desired_sample_rate);
audio_midi_setup->set_position (WIN_POS_CENTER);
- int response;
+ if (desired_sample_rate != 0) {
+ if (Config->get_try_autostart_engine () || getenv ("TRY_AUTOSTART_ENGINE")) {
+ audio_midi_setup->try_autostart ();
+ if (ARDOUR::AudioEngine::instance()->running()) {
+ return 0;
+ }
+ }
+ }
while (true) {
- response = audio_midi_setup->run();
+ int response = audio_midi_setup->run();
switch (response) {
- case Gtk::RESPONSE_OK:
+ case Gtk::RESPONSE_DELETE_EVENT:
+ // after latency callibration engine may run,
+ // Running() signal was emitted, but dialog will not
+ // have emitted a response. The user needs to close
+ // the dialog -> Gtk::RESPONSE_DELETE_EVENT
+ if (!AudioEngine::instance()->running()) {
+ return -1;
+ }
+ // fall through
+ default:
if (!AudioEngine::instance()->running()) {
continue;
- } else {
- return 0;
}
+ audio_midi_setup->hide ();
return 0;
- default:
- return -1;
}
}
}
_pending_locate_num = _pending_locate_num*10 + num;
} else {
switch (num) {
- case 0: toggle_roll(false, false); break;
- case 1: transport_rewind(1); break;
- case 2: transport_forward(1); break;
- case 3: transport_record(true); break;
+ case 0: toggle_roll(false, false); break;
+ case 1: transport_rewind(1); break;
+ case 2: transport_forward(1); break;
+ case 3: transport_record(true); break;
case 4: toggle_session_auto_loop(); break;
- case 5: transport_record(false); toggle_session_auto_loop(); break;
- case 6: toggle_punch(); break;
- case 7: toggle_click(); break;
+ case 5: transport_record(false); toggle_session_auto_loop(); break;
+ case 6: toggle_punch(); break;
+ case 7: toggle_click(); break;
case 8: toggle_auto_return(); break;
case 9: toggle_follow_edits(); break;
}
void
ARDOUR_UI::hide_application ()
{
- Application::instance ()-> hide ();
+ Application::instance ()-> hide ();
+}
+
+void
+ARDOUR_UI::setup_toplevel_window (Gtk::Window& window, const string& name, void* owner)
+{
+ /* icons, titles, WM stuff */
+
+ static list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
+
+ if (window_icons.empty()) {
+ Glib::RefPtr<Gdk::Pixbuf> icon;
+ if ((icon = ::get_icon (PROGRAM_NAME "-icon_16px"))) {
+ window_icons.push_back (icon);
+ }
+ if ((icon = ::get_icon (PROGRAM_NAME "-icon_22px"))) {
+ window_icons.push_back (icon);
+ }
+ if ((icon = ::get_icon (PROGRAM_NAME "-icon_32px"))) {
+ window_icons.push_back (icon);
+ }
+ if ((icon = ::get_icon (PROGRAM_NAME "-icon_48px"))) {
+ window_icons.push_back (icon);
+ }
+ }
+
+ if (!window_icons.empty()) {
+ window.set_default_icon_list (window_icons);
+ }
+
+ Gtkmm2ext::WindowTitle title (Glib::get_application_name());
+
+ if (!name.empty()) {
+ title += name;
+ }
+
+ window.set_title (title.get_string());
+ window.set_wmclass (string_compose (X_("%1_%1"), downcase (std::string(PROGRAM_NAME)), downcase (name)), PROGRAM_NAME);
+
+ window.set_flags (CAN_FOCUS);
+ window.add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
+
+ /* This is a hack to ensure that GTK-accelerators continue to
+ * work. Once we switch over to entirely native bindings, this will be
+ * unnecessary and should be removed
+ */
+ window.add_accel_group (ActionManager::ui_manager->get_accel_group());
+
+ window.signal_configure_event().connect (sigc::mem_fun (*this, &ARDOUR_UI::configure_handler));
+ window.signal_window_state_event().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::tabbed_window_state_event_handler), owner));
+ window.signal_key_press_event().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::key_event_handler), &window), false);
+ window.signal_key_release_event().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::key_event_handler), &window), false);
+}
+
+bool
+ARDOUR_UI::key_event_handler (GdkEventKey* ev, Gtk::Window* event_window)
+{
+ Gtkmm2ext::Bindings* bindings = 0;
+ Gtk::Window* window = 0;
+
+ /* until we get ardour bindings working, we are not handling key
+ * releases yet.
+ */
+
+ if (ev->type != GDK_KEY_PRESS) {
+ return false;
+ }
+
+ if (event_window == &_main_window) {
+
+ window = event_window;
+
+ /* find current tab contents */
+
+ Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page());
+
+ /* see if it uses the ardour binding system */
+
+ if (w) {
+ bindings = reinterpret_cast<Gtkmm2ext::Bindings*>(w->get_data ("ardour-bindings"));
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, string_compose ("main window key event, bindings = %1, global = %2\n", bindings, &global_bindings));
+
+ } else {
+
+ window = event_window;
+
+ /* see if window uses ardour binding system */
+
+ bindings = reinterpret_cast<Gtkmm2ext::Bindings*>(window->get_data ("ardour-bindings"));
+ }
+
+ /* An empty binding set is treated as if it doesn't exist */
+
+ if (bindings && bindings->empty()) {
+ bindings = 0;
+ }
+
+ return key_press_focus_accelerator_handler (*window, ev, bindings);
+}
+
+static Gtkmm2ext::Bindings*
+get_bindings_from_widget_heirarchy (GtkWidget** w)
+{
+ void* p = NULL;
+
+ while (*w) {
+ if ((p = g_object_get_data (G_OBJECT(*w), "ardour-bindings")) != 0) {
+ break;
+ }
+ *w = gtk_widget_get_parent (*w);
+ }
+
+ return reinterpret_cast<Gtkmm2ext::Bindings*> (p);
+}
+
+bool
+ARDOUR_UI::key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev, Gtkmm2ext::Bindings* bindings)
+{
+ GtkWindow* win = window.gobj();
+ GtkWidget* focus = gtk_window_get_focus (win);
+ GtkWidget* binding_widget = focus;
+ bool special_handling_of_unmodified_accelerators = false;
+ const guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK));
+
+ if (focus) {
+
+ /* some widget has keyboard focus */
+
+ if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) {
+
+ /* A particular kind of focusable widget currently has keyboard
+ * focus. All unmodified key events should go to that widget
+ * first and not be used as an accelerator by default
+ */
+
+ special_handling_of_unmodified_accelerators = true;
+
+ } else {
+
+ Gtkmm2ext::Bindings* focus_bindings = get_bindings_from_widget_heirarchy (&binding_widget);
+ if (focus_bindings) {
+ bindings = focus_bindings;
+ DEBUG_TRACE (DEBUG::Accelerators, string_compose ("Switch bindings based on focus widget, now using %1\n", bindings->name()));
+ }
+ }
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, string_compose ("Win = %1 [title = %9] focus = %7 (%8) Key event: code = %2 state = %3 special handling ? %4 magic widget focus ? %5 focus widget %6 named %7 mods ? %8\n",
+ win,
+ ev->keyval,
+ Gtkmm2ext::show_gdk_event_state (ev->state),
+ special_handling_of_unmodified_accelerators,
+ Keyboard::some_magic_widget_has_focus(),
+ focus,
+ (focus ? gtk_widget_get_name (focus) : "no focus widget"),
+ ((ev->state & mask) ? "yes" : "no"),
+ window.get_title()));
+
+ /* This exists to allow us to override the way GTK handles
+ key events. The normal sequence is:
+
+ a) event is delivered to a GtkWindow
+ b) accelerators/mnemonics are activated
+ c) if (b) didn't handle the event, propagate to
+ the focus widget and/or focus chain
+
+ The problem with this is that if the accelerators include
+ keys without modifiers, such as the space bar or the
+ letter "e", then pressing the key while typing into
+ a text entry widget results in the accelerator being
+ activated, instead of the desired letter appearing
+ in the text entry.
+
+ There is no good way of fixing this, but this
+ represents a compromise. The idea is that
+ key events involving modifiers (not Shift)
+ get routed into the activation pathway first, then
+ get propagated to the focus widget if necessary.
+
+ If the key event doesn't involve modifiers,
+ we deliver to the focus widget first, thus allowing
+ it to get "normal text" without interference
+ from acceleration.
+
+ Of course, this can also be problematic: if there
+ is a widget with focus, then it will swallow
+ all "normal text" accelerators.
+ */
+
+
+ if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) {
+
+ /* no special handling or there are modifiers in effect: accelerate first */
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tactivate, then propagate\n");
+ DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tevent send-event:%1 time:%2 length:%3 name %7 string:%4 hardware_keycode:%5 group:%6\n",
+ ev->send_event, ev->time, ev->length, ev->string, ev->hardware_keycode, ev->group, gdk_keyval_name (ev->keyval)));
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tsending to window\n");
+ KeyboardKey k (ev->state, ev->keyval);
+
+ while (bindings) {
+
+ DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tusing Ardour bindings %1 @ %2 for this event\n", bindings->name(), bindings));
+
+ if (bindings->activate (k, Bindings::Press)) {
+ DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
+ return true;
+ }
+
+ if (binding_widget) {
+ binding_widget = gtk_widget_get_parent (binding_widget);
+ if (binding_widget) {
+ bindings = get_bindings_from_widget_heirarchy (&binding_widget);
+ } else {
+ bindings = 0;
+ }
+ } else {
+ bindings = 0;
+ }
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tnot yet handled, try global bindings\n");
+
+ if (global_bindings && global_bindings->activate (k, Bindings::Press)) {
+ DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
+ return true;
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tnot accelerated, now propagate\n");
+
+ if (gtk_window_propagate_key_event (win, ev)) {
+ DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate handled\n");
+ return true;
+ }
+
+ } else {
+
+ /* no modifiers, propagate first */
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate, then activate\n");
+
+ if (gtk_window_propagate_key_event (win, ev)) {
+ DEBUG_TRACE (DEBUG::Accelerators, "\thandled by propagate\n");
+ return true;
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tpropagation didn't handle, so activate\n");
+ KeyboardKey k (ev->state, ev->keyval);
+
+ while (bindings) {
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tusing Ardour bindings for this window\n");
+
+
+ if (bindings->activate (k, Bindings::Press)) {
+ DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
+ return true;
+ }
+
+ if (binding_widget) {
+ binding_widget = gtk_widget_get_parent (binding_widget);
+ if (binding_widget) {
+ bindings = get_bindings_from_widget_heirarchy (&binding_widget);
+ } else {
+ bindings = 0;
+ }
+ } else {
+ bindings = 0;
+ }
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tnot yet handled, try global bindings\n");
+
+ if (global_bindings && global_bindings->activate (k, Bindings::Press)) {
+ DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
+ return true;
+ }
+ }
+
+ DEBUG_TRACE (DEBUG::Accelerators, "\tnot handled\n");
+ return true;
+}
+
+void
+ARDOUR_UI::load_bindings ()
+{
+ if ((global_bindings = Bindings::get_bindings (X_("Global"), global_actions)) == 0) {
+ error << _("Global keybindings are missing") << endmsg;
+ }
}
void
ARDOUR_UI::cancel_solo ()
{
if (_session) {
- if (_session->soloing()) {
- _session->set_solo (_session->get_routes(), false);
- } else if (_session->listening()) {
- _session->set_listen (_session->get_routes(), false);
+ _session->cancel_all_solo ();
+ }
+}
+
+void
+ARDOUR_UI::reset_focus (Gtk::Widget* w)
+{
+ /* this resets focus to the first focusable parent of the given widget,
+ * or, if there is no focusable parent, cancels focus in the toplevel
+ * window that the given widget is packed into (if there is one).
+ */
+
+ if (!w) {
+ return;
+ }
+
+ Gtk::Widget* top = w->get_toplevel();
+
+ if (!top || !top->is_toplevel()) {
+ return;
+ }
+
+ w = w->get_parent ();
+
+ while (w) {
+
+ if (w->is_toplevel()) {
+ /* Setting the focus widget to a Gtk::Window causes all
+ * subsequent calls to ::has_focus() on the nominal
+ * focus widget in that window to return
+ * false. Workaround: never set focus to the toplevel
+ * itself.
+ */
+ break;
+ }
+
+ if (w->get_can_focus ()) {
+ Gtk::Window* win = dynamic_cast<Gtk::Window*> (top);
+ win->set_focus (*w);
+ return;
}
+ w = w->get_parent ();
+ }
+
+ if (top == &_main_window) {
- _session->clear_all_solo_state (_session->get_routes()); // safeguard, ideally this won't do anything, check the log-window
}
+
+ /* no focusable parent found, cancel focus in top level window.
+ C++ API cannot be used for this. Thanks, references.
+ */
+
+ gtk_window_set_focus (GTK_WINDOW(top->gobj()), 0);
+
}
projects / ardour.git / blobdiff