gtk2_ardour/ardour_ui_options.cc

   1 /*
   2     Copyright (C) 2005 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <pbd/convert.h>
  21 #include <pbd/stacktrace.h>
  22
  23 #include <gtkmm2ext/utils.h>
  24
  25 #include <ardour/configuration.h>
  26 #include <ardour/session.h>
  27 #include <ardour/osc.h>
  28 #include <ardour/audioengine.h>
  29
  30 #include "ardour_ui.h"
  31 #include "actions.h"
  32 #include "gui_thread.h"
  33 #include "public_editor.h"
  34
  35 #include "i18n.h"
  36
  37 using namespace Gtk;
  38 using namespace Gtkmm2ext;
  39 using namespace ARDOUR;
  40 using namespace PBD;
  41 using namespace sigc;
  42
  43 void
  44 ARDOUR_UI::toggle_time_master ()
  45 {
  46         ActionManager::toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master, &Configuration::get_jack_time_master);
  47 }
  48
  49 void
  50 ARDOUR_UI::toggle_send_mtc ()
  51 {
  52         ActionManager::toggle_config_state ("options", "SendMTC", &Configuration::set_send_mtc, &Configuration::get_send_mtc);
  53 }
  54
  55 void
  56 ARDOUR_UI::toggle_send_mmc ()
  57 {
  58         ActionManager::toggle_config_state ("options", "SendMMC", &Configuration::set_send_mmc, &Configuration::get_send_mmc);
  59 }
  60
  61 void
  62 ARDOUR_UI::toggle_use_mmc ()
  63 {
  64         ActionManager::toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
  65 }
  66
  67 void
  68 ARDOUR_UI::toggle_use_osc ()
  69 {
  70         ActionManager::toggle_config_state ("options", "UseOSC", &Configuration::set_use_osc, &Configuration::get_use_osc);
  71 }
  72
  73 void
  74 ARDOUR_UI::toggle_send_midi_feedback ()
  75 {
  76         ActionManager::toggle_config_state ("options", "SendMIDIfeedback", &Configuration::set_midi_feedback, &Configuration::get_midi_feedback);
  77 }
  78
  79 void
  80 ARDOUR_UI::toggle_denormal_protection ()
  81 {
  82         ActionManager::toggle_config_state ("options", "DenormalProtection", &Configuration::set_denormal_protection, &Configuration::get_denormal_protection);
  83 }
  84
  85 void
  86 ARDOUR_UI::toggle_only_copy_imported_files ()
  87 {
  88         ActionManager::toggle_config_state ("options", "OnlyCopyImportedFiles", &Configuration::set_only_copy_imported_files, &Configuration::get_only_copy_imported_files);
  89 }
  90
  91 void
  92 ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
  93 {
  94         const char *action = 0;
  95
  96         switch (hf) {
  97         case BWF:
  98                 action = X_("FileHeaderFormatBWF");
  99                 break;
 100         case WAVE:
 101                 action = X_("FileHeaderFormatWAVE");
 102                 break;
 103         case WAVE64:
 104                 action = X_("FileHeaderFormatWAVE64");
 105                 break;
 106         case iXML:
 107                 action = X_("FileHeaderFormatiXML");
 108                 break;
 109         case RF64:
 110                 action = X_("FileHeaderFormatRF64");
 111                 break;
 112         case CAF:
 113                 action = X_("FileHeaderFormatCAF");
 114                 break;
 115         case AIFF:
 116                 action = X_("FileHeaderFormatAIFF");
 117                 break;
 118         default:
 119                 fatal << string_compose (_("programming error: %1"), "illegal file header format in ::set_native_file_header_format") << endmsg;
 120                 /*NOTREACHED*/
 121         }
 122
 123         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 124
 125         if (act) {
 126                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 127                 if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
 128                         Config->set_native_file_header_format (hf);
 129                 }
 130         }
 131 }
 132
 133 void
 134 ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
 135 {
 136         const char* action = 0;
 137
 138         switch (sf) {
 139         case FormatFloat:
 140                 action = X_("FileDataFormatFloat");
 141                 break;
 142         case FormatInt24:
 143                 action = X_("FileDataFormat24bit");
 144                 break;
 145         case FormatInt16:
 146                 action = X_("FileDataFormat16bit");
 147                 break;
 148         default:
 149                 fatal << string_compose (_("programming error: %1"), "illegal file data format in ::set_native_file_data_format") << endmsg;
 150                 /*NOTREACHED*/
 151         }
 152
 153         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 154
 155         if (act) {
 156                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 157                 if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
 158                         Config->set_native_file_data_format (sf);
 159                 }
 160         }
 161 }
 162
 163 void
 164 ARDOUR_UI::set_input_auto_connect (AutoConnectOption option)
 165 {
 166         const char* action;
 167
 168         switch (option) {
 169         case AutoConnectPhysical:
 170                 action = X_("InputAutoConnectPhysical");
 171                 break;
 172         default:
 173                 action = X_("InputAutoConnectManual");
 174         }
 175
 176         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 177
 178         if (act) {
 179                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 180
 181                 if (ract && ract->get_active() && Config->get_input_auto_connect() != option) {
 182                         Config->set_input_auto_connect (option);
 183                 }
 184         }
 185 }
 186
 187 void
 188 ARDOUR_UI::set_output_auto_connect (AutoConnectOption option)
 189 {
 190         const char* action;
 191
 192         switch (option) {
 193         case AutoConnectPhysical:
 194                 action = X_("OutputAutoConnectPhysical");
 195                 break;
 196         case AutoConnectMaster:
 197                 action = X_("OutputAutoConnectMaster");
 198                 break;
 199         default:
 200                 action = X_("OutputAutoConnectManual");
 201         }
 202
 203         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 204
 205         if (act) {
 206                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 207
 208                 if (ract && ract->get_active() && Config->get_output_auto_connect() != option) {
 209                         Config->set_output_auto_connect (option);
 210                 }
 211         }
 212 }
 213
 214 void
 215 ARDOUR_UI::set_solo_model (SoloModel model)
 216 {
 217         const char* action = 0;
 218
 219         switch (model) {
 220         case SoloBus:
 221                 action = X_("SoloViaBus");
 222                 break;
 223
 224         case InverseMute:
 225                 action = X_("SoloInPlace");
 226                 break;
 227         default:
 228                 fatal << string_compose (_("programming error: unknown solo model in ARDOUR_UI::set_solo_model: %1"), model) << endmsg;
 229                 /*NOTREACHED*/
 230         }
 231
 232         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 233
 234         if (act) {
 235                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 236
 237                 if (ract && ract->get_active() && Config->get_solo_model() != model) {
 238                         Config->set_solo_model (model);
 239                 }
 240         }
 241
 242 }
 243
 244 void
 245 ARDOUR_UI::set_remote_model (RemoteModel model)
 246 {
 247         const char* action = 0;
 248
 249         switch (model) {
 250         case UserOrdered:
 251                 action = X_("RemoteUserDefined");
 252                 break;
 253         case MixerOrdered:
 254                 action = X_("RemoteMixerDefined");
 255                 break;
 256         case EditorOrdered:
 257                 action = X_("RemoteEditorDefined");
 258                 break;
 259
 260         default:
 261                 fatal << string_compose (_("programming error: unknown remote model in ARDOUR_UI::set_remote_model: %1"), model) << endmsg;
 262                 /*NOTREACHED*/
 263         }
 264
 265         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 266
 267         if (act) {
 268                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 269
 270                 if (ract && ract->get_active() && Config->get_remote_model() != model) {
 271                         Config->set_remote_model (model);
 272                 }
 273         }
 274
 275 }
 276
 277 void
 278 ARDOUR_UI::set_monitor_model (MonitorModel model)
 279 {
 280         const char* action = 0;
 281
 282         switch (model) {
 283         case HardwareMonitoring:
 284                 action = X_("UseHardwareMonitoring");
 285                 break;
 286
 287         case SoftwareMonitoring:
 288                 action = X_("UseSoftwareMonitoring");
 289                 break;
 290         case ExternalMonitoring:
 291                 action = X_("UseExternalMonitoring");
 292                 break;
 293
 294         default:
 295                 fatal << string_compose (_("programming error: unknown monitor model in ARDOUR_UI::set_monitor_model: %1"), model) << endmsg;
 296                 /*NOTREACHED*/
 297         }
 298
 299         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 300
 301         if (act) {
 302                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 303
 304                 if (ract && ract->get_active() && Config->get_monitoring_model() != model) {
 305                         Config->set_monitoring_model (model);
 306                 }
 307         }
 308
 309 }
 310
 311 void
 312 ARDOUR_UI::set_denormal_model (DenormalModel model)
 313 {
 314         const char* action = 0;
 315
 316         switch (model) {
 317         case DenormalNone:
 318                 action = X_("DenormalNone");
 319                 break;
 320
 321         case DenormalFTZ:
 322                 action = X_("DenormalFTZ");
 323                 break;
 324
 325         case DenormalDAZ:
 326                 action = X_("DenormalDAZ");
 327                 break;
 328
 329         case DenormalFTZDAZ:
 330                 action = X_("DenormalFTZDAZ");
 331                 break;
 332
 333         default:
 334                 fatal << string_compose (_("programming error: unknown denormal model in ARDOUR_UI::set_denormal_model: %1"), model) << endmsg;
 335                 /*NOTREACHED*/
 336         }
 337
 338         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 339
 340         if (act) {
 341                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 342
 343                 if (ract && ract->get_active() && Config->get_denormal_model() != model) {
 344                         Config->set_denormal_model (model);
 345                 }
 346         }
 347
 348 }
 349
 350 void
 351 ARDOUR_UI::toggle_auto_input ()
 352 {
 353         ActionManager::toggle_config_state ("Transport", "ToggleAutoInput", &Configuration::set_auto_input, &Configuration::get_auto_input);
 354 }
 355
 356 void
 357 ARDOUR_UI::toggle_auto_play ()
 358 {
 359         ActionManager::toggle_config_state ("Transport", "ToggleAutoPlay", &Configuration::set_auto_play, &Configuration::get_auto_play);
 360 }
 361
 362 void
 363 ARDOUR_UI::toggle_auto_return ()
 364 {
 365         ActionManager::toggle_config_state ("Transport", "ToggleAutoReturn", &Configuration::set_auto_return, &Configuration::get_auto_return);
 366 }
 367
 368 void
 369 ARDOUR_UI::toggle_click ()
 370 {
 371         ActionManager::toggle_config_state ("Transport", "ToggleClick", &Configuration::set_clicking, &Configuration::get_clicking);
 372 }
 373
 374 void
 375 ARDOUR_UI::toggle_session_auto_loop ()
 376 {
 377         if (session) {
 378                 if (session->get_play_loop()) {
 379                         if (session->transport_rolling()) {
 380                                 transport_roll();
 381                         } else {
 382                                 session->request_play_loop (false);
 383                         }
 384                 } else {
 385                         session->request_play_loop (true);
 386                 }
 387         }
 388 }
 389
 390 void
 391 ARDOUR_UI::unset_dual_punch ()
 392 {
 393         Glib::RefPtr<Action> action = ActionManager::get_action ("Transport", "TogglePunch");
 394
 395         if (action) {
 396                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(action);
 397                 if (tact) {
 398                         ignore_dual_punch = true;
 399                         tact->set_active (false);
 400                         ignore_dual_punch = false;
 401                 }
 402         }
 403 }
 404
 405 void
 406 ARDOUR_UI::toggle_punch ()
 407 {
 408         if (ignore_dual_punch) {
 409                 return;
 410         }
 411
 412         Glib::RefPtr<Action> action = ActionManager::get_action ("Transport", "TogglePunch");
 413
 414         if (action) {
 415
 416                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(action);
 417
 418                 if (!tact) {
 419                         return;
 420                 }
 421
 422                 /* drive the other two actions from this one */
 423
 424                 Glib::RefPtr<Action> in_action = ActionManager::get_action ("Transport", "TogglePunchIn");
 425                 Glib::RefPtr<Action> out_action = ActionManager::get_action ("Transport", "TogglePunchOut");
 426
 427                 if (in_action && out_action) {
 428                         Glib::RefPtr<ToggleAction> tiact = Glib::RefPtr<ToggleAction>::cast_dynamic(in_action);
 429                         Glib::RefPtr<ToggleAction> toact = Glib::RefPtr<ToggleAction>::cast_dynamic(out_action);
 430                         tiact->set_active (tact->get_active());
 431                         toact->set_active (tact->get_active());
 432                 }
 433         }
 434 }
 435
 436 void
 437 ARDOUR_UI::toggle_punch_in ()
 438 {
 439         ActionManager::toggle_config_state ("Transport", "TogglePunchIn", &Configuration::set_punch_in, &Configuration::get_punch_in);
 440 }
 441
 442 void
 443 ARDOUR_UI::toggle_punch_out ()
 444 {
 445         ActionManager::toggle_config_state ("Transport", "TogglePunchOut", &Configuration::set_punch_out, &Configuration::get_punch_out);
 446 }
 447
 448 void
 449 ARDOUR_UI::toggle_video_sync()
 450 {
 451         Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", "ToggleVideoSync");
 452         if (act) {
 453                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 454                 Config->set_use_video_sync (tact->get_active());
 455         }
 456 }
 457
 458 void
 459 ARDOUR_UI::toggle_editing_space()
 460 {
 461         Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMaximalEditor");
 462         if (act) {
 463                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 464                 if (tact->get_active()) {
 465                         maximise_editing_space ();
 466                 } else {
 467                         restore_editing_space ();
 468                 }
 469         }
 470 }
 471
 472 void
 473 ARDOUR_UI::toggle_new_plugins_active ()
 474 {
 475         ActionManager::toggle_config_state ("options", "NewPluginsActive", &Configuration::set_new_plugins_active, &Configuration::get_new_plugins_active);
 476 }
 477
 478 void
 479 ARDOUR_UI::toggle_StopPluginsWithTransport()
 480 {
 481         ActionManager::toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport, &Configuration::get_plugins_stop_with_transport);
 482 }
 483
 484 void
 485 ARDOUR_UI::toggle_LatchedRecordEnable()
 486 {
 487         ActionManager::toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable, &Configuration::get_latched_record_enable);
 488 }
 489
 490 void
 491 ARDOUR_UI::toggle_RegionEquivalentsOverlap()
 492 {
 493         ActionManager::toggle_config_state ("options", "RegionEquivalentsOverlap", &Configuration::set_use_overlap_equivalency, &Configuration::get_use_overlap_equivalency);
 494 }
 495
 496 void
 497 ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
 498 {
 499         ActionManager::toggle_config_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::set_do_not_record_plugins, &Configuration::get_do_not_record_plugins);
 500 }
 501
 502 void
 503 ARDOUR_UI::toggle_VerifyRemoveLastCapture()
 504 {
 505         ActionManager::toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture, &Configuration::get_verify_remove_last_capture);
 506 }
 507
 508 void
 509 ARDOUR_UI::toggle_PeriodicSafetyBackups()
 510 {
 511         ActionManager::toggle_config_state ("options", "PeriodicSafetyBackups", &Configuration::set_periodic_safety_backups, &Configuration::get_periodic_safety_backups);
 512 }
 513
 514 void
 515 ARDOUR_UI::toggle_StopRecordingOnXrun()
 516 {
 517         ActionManager::toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun, &Configuration::get_stop_recording_on_xrun);
 518 }
 519
 520 void
 521 ARDOUR_UI::toggle_CreateXrunMarker()
 522 {
 523         ActionManager::toggle_config_state ("options", "CreateXrunMarker", &Configuration::set_create_xrun_marker, &Configuration::get_create_xrun_marker);
 524 }
 525
 526 void
 527 ARDOUR_UI::toggle_sync_order_keys ()
 528 {
 529         ActionManager::toggle_config_state ("options", "SyncEditorAndMixerTrackOrder", &Configuration::set_sync_all_route_ordering, &Configuration::get_sync_all_route_ordering);
 530 }
 531
 532 void
 533 ARDOUR_UI::toggle_StopTransportAtEndOfSession()
 534 {
 535         ActionManager::toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end, &Configuration::get_stop_at_session_end);
 536 }
 537
 538 void
 539 ARDOUR_UI::toggle_GainReduceFastTransport()
 540 {
 541         ActionManager::toggle_config_state ("options", "GainReduceFastTransport", &Configuration::set_quieten_at_speed, &Configuration::get_quieten_at_speed);
 542 }
 543
 544 void
 545 ARDOUR_UI::toggle_LatchedSolo()
 546 {
 547         ActionManager::toggle_config_state ("options", "LatchedSolo", &Configuration::set_solo_latched, &Configuration::get_solo_latched);
 548 }
 549
 550 void
 551 ARDOUR_UI::toggle_ShowSoloMutes()
 552 {
 553         ActionManager::toggle_config_state ("options", "ShowSoloMutes", &Configuration::set_show_solo_mutes, &Configuration::get_show_solo_mutes);
 554 }
 555
 556 void
 557 ARDOUR_UI::toggle_SoloMuteOverride()
 558 {
 559         ActionManager::toggle_config_state ("options", "SoloMuteOverride", &Configuration::set_solo_mute_override, &Configuration::get_solo_mute_override);
 560 }
 561
 562 void
 563 ARDOUR_UI::toggle_PrimaryClockDeltaEditCursor()
 564 {
 565         ActionManager::toggle_config_state ("options", "PrimaryClockDeltaEditCursor", &Configuration::set_primary_clock_delta_edit_cursor, &Configuration::get_primary_clock_delta_edit_cursor);
 566 }
 567
 568 void
 569 ARDOUR_UI::toggle_SecondaryClockDeltaEditCursor()
 570 {
 571         ActionManager::toggle_config_state ("options", "SecondaryClockDeltaEditCursor", &Configuration::set_secondary_clock_delta_edit_cursor, &Configuration::get_secondary_clock_delta_edit_cursor);
 572 }
 573
 574 void
 575 ARDOUR_UI::toggle_ShowTrackMeters()
 576 {
 577         ActionManager::toggle_config_state ("options", "ShowTrackMeters", &Configuration::set_show_track_meters, &Configuration::get_show_track_meters);
 578 }
 579
 580 void
 581 ARDOUR_UI::toggle_TapeMachineMode ()
 582 {
 583         ActionManager::toggle_config_state ("options", "ToggleTapeMachineMode", &Configuration::set_tape_machine_mode, &Configuration::get_tape_machine_mode);
 584 }
 585
 586 void
 587 ARDOUR_UI::toggle_use_narrow_ms()
 588 {
 589         ActionManager::toggle_config_state ("options", "DefaultNarrowMS", &Configuration::set_default_narrow_ms, &Configuration::get_default_narrow_ms);
 590 }
 591
 592 void
 593 ARDOUR_UI::toggle_NameNewMarkers()
 594 {
 595         ActionManager::toggle_config_state ("options", "NameNewMarkers", &Configuration::set_name_new_markers, &Configuration::get_name_new_markers);
 596 }
 597
 598 void
 599 ARDOUR_UI::toggle_rubberbanding_snaps_to_grid ()
 600 {
 601         ActionManager::toggle_config_state ("options", "RubberbandingSnapsToGrid", &Configuration::set_rubberbanding_snaps_to_grid, &Configuration::get_rubberbanding_snaps_to_grid);
 602 }
 603
 604 void
 605 ARDOUR_UI::toggle_auto_analyse_audio ()
 606 {
 607         ActionManager::toggle_config_state ("options", "AutoAnalyseAudio", &Configuration::set_auto_analyse_audio, &Configuration::get_auto_analyse_audio);
 608 }
 609
 610 void
 611 ARDOUR_UI::mtc_port_changed ()
 612 {
 613         bool have_mtc;
 614
 615         if (session) {
 616                 if (session->mtc_port()) {
 617                         have_mtc = true;
 618                 } else {
 619                         have_mtc = false;
 620                 }
 621         } else {
 622                 have_mtc = false;
 623         }
 624
 625         positional_sync_strings.clear ();
 626         positional_sync_strings.push_back (slave_source_to_string (None));
 627         if (have_mtc) {
 628                 positional_sync_strings.push_back (slave_source_to_string (MTC));
 629         }
 630         positional_sync_strings.push_back (slave_source_to_string (JACK));
 631
 632         set_popdown_strings (sync_option_combo, positional_sync_strings);
 633 }
 634
 635 void
 636 ARDOUR_UI::setup_session_options ()
 637 {
 638         mtc_port_changed ();
 639
 640         Config->ParameterChanged.connect (mem_fun (*this, &ARDOUR_UI::parameter_changed));
 641 }
 642
 643
 644 void
 645 ARDOUR_UI::map_solo_model ()
 646 {
 647         const char* on;
 648
 649         if (Config->get_solo_model() == InverseMute) {
 650                 on = X_("SoloInPlace");
 651         } else {
 652                 on = X_("SoloViaBus");
 653         }
 654
 655         Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 656         if (act) {
 657                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 658
 659                 if (tact && !tact->get_active()) {
 660                         tact->set_active (true);
 661                 }
 662         }
 663 }
 664
 665 void
 666 ARDOUR_UI::map_monitor_model ()
 667 {
 668         const char* on = 0;
 669
 670         switch (Config->get_monitoring_model()) {
 671         case HardwareMonitoring:
 672                 on = X_("UseHardwareMonitoring");
 673                 break;
 674         case SoftwareMonitoring:
 675                 on = X_("UseSoftwareMonitoring");
 676                 break;
 677         case ExternalMonitoring:
 678                 on = X_("UseExternalMonitoring");
 679                 break;
 680         }
 681
 682         Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 683         if (act) {
 684                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 685
 686                 if (tact && !tact->get_active()) {
 687                         tact->set_active (true);
 688                 }
 689         }
 690 }
 691
 692 void
 693 ARDOUR_UI::map_denormal_protection ()
 694 {
 695         Glib::RefPtr<Action> act = ActionManager::get_action ("options", X_("DenormalProtection"));
 696         if (act) {
 697                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 698
 699                 if (tact && !tact->get_active()) {
 700                         tact->set_active (Config->get_denormal_protection());
 701                 }
 702         }
 703 }
 704
 705 void
 706 ARDOUR_UI::map_denormal_model ()
 707 {
 708         const char* on = 0;
 709
 710         switch (Config->get_denormal_model()) {
 711         case DenormalNone:
 712                 on = X_("DenormalNone");
 713                 break;
 714         case DenormalFTZ:
 715                 on = X_("DenormalFTZ");
 716                 break;
 717         case DenormalDAZ:
 718                 on = X_("DenormalDAZ");
 719                 break;
 720         case DenormalFTZDAZ:
 721                 on = X_("DenormalFTZDAZ");
 722                 break;
 723         }
 724
 725         Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 726         if (act) {
 727                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 728
 729                 if (tact && !tact->get_active()) {
 730                         tact->set_active (true);
 731                 }
 732         }
 733 }
 734
 735 void
 736 ARDOUR_UI::map_remote_model ()
 737 {
 738         const char* on = 0;
 739
 740         switch (Config->get_remote_model()) {
 741         case UserOrdered:
 742                 on = X_("RemoteUserDefined");
 743                 break;
 744         case MixerOrdered:
 745                 on = X_("RemoteMixerDefined");
 746                 break;
 747         case EditorOrdered:
 748                 on = X_("RemoteEditorDefined");
 749                 break;
 750         }
 751
 752         Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 753         if (act) {
 754                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 755
 756                 if (tact && !tact->get_active()) {
 757                         tact->set_active (true);
 758                 }
 759         }
 760 }
 761
 762 void
 763 ARDOUR_UI::map_file_header_format ()
 764 {
 765         const char* action = 0;
 766
 767         switch (Config->get_native_file_header_format()) {
 768         case BWF:
 769                 action = X_("FileHeaderFormatBWF");
 770                 break;
 771
 772         case WAVE:
 773                 action = X_("FileHeaderFormatWAVE");
 774                 break;
 775
 776         case WAVE64:
 777                 action = X_("FileHeaderFormatWAVE64");
 778                 break;
 779
 780         case iXML:
 781                 action = X_("FileHeaderFormatiXML");
 782                 break;
 783
 784         case RF64:
 785                 action = X_("FileHeaderFormatRF64");
 786                 break;
 787
 788         case CAF:
 789                 action = X_("FileHeaderFormatCAF");
 790                 break;
 791
 792         default:
 793                 fatal << string_compose (_("programming error: unknown file header format passed to ARDOUR_UI::map_file_data_format: %1"),
 794                                          Config->get_native_file_header_format()) << endmsg;
 795                 /*NOTREACHED*/
 796         }
 797
 798
 799         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 800
 801         if (act) {
 802                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 803
 804                 if (tact && !tact->get_active()) {
 805                         tact->set_active (true);
 806                 }
 807         }
 808 }
 809
 810 void
 811 ARDOUR_UI::map_file_data_format ()
 812 {
 813         const char* action = 0;
 814
 815         switch (Config->get_native_file_data_format()) {
 816         case FormatFloat:
 817                 action = X_("FileDataFormatFloat");
 818                 break;
 819
 820         case FormatInt24:
 821                 action = X_("FileDataFormat24bit");
 822                 break;
 823
 824         case FormatInt16:
 825                 action = X_("FileDataFormat16bit");
 826                 break;
 827
 828         default:
 829                 fatal << string_compose (_("programming error: unknown file data format passed to ARDOUR_UI::map_file_data_format: %1"),
 830                                          Config->get_native_file_data_format()) << endmsg;
 831                 /*NOTREACHED*/
 832         }
 833
 834
 835         Glib::RefPtr<Action> act = ActionManager::get_action ("options", action);
 836
 837         if (act) {
 838                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 839
 840                 if (tact && !tact->get_active()) {
 841                         tact->set_active (true);
 842                 }
 843         }
 844 }
 845
 846 void
 847 ARDOUR_UI::map_input_auto_connect ()
 848 {
 849         const char* on;
 850
 851         if (Config->get_input_auto_connect() == (AutoConnectOption) 0) {
 852                 on = "InputAutoConnectManual";
 853         } else {
 854                 on = "InputAutoConnectPhysical";
 855         }
 856
 857         Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 858         if (act) {
 859                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 860
 861                 if (tact && !tact->get_active()) {
 862                         tact->set_active (true);
 863                 }
 864         }
 865 }
 866
 867 void
 868 ARDOUR_UI::map_output_auto_connect ()
 869 {
 870         const char* on;
 871
 872         if (Config->get_output_auto_connect() == (AutoConnectOption) 0) {
 873                 on = "OutputAutoConnectManual";
 874         } else if (Config->get_output_auto_connect() == AutoConnectPhysical) {
 875                 on = "OutputAutoConnectPhysical";
 876         } else {
 877                 on = "OutputAutoConnectMaster";
 878         }
 879
 880         Glib::RefPtr<Action> act = ActionManager::get_action ("options", on);
 881         if (act) {
 882                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 883
 884                 if (tact && !tact->get_active()) {
 885                         tact->set_active (true);
 886                 }
 887         }
 888 }
 889
 890 void
 891 ARDOUR_UI::map_only_copy_imported_files ()
 892 {
 893         Glib::RefPtr<Action> act = ActionManager::get_action ("options", X_("OnlyCopyImportedFiles"));
 894         if (act) {
 895                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 896
 897                 if (tact && !tact->get_active()) {
 898                         tact->set_active (Config->get_only_copy_imported_files());
 899                 }
 900         }
 901
 902 }
 903
 904 void
 905 ARDOUR_UI::map_meter_falloff ()
 906 {
 907         const char* action = X_("MeterFalloffMedium");
 908
 909         float val = Config->get_meter_falloff ();
 910         MeterFalloff code = meter_falloff_from_float(val);
 911
 912         switch (code) {
 913         case MeterFalloffOff:
 914                 action = X_("MeterFalloffOff");
 915                 break;
 916         case MeterFalloffSlowest:
 917                 action = X_("MeterFalloffSlowest");
 918                 break;
 919         case MeterFalloffSlow:
 920                 action = X_("MeterFalloffSlow");
 921                 break;
 922         case MeterFalloffMedium:
 923                 action = X_("MeterFalloffMedium");
 924                 break;
 925         case MeterFalloffFast:
 926                 action = X_("MeterFalloffFast");
 927                 break;
 928         case MeterFalloffFaster:
 929                 action = X_("MeterFalloffFaster");
 930                 break;
 931         case MeterFalloffFastest:
 932                 action = X_("MeterFalloffFastest");
 933                 break;
 934         }
 935
 936         Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
 937
 938         if (act) {
 939                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 940                 if (ract && !ract->get_active()) {
 941                         ract->set_active (true);
 942                 }
 943         }
 944 }
 945
 946 void
 947 ARDOUR_UI::map_meter_hold ()
 948 {
 949         const char* action = X_("MeterHoldMedium");
 950
 951         /* XXX hack alert. Fix this. Please */
 952
 953         float val = Config->get_meter_hold ();
 954         MeterHold code = (MeterHold) (int) (floor (val));
 955
 956         switch (code) {
 957         case MeterHoldOff:
 958                 action = X_("MeterHoldOff");
 959                 break;
 960         case MeterHoldShort:
 961                 action = X_("MeterHoldShort");
 962                 break;
 963         case MeterHoldMedium:
 964                 action = X_("MeterHoldMedium");
 965                 break;
 966         case MeterHoldLong:
 967                 action = X_("MeterHoldLong");
 968                 break;
 969         }
 970
 971         Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
 972
 973         if (act) {
 974                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
 975                 if (ract && !ract->get_active()) {
 976                         ract->set_active (true);
 977                 }
 978         }
 979 }
 980
 981 void
 982 ARDOUR_UI::set_meter_hold (MeterHold val)
 983 {
 984         const char* action = 0;
 985         float fval;
 986
 987         fval = meter_hold_to_float (val);
 988
 989         switch (val) {
 990         case MeterHoldOff:
 991                 action = X_("MeterHoldOff");
 992                 break;
 993         case MeterHoldShort:
 994                 action = X_("MeterHoldShort");
 995                 break;
 996         case MeterHoldMedium:
 997                 action = X_("MeterHoldMedium");
 998                 break;
 999         case MeterHoldLong:
1000                 action = X_("MeterHoldLong");
1001                 break;
1002         }
1003
1004         Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
1005
1006         if (act) {
1007                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
1008                 if (ract && ract->get_active() && Config->get_meter_hold() != fval) {
1009                         Config->set_meter_hold (fval);
1010                 }
1011         }
1012 }
1013
1014 void
1015 ARDOUR_UI::set_meter_falloff (MeterFalloff val)
1016 {
1017         const char* action = 0;
1018         float fval;
1019
1020         fval = meter_falloff_to_float (val);
1021
1022         switch (val) {
1023         case MeterFalloffOff:
1024                 action = X_("MeterFalloffOff");
1025                 break;
1026         case MeterFalloffSlowest:
1027                 action = X_("MeterFalloffSlowest");
1028                 break;
1029         case MeterFalloffSlow:
1030                 action = X_("MeterFalloffSlow");
1031                 break;
1032         case MeterFalloffMedium:
1033                 action = X_("MeterFalloffMedium");
1034                 break;
1035         case MeterFalloffFast:
1036                 action = X_("MeterFalloffFast");
1037                 break;
1038         case MeterFalloffFaster:
1039                 action = X_("MeterFalloffFaster");
1040                 break;
1041         case MeterFalloffFastest:
1042                 action = X_("MeterFalloffFastest");
1043                 break;
1044         }
1045
1046         Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), action);
1047
1048         if (act) {
1049                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
1050                 if (ract && ract->get_active() && Config->get_meter_falloff () != fval) {
1051                         Config->set_meter_falloff (fval);
1052                 }
1053         }
1054 }
1055
1056 void
1057 ARDOUR_UI::parameter_changed (const char* parameter_name)
1058 {
1059         ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::parameter_changed), parameter_name));
1060
1061 #define PARAM_IS(x) (!strcmp (parameter_name, (x)))
1062
1063         if (PARAM_IS ("slave-source")) {
1064
1065                 sync_option_combo.set_active_text (slave_source_to_string (Config->get_slave_source()));
1066
1067                 switch (Config->get_slave_source()) {
1068                 case None:
1069                         ActionManager::get_action ("Transport", "ToggleAutoPlay")->set_sensitive (true);
1070                         ActionManager::get_action ("Transport", "ToggleAutoReturn")->set_sensitive (true);
1071                         break;
1072
1073                 default:
1074                         /* XXX need to make auto-play is off as well as insensitive */
1075                         ActionManager::get_action ("Transport", "ToggleAutoPlay")->set_sensitive (false);
1076                         ActionManager::get_action ("Transport", "ToggleAutoReturn")->set_sensitive (false);
1077                         break;
1078                 }
1079
1080         } else if (PARAM_IS ("send-mtc")) {
1081
1082                 ActionManager::map_some_state ("options", "SendMTC", &Configuration::get_send_mtc);
1083
1084         } else if (PARAM_IS ("send-mmc")) {
1085
1086
1087                 ActionManager::map_some_state ("options", "SendMMC", &Configuration::get_send_mmc);
1088
1089         } else if (PARAM_IS ("use-osc")) {
1090
1091 #ifdef HAVE_LIBLO
1092                 if (Config->get_use_osc()) {
1093                         osc->start ();
1094                 } else {
1095                         osc->stop ();
1096                 }
1097 #endif
1098
1099                 ActionManager::map_some_state ("options", "UseOSC", &Configuration::get_use_osc);
1100
1101         } else if (PARAM_IS ("mmc-control")) {
1102                 ActionManager::map_some_state ("options", "UseMMC", &Configuration::get_mmc_control);
1103
1104         } else if (PARAM_IS ("midi-feedback")) {
1105                 ActionManager::map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback);
1106         } else if (PARAM_IS ("do-not-record-plugins")) {
1107                 ActionManager::map_some_state ("options", "DoNotRunPluginsWhileRecording", &Configuration::get_do_not_record_plugins);
1108         } else if (PARAM_IS ("latched-record-enable")) {
1109                 ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
1110         } else if (PARAM_IS ("solo-latched")) {
1111                 ActionManager::map_some_state ("options", "LatchedSolo", &Configuration::get_solo_latched);
1112         } else if (PARAM_IS ("show-solo-mutes")) {
1113                 ActionManager::map_some_state ("options", "ShowSoloMutes", &Configuration::get_show_solo_mutes);
1114         } else if (PARAM_IS ("solo-mute-override")) {
1115                 ActionManager::map_some_state ("options", "SoloMuteOverride", &Configuration::get_solo_mute_override);
1116         } else if (PARAM_IS ("solo-model")) {
1117                 map_solo_model ();
1118         } else if (PARAM_IS ("auto-play")) {
1119                 ActionManager::map_some_state ("Transport", "ToggleAutoPlay", &Configuration::get_auto_play);
1120         } else if (PARAM_IS ("auto-return")) {
1121                 ActionManager::map_some_state ("Transport", "ToggleAutoReturn", &Configuration::get_auto_return);
1122         } else if (PARAM_IS ("auto-input")) {
1123                 ActionManager::map_some_state ("Transport", "ToggleAutoInput", &Configuration::get_auto_input);
1124         } else if (PARAM_IS ("tape-machine-mode")) {
1125                 ActionManager::map_some_state ("options", "ToggleTapeMachineMode", &Configuration::get_tape_machine_mode);
1126         } else if (PARAM_IS ("punch-out")) {
1127                 ActionManager::map_some_state ("Transport", "TogglePunchOut", &Configuration::get_punch_out);
1128                 if (!Config->get_punch_out()) {
1129                         unset_dual_punch ();
1130                 }
1131         } else if (PARAM_IS ("punch-in")) {
1132                 ActionManager::map_some_state ("Transport", "TogglePunchIn", &Configuration::get_punch_in);
1133                 if (!Config->get_punch_in()) {
1134                         unset_dual_punch ();
1135                 }
1136         } else if (PARAM_IS ("clicking")) {
1137                 ActionManager::map_some_state ("Transport", "ToggleClick", &Configuration::get_clicking);
1138         } else if (PARAM_IS ("jack-time-master")) {
1139                 ActionManager::map_some_state ("Transport",  "ToggleTimeMaster", &Configuration::get_jack_time_master);
1140         } else if (PARAM_IS ("plugins-stop-with-transport")) {
1141                 ActionManager::map_some_state ("options",  "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport);
1142         } else if (PARAM_IS ("new-plugins-active")) {
1143                 ActionManager::map_some_state ("options",  "NewPluginsActive", &Configuration::get_new_plugins_active);
1144         } else if (PARAM_IS ("latched-record-enable")) {
1145                 ActionManager::map_some_state ("options", "LatchedRecordEnable", &Configuration::get_latched_record_enable);
1146         } else if (PARAM_IS ("verify-remove-last-capture")) {
1147                 ActionManager::map_some_state ("options",  "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture);
1148         } else if (PARAM_IS ("periodic-safety-backups")) {
1149                 ActionManager::map_some_state ("options",  "PeriodicSafetyBackups", &Configuration::get_periodic_safety_backups);
1150         } else if (PARAM_IS ("stop-recording-on-xrun")) {
1151                 ActionManager::map_some_state ("options",  "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun);
1152         } else if (PARAM_IS ("create-xrun-marker")) {
1153                 ActionManager::map_some_state ("options",  "CreateXrunMarker", &Configuration::get_create_xrun_marker);
1154         } else if (PARAM_IS ("sync-all-route-ordering")) {
1155                 ActionManager::map_some_state ("options",  "SyncEditorAndMixerTrackOrder", &Configuration::get_sync_all_route_ordering);
1156         } else if (PARAM_IS ("stop-at-session-end")) {
1157                 ActionManager::map_some_state ("options",  "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end);
1158         } else if (PARAM_IS ("monitoring-model")) {
1159                 map_monitor_model ();
1160         } else if (PARAM_IS ("denormal-model")) {
1161                 map_denormal_model ();
1162         } else if (PARAM_IS ("denormal-protection")) {
1163                 map_denormal_protection ();
1164         } else if (PARAM_IS ("remote-model")) {
1165                 map_remote_model ();
1166         } else if (PARAM_IS ("use-video-sync")) {
1167                 ActionManager::map_some_state ("Transport",  "ToggleVideoSync", &Configuration::get_use_video_sync);
1168         } else if (PARAM_IS ("quieten-at-speed")) {
1169                 ActionManager::map_some_state ("options",  "GainReduceFastTransport", &Configuration::get_quieten_at_speed);
1170         } else if (PARAM_IS ("shuttle-behaviour")) {
1171
1172                 switch (Config->get_shuttle_behaviour ()) {
1173                 case Sprung:
1174                         shuttle_style_button.set_active_text (_("sprung"));
1175                         shuttle_fract = 0.0;
1176                         shuttle_box.queue_draw ();
1177                         if (session) {
1178                                 if (session->transport_rolling()) {
1179                                         shuttle_fract = SHUTTLE_FRACT_SPEED1;
1180                                         session->request_transport_speed (1.0);
1181                                 }
1182                         }
1183                         break;
1184                 case Wheel:
1185                         shuttle_style_button.set_active_text (_("wheel"));
1186                         break;
1187                 }
1188
1189         } else if (PARAM_IS ("shuttle-units")) {
1190
1191                 switch (Config->get_shuttle_units()) {
1192                 case Percentage:
1193                         shuttle_units_button.set_label("% ");
1194                         break;
1195                 case Semitones:
1196                         shuttle_units_button.set_label(_("ST"));
1197                         break;
1198                 }
1199         } else if (PARAM_IS ("input-auto-connect")) {
1200                 map_input_auto_connect ();
1201         } else if (PARAM_IS ("output-auto-connect")) {
1202                 map_output_auto_connect ();
1203         } else if (PARAM_IS ("native-file-header-format")) {
1204                 map_file_header_format ();
1205         } else if (PARAM_IS ("native-file-data-format")) {
1206                 map_file_data_format ();
1207         } else if (PARAM_IS ("meter-hold")) {
1208                 map_meter_hold ();
1209         } else if (PARAM_IS ("meter-falloff")) {
1210                 map_meter_falloff ();
1211         } else if (PARAM_IS ("video-pullup") || PARAM_IS ("smpte-format")) {
1212                 if (session) {
1213                         primary_clock.set (session->audible_frame(), true);
1214                         secondary_clock.set (session->audible_frame(), true);
1215                 } else {
1216                         primary_clock.set (0, true);
1217                         secondary_clock.set (0, true);
1218                 }
1219         } else if (PARAM_IS ("use-overlap-equivalency")) {
1220                 ActionManager::map_some_state ("options", "RegionEquivalentsOverlap", &Configuration::get_use_overlap_equivalency);
1221         } else if (PARAM_IS ("primary-clock-delta-edit-cursor")) {
1222                 ActionManager::map_some_state ("options",  "PrimaryClockDeltaEditCursor", &Configuration::get_primary_clock_delta_edit_cursor);
1223         } else if (PARAM_IS ("secondary-clock-delta-edit-cursor")) {
1224                 ActionManager::map_some_state ("options",  "SecondaryClockDeltaEditCursor", &Configuration::get_secondary_clock_delta_edit_cursor);
1225         } else if (PARAM_IS ("only-copy-imported-files")) {
1226                 map_only_copy_imported_files ();
1227         } else if (PARAM_IS ("show-track-meters")) {
1228                 ActionManager::map_some_state ("options",  "ShowTrackMeters", &Configuration::get_show_track_meters);
1229                 editor->toggle_meter_updating();
1230         } else if (PARAM_IS ("default-narrow_ms")) {
1231                 ActionManager::map_some_state ("options",  "DefaultNarrowMS", &Configuration::get_default_narrow_ms);
1232         } else if (PARAM_IS ("rubberbanding-snaps-to-grid")) {
1233                 ActionManager::map_some_state ("options", "RubberbandingSnapsToGrid", &Configuration::get_rubberbanding_snaps_to_grid);
1234         }
1235
1236
1237
1238 #undef PARAM_IS
1239 }