/*
- Copyright (C) 1999-2007 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
#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 "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++/manager.h"
#include "route_time_axis.h"
#include "startup.h"
#include "engine_dialog.h"
+#include "processor_box.h"
#include "i18n.h"
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
- : 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),
- preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, true),
- postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, true),
+ : Gtkmm2ext::UI (X_("gui"), argcp, argvp),
+
+ primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, true, false, true),
+ secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, true, false, true),
+ preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, false, true),
+ postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, false, true),
/* preroll stuff */
/* big clock */
- big_clock (X_("bigclock"), false, "BigClockNonRecording", true, false, true),
+ big_clock (X_("bigclock"), false, "BigClockNonRecording", true, true, false, true),
/* transport */
auto_loop_button (auto_loop_controllable),
play_selection_button (play_selection_controllable),
rec_button (rec_controllable),
-
+
shuttle_units_button (_("% ")),
punch_in_button (_("Punch In")),
using namespace Gtk::Menu_Helpers;
Gtkmm2ext::init();
-
+
#ifdef TOP_MENUBAR
- _auto_display_errors = false;
+ // _auto_display_errors = false;
+ /*
+ * This was commented out as it wasn't defined
+ * in A3 IIRC. If this is not needed it should
+ * be completely removed.
+ */
#endif
about = 0;
ui_config = new UIConfiguration();
theme_manager = new ThemeManager();
-
+
editor = 0;
mixer = 0;
session = 0;
shuttle_unit_menu = 0;
// We do not have jack linked in yet so;
-
+
last_shuttle_request = last_peak_grab = 0; // get_microseconds();
-
+
ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
/* lets get this party started */
- try {
+ try {
if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) {
throw failed_constructor ();
}
GainMeter::setup_slider_pix ();
RouteTimeAxisView::setup_slider_pix ();
+ SendProcessorEntry::setup_slider_pix ();
+ SessionEvent::create_per_thread_pool ("GUI", 512);
} catch (failed_constructor& err) {
error << _("could not initialize Ardour.") << endmsg;
// pass it on up
throw;
- }
+ }
/* we like keyboards */
- keyboard = new Keyboard;
+ keyboard = new ArdourKeyboard;
+
+ XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
+ if (node) {
+ keyboard->set_state (*node, Stateful::loading_state_version);
+ }
reset_dpi();
platform_setup ();
}
-void
+/** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
+bool
ARDOUR_UI::run_startup (bool should_be_new)
{
if (_startup == 0) {
main().run();
- /* we don't return here until the startup assistant is finished */
-
_startup->hide ();
+
+ switch (_startup->response()) {
+ case RESPONSE_OK:
+ return true;
+ default:
+ return false;
+ }
}
int
loading_message (_("Starting audio engine"));
- try {
+ try {
engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name);
} catch (...) {
MIDI::Manager::instance()->set_api_data (engine->jack());
setup_midi ();
+
+ ARDOUR::init_post_engine ();
ActionManager::init ();
_tooltips.enable();
primary_clock.set_mode (AudioClock::BBT);
secondary_clock.set_mode (AudioClock::MinSec);
} else {
- primary_clock.set_mode (AudioClock::SMPTE);
+ primary_clock.set_mode (AudioClock::Timecode);
secondary_clock.set_mode (AudioClock::BBT);
}
/* start the time-of-day-clock */
-
+
#ifndef GTKOSX
/* OS X provides an always visible wallclock, so don't be stupid */
update_wall_clock ();
update_cpu_load ();
update_sample_rate (engine->frame_rate());
+ Config->ParameterChanged.connect (mem_fun (*this, &ARDOUR_UI::parameter_changed));
+ Config->map_parameters (mem_fun (*this, &ARDOUR_UI::parameter_changed));
+
/* 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
+ /* we need to retain initial visual
+ settings for a new session
*/
session->save_state ("");
}
}
gboolean
-ARDOUR_UI::configure_handler (GdkEventConfigure* conf)
+ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
{
if (have_configure_timeout) {
last_configure_time = get_microseconds();
Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
have_configure_timeout = true;
}
-
+
return FALSE;
}
if (!keyboard || !mixer || !editor) {
return;
}
-
+
/* XXX this is all a bit dubious. add_extra_xml() uses
a different lifetime model from add_instant_xml().
*/
{
if (g_main_depth() > 1) {
/* inside a recursive main loop,
- give up because we may not be able to
+ give up because we may not be able to
take a lock.
*/
return 1;
{
ENSURE_GUI_THREAD (mem_fun (*this, &ARDOUR_UI::update_autosave));
- if (session->dirty()) {
+ if (session && session->dirty()) {
if (_autosave_connection.connected()) {
_autosave_connection.disconnect();
}
} else {
if (_autosave_connection.connected()) {
_autosave_connection.disconnect();
- }
+ }
}
}
false,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_NONE);
-
+
if (we_set_params) {
win.set_secondary_text(_("There are several possible reasons:\n\
\n\
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);
pop_back_splash ();
ARDOUR_UI::startup ()
{
XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
-
+
if (audio_setup && _startup && _startup->engine_control()) {
_startup->engine_control()->set_state (*audio_setup);
}
-
- if (get_session_parameters (ARDOUR_COMMAND_LINE::new_session)) {
+
+ if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session)) {
exit (1);
}
use_config ();
goto_editor_window ();
-
+
BootMessage (_("Ardour is ready for use"));
show ();
}
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);
cb.show();
hbox.show ();
pop_back_splash ();
-
+
editor->ensure_float (msg);
msg.run ();
}
if (session->transport_rolling()) {
session->request_stop ();
- usleep (2500000);
+ usleep (250000);
}
if (session->dirty()) {
/* use the default name */
if (save_state_canfail ("")) {
/* failed - don't quit */
- MessageDialog msg (*editor,
+ MessageDialog msg (*editor,
_("\
Ardour was unable to save your session.\n\n\
If you still wish to quit, please use the\n\n\
break;
}
}
+
+ second_connection.disconnect ();
+ point_one_second_connection.disconnect ();
+ point_oh_five_second_connection.disconnect ();
+ point_zero_one_second_connection.disconnect();
- session->set_deletion_in_progress ();
+ // session->set_deletion_in_progress ();
+ session->remove_pending_capture_state ();
+ delete session;
+ session = 0;
}
ArdourDialog::close_all_dialogs ();
} else {
type = _("snapshot");
}
- prompt = string_compose(_("The %1\"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
+ prompt = string_compose(_("The %1 \"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
type, session->snap_name());
-
+
prompt_label.set_text (prompt);
prompt_label.set_name (X_("PrompterLabel"));
prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
return -1;
}
-
+
gint
ARDOUR_UI::every_second ()
{
} else {
nframes_t rate = engine->frame_rate();
-
+
if (fmod (rate, 1000.0) != 0.0) {
- snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"),
+ 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 ms"),
+ snprintf (buf, sizeof (buf), _("%u kHz / %4.1f ms"),
rate/1000,
(engine->frames_per_cycle() / (float) rate) * 1000.0f);
}
if (session) {
c = session->capture_load ();
p = session->playback_load ();
-
+
push_buffer_stats (c, p);
- snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
+ snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
session->playback_load(), session->capture_load());
buffer_load_label.set_text (buf);
} else {
nframes_t frames = session->available_capture_duration();
char buf[64];
nframes_t fr = session->frame_rate();
-
+
if (frames == max_frames) {
strcpy (buf, _("Disk: 24hrs+"));
} else {
rec_enabled_streams = 0;
session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
-
+
if (rec_enabled_streams) {
frames /= rec_enabled_streams;
}
-
+
int hrs;
int mins;
int secs;
-
+
hrs = frames / (fr * 3600);
frames -= hrs * fr * 3600;
mins = frames / (fr * 60);
frames -= mins * fr * 60;
secs = frames / fr;
-
+
snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);
}
-
+
disk_space_label.set_text (buf);
-
+
// An attempt to make the disk space label flash red when space has run out.
-
+
if (frames < fr * 60 * 5) {
/* disk_space_box.style ("disk_space_label_empty"); */
} else {
/* disk_space_box.style ("disk_space_label"); */
}
-}
+}
gint
ARDOUR_UI::update_wall_clock ()
}
gint
-ARDOUR_UI::session_menu (GdkEventButton *ev)
+ARDOUR_UI::session_menu (GdkEventButton */*ev*/)
{
session_popup_menu->popup (0, 0);
return TRUE;
{
std::vector<sys::path> session_directories;
RecentSessionsSorter cmp;
-
+
recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
recent_session_model->clear ();
//
// sort them alphabetically
sort (rs.begin(), rs.end(), cmp);
-
+
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
get_state_files_in_directory (*i, state_file_paths);
vector<string*>* states;
vector<const gchar*> item;
string fullpath = (*i).to_string();
-
+
/* remove any trailing / */
if (fullpath[fullpath.length()-1] == '/') {
/* session doesn't exist */
cerr << "skipping non-existent session " << fullpath << endl;
continue;
- }
-
+ }
+
/* now get available states for this session */
if ((states = Session::possible_states (fullpath)) == 0) {
/* no state file? */
continue;
}
-
+
std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
Gtk::TreeModel::Row row = *(recent_session_model->append());
row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
-
+
if (state_file_names.size() > 1) {
// add the children
void
ARDOUR_UI::build_session_selector ()
{
- session_selector_window = new ArdourDialog ("session selector");
-
+ session_selector_window = new ArdourDialog (_("Recent Sessions"));
+
Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
-
+
session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
session_selector_window->set_default_response (RESPONSE_ACCEPT);
}
void
-ARDOUR_UI::recent_session_row_activated (const TreePath& path, TreeViewColumn* col)
+ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColumn* /*col*/)
{
session_selector_window->response (RESPONSE_ACCEPT);
}
if (session_selector_window == 0) {
build_session_selector ();
}
-
+
redisplay_recent_sessions ();
while (true) {
-
+
session_selector_window->set_position (WIN_POS_MOUSE);
ResponseType r = (ResponseType) session_selector_window->run ();
-
+
switch (r) {
case RESPONSE_ACCEPT:
break;
if (recent_session_display.get_selection()->count_selected_rows() == 0) {
continue;
}
-
+
session_selector_window->hide();
Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
-
+
if (i == recent_session_model->children().end()) {
return;
}
-
+
Glib::ustring path = (*i)[recent_session_columns.fullpath];
Glib::ustring state = (*i)[recent_session_columns.visible_name];
-
+
_session_is_new = false;
-
+
if (load_session (path, state) == 0) {
break;
}
{
if (!check_audioengine()) {
return;
-
+
}
/* popup selector window */
/* ardour sessions are folders */
- open_session_selector = new Gtk::FileChooserDialog (_("open session"), FILE_CHOOSER_ACTION_OPEN);
+ 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);
void
-ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)
+ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many)
{
list<boost::shared_ptr<MidiTrack> > tracks;
return;
}
- try {
+ try {
if (disk) {
- tracks = session->new_midi_track (ARDOUR::Normal, how_many);
+ tracks = session->new_midi_track (ARDOUR::Normal, route_group, how_many);
if (tracks.size() != how_many) {
if (how_many == 1) {
}
catch (...) {
- MessageDialog msg (*editor,
+ 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\
void
-ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, uint32_t how_many)
+ARDOUR_UI::session_add_audio_route (bool track, bool aux, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
{
list<boost::shared_ptr<AudioTrack> > tracks;
RouteList routes;
return;
}
- try {
+ try {
if (track) {
- tracks = session->new_audio_track (input_channels, output_channels, mode, how_many);
+ tracks = session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
if (tracks.size() != how_many) {
if (how_many == 1) {
error << _("could not create a new audio track") << endmsg;
} else {
- error << string_compose (_("could only create %1 of %2 new audio %3"),
+ error << string_compose (_("could only create %1 of %2 new audio %3"),
tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
}
}
} else {
- routes = session->new_audio_route (input_channels, output_channels, how_many);
+ routes = session->new_audio_route (aux, input_channels, output_channels, route_group, how_many);
if (routes.size() != how_many) {
if (how_many == 1) {
}
}
}
-
+
#if CONTROLOUTS
if (need_control_room_outs) {
pan_t pans[2];
-
+
pans[0] = 0.5;
pans[1] = 0.5;
-
+
route->set_stereo_control_outs (control_lr_channels);
route->control_outs()->set_stereo_pan (pans, this);
}
}
catch (...) {
- MessageDialog msg (*editor,
+ 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\
}
void
-ARDOUR_UI::transport_goto_start ()
+ARDOUR_UI::transport_goto_start ()
{
if (session) {
session->goto_start();
-
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (session->current_start_frame());
+ editor->center_screen (session->current_start_frame ());
}
}
}
if (session) {
session->request_locate (0);
-
+
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
editor->reset_x_origin (0);
}
time_t now;
struct tm tmnow;
nframes64_t frames;
-
+
time (&now);
localtime_r (&now, &tmnow);
-
+
frames = tmnow.tm_hour * (60 * 60 * session->frame_rate());
frames += tmnow.tm_min * (60 * session->frame_rate());
frames += tmnow.tm_sec * session->frame_rate();
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (frames - (editor->current_page_frames()/2));
+ editor->center_screen (frames);
}
}
}
ARDOUR_UI::transport_goto_end ()
{
if (session) {
- nframes_t frame = session->current_end_frame();
+ nframes_t const frame = session->current_end_frame();
session->request_locate (frame);
/* force displayed area in editor to start no matter
what "follow playhead" setting is.
*/
-
+
if (editor) {
- editor->reset_x_origin (frame);
+ editor->center_screen (frame);
}
}
}
session->cancel_audition ();
return;
}
-
- if (session->get_play_loop ()) {
- session->request_play_loop (false);
- }
-
+
session->request_stop ();
}
void
ARDOUR_UI::transport_record (bool roll)
{
-
+
if (session) {
switch (session->record_status()) {
case Session::Disabled:
//cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " session->record_status() = " << session->record_status() << endl;
}
-void
+void
ARDOUR_UI::transport_roll ()
{
- bool rolling;
-
if (!session) {
return;
}
- rolling = session->transport_rolling ();
+ if (session->is_auditioning()) {
+ return;
+ }
+
+ if (session->config.get_external_sync()) {
+ switch (session->config.get_sync_source()) {
+ case JACK:
+ break;
+ default:
+ /* transport controlled by the master */
+ return;
+ }
+ }
- //cerr << "ARDOUR_UI::transport_roll () called session->record_status() = " << session->record_status() << endl;
+ bool rolling = session->transport_rolling();
if (session->get_play_loop()) {
- session->request_play_loop (false);
- auto_loop_button.set_visual_state (1);
- roll_button.set_visual_state (1);
+ session->request_play_loop (false, true);
} else if (session->get_play_range ()) {
- session->request_play_range (false);
- play_selection_button.set_visual_state (0);
- } else if (rolling) {
- session->request_locate (session->last_transport_start(), true);
+ session->request_play_range (false, true);
+ }
+
+ if (!rolling) {
+ session->request_transport_speed (1.0f);
+ }
+
+ map_transport_state ();
+}
+
+void
+ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode)
+{
+
+ if (!session) {
+ return;
+ }
+
+ if (session->is_auditioning()) {
+ session->cancel_audition ();
+ return;
+ }
+
+ if (session->config.get_external_sync()) {
+ switch (session->config.get_sync_source()) {
+ case JACK:
+ break;
+ default:
+ /* transport controlled by the master */
+ return;
+ }
}
- session->request_transport_speed (1.0f);
+ bool rolling = session->transport_rolling();
+ bool affect_transport = true;
+
+ if (rolling && roll_out_of_bounded_mode) {
+ /* drop out of loop/range playback but leave transport rolling */
+ if (session->get_play_loop()) {
+ if (Config->get_seamless_loop()) {
+ /* the disk buffers contain copies of the loop - we can't
+ just keep playing, so stop the transport. the user
+ can restart as they wish.
+ */
+ affect_transport = true;
+ } else {
+ /* disk buffers are normal, so we can keep playing */
+ affect_transport = false;
+ }
+ session->request_play_loop (false, true);
+ } else if (session->get_play_range ()) {
+ affect_transport = false;
+ session->request_play_range (0, true);
+ }
+ }
+
+ if (affect_transport) {
+ if (rolling) {
+ session->request_stop (with_abort, true);
+ } else {
+ session->request_transport_speed (1.0f);
+ }
+ }
+
+ map_transport_state ();
}
void
-ARDOUR_UI::transport_loop()
+ARDOUR_UI::toggle_session_auto_loop ()
{
if (session) {
if (session->get_play_loop()) {
if (looploc) {
session->request_locate (looploc->start(), true);
}
+ } else {
+ session->request_play_loop (false);
+ }
+ } else {
+ Location * looploc = session->locations()->auto_loop_location();
+ if (looploc) {
+ session->request_play_loop (true);
}
- }
- else {
- session->request_play_loop (true);
}
}
}
return;
}
- if (!session->get_play_range()) {
- session->request_stop ();
- }
-
editor->play_selection ();
}
ARDOUR_UI::transport_rewind (int option)
{
float current_transport_speed;
-
+
if (session) {
current_transport_speed = session->transport_speed();
-
+
if (current_transport_speed >= 0.0f) {
switch (option) {
case 0:
ARDOUR_UI::transport_forward (int option)
{
float current_transport_speed;
-
+
if (session) {
current_transport_speed = session->transport_speed();
-
+
if (current_transport_speed <= 0.0f) {
switch (option) {
case 0:
/* speed up */
session->request_transport_speed (current_transport_speed * 1.5f);
}
+
}
}
}
boost::shared_ptr<Route> r;
-
+
if ((r = session->route_by_remote_id (dstream)) != 0) {
Track* t;
}
}
-void
-ARDOUR_UI::queue_transport_change ()
-{
- Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
-}
-
void
ARDOUR_UI::map_transport_state ()
{
+ ENSURE_GUI_THREAD(mem_fun (*this, &ARDOUR_UI::map_transport_state));
+
+ if (!session) {
+ auto_loop_button.set_visual_state (0);
+ play_selection_button.set_visual_state (0);
+ roll_button.set_visual_state (0);
+ stop_button.set_visual_state (1);
+ return;
+ }
+
float sp = session->transport_speed();
if (sp == 1.0f) {
- transport_rolling ();
- } else if (sp < 0.0f) {
- transport_rewinding ();
- } else if (sp > 0.0f) {
- transport_forwarding ();
+ shuttle_fract = SHUTTLE_FRACT_SPEED1; /* speed = 1.0, believe it or not */
+ shuttle_box.queue_draw ();
+ } else if (sp == 0.0f) {
+ shuttle_fract = 0;
+ shuttle_box.queue_draw ();
+ update_disk_space ();
+ }
+
+ if (sp != 0.0) {
+
+ if (session->get_play_range()) {
+
+ play_selection_button.set_visual_state (1);
+ roll_button.set_visual_state (0);
+ auto_loop_button.set_visual_state (0);
+
+ } else if (session->get_play_loop ()) {
+
+ auto_loop_button.set_visual_state (1);
+ play_selection_button.set_visual_state (0);
+ roll_button.set_visual_state (0);
+
+ } else {
+
+ roll_button.set_visual_state (1);
+ play_selection_button.set_visual_state (0);
+ auto_loop_button.set_visual_state (0);
+ }
+
+ stop_button.set_visual_state (0);
+
} else {
- transport_stopped ();
+
+ stop_button.set_visual_state (1);
+ roll_button.set_visual_state (0);
+ play_selection_button.set_visual_state (0);
+ auto_loop_button.set_visual_state (0);
}
+
}
void
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 ();
update_sample_rate (0);
- MessageDialog msg (*editor,
+ MessageDialog msg (*editor,
_("\
JACK has either been shutdown or it\n\
disconnected Ardour because Ardour\n\
int32_t
ARDOUR_UI::do_engine_start ()
{
- try {
+ try {
engine->start();
}
unload_session ();
return -2;
}
-
+
return 0;
}
{
clock_signal_connection.disconnect ();
}
-
+
void
ARDOUR_UI::toggle_clocking ()
{
*/
if (blink_timeout_tag < 0) {
- blink_on = false;
+ blink_on = false;
blink_timeout_tag = g_timeout_add (240, _blink, this);
}
}
}
}
-void
-ARDOUR_UI::name_io_setup (AudioEngine& engine,
- string& buf,
- IO& io,
- bool in)
-{
- vector<string> connections;
-
- if (in) {
- if (io.n_inputs().n_total() == 0) {
- buf = _("none");
- return;
- }
-
- /* XXX we're not handling multiple ports yet. */
-
- if (io.input(0)->get_connections(connections) == 0) {
- buf = _("off");
- } else {
- buf = connections.front();
- }
-
- } else {
-
- if (io.n_outputs().n_total() == 0) {
- buf = _("none");
- return;
- }
-
- /* XXX we're not handling multiple ports yet. */
-
- if (io.output(0)->get_connections(connections) == 0) {
- buf = _("off");
- } else {
- buf = connections.front();
- }
- }
-}
/** Ask the user for the name of a new shapshot and then take it.
*/
prompter.set_name ("Prompter");
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+ prompter.set_title (_("Take Snapshot"));
prompter.set_prompt (_("Name of New Snapshot"));
prompter.set_initial_text (timebuf);
-
+
switch (prompter.run()) {
case RESPONSE_ACCEPT:
{
do_save = false;
}
}
-
+
if (do_save) {
save_state (snapname);
}
{
(void) save_state_canfail (name);
}
-
+
int
ARDOUR_UI::save_state_canfail (string name)
{
}
void
-ARDOUR_UI::transport_rec_enable_blink (bool onoff)
+ARDOUR_UI::transport_rec_enable_blink (bool onoff)
{
if (session == 0) {
return;
Session::RecordState const r = session->record_status ();
bool const h = session->have_rec_enabled_diskstream ();
-
+
if (r == Session::Enabled || (r == Session::Recording && !h)) {
if (onoff) {
rec_button.set_visual_state (2);
void
ARDOUR_UI::save_template ()
-
{
ArdourPrompter prompter (true);
string name;
}
prompter.set_name (X_("Prompter"));
+ prompter.set_title (_("Save Mix Template"));
prompter.set_prompt (_("Name for mix template:"));
prompter.set_initial_text(session->name() + _("-template"));
prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
switch (prompter.run()) {
case RESPONSE_ACCEPT:
prompter.get_result (name);
-
+
if (name.length()) {
session->save_template (name);
}
ARDOUR_UI::fontconfig_dialog ()
{
#ifdef GTKOSX
- /* X11 users will always have fontconfig info around, but new GTK-OSX users
+ /* 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.
*/
-
+
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 (*_startup,
_("Welcome to Ardour.\n\n"
/* it doesn't exist, assume the best */
session_path = Glib::path_get_dirname (string (cmdline_path));
}
-
+
session_name = basename_nosuffix (string (cmdline_path));
}
if (session_name.length() == 0 || session_path.length() == 0) {
return false;
}
-
+
if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
Glib::ustring predicted_session_file;
-
+
predicted_session_file = session_path;
predicted_session_file += '/';
predicted_session_file += session_name;
predicted_session_file += ARDOUR::statefile_suffix;
-
+
if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) {
existing_session = true;
}
-
+
} else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) {
-
+
if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) {
/* existing .ardour file */
existing_session = true;
} else {
existing_session = false;
}
-
+
/* lets just try to load it */
-
+
if (create_engine ()) {
backend_audio_error (false, _startup);
return -1;
}
-
+
return load_session (session_path, session_name);
}
ARDOUR_UI::ask_about_loading_existing_session (const Glib::ustring& session_path)
{
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_name (X_("OpenExistingDialog"));
+ msg.set_title (_("Open Existing Session"));
msg.set_wmclass (X_("existing_session"), "Ardour");
msg.set_position (Gtk::WIN_POS_MOUSE);
pop_back_splash ();
int
ARDOUR_UI::build_session_from_nsd (const Glib::ustring& session_path, const Glib::ustring& session_name)
{
-
+
uint32_t cchns;
uint32_t mchns;
AutoConnectOption iconnect;
AutoConnectOption oconnect;
uint32_t nphysin;
uint32_t nphysout;
-
+
if (Profile->get_sae()) {
-
+
cchns = 0;
mchns = 2;
iconnect = AutoConnectPhysical;
oconnect = AutoConnectMaster;
nphysin = 0; // use all available
nphysout = 0; // use all available
-
+
} else {
-
+
/* get settings from advanced section of NSD */
-
+
if (_startup->create_control_bus()) {
cchns = (uint32_t) _startup->control_channel_count();
} else {
cchns = 0;
}
-
+
if (_startup->create_master_bus()) {
mchns = (uint32_t) _startup->master_channel_count();
} else {
mchns = 0;
}
-
+
if (_startup->connect_inputs()) {
iconnect = AutoConnectPhysical;
} else {
iconnect = AutoConnectOption (0);
}
-
+
/// @todo some minor tweaks.
-
- if (_startup->connect_outs_to_master()) {
- oconnect = AutoConnectMaster;
- } else if (_startup->connect_outs_to_physical()) {
- oconnect = AutoConnectPhysical;
- } else {
- oconnect = AutoConnectOption (0);
- }
-
+
+ oconnect = AutoConnectOption (0);
+
+ if (_startup->connect_outputs ()) {
+ if (_startup->connect_outs_to_master()) {
+ oconnect = AutoConnectMaster;
+ } else if (_startup->connect_outs_to_physical()) {
+ oconnect = AutoConnectPhysical;
+ }
+ }
+
nphysin = (uint32_t) _startup->input_limit_count();
nphysout = (uint32_t) _startup->output_limit_count();
}
-
+
if (build_session (session_path,
session_name,
cchns,
iconnect,
oconnect,
nphysin,
- nphysout,
+ nphysout,
engine->frame_rate() * 60 * 5)) {
-
+
return -1;
}
return 0;
}
+void
+ARDOUR_UI::idle_load (const Glib::ustring& path)
+{
+ if (session) {
+ if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
+ /* /path/to/foo => /path/to/foo, foo */
+ load_session (path, basename_nosuffix (path));
+ } else {
+ /* /path/to/foo/foo.ardour => /path/to/foo, foo */
+ load_session (Glib::path_get_dirname (path), basename_nosuffix (path));
+ }
+ } else {
+
+ ARDOUR_COMMAND_LINE::session_name = path;
+
+ /*
+ * new_session_dialog doens't exist in A3
+ * Try to remove all references to it to
+ * see if it will compile. NOTE: this will
+ * likely cause a runtime issue is my somewhat
+ * uneducated guess.
+ */
+
+ //if (new_session_dialog) {
+
+
+ /* make it break out of Dialog::run() and
+ start again.
+ */
+
+ //new_session_dialog->response (1);
+ //}
+ }
+}
+
void
ARDOUR_UI::end_loading_messages ()
{
}
void
-ARDOUR_UI::loading_message (const std::string& msg)
+ARDOUR_UI::loading_message (const std::string& /*msg*/)
{
// show_splash ();
// splash->message (msg);
flush_pending ();
}
+/** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
int
-ARDOUR_UI::get_session_parameters (bool should_be_new)
+ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new)
{
Glib::ustring session_name;
Glib::ustring session_path;
if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) {
- /* if they named a specific statefile, use it, otherwise they are
+ /* if they named a specific statefile, use it, otherwise they are
just giving a session folder, and we want to use it as is
to find the session.
*/
} else {
- run_startup (should_be_new);
-
+ bool const apply = run_startup (should_be_new);
+ if (!apply) {
+ if (quit_on_cancel) {
+ exit (1);
+ } else {
+ return ret;
+ }
+ }
+
/* if we run the startup dialog again, offer more than just "new session" */
-
+
should_be_new = false;
-
+
session_name = _startup->session_name (likely_new);
-
+
/* this shouldn't happen, but we catch it just in case it does */
-
+
if (session_name.empty()) {
break;
- }
+ }
if (_startup->use_session_template()) {
template_name = _startup->session_template_name();
_session_is_new = true;
- }
-
+ }
- if (session_name[0] == '/' ||
+ 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 {
-
+
session_path = _startup->session_folder();
}
}
if (create_engine ()) {
break;
}
-
+
if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
if (likely_new) {
Glib::ustring existing = Glib::build_filename (session_path, session_name);
-
+
if (!ask_about_loading_existing_session (existing)) {
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
- }
- }
+ }
+ }
_session_is_new = false;
}
if (likely_new && template_name.empty()) {
-
+
ret = build_session_from_nsd (session_path, session_name);
} else {
ret = load_session (session_path, session_name, template_name);
+ if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
+ session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
+ exit (1);
+ }
}
}
-
+
return ret;
-}
+}
void
ARDOUR_UI::close_session()
unload_session (true);
- get_session_parameters (false);
+ ARDOUR_COMMAND_LINE::session_name = "";
+ get_session_parameters (true, false);
}
int
goto out;
}
- /* if it already exists, we must have write access */
-
- if (Glib::file_test (path.c_str(), Glib::FILE_TEST_EXISTS) && ::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."));
- pop_back_splash ();
- msg.run ();
- goto out;
- }
-
loading_message (_("Please wait while Ardour loads your session"));
try {
true,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_CLOSE);
-
+
msg.set_title (_("Port Registration Error"));
msg.set_secondary_text (_("Click the Close button to try again."));
msg.set_position (Gtk::WIN_POS_CENTER);
true,
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_CLOSE);
-
+
msg.set_title (_("Loading Error"));
msg.set_secondary_text (_("Click the Close button to try again."));
msg.set_position (Gtk::WIN_POS_CENTER);
connect_to_session (new_session);
session_loaded = true;
-
+
goto_editor_window ();
if (session) {
}
int
-ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name,
+ARDOUR_UI::build_session (const Glib::ustring& path, const Glib::ustring& snap_name,
uint32_t control_channels,
- uint32_t master_channels,
+ uint32_t master_channels,
AutoConnectOption input_connect,
AutoConnectOption output_connect,
uint32_t nphysin,
} else if (x > 0) {
return 0;
}
-
+
_session_is_new = true;
try {
{
if (editor) {
editor->show_window ();
-
+
if (!shown_flag) {
editor->present ();
}
}
void
-ARDOUR_UI::about_signal_response(int response)
+ARDOUR_UI::about_signal_response (int /*response*/)
{
hide_about();
}
}
void
-ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, const string & msg)
+ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title,
+ const string& plural_msg, const string& singular_msg)
{
size_t removed;
if (removed == 0) {
MessageDialog msgd (*editor,
- _("No audio files were ready for cleanup"),
+ _("No audio files were ready for cleanup"),
true,
Gtk::MESSAGE_INFO,
(Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
check for any existing snapshots.\n\
These may still include regions that\n\
require some unused files to continue to exist."));
-
+
msgd.run ();
return;
- }
+ }
ArdourDialog results (_("ardour: cleanup"), true, false);
-
+
struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
- CleanupResultsModelColumns() {
+ CleanupResultsModelColumns() {
add (visible_name);
add (fullpath);
}
Gtk::TreeModelColumn<Glib::ustring> fullpath;
};
-
+
CleanupResultsModelColumns results_columns;
Glib::RefPtr<Gtk::ListStore> results_model;
Gtk::TreeView results_display;
-
+
results_model = ListStore::create (results_columns);
results_display.set_model (results_model);
results_display.append_column (list_title, results_columns.visible_name);
const string dead_sound_directory = session->session_directory().dead_sound_path().to_string();
+
+
+
+ /* subst:
+ %1 - number of files removed
+ %2 - location of "dead_sounds"
+ %3 - size of files affected
+ %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
+ */
+
+ const char* bprefix;
+
if (rep.space < 1048576.0f) {
- if (removed > 1) {
- 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"), dead_sound_directory, (float) rep.space / 1024.0f, "kilo"));
- }
+ bprefix = X_("kilo");
+ } else if (rep.space < 1048576.0f * 1000) {
+ bprefix = X_("mega");
} else {
- if (removed > 1) {
- 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"), dead_sound_directory, (float) rep.space / 1048576.0f, "mega"));
- }
+ bprefix = X_("giga");
+ }
+
+ if (removed > 1) {
+ txt.set_text (string_compose (plural_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
+ } else {
+ txt.set_text (string_compose (singular_msg, removed, dead_sound_directory, (float) rep.space / 1024.0f, bprefix));
}
dhbox.pack_start (*dimage, true, false, 5);
row[results_columns.visible_name] = *i;
row[results_columns.fullpath] = *i;
}
-
+
list_scroller.add (results_display);
list_scroller.set_size_request (-1, 150);
list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
ALL undo/redo information will be lost if you cleanup.\n\
After cleanup, unused audio files will be moved to a \
\"dead sounds\" location."));
-
+
checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
checker.set_default_response (RESPONSE_CANCEL);
return;
}
- Session::cleanup_report rep;
+ ARDOUR::CleanupReport rep;
editor->prepare_for_cleanup ();
editor->finish_cleanup ();
return;
}
-
+
editor->finish_cleanup ();
checker.hide();
- display_cleanup_results (rep,
+ display_cleanup_results (rep,
_("cleaned files"),
_("\
-The following %1 %2 not in use and \n\
+The following %1 files were not in use and \n\
have been moved to:\n\
-%3. \n\n\
+%2. \n\n\
+Flushing the wastebasket will \n\
+release an additional\n\
+%3 %4bytes of disk space.\n"),
+ _("\
+The following file was not in use and \n \
+has been moved to:\n \
+%2. \n\n\
Flushing the wastebasket will \n\
release an additional\n\
-%4 %5bytes of disk space.\n"
+%3 %4bytes of disk space.\n"
));
}
return;
}
- Session::cleanup_report rep;
+ ARDOUR::CleanupReport rep;
if (session->cleanup_trash_sources (rep)) {
return;
}
- display_cleanup_results (rep,
+ display_cleanup_results (rep,
_("deleted file"),
- _("The following %1 %2 deleted from\n\
-%3,\n\
-releasing %4 %5bytes of disk space"));
+ _("The following %1 files were deleted from\n\
+%2,\n\
+releasing %3 %4bytes of disk space"),
+ _("The following file was deleted from\n\
+%2,\n\
+releasing %3 %4bytes of disk space"));
}
void
}
if (add_route_dialog == 0) {
- add_route_dialog = new AddRouteDialog;
+ add_route_dialog = new AddRouteDialog (*session);
if (float_window) {
add_route_dialog->set_transient_for (*float_window);
}
}
string template_path = add_route_dialog->track_template();
-
+
if (!template_path.empty()) {
session->new_route_from_template (count, template_path);
return;
uint32_t output_chan;
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
+ bool aux = !track && add_route_dialog->aux();
+ RouteGroup* route_group = add_route_dialog->route_group ();
AutoConnectOption oac = Config->get_output_auto_connect();
}
/* XXX do something with name template */
-
+
if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
- session_add_midi_track(count);
+ session_add_midi_track (route_group, count);
} else {
MessageDialog msg (*editor,
_("Sorry, MIDI Busses are not supported at this time."));
msg.run ();
//session_add_midi_bus();
}
- } else {
+ } else {
if (track) {
- session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
+ session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
} else {
- session_add_audio_bus (input_chan, output_chan, count);
+ session_add_audio_bus (aux, input_chan, output_chan, route_group, count);
}
}
}
} else {
node = Config->instant_xml(X_("Editor"));
}
-
+
if (!node) {
if (getenv("ARDOUR_INSTANT_XML_PATH")) {
node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
XMLNode* node = 0;
node = Config->extra_xml(X_("Keyboard"));
-
+
if (!node) {
node = new XMLNode (X_("Keyboard"));
}
void
ARDOUR_UI::write_buffer_stats ()
{
+
+ std::ofstream fout;
struct tm tm;
char buf[64];
- char* path;
+ char path[PATH_MAX+1]; int fd;
+
+ strcpy (path, "ardourBufferingXXXXXX");
- char* tmplt = (char*)calloc(strlen("ardourXXXXXX"), sizeof(char));
- int fd = mkstemp (tmplt);
- if (fd) {
+ if ((fd = mkstemp (path )) < 0) {
cerr << X_("cannot find temporary name for ardour buffer stats") << endl;
return;
}
+
+ fout.open (path);
+ close (fd);
- FILE* fout = fdopen (fd, "w");
if (!fout) {
cerr << string_compose (X_("cannot open file %1 for ardour buffer stats"), path) << endl;
return;
}
for (list<DiskBufferStat>::iterator i = disk_buffer_stats.begin(); i != disk_buffer_stats.end(); ++i) {
- std::ostringstream ss;
localtime_r (&(*i).when, &tm);
strftime (buf, sizeof (buf), "%T", &tm);
- fprintf(fout, "%s %u %u\n", buf, (*i).capture, (*i).playback);
+ fout << buf << ' ' << (*i).capture << ' ' << (*i).playback << endl;
}
disk_buffer_stats.clear ();
- fclose (fout);
- close (fd);
+ fout.close ();
cerr << "Ardour buffering statistics can be found in: " << path << endl;
- free (path);
- free (tmplt);
}
void
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_speed_dialog_gone (int ignored_response, MessageDialog* msg)
+ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
{
have_disk_speed_dialog_displayed = false;
delete msg;
ARDOUR_UI::session_dialog (std::string msg)
{
ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::session_dialog), msg));
-
+
MessageDialog* d;
if (editor) {
d->show_all ();
d->run ();
delete d;
-}
+}
int
ARDOUR_UI::pending_state_dialog ()
}
}
-
+
void
ARDOUR_UI::disconnect_from_jack ()
{
void
ARDOUR_UI::use_config ()
{
- Glib::RefPtr<Action> act;
-
- assert (session);
-
- switch (session->config.get_native_file_data_format ()) {
- case FormatFloat:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
- break;
- case FormatInt24:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
- break;
- case FormatInt16:
- act = ActionManager::get_action (X_("options"), X_("FileDataFormat16bit"));
- break;
- }
-
- if (act) {
- Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
- ract->set_active ();
- }
-
- switch (session->config.get_native_file_header_format ()) {
- 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);
- ract->set_active ();
- }
XMLNode* node = Config->extra_xml (X_("TransportControllables"));
if (node) {
Session::RecordState const r = session->record_status ();
bool const h = session->have_rec_enabled_diskstream ();
-
+
if (r == Session::Recording && h) {
big_clock.set_widget_name ("BigClockRecording");
- } else {
+ } else {
big_clock.set_widget_name ("BigClockNonRecording");
}
}
}
-
+
ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp)
: Controllable (name), ui (u), type(tp)
{
-
+
}
void
fract = ((val - 0.5f)/0.5f);
}
}
-
+
ui.set_shuttle_fract (fract);
return;
}
ARDOUR_UI::TransportControllable::get_value (void) const
{
float val = 0.0f;
-
+
switch (type) {
case Roll:
break;
projects / ardour.git / blobdiff