X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui_options.cc;h=4c1aae1583b46480fb377e58fe5e89f034474c5f;hb=9a8eda6930aef71a17456704967a9f0b2e7b1769;hp=7a3ebfc13059495418743260e2f4a801a44d3fc1;hpb=0b6139304ba628d63bfcad3a868fd5757bb6478c;p=ardour.git diff --git a/gtk2_ardour/ardour_ui_options.cc b/gtk2_ardour/ardour_ui_options.cc index 7a3ebfc130..4c1aae1583 100644 --- a/gtk2_ardour/ardour_ui_options.cc +++ b/gtk2_ardour/ardour_ui_options.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2005 Paul Davis + Copyright (C) 2005 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,10 +15,10 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #include +#include #include @@ -26,9 +26,14 @@ #include #include +#ifdef HAVE_LIBLO +#include +#endif + #include "ardour_ui.h" #include "actions.h" #include "gui_thread.h" +#include "public_editor.h" #include "i18n.h" @@ -63,9 +68,15 @@ ARDOUR_UI::toggle_use_mmc () } void -ARDOUR_UI::toggle_use_midi_control () +ARDOUR_UI::toggle_use_midi_clock () +{ + ActionManager::toggle_config_state ("options", "UseMIDIClock", &Configuration::set_midi_clock_control, &Configuration::get_midi_clock_control); +} + +void +ARDOUR_UI::toggle_use_osc () { - ActionManager::toggle_config_state ("options", "UseMIDIcontrol", &Configuration::set_midi_control, &Configuration::get_midi_control); + ActionManager::toggle_config_state ("options", "UseOSC", &Configuration::set_use_osc, &Configuration::get_use_osc); } void @@ -74,10 +85,23 @@ ARDOUR_UI::toggle_send_midi_feedback () ActionManager::toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback); } +void +ARDOUR_UI::toggle_denormal_protection () +{ + ActionManager::toggle_config_state ("options", "DenormalProtection", &Configuration::set_denormal_protection, &Configuration::get_denormal_protection); +} + +void +ARDOUR_UI::toggle_only_copy_imported_files () +{ + ActionManager::toggle_config_state ("options", "OnlyCopyImportedFiles", &Configuration::set_only_copy_imported_files, &Configuration::get_only_copy_imported_files); +} + + void ARDOUR_UI::set_native_file_header_format (HeaderFormat hf) { - const char *action; + const char *action = 0; switch (hf) { case BWF: @@ -101,6 +125,9 @@ ARDOUR_UI::set_native_file_header_format (HeaderFormat hf) case AIFF: action = X_("FileHeaderFormatAIFF"); break; + default: + fatal << string_compose (_("programming error: %1"), "illegal file header format in ::set_native_file_header_format") << endmsg; + /*NOTREACHED*/ } Glib::RefPtr act = ActionManager::get_action ("options", action); @@ -116,7 +143,7 @@ ARDOUR_UI::set_native_file_header_format (HeaderFormat hf) void ARDOUR_UI::set_native_file_data_format (SampleFormat sf) { - const char* action; + const char* action = 0; switch (sf) { case FormatFloat: @@ -125,6 +152,12 @@ ARDOUR_UI::set_native_file_data_format (SampleFormat sf) case FormatInt24: action = X_("FileDataFormat24bit"); break; + case FormatInt16: + action = X_("FileDataFormat16bit"); + break; + default: + fatal << string_compose (_("programming error: %1"), "illegal file data format in ::set_native_file_data_format") << endmsg; + /*NOTREACHED*/ } Glib::RefPtr act = ActionManager::get_action ("options", action); @@ -141,7 +174,7 @@ void ARDOUR_UI::set_input_auto_connect (AutoConnectOption option) { const char* action; - + switch (option) { case AutoConnectPhysical: action = X_("InputAutoConnectPhysical"); @@ -165,7 +198,7 @@ void ARDOUR_UI::set_output_auto_connect (AutoConnectOption option) { const char* action; - + switch (option) { case AutoConnectPhysical: action = X_("OutputAutoConnectPhysical"); @@ -197,7 +230,7 @@ ARDOUR_UI::set_solo_model (SoloModel model) case SoloBus: action = X_("SoloViaBus"); break; - + case InverseMute: action = X_("SoloInPlace"); break; @@ -218,6 +251,39 @@ ARDOUR_UI::set_solo_model (SoloModel model) } +void +ARDOUR_UI::set_remote_model (RemoteModel model) +{ + const char* action = 0; + + switch (model) { + case UserOrdered: + action = X_("RemoteUserDefined"); + break; + case MixerOrdered: + action = X_("RemoteMixerDefined"); + break; + case EditorOrdered: + action = X_("RemoteEditorDefined"); + break; + + default: + fatal << string_compose (_("programming error: unknown remote model in ARDOUR_UI::set_remote_model: %1"), model) << endmsg; + /*NOTREACHED*/ + } + + Glib::RefPtr act = ActionManager::get_action ("options", action); + + if (act) { + Glib::RefPtr ract = Glib::RefPtr::cast_dynamic(act); + + if (ract && ract->get_active() && Config->get_remote_model() != model) { + Config->set_remote_model (model); + } + } + +} + void ARDOUR_UI::set_monitor_model (MonitorModel model) { @@ -227,7 +293,7 @@ ARDOUR_UI::set_monitor_model (MonitorModel model) case HardwareMonitoring: action = X_("UseHardwareMonitoring"); break; - + case SoftwareMonitoring: action = X_("UseSoftwareMonitoring"); break; @@ -236,7 +302,7 @@ ARDOUR_UI::set_monitor_model (MonitorModel model) break; default: - fatal << string_compose (_("programming error: unknown solo model in ARDOUR_UI::set_solo_model: %1"), model) << endmsg; + fatal << string_compose (_("programming error: unknown monitor model in ARDOUR_UI::set_monitor_model: %1"), model) << endmsg; /*NOTREACHED*/ } @@ -252,6 +318,45 @@ ARDOUR_UI::set_monitor_model (MonitorModel model) } +void +ARDOUR_UI::set_denormal_model (DenormalModel model) +{ + const char* action = 0; + + switch (model) { + case DenormalNone: + action = X_("DenormalNone"); + break; + + case DenormalFTZ: + action = X_("DenormalFTZ"); + break; + + case DenormalDAZ: + action = X_("DenormalDAZ"); + break; + + case DenormalFTZDAZ: + action = X_("DenormalFTZDAZ"); + break; + + default: + fatal << string_compose (_("programming error: unknown denormal model in ARDOUR_UI::set_denormal_model: %1"), model) << endmsg; + /*NOTREACHED*/ + } + + Glib::RefPtr act = ActionManager::get_action ("options", action); + + if (act) { + Glib::RefPtr ract = Glib::RefPtr::cast_dynamic(act); + + if (ract && ract->get_active() && Config->get_denormal_model() != model) { + Config->set_denormal_model (model); + } + } + +} + void ARDOUR_UI::toggle_auto_input () { @@ -280,7 +385,7 @@ void ARDOUR_UI::toggle_session_auto_loop () { if (session) { - if (Config->get_auto_loop()) { + if (session->get_play_loop()) { if (session->transport_rolling()) { transport_roll(); } else { @@ -292,6 +397,52 @@ ARDOUR_UI::toggle_session_auto_loop () } } +void +ARDOUR_UI::unset_dual_punch () +{ + Glib::RefPtr action = ActionManager::get_action ("Transport", "TogglePunch"); + + if (action) { + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(action); + if (tact) { + ignore_dual_punch = true; + tact->set_active (false); + ignore_dual_punch = false; + } + } +} + +void +ARDOUR_UI::toggle_punch () +{ + if (ignore_dual_punch) { + return; + } + + Glib::RefPtr action = ActionManager::get_action ("Transport", "TogglePunch"); + + if (action) { + + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(action); + + if (!tact) { + return; + } + + /* drive the other two actions from this one */ + + Glib::RefPtr in_action = ActionManager::get_action ("Transport", "TogglePunchIn"); + Glib::RefPtr out_action = ActionManager::get_action ("Transport", "TogglePunchOut"); + + if (in_action && out_action) { + Glib::RefPtr tiact = Glib::RefPtr::cast_dynamic(in_action); + Glib::RefPtr toact = Glib::RefPtr::cast_dynamic(out_action); + tiact->set_active (tact->get_active()); + toact->set_active (tact->get_active()); + } + } +} + void ARDOUR_UI::toggle_punch_in () { @@ -340,6 +491,12 @@ ARDOUR_UI::toggle_LatchedRecordEnable() ActionManager::toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable); } +void +ARDOUR_UI::toggle_RegionEquivalentsOverlap() +{ + ActionManager::toggle_config_state ("options", "RegionEquivalentsOverlap", &Configuration::set_use_overlap_equivalency, &Configuration::get_use_overlap_equivalency); +} + void ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording() { @@ -352,12 +509,30 @@ ARDOUR_UI::toggle_VerifyRemoveLastCapture() ActionManager::toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture); } +void +ARDOUR_UI::toggle_PeriodicSafetyBackups() +{ + ActionManager::toggle_config_state ("options", "PeriodicSafetyBackups", &Configuration::set_periodic_safety_backups, &Configuration::get_periodic_safety_backups); +} + void ARDOUR_UI::toggle_StopRecordingOnXrun() { ActionManager::toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun, &Configuration::get_stop_recording_on_xrun); } +void +ARDOUR_UI::toggle_CreateXrunMarker() +{ + ActionManager::toggle_config_state ("options", "CreateXrunMarker", &Configuration::set_create_xrun_marker, &Configuration::get_create_xrun_marker); +} + +void +ARDOUR_UI::toggle_sync_order_keys () +{ + ActionManager::toggle_config_state ("options", "SyncEditorAndMixerTrackOrder", &Configuration::set_sync_all_route_ordering, &Configuration::get_sync_all_route_ordering); +} + void ARDOUR_UI::toggle_StopTransportAtEndOfSession() { @@ -367,15 +542,7 @@ ARDOUR_UI::toggle_StopTransportAtEndOfSession() void ARDOUR_UI::toggle_GainReduceFastTransport() { - Glib::RefPtr act = ActionManager::get_action ("options", "GainReduceFastTransport"); - if (act) { - Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); - if (tact->get_active()) { - Config->set_quieten_at_speed (0.251189); // -12dB reduction for ffwd or rewind - } else { - Config->set_quieten_at_speed (1.0); /* no change */ - } - } + ActionManager::toggle_config_state ("options", "GainReduceFastTransport", &Configuration::set_quieten_at_speed, &Configuration::get_quieten_at_speed); } void @@ -384,10 +551,65 @@ ARDOUR_UI::toggle_LatchedSolo() ActionManager::toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched); } +void +ARDOUR_UI::toggle_ShowSoloMutes() +{ + ActionManager::toggle_config_state ("options", "ShowSoloMutes", &Configuration::set_show_solo_mutes, &Configuration::get_show_solo_mutes); +} + +void +ARDOUR_UI::toggle_PrimaryClockDeltaEditCursor() +{ + ActionManager::toggle_config_state ("options", "PrimaryClockDeltaEditCursor", &Configuration::set_primary_clock_delta_edit_cursor, &Configuration::get_primary_clock_delta_edit_cursor); +} + +void +ARDOUR_UI::toggle_SecondaryClockDeltaEditCursor() +{ + ActionManager::toggle_config_state ("options", "SecondaryClockDeltaEditCursor", &Configuration::set_secondary_clock_delta_edit_cursor, &Configuration::get_secondary_clock_delta_edit_cursor); +} + +void +ARDOUR_UI::toggle_ShowTrackMeters() +{ + ActionManager::toggle_config_state ("options", "ShowTrackMeters", &Configuration::set_show_track_meters, &Configuration::get_show_track_meters); +} + +void +ARDOUR_UI::toggle_TapeMachineMode () +{ + ActionManager::toggle_config_state ("options", "ToggleTapeMachineMode", &Configuration::set_tape_machine_mode, &Configuration::get_tape_machine_mode); +} + +void +ARDOUR_UI::toggle_use_narrow_ms() +{ + ActionManager::toggle_config_state ("options", "DefaultNarrowMS", &Configuration::set_default_narrow_ms, &Configuration::get_default_narrow_ms); +} + +void +ARDOUR_UI::toggle_NameNewMarkers() +{ + ActionManager::toggle_config_state ("options", "NameNewMarkers", &Configuration::set_name_new_markers, &Configuration::get_name_new_markers); +} + +void +ARDOUR_UI::toggle_rubberbanding_snaps_to_grid () +{ + ActionManager::toggle_config_state ("options", "RubberbandingSnapsToGrid", &Configuration::set_rubberbanding_snaps_to_grid, &Configuration::get_rubberbanding_snaps_to_grid); +} + +void +ARDOUR_UI::toggle_auto_analyse_audio () +{ + ActionManager::toggle_config_state ("options", "AutoAnalyseAudio", &Configuration::set_auto_analyse_audio, &Configuration::get_auto_analyse_audio); +} + void ARDOUR_UI::mtc_port_changed () { bool have_mtc; + bool have_midi_clock; if (session) { if (session->mtc_port()) { @@ -395,8 +617,14 @@ ARDOUR_UI::mtc_port_changed () } else { have_mtc = false; } + if (session->midi_clock_port()) { + have_midi_clock = true; + } else { + have_midi_clock = false; + } } else { have_mtc = false; + have_midi_clock = false; } positional_sync_strings.clear (); @@ -404,8 +632,11 @@ ARDOUR_UI::mtc_port_changed () if (have_mtc) { positional_sync_strings.push_back (slave_source_to_string (MTC)); } + if (have_midi_clock) { + positional_sync_strings.push_back (slave_source_to_string (MIDIClock)); + } positional_sync_strings.push_back (slave_source_to_string (JACK)); - + set_popdown_strings (sync_option_combo, positional_sync_strings); } @@ -424,9 +655,9 @@ ARDOUR_UI::map_solo_model () const char* on; if (Config->get_solo_model() == InverseMute) { - on = "SoloInPlace"; + on = X_("SoloInPlace"); } else { - on = "SoloViaBus"; + on = X_("SoloViaBus"); } Glib::RefPtr act = ActionManager::get_action ("options", on); @@ -466,6 +697,76 @@ ARDOUR_UI::map_monitor_model () } } +void +ARDOUR_UI::map_denormal_protection () +{ + Glib::RefPtr act = ActionManager::get_action ("options", X_("DenormalProtection")); + if (act) { + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); + + if (tact && !tact->get_active()) { + tact->set_active (Config->get_denormal_protection()); + } + } +} + +void +ARDOUR_UI::map_denormal_model () +{ + const char* on = 0; + + switch (Config->get_denormal_model()) { + case DenormalNone: + on = X_("DenormalNone"); + break; + case DenormalFTZ: + on = X_("DenormalFTZ"); + break; + case DenormalDAZ: + on = X_("DenormalDAZ"); + break; + case DenormalFTZDAZ: + on = X_("DenormalFTZDAZ"); + break; + } + + Glib::RefPtr act = ActionManager::get_action ("options", on); + if (act) { + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); + + if (tact && !tact->get_active()) { + tact->set_active (true); + } + } +} + +void +ARDOUR_UI::map_remote_model () +{ + const char* on = 0; + + switch (Config->get_remote_model()) { + case UserOrdered: + on = X_("RemoteUserDefined"); + break; + case MixerOrdered: + on = X_("RemoteMixerDefined"); + break; + case EditorOrdered: + on = X_("RemoteEditorDefined"); + break; + } + + Glib::RefPtr act = ActionManager::get_action ("options", on); + if (act) { + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); + + if (tact && !tact->get_active()) { + tact->set_active (true); + } + } +} + void ARDOUR_UI::map_file_header_format () { @@ -497,7 +798,7 @@ ARDOUR_UI::map_file_header_format () break; default: - fatal << string_compose (_("programming error: unknown file header format passed to ARDOUR_UI::map_file_data_format: %1"), + fatal << string_compose (_("programming error: unknown file header format passed to ARDOUR_UI::map_file_data_format: %1"), Config->get_native_file_header_format()) << endmsg; /*NOTREACHED*/ } @@ -528,8 +829,12 @@ ARDOUR_UI::map_file_data_format () action = X_("FileDataFormat24bit"); break; + case FormatInt16: + action = X_("FileDataFormat16bit"); + break; + default: - fatal << string_compose (_("programming error: unknown file data format passed to ARDOUR_UI::map_file_data_format: %1"), + fatal << string_compose (_("programming error: unknown file data format passed to ARDOUR_UI::map_file_data_format: %1"), Config->get_native_file_data_format()) << endmsg; /*NOTREACHED*/ } @@ -583,7 +888,7 @@ ARDOUR_UI::map_output_auto_connect () Glib::RefPtr act = ActionManager::get_action ("options", on); if (act) { Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); - + if (tact && !tact->get_active()) { tact->set_active (true); } @@ -591,14 +896,27 @@ ARDOUR_UI::map_output_auto_connect () } void -ARDOUR_UI::map_meter_falloff () +ARDOUR_UI::map_only_copy_imported_files () { - const char* action = 0; + Glib::RefPtr act = ActionManager::get_action ("options", X_("OnlyCopyImportedFiles")); + if (act) { + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic(act); - /* XXX hack alert. Fix this. Please */ + if (tact && !tact->get_active()) { + tact->set_active (Config->get_only_copy_imported_files()); + } + } + +} + + +void +ARDOUR_UI::map_meter_falloff () +{ + const char* action = X_("MeterFalloffMedium"); float val = Config->get_meter_falloff (); - MeterFalloff code = (MeterFalloff) (floor (val)); + MeterFalloff code = meter_falloff_from_float(val); switch (code) { case MeterFalloffOff: @@ -637,12 +955,12 @@ ARDOUR_UI::map_meter_falloff () void ARDOUR_UI::map_meter_hold () { - const char* action = 0; + const char* action = X_("MeterHoldMedium"); /* XXX hack alert. Fix this. Please */ float val = Config->get_meter_hold (); - MeterHold code = (MeterHold) (floor (val)); + MeterHold code = (MeterHold) (int) (floor (val)); switch (code) { case MeterHoldOff: @@ -669,7 +987,7 @@ ARDOUR_UI::map_meter_hold () } } -void +void ARDOUR_UI::set_meter_hold (MeterHold val) { const char* action = 0; @@ -693,7 +1011,7 @@ ARDOUR_UI::set_meter_hold (MeterHold val) } Glib::RefPtr act = ActionManager::get_action (X_("options"), action); - + if (act) { Glib::RefPtr ract = Glib::RefPtr::cast_dynamic(act); if (ract && ract->get_active() && Config->get_meter_hold() != fval) { @@ -747,7 +1065,7 @@ ARDOUR_UI::set_meter_falloff (MeterFalloff val) void ARDOUR_UI::parameter_changed (const char* parameter_name) { - cerr << "Parameter changed : " << parameter_name << endl; + ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::parameter_changed), parameter_name)); #define PARAM_IS(x) (!strcmp (parameter_name, (x))) @@ -755,6 +1073,19 @@ ARDOUR_UI::parameter_changed (const char* parameter_name) sync_option_combo.set_active_text (slave_source_to_string (Config->get_slave_source())); + switch (Config->get_slave_source()) { + case None: + ActionManager::get_action ("Transport", "ToggleAutoPlay")->set_sensitive (true); + ActionManager::get_action ("Transport", "ToggleAutoReturn")->set_sensitive (true); + break; + + default: + /* XXX need to make auto-play is off as well as insensitive */ + ActionManager::get_action ("Transport", "ToggleAutoPlay")->set_sensitive (false); + ActionManager::get_action ("Transport", "ToggleAutoReturn")->set_sensitive (false); + break; + } + } else if (PARAM_IS ("send-mtc")) { ActionManager::map_some_state ("options", "SendMTC", &Configuration::get_send_mtc); @@ -763,32 +1094,52 @@ ARDOUR_UI::parameter_changed (const char* parameter_name) ActionManager::map_some_state ("options", "SendMMC", &Configuration::get_send_mmc); + } else if (PARAM_IS ("use-osc")) { + +#ifdef HAVE_LIBLO + if (Config->get_use_osc()) { + osc->start (); + } else { + osc->stop (); + } +#endif + + ActionManager::map_some_state ("options", "UseOSC", &Configuration::get_use_osc); + } else if (PARAM_IS ("mmc-control")) { ActionManager::map_some_state ("options", "UseMMC", &Configuration::get_mmc_control); + } else if (PARAM_IS ("midi-clock-control")) { + ActionManager::map_some_state ("options", "UseMIDIClock", &Configuration::get_midi_clock_control); } else if (PARAM_IS ("midi-feedback")) { ActionManager::map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback); - } else if (PARAM_IS ("midi-control")) { - ActionManager::map_some_state ("options", "UseMIDIcontrol", &Configuration::get_midi_control); } else if (PARAM_IS ("do-not-record-plugins")) { ActionManager::map_some_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::get_do_not_record_plugins); } else if (PARAM_IS ("latched-record-enable")) { ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable); } else if (PARAM_IS ("solo-latched")) { ActionManager::map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched); + } else if (PARAM_IS ("show-solo-mutes")) { + ActionManager::map_some_state ("options", "ShowSoloMutes", &Configuration::get_show_solo_mutes); } else if (PARAM_IS ("solo-model")) { map_solo_model (); } else if (PARAM_IS ("auto-play")) { ActionManager::map_some_state ("Transport", "ToggleAutoPlay", &Configuration::get_auto_play); - } else if (PARAM_IS ("auto-loop")) { - ActionManager::map_some_state ("Transport", "Loop", &Configuration::get_auto_loop); } else if (PARAM_IS ("auto-return")) { ActionManager::map_some_state ("Transport", "ToggleAutoReturn", &Configuration::get_auto_return); } else if (PARAM_IS ("auto-input")) { ActionManager::map_some_state ("Transport", "ToggleAutoInput", &Configuration::get_auto_input); + } else if (PARAM_IS ("tape-machine-mode")) { + ActionManager::map_some_state ("options", "ToggleTapeMachineMode", &Configuration::get_tape_machine_mode); } else if (PARAM_IS ("punch-out")) { ActionManager::map_some_state ("Transport", "TogglePunchOut", &Configuration::get_punch_out); + if (!Config->get_punch_out()) { + unset_dual_punch (); + } } else if (PARAM_IS ("punch-in")) { ActionManager::map_some_state ("Transport", "TogglePunchIn", &Configuration::get_punch_in); + if (!Config->get_punch_in()) { + unset_dual_punch (); + } } else if (PARAM_IS ("clicking")) { ActionManager::map_some_state ("Transport", "ToggleClick", &Configuration::get_clicking); } else if (PARAM_IS ("jack-time-master")) { @@ -799,12 +1150,24 @@ ARDOUR_UI::parameter_changed (const char* parameter_name) ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable); } else if (PARAM_IS ("verify-remove-last-capture")) { ActionManager::map_some_state ("options", "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture); + } else if (PARAM_IS ("periodic-safety-backups")) { + ActionManager::map_some_state ("options", "PeriodicSafetyBackups", &Configuration::get_periodic_safety_backups); } else if (PARAM_IS ("stop-recording-on-xrun")) { ActionManager::map_some_state ("options", "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun); + } else if (PARAM_IS ("create-xrun-marker")) { + ActionManager::map_some_state ("options", "CreateXrunMarker", &Configuration::get_create_xrun_marker); + } else if (PARAM_IS ("sync-all-route-ordering")) { + ActionManager::map_some_state ("options", "SyncEditorAndMixerTrackOrder", &Configuration::get_sync_all_route_ordering); } else if (PARAM_IS ("stop-at-session-end")) { ActionManager::map_some_state ("options", "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end); } else if (PARAM_IS ("monitoring-model")) { map_monitor_model (); + } else if (PARAM_IS ("denormal-model")) { + map_denormal_model (); + } else if (PARAM_IS ("denormal-protection")) { + map_denormal_protection (); + } else if (PARAM_IS ("remote-model")) { + map_remote_model (); } else if (PARAM_IS ("use-video-sync")) { ActionManager::map_some_state ("Transport", "ToggleVideoSync", &Configuration::get_use_video_sync); } else if (PARAM_IS ("quieten-at-speed")) { @@ -829,7 +1192,7 @@ ARDOUR_UI::parameter_changed (const char* parameter_name) } } else if (PARAM_IS ("shuttle-units")) { - + switch (Config->get_shuttle_units()) { case Percentage: shuttle_units_button.set_label("% "); @@ -850,9 +1213,32 @@ ARDOUR_UI::parameter_changed (const char* parameter_name) map_meter_hold (); } else if (PARAM_IS ("meter-falloff")) { map_meter_falloff (); - } else if (PARAM_IS ("verify-remove-last-capture")) { - ActionManager::map_some_state ("options", "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture); + } else if (PARAM_IS ("video-pullup") || PARAM_IS ("smpte-format")) { + if (session) { + primary_clock.set (session->audible_frame(), true); + secondary_clock.set (session->audible_frame(), true); + } else { + primary_clock.set (0, true); + secondary_clock.set (0, true); + } + } else if (PARAM_IS ("use-overlap-equivalency")) { + ActionManager::map_some_state ("options", "RegionEquivalentsOverlap", &Configuration::get_use_overlap_equivalency); + } else if (PARAM_IS ("primary-clock-delta-edit-cursor")) { + ActionManager::map_some_state ("options", "PrimaryClockDeltaEditCursor", &Configuration::get_primary_clock_delta_edit_cursor); + } else if (PARAM_IS ("secondary-clock-delta-edit-cursor")) { + ActionManager::map_some_state ("options", "SecondaryClockDeltaEditCursor", &Configuration::get_secondary_clock_delta_edit_cursor); + } else if (PARAM_IS ("only-copy-imported-files")) { + map_only_copy_imported_files (); + } else if (PARAM_IS ("show-track-meters")) { + ActionManager::map_some_state ("options", "ShowTrackMeters", &Configuration::get_show_track_meters); + editor->toggle_meter_updating(); + } else if (PARAM_IS ("default-narrow_ms")) { + ActionManager::map_some_state ("options", "DefaultNarrowMS", &Configuration::get_default_narrow_ms); + } else if (PARAM_IS ("rubberbanding-snaps-to-grid")) { + ActionManager::map_some_state ("options", "RubberbandingSnapsToGrid", &Configuration::get_rubberbanding_snaps_to_grid); } + + #undef PARAM_IS }