Fixed some valgrind errors from using uninitialized variables in

[ardour.git] / gtk2_ardour / ardour_ui_options.cc

diff --git a/gtk2_ardour/ardour_ui_options.cc b/gtk2_ardour/ardour_ui_options.cc
index 2fbec5d9a107b67a901889feaa87564974ec4950..826823885c1d727ca66b1f869af905a834701580 100644 (file)
--- a/gtk2_ardour/ardour_ui_options.cc
+++ b/gtk2_ardour/ardour_ui_options.cc
@@ -18,6 +18,8 @@
     $Id$
 */
 
+#include <pbd/convert.h>
+
 #include <gtkmm2ext/utils.h>
 
 #include <ardour/configuration.h>
@@ -34,6 +36,31 @@ using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace ARDOUR;
 
+void
+ARDOUR_UI::setup_config_options ()
+{
+       struct { 
+           char* name;
+           bool (Configuration::*method)(void) const;
+       } options[] = {
+               { "ToggleTimeMaster", &Configuration::get_jack_time_master },
+               { "StopPluginsWithTransport", &Configuration::get_plugins_stop_with_transport },
+               { "LatchedRecordEnable", &Configuration::get_latched_record_enable },
+               { "VerifyRemoveLastCapture", &Configuration::get_verify_remove_last_capture },
+               { "StopRecordingOnXrun", &Configuration::get_stop_recording_on_xrun },
+               { "StopTransportAtEndOfSession", &Configuration::get_stop_at_session_end },
+               { 0, 0 }
+       };
+       
+       for (uint32_t n = 0; options[n].name; ++n) {
+               Glib::RefPtr<Action> act = ActionManager::get_action ("options", options[n].name);
+               if (act) {
+                       Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+                       tact->set_active ((Config->*(options[n].method))());
+               }
+       }
+}
+
 void
 ARDOUR_UI::toggle_time_master ()
 {
@@ -134,6 +161,72 @@ ARDOUR_UI::toggle_ManuallyConnectNewTrackOutputs()
        toggle_session_state ("options", "AutoConnectNewTrackOutputsToHardware", bind (mem_fun (session, &Session::set_output_auto_connect), Session::AutoConnectOption (0)));
 }
 
+void
+ARDOUR_UI::toggle_auto_input ()
+{
+       toggle_session_state ("Transport", "ToggleAutoInput", &Session::set_auto_input, &Session::get_auto_input);
+}
+
+void
+ARDOUR_UI::toggle_auto_play ()
+{
+       toggle_session_state ("Transport", "ToggleAutoPlay", &Session::set_auto_play, &Session::get_auto_play);
+}
+
+void
+ARDOUR_UI::toggle_auto_return ()
+{
+       toggle_session_state ("Transport", "ToggleAutoReturn", &Session::set_auto_return, &Session::get_auto_return);
+}
+
+void
+ARDOUR_UI::toggle_click ()
+{
+       toggle_session_state ("Transport", "ToggleClick", &Session::set_clicking, &Session::get_clicking);
+}
+
+void
+ARDOUR_UI::toggle_session_auto_loop ()
+{
+       if (session) {
+               if (session->get_auto_loop()) {
+                       if (session->transport_rolling()) {
+                               transport_roll();
+                       } else {
+                               session->request_auto_loop (false);
+                       }
+               } else {
+                       session->request_auto_loop (true);
+               }
+       }
+}
+
+void
+ARDOUR_UI::toggle_punch_in ()
+{
+       toggle_session_state ("Transport", "TogglePunchIn", &Session::set_punch_in, &Session::get_punch_in);
+}
+
+void
+ARDOUR_UI::toggle_punch_out ()
+{
+       toggle_session_state ("Transport", "TogglePunchOut", &Session::set_punch_out, &Session::get_punch_out);
+}
+
+void
+ARDOUR_UI::toggle_editing_space()
+{
+       Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMaximalEditor");
+       if (act) {
+               Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+               if (tact->get_active()) {
+                       maximise_editing_space ();
+               } else {
+                       restore_editing_space ();
+               }
+       }
+}
+
 void
 ARDOUR_UI::toggle_UseHardwareMonitoring()
 {
@@ -187,10 +280,17 @@ ARDOUR_UI::toggle_StopPluginsWithTransport()
 {
        toggle_config_state ("options", "StopPluginsWithTransport", &Configuration::set_plugins_stop_with_transport);
 }
+
 void
-ARDOUR_UI::toggle_RunPluginsWhileRecording()
+ARDOUR_UI::toggle_LatchedRecordEnable()
 {
-       toggle_session_state ("options", "RunPluginsWhileRecording", &Session::set_recording_plugins, &Session::get_recording_plugins);
+       toggle_config_state ("options", "LatchedRecordEnable", &Configuration::set_latched_record_enable);
+}
+
+void
+ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording()
+{
+       toggle_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::set_do_not_record_plugins, &Session::get_do_not_record_plugins);
 }
 
 void
