along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
#include <algorithm>
#include <cmath>
#include <fcntl.h>
#include <gtkmm/accelmap.h>
#include <pbd/error.h>
+#include <pbd/misc.h>
#include <pbd/compose.h>
-#include <pbd/pathscanner.h>
#include <pbd/failed_constructor.h>
#include <pbd/enumwriter.h>
-#include <pbd/stacktrace.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++/port.h>
-#include <midi++/mmc.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/recent_sessions.h>
#include <ardour/port.h>
#include <ardour/audio_track.h>
+#include <ardour/midi_track.h>
+#include <ardour/filesystem_paths.h>
#include "actions.h"
#include "ardour_ui.h"
#include "about.h"
#include "utils.h"
#include "gui_thread.h"
-#include "color_manager.h"
+#include "theme_manager.h"
+#include "bundle_manager.h"
#include "i18n.h"
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::MidRapidScreenUpdate;
sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
-sigc::signal<void,nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void,nframes_t, bool, nframes_t> ARDOUR_UI::Clock;
-ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
+ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
- : Gtkmm2ext::UI ("ardour", argcp, argvp, rcfile),
+ : 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),
auditioning_alert_button (_("AUDITION")),
solo_alert_button (_("SOLO")),
- shown_flag (false)
+ shown_flag (false),
+ error_log_button (_("Errors"))
+
{
using namespace Gtk::Menu_Helpers;
Gtkmm2ext::init();
+
+#ifdef TOP_MENUBAR
+ _auto_display_errors = false;
+#endif
about = 0;
if (theArdourUI == 0) {
theArdourUI = this;
}
- /* load colors */
-
- color_manager = new ColorManager();
-
- std::string color_file = ARDOUR::find_config_file("ardour.colors");
-
- color_manager->load (color_file);
-
+ ui_config = new UIConfiguration();
+ theme_manager = new ThemeManager();
+
editor = 0;
mixer = 0;
session = 0;
session_selector_window = 0;
last_key_press_time = 0;
connection_editor = 0;
+ _will_create_new_session_automatically = false;
+ new_session_dialog = 0;
+ loading_dialog = 0;
add_route_dialog = 0;
route_params = 0;
option_editor = 0;
location_ui = 0;
open_session_selector = 0;
have_configure_timeout = false;
- have_disk_overrun_displayed = false;
- have_disk_underrun_displayed = false;
- _will_create_new_session_automatically = false;
+ have_disk_speed_dialog_displayed = false;
session_loaded = false;
last_speed_displayed = -1.0f;
- keybindings_path = ARDOUR::find_config_file ("ardour.bindings");
+ ab_direction = true;
+
+ sys::path key_bindings_file;
+
+ find_file_in_search_path (ardour_search_path() + system_config_search_path(),
+ "ardour.bindings", key_bindings_file);
+
+ keybindings_path = key_bindings_file.to_string();
+
+ /* store all bindings changes in per-user file, no matter where they were loaded from */
+ user_keybindings_path = user_config_directory().to_string ();
+ user_keybindings_path += '/';
+ user_keybindings_path += "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;
ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
- /* have to wait for AudioEngine and Configuration before proceeding */
+ /* lets get this party started */
+
+ try {
+ ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization);
+ setup_gtk_ardour_enums ();
+ Config->set_current_owner (ConfigVariableBase::Interface);
+ setup_profile ();
+
+ } catch (failed_constructor& err) {
+ error << _("could not initialize Ardour.") << endmsg;
+ // pass it on up
+ throw err;
+ }
+
+ /* we like keyboards */
+
+ keyboard = new Keyboard;
+
+ starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
+ stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+
+ platform_specific ();
}
-void
-ARDOUR_UI::set_engine (AudioEngine& e)
+int
+ARDOUR_UI::create_engine ()
{
- engine = &e;
+ // this gets called every time by new_session()
+
+ if (engine) {
+ return 0;
+ }
+
+ try {
+ engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
+
+ } 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));
- ActionManager::init ();
- new_session_dialog = new NewSessionDialog();
+ post_engine ();
- _tooltips.enable();
+ return 0;
+}
- keyboard = new Keyboard;
+void
+ARDOUR_UI::post_engine ()
+{
+ extern int setup_midi ();
+
+ /* Things to be done once we create the AudioEngine
+ */
+
+ MIDI::Manager::instance()->set_api_data (engine->jack());
+ setup_midi ();
+
+ ActionManager::init ();
+ _tooltips.enable();
if (setup_windows ()) {
throw failed_constructor ();
}
+
+ check_memory_locking();
- if (GTK_ARDOUR::show_key_actions) {
+ /* this is the first point at which all the keybindings are available */
+
+ if (ARDOUR_COMMAND_LINE::show_key_actions) {
vector<string> names;
vector<string> paths;
vector<string> keys;
exit (0);
}
- /* start with timecode, metering enabled
- */
-
blink_timeout_tag = -1;
/* the global configuration object is now valid */
AudioFileSource::set_build_peakfiles (true);
AudioFileSource::set_build_missing_peakfiles (true);
- if (AudioSource::start_peak_thread ()) {
- throw failed_constructor();
- }
-
/* set default clock modes */
primary_clock.set_mode (AudioClock::SMPTE);
/* start the time-of-day-clock */
+#ifndef GTKOSX
+ /* OS X provides an always visible wallclock, so don't be stupid */
update_wall_clock ();
Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
+#endif
update_disk_space ();
update_cpu_load ();
update_sample_rate (engine->frame_rate());
- starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
- stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
+ /* 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
+ */
+ session->save_state ("");
+ }
+ }
}
ARDOUR_UI::~ARDOUR_UI ()
delete add_route_dialog;
}
- AudioSource::stop_peak_thread ();
+
+ if (new_session_dialog) {
+ delete new_session_dialog;
+ }
}
gint
if ((prop = node.property ("stop")) != 0) {
stop_controllable.set_id (prop->value());
}
- if ((prop = node.property ("goto start")) != 0) {
+ if ((prop = node.property ("goto_start")) != 0) {
goto_start_controllable.set_id (prop->value());
}
- if ((prop = node.property ("goto end")) != 0) {
+ if ((prop = node.property ("goto_end")) != 0) {
goto_end_controllable.set_id (prop->value());
}
- if ((prop = node.property ("auto loop")) != 0) {
+ if ((prop = node.property ("auto_loop")) != 0) {
auto_loop_controllable.set_id (prop->value());
}
- if ((prop = node.property ("play selection")) != 0) {
+ if ((prop = node.property ("play_selection")) != 0) {
play_selection_controllable.set_id (prop->value());
}
if ((prop = node.property ("rec")) != 0) {
stop_controllable.id().print (buf, sizeof (buf));
node->add_property (X_("stop"), buf);
goto_start_controllable.id().print (buf, sizeof (buf));
- node->add_property (X_("goto start"), buf);
+ node->add_property (X_("goto_start"), buf);
goto_end_controllable.id().print (buf, sizeof (buf));
- node->add_property (X_("goto end"), buf);
+ node->add_property (X_("goto_end"), buf);
auto_loop_controllable.id().print (buf, sizeof (buf));
- node->add_property (X_("auto loop"), buf);
+ node->add_property (X_("auto_loop"), buf);
play_selection_controllable.id().print (buf, sizeof (buf));
- node->add_property (X_("play selection"), buf);
+ 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));
XMLNode mnode(mixer->get_state());
if (session) {
- session->add_instant_xml (enode, session->path());
- session->add_instant_xml (mnode, session->path());
+ session->add_instant_xml (enode);
+ session->add_instant_xml (mnode);
} else {
- Config->add_instant_xml (enode, get_user_ardour_path());
- Config->add_instant_xml (mnode, get_user_ardour_path());
+ Config->add_instant_xml (enode);
+ Config->add_instant_xml (mnode);
}
save_keybindings ();
}
+gint
+ARDOUR_UI::autosave_session ()
+{
+ if (!Config->get_periodic_safety_backups())
+ return 1;
+
+ if (session) {
+ session->maybe_write_autosave();
+ }
+
+ return 1;
+}
+
+void
+ARDOUR_UI::update_autosave ()
+{
+ ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
+
+ if (session->dirty()) {
+ if (_autosave_connection.connected()) {
+ _autosave_connection.disconnect();
+ }
+
+ _autosave_connection = Glib::signal_timeout().connect (mem_fun (*this, &ARDOUR_UI::autosave_session),
+ Config->get_periodic_safety_backup_interval() * 1000);
+
+ } else {
+ if (_autosave_connection.connected()) {
+ _autosave_connection.disconnect();
+ }
+ }
+}
+
+void
+ARDOUR_UI::backend_audio_error (bool we_set_params, Gtk::Window* toplevel)
+{
+ string title;
+ if (we_set_params) {
+ title = _("Ardour could not start JACK");
+ } else {
+ title = _("Ardour could not connect to JACK.");
+ }
+
+ 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\
+1) You requested audio parameters that are not supported..\n\
+2) JACK is running as another user.\n\
+\n\
+Please consider the possibilities, and perhaps try different parameters."));
+ } else {
+ win.set_secondary_text(_("There are several possible reasons:\n\
+\n\
+1) JACK is not running.\n\
+2) JACK is running as another user, perhaps root.\n\
+3) There is already another client called \"ardour\".\n\
+\n\
+Please consider the possibilities, and perhaps (re)start JACK."));
+ }
+
+ if (toplevel) {
+ win.set_transient_for (*toplevel);
+ }
+
+ if (we_set_params) {
+ 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);
+
+ if (!ARDOUR_COMMAND_LINE::no_splash) {
+ hide_splash ();
+ }
+
+ /* we just don't care about the result, but we want to block */
+
+ win.run ();
+}
+
void
ARDOUR_UI::startup ()
{
- if (engine->is_realtime()) {
+ string name, path;
+ bool isnew;
- struct rlimit limits;
+ new_session_dialog = new NewSessionDialog();
+
+ /* If no session name is given: we're not loading a session yet, nor creating a new one */
+
+ if (ARDOUR_COMMAND_LINE::session_name.length()) {
+
+ /* Load session or start the new session dialog */
+
+ if (find_session (ARDOUR_COMMAND_LINE::session_name, path, name, isnew)) {
+ error << string_compose(_("could not load command line session \"%1\""),
+ ARDOUR_COMMAND_LINE::session_name) << endmsg;
+ return;
+ }
+
+ if (!ARDOUR_COMMAND_LINE::new_session) {
+
+ /* Supposed to be loading an existing session, but the session doesn't exist */
+
+ if (isnew) {
+ error << string_compose (_("\n\nNo session named \"%1\" exists.\n"
+ "To create it from the command line, start ardour as \"ardour --new %1"), path)
+ << endmsg;
+ return;
+ }
+ }
+
+ new_session_dialog->set_session_name (name);
+ new_session_dialog->set_session_folder (Glib::path_get_basename (path));
+ _session_is_new = isnew;
+ }
+
+ hide_splash ();
+
+ bool have_backend = EngineControl::engine_running();
+ bool need_nsd;
+ bool load_needed = false;
+
+ if (have_backend) {
+
+ /* backend audio is working */
+
+ if (ARDOUR_COMMAND_LINE::session_name.empty() || ARDOUR_COMMAND_LINE::new_session) {
+ /* need NSD to get session name and other info */
+ need_nsd = true;
+ } else {
+ need_nsd = false;
+ }
+ } else {
+
+ XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
+
+ if (audio_setup) {
+ new_session_dialog->engine_control.set_state (*audio_setup);
+ }
+
+ /* no backend audio, must bring up NSD to check configuration */
+
+ need_nsd = true;
+ }
+
+ if (need_nsd) {
+
+ if (!get_session_parameters (ARDOUR_COMMAND_LINE::session_name, have_backend, ARDOUR_COMMAND_LINE::new_session)) {
+ return;
+ }
+
+ } else {
+
+ if (create_engine ()) {
+ backend_audio_error (false);
+ exit (1);
+ }
+
+ load_needed = true;
+ }
+
+ if (load_needed) {
+ if (load_session (ARDOUR_COMMAND_LINE::session_name, name)) {
+ return;
+ }
+ }
+
+ show ();
+}
+
+void
+ARDOUR_UI::no_memory_warning ()
+{
+ XMLNode node (X_("no-memory-warning"));
+ Config->add_instant_xml (node);
+}
+
+void
+ARDOUR_UI::check_memory_locking ()
+{
+#ifdef __APPLE__
+ /* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
+ return;
+#else // !__APPLE__
+
+ XMLNode* memory_warning_node = Config->instant_xml (X_("no-memory-warning"));
+
+ if (engine->is_realtime() && memory_warning_node == 0) {
+
+ struct rlimit limits;
+ int64_t ram;
+ long pages, page_size;
+
+ if ((page_size = sysconf (_SC_PAGESIZE)) < 0 ||(pages = sysconf (_SC_PHYS_PAGES)) < 0) {
+ ram = 0;
+ } else {
+ ram = (int64_t) pages * (int64_t) page_size;
+ }
+
if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
return;
}
if (limits.rlim_cur != RLIM_INFINITY) {
- 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"));
+
+ if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
- editor->ensure_float (msg);
- msg.run ();
+
+ 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"));
+
+ 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));
+
+ hbox.pack_start (cb, true, false);
+ vbox->pack_start (hbox);
+ cb.show();
+ vbox->show();
+ hbox.show ();
+
+ editor->ensure_float (msg);
+ msg.run ();
+ }
}
}
+#endif // !__APPLE__
}
+
void
ARDOUR_UI::finish()
{
}
engine->stop (true);
Config->save_state();
+ ARDOUR_UI::config()->save_state();
quit ();
}
window.set_position (Gtk::WIN_POS_MOUSE);
window.set_modal (true);
window.set_resizable (false);
- window.show_all ();
+
+ dhbox.show();
+ prompt_label.show();
+ dimage->show();
+ window.show();
save_the_session = 0;
return TRUE;
}
-gint
-ARDOUR_UI::every_point_oh_five_seconds ()
-{
- MidRapidScreenUpdate(); /* EMIT_SIGNAL */
- return true;
-}
-
gint
ARDOUR_UI::every_point_zero_one_seconds ()
{
+ // august 2007: actual update frequency: 40Hz, not 100Hz
+
SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
return TRUE;
}
nframes_t rate = engine->frame_rate();
if (fmod (rate, 1000.0) != 0.0) {
- snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f msecs"),
+ snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"),
(float) rate/1000.0f,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
} else {
- snprintf (buf, sizeof (buf), _("%u kHz / %4.1f msecs"),
+ snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"),
rate/1000,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
}
ARDOUR_UI::update_cpu_load ()
{
char buf[32];
- snprintf (buf, sizeof (buf), _("DSP: %.1f%%"), engine->get_cpu_load());
+ snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load());
cpu_load_label.set_text (buf);
}
{
Track* track = dynamic_cast<Track*>(&route);
if (track && track->diskstream()->record_enabled()) {
- rec_enabled_streams += track->n_inputs();
+ rec_enabled_streams += track->n_inputs().n_total();
}
}
return TRUE;
}
-void
-ARDOUR_UI::control_methods_adjusted ()
-
-{
- int which_method;
-
- which_method = (int) online_control_button->adjustment.get_value();
- switch (which_method) {
- case 0:
- allow_mmc_and_local ();
- break;
- case 1:
- allow_mmc_only ();
- break;
- case 2:
- allow_local_only ();
- break;
- default:
- fatal << _("programming error: impossible control method") << endmsg;
- }
-}
-
-
-void
-ARDOUR_UI::mmc_device_id_adjusted ()
-
-{
-#if 0
- if (mmc) {
- int dev_id = (int) mmc_id_button->adjustment.get_value();
- mmc->set_device_id (dev_id);
- }
-#endif
-}
gint
ARDOUR_UI::session_menu (GdkEventButton *ev)
void
ARDOUR_UI::redisplay_recent_sessions ()
{
- vector<string *> *sessions;
- vector<string *>::iterator i;
+ std::vector<sys::path> session_directories;
RecentSessionsSorter cmp;
recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
recent_session_model->clear ();
- RecentSessions rs;
+ ARDOUR::RecentSessions rs;
ARDOUR::read_recent_sessions (rs);
if (rs.empty()) {
recent_session_display.set_model (recent_session_model);
return;
}
-
- /* sort them alphabetically */
+ //
+ // sort them alphabetically
sort (rs.begin(), rs.end(), cmp);
- sessions = new vector<string*>;
-
- for (RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
- sessions->push_back (new string ((*i).second));
+
+ for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
+ 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
- for (i = sessions->begin(); i != sessions->end(); ++i) {
-
- vector<string*>* states;
- vector<const gchar*> item;
- string fullpath = *(*i);
-
- /* remove any trailing / */
-
- if (fullpath[fullpath.length()-1] == '/') {
- fullpath = fullpath.substr (0, fullpath.length()-1);
- }
-
- /* now get available states for this session */
+ get_state_files_in_directory (*i, state_file_paths);
- if ((states = Session::possible_states (fullpath)) == 0) {
- /* no state file? */
+ if (state_file_paths.empty()) {
+ // no state file?
continue;
}
+
+ std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
- TreeModel::Row row = *(recent_session_model->append());
+ Gtk::TreeModel::Row row = *(recent_session_model->append());
+ const string fullpath = (*i).to_string();
+
row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
+
+ if (state_file_names.size() > 1) {
- if (states->size() > 1) {
+ // add the children
- /* add the children */
-
- for (vector<string*>::iterator i2 = states->begin(); i2 != states->end(); ++i2) {
-
- TreeModel::Row child_row = *(recent_session_model->append (row.children()));
+ for (std::vector<std::string>::iterator i2 = state_file_names.begin();
+ i2 != state_file_names.end(); ++i2)
+ {
- child_row[recent_session_columns.visible_name] = **i2;
- child_row[recent_session_columns.fullpath] = fullpath;
+ Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
- delete *i2;
+ child_row[recent_session_columns.visible_name] = *i2;
+ child_row[recent_session_columns.fullpath] = fullpath;
}
}
-
- delete states;
}
recent_session_display.set_model (recent_session_model);
- delete sessions;
}
void
session_selector_window->set_name ("SessionSelectorWindow");
session_selector_window->set_size_request (200, 400);
session_selector_window->get_vbox()->pack_start (*scroller);
- session_selector_window->show_all_children();
+
+ recent_session_display.show();
+ scroller->show();
+ //session_selector_window->get_vbox()->show();
}
void
return S_ISREG (statbuf.st_mode);
}
+bool
+ARDOUR_UI::check_audioengine ()
+{
+ if (engine) {
+ if (!engine->connected()) {
+ MessageDialog msg (_("Ardour is not connected to JACK\n"
+ "You cannot open or close sessions in this condition"));
+ msg.run ();
+ return false;
+ }
+ return true;
+ } else {
+ return false;
+ }
+}
+
void
ARDOUR_UI::open_session ()
{
+ if (!check_audioengine()) {
+ return;
+
+ }
+
/* popup selector window */
if (open_session_selector == 0) {
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");
bool isnew;
if (session_path.length() > 0) {
- if (Session::find_session (session_path, path, name, isnew) == 0) {
+ if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
_session_is_new = isnew;
load_session (path, name);
}
void
-ARDOUR_UI::session_add_midi_track ()
+ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)
{
- cerr << _("Patience is a virtue.\n");
+ list<boost::shared_ptr<MidiTrack> > tracks;
+
+ if (session == 0) {
+ warning << _("You cannot add a track without a session already loaded.") << endmsg;
+ return;
+ }
+
+ try {
+ if (disk) {
+
+ tracks = session->new_midi_track (ARDOUR::Normal, how_many);
+
+ if (tracks.size() != how_many) {
+ if (how_many == 1) {
+ error << _("could not create a new midi track") << endmsg;
+ } else {
+ error << string_compose (_("could not create %1 new midi tracks"), how_many) << endmsg;
+ }
+ }
+ } /*else {
+ 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\
+to create a new track or bus.\n\
+You should save Ardour, exit and\n\
+restart JACK with more ports."));
+ 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)
{
if (how_many == 1) {
error << _("could not create a new audio track") << endmsg;
} else {
- error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
+ error << string_compose (_("could only create %1 of %2 new audio %3"),
+ tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
}
}
}
catch (...) {
+ cerr << "About to complain about JACK\n";
MessageDialog msg (*editor,
_("There are insufficient JACK ports available\n\
to create a new track or bus.\n\
void
ARDOUR_UI::transport_record ()
{
- cerr << "transport record\n";
-
if (session) {
switch (session->record_status()) {
case Session::Disabled:
break;
case Session::Recording:
case Session::Enabled:
- session->disable_record (true);
+ session->disable_record (false, true);
}
}
}
}
}
-void
-ARDOUR_UI::allow_local_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_only ()
-{
-
-}
-
-void
-ARDOUR_UI::allow_mmc_and_local ()
-{
-
-}
-
void
ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
{
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
Glib::RefPtr<Action> action;
- char* action_name = 0;
+ const char* action_name = 0;
switch (engine->frames_per_cycle()) {
case 32:
return 0;
}
-gint
-ARDOUR_UI::start_engine ()
+void
+ARDOUR_UI::setup_theme ()
{
- if (do_engine_start () == 0) {
- if (session && _session_is_new) {
- /* we need to retain initial visual
- settings for a new session
- */
- session->save_state ("");
- }
- }
-
- return FALSE;
+ theme_manager->setup_theme();
}
void
ARDOUR_UI::update_clocks ()
{
if (!editor || !editor->dragging_playhead()) {
- Clock (session->audible_frame()); /* EMIT_SIGNAL */
+ Clock (session->audible_frame(), false, editor->edit_cursor_position(false)); /* EMIT_SIGNAL */
}
}
bool in)
{
if (in) {
- if (io.n_inputs() == 0) {
+ if (io.n_inputs().n_total() == 0) {
buf = _("none");
return;
}
} else {
- if (io.n_outputs() == 0) {
+ if (io.n_outputs().n_total() == 0) {
buf = _("none");
return;
}
}
}
+/** Ask the user for the name of a new shapshot and then take it.
+ */
void
ARDOUR_UI::snapshot_session ()
{
switch (session->record_status()) {
case Session::Enabled:
if (onoff) {
- rec_button.set_visual_state (1);
+ rec_button.set_visual_state (2);
} else {
rec_button.set_visual_state (0);
}
break;
case Session::Recording:
- rec_button.set_visual_state (2);
+ rec_button.set_visual_state (1);
break;
default:
ArdourPrompter prompter (true);
string name;
+ if (!check_audioengine()) {
+ return;
+ }
+
prompter.set_name (X_("Prompter"));
prompter.set_prompt (_("Name for mix template:"));
prompter.set_initial_text(session->name() + _("-template"));
}
}
-void
-ARDOUR_UI::new_session (std::string predetermined_path)
+bool
+ARDOUR_UI::get_session_parameters (Glib::ustring predetermined_path, bool have_engine, bool should_be_new)
{
string session_name;
string session_path;
+ string template_name;
+ if (!loading_dialog) {
+ loading_dialog = new MessageDialog (*new_session_dialog,
+ "",
+ false,
+ Gtk::MESSAGE_INFO,
+ Gtk::BUTTONS_NONE);
+ }
+
int response = Gtk::RESPONSE_NONE;
new_session_dialog->set_modal(true);
new_session_dialog->set_name (predetermined_path);
new_session_dialog->reset_recent();
- new_session_dialog->show();
+ new_session_dialog->set_position (WIN_POS_CENTER);
+ new_session_dialog->set_current_page (0);
do {
+ new_session_dialog->set_have_engine (have_engine);
+
+ new_session_dialog->show();
+ new_session_dialog->present ();
response = new_session_dialog->run ();
-
+
_session_is_new = false;
if (response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
quit();
}
new_session_dialog->hide ();
- return;
+ return false;
} else if (response == Gtk::RESPONSE_NONE) {
/* Clear was pressed */
new_session_dialog->reset();
+ continue;
+ }
+
+ /* first things first ... if we're here to help set up audio parameters
+ this is where want to do that.
+ */
- } else if (response == Gtk::RESPONSE_YES) {
+ if (!have_engine) {
+ if (new_session_dialog->engine_control.setup_engine ()) {
+ new_session_dialog->hide ();
+ return false;
+ }
+ }
+
+#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.
+ */
- /* YES == OPEN, but there's no enum for that */
+ 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);
+ msg.show_all ();
+ msg.present ();
+ msg.run ();
+ }
+#endif
+ loading_dialog->set_message (_("Starting audio engine"));
+ loading_dialog->show_all ();
+ flush_pending ();
+
+ if (create_engine ()) {
+ backend_audio_error (!have_engine, new_session_dialog);
+ loading_dialog->hide ();
+ flush_pending ();
+ /* audio setup page */
+ new_session_dialog->set_current_page (2);
+ /* try again */
+ response = Gtk::RESPONSE_NONE;
+ continue;
+ }
+
+ have_engine = true;
+
+ /* now handle possible affirmative responses */
+
+ if (response == Gtk::RESPONSE_YES) {
+
+ /* YES == OPEN from the session selector */
session_name = new_session_dialog->session_name();
} else if (response == Gtk::RESPONSE_OK) {
+ /* OK == OPEN button */
+
session_name = new_session_dialog->session_name();
-
- if (new_session_dialog->get_current_page() == 1) {
-
- /* XXX this is a bit of a hack..
- i really want the new sesion dialog to return RESPONSE_YES
- if we're on page 1 (the load page)
- Unfortunately i can't see how atm..
- */
-
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+
+ if (session_name.empty()) {
+ response = Gtk::RESPONSE_NONE;
+ continue;
+ }
+ switch (new_session_dialog->get_current_page()) {
+ case 1: /* recent session selector */
+ case 2: /* audio engine control */
+
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] == '/')) {
session_path = new_session_dialog->session_folder();
load_session (session_path, session_name);
}
-
- } else {
+ break;
- if (session_name.empty()) {
- response = Gtk::RESPONSE_NONE;
- continue;
- }
+ case 0: /* nominally the "new" session creator, but could be in use for an old session */
+
+ if (new_session_dialog->get_current_page() == 0 && ARDOUR_COMMAND_LINE::session_name.empty()) {
+ should_be_new = true;
+ }
+
+ /* handle what appear to be paths rather than just a name */
if (session_name[0] == '/' ||
(session_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
//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))) {
+
+ if (!should_be_new) {
+
+ load_session (session_path, session_name);
+ continue; /* leaves while() loop because response != NONE */
+
+ } else if (Glib::file_test (session_path, Glib::FileTest (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);
switch (msg.run()) {
case RESPONSE_YES:
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
load_session (session_path, session_name);
goto done;
break;
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()) {
-
+
+ template_name = new_session_dialog->session_template_name();
+
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
+
load_session (session_path, session_name, &template_name);
} else {
-
+
uint32_t cchns;
uint32_t mchns;
AutoConnectOption iconnect;
AutoConnectOption oconnect;
-
- if (new_session_dialog->create_control_bus()) {
- cchns = (uint32_t) new_session_dialog->control_channel_count();
- } else {
+ uint32_t nphysin;
+ uint32_t nphysout;
+
+ if (Profile->get_sae()) {
+
cchns = 0;
- }
-
- if (new_session_dialog->create_master_bus()) {
- mchns = (uint32_t) new_session_dialog->master_channel_count();
- } else {
- mchns = 0;
- }
-
- if (new_session_dialog->connect_inputs()) {
+ mchns = 2;
iconnect = AutoConnectPhysical;
- } else {
- iconnect = AutoConnectOption (0);
- }
-
- /// @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;
+ nphysin = 0; // use all available
+ nphysout = 0; // use all available
+
} else {
- oconnect = AutoConnectOption (0);
- }
-
- uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
- uint32_t nphysout = (uint32_t) new_session_dialog->output_limit_count();
-
- build_session (session_path,
- session_name,
- cchns,
- mchns,
- iconnect,
- oconnect,
- nphysin,
- nphysout,
- engine->frame_rate() * 60 * 5);
+
+ /* get settings from advanced section of NSD */
+
+ if (new_session_dialog->create_control_bus()) {
+ cchns = (uint32_t) new_session_dialog->control_channel_count();
+ } else {
+ cchns = 0;
+ }
+
+ if (new_session_dialog->create_master_bus()) {
+ mchns = (uint32_t) new_session_dialog->master_channel_count();
+ } else {
+ mchns = 0;
+ }
+
+ if (new_session_dialog->connect_inputs()) {
+ iconnect = AutoConnectPhysical;
+ } else {
+ iconnect = AutoConnectOption (0);
+ }
+
+ /// @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();
+ }
+
+ new_session_dialog->hide ();
+ goto_editor_window ();
+ flush_pending ();
+
+ if (build_session (session_path,
+ session_name,
+ cchns,
+ mchns,
+ iconnect,
+ oconnect,
+ nphysin,
+ nphysout,
+ engine->frame_rate() * 60 * 5)) {
+
+ response = Gtk::RESPONSE_NONE;
+ new_session_dialog->reset ();
+ continue;
+ }
}
+ break;
+
+ default:
+ break;
}
}
done:
show();
- new_session_dialog->get_window()->set_cursor();
+ loading_dialog->hide ();
new_session_dialog->hide();
+ return true;
}
void
ARDOUR_UI::close_session()
{
- unload_session();
- new_session ();
+ if (!check_audioengine()) {
+ return;
+ }
+
+ unload_session (true);
+
+ get_session_parameters ("", true, false);
}
int
ARDOUR_UI::load_session (const string & path, const string & snap_name, string* mix_template)
{
Session *new_session;
- int x;
+ int unload_status;
+ int retval = -1;
+
session_loaded = false;
-
- x = unload_session ();
- if (x < 0) {
+ if (!check_audioengine()) {
return -1;
- } else if (x > 0) {
- return 0;
+ }
+
+ unload_status = unload_session ();
+
+ if (unload_status < 0) {
+ goto out;
+ } else if (unload_status > 0) {
+ retval = 0;
+ goto out;
}
/* if it already exists, we must have write access */
MessageDialog msg (*editor, _("You do not have write access to this session.\n"
"This prevents the session from being loaded."));
msg.run ();
- return -1;
+ goto out;
}
+ if (loading_dialog) {
+ loading_dialog->set_markup (_("Please wait while Ardour loads your session"));
+ flush_pending ();
+ }
+
+ disable_screen_updates ();
+
try {
new_session = new Session (*engine, path, snap_name, mix_template);
}
catch (...) {
-
error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
- return -1;
+ goto out;
}
connect_to_session (new_session);
session->set_clean ();
}
- return 0;
+ editor->edit_cursor_position (true);
+ enable_screen_updates ();
+ flush_pending ();
+ retval = 0;
+
+ out:
+ return retval;
}
int
Session *new_session;
int x;
+ if (!check_audioengine()) {
+ return -1;
+ }
+
session_loaded = false;
+
x = unload_session ();
+
if (x < 0) {
return -1;
} else if (x > 0) {
catch (...) {
- error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
+ MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
+ msg.run ();
return -1;
}
dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
+ const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
+
if (rep.space < 1048576.0f) {
if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
+ 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"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
+ txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
}
} else {
if (removed > 1) {
- txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
+ 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"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
+ txt.set_text (string_compose (msg, removed, _("file was"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
}
}
results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
results.set_default_response (RESPONSE_CLOSE);
results.set_position (Gtk::WIN_POS_MOUSE);
- results.show_all_children ();
+
+ results_display.show();
+ list_scroller.show();
+ txt.show();
+ dvbox.show();
+ dhbox.show();
+ ddhbox.show();
+ dimage->show();
+
+ //results.get_vbox()->show();
results.set_resizable (false);
results.run ();
editor->prepare_for_cleanup ();
+ /* do not allow flush until a session is reloaded */
+
+ Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
+ if (act) {
+ act->set_sensitive (false);
+ }
+
if (session->cleanup_sources (rep)) {
return;
}
+
checker.hide();
display_cleanup_results (rep,
_("cleaned files"),
release an additional\n\
%4 %5bytes of disk space.\n"
));
+
+
+
}
void
}
void
-ARDOUR_UI::add_route ()
+ARDOUR_UI::add_route (Gtk::Window* float_window)
{
int count;
if (add_route_dialog == 0) {
add_route_dialog = new AddRouteDialog;
- editor->ensure_float (*add_route_dialog);
+ if (float_window) {
+ add_route_dialog->set_transient_for (*float_window);
+ }
}
if (add_route_dialog->is_visible()) {
}
ResponseType r = (ResponseType) add_route_dialog->run ();
-
+
add_route_dialog->hide();
switch (r) {
- case RESPONSE_ACCEPT:
- break;
- default:
- return;
- break;
+ case RESPONSE_ACCEPT:
+ break;
+ default:
+ return;
+ break;
}
if ((count = add_route_dialog->count()) <= 0) {
AutoConnectOption oac = Config->get_output_auto_connect();
if (oac & AutoConnectMaster) {
- output_chan = (session->master_out() ? session->master_out()->n_inputs() : 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 (track) {
- session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
- } else {
- session_add_audio_bus (input_chan, output_chan, count);
+ if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
+ if (track) {
+ session_add_midi_track(count);
+ } else {
+ MessageDialog msg (*editor,
+ _("Sorry, MIDI Busses are not supported at this time."));
+ msg.run ();
+ //session_add_midi_bus();
+ }
+ } else {
+ if (track) {
+ session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
+ } else {
+ session_add_audio_bus (input_chan, output_chan, count);
+ }
}
}
XMLNode* node = 0;
if (session) {
- node = session->instant_xml(X_("Mixer"), session->path());
+ node = session->instant_xml(X_("Mixer"));
} else {
- node = Config->instant_xml(X_("Mixer"), get_user_ardour_path());
+ node = Config->instant_xml(X_("Mixer"));
}
if (!node) {
XMLNode* node = 0;
if (session) {
- node = session->instant_xml(X_("Editor"), session->path());
+ node = session->instant_xml(X_("Editor"));
} else {
- node = Config->instant_xml(X_("Editor"), get_user_ardour_path());
+ node = Config->instant_xml(X_("Editor"));
}
if (!node) {
void
ARDOUR_UI::disk_overrun_handler ()
{
- ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
- if (!have_disk_overrun_displayed) {
- have_disk_overrun_displayed = true;
- MessageDialog msg (*editor, X_("diskrate dialog"), _("\
+ 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\
\n\
Specifically, it failed to write data to disk\n\
quickly enough to keep up with recording.\n"));
- msg.run ();
- have_disk_overrun_displayed = false;
+ msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+ msg->show ();
}
}
{
ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
- if (!have_disk_underrun_displayed) {
- have_disk_underrun_displayed = true;
- MessageDialog msg (*editor,
- (_("The disk system on your computer\n\
+ 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\
\n\
Specifically, it failed to read data from disk\n\
-quickly enough to keep up with playback.\n")));
- msg.run ();
- have_disk_underrun_displayed = false;
+quickly enough to keep up with playback.\n"));
+ msg->signal_response().connect (bind (mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
+ msg->show ();
}
}
void
-ARDOUR_UI::disk_underrun_message_gone ()
+ARDOUR_UI::disk_speed_dialog_gone (int ignored_response, MessageDialog* msg)
{
- have_disk_underrun_displayed = false;
-}
-
-void
-ARDOUR_UI::disk_overrun_message_gone ()
-{
- have_disk_underrun_displayed = false;
+ have_disk_speed_dialog_displayed = false;
+ delete msg;
}
int
dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
dialog.set_position (WIN_POS_CENTER);
- dialog.show_all ();
+ message.show();
+ //dialog.get_vbox()->show();
switch (dialog.run ()) {
case RESPONSE_ACCEPT:
path = str;
}
- new_session (path);
+ get_session_parameters (path, false, true);
_will_create_new_session_automatically = false; /* done it */
+
return FALSE; /* don't call it again */
}
case FormatInt24:
act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
break;
+ case FormatInt16:
+ act = ActionManager::get_action (X_("options"), X_("FileDataFormat16bit"));
+ break;
}
if (act) {
void
ARDOUR_UI::update_transport_clocks (nframes_t pos)
{
- primary_clock.set (pos);
- secondary_clock.set (pos);
+ if (Config->get_primary_clock_delta_edit_cursor()) {
+ primary_clock.set (pos, false, editor->edit_cursor_position(false), 'p');
+ } else {
+ primary_clock.set (pos, 0, true);
+ }
+
+ if (Config->get_secondary_clock_delta_edit_cursor()) {
+ secondary_clock.set (pos, false, editor->edit_cursor_position(false), 's');
+ } else {
+ secondary_clock.set (pos);
+ }
if (big_clock_window) {
big_clock.set (pos);
ARDOUR_UI::save_keybindings ()
{
if (can_save_keybindings) {
- AccelMap::save (keybindings_path);
+ AccelMap::save (user_keybindings_path);
}
}
bool
ARDOUR_UI::first_idle ()
{
+ if (session) {
+ session->allow_auto_play (true);
+ }
can_save_keybindings = true;
return false;
}
ARDOUR_UI::TransportControllable::set_value (float val)
{
if (type == ShuttleControl) {
-
double fract;
- if (val == 63.0f) {
+ if (val == 0.5f) {
fract = 0.0;
} else {
- if (val < 63.0f) {
- fract = -((63.0f - val)/63.0f);
+ if (val < 0.5f) {
+ fract = -((0.5f - val)/0.5f);
} else {
- fract = ((val - 63.0f)/63.0f);
+ fract = ((val - 0.5f)/0.5f);
}
}
ui.set_shuttle_fract (fract);
return;
}
-
+
if (val < 0.5f) {
/* do nothing: these are radio-style actions */
return;
}
- char *action = 0;
+ const char *action = 0;
switch (type) {
case Roll:
return;
}
- Glib::RefPtr<Action> act = ActionManager::get_action ("transport", action);
+ Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", action);
if (act) {
act->activate ();
{
_id = str;
}
+
+void
+ARDOUR_UI::setup_profile ()
+{
+ if (gdk_screen_width() < 1200) {
+ Profile->set_small_screen ();
+ }
+
+
+ if (getenv ("ARDOUR_SAE")) {
+ Profile->set_sae ();
+ Profile->set_single_package ();
+ }
+}
+
+void
+ARDOUR_UI::disable_all_plugins ()
+{
+ if (!session) {
+ return;
+ }
+
+ // session->begin_reversible_command (_("Disable all plugins"));
+
+ boost::shared_ptr<Session::RouteList> routes = session->get_routes ();
+
+ for (Session::RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
+ // XMLNode& before = (*i)->get_redirect_state ();
+ // session->add_command (new MementoCommand<Route>(**i, &before, 0));
+ (*i)->disable_plugins ();
+ // XMLNode& after = (*i)->get_redirect_state ();
+ // session->add_command (new MementoCommand<Route>(**i, 0, &after));
+
+ }
+
+ // session->commit_reversible_command ();
+}
+
+void
+ARDOUR_UI::ab_all_plugins ()
+{
+ if (!session) {
+ return;
+ }
+
+ boost::shared_ptr<Session::RouteList> routes = session->get_routes ();
+
+ for (Session::RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
+ (*i)->ab_plugins (ab_direction);
+ }
+
+ ab_direction = !ab_direction;
+}
projects / ardour.git / blobdiff