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;
void
ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
{
- jack_nframes_t _preroll;
+ jack_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;
return;
}
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (Config->get_auto_loop()) {
+ session->request_play_loop (false);
}
session->request_stop ();
rolling = session->transport_rolling ();
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (Config->get_auto_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 (Config->get_auto_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);
}
}
}
uint32_t cchns;
uint32_t mchns;
- Session::AutoConnectOption iconnect;
- Session::AutoConnectOption oconnect;
+ AutoConnectOption iconnect;
+ AutoConnectOption oconnect;
if (new_session_dialog->create_control_bus()) {
cchns = (uint32_t) new_session_dialog->control_channel_count();
}
if (new_session_dialog->connect_inputs()) {
- iconnect = Session::AutoConnectPhysical;
+ iconnect = AutoConnectPhysical;
} else {
- iconnect = Session::AutoConnectOption (0);
+ iconnect = AutoConnectOption (0);
}
/// @todo some minor tweaks.
if (new_session_dialog->connect_outs_to_master()) {
- oconnect = Session::AutoConnectMaster;
+ oconnect = AutoConnectMaster;
} else if (new_session_dialog->connect_outs_to_physical()) {
- oconnect = Session::AutoConnectPhysical;
+ oconnect = AutoConnectPhysical;
} else {
- oconnect = Session::AutoConnectOption (0);
+ oconnect = AutoConnectOption (0);
}
uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
connect_to_session (new_session);
+ Config->set_current_owner (ConfigVariableBase::Interface);
+
session_loaded = true;
return 0;
}
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)
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;
int build_session (const string & path, const string & snapshot,
uint32_t ctl_chns,
uint32_t master_chns,
- ARDOUR::Session::AutoConnectOption input_connect,
- ARDOUR::Session::AutoConnectOption output_connect,
+ ARDOUR::AutoConnectOption input_connect,
+ ARDOUR::AutoConnectOption output_connect,
uint32_t nphysin,
uint32_t nphysout,
jack_nframes_t initial_length);
void toggle_time_master ();
void toggle_video_sync ();
- enum ShuttleBehaviour {
- Sprung,
- Wheel
- };
-
- enum ShuttleUnits {
- Percentage,
- Semitones
- };
-
Gtk::DrawingArea shuttle_box;
Gtk::EventBox speed_display_box;
Gtk::Label speed_display_label;
Gtk::ComboBoxText shuttle_style_button;
Gtk::Menu* shuttle_unit_menu;
Gtk::Menu* shuttle_style_menu;
- ShuttleBehaviour shuttle_behaviour;
- ShuttleUnits shuttle_units;
float shuttle_max_speed;
Gtk::Menu* shuttle_context_menu;
void show_shuttle_context_menu ();
void shuttle_style_changed();
void shuttle_unit_clicked ();
- void set_shuttle_behaviour (ShuttleBehaviour);
- void set_shuttle_units (ShuttleUnits);
void set_shuttle_max_speed (float);
void update_speed_display ();
float last_speed_displayed;
bool shuttle_grabbed;
double shuttle_fract;
+ static const double SHUTTLE_FRACT_SPEED1=0.48412291827; /* derived from A1,A2 */
+
Gtk::ToggleButton punch_in_button;
Gtk::ToggleButton punch_out_button;
Gtk::ToggleButton auto_return_button;
void we_have_dependents ();
void setup_keybindings ();
void setup_session_options ();
- void setup_config_options ();
guint32 last_key_press_time;
std::vector<std::string> positional_sync_strings;
- void toggle_config_state (const char* group, const char* action, void (ARDOUR::Configuration::*set)(bool));
- void toggle_session_state (const char* group, const char* action, void (ARDOUR::Session::*set)(bool), bool (ARDOUR::Session::*get)(void) const);
- void toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot);
+ void toggle_config_state (const char* group, const char* action, bool (ARDOUR::Configuration::*set)(bool), bool (ARDOUR::Configuration::*get)(void) const);
+ void toggle_config_state (const char* group, const char* action, sigc::slot<void> theSlot);
void toggle_send_midi_feedback ();
void toggle_use_mmc ();
void toggle_send_mmc ();
void toggle_LatchedRecordEnable ();
void mtc_port_changed ();
- void map_some_session_state (const char* group, const char* action, bool (ARDOUR::Session::*get)() const);
- void queue_session_control_changed (ARDOUR::Session::ControlType t);
- void session_control_changed (ARDOUR::Session::ControlType t);
+ void map_some_state (const char* group, const char* action, bool (ARDOUR::Configuration::*get)() const);
+ void parameter_changed (const char*);
void toggle_control_protocol (ARDOUR::ControlProtocolInfo*);
};
update_disk_space ();
}
-static const double SHUTTLE_FRACT_SPEED1=0.48412291827; /* derived from A1,A2 */
-
void
ARDOUR_UI::transport_rolling ()
{
stop_button.set_active (false);
if (session->get_play_range()) {
-
play_selection_button.set_active (true);
roll_button.set_active (false);
auto_loop_button.set_active (false);
- } else if (session->get_auto_loop ()) {
-
+ } else if (Config->get_auto_loop ()) {
auto_loop_button.set_active (true);
play_selection_button.set_active (false);
roll_button.set_active (false);
sdframe->add (speed_display_box);
mtc_port_changed ();
- sync_option_combo.set_active_text (positional_sync_strings.front());
sync_option_combo.signal_changed().connect (mem_fun (*this, &ARDOUR_UI::sync_option_changed));
- Gtkmm2ext::set_size_request_to_display_given_text (sync_option_combo, "Internal", 22, 10);
+ const guint32 FUDGE = 25; // Combo's are stupid - they steal space from the entry for the button
+ set_size_request_to_display_given_text (sync_option_combo, X_("Igternal"), 2+FUDGE, 10);
shbox->pack_start (*sdframe, false, false);
shbox->pack_start (shuttle_units_button, true, true);
void
ARDOUR_UI::auditioning_changed (bool onoff)
{
- Gtkmm2ext::UI::instance()->call_slot(bind (mem_fun(*this, &ARDOUR_UI::_auditioning_changed), onoff));
+ UI::instance()->call_slot(bind (mem_fun(*this, &ARDOUR_UI::_auditioning_changed), onoff));
}
void
mouse_shuttle (ev->x, true);
shuttle_grabbed = false;
shuttle_box.remove_modal_grab ();
- if (shuttle_behaviour == Sprung) {
- if (session->get_auto_play() || roll_button.get_state()) {
+ if (Config->get_shuttle_behaviour() == Sprung) {
+ if (Config->get_auto_play() || roll_button.get_state()) {
shuttle_fract = SHUTTLE_FRACT_SPEED1;
session->request_transport_speed (1.0);
stop_button.set_active (false);
shuttle_unit_menu->popup (1, 0);
}
-void
-ARDOUR_UI::set_shuttle_units (ShuttleUnits u)
-{
- switch ((shuttle_units = u)) {
- case Percentage:
- shuttle_units_button.set_label("% ");
- break;
- case Semitones:
- shuttle_units_button.set_label(_("ST"));
- break;
- }
-}
-
void
ARDOUR_UI::shuttle_style_changed ()
{
ustring str = shuttle_style_button.get_active_text ();
if (str == _("sprung")) {
- set_shuttle_behaviour (Sprung);
+ Config->set_shuttle_behaviour (Sprung);
} else if (str == _("wheel")) {
- set_shuttle_behaviour (Wheel);
- }
-}
-
-
-void
-ARDOUR_UI::set_shuttle_behaviour (ShuttleBehaviour b)
-{
- switch ((shuttle_behaviour = b)) {
- case Sprung:
- shuttle_style_button.set_active_text (_("sprung"));
- shuttle_fract = 0.0;
- shuttle_box.queue_draw ();
- if (session) {
- if (session->transport_rolling()) {
- shuttle_fract = SHUTTLE_FRACT_SPEED1;
- session->request_transport_speed (1.0);
- }
- }
- break;
- case Wheel:
- shuttle_style_button.set_active_text (_("wheel"));
- break;
+ Config->set_shuttle_behaviour (Wheel);
}
}
if (x != last_speed_displayed) {
if (x != 0) {
- if (shuttle_units == Percentage) {
+ if (Config->get_shuttle_units() == Percentage) {
snprintf (buf, sizeof (buf), "%.2f", x);
} else {
if (x < 0) {
void
ARDOUR_UI::editor_realized ()
{
+ Config->map_parameters (mem_fun (*this, &ARDOUR_UI::parameter_changed));
+
set_size_request_to_display_given_text (speed_display_box, _("-0.55"), 2, 2);
- /* XXX: this should really be saved in instant.xml or something similar and restored from there */
- shuttle_style_button.set_active_text (_("sprung"));
- const guint32 FUDGE = 20; // Combo's are stupid - they steal space from the entry for the button
+ const guint32 FUDGE = 25; // Combo's are stupid - they steal space from the entry for the button
set_size_request_to_display_given_text (shuttle_style_button, _("sprung"), 2+FUDGE, 10);
}
void
ARDOUR_UI::sync_option_changed ()
{
- string which;
-
- if (session == 0) {
- return;
+ if (session) {
+ session->request_slave_source (string_to_slave_source (sync_option_combo.get_active_text()));
}
-
- which = sync_option_combo.get_active_text();
-
- if (which == positional_sync_strings[Session::None]) {
- session->request_slave_source (Session::None);
- } else if (which == positional_sync_strings[Session::MTC]) {
- session->request_slave_source (Session::MTC);
- } else if (which == positional_sync_strings[Session::JACK]) {
- session->request_slave_source (Session::JACK);
- }
}
void
Glib::RefPtr<ActionGroup> shuttle_actions = ActionGroup::create ("ShuttleActions");
- shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), bind (mem_fun(*this, &ARDOUR_UI::set_shuttle_units), Percentage));
- shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), bind (mem_fun(*this, &ARDOUR_UI::set_shuttle_units), Semitones));
+ shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), sigc::hide_return (sigc::bind (sigc::mem_fun (*Config, &Configuration::set_shuttle_units), Percentage)));
+ shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), sigc::hide_return (sigc::bind (sigc::mem_fun (*Config, &Configuration::set_shuttle_units), Semitones)));
Glib::RefPtr<ActionGroup> option_actions = ActionGroup::create ("options");
ActionManager::add_action_group (transport_actions);
ActionManager::add_action_group (main_actions);
ActionManager::add_action_group (common_actions);
-
- /* initialize state of non-session dependent options */
-
- setup_config_options ();
}
void
using namespace Gtkmm2ext;
using namespace ARDOUR;
using namespace PBD;
+using namespace sigc;
void
-ARDOUR_UI::setup_config_options ()
-{
- std::vector<Glib::ustring> groups;
- groups.push_back("options");
- groups.push_back("Editor");
- groups.push_back("Transport");
-
- struct {
- char* name;
- bool (Configuration::*method)(void) const;
- char act_type; //(t)oggle or (r)adio
- } options[] = {
- { "ToggleTimeMaster", &Configuration::get_jack_time_master, 't' },
- { "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport, 't' },
- { "LatchedRecordEnable", &Configuration::get_latched_record_enable, 't' },
- { "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture, 't' },
- { "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun, 't' },
- { "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end, 't' },
- { "UseHardwareMonitoring", &Configuration::get_use_hardware_monitoring, 'r' },
- { "UseSoftwareMonitoring", &Configuration::get_use_sw_monitoring, 'r' },
- { "UseExternalMonitoring", &Configuration::get_use_external_monitoring, 'r' },
- { "MeterFalloffOff", &Configuration::get_meter_falloff_off, 'r' },
- { "MeterFalloffSlowest", &Configuration::get_meter_falloff_slowest, 'r' },
- { "MeterFalloffSlow", &Configuration::get_meter_falloff_slow, 'r' },
- { "MeterFalloffMedium", &Configuration::get_meter_falloff_medium, 'r' },
- { "MeterFalloffFast", &Configuration::get_meter_falloff_fast, 'r' },
- { "MeterFalloffFaster", &Configuration::get_meter_falloff_faster, 'r' },
- { "MeterFalloffFastest", &Configuration::get_meter_falloff_fastest, 'r' },
- { "MeterHoldOff", &Configuration::get_meter_hold_off, 'r' },
- { "MeterHoldShort", &Configuration::get_meter_hold_short, 'r' },
- { "MeterHoldMedium", &Configuration::get_meter_hold_medium, 'r' },
- { "MeterHoldLong", &Configuration::get_meter_hold_long, 'r' },
- { "ToggleVideoSync", &Configuration::get_use_video_sync, 't' },
- { 0, 0, 0 }
- };
-
- for (uint32_t n = 0; options[n].name; ++n) {
- for (std::vector<Glib::ustring>::iterator i = groups.begin(); i != groups.end(); i++) {
- Glib::RefPtr<Action> act = ActionManager::get_action (i->c_str(), options[n].name);
- if (act) {
- Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- if (options[n].act_type == 't' || options[n].act_type == 'r') {
- if ((Config->*(options[n].method))()) {
- tact->set_active (true);
- } else {
- tact->set_active (false);
- }
- }
- continue;
- }
- }
- }
-}
-
-void
-ARDOUR_UI::toggle_time_master ()
-{
- toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master);
- if (session) {
- session->engine().reset_timebase ();
- }
-}
-
-void
-ARDOUR_UI::toggle_config_state (const char* group, const char* action, void (Configuration::*set)(bool))
+ARDOUR_UI::toggle_config_state (const char* group, const char* action, bool (Configuration::*set)(bool), bool (Configuration::*get)(void) const)
{
Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
if (act) {
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- (Config->*set) (tact->get_active());
- }
-}
-
-void
-ARDOUR_UI::toggle_session_state (const char* group, const char* action, void (Session::*set)(bool), bool (Session::*get)(void) const)
-{
- if (session) {
- Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
- if (act) {
- Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- bool x = (session->*get)();
+ if (tact) {
+ bool x = (Config->*get)();
+
if (x != tact->get_active()) {
- (session->*set) (!x);
+ (Config->*set) (!x);
}
}
}
}
void
-ARDOUR_UI::toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot)
+ARDOUR_UI::toggle_config_state (const char* group, const char* action, sigc::slot<void> theSlot)
{
if (session) {
Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
}
}
+void
+ARDOUR_UI::toggle_time_master ()
+{
+ toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master, &Configuration::get_jack_time_master);
+ if (session) {
+ session->engine().reset_timebase ();
+ }
+}
+
void
ARDOUR_UI::toggle_send_mtc ()
{
- toggle_session_state ("options", "SendMTC", &Session::set_send_mtc, &Session::get_send_mtc);
+ toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
}
void
ARDOUR_UI::toggle_send_mmc ()
{
- toggle_session_state ("options", "SendMMC", &Session::set_send_mmc, &Session::get_send_mmc);
+ toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
}
void
ARDOUR_UI::toggle_use_mmc ()
{
- toggle_session_state ("options", "UseMMC", &Session::set_mmc_control, &Session::get_mmc_control);
+ toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
}
void
ARDOUR_UI::toggle_use_midi_control ()
{
- toggle_session_state ("options", "UseMIDIcontrol", &Session::set_midi_control, &Session::get_midi_control);
+ toggle_config_state ("options", "UseMIDIcontrol", &Configuration::set_midi_control, &Configuration::get_midi_control);
}
void
ARDOUR_UI::toggle_send_midi_feedback ()
{
- toggle_session_state ("options", "SendMIDIfeedback", &Session::set_midi_feedback, &Session::get_midi_feedback);
+ toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
}
void
ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware()
{
- toggle_session_state ("options", "AutoConnectNewTrackInputsToHardware", &Session::set_input_auto_connect, &Session::get_input_auto_connect);
+ toggle_config_state ("options", "AutoConnectNewTrackInputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_input_auto_connect), AutoConnectPhysical)));
}
void
ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware()
{
- toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectPhysical));
+ toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectPhysical)));
}
void
ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster()
{
- toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectMaster));
+ toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectMaster)));
}
void
ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs()
{
- toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectOption (0)));
+ toggle_config_state ("options", "AutoConnectNewTrackOutputsToHardware", hide_return (bind (mem_fun (*Config, &Configuration::set_output_auto_connect), AutoConnectOption (0))));
}
void
ARDOUR_UI::toggle_auto_input ()
{
- toggle_session_state ("Transport", "ToggleAutoInput", &Session::set_auto_input, &Session::get_auto_input);
+ toggle_config_state ("Transport", "ToggleAutoInput", &Configuration::set_auto_input, &Configuration::get_auto_input);
}
void
ARDOUR_UI::toggle_auto_play ()
{
- toggle_session_state ("Transport", "ToggleAutoPlay", &Session::set_auto_play, &Session::get_auto_play);
+ toggle_config_state ("Transport", "ToggleAutoPlay", &Configuration::set_auto_play, &Configuration::get_auto_play);
}
void
ARDOUR_UI::toggle_auto_return ()
{
- toggle_session_state ("Transport", "ToggleAutoReturn", &Session::set_auto_return, &Session::get_auto_return);
+ toggle_config_state ("Transport", "ToggleAutoReturn", &Configuration::set_auto_return, &Configuration::get_auto_return);
}
void
ARDOUR_UI::toggle_click ()
{
- toggle_session_state ("Transport", "ToggleClick", &Session::set_clicking, &Session::get_clicking);
+ toggle_config_state ("Transport", "ToggleClick", &Configuration::set_clicking, &Configuration::get_clicking);
}
void
ARDOUR_UI::toggle_session_auto_loop ()
{
if (session) {
- if (session->get_auto_loop()) {
+ if (Config->get_auto_loop()) {
if (session->transport_rolling()) {
transport_roll();
} else {
- session->request_auto_loop (false);
+ session->request_play_loop (false);
}
} else {
- session->request_auto_loop (true);
+ session->request_play_loop (true);
}
}
}
void
ARDOUR_UI::toggle_punch_in ()
{
- toggle_session_state ("Transport", "TogglePunchIn", &Session::set_punch_in, &Session::get_punch_in);
+ toggle_config_state ("Transport", "TogglePunchIn", &Configuration::set_punch_in, &Configuration::get_punch_in);
}
void
ARDOUR_UI::toggle_punch_out ()
{
- toggle_session_state ("Transport", "TogglePunchOut", &Session::set_punch_out, &Session::get_punch_out);
+ toggle_config_state ("Transport", "TogglePunchOut", &Configuration::set_punch_out, &Configuration::get_punch_out);
}
- void
+void
ARDOUR_UI::toggle_video_sync()
{
Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", "ToggleVideoSync");
void
ARDOUR_UI::toggle_StopPluginsWithTransport()
{
- toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport);
+ toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport, &Configuration::get_plugins_stop_with_transport);
}
void
ARDOUR_UI::toggle_LatchedRecordEnable()
{
- toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable);
+ toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
}
void
ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
{
- toggle_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::set_do_not_record_plugins, &Session::get_do_not_record_plugins);
+ toggle_config_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::set_do_not_record_plugins, &Configuration::get_do_not_record_plugins);
}
void
ARDOUR_UI::toggle_VerifyRemoveLastCapture()
{
- toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture);
+ toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture);
}
void
ARDOUR_UI::toggle_StopRecordingOnXrun()
{
- toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun);
+ toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun, &Configuration::get_stop_recording_on_xrun);
}
void
ARDOUR_UI::toggle_StopTransportAtEndOfSession()
{
- toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end);
+ toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end, &Configuration::get_stop_at_session_end);
}
void
void
ARDOUR_UI::toggle_LatchedSolo()
{
- toggle_session_state ("options", "LatchedSolo", &Session::set_solo_latched, &Session::solo_latched);
+ toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched);
}
void
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
if (tact->get_active()) {
- session->set_solo_model (Session::SoloBus);
+ Config->set_solo_model (SoloBus);
} else {
- session->set_solo_model (Session::InverseMute);
+ Config->set_solo_model (InverseMute);
}
}
}
ARDOUR_UI::toggle_AutomaticallyCreateCrossfades()
{
}
+
void
ARDOUR_UI::toggle_UnmuteNewFullCrossfades()
{
have_mtc = false;
}
+ positional_sync_strings.clear ();
+ positional_sync_strings.push_back (slave_source_to_string (None));
if (have_mtc) {
- const gchar *psync_strings[] = {
- N_("Internal"),
- N_("MTC"),
- N_("JACK"),
- 0
- };
-
- positional_sync_strings = PBD::internationalize (psync_strings);
-
- } else {
- const gchar *psync_strings[] = {
- N_("Internal"),
- N_("JACK"),
- 0
- };
- positional_sync_strings = PBD::internationalize (psync_strings);
+ positional_sync_strings.push_back (slave_source_to_string (MTC));
}
+ positional_sync_strings.push_back (slave_source_to_string (JACK));
set_popdown_strings (sync_option_combo, positional_sync_strings);
}
{
mtc_port_changed ();
- session_control_changed (Session::SlaveType);
- session_control_changed (Session::SendMTC);
- session_control_changed (Session::SendMMC);
- session_control_changed (Session::MMCControl);
- session_control_changed (Session::MidiFeedback);
- session_control_changed (Session::MidiControl);
- session_control_changed (Session::RecordingPlugins);
- session_control_changed (Session::CrossFadesActive);
- session_control_changed (Session::SoloLatch);
- session_control_changed (Session::SoloingModel);
- session_control_changed (Session::LayeringModel);
- session_control_changed (Session::CrossfadingModel);
- session_control_changed (Session::PunchOut);
- session_control_changed (Session::PunchIn);
- session_control_changed (Session::AutoPlay);
- session_control_changed (Session::AutoReturn);
- session_control_changed (Session::AutoInput);
- session_control_changed (Session::Clicking);
- session_control_changed (Session::SmpteMode);
-
- session->ControlChanged.connect (mem_fun (*this, &ARDOUR_UI::queue_session_control_changed));
+ Config->ParameterChanged.connect (mem_fun (*this, &ARDOUR_UI::parameter_changed));
}
void
-ARDOUR_UI::map_some_session_state (const char* group, const char* action, bool (Session::*get)() const)
+ARDOUR_UI::map_some_state (const char* group, const char* action, bool (Configuration::*get)() const)
{
- if (!session) {
- return;
- }
-
Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
if (act) {
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- bool x = (session->*get)();
- if (tact->get_active() != x) {
- tact->set_active (x);
+
+ if (tact) {
+ bool x = (Config->*get)();
+
+ if (tact->get_active() != x) {
+ tact->set_active (x);
+ }
}
}
}
void
-ARDOUR_UI::queue_session_control_changed (Session::ControlType t)
-{
- ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::session_control_changed), t));
-}
-
-void
-ARDOUR_UI::session_control_changed (Session::ControlType t)
-{
- switch (t) {
- case Session::SlaveType:
- switch (session->slave_source()) {
- case Session::None:
- sync_option_combo.set_active_text (_("Internal"));
- break;
- case Session::MTC:
- sync_option_combo.set_active_text (_("MTC"));
+ARDOUR_UI::parameter_changed (const char* parameter_name)
+{
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+
+ if (PARAM_IS ("slave-source")) {
+
+ sync_option_combo.set_active_text (slave_source_to_string (Config->get_slave_source()));
+
+ } else if (PARAM_IS ("send-mtc")) {
+
+ map_some_state ("options", "SendMTC", &Configuration::get_send_mtc);
+
+ } else if (PARAM_IS ("send-mmc")) {
+
+ map_some_state ("options", "SendMMC", &Configuration::get_send_mmc);
+
+ } else if (PARAM_IS ("mmc-control")) {
+ map_some_state ("options", "UseMMC", &Configuration::get_mmc_control);
+ } else if (PARAM_IS ("midi-feedback")) {
+ map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback);
+ } else if (PARAM_IS ("midi-control")) {
+ map_some_state ("options", "UseMIDIcontrol", &Configuration::get_midi_control);
+ } else if (PARAM_IS ("do-not-record-plugins")) {
+ map_some_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::get_do_not_record_plugins);
+ } else if (PARAM_IS ("crossfades-active")) {
+ map_some_state ("options", "CrossfadesActive", &Configuration::get_crossfades_active);
+ } else if (PARAM_IS ("latched-record-enable")) {
+ map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
+ } else if (PARAM_IS ("solo-latch")) {
+ map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched);
+ } else if (PARAM_IS ("solo-model")) {
+ } else if (PARAM_IS ("layer-model")) {
+ } else if (PARAM_IS ("crossfade-model")) {
+ } else if (PARAM_IS ("auto-play")) {
+ map_some_state ("Transport", "ToggleAutoPlay", &Configuration::get_auto_play);
+ } else if (PARAM_IS ("auto-loop")) {
+ map_some_state ("Transport", "Loop", &Configuration::get_auto_loop);
+ } else if (PARAM_IS ("auto-return")) {
+ map_some_state ("Transport", "ToggleAutoReturn", &Configuration::get_auto_return);
+ } else if (PARAM_IS ("auto-input")) {
+ map_some_state ("Transport", "ToggleAutoInput", &Configuration::get_auto_input);
+ } else if (PARAM_IS ("punch-out")) {
+ map_some_state ("Transport", "TogglePunchOut", &Configuration::get_punch_out);
+ } else if (PARAM_IS ("punch-in")) {
+ map_some_state ("Transport", "TogglePunchIn", &Configuration::get_punch_in);
+ } else if (PARAM_IS ("clicking")) {
+ map_some_state ("Transport", "ToggleClick", &Configuration::get_clicking);
+ } else if (PARAM_IS ("jack-time-master")) {
+ map_some_state ("Transport", "ToggleTimeMaster", &Configuration::get_jack_time_master);
+ } else if (PARAM_IS ("plugins-stop-with-transport")) {
+ map_some_state ("options", "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport);
+ } else if (PARAM_IS ("latched-record-enable")) {
+ map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
+ } else if (PARAM_IS ("verify-remove-last-capture")) {
+ map_some_state ("options", "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture);
+ } else if (PARAM_IS ("stop-recording-on-xrun")) {
+ map_some_state ("options", "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun);
+ } else if (PARAM_IS ("stop-at-session-end")) {
+ map_some_state ("options", "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end);
+ } else if (PARAM_IS ("use-hardware-monitoring")) {
+ map_some_state ("options", "UseHardwareMonitoring", &Configuration::get_use_hardware_monitoring);
+ } else if (PARAM_IS ("use-sw-monitoring")) {
+ map_some_state ("options", "UseSoftwareMonitoring", &Configuration::get_use_sw_monitoring);
+ } else if (PARAM_IS ("use-external-monitoring")) {
+ map_some_state ("options", "UseExternalMonitoring", &Configuration::get_use_external_monitoring);
+ } else if (PARAM_IS ("use-video-sync")) {
+ map_some_state ("Transport", "ToggleVideoSync", &Configuration::get_use_video_sync);
+ } else if (PARAM_IS ("quieten-at-speed")) {
+ map_some_state ("options", "GainReduceFastTransport", &Configuration::get_quieten_at_speed);
+ } else if (PARAM_IS ("shuttle-behaviour")) {
+
+ switch (Config->get_shuttle_behaviour ()) {
+ case Sprung:
+ shuttle_style_button.set_active_text (_("sprung"));
+ shuttle_fract = 0.0;
+ shuttle_box.queue_draw ();
+ if (session) {
+ if (session->transport_rolling()) {
+ shuttle_fract = SHUTTLE_FRACT_SPEED1;
+ session->request_transport_speed (1.0);
+ }
+ }
break;
- case Session::JACK:
- sync_option_combo.set_active_text (_("JACK"));
+ case Wheel:
+ shuttle_style_button.set_active_text (_("wheel"));
break;
}
-
- break;
-
- case Session::SendMTC:
- map_some_session_state ("options", "SendMTC", &Session::get_send_mtc);
- break;
-
- case Session::SendMMC:
- map_some_session_state ("options", "SendMMC", &Session::get_send_mmc);
- break;
- case Session::MMCControl:
- map_some_session_state ("options", "UseMMC", &Session::get_mmc_control);
- break;
-
- case Session::MidiFeedback:
- map_some_session_state ("options", "SendMIDIfeedback", &Session::get_midi_feedback);
- break;
-
- case Session::MidiControl:
- map_some_session_state ("options", "UseMIDIcontrol", &Session::get_midi_control);
- break;
-
- case Session::RecordingPlugins:
- map_some_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::get_do_not_record_plugins);
- break;
-
- case Session::CrossFadesActive:
- map_some_session_state ("options", "CrossfadesActive", &Session::get_crossfades_active);
- break;
-
- case Session::SoloLatch:
- break;
-
- case Session::SoloingModel:
- switch (session->solo_model()) {
- case Session::InverseMute:
+ } else if (PARAM_IS ("shuttle-units")) {
+
+ switch (Config->get_shuttle_units()) {
+ case Percentage:
+ shuttle_units_button.set_label("% ");
break;
- case Session::SoloBus:
+ case Semitones:
+ shuttle_units_button.set_label(_("ST"));
break;
}
- break;
-
- case Session::LayeringModel:
- break;
-
- case Session::CrossfadingModel:
- break;
-
- case Session::AutoPlay:
- map_some_session_state ("Transport", "ToggleAutoPlay", &Session::get_auto_play);
- break;
-
- case Session::AutoLoop:
- break;
-
- case Session::AutoReturn:
- map_some_session_state ("Transport", "ToggleAutoReturn", &Session::get_auto_return);
- break;
-
- case Session::AutoInput:
- map_some_session_state ("Transport", "ToggleAutoInput", &Session::get_auto_input);
- break;
-
- case Session::PunchOut:
- map_some_session_state ("Transport", "TogglePunchOut", &Session::get_punch_out);
- break;
-
- case Session::PunchIn:
- map_some_session_state ("Transport", "TogglePunchIn", &Session::get_punch_in);
- break;
-
- case Session::Clicking:
- map_some_session_state ("Transport", "ToggleClick", &Session::get_clicking);
- break;
-
- default:
- // somebody else handles this
- break;
-
}
+
+#undef PARAM_IS
}
frames = session->frame_rate();
break;
case SMPTE_Frames:
- frames = (jack_nframes_t) floor (session->frame_rate() / session->smpte_frames_per_second);
+ frames = (jack_nframes_t) floor (session->frame_rate() / Config->get_smpte_frames_per_second());
break;
case AudioFrames:
seconds_label.set_text("59");
}
- switch ((long)rint(session->smpte_frames_per_second)) {
+ switch ((long)rint(Config->get_smpte_frames_per_second())) {
case 24:
if (atoi(frames_label.get_text()) > 23) {
frames_label.set_text("23");
break;
}
- if (session->smpte_drop_frames) {
+ if (Config->get_smpte_drop_frames()) {
if ((atoi(minutes_label.get_text()) % 10) && (atoi(seconds_label.get_text()) == 0) && (atoi(frames_label.get_text()) < 2)) {
frames_label.set_text("02");
}
case PROP_RECTIFIED:
g_value_set_boolean (value, waveview->rectified);
+ break;
case PROP_REGION_START:
g_value_set_uint (value, waveview->region_start);
}
void
-Editor::queue_session_control_changed (Session::ControlType t)
+Editor::parameter_changed (const char* parameter_name)
{
- Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &Editor::session_control_changed), t));
-}
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
-void
-Editor::session_control_changed (Session::ControlType t)
-{
- // right now we're only tracking some state here
+ ENSURE_GUI_THREAD (bind (mem_fun (*this, &Editor::parameter_changed), parameter_name));
- switch (t) {
- case Session::AutoLoop:
+ if (PARAM_IS ("auto-loop")) {
update_loop_range_view (true);
- break;
- case Session::PunchIn:
- case Session::PunchOut:
+ } else if (PARAM_IS ("punch-in")) {
update_punch_range_view (true);
- break;
-
- case Session::LayeringModel:
+ } else if (PARAM_IS ("punch-out")) {
+ update_punch_range_view (true);
+ } else if (PARAM_IS ("layer-model")) {
update_layering_model ();
- break;
-
- case Session::SmpteMode:
+ } else if (PARAM_IS ("smpte-frames-per-second") || PARAM_IS ("smpte-drop-frames")) {
update_smpte_mode ();
- break;
+ update_just_smpte ();
+ } else if (PARAM_IS ("video-pullup")) {
+ update_video_pullup ();
+ }
- default:
- break;
- }
+#undef PARAM_IS
}
void
session_connections.push_back (session->RegionHiddenChange.connect (mem_fun(*this, &Editor::region_hidden)));
session_connections.push_back (session->SMPTEOffsetChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
- session_connections.push_back (session->SMPTETypeChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
-
- session_connections.push_back (session->SMPTETypeChanged.connect (mem_fun(*this, &Editor::update_smpte_mode)));
- session_connections.push_back (session->PullupChanged.connect (mem_fun(*this, &Editor::update_video_pullup)));
session_connections.push_back (session->tempo_map().StateChanged.connect (mem_fun(*this, &Editor::tempo_map_changed)));
analysis_window->set_session (session);
#endif
- switch (session->get_edit_mode()) {
+ switch (Config->get_edit_mode()) {
case Splice:
edit_mode_selector.set_active_text (edit_mode_strings[splice_index]);
break;
update_loop_range_view (true);
update_punch_range_view (true);
- session->ControlChanged.connect (mem_fun(*this, &Editor::queue_session_control_changed));
session->StateSaved.connect (mem_fun(*this, &Editor::session_state_saved));
refresh_location_display ();
if (act) {
RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
/* do it twice to force the change */
- yn = session->get_crossfades_active();
+ yn = Config->get_crossfades_active();
tact->set_active (!yn);
tact->set_active (yn);
}
mode = Slide;
}
- session->set_edit_mode (mode);
+ Config->set_edit_mode (mode);
}
void
RefPtr<Action> act;
- float frames = session->smpte_frames_per_second;
- bool drop = session->smpte_drop_frames;
+ float frames = Config->get_smpte_frames_per_second();
+ bool drop = Config->get_smpte_drop_frames();
if ((frames < 23.976 * 1.0005) && !drop)
act = ActionManager::get_action (X_("Editor"), X_("Smpte23976"));
RefPtr<Action> act;
- float pullup = session->video_pullup;
+ float pullup = Config->get_video_pullup();
if ( pullup < (-4.1667 - 0.1) * 0.99) {
act = ActionManager::get_action (X_("Editor"), X_("PullupMinus4Minus1"));
{
RefPtr<Action> act;
- switch (session->get_layer_model()) {
- case Session::LaterHigher:
+ switch (Config->get_layer_model()) {
+ case LaterHigher:
act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
break;
- case Session::MoveAddHigher:
+ case MoveAddHigher:
act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
break;
- case Session::AddHigher:
+ case AddHigher:
act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
break;
}
{
RefPtr<Action> act;
- switch (session->get_xfade_model()) {
+ switch (Config->get_xfade_model()) {
case FullCrossfade:
act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
break;
void toggle_waveforms_while_recording ();
void toggle_measure_visibility ();
- void set_meter_falloff (int);
- void set_meter_hold (int32_t);
-
/* SMPTE timecode & video sync */
void smpte_fps_chosen (ARDOUR::Session::SmpteFormat format);
/* layers */
- void set_layer_model (ARDOUR::Session::LayerModel);
+ void set_layer_model (ARDOUR::LayerModel);
void update_layering_model ();
/* redirect shared ops menu. caller must free returned menu */
ArdourCanvas::Text* verbose_canvas_cursor;
bool verbose_cursor_visible;
- void session_control_changed (ARDOUR::Session::ControlType);
- void queue_session_control_changed (ARDOUR::Session::ControlType);
-
+ void parameter_changed (const char *);
bool track_canvas_motion (GdkEvent*);
Slow = 6.8dB/sec falloff at update rate of 40ms
*/
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &Editor::set_meter_falloff), 0));
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &Editor::set_meter_falloff), 1));
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &Editor::set_meter_falloff), 2));
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &Editor::set_meter_falloff), 3));
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &Editor::set_meter_falloff), 4));
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &Editor::set_meter_falloff), 5));
- ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &Editor::set_meter_falloff), 6));
-
- ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &Editor::set_meter_hold), 0));
- ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &Editor::set_meter_hold), 40));
- ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &Editor::set_meter_hold), 100));
- ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &Editor::set_meter_hold), 200));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 0.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 1.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 2.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 3.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 4.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 5.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_falloff), 6.0f)));
+
+ ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldOff"), _("Off"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 0.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldShort"), _("Short"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 40.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldMedium"), _("Medium"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 100.0f)));
+ ActionManager::register_radio_action (editor_actions, meter_hold_group, X_("MeterHoldLong"), _("Long"), hide_return (bind (mem_fun (*Config, &Configuration::set_meter_hold), 200.0f)));
RadioAction::Group layer_model_group;
- ActionManager::register_radio_action (editor_actions, layer_model_group, X_("LayerLaterHigher"), _("Later is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), Session::LaterHigher));
- ActionManager::register_radio_action (editor_actions, layer_model_group, X_("LayerMoveAddHigher"), _("Most Recently Moved/Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), Session::MoveAddHigher));
- ActionManager::register_radio_action (editor_actions, layer_model_group, X_("LayerAddHigher"), _("Most Recently Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), Session::AddHigher));
+ ActionManager::register_radio_action (editor_actions, layer_model_group, X_("LayerLaterHigher"), _("Later is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), LaterHigher));
+ ActionManager::register_radio_action (editor_actions, layer_model_group, X_("LayerMoveAddHigher"), _("Most Recently Moved/Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), MoveAddHigher));
+ ActionManager::register_radio_action (editor_actions, layer_model_group, X_("LayerAddHigher"), _("Most Recently Added is Higher"), bind (mem_fun (*this, &Editor::set_layer_model), AddHigher));
RadioAction::Group smpte_group;
Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-xfades-active"));
if (session && act) {
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- session->set_crossfades_active (tact->get_active());
+ Config->set_crossfades_active (tact->get_active());
}
}
}
void
-Editor::set_layer_model (Session::LayerModel model)
+Editor::set_layer_model (LayerModel model)
{
/* this is driven by a toggle on a radio group, and so is invoked twice,
once for the item that became inactive and once for the one that became
if (session) {
switch (model) {
- case Session::LaterHigher:
+ case LaterHigher:
act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
break;
- case Session::MoveAddHigher:
+ case MoveAddHigher:
act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
break;
- case Session::AddHigher:
+ case AddHigher:
act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
break;
}
if (act) {
RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
if (ract && ract->get_active()) {
- session->set_layer_model (model);
+ Config->set_layer_model (model);
}
}
}
if (act) {
RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
if (ract && ract->get_active()) {
- session->set_video_pullup ( pull );
+ Config->set_video_pullup ( pull );
}
} else cerr << "Editor::video_pullup_chosen could not find action to match pullup." << endl;
}
if (act) {
RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
if (ract && ract->get_active()) {
- session->set_xfade_model (model);
+ Config->set_xfade_model (model);
}
}
}
input_chan = finfo.channels;
- if (session->get_output_auto_connect() & Session::AutoConnectMaster) {
+ if (Config->get_output_auto_connect() & AutoConnectMaster) {
output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
} else {
output_chan = input_chan;
loc->set (start, end);
// enable looping, reposition and start rolling
- session->request_auto_loop (true);
+ session->request_play_loop (true);
session->request_locate (loc->start(), true);
}
l2->set (l->start(), l->end());
// enable looping, reposition and start rolling
- session->request_auto_loop(true);
+ session->request_play_loop(true);
session->request_locate (l2->start(), true);
}
}
Location* tll;
- if (session->get_auto_loop() && ((tll = transport_loop_location()) != 0)) {
+ if (Config->get_auto_loop() && ((tll = transport_loop_location()) != 0)) {
double x1 = frame_to_pixel (tll->start());
double x2 = frame_to_pixel (tll->end());
Location* tpl;
- if ((session->get_punch_in() || session->get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
+ if ((Config->get_punch_in() || Config->get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
double x1 = frame_to_pixel (tpl->start());
double x2 = frame_to_pixel (tpl->end());
case AudioClock::MinSec:
/* XXX fix this to compute min/sec properly */
session->smpte_time (frame, smpte);
- secs = smpte.seconds + ((float) smpte.frames / session->smpte_frames_per_second);
+ secs = smpte.seconds + ((float) smpte.frames / Config->get_smpte_frames_per_second());
snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
break;
case AudioClock::MinSec:
/* XXX fix this to compute min/sec properly */
session->smpte_duration (end - start, smpte);
- secs = smpte.seconds + ((float) smpte.frames / session->smpte_frames_per_second);
+ secs = smpte.seconds + ((float) smpte.frames / Config->get_smpte_frames_per_second());
snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
break;
}
}
-void
-Editor::set_meter_hold (int32_t cnt)
-{
- Config->set_meter_hold_off(false);
- Config->set_meter_hold_short(false);
- Config->set_meter_hold_medium(false);
- Config->set_meter_hold_long(false);
-
- switch (cnt)
- {
- case 0:
- Config->set_meter_hold_off(true);
- break;
- case 40:
- Config->set_meter_hold_short(true);
- break;
- case 100:
- Config->set_meter_hold_medium(true);
- break;
- case 200:
- Config->set_meter_hold_long(true);
- break;
- }
-
- if (session) {
- session->set_meter_hold (cnt);
- }
-}
-
-void
-Editor::set_meter_falloff (int intval)
-{
- float val = 0.0f; /* off */
- std::string str;
-
- Config->set_meter_falloff_off(false);
- Config->set_meter_falloff_slowest(false);
- Config->set_meter_falloff_slow(false);
- Config->set_meter_falloff_medium(false);
- Config->set_meter_falloff_fast(false);
- Config->set_meter_falloff_faster(false);
- Config->set_meter_falloff_fastest(false);
-
- switch (intval)
- {
- case 0:
- val = 0.0f;
- Config->set_meter_falloff_off(true);
- break;
- case 1:
- val = 0.125f;
- Config->set_meter_falloff_slowest(true);
- break;
- case 2:
- val = 0.250f;
- Config->set_meter_falloff_slow(true);
- break;
- case 3:
- val = 0.375f;
- Config->set_meter_falloff_medium(true);
- break;
- case 4:
- val = 0.500f;
- Config->set_meter_falloff_fast(true);
- break;
- case 5:
- val = 0.750f;
- Config->set_meter_falloff_faster(true);
- break;
- case 6:
- val = 0.875f;
- Config->set_meter_falloff_fastest(true);
- break;
- }
-
- if (session) {
- session->set_meter_falloff (val);
- }
-}
-
-
int
Editor::ensure_cursor (jack_nframes_t *pos)
{
return;
}
- switch (session->slave_source()) {
- case Session::None:
- case Session::JACK:
+ switch (Config->get_slave_source()) {
+ case None:
+ case JACK:
break;
default:
/* transport controlled by the master */
if (session->transport_rolling()) {
session->request_stop (with_abort);
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (Config->get_auto_loop()) {
+ session->request_play_loop (false);
}
} else {
session->request_transport_speed (1.0f);
// enable looping, reposition and start rolling
- session->request_auto_loop (true);
+ session->request_play_loop (true);
session->request_locate (tll->start(), false);
session->request_transport_speed (1.0f);
}
tll->set (location.start(), location.end());
// enable looping, reposition and start rolling
- session->request_auto_loop (true);
+ session->request_play_loop (true);
session->request_locate (tll->start(), true);
}
}
gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeter::gain_adjusted));
peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeter::peak_button_release));
- _session.MeterHoldChanged.connect (mem_fun(*this, &GainMeter::meter_hold_changed));
+ Config->ParameterChanged.connect (mem_fun (*this, &GainMeter::parameter_changed));
gain_changed (0);
update_gain_sensitive ();
}
void
-GainMeter::meter_hold_changed()
+GainMeter::parameter_changed(const char* parameter_name)
{
- ENSURE_GUI_THREAD(mem_fun(*this, &GainMeter::meter_hold_changed));
-
- vector<MeterInfo>::iterator i;
- uint32_t n;
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+
+ ENSURE_GUI_THREAD (bind (mem_fun(*this, &GainMeter::parameter_changed), parameter_name));
+
+ if (PARAM_IS ("meter-hold")) {
- for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
+ vector<MeterInfo>::iterator i;
+ uint32_t n;
- (*i).meter->set_hold_count ((uint32_t) floor(_session.meter_hold()));
+ for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
+
+ (*i).meter->set_hold_count ((uint32_t) floor(Config->get_meter_hold()));
+ }
}
+
+#undef PARAM_IS
}
void
for (uint32_t n = 0; n < nmeters; ++n) {
if (meters[n].width != width) {
delete meters[n].meter;
- meters[n].meter = new FastMeter ((uint32_t) floor (_session.meter_hold()), width, FastMeter::Vertical);
+ meters[n].meter = new FastMeter ((uint32_t) floor (Config->get_meter_hold()), width, FastMeter::Vertical);
meters[n].width = width;
meters[n].meter->add_events (Gdk::BUTTON_RELEASE_MASK);
bool wait_for_release;
ARDOUR::MeterPoint old_meter_point;
- void meter_hold_changed();
+ void parameter_changed (const char*);
void reset_peak_display ();
void reset_group_peak_display (ARDOUR::RouteGroup*);
try {
ARDOUR::init (use_vst, try_hw_optimization);
+ Config->set_current_owner (ConfigVariableBase::Interface);
ui->set_engine (*engine);
} catch (failed_constructor& err) {
error << _("could not initialize Ardour.") << endmsg;
click_emphasis_path_entry.set_sensitive (true);
session_raid_entry.set_sensitive (true);
- if (session->click_sound.length() == 0) {
+ if (Config->get_click_sound().empty()) {
click_path_entry.set_text (_("internal"));
} else {
- click_path_entry.set_text (session->click_sound);
+ click_path_entry.set_text (Config->get_click_sound());
}
- if (session->click_emphasis_sound.length() == 0) {
+ if (Config->get_click_emphasis_sound().empty()) {
click_emphasis_path_entry.set_text (_("internal"));
} else {
- click_emphasis_path_entry.set_text (session->click_emphasis_sound);
+ click_emphasis_path_entry.set_text (Config->get_click_emphasis_sound());
}
session_raid_entry.set_text(session->raid_path());
OptionEditor::raid_path_changed ()
{
if (session) {
- session->set_raid_path (session_raid_entry.get_text());
+ Config->set_raid_path (session_raid_entry.get_text());
}
}
if (session) {
string path = click_path_entry.get_text();
- if (path == session->click_sound) {
+ if (path == Config->get_click_sound()) {
return;
}
- if (path.length() == 0) {
+ if (path.empty()) {
- session->set_click_sound ("");
+ Config->set_click_sound ("");
} else {
strip_whitespace_edges (path);
if (path == _("internal")) {
- session->set_click_sound ("");
+ Config->set_click_sound ("");
} else {
- session->set_click_sound (path);
+ Config->set_click_sound (path);
}
}
}
if (session) {
string path = click_emphasis_path_entry.get_text();
- if (path == session->click_emphasis_sound) {
+ if (path == Config->get_click_emphasis_sound()) {
return;
}
- if (path.length() == 0) {
+ if (path.empty()) {
- session->set_click_emphasis_sound ("");
+ Config->set_click_emphasis_sound ("");
} else {
strip_whitespace_edges (path);
if (path == _("internal")) {
- session->set_click_emphasis_sound ("");
+ Config->set_click_emphasis_sound ("");
} else {
- session->set_click_emphasis_sound (path);
+ Config->set_click_emphasis_sound (path);
}
}
}
void
SendUI::fast_update ()
{
- if (_session.meter_falloff() > 0.0f) {
+ if (Config->get_meter_falloff() > 0.0f) {
gpm.update_meters ();
}
}
std::map<std::string,MidiPortDescriptor *> midi_ports;
+ void map_parameters (sigc::slot<void,const char*> theSlot);
+
int load_state ();
int save_state ();
int set_state (const XMLNode&);
XMLNode& get_state (void);
+ XMLNode& get_partial_state (ConfigVariableBase::Owner);
+ void set_variables (const XMLNode&, ConfigVariableBase::Owner owner);
+
+ void set_current_owner (ConfigVariableBase::Owner);
XMLNode* control_protocol_state () { return _control_protocol_state; }
#undef CONFIG_VARIABLE_SPECIAL
#define CONFIG_VARIABLE(Type,var,name,value) \
Type get_##var () const { return var.get(); } \
- void set_##var (Type val) { var.set (val); var.set_is_user (user_configuration); ParameterChanged (name); }
+ bool set_##var (Type val) { bool ret = var.set (val, current_owner); if (ret) { ParameterChanged (name); } return ret; }
#define CONFIG_VARIABLE_SPECIAL(Type,var,name,value,mutator) \
Type get_##var () const { return var.get(); } \
- void set_##var (Type val) { var.set (val); var.set_is_user (user_configuration); ParameterChanged (name); }
+ bool set_##var (Type val) { bool ret = var.set (val, current_owner); if (ret) { ParameterChanged (name); } return ret; }
#include "ardour/configuration_vars.h"
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
-
private:
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
- bool user_configuration;
+ ConfigVariableBase::Owner current_owner;
XMLNode* _control_protocol_state;
- XMLNode& state (bool user_only);
+ XMLNode& state (ConfigVariableBase::Owner);
};
extern Configuration *Config;
class ConfigVariableBase {
public:
- ConfigVariableBase (std::string str) : _name (str), _is_user (false) {}
+ enum Owner {
+ Default,
+ System,
+ Config,
+ Session,
+ Interface
+ };
+
+ ConfigVariableBase (std::string str) : _name (str), _owner (Default) {}
virtual ~ConfigVariableBase() {}
std::string name() const { return _name; }
- bool is_user() const { return _is_user; }
- void set_is_user (bool yn) { _is_user = yn; }
-
+ Owner owner() const { return _owner; }
+
virtual void add_to_node (XMLNode& node) = 0;
- virtual bool set_from_node (const XMLNode& node) = 0;
+ virtual bool set_from_node (const XMLNode& node, Owner owner) = 0;
protected:
std::string _name;
- bool _is_user;
+ Owner _owner;
};
template<class T>
ConfigVariable (std::string str) : ConfigVariableBase (str) {}
ConfigVariable (std::string str, T val) : ConfigVariableBase (str), value (val) {}
- virtual void set (T val) {
+ virtual bool set (T val, Owner owner) {
+ if (val == value) {
+ return false;
+ }
value = val;
+ _owner = owner;
+ return true;
}
T get() const {
node.add_child_nocopy (*child);
}
- bool set_from_node (const XMLNode& node) {
- const XMLProperty* prop;
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
- XMLNode* child;
+ bool set_from_node (const XMLNode& node, Owner owner) {
+
+ if (node.name() == "Config") {
+
+ /* ardour.rc */
- nlist = node.children();
-
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ const XMLProperty* prop;
+ XMLNodeList nlist;
+ XMLNodeConstIterator niter;
+ XMLNode* child;
- child = *niter;
+ nlist = node.children();
- if (child->name() == "Option") {
- if ((prop = child->property ("name")) != 0) {
- if (prop->value() == _name) {
- if ((prop = child->property ("value")) != 0) {
- std::stringstream ss;
- ss << prop->value();
- ss >> value;
- return true;
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+
+ child = *niter;
+
+ if (child->name() == "Option") {
+ if ((prop = child->property ("name")) != 0) {
+ if (prop->value() == _name) {
+ if ((prop = child->property ("value")) != 0) {
+ std::stringstream ss;
+ ss << prop->value();
+ ss >> value;
+ _owner = owner;
+ return true;
+ }
}
}
}
}
+
+ } else if (node.name() == "Options") {
+
+ /* session file */
+
+ XMLNodeList olist;
+ XMLNodeConstIterator oiter;
+ XMLNode* option;
+ const XMLProperty* opt_prop;
+
+ olist = node.children();
+
+ for (oiter = olist.begin(); oiter != olist.end(); ++oiter) {
+
+ option = *oiter;
+
+ if (option->name() == _name) {
+ if ((opt_prop = option->property ("val")) != 0) {
+ std::stringstream ss;
+ ss << opt_prop->value();
+ ss >> value;
+ _owner = owner;
+ return true;
+ }
+ }
+ }
}
return false;
ConfigVariableWithMutation (std::string name, T val, T (*m)(T))
: ConfigVariable<T> (name, val), mutator (m) {}
- void set (T val) {
- unmutated_value = val;
- ConfigVariable<T>::set (mutator (val));
+ bool set (T val, ConfigVariableBase::Owner owner) {
+ if (unmutated_value != val) {
+ unmutated_value = val;
+ return ConfigVariable<T>::set (mutator (val), owner);
+ }
+ return false;
}
protected:
#ifdef __APPLE__
-CONFIG_VARIABLE(std::string, auditioner_output_left, "auditioner-output-left", "coreaudio:Built-in Audio:in1")
-CONFIG_VARIABLE(std::string, auditioner_output_right, "auditioner-output-right", "coreaudio:Built-in Audio:in2")
+CONFIG_VARIABLE (std::string, auditioner_output_left, "auditioner-output-left", "coreaudio:Built-in Audio:in1")
+CONFIG_VARIABLE (std::string, auditioner_output_right, "auditioner-output-right", "coreaudio:Built-in Audio:in2")
#else
-CONFIG_VARIABLE(std::string, auditioner_output_left, "auditioner-output-left", "alsa_pcm:playback_1")
-CONFIG_VARIABLE(std::string, auditioner_output_right, "auditioner-output-right", "alsa_pcm:playback_2")
+CONFIG_VARIABLE (std::string, auditioner_output_left, "auditioner-output-left", "alsa_pcm:playback_1")
+CONFIG_VARIABLE (std::string, auditioner_output_right, "auditioner-output-right", "alsa_pcm:playback_2")
#endif
-CONFIG_VARIABLE(std::string, mtc_port_name, "mtc-port-name", "default")
-CONFIG_VARIABLE(std::string, mmc_port_name, "mmc-port-name", "default")
-CONFIG_VARIABLE(std::string, midi_port_name, "midi-port-name", "default")
-CONFIG_VARIABLE(uint32_t, minimum_disk_io_bytes, "minimum-disk-io-bytes", 1024 * 256)
-CONFIG_VARIABLE(float, track_buffer_seconds, "track-buffer-seconds", 5.0)
-CONFIG_VARIABLE(bool, hiding_groups_deactivates_groups, "hiding-groups-deactivates-groups", true)
-CONFIG_VARIABLE(bool, mute_affects_pre_fader, "mute-affects-pre-fader", true)
-CONFIG_VARIABLE(bool, mute_affects_post_fader, "mute-affects-post-fader", true)
-CONFIG_VARIABLE(bool, mute_affects_control_outs, "mute-affects-control-outs", true)
-CONFIG_VARIABLE(bool, mute_affects_main_outs, "mute-affects-main-outs", true)
-CONFIG_VARIABLE(bool, solo_latch, "solo-latch", true)
-CONFIG_VARIABLE(bool, use_hardware_monitoring, "use-hardware-monitoring", false)
-CONFIG_VARIABLE(bool, use_sw_monitoring, "use-sw-monitoring", false)
-CONFIG_VARIABLE(bool, use_external_monitoring, "use-external-monitoring", true)
-CONFIG_VARIABLE(bool, jack_time_master, "jack-time-master", true)
-CONFIG_VARIABLE(bool, use_video_sync, "use-video-sync", false)
-CONFIG_VARIABLE(bool, trace_midi_input, "trace-midi-input", false)
-CONFIG_VARIABLE(bool, trace_midi_output, "trace-midi-output", false)
-CONFIG_VARIABLE(bool, plugins_stop_with_transport, "plugins-stop-with-transport", false)
-CONFIG_VARIABLE(bool, stop_recording_on_xrun, "stop-recording-on-xrun", false)
-CONFIG_VARIABLE(bool, verify_remove_last_capture, "verify-remove-last-capture", true)
-CONFIG_VARIABLE(bool, stop_at_session_end, "stop-at-session-end", true)
-CONFIG_VARIABLE(bool, seamless_looping, "seamless-looping", true)
-CONFIG_VARIABLE(bool, auto_xfade, "auto-xfade", true)
-CONFIG_VARIABLE(bool, no_new_session_dialog, "no-new-session-dialog", false)
-CONFIG_VARIABLE(bool, timecode_source_is_synced, "timecode-source-is-synced", true)
-CONFIG_VARIABLE(bool, latched_record_enable, "latched-record-enable", false)
-CONFIG_VARIABLE(bool, use_vst, "use-vst", true)
-CONFIG_VARIABLE(bool, quieten_at_speed, "quieten-at-speed", true)
-CONFIG_VARIABLE(uint32_t, feedback_interval_ms, "feedback-interval-ms", 100)
-CONFIG_VARIABLE(uint32_t, disk_choice_space_threshold, "disk-choice-space-threshold", 57600000)
-CONFIG_VARIABLE(uint32_t, destructive_xfade_msecs, "destructive-xfade-msecs", 2)
-CONFIG_VARIABLE(SampleFormat, native_file_data_format, "native-file-data-format", ARDOUR::FormatFloat)
-CONFIG_VARIABLE(HeaderFormat, native_file_header_format, "native-file-header-format", ARDOUR::WAVE)
-CONFIG_VARIABLE(bool, use_tranzport, "use-tranzport", false)
-CONFIG_VARIABLE(uint32_t, osc_port, "osc-port", 3819)
-CONFIG_VARIABLE(bool, use_osc, "use-osc", true)
-CONFIG_VARIABLE(bool, use_overlap_equivalency, "use-overlap-equivalency", true)
-CONFIG_VARIABLE(bool, meter_falloff_off, "meter-falloff-off", false)
-CONFIG_VARIABLE(bool, meter_falloff_slowest, "meter-falloff-slowest", false)
-CONFIG_VARIABLE(bool, meter_falloff_slower, "meter-falloff-slower", false)
-CONFIG_VARIABLE(bool, meter_falloff_slow, "meter-falloff-slow", false)
-CONFIG_VARIABLE(bool, meter_falloff_medium, "meter-falloff-medium", false)
-CONFIG_VARIABLE(bool, meter_falloff_fast, "meter-falloff-fast", true)
-CONFIG_VARIABLE(bool, meter_falloff_faster, "meter-falloff-faster", false)
-CONFIG_VARIABLE(bool, meter_falloff_fastest, "meter-falloff-fastest", false)
-CONFIG_VARIABLE(bool, meter_hold_off, "meter-hold-off", false)
-CONFIG_VARIABLE(bool, meter_hold_short, "meter-hold-short", false)
-CONFIG_VARIABLE(bool, meter_hold_medium, "meter-hold-medium", false)
-CONFIG_VARIABLE(bool, meter_hold_long, "meter-hold-long", false)
+CONFIG_VARIABLE (std::string, mtc_port_name, "mtc-port-name", "default")
+CONFIG_VARIABLE (std::string, mmc_port_name, "mmc-port-name", "default")
+CONFIG_VARIABLE (std::string, midi_port_name, "midi-port-name", "default")
+CONFIG_VARIABLE (uint32_t, minimum_disk_io_bytes, "minimum-disk-io-bytes", 1024 * 256)
+CONFIG_VARIABLE (float, track_buffer_seconds, "track-buffer-seconds", 5.0)
+CONFIG_VARIABLE (bool, hiding_groups_deactivates_groups, "hiding-groups-deactivates-groups", true)
+CONFIG_VARIABLE (bool, mute_affects_pre_fader, "mute-affects-pre-fader", true)
+CONFIG_VARIABLE (bool, mute_affects_post_fader, "mute-affects-post-fader", true)
+CONFIG_VARIABLE (bool, mute_affects_control_outs, "mute-affects-control-outs", true)
+CONFIG_VARIABLE (bool, mute_affects_main_outs, "mute-affects-main-outs", true)
+CONFIG_VARIABLE (bool, solo_latch, "solo-latch", true)
+CONFIG_VARIABLE (bool, use_hardware_monitoring, "use-hardware-monitoring", false)
+CONFIG_VARIABLE (bool, use_sw_monitoring, "use-sw-monitoring", false)
+CONFIG_VARIABLE (bool, use_external_monitoring, "use-external-monitoring", true)
+CONFIG_VARIABLE (bool, jack_time_master, "jack-time-master", true)
+CONFIG_VARIABLE (bool, use_video_sync, "use-video-sync", false)
+CONFIG_VARIABLE (bool, trace_midi_input, "trace-midi-input", false)
+CONFIG_VARIABLE (bool, trace_midi_output, "trace-midi-output", false)
+CONFIG_VARIABLE (bool, plugins_stop_with_transport, "plugins-stop-with-transport", false)
+CONFIG_VARIABLE (bool, stop_recording_on_xrun, "stop-recording-on-xrun", false)
+CONFIG_VARIABLE (bool, verify_remove_last_capture, "verify-remove-last-capture", true)
+CONFIG_VARIABLE (bool, stop_at_session_end, "stop-at-session-end", true)
+CONFIG_VARIABLE (bool, seamless_looping, "seamless-looping", true)
+CONFIG_VARIABLE (bool, auto_xfade, "auto-xfade", true)
+CONFIG_VARIABLE (bool, no_new_session_dialog, "no-new-session-dialog", false)
+CONFIG_VARIABLE (bool, timecode_source_is_synced, "timecode-source-is-synced", true)
+CONFIG_VARIABLE (bool, latched_record_enable, "latched-record-enable", false)
+CONFIG_VARIABLE (bool, use_vst, "use-vst", true)
+CONFIG_VARIABLE (bool, quieten_at_speed, "quieten-at-speed", true)
+CONFIG_VARIABLE (uint32_t, feedback_interval_ms, "feedback-interval-ms", 100)
+CONFIG_VARIABLE (uint32_t, disk_choice_space_threshold, "disk-choice-space-threshold", 57600000)
+CONFIG_VARIABLE (uint32_t, destructive_xfade_msecs, "destructive-xfade-msecs", 2)
+CONFIG_VARIABLE (SampleFormat, native_file_data_format, "native-file-data-format", ARDOUR::FormatFloat)
+CONFIG_VARIABLE (HeaderFormat, native_file_header_format, "native-file-header-format", ARDOUR::WAVE)
+CONFIG_VARIABLE (bool, use_tranzport, "use-tranzport", false)
+CONFIG_VARIABLE (uint32_t, osc_port, "osc-port", 3819)
+CONFIG_VARIABLE (bool, use_osc, "use-osc", true)
+CONFIG_VARIABLE (bool, use_overlap_equivalency, "use-overlap-equivalency", true)
+CONFIG_VARIABLE (bool, auto_play, "auto-play", false)
+CONFIG_VARIABLE (bool, auto_return, "auto-return", false)
+CONFIG_VARIABLE (bool, auto_input, "auto-input", true)
+CONFIG_VARIABLE (bool, auto_loop, "auto-loop", false)
+CONFIG_VARIABLE (bool, all_safe, "all-safe", false)
+CONFIG_VARIABLE (bool, punch_in, "punch-in", false)
+CONFIG_VARIABLE (bool, punch_out, "punch-out", false)
+CONFIG_VARIABLE (bool, send_mtc, "send-mtc", false)
+CONFIG_VARIABLE (bool, send_mmc, "send-mmc", false)
+CONFIG_VARIABLE (bool, mmc_control, "mmc-control", false)
+CONFIG_VARIABLE (bool, midi_feedback, "midi-feedback", false)
+CONFIG_VARIABLE (bool, midi_control, "midi-control", false)
+CONFIG_VARIABLE (bool, crossfades_active, "crossfades-active", false)
+CONFIG_VARIABLE (bool, seamless_loop, "seamless-loop", false)
+CONFIG_VARIABLE (bool, do_not_record_plugins, "do_not_record_plugins", false)
+CONFIG_VARIABLE (AutoConnectOption, output_auto_connect, "output-auto-connect", AutoConnectOption (0))
+CONFIG_VARIABLE (AutoConnectOption, input_auto_connect, "input-auto-connect", AutoConnectOption (0))
+CONFIG_VARIABLE (EditMode, edit_mode, "edit-mode", Slide)
+CONFIG_VARIABLE (LayerModel, layer_model, "layer-model", MoveAddHigher)
+CONFIG_VARIABLE (SoloModel, solo_model, "solo-model", InverseMute)
+CONFIG_VARIABLE (bool, solo_latched, "solo-latched", true)
+CONFIG_VARIABLE (CrossfadeModel, xfade_model, "xfade-model", ShortCrossfade)
+CONFIG_VARIABLE (bool, clicking, "clicking", false)
+CONFIG_VARIABLE (std::string, click_sound, "click-sound", "")
+CONFIG_VARIABLE (std::string, click_emphasis_sound, "click-emphasis-sound", "")
+CONFIG_VARIABLE (float, meter_hold, "meter-hold", 100)
+CONFIG_VARIABLE (float, meter_falloff, "meter-falloff", 0.375f)
+CONFIG_VARIABLE (float, rf_speed, "rf-speed", 2.0f)
+CONFIG_VARIABLE (float, shuttle_speed_factor, "shuttle-speed-factor", 1.0f)
+CONFIG_VARIABLE (float, shuttle_speed_threshold, "shuttle-speed-threshold", 5.0f)
+CONFIG_VARIABLE (float, smpte_frames_per_second, "smpte-frames-per-second", 30.0f)
+CONFIG_VARIABLE (float, video_pullup, "video-pullup", 0.0f)
+CONFIG_VARIABLE (bool, smpte_drop_frames, "smpte-drop-frames", false)
+CONFIG_VARIABLE (jack_nframes_t, preroll, "preroll", 0)
+CONFIG_VARIABLE (jack_nframes_t, postroll, "postroll", 0)
+CONFIG_VARIABLE (jack_nframes_t, over_length_short, "over-length-short", 2)
+CONFIG_VARIABLE (jack_nframes_t, over_length_long, "over-length-long", 10)
+CONFIG_VARIABLE (bool, full_xfades_unmuted, "full-xfades-unmuted", true)
+CONFIG_VARIABLE (float, short_xfade_seconds, "short-xfade-seconds", 0.015)
+CONFIG_VARIABLE (SlaveSource, slave_source, "slave-source", None)
+CONFIG_VARIABLE (ShuttleBehaviour, shuttle_behaviour, "shuttle-behaviour", Sprung)
+CONFIG_VARIABLE (ShuttleUnits, shuttle_units, "shuttle-units", Percentage)
/* these variables have custom set() methods */
Recording = 2
};
- enum SlaveSource {
- None = 0,
- MTC,
- JACK
- };
-
- enum AutoConnectOption {
- AutoConnectPhysical = 0x1,
- AutoConnectMaster = 0x2
- };
-
struct Event {
enum Type {
SetTransportSpeed,
union {
void* ptr;
bool yes_or_no;
- Session::SlaveSource slave;
+ SlaveSource slave;
Route* route;
};
string path() const { return _path; }
string name() const { return _name; }
string snap_name() const { return _current_snapshot_name; }
+ string raid_path () const;
void set_snap_name ();
void request_bounded_roll (jack_nframes_t start, jack_nframes_t end);
void request_stop (bool abort = false);
void request_locate (jack_nframes_t frame, bool with_roll = false);
- void request_auto_loop (bool yn);
+ void request_play_loop (bool yn);
jack_nframes_t last_transport_start() const { return _last_roll_location; }
void goto_end () { request_locate (end_location->start(), false);}
void goto_start () { request_locate (start_location->start(), false); }
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
-
- enum ControlType {
- AutoPlay,
- AutoLoop,
- AutoReturn,
- AutoInput,
- PunchIn,
- PunchOut,
- SendMTC,
- MMCControl,
- SoloLatch,
- SoloingModel,
- RecordingPlugins,
- CrossFadesActive,
- SendMMC,
- SlaveType,
- Clicking,
- EditingMode,
- PlayRange,
- LayeringModel,
- CrossfadingModel,
- SeamlessLoop,
- MidiFeedback,
- MidiControl,
- TranzportControl,
- Feedback,
- SmpteMode,
- };
-
- sigc::signal<void,ControlType> ControlChanged;
-
- void set_auto_play (bool yn);
- void set_auto_return (bool yn);
- void set_auto_input (bool yn);
void reset_input_monitor_state ();
- void set_input_auto_connect (bool yn);
- void set_output_auto_connect (AutoConnectOption);
- void set_punch_in (bool yn);
- void set_punch_out (bool yn);
- void set_send_mtc (bool yn);
- void set_send_mmc (bool yn);
- void set_mmc_control (bool yn);
- void set_midi_feedback (bool yn);
- void set_midi_control (bool yn);
- void set_do_not_record_plugins (bool yn);
- void set_crossfades_active (bool yn);
- void set_seamless_loop (bool yn);
-
- bool get_auto_play () const { return auto_play; }
- bool get_auto_input () const { return auto_input; }
- bool get_auto_loop () const { return auto_loop; }
- bool get_seamless_loop () const { return seamless_loop; }
- bool get_punch_in () const { return punch_in; }
- bool get_punch_out () const { return punch_out; }
- bool get_all_safe () const { return all_safe; }
- bool get_auto_return () const { return auto_return; }
- bool get_send_mtc () const;
- bool get_send_mmc () const;
- bool get_mmc_control () const;
- bool get_midi_feedback () const;
- bool get_midi_control () const;
- bool get_do_not_record_plugins () const { return do_not_record_plugins; }
- bool get_crossfades_active () const { return crossfades_active; }
-
- bool get_input_auto_connect () const;
- AutoConnectOption get_output_auto_connect () const { return output_auto_connect; }
-
- enum LayerModel {
- LaterHigher,
- MoveAddHigher,
- AddHigher
- };
-
- void set_layer_model (LayerModel);
- LayerModel get_layer_model () const { return layer_model; }
-
- void set_xfade_model (CrossfadeModel);
- CrossfadeModel get_xfade_model () const { return xfade_model; }
void add_event (jack_nframes_t action_frame, Event::Type type, jack_nframes_t target_frame = 0);
void remove_event (jack_nframes_t frame, Event::Type type);
AudioEngine &engine() { return _engine; };
- /* configuration. there should really be accessors/mutators
- for these
- */
-
- float meter_hold () { return _meter_hold; }
- void set_meter_hold (float);
- sigc::signal<void> MeterHoldChanged;
-
- float meter_falloff () { return _meter_falloff; }
- void set_meter_falloff (float);
- sigc::signal<void> MeterFalloffChanged;
-
int32_t max_level;
int32_t min_level;
- string click_emphasis_sound;
- string click_sound;
- bool click_requested;
- jack_nframes_t over_length_short;
- jack_nframes_t over_length_long;
- bool send_midi_timecode;
- bool send_midi_machine_control;
- float shuttle_speed_factor;
- float shuttle_speed_threshold;
- float rf_speed;
- float smpte_frames_per_second;
- float video_pullup;
- bool smpte_drop_frames;
- AnyTime preroll;
- AnyTime postroll;
-
+
/* Time */
jack_nframes_t transport_frame () const {return _transport_frame; }
};
int set_smpte_type (float fps, bool drop_frames);
- int set_video_pullup (float pullup);
void sync_time_vars();
static sigc::signal<void> StartTimeChanged;
static sigc::signal<void> EndTimeChanged;
static sigc::signal<void> SMPTEOffsetChanged;
- static sigc::signal<void> SMPTETypeChanged;
- static sigc::signal<void> PullupChanged;
- void request_slave_source (SlaveSource, jack_nframes_t pos = 0);
- SlaveSource slave_source() const { return _slave_type; }
- bool synced_to_jack() const { return _slave_type == JACK; }
+ void request_slave_source (SlaveSource);
+ bool synced_to_jack() const { return Config->get_slave_source() == JACK; }
+
float transport_speed() const { return _transport_speed; }
bool transport_stopped() const { return _transport_speed == 0.0f; }
bool transport_rolling() const { return _transport_speed != 0.0f; }
bool sample_rate_convert (import_status&, string infile, string& outfile);
string build_tmp_convert_name (string file);
- Session::SlaveSource post_export_slave;
+ SlaveSource post_export_slave;
jack_nframes_t post_export_position;
int start_audio_export (ARDOUR::AudioExportSpecification&);
int freeze (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */
-
- enum SoloModel {
- InverseMute,
- SoloBus
- };
bool soloing() const { return currently_soloing; }
- SoloModel solo_model() const { return _solo_model; }
- void set_solo_model (SoloModel);
-
- bool solo_latched() const { return _solo_latched; }
- void set_solo_latched (bool yn);
-
void set_all_solo (bool);
void set_all_mute (bool);
sigc::signal<void,Connection *> ConnectionRemoved;
/* MIDI */
-
+
int set_mtc_port (string port_tag);
int set_mmc_port (string port_tag);
int set_midi_port (string port_tag);
void mark();
};
- /* edit mode */
-
- void set_edit_mode (EditMode);
- EditMode get_edit_mode () const { return _edit_mode; }
-
/* clicking */
boost::shared_ptr<IO> click_io() { return _click_io; }
- void set_clicking (bool yn);
- bool get_clicking() const;
-
- void set_click_sound (string path);
- void set_click_emphasis_sound (string path);
/* tempo FX */
boost::shared_ptr<AudioRegion> tempoize_region (TimeStretchRequest&);
- string raid_path() const;
- void set_raid_path(string);
-
/* need to call this whenever we change native file formats */
void reset_native_file_format();
Location* end_location;
Location* start_location;
Slave *_slave;
- SlaveSource _slave_type;
volatile float _transport_speed;
volatile float _desired_transport_speed;
float _last_transport_speed;
void reset_slave_state ();
bool follow_slave (jack_nframes_t, jack_nframes_t);
+ void set_slave_source (SlaveSource);
bool _exporting;
int prepare_to_export (ARDOUR::AudioExportSpecification&);
if (actively_recording()) {
return true;
} else {
- if (auto_input) {
+ if (Config->get_auto_input()) {
return false;
} else {
return true;
MIDI::Port* _midi_port;
string _path;
string _name;
- bool do_not_record_plugins;
-
- /* toggles */
-
- bool auto_play;
- bool punch_in;
- bool punch_out;
- bool auto_loop;
- bool seamless_loop;
- bool loop_changing;
- jack_nframes_t last_loopend;
- bool auto_input;
- bool crossfades_active;
- bool all_safe;
- bool auto_return;
- bool monitor_in;
- bool send_mtc;
- bool send_mmc;
- bool mmc_control;
- bool midi_control;
+ bool session_send_mmc;
+ bool session_send_mtc;
+ bool session_midi_feedback;
+ bool play_loop;
+ bool loop_changing;
+ jack_nframes_t last_loopend;
RingBuffer<Event*> pending_events;
bool waiting_to_start;
- void set_auto_loop (bool yn);
+ void set_play_loop (bool yn);
void overwrite_some_buffers (Diskstream*);
void flush_all_redirects ();
void locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
ConnectionList _connections;
int load_connections (const XMLNode&);
- int set_slave_source (SlaveSource, jack_nframes_t);
-
void reverse_diskstream_buffers ();
UndoHistory history;
vector<Route*> master_outs;
- EditMode _edit_mode;
EditMode pending_edit_mode;
/* range playback */
void add_controllable (PBD::Controllable*);
void remove_controllable (PBD::Controllable*);
- void handle_configuration_change (const char*);
+ void config_changed (const char*);
};
} // namespace ARDOUR
jack_nframes_t frames;
double seconds;
};
+
+ AnyTime() { type = Frames; frames = 0; }
};
struct AudioRange {
FullCrossfade,
ShortCrossfade
};
+
+ enum LayerModel {
+ LaterHigher,
+ MoveAddHigher,
+ AddHigher
+ };
+
+ enum SoloModel {
+ InverseMute,
+ SoloBus
+ };
+
+ enum AutoConnectOption {
+ AutoConnectPhysical = 0x1,
+ AutoConnectMaster = 0x2
+ };
struct InterThreadInfo {
volatile bool done;
LADSPA,
VST
};
-
+
+ enum SlaveSource {
+ None = 0,
+ MTC,
+ JACK
+ };
+
+ enum ShuttleBehaviour {
+ Sprung,
+ Wheel
+ };
+
+ enum ShuttleUnits {
+ Percentage,
+ Semitones
+ };
+
typedef std::vector<boost::shared_ptr<AudioSource> > SourceList;
} // namespace ARDOUR
std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::SoloModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::SlaveSource& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
static inline jack_nframes_t
session_frame_to_track_frame (jack_nframes_t session_frame, double speed)
void compute_equal_power_fades (jack_nframes_t nframes, float* in, float* out);
+const char* slave_source_to_string (ARDOUR::SlaveSource src);
+ARDOUR::SlaveSource string_to_slave_source (std::string str);
+
#if defined(HAVE_COREAUDIO) || defined(HAVE_AUDIOUNITS)
std::string CFStringRefToStdString(CFStringRef stringRef);
#endif // HAVE_COREAUDIO
if (_alignment_style == ExistingMaterial) {
-
- if (!_session.get_punch_in()) {
+ if (!Config->get_punch_in()) {
/* manual punch in happens at the correct transport frame
because the user hit a button. but to get alignment correct
} else {
- if (_session.get_punch_in()) {
+ if (Config->get_punch_in()) {
first_recordable_frame += _roll_delay;
} else {
capture_start_frame -= _roll_delay;
(*c).current_playback_buffer = 0;
}
- if (nominally_recording || (_session.get_record_enabled() && _session.get_punch_in())) {
+ if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
OverlapType ot;
ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
if (Config->get_use_hardware_monitoring()) {
for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
if ((*chan).source) {
- (*chan).source->ensure_monitor_input (!(_session.get_auto_input() && rolling));
+ (*chan).source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
}
capturing_sources.push_back ((*chan).write_source);
}
Location* pi;
- if (_session.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
+ if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
} else {
snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
} else {
- xfade = new Crossfade (other, region, _session.get_xfade_model(), _session.get_crossfades_active());
+ xfade = new Crossfade (other, region, Config->get_xfade_model(), Config->get_crossfades_active());
add_crossfade (*xfade);
}
}
send_silence = true;
} else {
- if (_session.get_auto_input()) {
+ if (Config->get_auto_input()) {
if (Config->get_use_sw_monitoring()) {
send_silence = false;
} else {
just_meter_input (start_frame, end_frame, nframes, offset);
}
- if (diskstream->record_enabled() && !can_record && !_session.get_auto_input()) {
+ if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) {
/* not actually recording, but we want to hear the input material anyway,
at least potentially (depending on monitoring options)
}
}
- process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !_session.get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
+ process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
} else {
/* problem with the diskstream; just be quiet for a bit */
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
- user_configuration (false)
+ current_owner (ConfigVariableBase::Default)
{
_control_protocol_state = 0;
}
{
}
+void
+Configuration::set_current_owner (ConfigVariableBase::Owner owner)
+{
+ current_owner = owner;
+}
+
int
Configuration::load_state ()
{
return -1;
}
+ current_owner = ConfigVariableBase::System;
+
if (set_state (*tree.root())) {
error << string_compose(_("Ardour: system configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
}
}
- /* from this point on, all configuration changes are user driven */
-
- user_configuration = true;
/* now load configuration file for user */
return -1;
}
+ current_owner = ConfigVariableBase::Config;
+
if (set_state (*tree.root())) {
error << string_compose(_("Ardour: user configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
XMLTree tree;
string rcfile;
- /* Note: this only writes the per-user file, and therefore
- only saves variables marked as user-set or modified
+ /* Note: this only writes the state not touched by Session or Interface
*/
rcfile = get_user_ardour_path ();
rcfile += "ardour.rc";
if (rcfile.length()) {
- tree.set_root (&state (true));
+ tree.set_root (&state (ConfigVariableBase::Config));
if (!tree.write (rcfile.c_str())){
error << string_compose (_("Config file %1 not saved"), rcfile) << endmsg;
return -1;
XMLNode&
Configuration::get_state ()
{
- return state (false);
+ return state (ConfigVariableBase::Config);
}
XMLNode&
-Configuration::state (bool user_only)
+Configuration::get_partial_state (ConfigVariableBase::Owner owner)
{
- XMLNode* root = new XMLNode("Ardour");
+ return state (owner);
+}
+
+XMLNode&
+Configuration::state (ConfigVariableBase::Owner owner)
+{
+ XMLNode* root;
+ XMLNode* node;
LocaleGuard lg (X_("POSIX"));
- typedef map<string, MidiPortDescriptor*>::const_iterator CI;
- for(CI m = midi_ports.begin(); m != midi_ports.end(); ++m){
- root->add_child_nocopy(m->second->get_state());
- }
+ node = new XMLNode("Config");
- XMLNode* node = new XMLNode("Config");
-
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
#define CONFIG_VARIABLE(type,var,name,value) \
- if (!user_only || var.is_user()) var.add_to_node (*node);
+ if (var.owner() <= owner) var.add_to_node (*node);
#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) \
- if (!user_only || var.is_user()) var.add_to_node (*node);
+ if (var.owner() <= owner) var.add_to_node (*node);
#include "ardour/configuration_vars.h"
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
- root->add_child_nocopy (*node);
+ if (owner == ConfigVariableBase::Config) {
- if (_extra_xml) {
- root->add_child_copy (*_extra_xml);
- }
+ root = new XMLNode("Ardour");
+ typedef map<string, MidiPortDescriptor*>::const_iterator CI;
+ for(CI m = midi_ports.begin(); m != midi_ports.end(); ++m){
+ root->add_child_nocopy(m->second->get_state());
+ }
+
+ root->add_child_nocopy (*node);
+
+ if (_extra_xml) {
+ root->add_child_copy (*_extra_xml);
+ }
+
+ root->add_child_nocopy (ControlProtocolManager::instance().get_state());
+ root->add_child_nocopy (Library->get_state());
- root->add_child_nocopy (ControlProtocolManager::instance().get_state());
- root->add_child_nocopy (Library->get_state());
+ } else {
+ root = node;
+ }
+
return *root;
}
}
} else if (node->name() == "Config") {
-
-#undef CONFIG_VARIABLE
-#undef CONFIG_VARIABLE_SPECIAL
-#define CONFIG_VARIABLE(type,var,name,value) \
- var.set_from_node (*node); \
- var.set_is_user (user_configuration);
-#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) \
- var.set_from_node (*node); \
- var.set_is_user (user_configuration);
-#include "ardour/configuration_vars.h"
-#undef CONFIG_VARIABLE
-#undef CONFIG_VARIABLE_SPECIAL
+
+ set_variables (*node, ConfigVariableBase::Config);
} else if (node->name() == "extra") {
_extra_xml = new XMLNode (*node);
return 0;
}
+void
+Configuration::set_variables (const XMLNode& node, ConfigVariableBase::Owner owner)
+{
+#undef CONFIG_VARIABLE
+#undef CONFIG_VARIABLE_SPECIAL
+#define CONFIG_VARIABLE(type,var,name,value) \
+ if (var.set_from_node (node, owner)) { \
+ ParameterChanged (name); \
+ }
+#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) \
+ if (var.set_from_node (node, owner)) { \
+ ParameterChanged (name); \
+ }
+#include "ardour/configuration_vars.h"
+#undef CONFIG_VARIABLE
+#undef CONFIG_VARIABLE_SPECIAL
+
+}
+
Configuration::MidiPortDescriptor::MidiPortDescriptor (const XMLNode& node)
{
const XMLProperty *prop;
return *root;
}
+void
+Configuration::map_parameters (sigc::slot<void,const char*> theSlot)
+{
+#undef CONFIG_VARIABLE
+#undef CONFIG_VARIABLE_SPECIAL
+#define CONFIG_VARIABLE(type,var,name,value) theSlot (name);
+#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) theSlot (name);
+#include "ardour/configuration_vars.h"
+#undef CONFIG_VARIABLE
+#undef CONFIG_VARIABLE_SPECIAL
+}
/* not sure where to put these */
-std::istream& operator>>(std::istream& o, HeaderFormat& hf) {
+template<class T>
+std::istream& int_to_type (std::istream& o, T& hf) {
int val;
o >> val;
- hf = (HeaderFormat) val;
+ hf = (T) val;
return o;
}
-std::istream& operator>>(std::istream& o, SampleFormat& sf) {
- int val;
- o >> val;
- sf = (SampleFormat) val;
- return o;
-}
+std::istream& operator>>(std::istream& o, HeaderFormat& var) { return int_to_type<HeaderFormat> (o, var); }
+std::istream& operator>>(std::istream& o, SampleFormat& var) { return int_to_type<SampleFormat> (o, var); }
+std::istream& operator>>(std::istream& o, AutoConnectOption& var) { return int_to_type<AutoConnectOption> (o, var); }
+std::istream& operator>>(std::istream& o, EditMode& var) { return int_to_type<EditMode> (o, var); }
+std::istream& operator>>(std::istream& o, SoloModel& var) { return int_to_type<SoloModel> (o, var); }
+std::istream& operator>>(std::istream& o, LayerModel& var) { return int_to_type<LayerModel> (o, var); }
+std::istream& operator>>(std::istream& o, CrossfadeModel& var) { return int_to_type<CrossfadeModel> (o, var); }
+std::istream& operator>>(std::istream& o, SlaveSource& var) { return int_to_type<SlaveSource> (o, var); }
+std::istream& operator>>(std::istream& o, ShuttleBehaviour& var) { return int_to_type<ShuttleBehaviour> (o, var); }
+std::istream& operator>>(std::istream& o, ShuttleUnits& var) { return int_to_type<ShuttleUnits> (o, var); }
+
new_peak = minus_infinity();
}
- if (_session.meter_falloff() == 0.0f || new_peak > _visible_peak_power[n]) {
+ if (Config->get_meter_falloff() == 0.0f || new_peak > _visible_peak_power[n]) {
_visible_peak_power[n] = new_peak;
} else {
// do falloff
- new_peak = _visible_peak_power[n] - _session.meter_falloff();
+ new_peak = _visible_peak_power[n] - Config->get_meter_falloff();
_visible_peak_power[n] = max (new_peak, -INFINITY);
}
}
_splicing = false;
_nudging = false;
in_set_state = false;
- _edit_mode = _session.get_edit_mode();
+ _edit_mode = Config->get_edit_mode();
in_flush = false;
in_partition = false;
subcnt = 0;
// pending_bounds.sort (cmp);
for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
- if (_session.get_layer_model() == Session::MoveAddHigher) {
+ if (Config->get_layer_model() == MoveAddHigher) {
timestamp_layer_op (*r);
}
pending_length = true;
if (holding_state ()) {
pending_bounds.push_back (region);
} else {
- if (_session.get_layer_model() == Session::MoveAddHigher) {
+ if (Config->get_layer_model() == MoveAddHigher) {
/* it moved or changed length, so change the timestamp */
timestamp_layer_op (region);
}
freeze ();
- if (_session.get_layer_model() == Session::MoveAddHigher ||
- _session.get_layer_model() == Session::AddHigher) {
+ if (Config->get_layer_model() == MoveAddHigher ||
+ Config->get_layer_model() == AddHigher) {
RegionSortByLastLayerOp cmp;
RegionList copy = regions;
Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((_session.get_layer_model() == Session::MoveAddHigher) ||
- (_session.get_layer_model() == Session::AddHigher)) {
+ if ((Config->get_layer_model() == MoveAddHigher) ||
+ (Config->get_layer_model() == AddHigher)) {
timestamp_layer_op (region);
relayer ();
}
Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((_session.get_layer_model() == Session::MoveAddHigher) ||
- (_session.get_layer_model() == Session::AddHigher)) {
+ if ((Config->get_layer_model() == MoveAddHigher) ||
+ (Config->get_layer_model() == AddHigher)) {
region->set_last_layer_op (0);
relayer ();
}
// TODO: this is probably wrong
- (no_monitor && record_enabled() && (!_session.get_auto_input() || _session.actively_recording()))
+ (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
) {
// rec-enabled but not s/w monitoring
- (no_monitor && record_enabled() && (!_session.get_auto_input() || _session.actively_recording()))
+ (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
) {
// recording but not s/w monitoring
- (no_monitor && record_enabled() && (!_session.get_auto_input() || _session.actively_recording()))
+ (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
) {
/* relax */
- } else if (no_monitor && record_enabled() && (!_session.get_auto_input() || _session.actively_recording())) {
+ } else if (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording())) {
IO::silence (nframes, offset);
// muted by solo of another track, but not using control outs for solo
- (!solo_audible && (_session.solo_model() != Session::SoloBus)) ||
+ (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
// muted by mute of this track
sigc::signal<void> Session::SendFeedback;
sigc::signal<void> Session::SMPTEOffsetChanged;
-sigc::signal<void> Session::SMPTETypeChanged;
-sigc::signal<void> Session::PullupChanged;
sigc::signal<void> Session::StartTimeChanged;
sigc::signal<void> Session::EndTimeChanged;
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- Config->ParameterChanged.connect (mem_fun (*this, &Session::handle_configuration_change));
+ Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
set_block_size (_engine.frames_per_cycle());
set_frame_rate (_engine.frame_rate());
+ Config->map_parameters (mem_fun (*this, &Session::config_changed));
+
/* every time we reconnect, recompute worst case output latencies */
_engine.Running.connect (mem_fun (*this, &Session::set_worst_io_latencies));
if (_click_io->set_state (*child->children().front()) == 0) {
- _clicking = click_requested;
+ _clicking = Config->get_clicking ();
} else {
if (_click_io->add_output_port (first_physical_output, this)) {
// relax, even though its an error
} else {
- _clicking = click_requested;
+ _clicking = Config->get_clicking ();
}
}
}
set_worst_io_latencies ();
if (_clicking) {
- ControlChanged (Clicking); /* EMIT SIGNAL */
+ // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
}
if (auditioner == 0) {
// return false;
// }
- if (all_safe) {
+ if (Config->get_all_safe()) {
return false;
}
return true;
}
-void
-Session::set_auto_play (bool yn)
-{
- if (auto_play != yn) {
- auto_play = yn;
- set_dirty ();
- ControlChanged (AutoPlay);
- }
-}
-
-void
-Session::set_auto_return (bool yn)
-{
- if (auto_return != yn) {
- auto_return = yn;
- set_dirty ();
- ControlChanged (AutoReturn);
- }
-}
-
-void
-Session::set_crossfades_active (bool yn)
-{
- if (crossfades_active != yn) {
- crossfades_active = yn;
- set_dirty ();
- ControlChanged (CrossFadesActive);
- }
-}
-
-void
-Session::set_do_not_record_plugins (bool yn)
-{
- if (do_not_record_plugins != yn) {
- do_not_record_plugins = yn;
- set_dirty ();
- ControlChanged (RecordingPlugins);
- }
-}
-
-void
-Session::set_auto_input (bool yn)
-{
- if (auto_input != yn) {
- auto_input = yn;
-
- if (Config->get_use_hardware_monitoring() && transport_rolling()) {
- /* auto-input only makes a difference if we're rolling */
-
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->record_enabled ()) {
- //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (!auto_input);
- }
- }
- }
-
- set_dirty();
- ControlChanged (AutoInput);
- }
-}
-
void
Session::reset_input_monitor_state ()
{
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (Config->get_use_hardware_monitoring() && !auto_input);
+ (*i)->monitor_input (Config->get_use_hardware_monitoring() && !Config->get_auto_input());
}
}
} else {
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
- //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
+ //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
(*i)->monitor_input (Config->get_use_hardware_monitoring());
}
}
}
}
-
-void
-Session::set_input_auto_connect (bool yn)
-{
- if (yn) {
- input_auto_connect = AutoConnectOption (input_auto_connect|AutoConnectPhysical);
- } else {
- input_auto_connect = AutoConnectOption (input_auto_connect|~AutoConnectPhysical);
- }
- set_dirty ();
-}
-
-bool
-Session::get_input_auto_connect () const
-{
- return (input_auto_connect & AutoConnectPhysical);
-}
-
-void
-Session::set_output_auto_connect (AutoConnectOption aco)
-{
- output_auto_connect = aco;
- set_dirty ();
-}
-
void
Session::auto_punch_start_changed (Location* location)
{
replace_event (Event::PunchIn, location->start());
- if (get_record_enabled() && get_punch_in()) {
+ if (get_record_enabled() && Config->get_punch_in()) {
/* capture start has been changed, so save new pending state */
save_state ("", true);
}
{
replace_event (Event::AutoLoop, location->end(), location->start());
- if (transport_rolling() && get_auto_loop()) {
+ if (transport_rolling() && play_loop) {
//if (_transport_frame < location->start() || _transport_frame > location->end()) {
request_locate (location->start(), true);
}
- else if (seamless_loop && !loop_changing) {
+ else if (Config->get_seamless_loop() && !loop_changing) {
// schedule a locate-roll to refill the diskstreams at the
// previous loop end
auto_punch_location_changed (location);
}
-void
-Session::set_punch_in (bool yn)
-{
- if (punch_in == yn) {
- return;
- }
-
- Location* location;
-
- if ((location = _locations.auto_punch_location()) != 0) {
- if ((punch_in = yn) == true) {
- replace_event (Event::PunchIn, location->start());
- } else {
- remove_event (location->start(), Event::PunchIn);
- }
- }
-
- set_dirty();
- ControlChanged (PunchIn); /* EMIT SIGNAL */
-}
-
-void
-Session::set_punch_out (bool yn)
-{
- if (punch_out == yn) {
- return;
- }
-
- Location* location;
-
- if ((location = _locations.auto_punch_location()) != 0) {
- if ((punch_out = yn) == true) {
- replace_event (Event::PunchOut, location->end());
- } else {
- clear_events (Event::PunchOut);
- }
- }
-
- set_dirty();
- ControlChanged (PunchOut); /* EMIT SIGNAL */
-}
-
void
Session::set_auto_loop_location (Location* location)
{
_last_record_location = _transport_frame;
send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordStrobe);
- if (Config->get_use_hardware_monitoring() && auto_input) {
+ if (Config->get_use_hardware_monitoring() && Config->get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordExit);
- if (Config->get_use_hardware_monitoring() && auto_input) {
+ if (Config->get_use_hardware_monitoring() && Config->get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (auto_input && (*i)->record_enabled ()) {
+ if (Config->get_auto_input() && (*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
(*i)->monitor_input (false);
}
save_state ("", true);
if (_transport_speed) {
- if (!punch_in) {
+ if (!Config->get_punch_in()) {
enable_record ();
}
} else {
set_dirty();
}
-void
-Session::set_solo_latched (bool yn)
-{
- if (yn != _solo_latched) {
- _solo_latched = yn;
- set_dirty ();
- ControlChanged (SoloLatch);
- }
-}
-
void
Session::update_route_solo_state ()
{
return 0;
}
-void
-Session::set_edit_mode (EditMode mode)
-{
- _edit_mode = mode;
-
- {
- Glib::Mutex::Lock lm (playlist_lock);
-
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
- (*i)->set_edit_mode (mode);
- }
- }
-
- set_dirty ();
- ControlChanged (EditingMode); /* EMIT SIGNAL */
-}
-
void
Session::tempo_map_changed (Change ignored)
{
return playlists.size();
}
-void
-Session::set_solo_model (SoloModel sm)
-{
- if (sm != _solo_model) {
- _solo_model = sm;
- ControlChanged (SoloingModel);
- set_dirty ();
- }
-}
-
void
Session::allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force)
{
return n;
}
-void
-Session::set_layer_model (LayerModel lm)
-{
- if (lm != layer_model) {
- layer_model = lm;
- set_dirty ();
- ControlChanged (LayeringModel);
- }
-}
-
-void
-Session::set_xfade_model (CrossfadeModel xm)
-{
- if (xm != xfade_model) {
- xfade_model = xm;
- set_dirty ();
- ControlChanged (CrossfadingModel);
- }
-}
-
-void
-Session::handle_configuration_change (const char* parameter)
-{
- if (!strcmp (parameter, "use-video-sync")) {
- if (_transport_speed == 0.0f) {
- waiting_for_sync_offset = true;
- }
- }
-}
-
void
Session::add_curve(Curve *curve)
{
click_data = 0;
}
- if (click_sound.length() == 0) {
+ string path = Config->get_click_emphasis_sound();
+
+ if (path.empty()) {
click_data = const_cast<Sample*> (default_click);
click_length = default_click_length;
} else {
- if ((sndfile = sf_open (click_sound.c_str(), SFM_READ, &info)) == 0) {
+ if ((sndfile = sf_open (path.c_str(), SFM_READ, &info)) == 0) {
char errbuf[256];
sf_error_str (0, errbuf, sizeof (errbuf) - 1);
- warning << string_compose (_("cannot open click soundfile %1 (%2)"), click_sound, errbuf) << endmsg;
+ warning << string_compose (_("cannot open click soundfile %1 (%2)"), path, errbuf) << endmsg;
_clicking = false;
return;
}
click_emphasis_data = 0;
}
- if (click_emphasis_sound.length() == 0) {
+ string path = Config->get_click_emphasis_sound();
+
+ if (path.empty()) {
click_emphasis_data = const_cast<Sample*> (default_click_emphasis);
click_emphasis_length = default_click_emphasis_length;
} else {
- if ((sndfile = sf_open (click_emphasis_sound.c_str(), SFM_READ, &info)) == 0) {
+ if ((sndfile = sf_open (path.c_str(), SFM_READ, &info)) == 0) {
char errbuf[256];
sf_error_str (0, errbuf, sizeof (errbuf) - 1);
- warning << string_compose (_("cannot open click emphasis soundfile %1 (%2)"), click_emphasis_sound, errbuf) << endmsg;
+ warning << string_compose (_("cannot open click emphasis soundfile %1 (%2)"), path, errbuf) << endmsg;
return;
}
clicks.clear ();
}
-
-void
-Session::set_click_sound (string path)
-{
- if (path != click_sound) {
- click_sound = path;
- setup_click_sounds (1);
- }
-}
-
-void
-Session::set_click_emphasis_sound (string path)
-{
- if (path != click_emphasis_sound) {
- click_emphasis_sound = path;
- setup_click_sounds (-1);
- }
-}
-
-void
-Session::set_clicking (bool yn)
-{
- if (click_requested != yn) {
- click_requested = yn;
-
- if (yn) {
- if (_click_io && click_data) {
- _clicking = true;
- }
- } else {
- _clicking = false;
- }
-
- ControlChanged (Clicking); /* EMIT SIGNAL */
- }
-}
-
-bool
-Session::get_clicking () const
-{
- return click_requested;
-}
-
switch (ev->type) {
case Event::SetLoop:
- set_auto_loop (ev->yes_or_no);
+ set_play_loop (ev->yes_or_no);
+ break;
+
+ case Event::AutoLoop:
+ if (play_loop) {
+ start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
+ }
+ remove = false;
+ del = false;
break;
case Event::Locate:
case Event::PunchIn:
// cerr << "PunchIN at " << transport_frame() << endl;
- if (punch_in && record_status() == Enabled) {
+ if (Config->get_punch_in() && record_status() == Enabled) {
enable_record ();
}
remove = false;
case Event::PunchOut:
// cerr << "PunchOUT at " << transport_frame() << endl;
- if (punch_out) {
+ if (Config->get_punch_out()) {
step_back_from_record ();
}
remove = false;
del = false;
break;
- case Event::AutoLoop:
- if (auto_loop) {
- start_locate (ev->target_frame, true, false, seamless_loop);
- }
- remove = false;
- del = false;
- break;
-
case Event::Overwrite:
overwrite_some_buffers (static_cast<AudioDiskstream*>(ev->ptr));
break;
break;
case Event::SetSlaveSource:
- set_slave_source (ev->slave, ev->target_frame);
+ set_slave_source (ev->slave);
break;
case Event::Audition:
/* restart slaving */
if (post_export_slave != None) {
- set_slave_source (post_export_slave, post_export_position);
+ Config->set_slave_source (post_export_slave);
} else {
locate (post_export_position, false, false, false);
}
/* no slaving */
- post_export_slave = _slave_type;
+ post_export_slave = Config->get_slave_source ();
post_export_position = _transport_frame;
- set_slave_source (None, 0);
+ Config->set_slave_source (None);
/* get transport ready */
MTC, MMC, etc.
**********************************************************************/
-void
-Session::set_mmc_control (bool yn)
-{
- if (mmc_control == yn) {
- return;
- }
-
- mmc_control = yn;
- set_dirty();
- poke_midi_thread ();
-
- ControlChanged (MMCControl); /* EMIT SIGNAL */
-}
-
-void
-Session::set_midi_control (bool yn)
-{
- if (midi_control == yn) {
- return;
- }
-
- midi_control = yn;
- set_dirty();
- poke_midi_thread ();
-
- ControlChanged (MidiControl); /* EMIT SIGNAL */
-}
-
-void
-Session::set_send_mtc (bool yn)
-{
- /* set the persistent option value regardless */
-
- send_midi_timecode = yn;
- set_dirty();
-
- /* only set the internal flag if we have
- a port.
- */
-
- if (_mtc_port == 0 || send_mtc == yn) {
- return;
- }
-
- send_mtc = yn;
- ControlChanged (SendMTC); /* EMIT SIGNAL */
-}
-
-void
-Session::set_send_mmc (bool yn)
-{
- if (_mmc_port == 0) {
- return;
- }
-
- if (send_midi_machine_control == yn) {
- return;
- }
-
- /* only set the internal flag if we have
- a port.
- */
-
- if (_mmc_port) {
- send_mmc = yn;
- }
-
- /* set the persistent option value regardless */
-
- send_midi_machine_control = yn;
- set_dirty();
-
- ControlChanged (SendMMC); /* EMIT SIGNAL */
-}
-
-void
-Session::set_midi_feedback (bool yn)
-{
-}
-
-bool
-Session::get_midi_feedback () const
-{
- return false;
-}
-
-bool
-Session::get_send_mtc () const
-{
- return send_mtc;
-}
-
-bool
-Session::get_send_mmc () const
-{
- return send_mmc;
-}
-
int
Session::set_mtc_port (string port_tag)
{
if (_mmc_port != 0) {
- send_mmc = send_midi_machine_control;
+ Config->set_send_mmc (session_send_mmc);
} else {
mmc = 0;
- send_mmc = false;
+ session_send_mmc = false;
}
if (_mtc_port != 0) {
- send_mtc = send_midi_timecode;
+ Config->set_send_mtc (session_send_mtc);
} else {
-
- send_mtc = false;
+ session_send_mtc = false;
}
}
void
Session::spp_start (Parser& ignored)
{
- if (mmc_control && (_slave_type != MTC)) {
+ if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
request_transport_speed (1.0);
}
}
void
Session::spp_stop (Parser& ignored)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
request_stop ();
}
}
void
Session::mmc_deferred_play (MIDI::MachineControl &mmc)
{
- if (mmc_control && (_slave_type != MTC)) {
+ if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
request_transport_speed (1.0);
}
}
void
Session::mmc_record_pause (MIDI::MachineControl &mmc)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
maybe_enable_record();
}
}
void
Session::mmc_record_strobe (MIDI::MachineControl &mmc)
{
- if (!mmc_control)
+ if (!Config->get_mmc_control())
return;
/* record strobe does an implicit "Play" command */
void
Session::mmc_record_exit (MIDI::MachineControl &mmc)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
disable_record (false);
}
}
void
Session::mmc_stop (MIDI::MachineControl &mmc)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
request_stop ();
}
}
void
Session::mmc_pause (MIDI::MachineControl &mmc)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
/* We support RECORD_PAUSE, so the spec says that
we must interpret PAUSE like RECORD_PAUSE if
Session::mmc_step (MIDI::MachineControl &mmc, int steps)
{
- if (!mmc_control) {
+ if (!Config->get_mmc_control()) {
return;
}
}
double diff_secs = diff.tv_sec + (diff.tv_usec / 1000000.0);
- double cur_speed = (((steps * 0.5) * smpte_frames_per_second) / diff_secs) / smpte_frames_per_second;
+ double cur_speed = (((steps * 0.5) * Config->get_smpte_frames_per_second()) / diff_secs) / Config->get_smpte_frames_per_second();
if (_transport_speed == 0 || cur_speed * _transport_speed < 0) {
/* change direction */
void
Session::mmc_rewind (MIDI::MachineControl &mmc)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
request_transport_speed(-8.0f);
}
}
void
Session::mmc_fast_forward (MIDI::MachineControl &mmc)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
request_transport_speed(8.0f);
}
}
void
Session::mmc_locate (MIDI::MachineControl &mmc, const MIDI::byte* mmc_tc)
{
- if (!mmc_control) {
+ if (!Config->get_mmc_control()) {
return;
}
void
Session::mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw)
{
- cerr << "MMC shuttle, speed = " << speed << endl;
-
- if (!mmc_control) {
+ if (!Config->get_mmc_control()) {
return;
}
- if (shuttle_speed_threshold >= 0 && speed > shuttle_speed_threshold) {
- speed *= shuttle_speed_factor;
+ if (Config->get_shuttle_speed_threshold() >= 0 && speed > Config->get_shuttle_speed_threshold()) {
+ speed *= Config->get_shuttle_speed_factor();
}
- cerr << "requested MMC control speed = " << speed << endl;
-
if (forw) {
request_transport_speed (speed);
} else {
void
Session::mmc_record_enable (MIDI::MachineControl &mmc, size_t trk, bool enabled)
{
- if (mmc_control) {
+ if (Config->get_mmc_control()) {
RouteList::iterator i;
boost::shared_ptr<RouteList> r = routes.reader();
MIDI::byte msg[10];
SMPTE::Time smpte;
- if (_mtc_port == 0 || !send_mtc) {
+ if (_mtc_port == 0 || !session_send_mtc) {
return 0;
}
int
Session::send_midi_time_code ()
{
- if (_mtc_port == 0 || !send_mtc || transmitting_smpte_time.negative || (next_quarter_frame_to_send < 0) ) {
+ if (_mtc_port == 0 || !session_send_mtc || transmitting_smpte_time.negative || (next_quarter_frame_to_send < 0) ) {
return 0;
}
{
MIDIRequest* request;
- if (_mtc_port == 0 || !send_mmc) {
+ if (_mtc_port == 0 || !session_send_mmc) {
return;
}
int nbytes = 4;
SMPTE::Time smpte;
- if (_mmc_port == 0 || !send_mmc) {
+ if (_mmc_port == 0 || !session_send_mmc) {
return;
}
on the appropriate port.
*/
- if (mmc_control && _mmc_port && _mmc_port->selectable() >= 0) {
+ if (Config->get_mmc_control() && _mmc_port && _mmc_port->selectable() >= 0) {
pfd[nfds].fd = _mmc_port->selectable();
pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
ports[nfds] = _mmc_port;
the relevant port.
*/
- if (_mtc_port && (_mtc_port != _mmc_port || !mmc_control) && _mtc_port->selectable() >= 0) {
+ if (_mtc_port && (_mtc_port != _mmc_port || !Config->get_mmc_control()) && _mtc_port->selectable() >= 0) {
pfd[nfds].fd = _mtc_port->selectable();
pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
ports[nfds] = _mtc_port;
nfds++;
}
- if (_midi_port && (_midi_port != _mmc_port || !mmc_control) && (_midi_port != _mtc_port) && _midi_port->selectable() >= 0) {
+ if (_midi_port && (_midi_port != _mmc_port || !Config->get_mmc_control()) && (_midi_port != _mtc_port) && _midi_port->selectable() >= 0) {
pfd[nfds].fd = _midi_port->selectable();
pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
ports[nfds] = _midi_port;
}
}
-bool
-Session::get_mmc_control () const
-{
- return mmc_control;
-}
-
-bool
-Session::get_midi_control () const
-{
- return midi_control;
-}
summon_butler ();
}
- if (!_engine.freewheeling() && send_mtc) {
+ if (!_engine.freewheeling() && session_send_mtc) {
send_midi_time_code_in_another_thread ();
}
{
Slave* sl = _slave;
- if (!locate_pending() && ((_slave_type == None) || (sl && sl->ok() && sl->locked()))) {
+ if (!locate_pending() && ((Config->get_slave_source() == None) || (sl && sl->ok() && sl->locked()))) {
return true;
}
if (!_slave->ok()) {
stop_transport ();
- set_slave_source (None, 0);
+ Config->set_slave_source (None);
goto noroll;
}
Location* al = _locations.auto_loop_location();
- if (al && auto_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
+ if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
// cancel looping
- request_auto_loop(false);
+ request_play_loop(false);
}
if (slave_transport_frame != _transport_frame) {
// << " tf = " << _transport_frame
// << endl;
- if (_slave_type == JACK) {
+ if (Config->get_slave_source() == JACK) {
last_stop_frame = _transport_frame;
}
} else {
increment_transport_position (frames_moved);
}
-
+
maybe_stop (stop_limit);
check_declick_out ();
summon_butler ();
}
- if (!_engine.freewheeling() && send_mtc) {
+ if (!_engine.freewheeling() && session_send_mtc) {
send_midi_time_code_in_another_thread ();
}
}
char buf[PATH_MAX+1];
- if (!realpath(fullpath.c_str(), buf) && (errno != ENOENT)) {
+ if (!realpath (fullpath.c_str(), buf) && (errno != ENOENT)) {
error << string_compose(_("Could not use path %1 (%s)"), buf, strerror(errno)) << endmsg;
throw failed_constructor();
}
+
_path = string(buf);
if (_path[_path.length()-1] != '/') {
start_location = new Location (0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
_end_location_is_free = true;
g_atomic_int_set (&_record_status, Disabled);
- auto_play = false;
- punch_in = false;
- punch_out = false;
- auto_loop = false;
- seamless_loop = false;
loop_changing = false;
- auto_input = true;
- crossfades_active = false;
- all_safe = false;
- auto_return = false;
+ play_loop = false;
_last_roll_location = 0;
_last_record_location = 0;
pending_locate_frame = 0;
outbound_mtc_smpte_frame = 0;
next_quarter_frame_to_send = -1;
current_block_size = 0;
- _solo_latched = true;
- _solo_model = InverseMute;
solo_update_disabled = false;
currently_soloing = false;
_have_captured = false;
_worst_track_latency = 0;
_state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
_slave = 0;
- _slave_type = None;
butler_mixdown_buffer = 0;
butler_gain_buffer = 0;
- mmc_control = false;
- midi_control = true;
mmc = 0;
+ session_send_mmc = false;
+ session_send_mtc = false;
+ session_midi_feedback = false;
post_transport_work = PostTransportWork (0);
g_atomic_int_set (&butler_should_do_transport_work, 0);
g_atomic_int_set (&butler_active, 0);
g_atomic_int_set (&_capture_load, 100);
g_atomic_int_set (&_playback_load_min, 100);
g_atomic_int_set (&_capture_load_min, 100);
- _edit_mode = Slide;
- pending_edit_mode = _edit_mode;
+ pending_edit_mode = Config->get_edit_mode ();
_play_range = false;
- input_auto_connect = AutoConnectOption (0);
- output_auto_connect = AutoConnectOption (0);
waiting_to_start = false;
_exporting = false;
_gain_automation_buffer = 0;
_pan_automation_buffer = 0;
_npan_buffers = 0;
pending_abort = false;
- layer_model = MoveAddHigher;
- xfade_model = ShortCrossfade;
destructive_index = 0;
current_trans = 0;
-
+
AudioDiskstream::allocate_working_buffers();
/* default short fade = 15ms */
- Crossfade::set_short_xfade_length ((jack_nframes_t) floor ((15.0 * frame_rate()) / 1000.0));
+ Crossfade::set_short_xfade_length ((jack_nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate()));
DestructiveFileSource::setup_standard_crossfades (frame_rate());
last_mmc_step.tv_sec = 0;
last_mmc_step.tv_usec = 0;
step_speed = 0.0;
- preroll.type = AnyTime::Frames;
- preroll.frames = 0;
- postroll.type = AnyTime::Frames;
- postroll.frames = 0;
-
/* click sounds are unset by default, which causes us to internal
waveforms for clicks.
*/
- _clicking = false;
- click_requested = false;
click_data = 0;
click_emphasis_data = 0;
click_length = 0;
click_emphasis_length = 0;
+ _clicking = false;
process_function = &Session::process_with_events;
_current_frame_rate = 48000;
_base_frame_rate = 48000;
- smpte_frames_per_second = 30;
- video_pullup = 0.0;
- smpte_drop_frames = false;
last_smpte_when = 0;
_smpte_offset = 0;
_smpte_offset_negative = true;
last_smpte_valid = false;
+ sync_time_vars ();
+
last_rr_session_dir = session_dirs.begin();
refresh_disk_space ();
// set_default_fade (0.2, 5.0); /* steepness, millisecs */
- /* default configuration */
-
- do_not_record_plugins = false;
- over_length_short = 2;
- over_length_long = 10;
- send_midi_timecode = false;
- send_midi_machine_control = false;
- shuttle_speed_factor = 1.0;
- shuttle_speed_threshold = 5;
- rf_speed = 2.0;
- _meter_hold = 100; // XXX unknown units: number of calls to meter::set()
- _meter_falloff = 0.375f; // XXX unknown units: refresh_rate
- max_level = 0;
- min_level = 0;
-
/* slave stuff */
average_slave_delta = 1800;
delta_accumulator_cnt = 0;
slave_state = Stopped;
- /* default SMPTE type is 30 FPS, non-drop */
-
- set_smpte_type (30.0, false);
- set_video_pullup (0.0);
-
_engine.GraphReordered.connect (mem_fun (*this, &Session::graph_reordered));
/* These are all static "per-class" signals */
return path.substr (0, path.length() - 1); // drop final colon
}
-void
-Session::set_raid_path (string path)
-{
- /* public-access to setup_raid_path() */
-
- setup_raid_path (path);
-}
-
void
Session::setup_raid_path (string path)
{
{
XMLNode* child;
XMLProperty* prop;
- bool have_fade_msecs = false;
- bool have_fade_steepness = false;
- float fade_msecs = 0;
- float fade_steepness = 0;
- SlaveSource slave_src = None;
- int x;
LocaleGuard lg (X_("POSIX"));
-
- if ((child = find_named_node (node, "input-auto-connect")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- sscanf (prop->value().c_str(), "%x", &x);
- input_auto_connect = AutoConnectOption (x);
- }
- }
- if ((child = find_named_node (node, "output-auto-connect")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- sscanf (prop->value().c_str(), "%x", &x);
- output_auto_connect = AutoConnectOption (x);
- }
- }
-
- if ((child = find_named_node (node, "slave")) != 0) {
- if ((prop = child->property ("type")) != 0) {
- if (prop->value() == "none") {
- slave_src = None;
- } else if (prop->value() == "mtc") {
- slave_src = MTC;
- } else if (prop->value() == "jack") {
- slave_src = JACK;
- }
- set_slave_source (slave_src, 0);
- }
- }
+ Config->set_variables (node, ConfigVariableBase::Session);
/* we cannot set edit mode if we are loading a session,
because it might destroy the playlist's positioning
}
}
}
-
- if ((child = find_named_node (node, "send-midi-timecode")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- bool x = (prop->value() == "yes");
- send_mtc = !x; /* force change in value */
- set_send_mtc (x);
- }
- }
- if ((child = find_named_node (node, "send-midi-machine-control")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- bool x = (prop->value() == "yes");
- send_mmc = !x; /* force change in value */
- set_send_mmc (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "max-level")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- max_level = atoi (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "min-level")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- min_level = atoi (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "meter-hold")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- _meter_hold = atof (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "meter-falloff")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- _meter_falloff = atof (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "long-over-length")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- over_length_long = atoi (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "short-over-length")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- over_length_short = atoi (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "shuttle-speed-factor")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- shuttle_speed_factor = atof (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "shuttle-speed-threshold")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- shuttle_speed_threshold = atof (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "rf-speed")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- rf_speed = atof (prop->value().c_str());
- }
- }
- if ((child = find_named_node (node, "video-pullup")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_video_pullup( atof (prop->value().c_str()) );
- }
- }
- if ((child = find_named_node (node, "smpte-frames-per-second")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_smpte_type( atof (prop->value().c_str()), smpte_drop_frames );
- }
- }
- if ((child = find_named_node (node, "smpte-drop-frames")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_smpte_type( smpte_frames_per_second, (prop->value() == "yes") );
- }
- }
- if ((child = find_named_node (node, "smpte-offset")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_smpte_offset( atoi (prop->value().c_str()) );
- }
- }
- if ((child = find_named_node (node, "smpte-offset-negative")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_smpte_offset_negative( (prop->value() == "yes") );
- }
- }
- if ((child = find_named_node (node, "click-sound")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- click_sound = prop->value();
- }
- }
- if ((child = find_named_node (node, "click-emphasis-sound")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- click_emphasis_sound = prop->value();
- }
- }
-
- if ((child = find_named_node (node, "solo-model")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- if (prop->value() == "SoloBus")
- _solo_model = SoloBus;
- else
- _solo_model = InverseMute;
- }
- }
-
- /* BOOLEAN OPTIONS */
-
- if ((child = find_named_node (node, "auto-play")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_auto_play (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "auto-input")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_auto_input (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "seamless-loop")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_seamless_loop (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "punch-in")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_punch_in (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "punch-out")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_punch_out (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "auto-return")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_auto_return (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "send-mtc")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_send_mtc (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "mmc-control")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_mmc_control (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "midi-control")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_midi_control (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "midi-feedback")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_midi_feedback (prop->value() == "yes");
- }
- }
- // Legacy support for <recording-plugins>
- if ((child = find_named_node (node, "recording-plugins")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_do_not_record_plugins (prop->value() == "no");
- }
- }
- if ((child = find_named_node (node, "do-not-record-plugins")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_do_not_record_plugins (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "crossfades-active")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_crossfades_active (prop->value() == "yes");
- }
- }
- if ((child = find_named_node (node, "audible-click")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- set_clicking (prop->value() == "yes");
- }
- }
if ((child = find_named_node (node, "end-marker-is-free")) != 0) {
if ((prop = child->property ("val")) != 0) {
}
}
- if ((child = find_named_node (node, "layer-model")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- if (prop->value() == X_("LaterHigher")) {
- set_layer_model (LaterHigher);
- } else if (prop->value() == X_("AddHigher")) {
- set_layer_model (AddHigher);
- } else {
- set_layer_model (MoveAddHigher);
- }
- }
- }
-
- if ((child = find_named_node (node, "xfade-model")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- if (prop->value() == X_("Short")) {
- set_xfade_model (ShortCrossfade);
- } else {
- set_xfade_model (FullCrossfade);
- }
- }
- }
-
- if ((child = find_named_node (node, "short-xfade-length")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- /* value is stored as a fractional seconds */
- float secs = atof (prop->value().c_str());
- Crossfade::set_short_xfade_length ((jack_nframes_t) floor (secs * frame_rate()));
- }
- }
-
- if ((child = find_named_node (node, "full-xfades-unmuted")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- crossfades_active = (prop->value() == "yes");
- }
- }
-
- /* TIED OPTIONS */
-
- if ((child = find_named_node (node, "default-fade-steepness")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- fade_steepness = atof (prop->value().c_str());
- have_fade_steepness = true;
- }
- }
- if ((child = find_named_node (node, "default-fade-msec")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- fade_msecs = atof (prop->value().c_str());
- have_fade_msecs = true;
- }
- }
-
- if (have_fade_steepness || have_fade_msecs) {
- // set_default_fade (fade_steepness, fade_msecs);
- }
-
return 0;
}
XMLNode&
Session::get_options () const
{
- XMLNode* opthead;
XMLNode* child;
- char buf[32];
LocaleGuard lg (X_("POSIX"));
- opthead = new XMLNode ("Options");
-
- SlaveSource src = slave_source ();
- string src_string;
- switch (src) {
- case None:
- src_string = "none";
- break;
- case MTC:
- src_string = "mtc";
- break;
- case JACK:
- src_string = "jack";
- break;
- }
- child = opthead->add_child ("slave");
- child->add_property ("type", src_string);
-
- child = opthead->add_child ("send-midi-timecode");
- child->add_property ("val", send_midi_timecode?"yes":"no");
+ XMLNode& option_root = Config->get_partial_state (ConfigVariableBase::Interface);
- child = opthead->add_child ("send-midi-machine-control");
- child->add_property ("val", send_midi_machine_control?"yes":"no");
-
- snprintf (buf, sizeof(buf)-1, "%x", (int) input_auto_connect);
- child = opthead->add_child ("input-auto-connect");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%x", (int) output_auto_connect);
- child = opthead->add_child ("output-auto-connect");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%d", max_level);
- child = opthead->add_child ("max-level");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%d", min_level);
- child = opthead->add_child ("min-level");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%f", _meter_hold);
- child = opthead->add_child ("meter-hold");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%f", _meter_falloff);
- child = opthead->add_child ("meter-falloff");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%u", over_length_long);
- child = opthead->add_child ("long-over-length");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%u", over_length_short);
- child = opthead->add_child ("short-over-length");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%f", shuttle_speed_factor);
- child = opthead->add_child ("shuttle-speed-factor");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%f", shuttle_speed_threshold);
- child = opthead->add_child ("shuttle-speed-threshold");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%f", rf_speed);
- child = opthead->add_child ("rf-speed");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%.4f", video_pullup);
- child = opthead->add_child ("video-pullup");
- child->add_property ("val", buf);
-
- snprintf (buf, sizeof(buf)-1, "%.2f", smpte_frames_per_second);
- child = opthead->add_child ("smpte-frames-per-second");
- child->add_property ("val", buf);
-
- child = opthead->add_child ("smpte-drop-frames");
- child->add_property ("val", smpte_drop_frames ? "yes" : "no");
-
- snprintf (buf, sizeof(buf)-1, "%u", smpte_offset ());
- child = opthead->add_child ("smpte-offset");
- child->add_property ("val", buf);
-
- child = opthead->add_child ("smpte-offset-negative");
- child->add_property ("val", smpte_offset_negative () ? "yes" : "no");
-
- child = opthead->add_child ("edit-mode");
- switch (_edit_mode) {
- case Splice:
- child->add_property ("val", "splice");
- break;
-
- case Slide:
- child->add_property ("val", "slide");
- break;
- }
-
- child = opthead->add_child ("auto-play");
- child->add_property ("val", get_auto_play () ? "yes" : "no");
- child = opthead->add_child ("auto-input");
- child->add_property ("val", get_auto_input () ? "yes" : "no");
- child = opthead->add_child ("seamless-loop");
- child->add_property ("val", get_seamless_loop () ? "yes" : "no");
- child = opthead->add_child ("punch-in");
- child->add_property ("val", get_punch_in () ? "yes" : "no");
- child = opthead->add_child ("punch-out");
- child->add_property ("val", get_punch_out () ? "yes" : "no");
- child = opthead->add_child ("all-safe");
- child->add_property ("val", get_all_safe () ? "yes" : "no");
- child = opthead->add_child ("auto-return");
- child->add_property ("val", get_auto_return () ? "yes" : "no");
- child = opthead->add_child ("mmc-control");
- child->add_property ("val", get_mmc_control () ? "yes" : "no");
- child = opthead->add_child ("midi-control");
- child->add_property ("val", get_midi_control () ? "yes" : "no");
- child = opthead->add_child ("midi-feedback");
- child->add_property ("val", get_midi_feedback () ? "yes" : "no");
- child = opthead->add_child ("do-not-record-plugins");
- child->add_property ("val", get_do_not_record_plugins () ? "yes" : "no");
- child = opthead->add_child ("auto-crossfade");
- child->add_property ("val", get_crossfades_active () ? "yes" : "no");
- child = opthead->add_child ("audible-click");
- child->add_property ("val", get_clicking () ? "yes" : "no");
- child = opthead->add_child ("end-marker-is-free");
+ child = option_root.add_child ("end-marker-is-free");
child->add_property ("val", _end_location_is_free ? "yes" : "no");
- if (click_sound.length()) {
- child = opthead->add_child ("click-sound");
- child->add_property ("val", click_sound);
- }
-
- if (click_emphasis_sound.length()) {
- child = opthead->add_child ("click-emphasis-sound");
- child->add_property ("val", click_emphasis_sound);
- }
-
- child = opthead->add_child ("solo-model");
- child->add_property ("val", _solo_model == SoloBus ? "SoloBus" : "InverseMute");
-
- child = opthead->add_child ("layer-model");
- switch (layer_model) {
- case LaterHigher:
- child->add_property ("val", X_("LaterHigher"));
- break;
- case MoveAddHigher:
- child->add_property ("val", X_("MoveAddHigher"));
- break;
- case AddHigher:
- child->add_property ("val", X_("AddHigher"));
- break;
- }
-
- child = opthead->add_child ("xfade-model");
- switch (xfade_model) {
- case FullCrossfade:
- child->add_property ("val", X_("Full"));
- break;
- case ShortCrossfade:
- child->add_property ("val", X_("Short"));
- }
-
- child = opthead->add_child ("short-xfade-length");
- /* store as fractions of a second */
- snprintf (buf, sizeof(buf)-1, "%f",
- (float) Crossfade::short_xfade_length() / frame_rate());
- child->add_property ("val", buf);
+ child = option_root.add_child ("full-xfades-unmuted");
- child = opthead->add_child ("full-xfades-unmuted");
- child->add_property ("val", crossfades_active ? "yes" : "no");
-
- return *opthead;
+ return option_root;
}
XMLNode&
MIDI
Path
extra
- Options
+ Options/Config
Sources
AudioRegions
AudioDiskstreams
if (use_config_midi_ports ()) {
}
- if ((child = find_named_node (node, "Path")) != 0) {
- /* XXX this XML content stuff horrible API design */
- string raid_path = _path + ':' + child->children().front()->content();
- setup_raid_path (raid_path);
- } else {
- /* the path is already set */
- }
-
if ((child = find_named_node (node, "extra")) != 0) {
_extra_xml = new XMLNode (*child);
}
- if ((child = find_named_node (node, "Options")) == 0) {
+ if (((child = find_named_node (node, "Options")) != 0)) { /* old style */
+ load_options (*child);
+ } else if ((child = find_named_node (node, "Config")) != 0) { /* new style */
+ load_options (*child);
+ } else {
error << _("Session: XML state has no options section") << endmsg;
- } else if (load_options (*child)) {
}
if ((child = find_named_node (node, "Sources")) == 0) {
/* OK, now we can set edit mode */
- set_edit_mode (pending_edit_mode);
+ Config->set_edit_mode (pending_edit_mode);
/* here beginneth the second phase ... */
return 0;
}
-void
-Session::set_meter_hold (float val)
-{
- _meter_hold = val;
- MeterHoldChanged(); // emit
-}
-
-void
-Session::set_meter_falloff (float val)
-{
- _meter_falloff = val;
- MeterFalloffChanged(); // emit
-}
-
-
void
Session::begin_reversible_command (string name)
{
return 0;
}
+
+void
+Session::config_changed (const char* parameter_name)
+{
+#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+
+ if (PARAM_IS ("seamless-loop")) {
+
+ } else if (PARAM_IS ("rf-speed")) {
+
+ } else if (PARAM_IS ("auto-loop")) {
+
+ } else if (PARAM_IS ("auto-input")) {
+
+ if (Config->get_use_hardware_monitoring() && transport_rolling()) {
+ /* auto-input only makes a difference if we're rolling */
+
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+ if ((*i)->record_enabled ()) {
+ //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
+ (*i)->monitor_input (!Config->get_auto_input());
+ }
+ }
+ }
+
+ } else if (PARAM_IS ("punch-in")) {
+
+ Location* location;
+
+ if ((location = _locations.auto_punch_location()) != 0) {
+
+ if (Config->get_punch_in ()) {
+ replace_event (Event::PunchIn, location->start());
+ } else {
+ remove_event (location->start(), Event::PunchIn);
+ }
+ }
+
+ } else if (PARAM_IS ("punch-out")) {
+
+ Location* location;
+
+ if ((location = _locations.auto_punch_location()) != 0) {
+
+ if (Config->get_punch_out()) {
+ replace_event (Event::PunchOut, location->end());
+ } else {
+ clear_events (Event::PunchOut);
+ }
+ }
+
+ } else if (PARAM_IS ("edit-mode")) {
+
+ Glib::Mutex::Lock lm (playlist_lock);
+
+ for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ (*i)->set_edit_mode (Config->get_edit_mode ());
+ }
+
+ } else if (PARAM_IS ("use-video-sync")) {
+
+ if (transport_stopped()) {
+ if (Config->get_use_video_sync()) {
+ waiting_for_sync_offset = true;
+ }
+ }
+
+ } else if (PARAM_IS ("mmc-control")) {
+
+ poke_midi_thread ();
+
+ } else if (PARAM_IS ("midi-control")) {
+
+ poke_midi_thread ();
+
+ } else if (PARAM_IS ("raid-path")) {
+
+ setup_raid_path (Config->get_raid_path());
+
+ } else if (PARAM_IS ("smpte-frames-per-second") || PARAM_IS ("smpte-drop-frames")) {
+
+ sync_time_vars ();
+
+ } else if (PARAM_IS ("video-pullup")) {
+
+ sync_time_vars ();
+
+ } else if (PARAM_IS ("seamless-loop")) {
+
+ if (play_loop && transport_rolling()) {
+ // to reset diskstreams etc
+ request_play_loop (true);
+ }
+
+ } else if (PARAM_IS ("rf-speed")) {
+
+ cumulative_rf_motion = 0;
+ reset_rf_scale (0);
+
+ } else if (PARAM_IS ("click-sound")) {
+
+ setup_click_sounds (1);
+
+ } else if (PARAM_IS ("click-emphasis-sound")) {
+
+ setup_click_sounds (-1);
+
+ } else if (PARAM_IS ("clicking")) {
+
+ if (Config->get_clicking()) {
+ if (_click_io && click_data) { // don't require emphasis data
+ _clicking = true;
+ }
+ } else {
+ _clicking = false;
+ }
+
+ } else if (PARAM_IS ("send-mtc")) {
+
+ /* only set the internal flag if we have
+ a port.
+ */
+
+ if (_mtc_port != 0) {
+ session_send_mtc = Config->get_send_mtc();
+ }
+
+ } else if (PARAM_IS ("send-mmc")) {
+
+ /* only set the internal flag if we have
+ a port.
+ */
+
+ if (_mmc_port != 0) {
+ session_send_mmc = Config->get_send_mmc();
+ }
+
+ } else if (PARAM_IS ("midi-feedback")) {
+
+ /* only set the internal flag if we have
+ a port.
+ */
+
+ if (_mtc_port != 0) {
+ session_midi_feedback = Config->get_midi_feedback();
+ }
+
+ }
+
+ set_dirty ();
+
+#undef PARAM_IS
+
+}
void
Session::sync_time_vars ()
{
- _current_frame_rate = (jack_nframes_t) round (_base_frame_rate * (1.0 + (video_pullup/100.0)));
+ _current_frame_rate = (jack_nframes_t) round (_base_frame_rate * (1.0 + (Config->get_video_pullup()/100.0)));
_frames_per_hour = _current_frame_rate * 3600;
- _frames_per_smpte_frame = (double) _current_frame_rate / (double) smpte_frames_per_second;
- _smpte_frames_per_hour = (unsigned long) (smpte_frames_per_second * 3600.0);
+ _frames_per_smpte_frame = (double) _current_frame_rate / (double) Config->get_smpte_frames_per_second();
+ _smpte_frames_per_hour = (unsigned long) (Config->get_smpte_frames_per_second() * 3600.0);
}
int
Session::set_smpte_type (float fps, bool drop_frames)
{
- smpte_frames_per_second = fps;
- smpte_drop_frames = drop_frames;
+ Config->set_smpte_frames_per_second (fps);
+ Config->set_smpte_drop_frames (drop_frames);
last_smpte_valid = false;
// smpte type bits are the middle two in the upper nibble
break;
};
- sync_time_vars();
-
- SMPTETypeChanged (); /* EMIT SIGNAL */
-
- set_dirty();
-
- return 0;
-}
-
-int
-Session::set_video_pullup (float pull)
-{
- video_pullup = pull;
-
- sync_time_vars();
-
- PullupChanged (); /* EMIT SIGNAL */
-
- set_dirty();
-
return 0;
}
void
Session::smpte_to_sample( SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes ) const
{
- if (smpte_drop_frames) {
+ if (Config->get_smpte_drop_frames()) {
// The drop frame format was created to better approximate the 30000/1001 = 29.97002997002997....
// framerate of NTSC color TV. The used frame rate of drop frame is 29.97, which drifts by about
// 0.108 frame per hour, or about 1.3 frames per 12 hours. This is not perfect, but a lot better
// Extract hour-exceeding frames for minute, second and frame calculations
smpte_frames_left = ((long) floor( smpte_frames_left_exact ));
- if (smpte_drop_frames) {
+ if (Config->get_smpte_drop_frames()) {
// See long explanation in smpte_to_sample()...
// Number of 10 minute chunks
}
} else {
// Non drop is easy
- smpte.minutes = smpte_frames_left / ((long) smpte_frames_per_second * 60);
- smpte_frames_left = smpte_frames_left % ((long) smpte_frames_per_second * 60);
- smpte.seconds = smpte_frames_left / (long) smpte_frames_per_second;
- smpte.frames = smpte_frames_left % (long) smpte_frames_per_second;
+ smpte.minutes = smpte_frames_left / ((long) Config->get_smpte_frames_per_second () * 60);
+ smpte_frames_left = smpte_frames_left % ((long) Config->get_smpte_frames_per_second () * 60);
+ smpte.seconds = smpte_frames_left / (long) Config->get_smpte_frames_per_second ();
+ smpte.frames = smpte_frames_left % (long) Config->get_smpte_frames_per_second ();
}
if (!use_subframes) {
#ifdef HAVE_JACK_VIDEO_SUPPORT
//poke audio video ratio so Ardour can track Video Sync
- pos->audio_frames_per_video_frame = frame_rate() / smpte_frames_per_second;
+ pos->audio_frames_per_video_frame = frame_rate() / Config->get_smpte_frames_per_second ();
pos->valid = jack_position_bits_t (pos->valid | JackAudioVideoRatio);
#endif
/* SMPTE info */
t.smpte_offset = _smpte_offset;
- t.smpte_frame_rate = smpte_frames_per_second;
+ t.smpte_frame_rate = Config->get_smpte_frames_per_second ();
if (_transport_speed) {
- if (auto_loop) {
+ if (play_loop) {
Location* location = _locations.auto_loop_location();
secs = any.smpte.hours * 60 * 60;
secs += any.smpte.minutes * 60;
secs += any.smpte.seconds;
- secs += any.smpte.frames / smpte_frames_per_second;
+ secs += any.smpte.frames / Config->get_smpte_frames_per_second ();
if (_smpte_offset_negative)
{
return (jack_nframes_t) floor (secs * frame_rate()) - _smpte_offset;
}
void
-Session::request_slave_source (SlaveSource src, jack_nframes_t pos)
+Session::request_slave_source (SlaveSource src)
{
- Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, pos, 0.0);
+ Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, 0, 0.0);
- if (src == Session::JACK) {
- /* could set_seamless_loop() be disposed of entirely?*/
- set_seamless_loop (false);
+ if (src == JACK) {
+ /* could set_seamless_loop() be disposed of entirely?*/
+ Config->set_seamless_loop (false);
} else {
-
- set_seamless_loop (true);
+ Config->set_seamless_loop (true);
}
ev->slave = src;
queue_event (ev);
}
void
-Session::request_auto_loop (bool yn)
+Session::request_play_loop (bool yn)
{
Event* ev;
Location *location = _locations.auto_loop_location();
ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, 0.0, yn);
queue_event (ev);
- if (!yn && seamless_loop && transport_rolling()) {
+ if (!yn && Config->get_seamless_loop() && transport_rolling()) {
// request an immediate locate to refresh the diskstreams
// after disabling looping
request_locate (_transport_frame-1, true);
}
}
-void
-Session::set_seamless_loop (bool yn)
-{
- if (seamless_loop != yn) {
- seamless_loop = yn;
-
- if (auto_loop && transport_rolling()) {
- // to reset diskstreams etc
- request_auto_loop (true);
- }
-
- ControlChanged (SeamlessLoop); /* EMIT */
- }
-}
-
void
Session::realtime_stop (bool abort)
{
waiting_for_sync_offset = true;
}
- transport_sub_state = (auto_return ? AutoReturning : 0);
+ transport_sub_state = (Config->get_auto_return() ? AutoReturning : 0);
}
void
update_latency_compensation (true, abort);
}
- if (auto_return || (post_transport_work & PostTransportLocate) || synced_to_jack()) {
+ if (Config->get_auto_return() || (post_transport_work & PostTransportLocate) || synced_to_jack()) {
if (pending_locate_flush) {
flush_all_redirects ();
}
- if ((auto_return || synced_to_jack()) && !(post_transport_work & PostTransportLocate)) {
+ if ((Config->get_auto_return() || synced_to_jack()) && !(post_transport_work & PostTransportLocate)) {
_transport_frame = last_stop_frame;
/* and start it up again if relevant */
- if ((post_transport_work & PostTransportLocate) && _slave_type == None && pending_locate_roll) {
+ if ((post_transport_work & PostTransportLocate) && Config->get_slave_source() == None && pending_locate_roll) {
request_transport_speed (1.0);
pending_locate_roll = false;
}
}
void
-Session::set_auto_loop (bool yn)
+Session::set_play_loop (bool yn)
{
/* Called from event-handling context */
set_dirty();
- if (yn && seamless_loop && synced_to_jack()) {
+ if (yn && Config->get_seamless_loop() && synced_to_jack()) {
warning << _("Seamless looping cannot be supported while Ardour is using JACK transport.\n"
"Recommend changing the configured options")
<< endmsg;
}
- if ((auto_loop = yn)) {
+ if ((play_loop = yn)) {
Location *loc;
if ((loc = _locations.auto_loop_location()) != 0) {
- if (seamless_loop) {
+ if (Config->get_seamless_loop()) {
// set all diskstreams to use internal looping
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
}
}
-
- ControlChanged (AutoLoop); /* EMIT SIGNAL */
}
void
}
}
- if (transport_rolling() && !auto_play && !with_roll && !(synced_to_jack() && auto_loop)) {
+ if (transport_rolling() && !Config->get_auto_play() && !with_roll && !(synced_to_jack() && play_loop)) {
realtime_stop (false);
}
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (!auto_input);
+ (*i)->monitor_input (!Config->get_auto_input());
}
}
}
}
}
- /* cancel autoloop if transport pos outside of loop range */
- if (auto_loop) {
+ /* cancel looped playback if transport pos outside of loop range */
+ if (play_loop) {
Location* al = _locations.auto_loop_location();
if (al && (_transport_frame < al->start() || _transport_frame > al->end())) {
// cancel looping directly, this is called from event handling context
- set_auto_loop(false);
+ set_play_loop (false);
}
}
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (auto_input && (*i)->record_enabled ()) {
+ if (Config->get_auto_input() && (*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
(*i)->monitor_input (false);
}
switch (record_status()) {
case Enabled:
- if (!punch_in) {
+ if (!Config->get_punch_in()) {
enable_record ();
}
break;
if (post_transport_work & PostTransportLocate) {
- if ((auto_play && !_exporting) || (post_transport_work & PostTransportRoll)) {
+ if ((Config->get_auto_play() && !_exporting) || (post_transport_work & PostTransportRoll)) {
start_transport ();
post_transport_work = PostTransportWork (0);
}
-void
-Session::set_rf_speed (float speed)
-{
- rf_speed = speed;
- cumulative_rf_motion = 0;
- reset_rf_scale (0);
-}
-
void
Session::reset_rf_scale (jack_nframes_t motion)
{
}
}
-int
-Session::set_slave_source (SlaveSource src, jack_nframes_t frame)
+void
+Session::set_slave_source (SlaveSource src)
{
bool reverse = false;
bool non_rt_required = false;
- if (src == _slave_type) {
- return 0;
- }
-
if (_transport_speed) {
error << _("please stop the transport before adjusting slave settings") << endmsg;
- /* help out non-MVC friendly UI's by telling them the slave type changed */
- ControlChanged (SlaveType); /* EMIT SIGNAL */
- return 0;
+ return;
}
// if (src == JACK && Config->get_jack_time_master()) {
-// return -1;
+// return;
// }
if (_slave) {
delete _slave;
_slave = 0;
- _slave_type = None;
}
if (_transport_speed < 0.0) {
}
catch (failed_constructor& err) {
- return -1;
+ return;
}
} else {
error << _("No MTC port defined: MTC slaving is impossible.") << endmsg;
- return -1;
+ return;
}
_desired_transport_speed = _transport_speed;
break;
_desired_transport_speed = _transport_speed;
break;
};
-
- _slave_type = src;
+ Config->set_slave_source (src);
+
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
}
set_dirty();
- ControlChanged (SlaveType); /* EMIT SIGNAL */
-
- return 0;
}
void
Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
merge_event (ev);
}
-
- ControlChanged (PlayRange); /* EMIT SIGNAL */
}
}
in[0] = 0.0f;
- for (int i = 1; i < nframes - 1; ++i) {
+ for (jack_nframes_t i = 1; i < nframes - 1; ++i) {
in[i] = in[i-1] + step;
}
in[n] = inVal * (scale * inVal + 1.0f - scale);
}
}
+
+SlaveSource
+string_to_slave_source (string str)
+{
+ if (str == _("Internal")) {
+ return None;
+ }
+
+ if (str == _("MTC")) {
+ return MTC;
+ }
+
+ if (str == _("JACK")) {
+ return JACK;
+ }
+
+ fatal << string_compose (_("programming error: unknown slave source string \"%1\""), str) << endmsg;
+ /*NOTREACHED*/
+ return None;
+}
+
+const char*
+slave_source_to_string (SlaveSource src)
+{
+ switch (src) {
+ case JACK:
+ return _("JACK");
+
+ case MTC:
+ return _("MTC");
+
+ default:
+ case None:
+ return _("Internal");
+
+ }
+}
void
BasicUI::loop_toggle ()
{
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (Config->get_auto_loop()) {
+ session->request_play_loop (false);
} else {
- session->request_auto_loop (true);
+ session->request_play_loop (true);
if (!session->transport_rolling()) {
session->request_transport_speed (1.0);
}
{
bool rolling = session->transport_rolling ();
- if (session->get_auto_loop()) {
- session->request_auto_loop (false);
+ if (Config->get_auto_loop()) {
+ session->request_play_loop (false);
}
if (session->get_play_range ()) {
void
BasicUI::toggle_punch_in ()
{
- session->set_punch_in (!session->get_punch_in());
+ Config->set_punch_in (!Config->get_punch_in());
}
void
BasicUI::toggle_punch_out ()
{
- session->set_punch_out (!session->get_punch_out());
+ Config->set_punch_out (!Config->get_punch_out());
}
bool
projects / ardour.git / commitdiff