#include <pbd/compose.h>
#include <pbd/pathscanner.h>
#include <pbd/failed_constructor.h>
+#include <pbd/enumwriter.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/click_box.h>
sigc::signal<void,bool> ARDOUR_UI::Blink;
sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
-sigc::signal<void,jack_nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void,nframes_t> ARDOUR_UI::Clock;
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
: Gtkmm2ext::UI ("ardour", argcp, argvp, rcfile),
- primary_clock (X_("TransportClockDisplay"), true, false, true),
- secondary_clock (X_("SecondaryClockDisplay"), true, false, true),
- preroll_clock (X_("PreRollClock"), true, true),
- postroll_clock (X_("PostRollClock"), true, true),
+ 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),
/* adjuster table */
/* big clock */
- big_clock ("BigClockDisplay", true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
/* transport */
color_manager = new ColorManager();
std::string color_file = ARDOUR::find_config_file("ardour.colors");
-
+
color_manager->load (color_file);
editor = 0;
route_params = 0;
option_editor = 0;
location_ui = 0;
- sfdb = 0;
open_session_selector = 0;
have_configure_timeout = false;
have_disk_overrun_displayed = false;
_will_create_new_session_automatically = false;
session_loaded = false;
last_speed_displayed = -1.0f;
+ keybindings_path = ARDOUR::find_config_file ("ardour.bindings");
+
+ can_save_keybindings = false;
+ Glib::signal_idle().connect (mem_fun (*this, &ARDOUR_UI::first_idle));
last_configure_time.tv_sec = 0;
last_configure_time.tv_usec = 0;
shuttle_fract = 0.0;
shuttle_max_speed = 8.0f;
- set_shuttle_units (Percentage);
- set_shuttle_behaviour (Sprung);
-
shuttle_style_menu = 0;
shuttle_unit_menu = 0;
gettimeofday (&last_peak_grab, 0);
gettimeofday (&last_shuttle_request, 0);
- ARDOUR::AudioDiskstream::DeleteSources.connect (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread));
ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
throw failed_constructor();
}
+ /* set default clock modes */
+
+ primary_clock.set_mode (AudioClock::SMPTE);
+ secondary_clock.set_mode (AudioClock::BBT);
+
/* start the time-of-day-clock */
update_wall_clock ();
Config->add_instant_xml (mnode, get_user_ardour_path());
}
- /* keybindings */
-
- AccelMap::save ("ardour.saved_bindings");
+ save_keybindings ();
}
void
ARDOUR_UI::startup ()
{
- /* Once the UI is up and running, start the audio engine. Doing
- this before the UI is up and running can cause problems
- when not running with SCHED_FIFO, because the amount of
- CPU and disk work needed to get the UI started can interfere
- with the scheduling of the audio thread.
- */
-
- Glib::signal_idle().connect (mem_fun(*this, &ARDOUR_UI::start_engine));
+ // relax
}
void
break;
}
}
+
+ if (session) {
+ session->set_deletion_in_progress ();
+ }
+ engine->stop (true);
Config->save_state();
quit ();
}
save_the_session = 0;
- editor->ensure_float (window);
+ window.set_keep_above (true);
+ window.present ();
ResponseType r = (ResponseType) window.run();
}
void
-ARDOUR_UI::update_sample_rate (jack_nframes_t ignored)
+ARDOUR_UI::update_sample_rate (nframes_t ignored)
{
char buf[32];
} else {
- jack_nframes_t rate = engine->frame_rate();
+ nframes_t rate = engine->frame_rate();
if (fmod (rate, 1000.0) != 0.0) {
snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f msecs"),
}
void
-ARDOUR_UI::count_recenabled_diskstreams (Route& route)
+ARDOUR_UI::count_recenabled_streams (Route& route)
{
Track* track = dynamic_cast<Track*>(&route);
if (track && track->diskstream()->record_enabled()) {
- rec_enabled_diskstreams++;
+ rec_enabled_streams += track->n_inputs();
}
}
return;
}
- jack_nframes_t frames = session->available_capture_duration();
+ nframes_t frames = session->available_capture_duration();
char buf[64];
if (frames == max_frames) {
int hrs;
int mins;
int secs;
- jack_nframes_t fr = session->frame_rate();
+ nframes_t fr = session->frame_rate();
- if (session->actively_recording()){
-
- rec_enabled_diskstreams = 0;
- session->foreach_route (this, &ARDOUR_UI::count_recenabled_diskstreams);
-
- if (rec_enabled_diskstreams) {
- frames /= rec_enabled_diskstreams;
- }
-
- } else {
-
- /* hmmm. shall we divide by the route count? or the diskstream count?
- or what? for now, do nothing ...
- */
-
+ rec_enabled_streams = 0;
+ session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
+
+ if (rec_enabled_streams) {
+ frames /= rec_enabled_streams;
}
hrs = frames / (fr * 3600);
}
void
-ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
+ARDOUR_UI::do_transport_locate (nframes_t new_position)
{
- jack_nframes_t _preroll;
+ nframes_t _preroll = 0;
if (session) {
- _preroll = session->convert_to_frames_at (new_position, session->preroll);
+ // XXX CONFIG_CHANGE FIX - requires AnyTime handling
+ // _preroll = session->convert_to_frames_at (new_position, Config->get_preroll());
if (new_position > _preroll) {
new_position -= _preroll;
ARDOUR_UI::transport_goto_end ()
{
if (session) {
- jack_nframes_t frame = session->current_end_frame();
+ nframes_t frame = session->current_end_frame();
session->request_locate (frame);
/* force displayed area in editor to start no matter
return;
}
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (session->get_play_loop ()) {
+ session->request_play_loop (false);
}
session->request_stop ();
switch (session->record_status()) {
case Session::Disabled:
if (session->ntracks() == 0) {
- string txt = _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu.");
- MessageDialog msg (*editor, txt);
+ MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
msg.run ();
return;
}
rolling = session->transport_rolling ();
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (session->get_play_loop()) {
+ session->request_play_loop (false);
auto_loop_button.set_active (false);
roll_button.set_active (true);
} else if (session->get_play_range ()) {
ARDOUR_UI::transport_loop()
{
if (session) {
- if (session->get_auto_loop()) {
+ if (session->get_play_loop()) {
if (session->transport_rolling()) {
Location * looploc = session->locations()->auto_loop_location();
if (looploc) {
}
}
else {
- session->request_auto_loop (true);
+ session->request_play_loop (true);
}
}
}
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
}
-
void
ARDOUR_UI::engine_running ()
{
engine->start();
}
- catch (AudioEngine::PortRegistrationFailure& err) {
- engine->stop ();
- error << _("Unable to create all required ports")
- << endmsg;
- unload_session ();
- return -1;
- }
-
catch (...) {
engine->stop ();
error << _("Unable to start the session running")
*/
session->save_state ("");
}
-
- /* there is too much going on, in too many threads, for us to
- end up with a clean session. So wait 1 second after loading,
- and fix it up. its ugly, but until i come across a better
- solution, its what we have.
- */
-
- Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::make_session_clean), 1000);
}
return FALSE;
void
ARDOUR_UI::update_clocks ()
{
- Clock (session->audible_frame()); /* EMIT_SIGNAL */
+ if (!editor || !editor->dragging_playhead()) {
+ Clock (session->audible_frame()); /* EMIT_SIGNAL */
+ }
}
void
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
prompter.set_prompt (_("Name of New Snapshot"));
prompter.set_initial_text (now);
prompter.set_prompt (_("Name for mix template:"));
prompter.set_initial_text(session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
}
void
-ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
+ARDOUR_UI::new_session (std::string predetermined_path)
{
string session_name;
string session_path;
int response = Gtk::RESPONSE_NONE;
new_session_dialog->set_modal(true);
- new_session_dialog->set_name(predetermined_path);
+ new_session_dialog->set_name (predetermined_path);
new_session_dialog->reset_recent();
new_session_dialog->show();
- //Glib::RefPtr<Gdk::Window> nsd_window = new_session_dialog->get_window();
-
do {
response = new_session_dialog->run ();
- //nsd_window ->set_cursor(Gdk::Cursor(Gdk::WATCH));
- if(response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
- quit();
+
+ _session_is_new = false;
+
+ if (response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
+
+ if (!session) {
+ quit();
+ }
+ new_session_dialog->hide ();
return;
} else if (response == Gtk::RESPONSE_NONE) {
+
/* Clear was pressed */
new_session_dialog->reset();
if (session_name.empty()) {
response = Gtk::RESPONSE_NONE;
- cerr << "session name is empty\n";
continue;
}
} else if (response == Gtk::RESPONSE_OK) {
+ session_name = new_session_dialog->session_name();
+
if (new_session_dialog->get_current_page() == 1) {
/* XXX this is a bit of a hack..
if (session_name.empty()) {
response = Gtk::RESPONSE_NONE;
- cerr << "session name is empty 2\n";
continue;
}
} else {
- _session_is_new = true;
-
- session_name = new_session_dialog->session_name();
-
if (session_name.empty()) {
response = Gtk::RESPONSE_NONE;
- cerr << "session name is empty 3\n";
continue;
}
} else {
- std::string session_path = new_session_dialog->session_folder();
-
+ session_path = new_session_dialog->session_folder();
+
}
-
+
//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 (g_file_test (session_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
+
+ Glib::ustring str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
+
+ MessageDialog msg (str,
+ false,
+ Gtk::MESSAGE_WARNING,
+ Gtk::BUTTONS_YES_NO,
+ true);
+
+
+ msg.set_name (X_("CleanupDialog"));
+ msg.set_wmclass (X_("existing_session"), "Ardour");
+ msg.set_position (Gtk::WIN_POS_MOUSE);
+
+ switch (msg.run()) {
+ case RESPONSE_YES:
+ load_session (session_path, session_name);
+ goto done;
+ break;
+ default:
+ response = RESPONSE_NONE;
+ new_session_dialog->reset ();
+ continue;
+ }
+ }
+
+ _session_is_new = true;
+
std::string template_name = new_session_dialog->session_template_name();
if (new_session_dialog->use_session_template()) {
uint32_t cchns;
uint32_t mchns;
- Session::AutoConnectOption iconnect;
- Session::AutoConnectOption oconnect;
+ AutoConnectOption iconnect;
+ AutoConnectOption oconnect;
if (new_session_dialog->create_control_bus()) {
cchns = (uint32_t) new_session_dialog->control_channel_count();
}
if (new_session_dialog->connect_inputs()) {
- iconnect = Session::AutoConnectPhysical;
+ iconnect = AutoConnectPhysical;
} else {
- iconnect = Session::AutoConnectOption (0);
+ iconnect = AutoConnectOption (0);
}
/// @todo some minor tweaks.
if (new_session_dialog->connect_outs_to_master()) {
- oconnect = Session::AutoConnectMaster;
+ oconnect = AutoConnectMaster;
} else if (new_session_dialog->connect_outs_to_physical()) {
- oconnect = Session::AutoConnectPhysical;
+ oconnect = AutoConnectPhysical;
} else {
- oconnect = Session::AutoConnectOption (0);
+ oconnect = AutoConnectOption (0);
}
uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
} while (response == Gtk::RESPONSE_NONE);
+ done:
show();
new_session_dialog->get_window()->set_cursor();
new_session_dialog->hide();
Session *new_session;
int x;
session_loaded = false;
+
x = unload_session ();
if (x < 0) {
/* if it already exists, we must have write access */
if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
- MessageDialog msg (*editor, _("\
-You do not have write access to this session.\n\
-This prevents the session from being loaded."));
+ MessageDialog msg (*editor, _("You do not have write access to this session.\n"
+ "This prevents the session from being loaded."));
msg.run ();
return -1;
}
connect_to_session (new_session);
+ Config->set_current_owner (ConfigVariableBase::Interface);
+
session_loaded = true;
- return 0;
-}
+
+ goto_editor_window ();
-int
-ARDOUR_UI::make_session_clean ()
-{
if (session) {
session->set_clean ();
}
- show ();
-
- return FALSE;
+ return 0;
}
int
ARDOUR_UI::build_session (const string & path, const string & snap_name,
uint32_t control_channels,
uint32_t master_channels,
- Session::AutoConnectOption input_connect,
- Session::AutoConnectOption output_connect,
+ AutoConnectOption input_connect,
+ AutoConnectOption output_connect,
uint32_t nphysin,
uint32_t nphysout,
- jack_nframes_t initial_length)
+ nframes_t initial_length)
{
Session *new_session;
int x;
{
if (editor) {
editor->show_window ();
+
+ if (!shown_flag) {
+ editor->present ();
+ }
+
shown_flag = true;
}
-
- if (about) {
- about->present ();
- }
}
void
{
if (about == 0) {
about = new About();
+ about->signal_response().connect(mem_fun (*this, &ARDOUR_UI::about_signal_response) );
}
about->present();
+ flush_pending ();
+}
+
+void
+ARDOUR_UI::about_signal_response(int response)
+{
+ hide_splash();
}
void
_("No audio files were ready for cleanup"),
true,
Gtk::MESSAGE_INFO,
- (Gtk::ButtonsType)(Gtk::BUTTONS_CLOSE) );
+ (Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
msgd.set_secondary_text (_("If this seems suprising, \n\
check for any existing snapshots.\n\
These may still include regions that\n\
checker.set_default_response (RESPONSE_CANCEL);
checker.set_name (_("CleanupDialog"));
- checker.set_wmclass (_("ardour_cleanup"), "Ardour");
+ checker.set_wmclass (X_("ardour_cleanup"), "Ardour");
checker.set_position (Gtk::WIN_POS_MOUSE);
switch (checker.run()) {
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
- Session::AutoConnectOption oac = session->get_output_auto_connect();
+ AutoConnectOption oac = Config->get_output_auto_connect();
- if (oac & Session::AutoConnectMaster) {
+ if (oac & AutoConnectMaster) {
output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
} else {
output_chan = input_chan;
msg.run ();
}
-void
-ARDOUR_UI::delete_sources_in_the_right_thread (list<boost::shared_ptr<ARDOUR::Source> >* deletion_list)
-{
- ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread), deletion_list));
-
- for (list<boost::shared_ptr<Source> >::iterator i = deletion_list->begin(); i != deletion_list->end(); ++i) {
- (*i)->drop_references ();
- }
-
- delete deletion_list;
-}
-
void
ARDOUR_UI::disk_overrun_handler ()
{
}
void
-ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
+ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
{
engine->request_buffer_size (nframes);
update_sample_rate (0);
path = str;
}
- new_session (false, path);
+ new_session (path);
_will_create_new_session_automatically = false; /* done it */
return FALSE; /* don't call it again */
}
-void
-ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
-{
- Glib::RefPtr<Action> act;
-
- switch (hf) {
- 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);
- if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
- Config->set_native_file_header_format (hf);
- if (session) {
- session->reset_native_file_format ();
- }
- }
- }
-}
-
-void
-ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
-{
- Glib::RefPtr<Action> act;
-
- switch (sf) {
- case FormatFloat:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
- break;
- case FormatInt24:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
- break;
- }
-
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
-
- if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
- Config->set_native_file_data_format (sf);
- if (session) {
- session->reset_native_file_format ();
- }
- }
- }
-}
-
void
ARDOUR_UI::use_config ()
{
ract->set_active ();
}
}
+
+void
+ARDOUR_UI::update_transport_clocks (nframes_t pos)
+{
+ primary_clock.set (pos);
+ secondary_clock.set (pos);
+
+ if (big_clock_window) {
+ big_clock.set (pos);
+ }
+}
+
+void
+ARDOUR_UI::record_state_changed ()
+{
+ if (!session || !big_clock_window) {
+ /* why bother - the clock isn't visible */
+ return;
+ }
+
+ switch (session->record_status()) {
+ case Session::Recording:
+ big_clock.set_widget_name ("BigClockRecording");
+ break;
+ default:
+ big_clock.set_widget_name ("BigClockNonRecording");
+ break;
+ }
+}
+
+void
+ARDOUR_UI::set_keybindings_path (string path)
+{
+ keybindings_path = path;
+}
+
+void
+ARDOUR_UI::save_keybindings ()
+{
+ if (can_save_keybindings) {
+ AccelMap::save (keybindings_path);
+ }
+}
+
+bool
+ARDOUR_UI::first_idle ()
+{
+ can_save_keybindings = true;
+ return false;
+}
+
+void
+ARDOUR_UI::store_clock_modes ()
+{
+ 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()));
+ }
+
+ session->add_extra_xml (*node);
+ session->set_dirty ();
+}
+
+
+