gtk2_ardour/ardour_ui_ed.cc

   1 /*
   2     Copyright (C) 20002-2004 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 /* This file contains any ARDOUR_UI methods that require knowledge of
  21    the editor, and exists so that no compilation dependency exists
  22    between the main ARDOUR_UI modules and the PublicEditor class. This
  23    is to cut down on the nasty compile times for both these classes.
  24 */
  25
  26 #include <pbd/file_utils.h>
  27 #include <pbd/fpu.h>
  28
  29 #include <glibmm/miscutils.h>
  30
  31 #include <gtkmm2ext/utils.h>
  32 #include <gtkmm2ext/window_title.h>
  33
  34 #include "ardour_ui.h"
  35 #include "public_editor.h"
  36 #include "audio_clock.h"
  37 #include "engine_dialog.h"
  38 #include "editor.h"
  39 #include "actions.h"
  40 #include "mixer_ui.h"
  41
  42 #ifdef GTKOSX
  43 #include <gtkmm2ext/sync-menu.h>
  44 #endif
  45
  46 #include <ardour/session.h>
  47 #include <ardour/profile.h>
  48 #include <ardour/audioengine.h>
  49 #include <ardour/control_protocol_manager.h>
  50
  51 #include <control_protocol/control_protocol.h>
  52
  53 #include "i18n.h"
  54
  55 using namespace std;
  56 using namespace ARDOUR;
  57 using namespace PBD;
  58 using namespace Gtkmm2ext;
  59 using namespace Gtk;
  60 using namespace Glib;
  61 using namespace sigc;
  62
  63 int
  64 ARDOUR_UI::create_editor ()
  65
  66 {
  67         try {
  68                 editor = new Editor ();
  69         }
  70
  71         catch (failed_constructor& err) {
  72                 return -1;
  73         }
  74
  75         editor->Realized.connect (mem_fun (*this, &ARDOUR_UI::editor_realized));
  76
  77         return 0;
  78 }
  79
  80 void
  81 ARDOUR_UI::install_actions ()
  82 {
  83         Glib::RefPtr<ActionGroup> main_actions = ActionGroup::create (X_("Main"));
  84         Glib::RefPtr<Action> act;
  85
  86         /* menus + submenus that need action items */
  87
  88         ActionManager::register_action (main_actions, X_("Session"), _("Session"));
  89         ActionManager::register_action (main_actions, X_("Files"), _("Import/Export"));
  90         ActionManager::register_action (main_actions, X_("Cleanup"), _("Cleanup"));
  91         ActionManager::register_action (main_actions, X_("Sync"), _("Sync"));
  92         ActionManager::register_action (main_actions, X_("Options"), _("Options"));
  93         ActionManager::register_action (main_actions, X_("TransportOptions"), _("Options"));
  94         ActionManager::register_action (main_actions, X_("Help"), _("Help"));
  95         ActionManager::register_action (main_actions, X_("KeyMouseActions"), _("Misc. Shortcuts"));
  96         ActionManager::register_action (main_actions, X_("AudioFileFormat"), _("Audio File Format"));
  97         ActionManager::register_action (main_actions, X_("AudioFileFormatHeader"), _("File Type"));
  98         ActionManager::register_action (main_actions, X_("AudioFileFormatData"), _("Sample Format"));
  99         ActionManager::register_action (main_actions, X_("ControlSurfaces"), _("Control Surfaces"));
 100         ActionManager::register_action (main_actions, X_("Plugins"), _("Plugins"));
 101         ActionManager::register_action (main_actions, X_("Metering"), _("Metering"));
 102         ActionManager::register_action (main_actions, X_("MeteringFallOffRate"), _("Fall off rate"));
 103         ActionManager::register_action (main_actions, X_("MeteringHoldTime"), _("Hold Time"));
 104         ActionManager::register_action (main_actions, X_("Denormals"), _("Denormal Handling"));
 105
 106         /* the real actions */
 107
 108         act = ActionManager::register_action (main_actions, X_("New"), _("New"),  hide_return (bind (mem_fun(*this, &ARDOUR_UI::get_session_parameters), true, true)));
 109
 110         ActionManager::register_action (main_actions, X_("Open"), _("Open"),  mem_fun(*this, &ARDOUR_UI::open_session));
 111         ActionManager::register_action (main_actions, X_("Recent"), _("Recent"),  mem_fun(*this, &ARDOUR_UI::open_recent_session));
 112         act = ActionManager::register_action (main_actions, X_("Close"), _("Close"),  mem_fun(*this, &ARDOUR_UI::close_session));
 113         ActionManager::session_sensitive_actions.push_back (act);
 114
 115         act = ActionManager::register_action (main_actions, X_("AddTrackBus"), _("Add Track/Bus"),
 116                                               bind (mem_fun(*this, &ARDOUR_UI::add_route), (Gtk::Window*) 0));
 117         ActionManager::session_sensitive_actions.push_back (act);
 118
 119
 120 #ifdef WITH_CMT
 121
 122         sys::path anicomp_file_path;
 123
 124         if (PBD::find_file_in_search_path (Glib::getenv("PATH"), "AniComp", anicomp_file_path)) {
 125                 act = ActionManager::register_action (main_actions, X_("aniConnect"), _("Connect"),  (mem_fun (*editor, &PublicEditor::connect_to_image_compositor)));
 126                 ActionManager::session_sensitive_actions.push_back (act);
 127         }
 128
 129 #endif
 130
 131         act = ActionManager::register_action (main_actions, X_("Snapshot"), _("Snapshot"),  mem_fun(*this, &ARDOUR_UI::snapshot_session));
 132         ActionManager::session_sensitive_actions.push_back (act);
 133
 134         act = ActionManager::register_action (main_actions, X_("SaveTemplate"), _("Save Template..."),  mem_fun(*this, &ARDOUR_UI::save_template));
 135         ActionManager::session_sensitive_actions.push_back (act);
 136
 137         act = ActionManager::register_action (main_actions, X_("ExportSession"), _("Export session to audiofile..."),  mem_fun (*editor, &PublicEditor::export_session));
 138         ActionManager::session_sensitive_actions.push_back (act);
 139
 140         act = ActionManager::register_action (main_actions, X_("ExportSelection"), _("Export selection to audiofile..."),  mem_fun (*editor, &PublicEditor::export_selection));
 141         ActionManager::session_sensitive_actions.push_back (act);
 142         ActionManager::time_selection_sensitive_actions.push_back (act);
 143
 144         act = ActionManager::register_action (main_actions, X_("ExportRangeMarkers"), _("Export range markers to audiofile..."),  mem_fun (*editor, &PublicEditor::export_range_markers));
 145         ActionManager::session_sensitive_actions.push_back (act);
 146         ActionManager::range_sensitive_actions.push_back (act);
 147
 148         act = ActionManager::register_action (main_actions, X_("Export"), _("Export"));
 149         ActionManager::session_sensitive_actions.push_back (act);
 150
 151         act = ActionManager::register_action (main_actions, X_("CleanupUnused"), _("Cleanup unused sources"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::cleanup));
 152         ActionManager::session_sensitive_actions.push_back (act);
 153         act = ActionManager::register_action (main_actions, X_("FlushWastebasket"), _("Flush wastebasket"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::flush_trash));
 154         ActionManager::session_sensitive_actions.push_back (act);
 155
 156         /* JACK actions for controlling ... JACK */
 157
 158         Glib::RefPtr<ActionGroup> jack_actions = ActionGroup::create (X_("JACK"));
 159         ActionManager::register_action (jack_actions, X_("JACK"), _("JACK"));
 160         ActionManager::register_action (jack_actions, X_("Latency"), _("Latency"));
 161
 162         act = ActionManager::register_action (jack_actions, X_("JACKReconnect"), _("Reconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_jack));
 163         ActionManager::jack_opposite_sensitive_actions.push_back (act);
 164
 165         act = ActionManager::register_action (jack_actions, X_("JACKDisconnect"), _("Disconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_jack));
 166         ActionManager::jack_sensitive_actions.push_back (act);
 167
 168         RadioAction::Group jack_latency_group;
 169
 170         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency32"), X_("32"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 32));
 171         ActionManager::jack_sensitive_actions.push_back (act);
 172         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency64"), X_("64"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 64));
 173         ActionManager::jack_sensitive_actions.push_back (act);
 174         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency128"), X_("128"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 128));
 175         ActionManager::jack_sensitive_actions.push_back (act);
 176         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency256"), X_("256"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 256));
 177         ActionManager::jack_sensitive_actions.push_back (act);
 178         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency512"), X_("512"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 512));
 179         ActionManager::jack_sensitive_actions.push_back (act);
 180         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency1024"), X_("1024"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 1024));
 181         ActionManager::jack_sensitive_actions.push_back (act);
 182         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency2048"), X_("2048"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 2048));
 183         ActionManager::jack_sensitive_actions.push_back (act);
 184         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency4096"), X_("4096"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 4096));
 185         ActionManager::jack_sensitive_actions.push_back (act);
 186         act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency8192"), X_("8192"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 8192));
 187         ActionManager::jack_sensitive_actions.push_back (act);
 188
 189         /* these actions are intended to be shared across all windows */
 190
 191         common_actions = ActionGroup::create (X_("Common"));
 192         ActionManager::register_action (main_actions, X_("WindowMenu"), _("Window"));
 193         ActionManager::register_action (common_actions, X_("Quit"), _("Quit"), (mem_fun(*this, &ARDOUR_UI::finish)));
 194
 195         /* windows visibility actions */
 196
 197         ActionManager::register_toggle_action (common_actions, X_("ToggleMaximalEditor"), _("Maximise Editor Space"), mem_fun (*this, &ARDOUR_UI::toggle_editing_space));
 198
 199         ActionManager::register_action (common_actions, X_("goto-editor"), _("Show Editor"),  mem_fun(*this, &ARDOUR_UI::goto_editor_window));
 200         ActionManager::register_action (common_actions, X_("goto-mixer"), _("Show Mixer"),  mem_fun(*this, &ARDOUR_UI::goto_mixer_window));
 201         ActionManager::register_toggle_action (common_actions, X_("ToggleOptionsEditor"), _("Preferences"), mem_fun(*this, &ARDOUR_UI::toggle_options_window));
 202         act = ActionManager::register_toggle_action (common_actions, X_("ToggleInspector"), _("Track/Bus Inspector"), mem_fun(*this, &ARDOUR_UI::toggle_route_params_window));
 203         ActionManager::session_sensitive_actions.push_back (act);
 204         act = ActionManager::register_toggle_action (common_actions, X_("ToggleConnections"), _("Connections"), mem_fun(*this, &ARDOUR_UI::toggle_connection_editor));
 205         ActionManager::session_sensitive_actions.push_back (act);
 206         act = ActionManager::register_toggle_action (common_actions, X_("ToggleLocations"), _("Locations"), mem_fun(*this, &ARDOUR_UI::toggle_location_window));
 207         ActionManager::session_sensitive_actions.push_back (act);
 208         act = ActionManager::register_toggle_action (common_actions, X_("ToggleBigClock"), _("Big Clock"), mem_fun(*this, &ARDOUR_UI::toggle_big_clock_window));
 209         ActionManager::session_sensitive_actions.push_back (act);
 210         ActionManager::register_action (common_actions, X_("About"), _("About"),  mem_fun(*this, &ARDOUR_UI::show_about));
 211         ActionManager::register_toggle_action (common_actions, X_("ToggleThemeManager"), _("Theme Manager"), mem_fun(*this, &ARDOUR_UI::toggle_theme_manager));
 212         ActionManager::register_toggle_action (common_actions, X_("ToggleKeyEditor"), _("Keybindings"), mem_fun(*this, &ARDOUR_UI::toggle_key_editor));
 213         ActionManager::register_toggle_action (common_actions, X_("ToggleBundleManager"), _("Bundle Manager"), mem_fun(*this, &ARDOUR_UI::toggle_bundle_manager));
 214
 215         act = ActionManager::register_action (common_actions, X_("AddAudioTrack"), _("Add Audio Track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_track), 1, 1, ARDOUR::Normal, 1));
 216         ActionManager::session_sensitive_actions.push_back (act);
 217         act = ActionManager::register_action (common_actions, X_("AddAudioBus"), _("Add Audio Bus"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_bus), 1, 1, 1));
 218         ActionManager::session_sensitive_actions.push_back (act);
 219         act = ActionManager::register_action (common_actions, X_("AddMIDITrack"), _("Add MIDI Track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_midi_track), 1));
 220         ActionManager::session_sensitive_actions.push_back (act);
 221         //act = ActionManager::register_action (common_actions, X_("AddMidiBus"), _("Add Midi Bus"), mem_fun(*this, &ARDOUR_UI::session_add_midi_bus));
 222         //ActionManager::session_sensitive_actions.push_back (act);
 223         act = ActionManager::register_action (common_actions, X_("Save"), _("Save"),  bind (mem_fun(*this, &ARDOUR_UI::save_state), string("")));
 224         ActionManager::session_sensitive_actions.push_back (act);
 225         act = ActionManager::register_action (common_actions, X_("RemoveLastCapture"), _("Remove Last Capture"), mem_fun(*this, &ARDOUR_UI::remove_last_capture));
 226         ActionManager::session_sensitive_actions.push_back (act);
 227
 228         Glib::RefPtr<ActionGroup> transport_actions = ActionGroup::create (X_("Transport"));
 229
 230         /* do-nothing action for the "transport" menu bar item */
 231
 232         ActionManager::register_action (transport_actions, X_("Transport"), _("Transport"));
 233
 234         /* these two are not used by key bindings, instead use ToggleRoll for that. these two do show up in
 235            menus and via button proxies.
 236         */
 237
 238         act = ActionManager::register_action (transport_actions, X_("Stop"), _("Stop"), mem_fun(*this, &ARDOUR_UI::transport_stop));
 239         ActionManager::session_sensitive_actions.push_back (act);
 240         ActionManager::transport_sensitive_actions.push_back (act);
 241         act = ActionManager::register_action (transport_actions, X_("Roll"), _("Roll"), mem_fun(*this, &ARDOUR_UI::transport_roll));
 242         ActionManager::session_sensitive_actions.push_back (act);
 243         ActionManager::transport_sensitive_actions.push_back (act);
 244
 245         ActionManager::register_action (transport_actions, X_("ToggleRoll"), _("Start/Stop"), bind (mem_fun (*editor, &PublicEditor::toggle_playback), false));
 246         ActionManager::session_sensitive_actions.push_back (act);
 247         ActionManager::transport_sensitive_actions.push_back (act);
 248         ActionManager::register_action (transport_actions, X_("ToggleRollForgetCapture"), _("Stop + Forget Capture"), bind (mem_fun(*editor, &PublicEditor::toggle_playback), true));
 249         ActionManager::session_sensitive_actions.push_back (act);
 250         ActionManager::transport_sensitive_actions.push_back (act);
 251
 252         /* these two behave as follows:
 253
 254            - if transport speed != 1.0 or != -1.0, change speed to 1.0 or -1.0 (respectively)
 255            - otherwise do nothing
 256         */
 257
 258         ActionManager::register_action (transport_actions, X_("TransitionToRoll"), _("Transition To Roll"), bind (mem_fun (*editor, &PublicEditor::transition_to_rolling), true));
 259         ActionManager::session_sensitive_actions.push_back (act);
 260         ActionManager::session_sensitive_actions.push_back (act);
 261
 262         ActionManager::register_action (transport_actions, X_("TransitionToReverse"), _("Transition To Reverse"), bind (mem_fun (*editor, &PublicEditor::transition_to_rolling), false));
 263         ActionManager::session_sensitive_actions.push_back (act);
 264         ActionManager::session_sensitive_actions.push_back (act);
 265
 266
 267         act = ActionManager::register_action (transport_actions, X_("Loop"), _("Play Loop Range"), mem_fun(*this, &ARDOUR_UI::toggle_session_auto_loop));
 268         ActionManager::session_sensitive_actions.push_back (act);
 269         ActionManager::transport_sensitive_actions.push_back (act);
 270         act = ActionManager::register_action (transport_actions, X_("PlaySelection"), _("Play Selection"), mem_fun(*this, &ARDOUR_UI::transport_play_selection));
 271         ActionManager::session_sensitive_actions.push_back (act);
 272         ActionManager::transport_sensitive_actions.push_back (act);
 273
 274         act = ActionManager::register_action (transport_actions, X_("Record"), _("Enable Record"), bind (mem_fun(*this, &ARDOUR_UI::transport_record), false));
 275         ActionManager::session_sensitive_actions.push_back (act);
 276         act = ActionManager::register_action (transport_actions, X_("record-roll"), _("Start Recording"), bind (mem_fun(*this, &ARDOUR_UI::transport_record), true));
 277         ActionManager::session_sensitive_actions.push_back (act);
 278         ActionManager::transport_sensitive_actions.push_back (act);
 279         act = ActionManager::register_action (transport_actions, X_("Rewind"), _("Rewind"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 0));
 280         ActionManager::session_sensitive_actions.push_back (act);
 281         ActionManager::transport_sensitive_actions.push_back (act);
 282         act = ActionManager::register_action (transport_actions, X_("RewindSlow"), _("Rewind (Slow)"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), -1));
 283         ActionManager::session_sensitive_actions.push_back (act);
 284         ActionManager::transport_sensitive_actions.push_back (act);
 285         act = ActionManager::register_action (transport_actions, X_("RewindFast"), _("Rewind (Fast)"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 1));
 286         ActionManager::session_sensitive_actions.push_back (act);
 287         ActionManager::transport_sensitive_actions.push_back (act);
 288         act = ActionManager::register_action (transport_actions, X_("Forward"), _("Forward"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 0));
 289         ActionManager::session_sensitive_actions.push_back (act);
 290         ActionManager::transport_sensitive_actions.push_back (act);
 291         act = ActionManager::register_action (transport_actions, X_("ForwardSlow"), _("Forward (Slow)"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), -1));
 292         ActionManager::session_sensitive_actions.push_back (act);
 293         ActionManager::transport_sensitive_actions.push_back (act);
 294         act = ActionManager::register_action (transport_actions, X_("ForwardFast"), _("Forward (Fast)"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 1));
 295         ActionManager::session_sensitive_actions.push_back (act);
 296         ActionManager::transport_sensitive_actions.push_back (act);
 297         act = ActionManager::register_action (transport_actions, X_("GotoZero"), _("Goto Zero"), mem_fun(*this, &ARDOUR_UI::transport_goto_zero));
 298         ActionManager::session_sensitive_actions.push_back (act);
 299         ActionManager::transport_sensitive_actions.push_back (act);
 300         act = ActionManager::register_action (transport_actions, X_("GotoStart"), _("Goto Start"), mem_fun(*this, &ARDOUR_UI::transport_goto_start));
 301         ActionManager::session_sensitive_actions.push_back (act);
 302         ActionManager::transport_sensitive_actions.push_back (act);
 303         act = ActionManager::register_action (transport_actions, X_("GotoEnd"), _("Goto End"), mem_fun(*this, &ARDOUR_UI::transport_goto_end));
 304         ActionManager::session_sensitive_actions.push_back (act);
 305         ActionManager::transport_sensitive_actions.push_back (act);
 306
 307         act = ActionManager::register_action (transport_actions, X_("focus-on-clock"), _("Focus On Clock"), mem_fun(primary_clock, &AudioClock::focus));
 308         ActionManager::session_sensitive_actions.push_back (act);
 309         ActionManager::transport_sensitive_actions.push_back (act);
 310
 311         act = ActionManager::register_action (transport_actions, X_("primary-clock-bbt"), _("Bars & Beats"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::BBT));
 312         ActionManager::session_sensitive_actions.push_back (act);
 313         act = ActionManager::register_action (transport_actions, X_("primary-clock-minsec"), _("Minutes & Seconds"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::MinSec));
 314         ActionManager::session_sensitive_actions.push_back (act);
 315         act = ActionManager::register_action (transport_actions, X_("primary-clock-samples"), _("Samples"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::Frames));
 316         ActionManager::session_sensitive_actions.push_back (act);
 317         act = ActionManager::register_action (transport_actions, X_("primary-clock-off"), _("Off"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::Off));
 318         ActionManager::session_sensitive_actions.push_back (act);
 319
 320         act = ActionManager::register_action (transport_actions, X_("secondary-clock-bbt"), _("Bars & Beats"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::BBT));
 321         ActionManager::session_sensitive_actions.push_back (act);
 322         act = ActionManager::register_action (transport_actions, X_("secondary-clock-minsec"), _("Minutes & Seconds"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::MinSec));
 323         ActionManager::session_sensitive_actions.push_back (act);
 324         act = ActionManager::register_action (transport_actions, X_("secondary-clock-samples"), _("Samples"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::Frames));
 325         ActionManager::session_sensitive_actions.push_back (act);
 326         act = ActionManager::register_action (transport_actions, X_("secondary-clock-off"), _("Off"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::Off));
 327         ActionManager::session_sensitive_actions.push_back (act);
 328
 329         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunchIn"), _("Punch In"), mem_fun(*this, &ARDOUR_UI::toggle_punch_in));
 330         ActionManager::session_sensitive_actions.push_back (act);
 331         ActionManager::transport_sensitive_actions.push_back (act);
 332         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunchOut"), _("Punch Out"), mem_fun(*this, &ARDOUR_UI::toggle_punch_out));
 333         ActionManager::session_sensitive_actions.push_back (act);
 334         ActionManager::transport_sensitive_actions.push_back (act);
 335         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunch"), _("Punch In/Out"), mem_fun(*this, &ARDOUR_UI::toggle_punch));
 336         ActionManager::session_sensitive_actions.push_back (act);
 337         ActionManager::transport_sensitive_actions.push_back (act);
 338         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleClick"), _("Click"), mem_fun(*this, &ARDOUR_UI::toggle_click));
 339         ActionManager::session_sensitive_actions.push_back (act);
 340         ActionManager::transport_sensitive_actions.push_back (act);
 341         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoInput"), _("Auto Input"), mem_fun(*this, &ARDOUR_UI::toggle_auto_input));
 342         ActionManager::session_sensitive_actions.push_back (act);
 343         ActionManager::transport_sensitive_actions.push_back (act);
 344         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoPlay"), _("Auto Play"), mem_fun(*this, &ARDOUR_UI::toggle_auto_play));
 345         ActionManager::session_sensitive_actions.push_back (act);
 346         ActionManager::transport_sensitive_actions.push_back (act);
 347         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoReturn"), _("Auto Return"), mem_fun(*this, &ARDOUR_UI::toggle_auto_return));
 348         ActionManager::session_sensitive_actions.push_back (act);
 349         ActionManager::transport_sensitive_actions.push_back (act);
 350
 351         ActionManager::register_toggle_action (transport_actions, X_("ToggleVideoSync"), _("Sync startup to video"), mem_fun(*this, &ARDOUR_UI::toggle_video_sync));
 352         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleTimeMaster"), _("Time master"), mem_fun(*this, &ARDOUR_UI::toggle_time_master));
 353         ActionManager::session_sensitive_actions.push_back (act);
 354
 355         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack1"), _("Toggle Record Enable Track1"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  0U));
 356         ActionManager::session_sensitive_actions.push_back (act);
 357         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack2"), _("Toggle Record Enable Track2"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  1U));
 358         ActionManager::session_sensitive_actions.push_back (act);
 359         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack3"), _("Toggle Record Enable Track3"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  2U));
 360         ActionManager::session_sensitive_actions.push_back (act);
 361         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack4"), _("Toggle Record Enable Track4"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  3U));
 362         ActionManager::session_sensitive_actions.push_back (act);
 363         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack5"), _("Toggle Record Enable Track5"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  4U));
 364         ActionManager::session_sensitive_actions.push_back (act);
 365         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack6"), _("Toggle Record Enable Track6"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  5U));
 366         ActionManager::session_sensitive_actions.push_back (act);
 367         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack7"), _("Toggle Record Enable Track7"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  6U));
 368         ActionManager::session_sensitive_actions.push_back (act);
 369         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack8"), _("Toggle Record Enable Track8"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  7U));
 370         ActionManager::session_sensitive_actions.push_back (act);
 371         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack9"), _("Toggle Record Enable Track9"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  8U));
 372         ActionManager::session_sensitive_actions.push_back (act);
 373         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack10"), _("Toggle Record Enable Track10"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 9U));
 374         ActionManager::session_sensitive_actions.push_back (act);
 375         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack11"), _("Toggle Record Enable Track11"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 10U));
 376         ActionManager::session_sensitive_actions.push_back (act);
 377         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack12"), _("Toggle Record Enable Track12"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 11U));
 378         ActionManager::session_sensitive_actions.push_back (act);
 379         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack13"), _("Toggle Record Enable Track13"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 12U));
 380         ActionManager::session_sensitive_actions.push_back (act);
 381         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack14"), _("Toggle Record Enable Track14"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 13U));
 382         ActionManager::session_sensitive_actions.push_back (act);
 383         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack15"), _("Toggle Record Enable Track15"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 14U));
 384         ActionManager::session_sensitive_actions.push_back (act);
 385         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack16"), _("Toggle Record Enable Track16"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 15U));
 386         ActionManager::session_sensitive_actions.push_back (act);
 387         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack17"), _("Toggle Record Enable Track17"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 16U));
 388         ActionManager::session_sensitive_actions.push_back (act);
 389         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack18"), _("Toggle Record Enable Track18"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 17U));
 390         ActionManager::session_sensitive_actions.push_back (act);
 391         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack19"), _("Toggle Record Enable Track19"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 18U));
 392         ActionManager::session_sensitive_actions.push_back (act);
 393         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack20"), _("Toggle Record Enable Track20"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 19U));
 394         ActionManager::session_sensitive_actions.push_back (act);
 395         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack21"), _("Toggle Record Enable Track21"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 20U));
 396         ActionManager::session_sensitive_actions.push_back (act);
 397         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack22"), _("Toggle Record Enable Track22"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 21U));
 398         ActionManager::session_sensitive_actions.push_back (act);
 399         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack23"), _("Toggle Record Enable Track23"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 22U));
 400         ActionManager::session_sensitive_actions.push_back (act);
 401         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack24"), _("Toggle Record Enable Track24"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 23U));
 402         ActionManager::session_sensitive_actions.push_back (act);
 403         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack25"), _("Toggle Record Enable Track25"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 24U));
 404         ActionManager::session_sensitive_actions.push_back (act);
 405         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack26"), _("Toggle Record Enable Track26"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 25U));
 406         ActionManager::session_sensitive_actions.push_back (act);
 407         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack27"), _("Toggle Record Enable Track27"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 26U));
 408         ActionManager::session_sensitive_actions.push_back (act);
 409         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack28"), _("Toggle Record Enable Track28"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 27U));
 410         ActionManager::session_sensitive_actions.push_back (act);
 411         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack29"), _("Toggle Record Enable Track29"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 28U));
 412         ActionManager::session_sensitive_actions.push_back (act);
 413         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack30"), _("Toggle Record Enable Track30"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 29U));
 414         ActionManager::session_sensitive_actions.push_back (act);
 415         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack31"), _("Toggle Record Enable Track31"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 30U));
 416         ActionManager::session_sensitive_actions.push_back (act);
 417         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack32"), _("Toggle Record Enable Track32"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 31U));
 418         ActionManager::session_sensitive_actions.push_back (act);
 419
 420         Glib::RefPtr<ActionGroup> shuttle_actions = ActionGroup::create ("ShuttleActions");
 421
 422         shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Percentage)));
 423         shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Semitones)));
 424
 425         Glib::RefPtr<ActionGroup> option_actions = ActionGroup::create ("options");
 426
 427         act = ActionManager::register_toggle_action (option_actions, X_("SendMTC"), _("Send MTC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mtc));
 428         ActionManager::session_sensitive_actions.push_back (act);
 429         act = ActionManager::register_toggle_action (option_actions, X_("SendMMC"), _("Send MMC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mmc));
 430         ActionManager::session_sensitive_actions.push_back (act);
 431         act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Use MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc));
 432         ActionManager::session_sensitive_actions.push_back (act);
 433         act = ActionManager::register_toggle_action (option_actions, X_("SendMIDIfeedback"), _("Send MIDI feedback"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_feedback));
 434         ActionManager::session_sensitive_actions.push_back (act);
 435
 436         act = ActionManager::register_toggle_action (option_actions, X_("UseOSC"), _("Use OSC"), mem_fun (*this, &ARDOUR_UI::toggle_use_osc));
 437 #ifndef HAVE_LIBLO
 438         act->set_sensitive (false);
 439 #endif
 440         act = ActionManager::register_toggle_action (option_actions, X_("ToggleTapeMachineMode"), _("Tape Machine mode"), mem_fun (*this, &ARDOUR_UI::toggle_TapeMachineMode));
 441         ActionManager::session_sensitive_actions.push_back (act);
 442
 443         ActionManager::register_toggle_action (option_actions, X_("SyncEditorAndMixerTrackOrder"), _("Sync Editor and Mixer track order"), mem_fun (*this, &ARDOUR_UI::toggle_sync_order_keys));
 444         ActionManager::register_toggle_action (option_actions, X_("StopPluginsWithTransport"), _("Stop plugins with transport"), mem_fun (*this, &ARDOUR_UI::toggle_StopPluginsWithTransport));
 445         ActionManager::register_toggle_action (option_actions, X_("VerifyRemoveLastCapture"), _("Verify remove last capture"), mem_fun (*this, &ARDOUR_UI::toggle_VerifyRemoveLastCapture));
 446         ActionManager::register_toggle_action (option_actions, X_("PeriodicSafetyBackups"), _("Make periodic safety backups"), mem_fun (*this, &ARDOUR_UI::toggle_PeriodicSafetyBackups));
 447         ActionManager::register_toggle_action (option_actions, X_("StopRecordingOnXrun"), _("Stop recording on xrun"), mem_fun (*this, &ARDOUR_UI::toggle_StopRecordingOnXrun));
 448         ActionManager::register_toggle_action (option_actions, X_("CreateXrunMarker"), _("Create marker at xrun location"), mem_fun (*this, &ARDOUR_UI::toggle_CreateXrunMarker));
 449         ActionManager::register_toggle_action (option_actions, X_("StopTransportAtEndOfSession"), _("Stop transport at session end"), mem_fun (*this, &ARDOUR_UI::toggle_StopTransportAtEndOfSession));
 450         ActionManager::register_toggle_action (option_actions, X_("GainReduceFastTransport"), _("-12dB gain reduce ffwd/rewind"), mem_fun (*this, &ARDOUR_UI::toggle_GainReduceFastTransport));
 451         ActionManager::register_toggle_action (option_actions, X_("LatchedRecordEnable"), _("Rec-enable stays engaged at stop"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedRecordEnable));
 452         ActionManager::register_toggle_action (option_actions, X_("RegionEquivalentsOverlap"), _("Region equivalents overlap"), mem_fun (*this, &ARDOUR_UI::toggle_RegionEquivalentsOverlap));
 453         ActionManager::register_toggle_action (option_actions, X_("PrimaryClockDeltaEditCursor"), _("Primary Clock delta to edit point"), mem_fun (*this, &ARDOUR_UI::toggle_PrimaryClockDeltaEditCursor));
 454         ActionManager::register_toggle_action (option_actions, X_("SecondaryClockDeltaEditCursor"), _("Secondary Clock delta to edit point"), mem_fun (*this, &ARDOUR_UI::toggle_SecondaryClockDeltaEditCursor));
 455         ActionManager::register_toggle_action (option_actions, X_("ShowTrackMeters"), _("Enable Editor Meters"), mem_fun (*this, &ARDOUR_UI::toggle_ShowTrackMeters));
 456         ActionManager::register_toggle_action (option_actions, X_("OnlyCopyImportedFiles"), _("Always copy imported files"), mem_fun (*this, &ARDOUR_UI::toggle_only_copy_imported_files));
 457         ActionManager::register_toggle_action (option_actions, X_("RubberbandingSnapsToGrid"), _("Rubberbanding Snaps to Grid"), mem_fun (*this, &ARDOUR_UI::toggle_rubberbanding_snaps_to_grid));
 458         ActionManager::register_toggle_action (option_actions, X_("AutoAnalyseAudio"), _("Auto-analyse new audio"), mem_fun (*this, &ARDOUR_UI::toggle_auto_analyse_audio));
 459
 460         ActionManager::register_toggle_action (option_actions, X_("DefaultNarrowMS"), _("Use narrow mixer strips"), mem_fun (*this, &ARDOUR_UI::toggle_use_narrow_ms));
 461
 462         RadioAction::Group denormal_group;
 463
 464         ActionManager::register_toggle_action (option_actions, X_("DenormalProtection"), _("Use DC bias"), mem_fun (*this, &ARDOUR_UI::toggle_denormal_protection));
 465         ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalNone"), _("No processor handling"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalNone));
 466
 467         // as of September 10th 2007, Valgrind cannot handle various FPU flag setting instructions
 468         // so avoid them
 469
 470         if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
 471
 472                 /* we still need these actions to exist, but make them all insensitive */
 473
 474                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 475                 act->set_sensitive (false);
 476                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 477                 act->set_sensitive (false);
 478                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 479                 act->set_sensitive (false);
 480
 481         } else {
 482
 483                 FPU fpu;
 484
 485                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 486                 if (!fpu.has_flush_to_zero()) {
 487                         act->set_sensitive (false);
 488                 }
 489
 490                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 491                 if (!fpu.has_denormals_are_zero()) {
 492                         act->set_sensitive (false);
 493                 }
 494
 495                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 496                 if (!fpu.has_flush_to_zero() || !fpu.has_denormals_are_zero()) {
 497                         act->set_sensitive (false);
 498                 }
 499         }
 500
 501         act = ActionManager::register_toggle_action (option_actions, X_("DoNotRunPluginsWhileRecording"), _("Do not run plugins while recording"), mem_fun (*this, &ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording));
 502         ActionManager::session_sensitive_actions.push_back (act);
 503
 504         act = ActionManager::register_toggle_action (option_actions, X_("LatchedSolo"), _("Latched solo"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedSolo));
 505         ActionManager::session_sensitive_actions.push_back (act);
 506         act = ActionManager::register_toggle_action (option_actions, X_("ShowSoloMutes"), _("Show solo muting"), mem_fun (*this, &ARDOUR_UI::toggle_ShowSoloMutes));
 507         ActionManager::session_sensitive_actions.push_back (act);
 508
 509         /* act = ActionManager::register_action (option_actions, X_("DisableAllPlugins"), _("Disable All Plugins"), mem_fun (*this, &ARDOUR_UI::disable_all_plugins));
 510         ActionManager::session_sensitive_actions.push_back (act);
 511         act = ActionManager::register_action (option_actions, X_("ABAllPlugins"), _("A/B All Plugins"), mem_fun (*this, &ARDOUR_UI::ab_all_plugins));
 512         ActionManager::session_sensitive_actions.push_back (act); */
 513
 514         /* !!! REMEMBER THAT RADIO ACTIONS HAVE TO BE HANDLED WITH MORE FINESSE THAN SIMPLE TOGGLES !!! */
 515
 516         RadioAction::Group meter_falloff_group;
 517         RadioAction::Group meter_hold_group;
 518
 519         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffOff));
 520         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlowest));
 521         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlow));
 522         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffMedium));
 523         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFast));
 524         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFaster));
 525         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFastest));
 526
 527         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldOff));
 528         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldShort));
 529         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldMedium));
 530         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldLong));
 531
 532         RadioAction::Group file_header_group;
 533
 534         act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatBWF"), X_("Broadcast WAVE"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::BWF));
 535         act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatWAVE"), X_("WAVE"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::WAVE));
 536         act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatWAVE64"), X_("WAVE-64"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::WAVE64));
 537         // act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatiXML"), X_("iXML"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::iXML));
 538         // act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatRF64"), X_("RF64"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::RF64));
 539         act = ActionManager::register_radio_action (option_actions, file_header_group, X_("FileHeaderFormatCAF"), X_("CAF"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_header_format), ARDOUR::CAF));
 540
 541         RadioAction::Group file_data_group;
 542
 543
 544         act = ActionManager::register_radio_action (option_actions, file_data_group, X_("FileDataFormatFloat"), X_("32-bit floating point"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_data_format), ARDOUR::FormatFloat));
 545         act = ActionManager::register_radio_action (option_actions, file_data_group, X_("FileDataFormat24bit"), X_("24-bit integer"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_data_format), ARDOUR::FormatInt24));
 546         act = ActionManager::register_radio_action (option_actions, file_data_group, X_("FileDataFormat16bit"), X_("16-bit integer"), bind (mem_fun (*this, &ARDOUR_UI::set_native_file_data_format), ARDOUR::FormatInt16));
 547
 548         RadioAction::Group monitoring_group;
 549
 550         /* it would be nice not to even show this item, but that messes up the
 551            menus which are not dynamically modified at runtime. so we make it
 552            sensitive only if it makes sense.
 553         */
 554
 555         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseHardwareMonitoring"), _("JACK does monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), HardwareMonitoring));
 556         if (engine->can_request_hardware_monitoring()) {
 557                 act->set_sensitive (false);
 558         }
 559         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseSoftwareMonitoring"), _("Ardour does monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), SoftwareMonitoring));
 560         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseExternalMonitoring"), _("Audio Hardware does monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), ExternalMonitoring));
 561
 562         RadioAction::Group solo_group;
 563
 564         act = ActionManager::register_radio_action (option_actions, solo_group, X_("SoloInPlace"), _("Solo in-place"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_solo_model), InverseMute)));
 565         ActionManager::session_sensitive_actions.push_back (act);
 566         act = ActionManager::register_radio_action (option_actions, solo_group, X_("SoloViaBus"), _("Solo via bus"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_solo_model), SoloBus)));
 567         ActionManager::session_sensitive_actions.push_back (act);
 568
 569         RadioAction::Group input_auto_connect_group;
 570
 571         act = ActionManager::register_radio_action (option_actions, input_auto_connect_group, X_("InputAutoConnectPhysical"), _("Auto-connect inputs to physical inputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_input_auto_connect), AutoConnectPhysical)));
 572         ActionManager::session_sensitive_actions.push_back (act);
 573         act = ActionManager::register_radio_action (option_actions, input_auto_connect_group, X_("InputAutoConnectManual"), _("Manually connect inputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_input_auto_connect), (AutoConnectOption) 0)));
 574         ActionManager::session_sensitive_actions.push_back (act);
 575
 576         RadioAction::Group output_auto_connect_group;
 577
 578         act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectPhysical"), _("Auto-connect outputs to physical outs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), AutoConnectPhysical)));
 579         ActionManager::session_sensitive_actions.push_back (act);
 580         act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectMaster"), _("Auto-connect outputs to master bus"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), AutoConnectMaster)));
 581         ActionManager::session_sensitive_actions.push_back (act);
 582         act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectManual"), _("Manually connect outputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), (AutoConnectOption) 0)));
 583         ActionManager::session_sensitive_actions.push_back (act);
 584
 585         RadioAction::Group remote_group;
 586
 587         act = ActionManager::register_radio_action (option_actions, remote_group, X_("RemoteUserDefined"), _("Remote ID assigned by User"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_remote_model), UserOrdered)));
 588         ActionManager::session_sensitive_actions.push_back (act);
 589         act = ActionManager::register_radio_action (option_actions, remote_group, X_("RemoteMixerDefined"), _("Remote ID follows order of Mixer"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_remote_model), MixerOrdered)));
 590         ActionManager::session_sensitive_actions.push_back (act);
 591         act = ActionManager::register_radio_action (option_actions, remote_group, X_("RemoteEditorDefined"), _("Remote ID follows order of Editor"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_remote_model), EditorOrdered)));
 592         ActionManager::session_sensitive_actions.push_back (act);
 593
 594         act = ActionManager::register_toggle_action (option_actions, X_("AutoRebinding"), _("Auto Rebind Controls"), mem_fun (*(this->mixer), &Mixer_UI::toggle_auto_rebinding));
 595         ActionManager::session_sensitive_actions.push_back (act);
 596
 597
 598         ActionManager::add_action_group (shuttle_actions);
 599         ActionManager::add_action_group (option_actions);
 600         ActionManager::add_action_group (jack_actions);
 601         ActionManager::add_action_group (transport_actions);
 602         ActionManager::add_action_group (main_actions);
 603         ActionManager::add_action_group (common_actions);
 604 }
 605
 606 void
 607 ARDOUR_UI::toggle_control_protocol (ControlProtocolInfo* cpi)
 608 {
 609         if (!session) {
 610                 /* this happens when we build the menu bar when control protocol support
 611                    has been used in the past for some given protocol - the item needs
 612                    to be made active, but there is no session yet.
 613                 */
 614                 return;
 615         }
 616
 617         if (cpi->protocol == 0) {
 618                 ControlProtocolManager::instance().instantiate (*cpi);
 619         } else {
 620                 ControlProtocolManager::instance().teardown (*cpi);
 621         }
 622 }
 623
 624 void
 625 ARDOUR_UI::toggle_control_protocol_feedback (ControlProtocolInfo* cpi, const char* group, string action)
 626 {
 627         if (!session) {
 628                 /* this happens when we build the menu bar when control protocol support
 629                    has been used in the past for some given protocol - the item needs
 630                    to be made active, but there is no session yet.
 631                 */
 632                 return;
 633         }
 634
 635         if (cpi->protocol) {
 636                 Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (group, action.c_str());
 637
 638                 if (act) {
 639                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 640
 641                         if (tact) {
 642                                 bool x = tact->get_active();
 643
 644                                 if (x != cpi->protocol->get_feedback()) {
 645                                         cpi->protocol->set_feedback (x);
 646                                 }
 647                         }
 648                 }
 649         }
 650 }
 651
 652 void
 653 ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
 654 {
 655         Glib::RefPtr<Action> action;
 656         const char* action_name = 0;
 657
 658         switch (nframes) {
 659         case 32:
 660                 action_name = X_("JACKLatency32");
 661                 break;
 662         case 64:
 663                 action_name = X_("JACKLatency64");
 664                 break;
 665         case 128:
 666                 action_name = X_("JACKLatency128");
 667                 break;
 668         case 512:
 669                 action_name = X_("JACKLatency512");
 670                 break;
 671         case 1024:
 672                 action_name = X_("JACKLatency1024");
 673                 break;
 674         case 2048:
 675                 action_name = X_("JACKLatency2048");
 676                 break;
 677         case 4096:
 678                 action_name = X_("JACKLatency4096");
 679                 break;
 680         case 8192:
 681                 action_name = X_("JACKLatency8192");
 682                 break;
 683         default:
 684                 /* XXX can we do anything useful ? */
 685                 break;
 686         }
 687
 688         if (action_name) {
 689
 690                 action = ActionManager::get_action (X_("JACK"), action_name);
 691
 692                 if (action) {
 693                         Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
 694
 695                         if (ract && ract->get_active()) {
 696                                 engine->request_buffer_size (nframes);
 697                                 update_sample_rate (0);
 698                         }
 699                 }
 700         }
 701 }
 702
 703 void
 704 ARDOUR_UI::build_control_surface_menu ()
 705 {
 706         list<ControlProtocolInfo*>::iterator i;
 707         bool with_feedback;
 708
 709         /* !!! this has to match the top level entry from ardour.menus */
 710
 711         string ui = "<menubar name='Main' action='MainMenu'>\n<menu name='Options' action='Options'>\n<menu action='ControlSurfaces'><separator/>\n";
 712
 713         for (i = ControlProtocolManager::instance().control_protocol_info.begin(); i != ControlProtocolManager::instance().control_protocol_info.end(); ++i) {
 714
 715                 if (!(*i)->mandatory) {
 716
 717                         string action_name = "Toggle";
 718                         action_name += legalize_for_path ((*i)->name);
 719                         action_name += "Surface";
 720
 721                         string action_label = (*i)->name;
 722
 723                         Glib::RefPtr<Action> act = ActionManager::register_toggle_action (editor->editor_actions, action_name.c_str(), action_label.c_str(),
 724                                                                                           (bind (mem_fun (*this, &ARDOUR_UI::toggle_control_protocol), *i)));
 725
 726                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 727
 728                         with_feedback = false;
 729
 730                         if ((*i)->protocol || (*i)->requested) {
 731                                 tact->set_active ();
 732                         }
 733
 734                         ui += "<menuitem action='";
 735                         ui += action_name;
 736                         ui += "'/>\n";
 737
 738                         if ((*i)->supports_feedback) {
 739
 740                                 string submenu_name = action_name;
 741
 742                                 submenu_name += "SubMenu";
 743
 744                                 ActionManager::register_action (editor->editor_actions, submenu_name.c_str(), _("Controls"));
 745
 746                                 action_name += "Feedback";
 747
 748                                 Glib::RefPtr<Action> act = ActionManager::register_toggle_action (editor->editor_actions, action_name.c_str(), _("Feedback"),
 749                                                                                                   (bind (mem_fun (*this, &ARDOUR_UI::toggle_control_protocol_feedback),
 750                                                                                                          *i,
 751                                                                                                          "Editor",
 752                                                                                                          action_name)));
 753
 754                                 ui += "<menu action='";
 755                                 ui += submenu_name;
 756                                 ui += "'>\n<menuitem action='";
 757                                 ui += action_name;
 758                                 ui += "'/>\n</menu>\n";
 759
 760                                 if ((*i)->protocol) {
 761                                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 762                                         tact->set_active ((*i)->protocol->get_feedback ());
 763                                 }
 764                         }
 765                 }
 766         }
 767
 768         ui += "</menu>\n</menu>\n</menubar>\n";
 769
 770         ActionManager::ui_manager->add_ui_from_string (ui);
 771 }
 772
 773 void
 774 ARDOUR_UI::build_menu_bar ()
 775 {
 776         if (!Profile->get_sae()) {
 777                 build_control_surface_menu ();
 778         }
 779
 780         menu_bar = dynamic_cast<MenuBar*> (ActionManager::get_widget (X_("/Main")));
 781         menu_bar->set_name ("MainMenuBar");
 782
 783         /*
 784          * This is needed because this property does not get installed
 785          * until the Menu GObject class is registered, which happens
 786          * when the first menu instance is created.
 787          */
 788         // XXX bug in gtkmm causes this to popup an error message
 789         // Gtk::Settings::get_default()->property_gtk_can_change_accels() = true;
 790         // so use this instead ...
 791         gtk_settings_set_long_property (gtk_settings_get_default(), "gtk-can-change-accels", 1, "Ardour:designers");
 792
 793         wall_clock_box.add (wall_clock_label);
 794         wall_clock_box.set_name ("WallClock");
 795         wall_clock_label.set_name ("WallClock");
 796
 797         disk_space_box.add (disk_space_label);
 798         disk_space_box.set_name ("WallClock");
 799         disk_space_label.set_name ("WallClock");
 800
 801         cpu_load_box.add (cpu_load_label);
 802         cpu_load_box.set_name ("CPULoad");
 803         cpu_load_label.set_name ("CPULoad");
 804
 805         buffer_load_box.add (buffer_load_label);
 806         buffer_load_box.set_name ("BufferLoad");
 807         buffer_load_label.set_name ("BufferLoad");
 808
 809         sample_rate_box.add (sample_rate_label);
 810         sample_rate_box.set_name ("SampleRate");
 811         sample_rate_label.set_name ("SampleRate");
 812
 813 #ifndef TOP_MENUBAR
 814         menu_hbox.pack_start (*menu_bar, true, true);
 815 #else
 816         use_menubar_as_top_menubar ();
 817 #endif
 818
 819         if (!Profile->get_small_screen()) {
 820 #ifndef GTKOSX
 821                 // OSX provides its own wallclock, thank you very much
 822                 menu_hbox.pack_end (wall_clock_box, false, false, 2);
 823 #endif
 824                 menu_hbox.pack_end (disk_space_box, false, false, 4);
 825         }
 826
 827         menu_hbox.pack_end (cpu_load_box, false, false, 4);
 828         menu_hbox.pack_end (buffer_load_box, false, false, 4);
 829         menu_hbox.pack_end (sample_rate_box, false, false, 4);
 830
 831         menu_bar_base.set_name ("MainMenuBar");
 832         menu_bar_base.add (menu_hbox);
 833 }
 834
 835 void
 836 ARDOUR_UI::use_menubar_as_top_menubar ()
 837 {
 838 #ifdef GTKOSX
 839         ige_mac_menu_set_menu_bar ((GtkMenuShell*) menu_bar->gobj());
 840         // ige_mac_menu_set_quit_menu_item (some_item->gobj());
 841 #endif
 842 }
 843
 844
 845 void
 846 ARDOUR_UI::setup_clock ()
 847 {
 848         ARDOUR_UI::Clock.connect (bind (mem_fun (big_clock, &AudioClock::set), false));
 849
 850         big_clock_window = new Window (WINDOW_TOPLEVEL);
 851
 852         big_clock_window->set_keep_above (true);
 853         big_clock_window->set_border_width (0);
 854         big_clock_window->add  (big_clock);
 855
 856         WindowTitle title(Glib::get_application_name());
 857         title += _("Clock");
 858         big_clock_window->set_title (title.get_string());
 859         big_clock_window->set_type_hint (Gdk::WINDOW_TYPE_HINT_MENU);
 860         big_clock_window->signal_realize().connect (bind (sigc::ptr_fun (set_decoration), big_clock_window,  (Gdk::DECOR_BORDER|Gdk::DECOR_RESIZEH)));
 861         big_clock_window->signal_unmap().connect (bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleBigClock")));
 862
 863         manage_window (*big_clock_window);
 864 }