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