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     $Id$
  19 */
  20
  21 #include <pbd/convert.h>
  22
  23 #include <gtkmm2ext/utils.h>
  24
  25 #include <ardour/configuration.h>
  26 #include <ardour/session.h>
  27 #include <ardour/audioengine.h>
  28
  29 #include "ardour_ui.h"
  30 #include "actions.h"
  31 #include "gui_thread.h"
  32
  33 #include "i18n.h"
  34
  35 using namespace Gtk;
  36 using namespace Gtkmm2ext;
  37 using namespace ARDOUR;
  38
  39 void
  40 ARDOUR_UI::setup_config_options ()
  41 {
  42         struct {
  43             char* name;
  44             bool (Configuration::*method)(void) const;
  45         } options[] = {
  46                 { "ToggleTimeMaster", &Configuration::get_jack_time_master },
  47                 { "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport },
  48                 { "LatchedRecordEnable", &Configuration::get_latched_record_enable },
  49                 { "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture },
  50                 { "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun },
  51                 { "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end },
  52                 { 0, 0 }
  53         };
  54
  55         for (uint32_t n = 0; options[n].name; ++n) {
  56                 Glib::RefPtr<Action> act = ActionManager::get_action ("options", options[n].name);
  57                 if (act) {
  58                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
  59                         tact->set_active ((Config->*(options[n].method))());
  60                 }
  61         }
  62 }
  63
  64 void
  65 ARDOUR_UI::toggle_time_master ()
  66 {
  67         toggle_config_state ("Transport", "ToggleTimeMaster", &Configuration::set_jack_time_master);
  68         if (session) {
  69                 session->engine().reset_timebase ();
  70         }
  71 }
  72
  73 void
  74 ARDOUR_UI::toggle_config_state (const char* group, const char* action, void (Configuration::*set)(bool))
  75 {
  76         Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
  77         if (act) {
  78                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
  79                 (Config->*set) (tact->get_active());
  80         }
  81 }
  82
  83 void
  84 ARDOUR_UI::toggle_session_state (const char* group, const char* action, void (Session::*set)(bool), bool (Session::*get)(void) const)
  85 {
  86         if (session) {
  87                 Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
  88                 if (act) {
  89                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
  90                         bool x = (session->*get)();
  91
  92                         if (x != tact->get_active()) {
  93                                 (session->*set) (!x);
  94                         }
  95                 }
  96         }
  97 }
  98
  99 void
 100 ARDOUR_UI::toggle_session_state (const char* group, const char* action, sigc::slot<void> theSlot)
 101 {
 102         if (session) {
 103                 Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
 104                 if (act) {
 105                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 106                         if (tact->get_active()) {
 107                                 theSlot ();
 108                         }
 109                 }
 110         }
 111 }
 112
 113 void
 114 ARDOUR_UI::toggle_send_mtc ()
 115 {
 116         toggle_session_state ("options", "SendMTC", &Session::set_send_mtc, &Session::get_send_mtc);
 117 }
 118
 119 void
 120 ARDOUR_UI::toggle_send_mmc ()
 121 {
 122         toggle_session_state ("options", "SendMMC", &Session::set_send_mmc, &Session::get_send_mmc);
 123 }
 124
 125 void
 126 ARDOUR_UI::toggle_use_mmc ()
 127 {
 128         toggle_session_state ("options", "UseMMC", &Session::set_mmc_control, &Session::get_mmc_control);
 129 }
 130
 131 void
 132 ARDOUR_UI::toggle_use_midi_control ()
 133 {
 134         toggle_session_state ("options", "UseMIDIcontrol", &Session::set_midi_control, &Session::get_midi_control);
 135 }
 136
 137 void
 138 ARDOUR_UI::toggle_send_midi_feedback ()
 139 {
 140         toggle_session_state ("options", "SendMIDIfeedback", &Session::set_midi_feedback, &Session::get_midi_feedback);
 141 }
 142
 143 void
 144 ARDOUR_UI::toggle_AutoConnectNewTrackInputsToHardware()
 145 {
 146         toggle_session_state ("options", "AutoConnectNewTrackInputsToHardware", &Session::set_input_auto_connect, &Session::get_input_auto_connect);
 147 }
 148 void
 149 ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToHardware()
 150 {
 151         toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectPhysical));
 152 }
 153 void
 154 ARDOUR_UI::toggle_AutoConnectNewTrackOutputsToMaster()
 155 {
 156         toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectMaster));
 157 }
 158 void
 159 ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs()
 160 {
 161         toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectOption (0)));
 162 }
 163
 164 void
 165 ARDOUR_UI::toggle_auto_input ()
 166 {
 167         toggle_session_state ("Transport", "ToggleAutoInput", &Session::set_auto_input, &Session::get_auto_input);
 168 }
 169
 170 void
 171 ARDOUR_UI::toggle_auto_play ()
 172 {
 173         toggle_session_state ("Transport", "ToggleAutoPlay", &Session::set_auto_play, &Session::get_auto_play);
 174 }
 175
 176 void
 177 ARDOUR_UI::toggle_auto_return ()
 178 {
 179         toggle_session_state ("Transport", "ToggleAutoReturn", &Session::set_auto_return, &Session::get_auto_return);
 180 }
 181
 182 void
 183 ARDOUR_UI::toggle_click ()
 184 {
 185         toggle_session_state ("Transport", "ToggleClick", &Session::set_clicking, &Session::get_clicking);
 186 }
 187
 188 void
 189 ARDOUR_UI::toggle_session_auto_loop ()
 190 {
 191         if (session) {
 192                 if (session->get_auto_loop()) {
 193                         if (session->transport_rolling()) {
 194                                 transport_roll();
 195                         } else {
 196                                 session->request_auto_loop (false);
 197                         }
 198                 } else {
 199                         session->request_auto_loop (true);
 200                 }
 201         }
 202 }
 203
 204 void
 205 ARDOUR_UI::toggle_punch_in ()
 206 {
 207         toggle_session_state ("Transport", "TogglePunchIn", &Session::set_punch_in, &Session::get_punch_in);
 208 }
 209
 210 void
 211 ARDOUR_UI::toggle_punch_out ()
 212 {
 213         toggle_session_state ("Transport", "TogglePunchOut", &Session::set_punch_out, &Session::get_punch_out);
 214 }
 215
 216 void
 217 ARDOUR_UI::toggle_editing_space()
 218 {
 219         Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMaximalEditor");
 220         if (act) {
 221                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 222                 if (tact->get_active()) {
 223                         maximise_editing_space ();
 224                 } else {
 225                         restore_editing_space ();
 226                 }
 227         }
 228 }
 229
 230 void
 231 ARDOUR_UI::toggle_UseHardwareMonitoring()
 232 {
 233         Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseSoftwareMonitoring");
 234         if (act) {
 235                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 236                 if (tact->get_active()) {
 237                         Config->set_use_hardware_monitoring (true);
 238                         Config->set_use_sw_monitoring (false);
 239                         if (session) {
 240                                 session->reset_input_monitor_state();
 241                         }
 242                 }
 243         }
 244 }
 245
 246 void
 247 ARDOUR_UI::toggle_UseSoftwareMonitoring()
 248 {
 249         Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseSoftwareMonitoring");
 250         if (act) {
 251                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 252                 if (tact->get_active()) {
 253                         Config->set_use_hardware_monitoring (false);
 254                         Config->set_use_sw_monitoring (true);
 255                         if (session) {
 256                                 session->reset_input_monitor_state();
 257                         }
 258                 }
 259         }
 260 }
 261
 262 void
 263 ARDOUR_UI::toggle_UseExternalMonitoring()
 264 {
 265         Glib::RefPtr<Action> act = ActionManager::get_action ("options", "UseExternalMonitoring");
 266         if (act) {
 267                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 268                 if (tact->get_active()) {
 269                         Config->set_use_hardware_monitoring (false);
 270                         Config->set_use_sw_monitoring (false);
 271                         if (session) {
 272                                 session->reset_input_monitor_state();
 273                         }
 274                 }
 275         }
 276 }
 277
 278 void
 279 ARDOUR_UI::toggle_StopPluginsWithTransport()
 280 {
 281         toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport);
 282 }
 283
 284 void
 285 ARDOUR_UI::toggle_LatchedRecordEnable()
 286 {
 287         toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable);
 288 }
 289
 290 void
 291 ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
 292 {
 293         toggle_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::set_do_not_record_plugins, &Session::get_do_not_record_plugins);
 294 }
 295
 296 void
 297 ARDOUR_UI::toggle_VerifyRemoveLastCapture()
 298 {
 299         toggle_config_state ("options", "VerifyRemoveLastCapture", &Configuration::set_verify_remove_last_capture);
 300 }
 301
 302 void
 303 ARDOUR_UI::toggle_StopRecordingOnXrun()
 304 {
 305         toggle_config_state ("options", "StopRecordingOnXrun", &Configuration::set_stop_recording_on_xrun);
 306 }
 307
 308 void
 309 ARDOUR_UI::toggle_StopTransportAtEndOfSession()
 310 {
 311         toggle_config_state ("options", "StopTransportAtEndOfSession", &Configuration::set_stop_at_session_end);
 312 }
 313
 314 void
 315 ARDOUR_UI::toggle_GainReduceFastTransport()
 316 {
 317         Glib::RefPtr<Action> act = ActionManager::get_action ("options", "GainReduceFastTransport");
 318         if (act) {
 319                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 320                 if (tact->get_active()) {
 321                         Config->set_quieten_at_speed (0.251189); // -12dB reduction for ffwd or rewind
 322                 } else {
 323                         Config->set_quieten_at_speed (1.0); /* no change */
 324                 }
 325         }
 326 }
 327
 328 void
 329 ARDOUR_UI::toggle_LatchedSolo()
 330 {
 331         toggle_session_state ("options", "LatchedSolo", &Session::set_solo_latched, &Session::solo_latched);
 332 }
 333
 334 void
 335 ARDOUR_UI::toggle_SoloViaBus()
 336 {
 337         if (!session) {
 338                 return;
 339         }
 340
 341         Glib::RefPtr<Action> act = ActionManager::get_action ("options", "SoloViaBus");
 342         if (act) {
 343                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 344
 345                 if (tact->get_active()) {
 346                         session->set_solo_model (Session::SoloBus);
 347                 } else {
 348                         session->set_solo_model (Session::InverseMute);
 349                 }
 350         }
 351 }
 352
 353 void
 354 ARDOUR_UI::toggle_AutomaticallyCreateCrossfades()
 355 {
 356 }
 357 void
 358 ARDOUR_UI::toggle_UnmuteNewFullCrossfades()
 359 {
 360 }
 361
 362 void
 363 ARDOUR_UI::mtc_port_changed ()
 364 {
 365         bool have_mtc;
 366
 367         if (session) {
 368                 if (session->mtc_port()) {
 369                         have_mtc = true;
 370                 } else {
 371                         have_mtc = false;
 372                 }
 373         } else {
 374                 have_mtc = false;
 375         }
 376
 377         if (have_mtc) {
 378                 const gchar *psync_strings[] = {
 379                         N_("Internal"),
 380                         N_("MTC"),
 381                         N_("JACK"),
 382                         0
 383                 };
 384
 385                 positional_sync_strings = PBD::internationalize (psync_strings);
 386
 387         } else {
 388                 const gchar *psync_strings[] = {
 389                         N_("Internal"),
 390                         N_("JACK"),
 391                         0
 392                 };
 393                 positional_sync_strings = PBD::internationalize (psync_strings);
 394         }
 395
 396         set_popdown_strings (sync_option_combo, positional_sync_strings);
 397 }
 398
 399 void
 400 ARDOUR_UI::setup_session_options ()
 401 {
 402         mtc_port_changed ();
 403
 404         session_control_changed (Session::SlaveType);
 405         session_control_changed (Session::SendMTC);
 406         session_control_changed (Session::SendMMC);
 407         session_control_changed (Session::MMCControl);
 408         session_control_changed (Session::MidiFeedback);
 409         session_control_changed (Session::MidiControl);
 410         session_control_changed (Session::RecordingPlugins);
 411         session_control_changed (Session::CrossFadesActive);
 412         session_control_changed (Session::SoloLatch);
 413         session_control_changed (Session::SoloingModel);
 414         session_control_changed (Session::LayeringModel);
 415         session_control_changed (Session::CrossfadingModel);
 416         session_control_changed (Session::PunchOut);
 417         session_control_changed (Session::PunchIn);
 418         session_control_changed (Session::AutoPlay);
 419         session_control_changed (Session::AutoReturn);
 420         session_control_changed (Session::AutoInput);
 421         session_control_changed (Session::Clicking);
 422
 423         session->ControlChanged.connect (mem_fun (*this, &ARDOUR_UI::queue_session_control_changed));
 424 }
 425
 426 void
 427 ARDOUR_UI::map_some_session_state (const char* group, const char* action, bool (Session::*get)() const)
 428 {
 429         if (!session) {
 430                 return;
 431         }
 432
 433         Glib::RefPtr<Action> act = ActionManager::get_action (group, action);
 434         if (act) {
 435                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 436                 bool x = (session->*get)();
 437                 if (tact->get_active() != x) {
 438                         tact->set_active (x);
 439                 }
 440         }
 441 }
 442
 443 void
 444 ARDOUR_UI::queue_session_control_changed (Session::ControlType t)
 445 {
 446         ENSURE_GUI_THREAD (bind (mem_fun (*this, &ARDOUR_UI::session_control_changed), t));
 447 }
 448
 449 void
 450 ARDOUR_UI::session_control_changed (Session::ControlType t)
 451 {
 452         switch (t) {
 453         case Session::SlaveType:
 454                 switch (session->slave_source()) {
 455                 case Session::None:
 456                         sync_option_combo.set_active_text (_("Internal"));
 457                         break;
 458                 case Session::MTC:
 459                         sync_option_combo.set_active_text (_("MTC"));
 460                         break;
 461                 case Session::JACK:
 462                         sync_option_combo.set_active_text (_("JACK"));
 463                         break;
 464                 }
 465
 466                 break;
 467
 468         case Session::SendMTC:
 469                 map_some_session_state ("options", "SendMTC", &Session::get_send_mtc);
 470                 break;
 471
 472         case Session::SendMMC:
 473                 map_some_session_state ("options", "SendMMC", &Session::get_send_mmc);
 474                 break;
 475
 476         case Session::MMCControl:
 477                 map_some_session_state ("options", "UseMMC", &Session::get_mmc_control);
 478                 break;
 479
 480         case Session::MidiFeedback:
 481                 map_some_session_state ("options", "SendMIDIfeedback", &Session::get_midi_feedback);
 482                 break;
 483
 484         case Session::MidiControl:
 485                 map_some_session_state ("options", "UseMIDIcontrol", &Session::get_midi_control);
 486                 break;
 487
 488         case Session::RecordingPlugins:
 489                 map_some_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::get_do_not_record_plugins);
 490                 break;
 491
 492         case Session::CrossFadesActive:
 493                 map_some_session_state ("options", "CrossfadesActive", &Session::get_crossfades_active);
 494                 break;
 495
 496         case Session::SoloLatch:
 497                 break;
 498
 499         case Session::SoloingModel:
 500                 switch (session->solo_model()) {
 501                 case Session::InverseMute:
 502                         break;
 503                 case Session::SoloBus:
 504                         break;
 505                 }
 506                 break;
 507
 508         case Session::LayeringModel:
 509                 break;
 510
 511         case Session::CrossfadingModel:
 512                 break;
 513
 514
 515         case Session::AutoPlay:
 516                 map_some_session_state ("Transport", "ToggleAutoPlay", &Session::get_auto_play);
 517                 break;
 518
 519         case Session::AutoLoop:
 520                 break;
 521
 522         case Session::AutoReturn:
 523                 map_some_session_state ("Transport", "ToggleAutoReturn", &Session::get_auto_return);
 524                 break;
 525
 526         case Session::AutoInput:
 527                 map_some_session_state ("Transport", "ToggleAutoInput", &Session::get_auto_input);
 528                 break;
 529
 530         case Session::PunchOut:
 531                 map_some_session_state ("Transport", "TogglePunchOut", &Session::get_punch_out);
 532                 break;
 533
 534         case Session::PunchIn:
 535                 map_some_session_state ("Transport", "TogglePunchIn", &Session::get_punch_in);
 536                 break;
 537
 538         case Session::Clicking:
 539                 map_some_session_state ("Transport", "ToggleClick", &Session::get_clicking);
 540                 break;
 541
 542         default:
 543                 // somebody else handles this
 544                 break;
 545
 546         }
 547 }