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