#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/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 "startup.h"
#include "engine_dialog.h"
#include "processor_box.h"
+#include "time_axis_view_item.h"
#include "i18n.h"
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
- : Gtkmm2ext::UI (X_("gui"), argcp, argvp),
+ : Gtkmm2ext::UI (PROGRAM_NAME, argcp, argvp),
primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, true, false, true),
secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, true, false, true),
/* big clock */
- big_clock (X_("bigclock"), false, "BigClockNonRecording", true, true, false, true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", true, true, false, false),
/* transport */
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.unset_flags (Gtk::CAN_FOCUS);
stop_button.unset_flags (Gtk::CAN_FOCUS);
last_shuttle_request = last_peak_grab = 0; // get_microseconds();
- ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context());
- ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context());
+ 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());
/* handle dialog requests */
- ARDOUR::Session::Dialog.connect (forever_connections, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
+ ARDOUR::Session::Dialog.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
/* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
/* we like keyboards */
- keyboard = new ArdourKeyboard;
+ keyboard = new ArdourKeyboard(*this);
XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
if (node) {
reset_dpi();
+ TimeAxisViewItem::set_constant_heights ();
+
starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
/** @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)
+ARDOUR_UI::run_startup (bool should_be_new, string load_template)
{
if (_startup == 0) {
_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();
loading_message (_("Starting audio engine"));
try {
- engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
+ engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name, ARDOUR_COMMAND_LINE::jack_session_uuid);
} catch (...) {
return -1;
}
- engine->Stopped.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context());
- engine->Running.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_running, this), gui_context());
- engine->Halted.connect (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this), gui_context());
- engine->SampleRateChanged.connect (forever_connections, ui_bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
+ 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 ();
ActionManager::init ();
/* 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 (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
#endif
update_cpu_load ();
update_sample_rate (engine->frame_rate());
- Config->ParameterChanged.connect (forever_connections, ui_bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
+ 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);
ARDOUR_UI::~ARDOUR_UI ()
{
- save_ardour_state ();
-
delete keyboard;
delete editor;
delete mixer;
{
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;
}
}
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 (_startup && _startup->engine_control() && _startup->engine_control()->was_used()) {
- Config->add_extra_xml (_startup->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 ()
{
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,
void
ARDOUR_UI::startup ()
{
- XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
-
- if (audio_setup && _startup && _startup->engine_control()) {
- _startup->engine_control()->set_state (*audio_setup);
- }
-
- if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session)) {
+ if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session, ARDOUR_COMMAND_LINE::load_template)) {
exit (1);
}
goto_editor_window ();
- BootMessage (_("Ardour is ready for use"));
+ BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
show ();
}
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"));
ARDOUR_UI::finish()
{
if (_session) {
+ int tries = 0;
- if (_session->transport_rolling()) {
- _session->request_stop ();
- usleep (250000);
+ if (_session->transport_rolling() && (++tries < 8)) {
+ _session->request_stop (false, true);
+ usleep (10000);
}
if (_session->dirty()) {
_session = 0;
}
+ cerr << "Save before quit\n";
+ save_ardour_state ();
+
ArdourDialog::close_all_dialogs ();
engine->stop (true);
- save_ardour_state ();
quit ();
}
int
ARDOUR_UI::ask_about_saving_session (const string & what)
{
- 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));
c = _session->capture_load ();
p = _session->playback_load ();
- push_buffer_stats (c, p);
-
snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
_session->playback_load(), _session->capture_load());
buffer_load_label.set_text (buf);
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();
}
}
{
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;
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);
}
}
}
}
-
-#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 (...) {
if (_session) {
_session->request_locate (0);
-
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
return;
}
- _session->request_stop ();
+ _session->request_stop (false, true);
}
void
ARDOUR_UI::transport_stop_and_forget_capture ()
{
if (_session) {
- _session->request_stop (true);
+ _session->request_stop (true, true);
}
}
bool rolling = _session->transport_rolling();
if (_session->get_play_loop()) {
- _session->request_play_loop (false, true);
+ /* 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.get_active()) {
/* stop playing a range if we currently are */
_session->request_play_range (0, true);
if (!rolling) {
_session->request_transport_speed (1.0f);
}
-
- map_transport_state ();
}
void
_session->request_play_loop (false, true);
} else if (_session->get_play_range ()) {
affect_transport = false;
- _session->request_play_range (0, true);
+ _session->request_play_range (0, true);
}
}
_session->request_transport_speed (1.0f);
}
}
-
- map_transport_state ();
}
void
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());
}
}
if (_session == 0) {
play_selection_button.set_visual_state (0);
auto_loop_button.set_visual_state (0);
}
-
}
void
}
void
-ARDOUR_UI::engine_halted ()
+ARDOUR_UI::engine_halted (const char* reason, bool free_reason)
{
- ENSURE_GUI_THREAD (*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 = _("\
JACK has either been shutdown or it\n\
disconnected Ardour because Ardour\n\
was not fast enough. Try to restart\n\
-JACK, reconnect and save the session."));
+JACK, reconnect and save the session.");
+ }
+
+ MessageDialog msg (*editor, msgstr);
pop_back_splash ();
msg.run ();
+
+ if (free_reason) {
+ free ((char*) reason);
+ }
}
int32_t
/** Ask the user for the name of a new shapshot and then take it.
*/
+
void
-ARDOUR_UI::snapshot_session ()
+ARDOUR_UI::snapshot_session (bool switch_to_it)
{
ArdourPrompter prompter (true);
string snapname;
- char timebuf[128];
- time_t n;
- struct tm local_time;
-
- time (&n);
- localtime_r (&n, &local_time);
- strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
prompter.set_title (_("Take Snapshot"));
- prompter.set_prompt (_("Name of New Snapshot"));
- prompter.set_initial_text (timebuf);
+ prompter.set_title (_("Take Snapshot"));
+ prompter.set_prompt (_("Name of new snapshot"));
+
+ if (!switch_to_it) {
+ char timebuf[128];
+ time_t n;
+ struct tm local_time;
+
+ time (&n);
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
+ prompter.set_initial_text (timebuf);
+ }
+ again:
switch (prompter.run()) {
case RESPONSE_ACCEPT:
{
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;
+ }
+ }
+
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);
+ 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);
}
if (do_save) {
- save_state (snapname);
+ save_state (snapname, switch_to_it);
}
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);
+ 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) {
int ret;
name = _session->snap_name();
}
- if ((ret = _session->save_state (name)) != 0) {
+ if ((ret = _session->save_state (name, false, switch_to_it)) != 0) {
return ret;
}
}
+ cerr << "SS canfail\n";
save_ardour_state (); /* XXX cannot fail? yeah, right ... */
return 0;
}
}
Session::RecordState const r = _session->record_status ();
- bool const h = _session->have_rec_enabled_diskstream ();
+ bool const h = _session->have_rec_enabled_track ();
if (r == Session::Enabled || (r == Session::Recording && !h)) {
if (onoff) {
int
ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& 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 (_startup->create_control_bus()) {
- cchns = (uint32_t) _startup->control_channel_count();
- } else {
- cchns = 0;
- }
-
if (_startup->create_master_bus()) {
- mchns = (uint32_t) _startup->master_channel_count();
+ bus_profile.master_out_channels = (uint32_t) _startup->master_channel_count();
} else {
- mchns = 0;
+ bus_profile.master_out_channels = 0;
}
if (_startup->connect_inputs()) {
- iconnect = AutoConnectPhysical;
+ bus_profile.input_ac = AutoConnectPhysical;
} else {
- iconnect = AutoConnectOption (0);
+ bus_profile.input_ac = AutoConnectOption (0);
}
/// @todo some minor tweaks.
-
- oconnect = AutoConnectOption (0);
+
+ bus_profile.output_ac = AutoConnectOption (0);
if (_startup->connect_outputs ()) {
if (_startup->connect_outs_to_master()) {
- oconnect = AutoConnectMaster;
+ bus_profile.output_ac = AutoConnectMaster;
} else if (_startup->connect_outs_to_physical()) {
- oconnect = AutoConnectPhysical;
+ bus_profile.output_ac = AutoConnectPhysical;
}
}
- nphysin = (uint32_t) _startup->input_limit_count();
- nphysout = (uint32_t) _startup->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;
}
/** @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)
+ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new, string load_template)
{
Glib::ustring session_name;
Glib::ustring session_path;
int ret = -1;
bool likely_new = false;
+ if (! load_template.empty()) {
+ should_be_new = true;
+ template_name = load_template;
+ }
+
while (ret != 0) {
if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) {
} else {
- bool const apply = run_startup (should_be_new);
+ bool const apply = run_startup (should_be_new, load_template);
if (!apply) {
if (quit_on_cancel) {
exit (1);
(session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
(session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
+ /* 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);
continue;
}
+ if (session_name.find ('/') != Glib::ustring::npos) {
+ MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
+
+ if (session_name.find ('\\') != Glib::ustring::npos) {
+ MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
+ msg.run ();
+ ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
+ continue;
+ }
+
_session_is_new = true;
}
return;
}
- unload_session (true);
+ if (unload_session (true)) {
+ return;
+ }
ARDOUR_COMMAND_LINE::session_name = "";
get_session_parameters (true, false);
goto out;
}
- loading_message (_("Please wait while Ardour loads your session"));
+ loading_message (string_compose (_("Please wait while %1loads 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 */
}
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 Glib::ustring& path, const Glib::ustring& snap_name, BusProfile& bus_profile)
{
Session *new_session;
int x;
_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 (...) {
}
}
+void
+ARDOUR_UI::launch_chat ()
+{
+#ifdef __APPLE__
+ open_uri("http://webchat.freenode.net/?channels=ardour-osx");
+#else
+ open_uri("http://webchat.freenode.net/?channels=ardour");
+#endif
+}
+
void
ARDOUR_UI::show_about ()
{
about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) );
}
+ about->set_transient_for(*editor);
about->show_all ();
}
return;
}
- ArdourDialog results (_("ardour: cleanup"), true, false);
+ ArdourDialog results (_("Clean-up"), true, false);
struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
CleanupResultsModelColumns() {
const string dead_sound_directory = _session->session_directory().dead_sound_path().to_string();
-
-
-
/* subst:
%1 - number of files removed
%2 - location of "dead_sounds"
*/
const char* bprefix;
+ double space_adjusted = 0;
- if (rep.space < 1048576.0f) {
+ if (rep.space < 100000.0f) {
bprefix = X_("kilo");
- } else if (rep.space < 1048576.0f * 1000) {
+ } else if (rep.space < 1000000.0f * 1000) {
bprefix = X_("mega");
+ space_adjusted = truncf((float)rep.space / 1000.0);
} else {
bprefix = X_("giga");
+ space_adjusted = truncf((float)rep.space / (1000000.0 * 1000));
}
if (removed > 1) {
- txt.set_text (string_compose (plural_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
+ txt.set_text (string_compose (plural_msg, removed, _session->path() + "dead_sounds", space_adjusted, bprefix));
} else {
- txt.set_text (string_compose (singular_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
+ txt.set_text (string_compose (singular_msg, removed, _session->path() + "dead_sounds", space_adjusted, bprefix));
}
dhbox.pack_start (*dimage, true, false, 5);
}
}
-void
-ARDOUR_UI::push_buffer_stats (uint32_t capture, uint32_t playback)
-{
- time_t now;
- time (&now);
-
- while (disk_buffer_stats.size() > 60) {
- disk_buffer_stats.pop_front ();
- }
-
- disk_buffer_stats.push_back (DiskBufferStat (now, capture, playback));
-}
-
-void
-ARDOUR_UI::write_buffer_stats ()
-{
-
- std::ofstream fout;
- struct tm tm;
- char buf[64];
- char path[PATH_MAX+1]; int fd;
-
- strcpy (path, "ardourBufferingXXXXXX");
-
- if ((fd = mkstemp (path )) < 0) {
- cerr << X_("cannot find temporary name for ardour buffer stats") << endl;
- return;
- }
-
- fout.open (path);
- close (fd);
-
- if (!fout) {
- cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), path) << endl;
- return;
- }
-
- for (list<DiskBufferStat>::iterator i = disk_buffer_stats.begin(); i != disk_buffer_stats.end(); ++i) {
- localtime_r (&(*i).when, &tm);
- strftime (buf, sizeof (buf), "%T", &tm);
- fout << buf << ' ' << (*i).capture << ' ' << (*i).playback << endl;
- }
-
- disk_buffer_stats.clear ();
-
- fout.close ();
-
- cerr << "Ardour buffering statistics can be found in: " << path << endl;
-}
-
void
ARDOUR_UI::disk_overrun_handler ()
{
ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler)
- write_buffer_stats ();
-
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
MessageDialog* msg = new MessageDialog (*editor, _("\
{
ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler)
- write_buffer_stats ();
-
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
MessageDialog* msg = new MessageDialog (*editor,
if (node) {
set_transport_controllable_state (*node);
}
+
+ node = Config->extra_xml (X_("UI"));
+
+ if (node) {
+ const XMLProperty* prop = node->property (X_("show-big-clock"));
+ Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleBigClock"));
+ if (act) {
+ Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+ tact->set_active (string_is_affirmative (prop->value()));
+ }
+ }
}
void
}
Session::RecordState const r = _session->record_status ();
- bool const h = _session->have_rec_enabled_diskstream ();
+ bool const h = _session->have_rec_enabled_track ();
if (r == Session::Recording && h) {
big_clock.set_widget_name ("BigClockRecording");
projects / ardour.git / blobdiff