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