@@ -282,7 +382,7 @@ ARDOUR_UI::mtc_port_changed ()
                        0
                };
                
-               positional_sync_strings = internationalize (psync_strings);
+               positional_sync_strings = PBD::internationalize (psync_strings);
                
        } else {
                const gchar *psync_strings[] = {
@@ -290,14 +390,14 @@ ARDOUR_UI::mtc_port_changed ()
                        N_("JACK"),
                        0
                };
-               positional_sync_strings = internationalize (psync_strings);
+               positional_sync_strings = PBD::internationalize (psync_strings);
        }
        
        set_popdown_strings (sync_option_combo, positional_sync_strings);
 }
 
 void
-ARDOUR_UI::setup_options ()
+ARDOUR_UI::setup_session_options ()
 {
        mtc_port_changed ();
 
@@ -313,7 +413,13 @@ ARDOUR_UI::setup_options ()
        session_control_changed (Session::SoloingModel);
        session_control_changed (Session::LayeringModel);
        session_control_changed (Session::CrossfadingModel);
-
+       session_control_changed (Session::PunchOut);
+       session_control_changed (Session::PunchIn);
+       session_control_changed (Session::AutoPlay);
+       session_control_changed (Session::AutoReturn);
+       session_control_changed (Session::AutoInput);
+       session_control_changed (Session::Clicking);
+       
        session->ControlChanged.connect (mem_fun (*this, &ARDOUR_UI::queue_session_control_changed));
 }
 
@@ -380,7 +486,7 @@ ARDOUR_UI::session_control_changed (Session::ControlType t)
                break;
 
        case Session::RecordingPlugins:
-               map_some_session_state ("options", "RunPluginsWhileRecording", &Session::get_recording_plugins);
+               map_some_session_state ("options", "DoNotRunPluginsWhileRecording", &Session::get_do_not_record_plugins);
                break;
 
        case Session::CrossFadesActive:
@@ -406,34 +512,31 @@ ARDOUR_UI::session_control_changed (Session::ControlType t)
                break;
 
                
-        // BUTTON STATE: fix me in the future to use actions
-
-
        case Session::AutoPlay:
-               map_some_session_state (auto_play_button, &Session::get_auto_play);
+               map_some_session_state ("Transport", "ToggleAutoPlay", &Session::get_auto_play);
                break;
 
        case Session::AutoLoop:
                break;
 
        case Session::AutoReturn:
-               map_some_session_state (auto_return_button, &Session::get_auto_return);
+               map_some_session_state ("Transport", "ToggleAutoReturn", &Session::get_auto_return);
                break;
 
        case Session::AutoInput:
-               map_some_session_state (auto_input_button, &Session::get_auto_input);
+               map_some_session_state ("Transport", "ToggleAutoInput", &Session::get_auto_input);
                break;
 
        case Session::PunchOut:
-               map_some_session_state (punch_in_button, &Session::get_punch_out);
+               map_some_session_state ("Transport", "TogglePunchOut", &Session::get_punch_out);
                break;
 
        case Session::PunchIn:
-               map_some_session_state (punch_in_button, &Session::get_punch_in);
+               map_some_session_state ("Transport", "TogglePunchIn", &Session::get_punch_in);
                break;
 
        case Session::Clicking:
-               map_some_session_state (click_button, &Session::get_clicking);
+               map_some_session_state ("Transport", "ToggleClick", &Session::get_clicking);
                break;
 
        default: