/*
- Copyright (C) 1999-2002 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
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 <iostream>
+#include <sys/resource.h>
+
#include <gtkmm/messagedialog.h>
#include <gtkmm/accelmap.h>
#include <pbd/error.h>
#include <pbd/compose.h>
-#include <pbd/pathscanner.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++/port.h>
#include <midi++/mmc.h>
#include <ardour/ardour.h>
+#include <ardour/profile.h>
+#include <ardour/session_directory.h>
#include <ardour/session_route.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 "mixer_ui.h"
#include "prompter.h"
#include "opts.h"
-#include "keyboard_target.h"
#include "add_route_dialog.h"
#include "new_session_dialog.h"
#include "about.h"
#include "utils.h"
#include "gui_thread.h"
-#include "color_manager.h"
+#include "theme_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::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_("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 ("BigClockNonRecording", true, false, true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", false, false, true),
/* transport */
- time_master_button (_("time\nmaster")),
-
+ roll_controllable ("transport roll", *this, TransportControllable::Roll),
+ stop_controllable ("transport stop", *this, TransportControllable::Stop),
+ goto_start_controllable ("transport goto start", *this, TransportControllable::GotoStart),
+ goto_end_controllable ("transport goto end", *this, TransportControllable::GotoEnd),
+ auto_loop_controllable ("transport auto loop", *this, TransportControllable::AutoLoop),
+ play_selection_controllable ("transport play selection", *this, TransportControllable::PlaySelection),
+ rec_controllable ("transport rec-enable", *this, TransportControllable::RecordEnable),
+ shuttle_controllable ("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 (_("Autuo Play")),
+ 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)
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;
route_params = 0;
option_editor = 0;
location_ui = 0;
- sfdb = 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;
+ 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();
+
+ can_save_keybindings = false;
last_configure_time.tv_sec = 0;
last_configure_time.tv_usec = 0;
engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
- ActionManager::init ();
+ ActionManager::init ();
new_session_dialog = new NewSessionDialog();
_tooltips.enable();
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);
+ secondary_clock.set_mode (AudioClock::BBT);
/* start the time-of-day-clock */
if (add_route_dialog) {
delete add_route_dialog;
}
-
- AudioSource::stop_peak_thread ();
}
gint
return FALSE;
}
+void
+ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
+{
+ const XMLProperty* prop;
+
+ if ((prop = node.property ("roll")) != 0) {
+ roll_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("stop")) != 0) {
+ stop_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("goto_start")) != 0) {
+ goto_start_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("goto_end")) != 0) {
+ goto_end_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("auto_loop")) != 0) {
+ auto_loop_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("play_selection")) != 0) {
+ play_selection_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("rec")) != 0) {
+ rec_controllable.set_id (prop->value());
+ }
+ if ((prop = node.property ("shuttle")) != 0) {
+ shuttle_controllable.set_id (prop->value());
+ }
+}
+
+XMLNode&
+ARDOUR_UI::get_transport_controllable_state ()
+{
+ XMLNode* node = new XMLNode(X_("TransportControllables"));
+ char buf[64];
+
+ roll_controllable.id().print (buf, sizeof (buf));
+ node->add_property (X_("roll"), buf);
+ 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);
+ goto_end_controllable.id().print (buf, sizeof (buf));
+ node->add_property (X_("goto_end"), buf);
+ auto_loop_controllable.id().print (buf, sizeof (buf));
+ node->add_property (X_("auto_loop"), buf);
+ play_selection_controllable.id().print (buf, sizeof (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));
+ node->add_property (X_("shuttle"), buf);
+
+ return *node;
+}
+
void
ARDOUR_UI::save_ardour_state ()
{
XMLNode* node = new XMLNode (keyboard->get_state());
Config->add_extra_xml (*node);
+ Config->add_extra_xml (get_transport_controllable_state());
Config->save_state();
XMLNode enode(static_cast<Stateful*>(editor)->get_state());
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);
}
- /* keybindings */
+ 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);
- AccelMap::save ("ardour.saved_bindings");
+ } else {
+ if (_autosave_connection.connected()) {
+ _autosave_connection.disconnect();
+ }
+ }
}
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.
- */
+ check_memory_locking();
+}
- Glib::signal_idle().connect (mem_fun(*this, &ARDOUR_UI::start_engine));
+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) {
+
+ 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"));
+
+ 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);
+ hbox.show_all ();
+
+ editor->ensure_float (msg);
+ msg.run ();
+ }
+ }
+ }
+#endif // !__APPLE__
+}
+
+
void
ARDOUR_UI::finish()
{
break;
}
}
+
+ if (session) {
+ session->set_deletion_in_progress ();
+ }
+ engine->stop (true);
Config->save_state();
+ ARDOUR_UI::config()->save_state();
quit ();
}
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)
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) {
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\
*/
if (editor) {
- editor->reposition_x_origin (session->current_start_frame());
+ editor->reset_x_origin (session->current_start_frame());
}
}
}
*/
if (editor) {
- editor->reposition_x_origin (0);
+ editor->reset_x_origin (0);
}
}
}
*/
if (editor) {
- editor->reposition_x_origin (frame);
+ editor->reset_x_origin (frame);
}
}
}
break;
case Session::Recording:
case Session::Enabled:
- session->disable_record (true);
+ session->disable_record (false, true);
}
}
}
if (session->get_play_loop()) {
session->request_play_loop (false);
- auto_loop_button.set_active (false);
- roll_button.set_active (true);
+ 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_active (false);
+ play_selection_button.set_visual_state (0);
} else if (rolling) {
session->request_locate (session->last_transport_start(), 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)
{
ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
+
+ Glib::RefPtr<Action> action;
+ char* action_name = 0;
+
+ switch (engine->frames_per_cycle()) {
+ case 32:
+ action_name = X_("JACKLatency32");
+ break;
+ case 64:
+ action_name = X_("JACKLatency64");
+ break;
+ case 128:
+ action_name = X_("JACKLatency128");
+ break;
+ case 512:
+ action_name = X_("JACKLatency512");
+ break;
+ case 1024:
+ action_name = X_("JACKLatency1024");
+ break;
+ case 2048:
+ action_name = X_("JACKLatency2048");
+ break;
+ case 4096:
+ action_name = X_("JACKLatency4096");
+ break;
+ case 8192:
+ action_name = X_("JACKLatency8192");
+ break;
+ default:
+ /* XXX can we do anything useful ? */
+ break;
+ }
+
+ 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
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")
return 0;
}
+void
+ARDOUR_UI::setup_theme ()
+{
+ theme_manager->setup_theme();
+}
+
gint
ARDOUR_UI::start_engine ()
{
*/
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;
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 */
}
}
void
ARDOUR_UI::blink ()
{
- Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
+ Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
}
void
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 ()
{
ArdourPrompter prompter (true);
string snapname;
- string now;
+ char timebuf[128];
time_t n;
+ struct tm local_time;
time (&n);
- now = ctime (&n);
- now = now.substr (20, 4) + now.substr (3, 16) + " (" + now.substr (0, 3) + ")";
+ 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_prompt (_("Name of New Snapshot"));
- prompter.set_initial_text (now);
+ prompter.set_initial_text (timebuf);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
switch (session->record_status()) {
case Session::Enabled:
if (onoff) {
- rec_button.set_state (1);
+ rec_button.set_visual_state (2);
} else {
- rec_button.set_state (0);
+ rec_button.set_visual_state (0);
}
break;
case Session::Recording:
- rec_button.set_state (2);
+ rec_button.set_visual_state (1);
break;
default:
- rec_button.set_state (0);
+ rec_button.set_visual_state (0);
break;
}
}
return TRUE;
}
-void
-ARDOUR_UI::start_keyboard_prefix ()
-{
- keyboard->start_prefix();
-}
-
void
ARDOUR_UI::save_template ()
}
}
-void
-ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
+bool
+ARDOUR_UI::new_session (std::string predetermined_path)
{
string session_name;
string session_path;
+ if (!check_audioengine()) {
+ return false;
+ }
+
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_current_page (0);
do {
- response = new_session_dialog->run ();
-
+ response = new_session_dialog->run ();
+
+ if (!check_audioengine()) {
+ new_session_dialog->hide ();
+ return false;
+ }
+
_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();
+ /* Clear was pressed */
+ new_session_dialog->reset();
} else if (response == Gtk::RESPONSE_YES) {
- /* YES == OPEN, but there's no enum for that */
+ /* YES == OPEN, but there's no enum for that */
+
+ session_name = new_session_dialog->session_name();
- session_name = new_session_dialog->session_name();
-
if (session_name.empty()) {
response = Gtk::RESPONSE_NONE;
continue;
}
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_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
load_session (Glib::path_get_dirname (session_name), session_name);
} else {
session_path = new_session_dialog->session_folder();
load_session (session_path, session_name);
}
-
+
} 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 (!new_session_dialog->on_new_session_page ()) {
+
+ /* 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[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_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
load_session (Glib::path_get_dirname (session_name), session_name);
} else {
session_path = new_session_dialog->session_folder();
load_session (session_path, session_name);
}
-
+
} else {
if (session_name.empty()) {
}
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_name.length() > 2 && session_name[0] == '.' && session_name[1] == '/') ||
+ (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == '/')) {
session_path = Glib::path_get_dirname (session_name);
session_name = Glib::path_get_basename (session_name);
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);
+ false,
+ Gtk::MESSAGE_WARNING,
+ Gtk::BUTTONS_YES_NO,
+ true);
msg.set_name (X_("CleanupDialog"));
- msg.set_wmclass (_("existing_session"), "Ardour");
+ 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;
+ 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;
+ _session_is_new = true;
std::string template_name = new_session_dialog->session_template_name();
-
+
if (new_session_dialog->use_session_template()) {
-
+
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 {
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()) {
} 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);
+
+ 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;
+ }
}
}
}
-
+
} while (response == Gtk::RESPONSE_NONE);
done:
show();
new_session_dialog->get_window()->set_cursor();
new_session_dialog->hide();
+ return true;
}
void
ARDOUR_UI::close_session()
{
+ if (!check_audioengine()) {
+ return;
+ }
+
unload_session();
new_session ();
}
ARDOUR_UI::load_session (const string & path, const string & snap_name, string* mix_template)
{
Session *new_session;
- int x;
session_loaded = false;
- x = unload_session ();
-
- if (x < 0) {
+
+ if (!check_audioengine()) {
return -1;
- } else if (x > 0) {
- return 0;
}
+ if(!unload_session ()) return -1;
+
/* 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;
}
Config->set_current_owner (ConfigVariableBase::Interface);
session_loaded = true;
-
+
goto_editor_window ();
- return 0;
-}
-
-int
-ARDOUR_UI::make_session_clean ()
-{
if (session) {
session->set_clean ();
}
- show ();
-
- return FALSE;
+ editor->edit_cursor_position (true);
+ return 0;
}
-int
+bool
ARDOUR_UI::build_session (const string & path, const string & snap_name,
uint32_t control_channels,
uint32_t master_channels,
nframes_t initial_length)
{
Session *new_session;
- int x;
- session_loaded = false;
- x = unload_session ();
- if (x < 0) {
- return -1;
- } else if (x > 0) {
- return 0;
+ if (!check_audioengine()) {
+ return false;
}
+
+ session_loaded = false;
+
+ if (!unload_session ()) return false;
_session_is_new = true;
catch (...) {
- error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
- return -1;
+ MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
+ msg.run ();
+ return false;
}
connect_to_session (new_session);
session_loaded = true;
- return 0;
+ return true;
}
void
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"));
}
}
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()) {
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_all ();
}
}
{
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_all ();
}
}
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
}
}
-void
-ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
-{
- engine->request_buffer_size (nframes);
- update_sample_rate (0);
-}
-
int
ARDOUR_UI::cmdline_new_session (string path)
{
path = str;
}
- new_session (false, path);
-
- _will_create_new_session_automatically = false; /* done it */
+ new_session (path);
+
return FALSE; /* don't call it again */
}
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)
{
- 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);
void
ARDOUR_UI::record_state_changed ()
{
+ ENSURE_GUI_THREAD (mem_fun (*this, &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_name ("BigClockRecording");
+ big_clock.set_widget_name ("BigClockRecording");
break;
default:
- big_clock.set_name ("BigClockNonRecording");
+ 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 ()
+{
+ if (session) {
+ session->allow_auto_play (true);
+ }
+ 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 ();
+}
+
+
+
+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)
+{
+ 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) {
+ /* do nothing: these are radio-style actions */
+ return;
+ }
+
+ char *action = 0;
+
+ switch (type) {
+ case Roll:
+ action = X_("Roll");
+ break;
+ case Stop:
+ action = X_("Stop");
+ break;
+ case GotoStart:
+ action = X_("Goto Start");
+ break;
+ case GotoEnd:
+ action = X_("Goto End");
+ break;
+ case AutoLoop:
+ action = X_("Loop");
+ break;
+ case PlaySelection:
+ action = X_("Play Selection");
+ break;
+ case RecordEnable:
+ action = X_("Record");
+ break;
+ default:
+ break;
+ }
+
+ if (action == 0) {
+ return;
+ }
+
+ Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", action);
+
+ if (act) {
+ act->activate ();
+ }
+}
+
+float
+ARDOUR_UI::TransportControllable::get_value (void) const
+{
+ float val = 0.0f;
+
+ switch (type) {
+ case Roll:
+ break;
+ case Stop:
+ break;
+ case GotoStart:
+ break;
+ case GotoEnd:
+ break;
+ case AutoLoop:
+ break;
+ case PlaySelection:
+ 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 ()
+{
+ if (gdk_screen_width() < 1200) {
+ Profile->set_small_screen ();
+ }
+}
+
+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;
+}