/*
- Copyright (C) 1999-2007 Paul Davis
+ Copyright (C) 1999-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#define __STDC_FORMAT_MACROS 1
+#ifdef WAF_BUILD
+#include "gtk2ardour-config.h"
+#endif
+
#include <stdint.h>
#include <algorithm>
#include <gtkmm/messagedialog.h>
#include <gtkmm/accelmap.h>
-#include <pbd/error.h>
-#include <pbd/basename.h>
-#include <pbd/compose.h>
-#include <pbd/failed_constructor.h>
-#include <pbd/enumwriter.h>
-#include <pbd/memento_command.h>
-#include <pbd/file_utils.h>
-
-#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/utils.h>
-#include <gtkmm2ext/click_box.h>
-#include <gtkmm2ext/fastmeter.h>
-#include <gtkmm2ext/stop_signal.h>
-#include <gtkmm2ext/popup.h>
-#include <gtkmm2ext/window_title.h>
-
-#include <midi++/manager.h>
-
-#include <ardour/ardour.h>
-#include <ardour/profile.h>
-#include <ardour/session_directory.h>
-#include <ardour/session_route.h>
-#include <ardour/session_state_utils.h>
-#include <ardour/session_utils.h>
-#include <ardour/port.h>
-#include <ardour/audioengine.h>
-#include <ardour/playlist.h>
-#include <ardour/utils.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/recent_sessions.h>
-#include <ardour/port.h>
-#include <ardour/audio_track.h>
-#include <ardour/midi_track.h>
-#include <ardour/filesystem_paths.h>
-#include <ardour/filename_extensions.h>
+#include "pbd/error.h"
+#include "pbd/basename.h"
+#include "pbd/compose.h"
+#include "pbd/failed_constructor.h"
+#include "pbd/enumwriter.h"
+#include "pbd/memento_command.h"
+#include "pbd/openuri.h"
+#include "pbd/file_utils.h"
+
+#include "gtkmm2ext/application.h"
+#include "gtkmm2ext/bindings.h"
+#include "gtkmm2ext/gtk_ui.h"
+#include "gtkmm2ext/utils.h"
+#include "gtkmm2ext/click_box.h"
+#include "gtkmm2ext/fastmeter.h"
+#include "gtkmm2ext/popup.h"
+#include "gtkmm2ext/window_title.h"
+
+#include "midi++/manager.h"
+
+#include "ardour/ardour.h"
+#include "ardour/callback.h"
+#include "ardour/profile.h"
+#include "ardour/plugin_manager.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_route.h"
+#include "ardour/session_state_utils.h"
+#include "ardour/session_utils.h"
+#include "ardour/port.h"
+#include "ardour/audioengine.h"
+#include "ardour/playlist.h"
+#include "ardour/utils.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/recent_sessions.h"
+#include "ardour/port.h"
+#include "ardour/audio_track.h"
+#include "ardour/midi_track.h"
+#include "ardour/filesystem_paths.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/process_thread.h"
typedef uint64_t microseconds_t;
+#include "about.h"
#include "actions.h"
+#include "add_route_dialog.h"
+#include "ambiguous_file_dialog.h"
#include "ardour_ui.h"
-#include "public_editor.h"
#include "audio_clock.h"
+#include "bundle_manager.h"
+#include "engine_dialog.h"
+#include "gain_meter.h"
+#include "global_port_matrix.h"
+#include "gui_object.h"
+#include "gui_thread.h"
#include "keyboard.h"
+#include "location_ui.h"
+#include "missing_file_dialog.h"
+#include "missing_plugin_dialog.h"
#include "mixer_ui.h"
-#include "prompter.h"
#include "opts.h"
-#include "add_route_dialog.h"
-#include "new_session_dialog.h"
-#include "about.h"
+#include "processor_box.h"
+#include "prompter.h"
+#include "public_editor.h"
+#include "route_time_axis.h"
+#include "session_metadata_dialog.h"
+#include "shuttle_control.h"
+#include "speaker_dialog.h"
#include "splash.h"
-#include "utils.h"
-#include "gui_thread.h"
+#include "startup.h"
#include "theme_manager.h"
-#include "bundle_manager.h"
-#include "session_metadata_dialog.h"
-#include "gain_meter.h"
-#include "route_time_axis.h"
+#include "time_axis_view_item.h"
+#include "utils.h"
+#include "window_proxy.h"
#include "i18n.h"
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
UIConfiguration *ARDOUR_UI::ui_config = 0;
sigc::signal<void,bool> ARDOUR_UI::Blink;
sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
-sigc::signal<void,nframes_t, bool, nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void, framepos_t, bool, framepos_t> ARDOUR_UI::Clock;
-ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
+bool could_be_a_valid_path (const string& path);
- : Gtkmm2ext::UI (X_("Ardour"), argcp, argvp),
-
- primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, false, true),
- secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, false, true),
- preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true),
- postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true),
+ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
- /* preroll stuff */
+ : Gtkmm2ext::UI (PROGRAM_NAME, argcp, argvp)
- preroll_button (_("pre\nroll")),
- postroll_button (_("post\nroll")),
+ , gui_object_state (new GUIObjectState)
+ , primary_clock (new AudioClock (X_("primary"), false, X_("transport"), true, true, false, true))
+ , secondary_clock (new AudioClock (X_("secondary"), false, X_("secondary"), true, true, false, true))
/* big clock */
- big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
+ , big_clock (new AudioClock (X_("bigclock"), false, "big", true, true, false, false))
/* transport */
- roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll)),
- stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop)),
- goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart)),
- goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd)),
- auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop)),
- play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection)),
- rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable)),
- shuttle_controllable (new TransportControllable ("shuttle", *this, TransportControllable::ShuttleControl)),
- shuttle_controller_binding_proxy (shuttle_controllable),
-
- roll_button (roll_controllable),
- stop_button (stop_controllable),
- goto_start_button (goto_start_controllable),
- goto_end_button (goto_end_controllable),
- auto_loop_button (auto_loop_controllable),
- play_selection_button (play_selection_controllable),
- rec_button (rec_controllable),
-
- shuttle_units_button (_("% ")),
-
- punch_in_button (_("Punch In")),
- punch_out_button (_("Punch Out")),
- auto_return_button (_("Auto Return")),
- auto_play_button (_("Auto Play")),
- auto_input_button (_("Auto Input")),
- click_button (_("Click")),
- time_master_button (_("time\nmaster")),
-
- auditioning_alert_button (_("AUDITION")),
- solo_alert_button (_("SOLO")),
- shown_flag (false),
- error_log_button (_("Errors"))
+ , roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll))
+ , stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop))
+ , goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart))
+ , goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd))
+ , auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop))
+ , play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection))
+ , rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable))
+
+ , auto_return_button (ArdourButton::led_default_elements)
+ , auto_play_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_log_button (_("Errors"))
+
+ , _status_bar_visibility (X_("status-bar"))
+ , _feedback_exists (false)
{
using namespace Gtk::Menu_Helpers;
Gtkmm2ext::init();
-
+
#ifdef TOP_MENUBAR
- _auto_display_errors = false;
+ // _auto_display_errors = false;
+ /*
+ * This was commented out as it wasn't defined
+ * in A3 IIRC. If this is not needed it should
+ * be completely removed.
+ */
#endif
about = 0;
splash = 0;
-
- if (ARDOUR_COMMAND_LINE::session_name.length()) {
- /* only show this if we're not going to post the new session dialog */
- show_splash ();
- }
+ _startup = 0;
if (theArdourUI == 0) {
theArdourUI = this;
ui_config = new UIConfiguration();
theme_manager = new ThemeManager();
-
+
+ key_editor = 0;
+
editor = 0;
mixer = 0;
- session = 0;
editor = 0;
engine = 0;
_session_is_new = false;
big_clock_window = 0;
+ big_clock_height = 0;
+ big_clock_resize_in_progress = false;
session_selector_window = 0;
last_key_press_time = 0;
_will_create_new_session_automatically = false;
- new_session_dialog = 0;
add_route_dialog = 0;
route_params = 0;
- option_editor = 0;
+ bundle_manager = 0;
+ rc_option_editor = 0;
+ session_option_editor = 0;
location_ui = 0;
open_session_selector = 0;
have_configure_timeout = false;
have_disk_speed_dialog_displayed = false;
session_loaded = false;
- last_speed_displayed = -1.0f;
ignore_dual_punch = false;
- _mixer_on_top = false;
+ original_big_clock_width = -1;
+ original_big_clock_height = -1;
+ original_big_clock_font_size = 0;
+
+ roll_button.set_controllable (roll_controllable);
+ stop_button.set_controllable (stop_controllable);
+ goto_start_button.set_controllable (goto_start_controllable);
+ goto_end_button.set_controllable (goto_end_controllable);
+ auto_loop_button.set_controllable (auto_loop_controllable);
+ play_selection_button.set_controllable (play_selection_controllable);
+ rec_button.set_controllable (rec_controllable);
+
+ roll_button.set_name ("transport button");
+ stop_button.set_name ("transport button");
+ goto_start_button.set_name ("transport button");
+ goto_end_button.set_name ("transport button");
+ auto_loop_button.set_name ("transport button");
+ play_selection_button.set_name ("transport button");
+ rec_button.set_name ("transport recenable button");
+ join_play_range_button.set_name ("transport button");
+ midi_panic_button.set_name ("transport button");
+
+ goto_start_button.set_tweaks (ArdourButton::ShowClick);
+ goto_end_button.set_tweaks (ArdourButton::ShowClick);
+ midi_panic_button.set_tweaks (ArdourButton::ShowClick);
+
+ last_configure_time= 0;
+ last_peak_grab = 0;
- roll_button.unset_flags (Gtk::CAN_FOCUS);
- stop_button.unset_flags (Gtk::CAN_FOCUS);
- goto_start_button.unset_flags (Gtk::CAN_FOCUS);
- goto_end_button.unset_flags (Gtk::CAN_FOCUS);
- auto_loop_button.unset_flags (Gtk::CAN_FOCUS);
- play_selection_button.unset_flags (Gtk::CAN_FOCUS);
- rec_button.unset_flags (Gtk::CAN_FOCUS);
+ ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context());
+ ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context());
- last_configure_time= 0;
+ /* handle dialog requests */
- shuttle_grabbed = false;
- shuttle_fract = 0.0;
- shuttle_max_speed = 8.0f;
+ ARDOUR::Session::Dialog.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
- shuttle_style_menu = 0;
- shuttle_unit_menu = 0;
+ /* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
- // We do not have jack linked in yet so;
-
- last_shuttle_request = last_peak_grab = 0; // get_microseconds();
-
- ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
- ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ ARDOUR::Session::AskAboutPendingState.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::pending_state_dialog, this));
- /* handle dialog requests */
+ /* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
+
+ ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
+
+ /* handle requests to quit (coming from JACK session) */
- ARDOUR::Session::Dialog.connect (mem_fun(*this, &ARDOUR_UI::session_dialog));
+ ARDOUR::Session::Quit.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::finish, this), gui_context ());
- /* handle pending state with a dialog */
+ /* tell the user about feedback */
- ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
+ ARDOUR::Session::FeedbackDetected.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::feedback_detected, this), gui_context ());
+ ARDOUR::Session::SuccessfulGraphSort.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::successful_graph_sort, this), gui_context ());
- /* handle sr mismatch with a dialog */
+ /* handle requests to deal with missing files */
- ARDOUR::Session::AskAboutSampleRateMismatch.connect (mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
+ ARDOUR::Session::MissingFile.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::missing_file, this, _1, _2, _3));
+
+ /* and ambiguous files */
+
+ ARDOUR::FileSource::AmbiguousFileName.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::ambiguous_file, this, _1, _2, _3));
/* lets get this party started */
- try {
+ try {
if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) {
throw failed_constructor ();
}
setup_gtk_ardour_enums ();
- Config->set_current_owner (ConfigVariableBase::Interface);
setup_profile ();
GainMeter::setup_slider_pix ();
RouteTimeAxisView::setup_slider_pix ();
+ SendProcessorEntry::setup_slider_pix ();
+ SessionEvent::create_per_thread_pool ("GUI", 512);
} catch (failed_constructor& err) {
- error << _("could not initialize Ardour.") << endmsg;
+ error << string_compose (_("could not initialize %1."), PROGRAM_NAME) << endmsg;
// pass it on up
throw;
- }
+ }
/* we like keyboards */
- keyboard = new Keyboard;
+ keyboard = new ArdourKeyboard(*this);
+
+ XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
+ if (node) {
+ keyboard->set_state (*node, Stateful::loading_state_version);
+ }
+
+ /* we don't like certain modifiers */
+ Bindings::set_ignored_state (GDK_LOCK_MASK|GDK_MOD2_MASK|GDK_MOD3_MASK);
reset_dpi();
- starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
- stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+ TimeAxisViewItem::set_constant_heights ();
+
+ /* The following must happen after ARDOUR::init() so that Config is set up */
+
+ location_ui = new ActionWindowProxy<LocationUIWindow> (X_("locations"), Config->extra_xml (X_("UI")), X_("ToggleLocations"));
+ big_clock_window = new ActionWindowProxy<Gtk::Window> (X_("bigclock"), Config->extra_xml (X_("UI")), X_("ToggleBigClock"));
+ speaker_config_window = new ActionWindowProxy<SpeakerDialog> (X_("speakerconf"), Config->extra_xml (X_("UI")), X_("toggle-speaker-config"));
+
+ for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
+ _global_port_matrix[*i] = new ActionWindowProxy<GlobalPortMatrixWindow> (
+ string_compose ("GlobalPortMatrix-%1", (*i).to_string()),
+ Config->extra_xml (X_("UI")),
+ string_compose ("toggle-%1-connection-manager", (*i).to_string())
+ );
+ }
+
+ setup_clock ();
+
+ SpeakerDialog* s = new SpeakerDialog ();
+ s->signal_unmap().connect (sigc::bind (sigc::ptr_fun (&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/toggle-speaker-config")));
+ speaker_config_window->set (s);
+
+ starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
+ stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
+
+ _process_thread = new ProcessThread ();
+ _process_thread->init ();
+
+ DPIReset.connect (sigc::mem_fun (*this, &ARDOUR_UI::resize_text_widgets));
+}
+
+/** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
+bool
+ARDOUR_UI::run_startup (bool should_be_new, string load_template)
+{
+ delete _startup;
+ _startup = new ArdourStartup ();
+
+ XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
+
+ if (audio_setup && _startup->engine_control()) {
+ _startup->engine_control()->set_state (*audio_setup);
+ }
+
+ _startup->set_new_only (should_be_new);
+ if (!load_template.empty()) {
+ _startup->set_load_template( load_template );
+ }
+ _startup->present ();
+
+ main().run();
- platform_setup ();
+ _startup->hide ();
+
+ switch (_startup->response()) {
+ case RESPONSE_OK:
+ return true;
+ default:
+ return false;
+ }
}
int
loading_message (_("Starting audio engine"));
- try {
- engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
+ try {
+ engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name, ARDOUR_COMMAND_LINE::jack_session_uuid);
} catch (...) {
return -1;
}
- engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped));
- engine->Running.connect (mem_fun(*this, &ARDOUR_UI::engine_running));
- engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
- engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
+ engine->Stopped.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context());
+ engine->Running.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_running, this), gui_context());
+ engine->SampleRateChanged.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
+
+ engine->Halted.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
+
+ ARDOUR::Port::set_connecting_blocked (ARDOUR_COMMAND_LINE::no_connect_ports);
post_engine ();
/* Things to be done once we create the AudioEngine
*/
- MIDI::Manager::instance()->set_api_data (engine->jack());
- setup_midi ();
+ ARDOUR::init_post_engine ();
+
+ /* load up the UI manager */
ActionManager::init ();
+
_tooltips.enable();
if (setup_windows ()) {
throw failed_constructor ();
}
+
+ /* Do this after setup_windows (), as that's when the _status_bar_visibility is created */
+ XMLNode* n = Config->extra_xml (X_("UI"));
+ if (n) {
+ _status_bar_visibility.set_state (*n);
+ }
check_memory_locking();
if (ARDOUR_COMMAND_LINE::show_key_actions) {
vector<string> names;
vector<string> paths;
+ vector<string> tooltips;
vector<string> keys;
vector<AccelKey> bindings;
- ActionManager::get_all_actions (names, paths, keys, bindings);
+ ActionManager::get_all_actions (names, paths, tooltips, keys, bindings);
vector<string>::iterator n;
vector<string>::iterator k;
blink_timeout_tag = -1;
- /* the global configuration object is now valid */
-
- use_config ();
-
/* this being a GUI and all, we want peakfiles */
AudioFileSource::set_build_peakfiles (true);
/* set default clock modes */
if (Profile->get_sae()) {
- primary_clock.set_mode (AudioClock::BBT);
- secondary_clock.set_mode (AudioClock::MinSec);
+ primary_clock->set_mode (AudioClock::BBT);
+ secondary_clock->set_mode (AudioClock::MinSec);
} else {
- primary_clock.set_mode (AudioClock::SMPTE);
- secondary_clock.set_mode (AudioClock::BBT);
+ primary_clock->set_mode (AudioClock::Timecode);
+ secondary_clock->set_mode (AudioClock::BBT);
}
/* start the time-of-day-clock */
-
+
#ifndef GTKOSX
- /* OS X provides an always visible wallclock, so don't be stupid */
+ /* OS X provides a nearly-always visible wallclock, so don't be stupid */
update_wall_clock ();
- Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
+ Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
#endif
update_disk_space ();
update_cpu_load ();
update_sample_rate (engine->frame_rate());
+ Config->ParameterChanged.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
+ boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
+ Config->map_parameters (pc);
+
/* now start and maybe save state */
if (do_engine_start () == 0) {
- if (session && _session_is_new) {
- /* we need to retain initial visual
- settings for a new session
+ if (_session && _session_is_new) {
+ /* we need to retain initial visual
+ settings for a new session
*/
- session->save_state ("");
+ _session->save_state ("");
}
}
}
ARDOUR_UI::~ARDOUR_UI ()
{
- save_ardour_state ();
-
delete keyboard;
delete editor;
delete mixer;
delete add_route_dialog;
- delete new_session_dialog;
}
void
{
if (last_configure_time == 0) {
/* no configure events yet */
- return TRUE;
+ return true;
}
/* force a gap of 0.5 seconds since the last configure event
*/
if (get_microseconds() - last_configure_time < 500000) {
- return TRUE;
+ return true;
} else {
have_configure_timeout = false;
+ cerr << "config event-driven save\n";
save_ardour_state ();
- return FALSE;
+ return false;
}
}
gboolean
-ARDOUR_UI::configure_handler (GdkEventConfigure* conf)
+ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
{
if (have_configure_timeout) {
last_configure_time = get_microseconds();
} else {
- Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
+ Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
have_configure_timeout = true;
}
-
+
return FALSE;
}
rec_controllable->set_id (prop->value());
}
if ((prop = node.property ("shuttle")) != 0) {
- shuttle_controllable->set_id (prop->value());
+ shuttle_box->controllable()->set_id (prop->value());
}
+
}
XMLNode&
node->add_property (X_("play_selection"), buf);
rec_controllable->id().print (buf, sizeof (buf));
node->add_property (X_("rec"), buf);
- shuttle_controllable->id().print (buf, sizeof (buf));
+ shuttle_box->controllable()->id().print (buf, sizeof (buf));
node->add_property (X_("shuttle"), buf);
return *node;
}
-void
-ARDOUR_UI::save_ardour_state ()
-{
- if (!keyboard || !mixer || !editor) {
- return;
- }
-
- /* XXX this is all a bit dubious. add_extra_xml() uses
- a different lifetime model from add_instant_xml().
- */
-
- XMLNode* node = new XMLNode (keyboard->get_state());
- Config->add_extra_xml (*node);
- Config->add_extra_xml (get_transport_controllable_state());
- if (new_session_dialog && new_session_dialog->engine_control.was_used()) {
- Config->add_extra_xml (new_session_dialog->engine_control.get_state());
- }
- Config->save_state();
- ui_config->save_state ();
-
- XMLNode enode(static_cast<Stateful*>(editor)->get_state());
- XMLNode mnode(mixer->get_state());
-
- if (session) {
- session->add_instant_xml (enode);
- session->add_instant_xml (mnode);
- } else {
- Config->add_instant_xml (enode);
- Config->add_instant_xml (mnode);
- }
-
- Keyboard::save_keybindings ();
-}
gint
ARDOUR_UI::autosave_session ()
{
if (g_main_depth() > 1) {
/* inside a recursive main loop,
- give up because we may not be able to
+ give up because we may not be able to
take a lock.
*/
return 1;
}
- if (!Config->get_periodic_safety_backups()) {
- return 1;
+ if (!Config->get_periodic_safety_backups()) {
+ return 1;
}
- if (session) {
- session->maybe_write_autosave();
- }
+ if (_session) {
+ _session->maybe_write_autosave();
+ }
return 1;
}
void
ARDOUR_UI::update_autosave ()
{
- ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_autosave)
- if (session->dirty()) {
+ if (_session && _session->dirty()) {
if (_autosave_connection.connected()) {
_autosave_connection.disconnect();
}
- _autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session),
+ _autosave_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &ARDOUR_UI::autosave_session),
Config->get_periodic_safety_backup_interval() * 1000);
} else {
if (_autosave_connection.connected()) {
_autosave_connection.disconnect();
- }
+ }
}
}
{
string title;
if (we_set_params) {
- title = _("Ardour could not start JACK");
+ title = string_compose (_("%1 could not start JACK"), PROGRAM_NAME);
} else {
- title = _("Ardour could not connect to JACK.");
+ title = string_compose (_("%1 could not connect to JACK."), PROGRAM_NAME);
}
MessageDialog win (title,
false,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_NONE);
-
+
if (we_set_params) {
win.set_secondary_text(_("There are several possible reasons:\n\
\n\
win.add_button (Stock::OK, RESPONSE_CLOSE);
} else {
win.add_button (Stock::QUIT, RESPONSE_CLOSE);
- }
+ }
win.set_default_response (RESPONSE_CLOSE);
-
+
win.show_all ();
win.set_position (Gtk::WIN_POS_CENTER);
pop_back_splash ();
void
ARDOUR_UI::startup ()
{
- string name, path;
-
- new_session_dialog = new NewSessionDialog();
+ Application* app = Application::instance ();
- bool backend_audio_is_running = EngineControl::engine_running();
- XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
-
- if (audio_setup) {
- new_session_dialog->engine_control.set_state (*audio_setup);
+ app->ShouldQuit.connect (sigc::mem_fun (*this, &ARDOUR_UI::queue_finish));
+ app->ShouldLoad.connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_load));
+
+#ifdef PHONE_HOME
+ call_the_mothership (VERSIONSTRING);
+#endif
+
+ app->ready ();
+
+ if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session, ARDOUR_COMMAND_LINE::load_template)) {
+ exit (1);
}
-
- if (!get_session_parameters (backend_audio_is_running, ARDOUR_COMMAND_LINE::new_session)) {
- return;
+
+ use_config ();
+
+ goto_editor_window ();
+
+ /* Add the window proxies here; their addition may cause windows to be opened, and we want them
+ to be opened on top of the editor window that goto_editor_window() just opened.
+ */
+ add_window_proxy (location_ui);
+ add_window_proxy (big_clock_window);
+ for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
+ add_window_proxy (_global_port_matrix[*i]);
}
-
- BootMessage (_("Ardour is ready for use"));
- show ();
+
+ /* We have to do this here since goto_editor_window() ends up calling show_all() on the
+ * editor window, and we may want stuff to be hidden.
+ */
+ _status_bar_visibility.update ();
+
+ BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
}
void
if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
return;
}
-
+
if (limits.rlim_cur != RLIM_INFINITY) {
if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
-
- MessageDialog msg (_("WARNING: Your system has a limit for maximum amount of locked memory. "
- "This might cause Ardour to run out of memory before your system "
- "runs out of memory. \n\n"
- "You can view the memory limit with 'ulimit -l', "
- "and it is normally controlled by /etc/security/limits.conf"));
-
+ MessageDialog msg (
+ string_compose (
+ _("WARNING: Your system has a limit for maximum amount of locked memory. "
+ "This might cause %1 to run out of memory before your system "
+ "runs out of memory. \n\n"
+ "You can view the memory limit with 'ulimit -l', "
+ "and it is normally controlled by /etc/security/limits.conf"),
+ PROGRAM_NAME).c_str());
+
VBox* vbox = msg.get_vbox();
HBox hbox;
CheckButton cb (_("Do not show this window again"));
-
- cb.signal_toggled().connect (mem_fun (*this, &ARDOUR_UI::no_memory_warning));
-
+
+ cb.signal_toggled().connect (sigc::mem_fun (*this, &ARDOUR_UI::no_memory_warning));
+
hbox.pack_start (cb, true, false);
vbox->pack_start (hbox);
cb.show();
hbox.show ();
pop_back_splash ();
-
+
editor->ensure_float (msg);
msg.run ();
}
}
+void
+ARDOUR_UI::queue_finish ()
+{
+ Glib::signal_idle().connect (mem_fun (*this, &ARDOUR_UI::idle_finish));
+}
+
+bool
+ARDOUR_UI::idle_finish ()
+{
+ finish ();
+ return false; /* do not call again */
+}
+
void
ARDOUR_UI::finish()
{
- if (session) {
+ if (_session) {
+ int tries = 0;
- if (session->transport_rolling()) {
- session->request_stop ();
- usleep (2500000);
+ if (_session->transport_rolling() && (++tries < 8)) {
+ _session->request_stop (false, true);
+ usleep (10000);
}
- if (session->dirty()) {
- switch (ask_about_saving_session(_("quit"))) {
+ if (_session->dirty()) {
+ vector<string> actions;
+ actions.push_back (_("Don't quit"));
+ actions.push_back (_("Just quit"));
+ actions.push_back (_("Save and quit"));
+ switch (ask_about_saving_session(actions)) {
case -1:
return;
break;
/* use the default name */
if (save_state_canfail ("")) {
/* failed - don't quit */
- MessageDialog msg (*editor,
+ MessageDialog msg (*editor,
_("\
Ardour was unable to save your session.\n\n\
If you still wish to quit, please use the\n\n\
break;
}
}
-
- session->set_deletion_in_progress ();
+
+ second_connection.disconnect ();
+ point_one_second_connection.disconnect ();
+ point_oh_five_second_connection.disconnect ();
+ point_zero_one_second_connection.disconnect();
+ }
+
+ /* Save state before deleting the session, as that causes some
+ windows to be destroyed before their visible state can be
+ saved.
+ */
+ save_ardour_state ();
+
+ if (_session) {
+ // _session->set_deletion_in_progress ();
+ _session->set_clean ();
+ _session->remove_pending_capture_state ();
+ delete _session;
+ _session = 0;
}
ArdourDialog::close_all_dialogs ();
engine->stop (true);
- save_ardour_state ();
quit ();
}
int
-ARDOUR_UI::ask_about_saving_session (const string & what)
+ARDOUR_UI::ask_about_saving_session (const vector<string>& actions)
{
- ArdourDialog window (_("ardour: save session?"));
+ ArdourDialog window (_("Unsaved Session"));
Gtk::HBox dhbox; // the hbox for the image and text
Gtk::Label prompt_label;
Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING, Gtk::ICON_SIZE_DIALOG));
string msg;
- msg = string_compose(_("Don't %1"), what);
- window.add_button (msg, RESPONSE_REJECT);
- msg = string_compose(_("Just %1"), what);
- window.add_button (msg, RESPONSE_APPLY);
- msg = string_compose(_("Save and %1"), what);
- window.add_button (msg, RESPONSE_ACCEPT);
+ assert (actions.size() >= 3);
+
+ window.add_button (actions[0], RESPONSE_REJECT);
+ window.add_button (actions[1], RESPONSE_APPLY);
+ window.add_button (actions[2], RESPONSE_ACCEPT);
window.set_default_response (RESPONSE_ACCEPT);
noquit_button.set_name ("EditorGTKButton");
string prompt;
- string type;
- if (session->snap_name() == session->name()) {
- type = _("session");
+ if (_session->snap_name() == _session->name()) {
+ prompt = string_compose(_("The session \"%1\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
+ _session->snap_name());
} else {
- type = _("snapshot");
+ prompt = string_compose(_("The snapshot \"%1\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
+ _session->snap_name());
}
- prompt = string_compose(_("The %1\"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
- type, session->snap_name());
-
+
prompt_label.set_text (prompt);
prompt_label.set_name (X_("PrompterLabel"));
prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
return -1;
}
-
+
gint
ARDOUR_UI::every_second ()
{
gint
ARDOUR_UI::every_point_one_seconds ()
{
- update_speed_display ();
+ shuttle_box->update_speed_display ();
RapidScreenUpdate(); /* EMIT_SIGNAL */
return TRUE;
}
}
void
-ARDOUR_UI::update_sample_rate (nframes_t ignored)
+ARDOUR_UI::update_sample_rate (framecnt_t)
{
- char buf[32];
+ char buf[64];
- ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::update_sample_rate), ignored));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_sample_rate, ignored)
if (!engine->connected()) {
} else {
- nframes_t rate = engine->frame_rate();
-
+ framecnt_t rate = engine->frame_rate();
+
if (fmod (rate, 1000.0) != 0.0) {
- snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"),
+ snprintf (buf, sizeof (buf), _("JACK: <span foreground=\"green\">%.1f kHz / %4.1f ms</span>"),
(float) rate/1000.0f,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
} else {
- snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"),
+ snprintf (buf, sizeof (buf), _("JACK: <span foreground=\"green\">%" PRId64 " kHz / %4.1f ms</span>"),
rate/1000,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
}
}
- sample_rate_label.set_text (buf);
+ sample_rate_label.set_markup (buf);
+}
+
+void
+ARDOUR_UI::update_format ()
+{
+ if (!_session) {
+ format_label.set_text ("");
+ return;
+ }
+
+ stringstream s;
+ s << _("File:") << X_(" <span foreground=\"green\">");
+
+ switch (_session->config.get_native_file_header_format ()) {
+ case BWF:
+ s << _("BWF");
+ break;
+ case WAVE:
+ s << _("WAV");
+ break;
+ case WAVE64:
+ s << _("WAV64");
+ break;
+ case CAF:
+ s << _("CAF");
+ break;
+ case AIFF:
+ s << _("AIFF");
+ break;
+ case iXML:
+ s << _("iXML");
+ break;
+ case RF64:
+ s << _("RF64");
+ break;
+ }
+
+ s << " ";
+
+ switch (_session->config.get_native_file_data_format ()) {
+ case FormatFloat:
+ s << _("32-float");
+ break;
+ case FormatInt24:
+ s << _("24-int");
+ break;
+ case FormatInt16:
+ s << _("16-int");
+ break;
+ }
+
+ s << X_("</span>");
+
+ format_label.set_markup (s.str ());
}
void
ARDOUR_UI::update_cpu_load ()
{
- char buf[32];
- snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load());
- cpu_load_label.set_text (buf);
+ char buf[64];
+
+ /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
+ should also be changed.
+ */
+
+ float const c = engine->get_cpu_load ();
+ snprintf (buf, sizeof (buf), _("DSP: <span foreground=\"%s\">%5.1f%%</span>"), c >= 90 ? X_("red") : X_("green"), c);
+ cpu_load_label.set_markup (buf);
}
void
ARDOUR_UI::update_buffer_load ()
{
- char buf[64];
+ char buf[256];
+
+ uint32_t const playback = _session ? _session->playback_load () : 100;
+ uint32_t const capture = _session ? _session->capture_load () : 100;
- if (session) {
- snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
- session->playback_load(), session->capture_load());
- buffer_load_label.set_text (buf);
+ /* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
+ should also be changed.
+ */
+
+ if (_session) {
+ snprintf (
+ buf, sizeof (buf),
+ _("Buffers: <span foreground=\"green\">p:</span><span foreground=\"%s\">%" PRIu32 "%%</span> "
+ "<span foreground=\"green\">c:</span><span foreground=\"%s\">%" PRIu32 "%%</span>"),
+ playback <= 5 ? X_("red") : X_("green"),
+ playback,
+ capture <= 5 ? X_("red") : X_("green"),
+ capture
+ );
+
+ buffer_load_label.set_markup (buf);
} else {
buffer_load_label.set_text ("");
}
ARDOUR_UI::count_recenabled_streams (Route& route)
{
Track* track = dynamic_cast<Track*>(&route);
- if (track && track->diskstream()->record_enabled()) {
+ if (track && track->record_enabled()) {
rec_enabled_streams += track->n_inputs().n_total();
}
}
void
ARDOUR_UI::update_disk_space()
{
- if (session == 0) {
+ if (_session == 0) {
return;
}
- nframes_t frames = session->available_capture_duration();
+ framecnt_t frames = _session->available_capture_duration();
char buf[64];
- nframes_t fr = session->frame_rate();
-
- if (frames == max_frames) {
- strcpy (buf, _("Disk: 24hrs+"));
+ framecnt_t fr = _session->frame_rate();
+
+ if (frames == max_framecnt) {
+ snprintf (buf, sizeof (buf), _("Disk: <span foreground=\"green\">24hrs+</span>"));
} else {
rec_enabled_streams = 0;
- session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
-
+ _session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
+
if (rec_enabled_streams) {
frames /= rec_enabled_streams;
}
-
+
int hrs;
int mins;
int secs;
-
+
hrs = frames / (fr * 3600);
- frames -= hrs * fr * 3600;
- mins = frames / (fr * 60);
- frames -= mins * fr * 60;
- secs = frames / fr;
+
+ if (hrs > 24) {
+ snprintf (buf, sizeof (buf), _("Disk: <span foreground=\"green\">>24 hrs</span>"));
+ } else {
+ frames -= hrs * fr * 3600;
+ mins = frames / (fr * 60);
+ frames -= mins * fr * 60;
+ secs = frames / fr;
- snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);
+ bool const low = (hrs == 0 && mins <= 30);
+
+ snprintf (
+ buf, sizeof(buf),
+ _("Disk: <span foreground=\"%s\">%02dh:%02dm:%02ds</span>"),
+ low ? X_("red") : X_("green"),
+ hrs, mins, secs
+ );
+ }
}
-
- disk_space_label.set_text (buf);
-
+
+ disk_space_label.set_markup (buf);
+
// An attempt to make the disk space label flash red when space has run out.
-
+
if (frames < fr * 60 * 5) {
/* disk_space_box.style ("disk_space_label_empty"); */
} else {
/* disk_space_box.style ("disk_space_label"); */
}
-}
+}
gint
ARDOUR_UI::update_wall_clock ()
}
gint
-ARDOUR_UI::session_menu (GdkEventButton *ev)
+ARDOUR_UI::session_menu (GdkEventButton */*ev*/)
{
session_popup_menu->popup (0, 0);
return TRUE;
{
std::vector<sys::path> session_directories;
RecentSessionsSorter cmp;
-
+
recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
recent_session_model->clear ();
//
// sort them alphabetically
sort (rs.begin(), rs.end(), cmp);
-
+
for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
- session_directories.push_back ((*i).second);
+ session_directories.push_back ((*i).second);
}
-
+
for (vector<sys::path>::const_iterator i = session_directories.begin();
i != session_directories.end(); ++i)
{
std::vector<sys::path> state_file_paths;
-
+
// now get available states for this session
get_state_files_in_directory (*i, state_file_paths);
vector<string*>* states;
vector<const gchar*> item;
string fullpath = (*i).to_string();
-
+
/* remove any trailing / */
if (fullpath[fullpath.length()-1] == '/') {
/* session doesn't exist */
cerr << "skipping non-existent session " << fullpath << endl;
continue;
- }
-
+ }
+
/* now get available states for this session */
if ((states = Session::possible_states (fullpath)) == 0) {
/* no state file? */
continue;
}
-
+
std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
Gtk::TreeModel::Row row = *(recent_session_model->append());
row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
-
+
if (state_file_names.size() > 1) {
// add the children
void
ARDOUR_UI::build_session_selector ()
{
- session_selector_window = new ArdourDialog ("session selector");
-
+ session_selector_window = new ArdourDialog (_("Recent Sessions"));
+
Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
-
+
session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
session_selector_window->set_default_response (RESPONSE_ACCEPT);
recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
recent_session_display.set_headers_visible (false);
recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
- recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
+ recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
scroller->add (recent_session_display);
scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
}
void
-ARDOUR_UI::recent_session_row_activated (const TreePath& path, TreeViewColumn* col)
+ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColumn* /*col*/)
{
session_selector_window->response (RESPONSE_ACCEPT);
}
void
ARDOUR_UI::open_recent_session ()
{
- bool can_return = (session != 0);
+ bool can_return = (_session != 0);
if (session_selector_window == 0) {
build_session_selector ();
}
-
+
redisplay_recent_sessions ();
while (true) {
-
+
session_selector_window->set_position (WIN_POS_MOUSE);
ResponseType r = (ResponseType) session_selector_window->run ();
-
+
switch (r) {
case RESPONSE_ACCEPT:
break;
if (recent_session_display.get_selection()->count_selected_rows() == 0) {
continue;
}
-
+
session_selector_window->hide();
Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
-
+
if (i == recent_session_model->children().end()) {
return;
}
-
- Glib::ustring path = (*i)[recent_session_columns.fullpath];
- Glib::ustring state = (*i)[recent_session_columns.visible_name];
-
+
+ std::string path = (*i)[recent_session_columns.fullpath];
+ std::string state = (*i)[recent_session_columns.visible_name];
+
_session_is_new = false;
-
+
if (load_session (path, state) == 0) {
break;
}
{
if (engine) {
if (!engine->connected()) {
- MessageDialog msg (_("Ardour is not connected to JACK\n"
- "You cannot open or close sessions in this condition"));
+ MessageDialog msg (string_compose (
+ _("%1 is not connected to JACK\n"
+ "You cannot open or close sessions in this condition"),
+ PROGRAM_NAME));
pop_back_splash ();
msg.run ();
return false;
{
if (!check_audioengine()) {
return;
-
+
}
/* popup selector window */
/* ardour sessions are folders */
- open_session_selector = new Gtk::FileChooserDialog (_("open session"), FILE_CHOOSER_ACTION_OPEN);
+ open_session_selector = new Gtk::FileChooserDialog (_("Open Session"), FILE_CHOOSER_ACTION_OPEN);
open_session_selector->add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
open_session_selector->add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
open_session_selector->set_default_response(Gtk::RESPONSE_ACCEPT);
FileFilter session_filter;
session_filter.add_pattern ("*.ardour");
- session_filter.set_name (_("Ardour sessions"));
+ session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
open_session_selector->add_filter (session_filter);
open_session_selector->set_filter (session_filter);
}
void
-ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)
+ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many, string const & name_template)
{
list<boost::shared_ptr<MidiTrack> > tracks;
- if (session == 0) {
+ if (_session == 0) {
warning << _("You cannot add a track without a session already loaded.") << endmsg;
return;
}
- try {
+ try {
if (disk) {
- tracks = session->new_midi_track (ARDOUR::Normal, how_many);
+ tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many, name_template);
if (tracks.size() != how_many) {
if (how_many == 1) {
}
}
} /*else {
- if ((route = session->new_midi_route ()) == 0) {
+ if ((route = _session->new_midi_route ()) == 0) {
error << _("could not create new midi bus") << endmsg;
}
}*/
}
catch (...) {
- MessageDialog msg (*editor,
- _("There are insufficient JACK ports available\n\
+ MessageDialog msg (*editor,
+ string_compose (_("There are insufficient JACK ports available\n\
to create a new track or bus.\n\
-You should save Ardour, exit and\n\
-restart JACK with more ports."));
+You should save %1, exit and\n\
+restart JACK with more ports."), PROGRAM_NAME));
msg.run ();
}
}
void
-ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, uint32_t how_many)
+ARDOUR_UI::session_add_audio_route (
+ bool track,
+ int32_t input_channels,
+ int32_t output_channels,
+ ARDOUR::TrackMode mode,
+ RouteGroup* route_group,
+ uint32_t how_many,
+ string const & name_template
+ )
{
list<boost::shared_ptr<AudioTrack> > tracks;
RouteList routes;
- if (session == 0) {
+ if (_session == 0) {
warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
return;
}
- try {
+ try {
if (track) {
- tracks = session->new_audio_track (input_channels, output_channels, mode, how_many);
+ tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many, name_template);
if (tracks.size() != how_many) {
if (how_many == 1) {
error << _("could not create a new audio track") << endmsg;
} else {
- error << string_compose (_("could only create %1 of %2 new audio %3"),
+ error << string_compose (_("could only create %1 of %2 new audio %3"),
tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
}
}
} else {
- routes = session->new_audio_route (input_channels, output_channels, how_many);
+ routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many, name_template);
if (routes.size() != how_many) {
if (how_many == 1) {
- error << _("could not create a new audio track") << endmsg;
+ error << _("could not create a new audio bus") << endmsg;
} else {
- error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
+ error << string_compose (_("could not create %1 new audio busses"), how_many) << endmsg;
}
}
}
-
-#if CONTROLOUTS
- if (need_control_room_outs) {
- pan_t pans[2];
-
- pans[0] = 0.5;
- pans[1] = 0.5;
-
- route->set_stereo_control_outs (control_lr_channels);
- route->control_outs()->set_stereo_pan (pans, this);
- }
-#endif /* CONTROLOUTS */
}
catch (...) {
- MessageDialog msg (*editor,
- _("There are insufficient JACK ports available\n\
+ MessageDialog msg (*editor,
+ string_compose (_("There are insufficient JACK ports available\n\
to create a new track or bus.\n\
-You should save Ardour, exit and\n\
-restart JACK with more ports."));
+You should save %1, exit and\n\
+restart JACK with more ports."), PROGRAM_NAME));
pop_back_splash ();
msg.run ();
}
}
void
-ARDOUR_UI::do_transport_locate (nframes_t new_position)
+ARDOUR_UI::do_transport_locate (framepos_t new_position, bool with_roll)
{
- nframes_t _preroll = 0;
+ framecnt_t _preroll = 0;
- if (session) {
+ if (_session) {
// XXX CONFIG_CHANGE FIX - requires AnyTime handling
- // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
+ // _preroll = _session->convert_to_frames_at (new_position, Config->get_preroll());
if (new_position > _preroll) {
new_position -= _preroll;
new_position = 0;
}
- session->request_locate (new_position);
+ _session->request_locate (new_position, with_roll);
}
}
void
-ARDOUR_UI::transport_goto_start ()
+ARDOUR_UI::transport_goto_start ()
{
- if (session) {
- session->goto_start();
+ if (_session) {
+ _session->goto_start();
-
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (session->current_start_frame());
+ editor->center_screen (_session->current_start_frame ());
}
}
}
void
ARDOUR_UI::transport_goto_zero ()
{
- if (session) {
- session->request_locate (0);
+ if (_session) {
+ _session->request_locate (0);
-
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
editor->reset_x_origin (0);
}
void
ARDOUR_UI::transport_goto_wallclock ()
{
- if (session && editor) {
+ if (_session && editor) {
time_t now;
struct tm tmnow;
- nframes64_t frames;
-
+ framepos_t frames;
+
time (&now);
localtime_r (&now, &tmnow);
-
- frames = tmnow.tm_hour * (60 * 60 * session->frame_rate());
- frames += tmnow.tm_min * (60 * session->frame_rate());
- frames += tmnow.tm_sec * session->frame_rate();
- session->request_locate (frames);
+ frames = tmnow.tm_hour * (60 * 60 * _session->frame_rate());
+ frames += tmnow.tm_min * (60 * _session->frame_rate());
+ frames += tmnow.tm_sec * _session->frame_rate();
+
+ _session->request_locate (frames, _session->transport_rolling ());
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (frames - (editor->current_page_frames()/2));
+ editor->center_screen (frames);
}
}
}
void
ARDOUR_UI::transport_goto_end ()
{
- if (session) {
- nframes_t frame = session->current_end_frame();
- session->request_locate (frame);
+ if (_session) {
+ framepos_t const frame = _session->current_end_frame();
+ _session->request_locate (frame);
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (frame);
+ editor->center_screen (frame);
}
}
}
void
ARDOUR_UI::transport_stop ()
{
- if (!session) {
+ if (!_session) {
return;
}
- if (session->is_auditioning()) {
- session->cancel_audition ();
+ if (_session->is_auditioning()) {
+ _session->cancel_audition ();
return;
}
-
- if (session->get_play_loop ()) {
- session->request_play_loop (false);
- }
-
- session->request_stop ();
+
+ _session->request_stop (false, true);
}
void
ARDOUR_UI::transport_stop_and_forget_capture ()
{
- if (session) {
- session->request_stop (true);
+ if (_session) {
+ _session->request_stop (true, true);
}
}
void
ARDOUR_UI::transport_record (bool roll)
{
-
- if (session) {
- switch (session->record_status()) {
+
+ if (_session) {
+ switch (_session->record_status()) {
case Session::Disabled:
- if (session->ntracks() == 0) {
- MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
+ 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."));
msg.run ();
return;
}
- session->maybe_enable_record ();
+ _session->maybe_enable_record ();
if (roll) {
transport_roll ();
}
break;
case Session::Recording:
if (roll) {
- session->request_stop();
+ _session->request_stop();
} else {
- session->disable_record (false, true);
+ _session->disable_record (false, true);
}
break;
case Session::Enabled:
- session->disable_record (false, true);
+ _session->disable_record (false, true);
}
}
- //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " session->record_status() = " << session->record_status() << endl;
+ //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " _session->record_status() = " << _session->record_status() << endl;
}
void
ARDOUR_UI::transport_roll ()
{
- bool rolling;
+ if (!_session) {
+ return;
+ }
- if (!session) {
+ if (_session->is_auditioning()) {
return;
}
- rolling = session->transport_rolling ();
+#if 0
+ if (_session->config.get_external_sync()) {
+ switch (_session->config.get_sync_source()) {
+ case JACK:
+ break;
+ default:
+ /* transport controlled by the master */
+ return;
+ }
+ }
+#endif
- //cerr << "ARDOUR_UI::transport_roll () called session->record_status() = " << session->record_status() << endl;
+ bool rolling = _session->transport_rolling();
- if (session->get_play_loop()) {
- session->request_play_loop (false);
- auto_loop_button.set_visual_state (1);
- roll_button.set_visual_state (1);
- } else if (session->get_play_range ()) {
- session->request_play_range (false);
- play_selection_button.set_visual_state (0);
- } else if (rolling) {
- session->request_locate (session->last_transport_start(), true);
+ if (_session->get_play_loop()) {
+ /* XXX it is not possible to just leave seamless loop and keep
+ playing at present (nov 4th 2009)
+ */
+ if (!Config->get_seamless_loop()) {
+ _session->request_play_loop (false, true);
+ }
+ } else if (_session->get_play_range () && !join_play_range_button.active_state()) {
+ /* stop playing a range if we currently are */
+ _session->request_play_range (0, true);
}
- session->request_transport_speed (1.0f);
+ if (join_play_range_button.active_state()) {
+ _session->request_play_range (&editor->get_selection().time, true);
+ }
+
+ if (!rolling) {
+ _session->request_transport_speed (1.0f);
+ }
}
void
-ARDOUR_UI::transport_loop()
+ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode)
{
- if (session) {
- if (session->get_play_loop()) {
- if (session->transport_rolling()) {
- Location * looploc = session->locations()->auto_loop_location();
- if (looploc) {
- session->request_locate (looploc->start(), true);
- }
+
+ if (!_session) {
+ return;
+ }
+
+ if (_session->is_auditioning()) {
+ _session->cancel_audition ();
+ return;
+ }
+
+ if (_session->config.get_external_sync()) {
+ switch (_session->config.get_sync_source()) {
+ case JACK:
+ break;
+ default:
+ /* transport controlled by the master */
+ return;
+ }
+ }
+
+ bool rolling = _session->transport_rolling();
+ bool affect_transport = true;
+
+ if (rolling && roll_out_of_bounded_mode) {
+ /* drop out of loop/range playback but leave transport rolling */
+ if (_session->get_play_loop()) {
+ if (Config->get_seamless_loop()) {
+ /* the disk buffers contain copies of the loop - we can't
+ just keep playing, so stop the transport. the user
+ can restart as they wish.
+ */
+ affect_transport = true;
+ } else {
+ /* disk buffers are normal, so we can keep playing */
+ affect_transport = false;
}
+ _session->request_play_loop (false, true);
+ } else if (_session->get_play_range ()) {
+ affect_transport = false;
+ _session->request_play_range (0, true);
}
- else {
- session->request_play_loop (true);
+ }
+
+ if (affect_transport) {
+ if (rolling) {
+ _session->request_stop (with_abort, true);
+ } else {
+ if (join_play_range_button.active_state()) {
+ _session->request_play_range (&editor->get_selection().time, true);
+ }
+
+ _session->request_transport_speed (1.0f);
}
}
}
void
-ARDOUR_UI::transport_play_selection ()
+ARDOUR_UI::toggle_session_auto_loop ()
{
- if (!session) {
+ if (!_session) {
return;
}
- if (!session->get_play_range()) {
- session->request_stop ();
+ if (_session->get_play_loop()) {
+
+ if (_session->transport_rolling()) {
+
+ Location * looploc = _session->locations()->auto_loop_location();
+
+ if (looploc) {
+ _session->request_locate (looploc->start(), true);
+ _session->request_play_loop (false);
+ }
+
+ } else {
+ _session->request_play_loop (false);
+ }
+ } else {
+
+ Location * looploc = _session->locations()->auto_loop_location();
+
+ if (looploc) {
+ _session->request_play_loop (true);
+ }
+ }
+}
+
+void
+ARDOUR_UI::transport_play_selection ()
+{
+ if (!_session) {
+ return;
}
editor->play_selection ();
ARDOUR_UI::transport_rewind (int option)
{
float current_transport_speed;
-
- if (session) {
- current_transport_speed = session->transport_speed();
-
+
+ if (_session) {
+ current_transport_speed = _session->transport_speed();
+
if (current_transport_speed >= 0.0f) {
switch (option) {
case 0:
- session->request_transport_speed (-1.0f);
+ _session->request_transport_speed (-1.0f);
break;
case 1:
- session->request_transport_speed (-4.0f);
+ _session->request_transport_speed (-4.0f);
break;
case -1:
- session->request_transport_speed (-0.5f);
+ _session->request_transport_speed (-0.5f);
break;
}
} else {
/* speed up */
- session->request_transport_speed (current_transport_speed * 1.5f);
+ _session->request_transport_speed (current_transport_speed * 1.5f);
}
}
}
ARDOUR_UI::transport_forward (int option)
{
float current_transport_speed;
-
- if (session) {
- current_transport_speed = session->transport_speed();
-
+
+ if (_session) {
+ current_transport_speed = _session->transport_speed();
+
if (current_transport_speed <= 0.0f) {
switch (option) {
case 0:
- session->request_transport_speed (1.0f);
+ _session->request_transport_speed (1.0f);
break;
case 1:
- session->request_transport_speed (4.0f);
+ _session->request_transport_speed (4.0f);
break;
case -1:
- session->request_transport_speed (0.5f);
+ _session->request_transport_speed (0.5f);
break;
}
} else {
/* speed up */
- session->request_transport_speed (current_transport_speed * 1.5f);
+ _session->request_transport_speed (current_transport_speed * 1.5f);
}
+
}
}
void
-ARDOUR_UI::toggle_record_enable (uint32_t dstream)
+ARDOUR_UI::toggle_record_enable (uint32_t rid)
{
- if (session == 0) {
+ if (_session == 0) {
return;
}
boost::shared_ptr<Route> r;
-
- if ((r = session->route_by_remote_id (dstream)) != 0) {
+
+ if ((r = _session->route_by_remote_id (rid)) != 0) {
Track* t;
if ((t = dynamic_cast<Track*>(r.get())) != 0) {
- t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
+ t->set_record_enabled (!t->record_enabled(), this);
}
}
- if (session == 0) {
+ if (_session == 0) {
return;
}
}
-void
-ARDOUR_UI::queue_transport_change ()
-{
- Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
-}
-
void
ARDOUR_UI::map_transport_state ()
{
- float sp = session->transport_speed();
+ if (!_session) {
+ auto_loop_button.unset_active_state ();
+ play_selection_button.unset_active_state ();
+ roll_button.unset_active_state ();
+ stop_button.set_active_state (Gtkmm2ext::Active);
+ return;
+ }
+
+ shuttle_box->map_transport_state ();
+
+ float sp = _session->transport_speed();
+
+ if (sp != 0.0f) {
+
+ /* we're rolling */
+
+ if (_session->get_play_range()) {
+
+ play_selection_button.set_active_state (Gtkmm2ext::Active);
+ roll_button.unset_active_state ();
+ auto_loop_button.unset_active_state ();
+
+ } else if (_session->get_play_loop ()) {
+
+ auto_loop_button.set_active_state (Gtkmm2ext::Active);
+ play_selection_button.unset_active_state ();
+ roll_button.unset_active_state ();
+
+ } else {
+
+ roll_button.set_active_state (Gtkmm2ext::Active);
+ play_selection_button.unset_active_state ();
+ auto_loop_button.unset_active_state ();
+ }
+
+ if (join_play_range_button.active_state()) {
+ /* light up both roll and play-selection if they are joined */
+ roll_button.set_active_state (Gtkmm2ext::Active);
+ play_selection_button.set_active_state (Gtkmm2ext::Active);
+ }
+
+ stop_button.unset_active_state ();
- if (sp == 1.0f) {
- transport_rolling ();
- } else if (sp < 0.0f) {
- transport_rewinding ();
- } else if (sp > 0.0f) {
- transport_forwarding ();
} else {
- transport_stopped ();
- }
-}
-void
-ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
-{
- snprintf (buf, sizeof(buf), "%s", ((GlobalClickBox *) arg)->strings[
- (int) adj.get_value()].c_str());
+ stop_button.set_active_state (Gtkmm2ext::Active);
+ roll_button.unset_active_state ();
+ play_selection_button.unset_active_state ();
+ auto_loop_button.unset_active_state ();
+ update_disk_space ();
+ }
}
void
ARDOUR_UI::engine_stopped ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_stopped));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_stopped)
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
}
void
ARDOUR_UI::engine_running ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_running)
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
if (action_name) {
action = ActionManager::get_action (X_("JACK"), action_name);
-
+
if (action) {
Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
ract->set_active ();
}
void
-ARDOUR_UI::engine_halted ()
+ARDOUR_UI::engine_halted (const char* reason, bool free_reason)
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
+ if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) {
+ /* we can't rely on the original string continuing to exist when we are called
+ again in the GUI thread, so make a copy and note that we need to
+ free it later.
+ */
+ char *copy = strdup (reason);
+ Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&ARDOUR_UI::engine_halted, this, copy, true));
+ return;
+ }
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
update_sample_rate (0);
- MessageDialog msg (*editor,
- _("\
+ string msgstr;
+
+ /* if the reason is a non-empty string, it means that the backend was shutdown
+ rather than just Ardour.
+ */
+
+ if (strlen (reason)) {
+ msgstr = string_compose (_("The audio backend (JACK) was shutdown because:\n\n%1"), reason);
+ } else {
+ msgstr = string_compose (_("\
JACK has either been shutdown or it\n\
-disconnected Ardour because Ardour\n\
+disconnected %1 because %1\n\
was not fast enough. Try to restart\n\
-JACK, reconnect and save the session."));
+JACK, reconnect and save the session."), PROGRAM_NAME);
+ }
+
+ MessageDialog msg (*editor, msgstr);
pop_back_splash ();
msg.run ();
+
+ if (free_reason) {
+ free ((char*) reason);
+ }
}
int32_t
ARDOUR_UI::do_engine_start ()
{
- try {
+ try {
engine->start();
}
unload_session ();
return -2;
}
-
+
return 0;
}
ARDOUR_UI::update_clocks ()
{
if (!editor || !editor->dragging_playhead()) {
- Clock (session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
+ Clock (_session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
}
}
void
ARDOUR_UI::start_clocking ()
{
- clock_signal_connection = RapidScreenUpdate.connect (mem_fun(*this, &ARDOUR_UI::update_clocks));
+ clock_signal_connection = RapidScreenUpdate.connect (sigc::mem_fun(*this, &ARDOUR_UI::update_clocks));
}
void
{
clock_signal_connection.disconnect ();
}
-
+
void
ARDOUR_UI::toggle_clocking ()
{
*/
if (blink_timeout_tag < 0) {
- blink_on = false;
+ blink_on = false;
blink_timeout_tag = g_timeout_add (240, _blink, this);
}
}
}
}
+
+/** Ask the user for the name of a new shapshot and then take it.
+ */
+
void
-ARDOUR_UI::name_io_setup (AudioEngine& engine,
- string& buf,
- IO& io,
- bool in)
+ARDOUR_UI::snapshot_session (bool switch_to_it)
{
- vector<string> connections;
+ ArdourPrompter prompter (true);
+ string snapname;
- if (in) {
- if (io.n_inputs().n_total() == 0) {
- buf = _("none");
- return;
- }
-
- /* XXX we're not handling multiple ports yet. */
+ prompter.set_name ("Prompter");
+ prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+ prompter.set_title (_("Take Snapshot"));
+ prompter.set_prompt (_("Name of new snapshot"));
- if (io.input(0)->get_connections(connections) == 0) {
- buf = _("off");
- } else {
- buf = connections.front();
- }
+ if (!switch_to_it) {
+ char timebuf[128];
+ time_t n;
+ struct tm local_time;
- } else {
+ time (&n);
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "%FT%H.%M.%S", &local_time);
+ prompter.set_initial_text (timebuf);
+ }
- if (io.n_outputs().n_total() == 0) {
- buf = _("none");
- return;
+ again:
+ switch (prompter.run()) {
+ case RESPONSE_ACCEPT:
+ {
+ prompter.get_result (snapname);
+
+ bool do_save = (snapname.length() != 0);
+
+ if (do_save) {
+ if (snapname.find ('/') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "snapshot names may not contain a '/' character"));
+ msg.run ();
+ goto again;
+ }
+ if (snapname.find ('\\') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "snapshot names may not contain a '\\' character"));
+ msg.run ();
+ goto again;
+ }
+ if (snapname.find (':') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "snapshot names may not contain a ':' character"));
+ msg.run ();
+ goto again;
+ }
}
-
- /* XXX we're not handling multiple ports yet. */
- if (io.output(0)->get_connections(connections) == 0) {
- buf = _("off");
- } else {
- buf = connections.front();
+ vector<sys::path> 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;
+ }
+ }
+
+ if (do_save) {
+ save_state (snapname, switch_to_it);
}
+ break;
+ }
+
+ default:
+ break;
}
}
/** Ask the user for the name of a new shapshot and then take it.
*/
+
void
-ARDOUR_UI::snapshot_session ()
+ARDOUR_UI::rename_session ()
{
- ArdourPrompter prompter (true);
- string snapname;
- char timebuf[128];
- time_t n;
- struct tm local_time;
+ if (!_session) {
+ return;
+ }
- time (&n);
- localtime_r (&n, &local_time);
- strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
+ ArdourPrompter prompter (true);
+ string name;
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- prompter.set_prompt (_("Name of New Snapshot"));
- prompter.set_initial_text (timebuf);
-
+ prompter.set_title (_("Rename Session"));
+ prompter.set_prompt (_("New session name"));
+
+ again:
switch (prompter.run()) {
case RESPONSE_ACCEPT:
- prompter.get_result (snapname);
- if (snapname.length()){
- save_state (snapname);
+ {
+ prompter.get_result (name);
+
+ bool do_rename = (name.length() != 0);
+
+ if (do_rename) {
+ if (name.find ('/') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
+ msg.run ();
+ goto again;
+ }
+ if (name.find ('\\') != string::npos) {
+ MessageDialog msg (_("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
+ msg.run ();
+ goto again;
+ }
+
+ switch (_session->rename (name)) {
+ case -1: {
+ MessageDialog msg (_("That name is already in use by another directory/folder. Please try again."));
+ msg.set_position (WIN_POS_MOUSE);
+ msg.run ();
+ goto again;
+ break;
+ }
+ case 0:
+ break;
+ default: {
+ MessageDialog msg (_("Renaming this session failed.\nThings could be seriously messed up at this point"));
+ msg.set_position (WIN_POS_MOUSE);
+ msg.run ();
+ break;
+ }
+ }
}
+
break;
+ }
default:
break;
}
void
-ARDOUR_UI::save_state (const string & name)
+ARDOUR_UI::save_state (const string & name, bool switch_to_it)
{
- (void) save_state_canfail (name);
+ XMLNode* node = new XMLNode (X_("UI"));
+
+ for (list<WindowProxyBase*>::iterator i = _window_proxies.begin(); i != _window_proxies.end(); ++i) {
+ if (!(*i)->rc_configured()) {
+ node->add_child_nocopy (*((*i)->get_state ()));
+ }
+ }
+
+ node->add_child_nocopy (gui_object_state->get_state());
+
+ _session->add_extra_xml (*node);
+
+ save_state_canfail (name, switch_to_it);
}
-
+
int
-ARDOUR_UI::save_state_canfail (string name)
+ARDOUR_UI::save_state_canfail (string name, bool switch_to_it)
{
- if (session) {
+ if (_session) {
int ret;
if (name.length() == 0) {
- name = session->snap_name();
+ name = _session->snap_name();
}
- if ((ret = session->save_state (name)) != 0) {
+ if ((ret = _session->save_state (name, false, switch_to_it)) != 0) {
return ret;
}
}
+
save_ardour_state (); /* XXX cannot fail? yeah, right ... */
return 0;
}
void
ARDOUR_UI::primary_clock_value_changed ()
{
- if (session) {
- session->request_locate (primary_clock.current_time ());
+ if (_session) {
+ _session->request_locate (primary_clock->current_time ());
}
}
void
ARDOUR_UI::big_clock_value_changed ()
{
- if (session) {
- session->request_locate (big_clock.current_time ());
+ if (_session) {
+ _session->request_locate (big_clock->current_time ());
}
}
void
ARDOUR_UI::secondary_clock_value_changed ()
{
- if (session) {
- session->request_locate (secondary_clock.current_time ());
+ if (_session) {
+ _session->request_locate (secondary_clock->current_time ());
}
}
void
-ARDOUR_UI::transport_rec_enable_blink (bool onoff)
+ARDOUR_UI::transport_rec_enable_blink (bool onoff)
{
- if (session == 0) {
+ if (_session == 0) {
return;
}
-
- switch (session->record_status()) {
- case Session::Enabled:
+
+ if (_session->step_editing()) {
+ return;
+ }
+
+ Session::RecordState const r = _session->record_status ();
+ bool const h = _session->have_rec_enabled_track ();
+
+ if (r == Session::Enabled || (r == Session::Recording && !h)) {
if (onoff) {
- rec_button.set_visual_state (2);
+ rec_button.set_active_state (Active);
} else {
- rec_button.set_visual_state (0);
+ rec_button.set_active_state (Mid);
}
- break;
-
- case Session::Recording:
- rec_button.set_visual_state (1);
- break;
-
- default:
- rec_button.set_visual_state (0);
- break;
+ } else if (r == Session::Recording && h) {
+ rec_button.set_active_state (Mid);
+ } else {
+ rec_button.unset_active_state ();
}
}
void
ARDOUR_UI::save_template ()
-
{
ArdourPrompter prompter (true);
string name;
}
prompter.set_name (X_("Prompter"));
- prompter.set_prompt (_("Name for mix template:"));
- prompter.set_initial_text(session->name() + _("-template"));
+ prompter.set_title (_("Save Template"));
+ prompter.set_prompt (_("Name for template:"));
+ prompter.set_initial_text(_session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
prompter.get_result (name);
-
+
if (name.length()) {
- session->save_template (name);
+ _session->save_template (name);
}
break;
ARDOUR_UI::edit_metadata ()
{
SessionMetadataEditor dialog;
- dialog.set_session (session);
+ dialog.set_session (_session);
editor->ensure_float (dialog);
dialog.run ();
}
ARDOUR_UI::import_metadata ()
{
SessionMetadataImporter dialog;
- dialog.set_session (session);
+ dialog.set_session (_session);
editor->ensure_float (dialog);
dialog.run ();
}
-void
-ARDOUR_UI::fontconfig_dialog ()
-{
-#ifdef GTKOSX
- /* X11 users will always have fontconfig info around, but new GTK-OSX users
- may not and it can take a while to build it. Warn them.
- */
-
- Glib::ustring fontconfig = Glib::build_filename (Glib::get_home_dir(), ".fontconfig");
-
- if (!Glib::file_test (fontconfig, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
- MessageDialog msg (*new_session_dialog,
- _("Welcome to Ardour.\n\n"
- "The program will take a bit longer to start up\n"
- "while the system fonts are checked.\n\n"
- "This will only be done once, and you will\n"
- "not see this message again\n"),
- true,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_OK);
- pop_back_splash ();
- msg.show_all ();
- msg.present ();
- msg.run ();
- }
-#endif
-}
-
-void
-ARDOUR_UI::parse_cmdline_path (const Glib::ustring& cmdline_path, Glib::ustring& session_name, Glib::ustring& session_path, bool& existing_session)
-{
- existing_session = false;
-
- if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_DIR)) {
- session_path = cmdline_path;
- existing_session = true;
- } else if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_REGULAR)) {
- session_path = Glib::path_get_dirname (string (cmdline_path));
- existing_session = true;
- } else {
- /* it doesn't exist, assume the best */
- session_path = Glib::path_get_dirname (string (cmdline_path));
- }
-
- session_name = basename_nosuffix (string (cmdline_path));
-}
-
-int
-ARDOUR_UI::load_cmdline_session (const Glib::ustring& session_name, const Glib::ustring& session_path, bool& existing_session)
-{
- /* when this is called, the backend audio system must be running */
-
- /* the main idea here is to deal with the fact that a cmdline argument for the session
- can be interpreted in different ways - it could be a directory or a file, and before
- we load, we need to know both the session directory and the snapshot (statefile) within it
- that we are supposed to use.
- */
-
- if (session_name.length() == 0 || session_path.length() == 0) {
- return false;
- }
-
- if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
-
- Glib::ustring predicted_session_file;
-
- predicted_session_file = session_path;
- predicted_session_file += '/';
- predicted_session_file += session_name;
- predicted_session_file += ARDOUR::statefile_suffix;
-
- if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) {
- existing_session = true;
- }
-
- } else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) {
-
- if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) {
- /* existing .ardour file */
- existing_session = true;
- }
-
- } else {
- existing_session = false;
- }
-
- /* lets just try to load it */
-
- if (create_engine ()) {
- backend_audio_error (false, new_session_dialog);
- return -1;
- }
-
- return load_session (session_path, session_name);
-}
-
bool
-ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path)
+ARDOUR_UI::ask_about_loading_existing_session (const std::string& session_path)
{
- Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
-
+ std::string str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
+
MessageDialog msg (str,
false,
Gtk::MESSAGE_WARNING,
Gtk::BUTTONS_YES_NO,
true);
-
-
- msg.set_name (X_("CleanupDialog"));
- msg.set_wmclass (X_("existing_session"), "Ardour");
+
+
+ msg.set_name (X_("OpenExistingDialog"));
+ msg.set_title (_("Open Existing Session"));
+ msg.set_wmclass (X_("existing_session"), PROGRAM_NAME);
msg.set_position (Gtk::WIN_POS_MOUSE);
pop_back_splash ();
}
int
-ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& session_name)
+ARDOUR_UI::build_session_from_nsd (const std::string& session_path, const std::string& session_name)
{
-
- uint32_t cchns;
- uint32_t mchns;
- AutoConnectOption iconnect;
- AutoConnectOption oconnect;
- uint32_t nphysin;
- uint32_t nphysout;
-
+ BusProfile bus_profile;
+
if (Profile->get_sae()) {
-
- cchns = 0;
- mchns = 2;
- iconnect = AutoConnectPhysical;
- oconnect = AutoConnectMaster;
- nphysin = 0; // use all available
- nphysout = 0; // use all available
-
+
+ bus_profile.master_out_channels = 2;
+ bus_profile.input_ac = AutoConnectPhysical;
+ bus_profile.output_ac = AutoConnectMaster;
+ bus_profile.requested_physical_in = 0; // use all available
+ bus_profile.requested_physical_out = 0; // use all available
+
} else {
-
+
/* get settings from advanced section of NSD */
-
- if (new_session_dialog->create_control_bus()) {
- cchns = (uint32_t) new_session_dialog->control_channel_count();
+
+ if (_startup->create_master_bus()) {
+ bus_profile.master_out_channels = (uint32_t) _startup->master_channel_count();
} else {
- cchns = 0;
+ bus_profile.master_out_channels = 0;
}
-
- if (new_session_dialog->create_master_bus()) {
- mchns = (uint32_t) new_session_dialog->master_channel_count();
+
+ if (_startup->connect_inputs()) {
+ bus_profile.input_ac = AutoConnectPhysical;
} else {
- mchns = 0;
+ bus_profile.input_ac = AutoConnectOption (0);
}
-
- if (new_session_dialog->connect_inputs()) {
- iconnect = AutoConnectPhysical;
- } else {
- iconnect = AutoConnectOption (0);
+
+ bus_profile.output_ac = AutoConnectOption (0);
+
+ if (_startup->connect_outputs ()) {
+ if (_startup->connect_outs_to_master()) {
+ bus_profile.output_ac = AutoConnectMaster;
+ } else if (_startup->connect_outs_to_physical()) {
+ bus_profile.output_ac = AutoConnectPhysical;
+ }
}
-
- /// @todo some minor tweaks.
-
- if (new_session_dialog->connect_outs_to_master()) {
- oconnect = AutoConnectMaster;
- } else if (new_session_dialog->connect_outs_to_physical()) {
- oconnect = AutoConnectPhysical;
- } else {
- oconnect = AutoConnectOption (0);
- }
-
- nphysin = (uint32_t) new_session_dialog->input_limit_count();
- nphysout = (uint32_t) new_session_dialog->output_limit_count();
+
+ bus_profile.requested_physical_in = (uint32_t) _startup->input_limit_count();
+ bus_profile.requested_physical_out = (uint32_t) _startup->output_limit_count();
}
-
- if (build_session (session_path,
- session_name,
- cchns,
- mchns,
- iconnect,
- oconnect,
- nphysin,
- nphysout,
- engine->frame_rate() * 60 * 5)) {
-
+
+ if (build_session (session_path, session_name, bus_profile)) {
return -1;
}
}
void
-ARDOUR_UI::end_loading_messages ()
-{
- // hide_splash ();
-}
-
-void
-ARDOUR_UI::loading_message (const std::string& msg)
+ARDOUR_UI::idle_load (const std::string& path)
{
- show_splash ();
- splash->message (msg);
- flush_pending ();
-}
-
-void
-ARDOUR_UI::idle_load (const Glib::ustring& path)
-{
- if (session) {
+ if (_session) {
if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
/* /path/to/foo => /path/to/foo, foo */
load_session (path, basename_nosuffix (path));
ARDOUR_COMMAND_LINE::session_name = path;
- if (new_session_dialog) {
+ /*
+ * new_session_dialog doens't exist in A3
+ * Try to remove all references to it to
+ * see if it will compile. NOTE: this will
+ * likely cause a runtime issue is my somewhat
+ * uneducated guess.
+ */
+
+ //if (new_session_dialog) {
/* make it break out of Dialog::run() and
start again.
*/
- new_session_dialog->response (1);
- }
+ //new_session_dialog->response (1);
+ //}
}
}
-/** @param offer_quit true to offer a Cancel button, otherwise call it Quit */
-bool
-ARDOUR_UI::get_session_parameters (bool backend_audio_is_running, bool should_be_new, bool offer_cancel)
+void
+ARDOUR_UI::end_loading_messages ()
{
- bool existing_session = false;
- Glib::ustring session_name;
- Glib::ustring session_path;
- Glib::ustring template_name;
- int response;
+ // hide_splash ();
+}
- begin:
- response = Gtk::RESPONSE_NONE;
+void
+ARDOUR_UI::loading_message (const std::string& /*msg*/)
+{
+ // show_splash ();
+ // splash->message (msg);
+ flush_pending ();
+}
- if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
+/** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
+int
+ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new, string load_template)
+{
+ string session_name;
+ string session_path;
+ string template_name;
+ int ret = -1;
+ bool likely_new = false;
- parse_cmdline_path (ARDOUR_COMMAND_LINE::session_name, session_name, session_path, existing_session);
+ if (!load_template.empty()) {
+ should_be_new = true;
+ template_name = load_template;
+ }
- /* don't ever reuse this */
+ while (ret != 0) {
- ARDOUR_COMMAND_LINE::session_name = string();
+ if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) {
- if (existing_session && backend_audio_is_running) {
+ /* if they named a specific statefile, use it, otherwise they are
+ just giving a session folder, and we want to use it as is
+ to find the session.
+ */
- /* just load the thing already */
+ string::size_type suffix = ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix);
- if (load_cmdline_session (session_name, session_path, existing_session) == 0) {
- return true;
+ if (suffix != string::npos) {
+ session_path = Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name);
+ session_name = ARDOUR_COMMAND_LINE::session_name.substr (0, suffix);
+ session_name = Glib::path_get_basename (session_name);
+ } else {
+ session_path = ARDOUR_COMMAND_LINE::session_name;
+ session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name);
}
- }
- /* make the NSD use whatever information we have */
+ } else {
- new_session_dialog->set_session_name (session_name);
- new_session_dialog->set_session_folder (session_path);
- }
+ bool const apply = run_startup (should_be_new, load_template);
- /* loading failed, or we need the NSD for something */
+ if (!apply) {
+ if (quit_on_cancel) {
+ exit (1);
+ } else {
+ return ret;
+ }
+ }
- new_session_dialog->set_modal (false);
- new_session_dialog->set_position (WIN_POS_CENTER);
- new_session_dialog->set_current_page (0);
- new_session_dialog->set_existing_session (existing_session);
- new_session_dialog->reset_recent();
- new_session_dialog->set_offer_cancel (offer_cancel);
+ /* if we run the startup dialog again, offer more than just "new session" */
- do {
- new_session_dialog->set_have_engine (backend_audio_is_running);
- new_session_dialog->present ();
- end_loading_messages ();
- response = new_session_dialog->run ();
-
- _session_is_new = false;
-
- /* handle possible negative responses */
+ should_be_new = false;
- switch (response) {
- case 1:
- /* sent by idle_load, meaning restart the whole process again */
- new_session_dialog->hide();
- new_session_dialog->reset();
- goto begin;
- break;
+ session_name = _startup->session_name (likely_new);
- case Gtk::RESPONSE_CANCEL:
- case Gtk::RESPONSE_DELETE_EVENT:
- if (!session) {
- if (engine && engine->running()) {
- engine->stop (true);
- }
- quit();
+ string::size_type suffix = session_name.find (statefile_suffix);
+
+ if (suffix != string::npos) {
+ session_name = session_name.substr (0, suffix);
}
- new_session_dialog->hide ();
- return false;
-
- case Gtk::RESPONSE_NONE:
- /* "Clear" was pressed */
- goto try_again;
- }
- fontconfig_dialog();
+ /* this shouldn't happen, but we catch it just in case it does */
+
+ if (session_name.empty()) {
+ continue;
+ }
- if (!backend_audio_is_running) {
- int ret = new_session_dialog->engine_control.setup_engine ();
- if (ret < 0) {
- return false;
- } else if (ret > 0) {
- response = Gtk::RESPONSE_REJECT;
- goto try_again;
+ if (_startup->use_session_template()) {
+ template_name = _startup->session_template_name();
+ _session_is_new = true;
+ }
+
+ if (session_name[0] == G_DIR_SEPARATOR ||
+ (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == G_DIR_SEPARATOR) ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == G_DIR_SEPARATOR)) {
+
+ /* absolute path or cwd-relative path specified for session name: infer session folder
+ from what was given.
+ */
+
+ session_path = Glib::path_get_dirname (session_name);
+ session_name = Glib::path_get_basename (session_name);
+
+ } else {
+
+ session_path = _startup->session_folder();
+
+ if (session_name.find ('/') != string::npos) {
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
+
+ if (session_name.find ('\\') != string::npos) {
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
}
}
-
+
if (create_engine ()) {
+ break;
+ }
- backend_audio_error (!backend_audio_is_running, new_session_dialog);
- flush_pending ();
+ if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
- new_session_dialog->set_existing_session (false);
- new_session_dialog->set_current_page (2);
+ if (likely_new) {
- response = Gtk::RESPONSE_NONE;
- goto try_again;
- }
+ std::string existing = Glib::build_filename (session_path, session_name);
- backend_audio_is_running = true;
-
- if (response == Gtk::RESPONSE_OK) {
+ if (!ask_about_loading_existing_session (existing)) {
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
+ }
- session_name = new_session_dialog->session_name();
+ _session_is_new = false;
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- goto try_again;
- }
+ } else {
- /* if the user mistakenly typed path information into the session filename entry,
- convert what they typed into a path & a name
- */
-
- if (session_name[0] == '/' ||
- (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
- (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
+ if (!likely_new) {
+ MessageDialog msg (string_compose (_("There is no existing session at \"%1\""), session_path));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
- session_path = Glib::path_get_dirname (session_name);
- session_name = Glib::path_get_basename (session_name);
-
- } else {
+ if (session_name.find ('/') != std::string::npos) {
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
- session_path = new_session_dialog->session_folder();
+ if (session_name.find ('\\') != std::string::npos) {
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
}
- template_name = Glib::ustring();
- switch (new_session_dialog->which_page()) {
+ _session_is_new = true;
+ }
- case NewSessionDialog::OpenPage:
- case NewSessionDialog::EnginePage:
- goto loadit;
- break;
+ if (likely_new && template_name.empty()) {
- case NewSessionDialog::NewPage: /* nominally the "new" session creator, but could be in use for an old session */
-
- should_be_new = true;
-
- //XXX This is needed because session constructor wants a
- //non-existant path. hopefully this will be fixed at some point.
-
- session_path = Glib::build_filename (session_path, session_name);
-
- if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
-
- if (ask_about_loading_existing_session (session_path)) {
- goto loadit;
- } else {
- response = RESPONSE_NONE;
- goto try_again;
- }
- }
+ ret = build_session_from_nsd (session_path, session_name);
- _session_is_new = true;
-
- if (new_session_dialog->use_session_template()) {
+ } else {
- template_name = new_session_dialog->session_template_name();
- goto loadit;
-
- } else {
- if (build_session_from_nsd (session_path, session_name)) {
- response = RESPONSE_NONE;
- goto try_again;
- }
- goto done;
- }
- break;
-
- default:
- break;
- }
-
- loadit:
- new_session_dialog->hide ();
+ ret = load_session (session_path, session_name, template_name);
- if (load_session (session_path, session_name, template_name)) {
- /* force a retry */
- response = Gtk::RESPONSE_NONE;
+ if (ret == -2) {
+ /* not connected to the AudioEngine, so quit to avoid an infinite loop */
+ exit (1);
}
- try_again:
- if (response == Gtk::RESPONSE_NONE) {
- new_session_dialog->set_existing_session (false);
- new_session_dialog->reset ();
+ if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
+ _session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
+ exit (1);
}
}
+ }
- } while (response == Gtk::RESPONSE_NONE || response == Gtk::RESPONSE_REJECT);
-
- done:
- show();
- new_session_dialog->hide();
- new_session_dialog->reset();
- goto_editor_window ();
- return true;
-}
+ return ret;
+}
void
ARDOUR_UI::close_session()
return;
}
- unload_session (true);
+ if (unload_session (true)) {
+ return;
+ }
+
+ ARDOUR_COMMAND_LINE::session_name = "";
+
+ if (get_session_parameters (true, false)) {
+ exit (1);
+ }
- get_session_parameters (true, false);
+ goto_editor_window ();
}
+/** @param snap_name Snapshot name (without .ardour suffix).
+ * @return -2 if the load failed because we are not connected to the AudioEngine.
+ */
int
-ARDOUR_UI::load_session (const Glib::ustring& path, const Glib::ustring& snap_name, Glib::ustring mix_template)
+ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name, std::string mix_template)
{
Session *new_session;
int unload_status;
session_loaded = false;
if (!check_audioengine()) {
- return -1;
+ return -2;
}
unload_status = unload_session ();
goto out;
}
- /* if it already exists, we must have write access */
-
- if (Glib::file_test (path.c_str(), Glib::FILE_TEST_EXISTS) && ::access (path.c_str(), W_OK)) {
- MessageDialog msg (*editor, _("You do not have write access to this session.\n"
- "This prevents the session from being loaded."));
- pop_back_splash ();
- msg.run ();
- goto out;
- }
-
- loading_message (_("Please wait while Ardour loads your session"));
+ loading_message (string_compose (_("Please wait while %1 loads your session"), PROGRAM_NAME));
try {
- new_session = new Session (*engine, path, snap_name, mix_template);
+ new_session = new Session (*engine, path, snap_name, 0, mix_template);
}
/* this one is special */
true,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_CLOSE);
-
+
msg.set_title (_("Port Registration Error"));
msg.set_secondary_text (_("Click the Close button to try again."));
msg.set_position (Gtk::WIN_POS_CENTER);
catch (...) {
- MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name),
- true,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_CLOSE);
-
+ MessageDialog msg (string_compose(
+ _("Session \"%1 (snapshot %2)\" did not load successfully"),
+ path, snap_name),
+ true,
+ Gtk::MESSAGE_INFO,
+ BUTTONS_OK);
+
msg.set_title (_("Loading Error"));
- msg.set_secondary_text (_("Click the Close button to try again."));
+ msg.set_secondary_text (_("Click the Refresh button to try again."));
+ msg.add_button (Stock::REFRESH, 1);
msg.set_position (Gtk::WIN_POS_CENTER);
pop_back_splash ();
msg.present ();
int response = msg.run ();
- msg.hide ();
-
switch (response) {
- case RESPONSE_CANCEL:
- exit (1);
- default:
+ case 1:
break;
+ default:
+ exit (1);
}
+
+ msg.hide ();
+
goto out;
}
- connect_to_session (new_session);
+ {
+ list<string> const u = new_session->unknown_processors ();
+ if (!u.empty()) {
+ MissingPluginDialog d (_session, u);
+ d.run ();
+ }
+ }
+
+ /* Now the session been created, add the transport controls */
+ new_session->add_controllable(roll_controllable);
+ new_session->add_controllable(stop_controllable);
+ new_session->add_controllable(goto_start_controllable);
+ new_session->add_controllable(goto_end_controllable);
+ new_session->add_controllable(auto_loop_controllable);
+ new_session->add_controllable(play_selection_controllable);
+ new_session->add_controllable(rec_controllable);
- Config->set_current_owner (ConfigVariableBase::Interface);
+ set_session (new_session);
session_loaded = true;
-
+
goto_editor_window ();
- if (session) {
- session->set_clean ();
+ if (_session) {
+ _session->set_clean ();
}
flush_pending ();
}
int
-ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name,
- uint32_t control_channels,
- uint32_t master_channels,
- AutoConnectOption input_connect,
- AutoConnectOption output_connect,
- uint32_t nphysin,
- uint32_t nphysout,
- nframes_t initial_length)
+ARDOUR_UI::build_session (const std::string& path, const std::string& snap_name, BusProfile& bus_profile)
{
Session *new_session;
int x;
} else if (x > 0) {
return 0;
}
-
+
_session_is_new = true;
try {
- new_session = new Session (*engine, path, snap_name, input_connect, output_connect,
- control_channels, master_channels, nphysin, nphysout, initial_length);
+ new_session = new Session (*engine, path, snap_name, &bus_profile);
}
catch (...) {
return -1;
}
- connect_to_session (new_session);
+ /* Give the new session the default GUI state, if such things exist */
+
+ XMLNode* n;
+ n = Config->instant_xml (X_("Editor"));
+ if (n) {
+ new_session->add_instant_xml (*n, false);
+ }
+ n = Config->instant_xml (X_("Mixer"));
+ if (n) {
+ new_session->add_instant_xml (*n, false);
+ }
+
+ /* Put the playhead at 0 and scroll fully left */
+ n = new_session->instant_xml (X_("Editor"));
+ if (n) {
+ n->add_property (X_("playhead"), X_("0"));
+ n->add_property (X_("left-frame"), X_("0"));
+ }
+
+ set_session (new_session);
session_loaded = true;
}
void
-ARDOUR_UI::show ()
+ARDOUR_UI::launch_chat ()
{
- if (editor) {
- editor->show_window ();
-
- if (!shown_flag) {
- editor->present ();
- }
-
- shown_flag = true;
- }
+#ifdef __APPLE__
+ open_uri("http://webchat.freenode.net/?channels=ardour-osx");
+#else
+ open_uri("http://webchat.freenode.net/?channels=ardour");
+#endif
}
void
{
if (about == 0) {
about = new About;
- about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );
+ about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) );
}
+ about->set_transient_for(*editor);
about->show_all ();
}
+void
+ARDOUR_UI::launch_manual ()
+{
+ PBD::open_uri("http://ardour.org/flossmanual");
+}
+
+void
+ARDOUR_UI::launch_reference ()
+{
+ PBD::open_uri("http://ardour.org/refmanual");
+}
+
void
ARDOUR_UI::hide_about ()
{
if (about) {
- about->get_window()->set_cursor ();
+ about->get_window()->set_cursor ();
about->hide ();
}
}
void
-ARDOUR_UI::about_signal_response(int response)
+ARDOUR_UI::about_signal_response (int /*response*/)
{
hide_about();
}
}
void
-ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, const string & msg)
+ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title,
+ const string& plural_msg, const string& singular_msg)
{
size_t removed;
if (removed == 0) {
MessageDialog msgd (*editor,
- _("No audio files were ready for cleanup"),
+ _("No files were ready for clean-up"),
true,
Gtk::MESSAGE_INFO,
- (Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
+ Gtk::BUTTONS_OK);
+ msgd.set_title (_("Clean-up"));
msgd.set_secondary_text (_("If this seems suprising, \n\
check for any existing snapshots.\n\
These may still include regions that\n\
require some unused files to continue to exist."));
-
+
msgd.run ();
return;
- }
+ }
+
+ ArdourDialog results (_("Clean-up"), true, false);
- ArdourDialog results (_("ardour: cleanup"), true, false);
-
struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
- CleanupResultsModelColumns() {
+ CleanupResultsModelColumns() {
add (visible_name);
add (fullpath);
}
- Gtk::TreeModelColumn<Glib::ustring> visible_name;
- Gtk::TreeModelColumn<Glib::ustring> fullpath;
+ Gtk::TreeModelColumn<std::string> visible_name;
+ Gtk::TreeModelColumn<std::string> fullpath;
};
-
+
CleanupResultsModelColumns results_columns;
Glib::RefPtr<Gtk::ListStore> results_model;
Gtk::TreeView results_display;
-
+
results_model = ListStore::create (results_columns);
results_display.set_model (results_model);
results_display.append_column (list_title, results_columns.visible_name);
dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
- const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
+ const string dead_directory = _session->session_directory().dead_path().to_string();
- if (rep.space < 1048576.0f) {
- if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
- } else {
- txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
- }
+ /* subst:
+ %1 - number of files removed
+ %2 - location of "dead"
+ %3 - size of files affected
+ %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
+ */
+
+ const char* bprefix;
+ double space_adjusted = 0;
+
+ if (rep.space < 1000) {
+ bprefix = X_("");
+ space_adjusted = rep.space;
+ } else if (rep.space < 1000000) {
+ bprefix = X_("kilo");
+ space_adjusted = truncf((float)rep.space / 1000.0);
+ } else if (rep.space < 1000000 * 1000) {
+ bprefix = X_("mega");
+ space_adjusted = truncf((float)rep.space / (1000.0 * 1000.0));
} else {
- if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
- } else {
- txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
- }
+ bprefix = X_("giga");
+ space_adjusted = truncf((float)rep.space / (1000.0 * 1000 * 1000.0));
+ }
+
+ if (removed > 1) {
+ txt.set_text (string_compose (plural_msg, removed, dead_directory, space_adjusted, bprefix));
+ } else {
+ txt.set_text (string_compose (singular_msg, removed, dead_directory, space_adjusted, bprefix));
}
dhbox.pack_start (*dimage, true, false, 5);
row[results_columns.visible_name] = *i;
row[results_columns.fullpath] = *i;
}
-
+
list_scroller.add (results_display);
list_scroller.set_size_request (-1, 150);
list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
void
ARDOUR_UI::cleanup ()
{
- if (session == 0) {
+ if (_session == 0) {
/* shouldn't happen: menu item is insensitive */
return;
}
- MessageDialog checker (_("Are you sure you want to cleanup?"),
+ MessageDialog checker (_("Are you sure you want to clean-up?"),
true,
Gtk::MESSAGE_QUESTION,
- (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
+ Gtk::BUTTONS_NONE);
+
+ checker.set_title (_("Clean-up"));
+
+ checker.set_secondary_text(_("Clean-up is a destructive operation.\n\
+ALL undo/redo information will be lost if you clean-up.\n\
+Clean-up will move all unused files to a \"dead\" location."));
- checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
-ALL undo/redo information will be lost if you cleanup.\n\
-After cleanup, unused audio files will be moved to a \
-\"dead sounds\" location."));
-
checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
- checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
+ checker.add_button (_("Clean-up"), RESPONSE_ACCEPT);
checker.set_default_response (RESPONSE_CANCEL);
checker.set_name (_("CleanupDialog"));
- checker.set_wmclass (X_("ardour_cleanup"), "Ardour");
+ checker.set_wmclass (X_("ardour_cleanup"), PROGRAM_NAME);
checker.set_position (Gtk::WIN_POS_MOUSE);
switch (checker.run()) {
return;
}
- Session::cleanup_report rep;
+ ARDOUR::CleanupReport rep;
editor->prepare_for_cleanup ();
act->set_sensitive (false);
}
- if (session->cleanup_sources (rep)) {
+ if (_session->cleanup_sources (rep)) {
editor->finish_cleanup ();
return;
}
-
+
editor->finish_cleanup ();
checker.hide();
- display_cleanup_results (rep,
- _("cleaned files"),
+ display_cleanup_results (rep,
+ _("Cleaned Files"),
_("\
-The following %1 %2 not in use and \n\
-have been moved to:\n\
-%3. \n\n\
-Flushing the wastebasket will \n\
-release an additional\n\
-%4 %5bytes of disk space.\n"
+The following %1 files were not in use and \n\
+have been moved to:\n\n\
+%2\n\n\
+After a restart of Ardour,\n\n\
+Session -> Clean-up -> Flush Wastebasket\n\n\
+will release an additional\n\
+%3 %4bytes of disk space.\n"),
+ _("\
+The following file was not in use and \n\
+has been moved to:\n \
+%2\n\n\
+After a restart of Ardour,\n\n\
+Session -> Clean-up -> Flush Wastebasket\n\n\
+will release an additional\n\
+%3 %4bytes of disk space.\n"
));
}
void
ARDOUR_UI::flush_trash ()
{
- if (session == 0) {
+ if (_session == 0) {
/* shouldn't happen: menu item is insensitive */
return;
}
- Session::cleanup_report rep;
+ ARDOUR::CleanupReport rep;
- if (session->cleanup_trash_sources (rep)) {
+ if (_session->cleanup_trash_sources (rep)) {
return;
}
- display_cleanup_results (rep,
+ display_cleanup_results (rep,
_("deleted file"),
- _("The following %1 %2 deleted from\n\
-%3,\n\
-releasing %4 %5bytes of disk space"));
+ _("The following %1 files were deleted from\n\
+%2,\n\
+releasing %3 %4bytes of disk space"),
+ _("The following file was deleted from\n\
+%2,\n\
+releasing %3 %4bytes of disk space"));
}
void
{
int count;
- if (!session) {
+ if (!_session) {
return;
}
if (add_route_dialog == 0) {
- add_route_dialog = new AddRouteDialog;
+ add_route_dialog = new AddRouteDialog (_session);
if (float_window) {
add_route_dialog->set_transient_for (*float_window);
}
return;
}
+ string template_path = add_route_dialog->track_template();
+
+ if (!template_path.empty()) {
+ _session->new_route_from_template (count, template_path);
+ return;
+ }
+
uint32_t input_chan = add_route_dialog->channels ();
uint32_t output_chan;
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
+ RouteGroup* route_group = add_route_dialog->route_group ();
AutoConnectOption oac = Config->get_output_auto_connect();
if (oac & AutoConnectMaster) {
- output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan);
+ output_chan = (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan);
} else {
output_chan = input_chan;
}
/* XXX do something with name template */
-
+
if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
- session_add_midi_track(count);
+ session_add_midi_track (route_group, count, name_template);
} else {
MessageDialog msg (*editor,
_("Sorry, MIDI Busses are not supported at this time."));
msg.run ();
//session_add_midi_bus();
}
- } else {
+ } else {
if (track) {
- session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
+ session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count, name_template);
} else {
- session_add_audio_bus (input_chan, output_chan, count);
+ session_add_audio_bus (input_chan, output_chan, route_group, count, name_template);
}
}
}
{
XMLNode* node = 0;
- if (session) {
- node = session->instant_xml(X_("Mixer"));
+ if (_session) {
+ node = _session->instant_xml(X_("Mixer"));
} else {
node = Config->instant_xml(X_("Mixer"));
}
{
XMLNode* node = 0;
- if (session) {
- node = session->instant_xml(X_("Editor"));
+ if (_session) {
+ node = _session->instant_xml(X_("Editor"));
} else {
node = Config->instant_xml(X_("Editor"));
}
-
+
if (!node) {
if (getenv("ARDOUR_INSTANT_XML_PATH")) {
node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
XMLNode* node = 0;
node = Config->extra_xml(X_("Keyboard"));
-
+
if (!node) {
node = new XMLNode (X_("Keyboard"));
}
+
return node;
}
void
-ARDOUR_UI::create_xrun_marker(nframes_t where)
+ARDOUR_UI::create_xrun_marker (framepos_t where)
{
editor->mouse_add_new_marker (where, false, true);
}
}
void
-ARDOUR_UI::xrun_handler(nframes_t where)
+ARDOUR_UI::xrun_handler (framepos_t where)
{
- if (!session) {
+ if (!_session) {
return;
}
- ENSURE_GUI_THREAD (bind(mem_fun(*this, &ARDOUR_UI::xrun_handler), where));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::xrun_handler, where)
- if (session && Config->get_create_xrun_marker() && session->actively_recording()) {
+ if (_session && Config->get_create_xrun_marker() && _session->actively_recording()) {
create_xrun_marker(where);
}
- if (session && Config->get_stop_recording_on_xrun() && session->actively_recording()) {
+ if (_session && Config->get_stop_recording_on_xrun() && _session->actively_recording()) {
halt_on_xrun_message ();
}
}
void
ARDOUR_UI::disk_overrun_handler ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler)
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
- MessageDialog* msg = new MessageDialog (*editor, _("\
+ MessageDialog* msg = new MessageDialog (*editor, string_compose (_("\
The disk system on your computer\n\
-was not able to keep up with Ardour.\n\
+was not able to keep up with %1.\n\
\n\
Specifically, it failed to write data to disk\n\
-quickly enough to keep up with recording.\n"));
- msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+quickly enough to keep up with recording.\n"), PROGRAM_NAME));
+ msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
msg->show ();
}
}
void
ARDOUR_UI::disk_underrun_handler ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler)
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
- MessageDialog* msg = new MessageDialog (*editor,
- _("The disk system on your computer\n\
-was not able to keep up with Ardour.\n\
+ MessageDialog* msg = new MessageDialog (
+ *editor, 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\
-quickly enough to keep up with playback.\n"));
- msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+quickly enough to keep up with playback.\n"), PROGRAM_NAME));
+ msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
msg->show ();
- }
+ }
}
void
-ARDOUR_UI::disk_speed_dialog_gone (int ignored_response, MessageDialog* msg)
+ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
{
have_disk_speed_dialog_displayed = false;
delete msg;
void
ARDOUR_UI::session_dialog (std::string msg)
{
- ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::session_dialog), msg));
-
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::session_dialog, msg)
+
MessageDialog* d;
if (editor) {
d->show_all ();
d->run ();
delete d;
-}
+}
int
ARDOUR_UI::pending_state_dialog ()
}
int
-ARDOUR_UI::sr_mismatch_dialog (nframes_t desired, nframes_t actual)
+ARDOUR_UI::sr_mismatch_dialog (framecnt_t desired, framecnt_t actual)
{
HBox* hbox = new HBox();
Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
}
}
-
+
void
ARDOUR_UI::disconnect_from_jack ()
{
void
ARDOUR_UI::use_config ()
{
- Glib::RefPtr<Action> act;
-
- switch (Config->get_native_file_data_format ()) {
- case FormatFloat:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
- break;
- case FormatInt24:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
- break;
- case FormatInt16:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat16bit"));
- break;
- }
-
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
-
- switch (Config->get_native_file_header_format ()) {
- case BWF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
- break;
- case WAVE:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
- break;
- case WAVE64:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
- break;
- case iXML:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
- break;
- case RF64:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
- break;
- case CAF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
- break;
- case AIFF:
- act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
- break;
- }
-
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
-
XMLNode* node = Config->extra_xml (X_("TransportControllables"));
if (node) {
set_transport_controllable_state (*node);
}
void
-ARDOUR_UI::update_transport_clocks (nframes_t pos)
+ARDOUR_UI::update_transport_clocks (framepos_t pos)
{
if (Config->get_primary_clock_delta_edit_cursor()) {
- primary_clock.set (pos, false, editor->get_preferred_edit_position(), 1);
+ primary_clock->set (pos, false, editor->get_preferred_edit_position());
} else {
- primary_clock.set (pos, 0, true);
+ primary_clock->set (pos);
}
if (Config->get_secondary_clock_delta_edit_cursor()) {
- secondary_clock.set (pos, false, editor->get_preferred_edit_position(), 2);
+ secondary_clock->set (pos, false, editor->get_preferred_edit_position());
} else {
- secondary_clock.set (pos);
+ secondary_clock->set (pos);
+ }
+
+ if (big_clock_window->get()) {
+ big_clock->set (pos);
}
+}
+
+
+void
+ARDOUR_UI::step_edit_status_change (bool yn)
+{
+ // XXX should really store pre-step edit status of things
+ // we make insensitive
- if (big_clock_window) {
- big_clock.set (pos);
+ if (yn) {
+ rec_button.set_active_state (Mid);
+ rec_button.set_sensitive (false);
+ } else {
+ rec_button.unset_active_state ();;
+ rec_button.set_sensitive (true);
}
}
void
ARDOUR_UI::record_state_changed ()
{
- ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::record_state_changed));
+ ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
- if (!session || !big_clock_window) {
+ if (!_session || !big_clock_window->get()) {
/* why bother - the clock isn't visible */
return;
}
- switch (session->record_status()) {
- case Session::Recording:
- big_clock.set_widget_name ("BigClockRecording");
- break;
- default:
- big_clock.set_widget_name ("BigClockNonRecording");
- break;
+ if (_session->record_status () == Session::Recording && _session->have_rec_enabled_track ()) {
+ big_clock->set_active (true);
+ } else {
+ big_clock->set_active (false);
}
}
bool
ARDOUR_UI::first_idle ()
{
- if (session) {
- session->allow_auto_play (true);
+ if (_session) {
+ _session->allow_auto_play (true);
}
if (editor) {
XMLNode* node = new XMLNode(X_("ClockModes"));
for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
- node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
+ 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")));
+
+ node->add_child_nocopy (*child);
}
- session->add_extra_xml (*node);
- session->set_dirty ();
+ _session->add_extra_xml (*node);
+ _session->set_dirty ();
}
-
-
ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp)
: Controllable (name), ui (u), type(tp)
{
-
+
}
void
-ARDOUR_UI::TransportControllable::set_value (float val)
+ARDOUR_UI::TransportControllable::set_value (double val)
{
- if (type == ShuttleControl) {
- double fract;
-
- if (val == 0.5f) {
- fract = 0.0;
- } else {
- if (val < 0.5f) {
- fract = -((0.5f - val)/0.5f);
- } else {
- fract = ((val - 0.5f)/0.5f);
- }
- }
-
- ui.set_shuttle_fract (fract);
- return;
- }
-
- if (val < 0.5f) {
+ if (val < 0.5) {
/* do nothing: these are radio-style actions */
return;
}
}
}
-float
+double
ARDOUR_UI::TransportControllable::get_value (void) const
{
- float val = 0.0f;
-
+ float val = 0.0;
+
switch (type) {
case Roll:
break;
break;
case RecordEnable:
break;
- case ShuttleControl:
- break;
default:
break;
}
return val;
}
-void
-ARDOUR_UI::TransportControllable::set_id (const string& str)
-{
- _id = str;
-}
-
void
ARDOUR_UI::setup_profile ()
{
}
}
+void
+ARDOUR_UI::toggle_translations ()
+{
+ using namespace Glib;
+
+ RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("EnableTranslation"));
+ if (act) {
+ RefPtr<ToggleAction> ract = RefPtr<ToggleAction>::cast_dynamic (act);
+ if (ract) {
+
+ string i18n_killer = ARDOUR::translation_kill_path();
+
+ bool already_enabled = !ARDOUR::translations_are_disabled ();
+
+ if (ract->get_active ()) {
+/* we don't care about errors */
+ int fd = ::open (i18n_killer.c_str(), O_RDONLY|O_CREAT, 0644);
+ close (fd);
+ } else {
+/* we don't care about errors */
+ unlink (i18n_killer.c_str());
+ }
+
+ if (already_enabled != ract->get_active()) {
+ MessageDialog win (already_enabled ? _("Translations disabled") : _("Translations enabled"),
+ false,
+ Gtk::MESSAGE_WARNING,
+ Gtk::BUTTONS_OK);
+ win.set_secondary_text (string_compose (_("You must restart %1 for this to take effect."), PROGRAM_NAME));
+ win.set_position (Gtk::WIN_POS_CENTER);
+ win.present ();
+ win.run ();
+ }
+ }
+ }
+}
+
+/** Add a window proxy to our list, so that its state will be saved.
+ * This call also causes the window to be created and opened if its
+ * state was saved as `visible'.
+ */
+void
+ARDOUR_UI::add_window_proxy (WindowProxyBase* p)
+{
+ _window_proxies.push_back (p);
+ p->maybe_show ();
+}
+
+/** Remove a window proxy from our list. Must be called if a WindowProxy
+ * is deleted, to prevent hanging pointers.
+ */
+void
+ARDOUR_UI::remove_window_proxy (WindowProxyBase* p)
+{
+ _window_proxies.remove (p);
+}
+
+int
+ARDOUR_UI::missing_file (Session*s, std::string str, DataType type)
+{
+ MissingFileDialog dialog (s, str, type);
+
+ dialog.show ();
+ dialog.present ();
+
+ int result = dialog.run ();
+ dialog.hide ();
+
+ switch (result) {
+ case RESPONSE_OK:
+ break;
+ default:
+ return 1; // quit entire session load
+ }
+
+ result = dialog.get_action ();
+
+ return result;
+}
+
+int
+ARDOUR_UI::ambiguous_file (std::string file, std::string /*path*/, std::vector<std::string> hits)
+{
+ AmbiguousFileDialog dialog (file, hits);
+
+ dialog.show ();
+ dialog.present ();
+
+ dialog.run ();
+ return dialog.get_which ();
+}
+
+/** Allocate our thread-local buffers */
+void
+ARDOUR_UI::get_process_buffers ()
+{
+ _process_thread->get_buffers ();
+}
+
+/** Drop our thread-local buffers */
+void
+ARDOUR_UI::drop_process_buffers ()
+{
+ _process_thread->drop_buffers ();
+}
+
+void
+ARDOUR_UI::feedback_detected ()
+{
+ _feedback_exists = true;
+}
+
+void
+ARDOUR_UI::successful_graph_sort ()
+{
+ _feedback_exists = false;
+}
+
+void
+ARDOUR_UI::midi_panic ()
+{
+ if (_session) {
+ _session->midi_panic();
+ }
+}
projects / ardour.git / blobdiff