#include "pbd/error.h"
#include "pbd/basename.h"
#include "pbd/compose.h"
+#include "pbd/convert.h"
#include "pbd/failed_constructor.h"
#include "pbd/enumwriter.h"
#include "pbd/memento_command.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/slave.h"
#include "ardour/system_exec.h"
+#include "LuaBridge/LuaBridge.h"
+
#ifdef WINDOWS_VST_SUPPORT
#include <fst.h>
#endif
#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 "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 "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 "route_time_axis.h"
#include "route_params_ui.h"
#include "save_as_dialog.h"
+#include "script_selector.h"
#include "session_dialog.h"
#include "session_metadata_dialog.h"
#include "session_option_editor.h"
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)
, 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)
, editor (0)
, mixer (0)
, 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"))
, 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"))
, 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"), _("Bindings Editor"), 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);
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 ();
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);
+ }
+
+ /* 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);
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;
+
+
vector<string> paths;
+ vector<string> labels;
vector<string> tooltips;
vector<string> keys;
- vector<AccelKey> bindings;
+ vector<Glib::RefPtr<Gtk::Action> > actions;
- ActionManager::get_all_actions (names, paths, tooltips, keys, bindings);
+ 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;
+
+ for (p = paths.begin(), k = keys.begin(); p != paths.end(); ++k, ++p) {
+
+ if ((*k).empty()) {
+ cout << *p << endl;
+ } else {
+ cout << *p << " => " << *k << endl;
+ }
}
halt_connection.disconnect ();
/* 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 meterbridge; meterbridge = 0;
+ delete luawindow; luawindow = 0;
+ delete editor; editor = 0;
+ delete mixer; mixer = 0;
+ delete nsm; nsm = 0;
+ delete gui_object_state; gui_object_state = 0;
FastMeter::flush_pattern_cache ();
PixFader::flush_pattern_cache ();
}
}
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 ()
{
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));
+
+ if (splash && splash->is_visible()) {
+ // in 1 second, hide the splash screen
+ Glib::signal_timeout().connect (sigc::bind (sigc::ptr_fun (_hide_splash), this), 1000);
+ }
+
+ /* 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\
{
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"),
+ _("%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 ();
void
ARDOUR_UI::open_session ()
{
- if (!check_audioengine(*editor)) {
+ if (!check_audioengine (_main_window)) {
return;
}
}
}
-
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_mixed_track (
+ const ChanCount& input,
+ const ChanCount& output,
+ RouteGroup* route_group,
+ uint32_t how_many,
+ const string& name_template,
+ bool strict_io,
+ PluginInfoPtr instrument)
{
list<boost::shared_ptr<MidiTrack> > tracks;
}
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;
+ }
+
+ if (strict_io) {
+ for (list<boost::shared_ptr<MidiTrack> >::iterator i = tracks.begin(); i != tracks.end(); ++i) {
+ (*i)->set_strict_io (true);
+ }
}
}
+void
+ARDOUR_UI::session_add_midi_bus (
+ RouteGroup* route_group,
+ uint32_t how_many,
+ const string& name_template,
+ bool strict_io,
+ PluginInfoPtr instrument)
+{
+ RouteList routes;
+
+ if (_session == 0) {
+ warning << _("You cannot add a track without a session already loaded.") << endmsg;
+ return;
+ }
+
+ try {
+ routes = _session->new_midi_route (route_group, how_many, name_template, instrument);
+ 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;
+ }
+
+ if (strict_io) {
+ for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ (*i)->set_strict_io (true);
+ }
+ }
+}
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)
{
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);
+ } else {
+ session_add_midi_bus (route_group, how_many, name_template, strict_io, instrument);
}
}
ARDOUR::TrackMode mode,
RouteGroup* route_group,
uint32_t how_many,
- string const & name_template
+ string const & name_template,
+ bool strict_io
)
{
list<boost::shared_ptr<AudioTrack> > tracks;
}
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
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 (rolling) {
_session->request_stop (with_abort, true);
} else {
+ /* 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;
}
{
float current_transport_speed;
- if (_session) {
+ if (_session) {
current_transport_speed = _session->transport_speed();
if (current_transport_speed >= 0.0f) {
if ((r = _session->route_by_remote_id (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->set_record_enabled (!t->record_enabled(), Controllable::UseGroup);
}
}
}
auto_loop_button.set_active (false);
}
- if (UIConfiguration::instance().get_follow_edits()) {
+ if (UIConfiguration::instance().get_follow_edits() && !_session->config.get_external_sync()) {
/* light up both roll and play-selection if they are joined */
roll_button.set_active (true);
play_selection_button.set_active (true);
}
- Session::SaveAs sa;
+ Session::SaveAs sa;
sa.new_parent_folder = save_as_dialog->new_parent_folder ();
sa.new_name = save_as_dialog->new_name ();
}
}
+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);
+
+ save_state (timebuf, switch_to_it);
+}
+
+
+bool
+ARDOUR_UI::process_snapshot_session_prompter (ArdourPrompter& prompter, bool switch_to_it)
+{
+ string snapname;
+
+ prompter.get_result (snapname);
+
+ bool do_save = (snapname.length() != 0);
+
+ if (do_save) {
+ 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));
+ msg.run ();
+ return false;
+ }
+ }
+
+ vector<std::string> p;
+ get_state_files_in_directory (_session->session_directory().root_path(), p);
+ vector<string> n = get_file_names_no_extension (p);
+
+ if (find (n.begin(), n.end(), snapname) != n.end()) {
+
+ do_save = overwrite_file_dialog (prompter,
+ _("Confirm Snapshot Overwrite"),
+ _("A snapshot already exists with that name. Do you want to overwrite it?"));
+ }
+
+ if (do_save) {
+ save_state (snapname, switch_to_it);
+ }
+ else {
+ return false;
+ }
+
+ return true;
+}
+
+
/** Ask the user for the name of a new snapshot and then take it.
*/
ARDOUR_UI::snapshot_session (bool switch_to_it)
{
ArdourPrompter prompter (true);
- string snapname;
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
prompter.set_prompt (_("Name of new snapshot"));
}
- if (!switch_to_it) {
+ if (switch_to_it) {
+ prompter.set_initial_text (_session->snap_name());
+ } else {
char timebuf[128];
time_t n;
struct tm local_time;
prompter.set_initial_text (timebuf);
}
- again:
- switch (prompter.run()) {
- case RESPONSE_ACCEPT:
- {
- prompter.get_result (snapname);
-
- bool do_save = (snapname.length() != 0);
-
- if (do_save) {
- 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));
- msg.run ();
- goto again;
- }
- }
-
- vector<std::string> p;
- get_state_files_in_directory (_session->session_directory().root_path(), p);
- vector<string> n = get_file_names_no_extension (p);
- if (find (n.begin(), n.end(), snapname) != n.end()) {
-
- ArdourDialog confirm (_("Confirm Snapshot Overwrite"), true);
- Label m (_("A snapshot already exists with that name. Do you want to overwrite it?"));
- confirm.get_vbox()->pack_start (m, true, true);
- confirm.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
- confirm.add_button (_("Overwrite"), Gtk::RESPONSE_ACCEPT);
- confirm.show_all ();
- switch (confirm.run()) {
- case RESPONSE_CANCEL:
- do_save = false;
- }
+ bool finished = false;
+ while (!finished) {
+ switch (prompter.run()) {
+ case RESPONSE_ACCEPT:
+ {
+ finished = process_snapshot_session_prompter (prompter, switch_to_it);
+ break;
}
- if (do_save) {
- save_state (snapname, switch_to_it);
+ default:
+ finished = true;
+ break;
}
- break;
- }
-
- default:
- break;
}
}
}
}
+bool
+ARDOUR_UI::process_save_template_prompter (ArdourPrompter& prompter)
+{
+ string name;
+
+ prompter.get_result (name);
+
+ if (name.length()) {
+ int failed = _session->save_template (name);
+
+ if (failed == -2) { /* file already exists. */
+ bool overwrite = overwrite_file_dialog (prompter,
+ _("Confirm Template Overwrite"),
+ _("A template already exists with that name. Do you want to overwrite it?"));
+
+ if (overwrite) {
+ _session->save_template (name, true);
+ }
+ else {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
void
ARDOUR_UI::save_template ()
{
ArdourPrompter prompter (true);
- string name;
- if (!check_audioengine(*editor)) {
+ if (!check_audioengine (_main_window)) {
return;
}
prompter.set_initial_text(_session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- switch (prompter.run()) {
- case RESPONSE_ACCEPT:
- prompter.get_result (name);
+ bool finished = false;
+ while (!finished) {
+ switch (prompter.run()) {
+ case RESPONSE_ACCEPT:
+ finished = process_save_template_prompter (prompter);
+ break;
- if (name.length()) {
- _session->save_template (name);
+ default:
+ finished = true;
+ break;
}
- break;
-
- default:
- break;
}
}
{
BusProfile bus_profile;
- if (nsm || Profile->get_sae()) {
+ if (nsm) {
bus_profile.master_out_channels = 2;
bus_profile.input_ac = AutoConnectPhysical;
ARDOUR_UI::load_from_application_api (const std::string& path)
{
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);
+ }
}
}
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
}
}
+ _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).
session_loaded = true;
- goto_editor_window ();
-
if (_session) {
_session->set_clean ();
}
fst_stop_threading();
#endif
- flush_pending ();
+ {
+ Timers::TimerSuspender t;
+ flush_pending ();
+ }
#ifdef WINDOWS_VST_SUPPORT
fst_start_threading();
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
removed = rep.paths.size();
if (removed == 0) {
- MessageDialog msgd (*editor,
+ MessageDialog msgd (_main_window,
_("No files were ready for clean-up"),
true,
Gtk::MESSAGE_INFO,
}
}
+void
+ARDOUR_UI::start_duplicate_routes ()
+{
+ if (!duplicate_routes_dialog) {
+ duplicate_routes_dialog = new DuplicateRouteDialog;
+ }
+
+ if (duplicate_routes_dialog->restart (_session)) {
+ return;
+ }
+
+ duplicate_routes_dialog->present ();
+}
+
void
ARDOUR_UI::add_route (Gtk::Window* /* ignored */)
{
}
setup_order_hint(add_route_dialog->insert_at());
-
string template_path = add_route_dialog->track_template();
DisplaySuspender ds;
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()));
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);
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);
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);
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);
+ break;
+ case AddRouteDialog::MidiBus:
+ session_add_midi_bus (route_group, count, name_template, strict_io, instrument);
break;
}
}
+void
+ARDOUR_UI::add_lua_script ()
+{
+ if (!_session) {
+ return;
+ }
+
+ LuaScriptInfoPtr spi;
+ ScriptSelector ss ("Add Lua Session Script", LuaScriptInfo::Session);
+ switch (ss.run ()) {
+ case Gtk::RESPONSE_ACCEPT:
+ spi = ss.script();
+ break;
+ default:
+ return;
+ }
+ ss.hide();
+
+ std::string script = "";
+
+ try {
+ script = Glib::file_get_contents (spi->path);
+ } catch (Glib::FileError e) {
+ string msg = string_compose (_("Cannot read session script '%1': %2"), spi->path, e.what());
+ MessageDialog am (msg);
+ am.run ();
+ return;
+ }
+
+ LuaScriptParamList lsp = LuaScriptParams::script_params (spi, "sess_params");
+ std::vector<std::string> reg = _session->registered_lua_functions ();
+
+ ScriptParameterDialog spd (_("Set Script Parameters"), spi, reg, lsp);
+ switch (spd.run ()) {
+ case Gtk::RESPONSE_ACCEPT:
+ break;
+ default:
+ return;
+ }
+
+ try {
+ _session->register_lua_function (spd.name(), script, lsp);
+ } catch (luabridge::LuaException const& e) {
+ string msg = string_compose (_("Session script '%1' instantiation failed: %2"), spd.name(), e.what ());
+ MessageDialog am (msg);
+ am.run ();
+ } catch (SessionException e) {
+ string msg = string_compose (_("Loading Session script '%1' failed: %2"), spd.name(), e.what ());
+ MessageDialog am (msg);
+ am.run ();
+ }
+}
+
+void
+ARDOUR_UI::remove_lua_script ()
+{
+ if (!_session) {
+ return;
+ }
+ if (_session->registered_lua_function_count () == 0) {
+ string msg = _("There are no active Lua session scripts present in this session.");
+ MessageDialog am (msg);
+ am.run ();
+ return;
+ }
+
+ std::vector<std::string> reg = _session->registered_lua_functions ();
+ SessionScriptManager sm ("Remove Lua Session Script", reg);
+ switch (sm.run ()) {
+ case Gtk::RESPONSE_ACCEPT:
+ break;
+ default:
+ return;
+ }
+ try {
+ _session->unregister_lua_function (sm.name());
+ } catch (luabridge::LuaException const& e) {
+ string msg = string_compose (_("Session script '%1' removal failed: %2"), sm.name(), e.what ());
+ MessageDialog am (msg);
+ am.run ();
+ }
+}
+
void
ARDOUR_UI::stop_video_server (bool ask_confirm)
{
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::halt_on_xrun_message ()
{
cerr << "HALT on xrun\n";
- MessageDialog msg (*editor, _("Recording was stopped because your system could not keep up."));
+ 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 (_("\
}
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 ();
}
dialog.present ();
dialog.run ();
+
return dialog.get_which ();
}
_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;
}
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 ("ardour_icon_16px")) != 0) {
+ window_icons.push_back (icon);
+ }
+ if ((icon = ::get_icon ("ardour_icon_22px")) != 0) {
+ window_icons.push_back (icon);
+ }
+ if ((icon = ::get_icon ("ardour_icon_32px")) != 0) {
+ window_icons.push_back (icon);
+ }
+ if ((icon = ::get_icon ("ardour_icon_48px")) != 0) {
+ 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 (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;
+
+ 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);
+ 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 (focus);
+ 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 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,
+ 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")));
+
+ /* 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);
+
+ if (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;
+ }
+ }
+
+ 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);
+
+ if (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;
+ }
+
+ }
+
+ 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 ()
{
projects / ardour.git / blobdiff