gtk2_ardour/ardour_ui_ed.cc

   1 /*
   2     Copyright (C) 20002-2004 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /* This file contains any ARDOUR_UI methods that require knowledge of
  21    the editor, and exists so that no compilation dependency exists
  22    between the main ARDOUR_UI modules and the PublicEditor class. This
  23    is to cut down on the nasty compile times for both these classes.
  24 */
  25
  26 #include <pbd/file_utils.h>
  27 #include <pbd/fpu.h>
  28
  29 #include <glibmm/miscutils.h>
  30
  31 #include <gtkmm2ext/utils.h>
  32 #include <gtkmm2ext/window_title.h>
  33 #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_("Plugins"), _("Plugins"));
 103         ActionManager::register_action (main_actions, X_("Metering"), _("Metering"));
 104         ActionManager::register_action (main_actions, X_("MeteringFallOffRate"), _("Fall off rate"));
 105         ActionManager::register_action (main_actions, X_("MeteringHoldTime"), _("Hold Time"));
 106         ActionManager::register_action (main_actions, X_("Denormals"), _("Denormal Handling"));
 107
 108         /* the real actions */
 109
 110         act = ActionManager::register_action (main_actions, X_("New"), _("New"),  hide_return (bind (mem_fun(*this, &ARDOUR_UI::get_session_parameters), true, true)));
 111
 112         ActionManager::register_action (main_actions, X_("Open"), _("Open"),  mem_fun(*this, &ARDOUR_UI::open_session));
 113         ActionManager::register_action (main_actions, X_("Recent"), _("Recent"),  mem_fun(*this, &ARDOUR_UI::open_recent_session));
 114         act = ActionManager::register_action (main_actions, X_("Close"), _("Close"),  mem_fun(*this, &ARDOUR_UI::close_session));
 115         ActionManager::session_sensitive_actions.push_back (act);
 116
 117         act = ActionManager::register_action (main_actions, X_("AddTrackBus"), _("Add Track/Bus"),
 118                                               bind (mem_fun(*this, &ARDOUR_UI::add_route), (Gtk::Window*) 0));
 119         ActionManager::session_sensitive_actions.push_back (act);
 120
 121
 122 #ifdef WITH_CMT
 123
 124         sys::path anicomp_file_path;
 125
 126         if (PBD::find_file_in_search_path (Glib::getenv("PATH"), "AniComp", anicomp_file_path)) {
 127                 act = ActionManager::register_action (main_actions, X_("aniConnect"), _("Connect"),  (mem_fun (*editor, &PublicEditor::connect_to_image_compositor)));
 128                 ActionManager::session_sensitive_actions.push_back (act);
 129         }
 130
 131 #endif
 132
 133         act = ActionManager::register_action (main_actions, X_("Snapshot"), _("Snapshot"),  mem_fun(*this, &ARDOUR_UI::snapshot_session));
 134         ActionManager::session_sensitive_actions.push_back (act);
 135
 136         act = ActionManager::register_action (main_actions, X_("SaveTemplate"), _("Save Template..."),  mem_fun(*this, &ARDOUR_UI::save_template));
 137         ActionManager::session_sensitive_actions.push_back (act);
 138
 139         act = ActionManager::register_action (main_actions, X_("Metadata"), _("Metadata"));
 140         ActionManager::session_sensitive_actions.push_back (act);
 141
 142         act = ActionManager::register_action (main_actions, X_("EditMetadata"), _("Edit Metadata"),  mem_fun(*this, &ARDOUR_UI::edit_metadata));
 143         ActionManager::session_sensitive_actions.push_back (act);
 144
 145         act = ActionManager::register_action (main_actions, X_("ImportMetadata"), _("Import Metadata"),  mem_fun(*this, &ARDOUR_UI::import_metadata));
 146         ActionManager::session_sensitive_actions.push_back (act);
 147
 148         act = ActionManager::register_action (main_actions, X_("ExportAudio"), _("Export to audiofile(s)..."),  mem_fun (*editor, &PublicEditor::export_audio));
 149         ActionManager::session_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         ActionManager::register_toggle_action (common_actions, X_("ToggleBundleManager"), _("Bundle Manager"), mem_fun(*this, &ARDOUR_UI::toggle_bundle_manager));
 217
 218         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));
 219         ActionManager::session_sensitive_actions.push_back (act);
 220         act = ActionManager::register_action (common_actions, X_("AddAudioBus"), _("Add Audio Bus"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_bus), 1, 1, 1));
 221         ActionManager::session_sensitive_actions.push_back (act);
 222         act = ActionManager::register_action (common_actions, X_("AddMIDITrack"), _("Add MIDI Track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_midi_track), 1));
 223         ActionManager::session_sensitive_actions.push_back (act);
 224         //act = ActionManager::register_action (common_actions, X_("AddMidiBus"), _("Add Midi Bus"), mem_fun(*this, &ARDOUR_UI::session_add_midi_bus));
 225         //ActionManager::session_sensitive_actions.push_back (act);
 226         act = ActionManager::register_action (common_actions, X_("Save"), _("Save"),  bind (mem_fun(*this, &ARDOUR_UI::save_state), string("")));
 227         ActionManager::session_sensitive_actions.push_back (act);
 228         act = ActionManager::register_action (common_actions, X_("RemoveLastCapture"), _("Remove Last Capture"), mem_fun(*this, &ARDOUR_UI::remove_last_capture));
 229         ActionManager::session_sensitive_actions.push_back (act);
 230
 231         Glib::RefPtr<ActionGroup> transport_actions = ActionGroup::create (X_("Transport"));
 232
 233         /* do-nothing action for the "transport" menu bar item */
 234
 235         ActionManager::register_action (transport_actions, X_("Transport"), _("Transport"));
 236
 237         /* these two are not used by key bindings, instead use ToggleRoll for that. these two do show up in
 238            menus and via button proxies.
 239         */
 240
 241         act = ActionManager::register_action (transport_actions, X_("Stop"), _("Stop"), mem_fun(*this, &ARDOUR_UI::transport_stop));
 242         ActionManager::session_sensitive_actions.push_back (act);
 243         ActionManager::transport_sensitive_actions.push_back (act);
 244         act = ActionManager::register_action (transport_actions, X_("Roll"), _("Roll"), mem_fun(*this, &ARDOUR_UI::transport_roll));
 245         ActionManager::session_sensitive_actions.push_back (act);
 246         ActionManager::transport_sensitive_actions.push_back (act);
 247
 248         ActionManager::register_action (transport_actions, X_("ToggleRoll"), _("Start/Stop"), bind (mem_fun (*editor, &PublicEditor::toggle_playback), false));
 249         ActionManager::session_sensitive_actions.push_back (act);
 250         ActionManager::transport_sensitive_actions.push_back (act);
 251         ActionManager::register_action (transport_actions, X_("ToggleRollForgetCapture"), _("Stop + Forget Capture"), bind (mem_fun(*editor, &PublicEditor::toggle_playback), true));
 252         ActionManager::session_sensitive_actions.push_back (act);
 253         ActionManager::transport_sensitive_actions.push_back (act);
 254
 255         /* these two behave as follows:
 256
 257            - if transport speed != 1.0 or != -1.0, change speed to 1.0 or -1.0 (respectively)
 258            - otherwise do nothing
 259         */
 260
 261         ActionManager::register_action (transport_actions, X_("TransitionToRoll"), _("Transition To Roll"), bind (mem_fun (*editor, &PublicEditor::transition_to_rolling), true));
 262         ActionManager::session_sensitive_actions.push_back (act);
 263         ActionManager::session_sensitive_actions.push_back (act);
 264
 265         ActionManager::register_action (transport_actions, X_("TransitionToReverse"), _("Transition To Reverse"), bind (mem_fun (*editor, &PublicEditor::transition_to_rolling), false));
 266         ActionManager::session_sensitive_actions.push_back (act);
 267         ActionManager::session_sensitive_actions.push_back (act);
 268
 269
 270         act = ActionManager::register_action (transport_actions, X_("Loop"), _("Play Loop Range"), mem_fun(*this, &ARDOUR_UI::toggle_session_auto_loop));
 271         ActionManager::session_sensitive_actions.push_back (act);
 272         ActionManager::transport_sensitive_actions.push_back (act);
 273         act = ActionManager::register_action (transport_actions, X_("PlaySelection"), _("Play Selection"), mem_fun(*this, &ARDOUR_UI::transport_play_selection));
 274         ActionManager::session_sensitive_actions.push_back (act);
 275         ActionManager::transport_sensitive_actions.push_back (act);
 276
 277         act = ActionManager::register_action (transport_actions, X_("Record"), _("Enable Record"), bind (mem_fun(*this, &ARDOUR_UI::transport_record), false));
 278         ActionManager::session_sensitive_actions.push_back (act);
 279         act = ActionManager::register_action (transport_actions, X_("record-roll"), _("Start Recording"), bind (mem_fun(*this, &ARDOUR_UI::transport_record), true));
 280         ActionManager::session_sensitive_actions.push_back (act);
 281         ActionManager::transport_sensitive_actions.push_back (act);
 282         act = ActionManager::register_action (transport_actions, X_("Rewind"), _("Rewind"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 0));
 283         ActionManager::session_sensitive_actions.push_back (act);
 284         ActionManager::transport_sensitive_actions.push_back (act);
 285         act = ActionManager::register_action (transport_actions, X_("RewindSlow"), _("Rewind (Slow)"), 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_("RewindFast"), _("Rewind (Fast)"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 1));
 289         ActionManager::session_sensitive_actions.push_back (act);
 290         ActionManager::transport_sensitive_actions.push_back (act);
 291         act = ActionManager::register_action (transport_actions, X_("Forward"), _("Forward"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 0));
 292         ActionManager::session_sensitive_actions.push_back (act);
 293         ActionManager::transport_sensitive_actions.push_back (act);
 294         act = ActionManager::register_action (transport_actions, X_("ForwardSlow"), _("Forward (Slow)"), 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_("ForwardFast"), _("Forward (Fast)"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 1));
 298         ActionManager::session_sensitive_actions.push_back (act);
 299         ActionManager::transport_sensitive_actions.push_back (act);
 300         act = ActionManager::register_action (transport_actions, X_("GotoZero"), _("Goto Zero"), mem_fun(*this, &ARDOUR_UI::transport_goto_zero));
 301         ActionManager::session_sensitive_actions.push_back (act);
 302         ActionManager::transport_sensitive_actions.push_back (act);
 303         act = ActionManager::register_action (transport_actions, X_("GotoStart"), _("Goto Start"), mem_fun(*this, &ARDOUR_UI::transport_goto_start));
 304         ActionManager::session_sensitive_actions.push_back (act);
 305         ActionManager::transport_sensitive_actions.push_back (act);
 306         act = ActionManager::register_action (transport_actions, X_("GotoEnd"), _("Goto End"), mem_fun(*this, &ARDOUR_UI::transport_goto_end));
 307         ActionManager::session_sensitive_actions.push_back (act);
 308         ActionManager::transport_sensitive_actions.push_back (act);
 309         act = ActionManager::register_action (transport_actions, X_("GotoWallClock"), _("Goto Wall Clock"), mem_fun(*this, &ARDOUR_UI::transport_goto_wallclock));
 310         ActionManager::session_sensitive_actions.push_back (act);
 311         ActionManager::transport_sensitive_actions.push_back (act);
 312
 313         act = ActionManager::register_action (transport_actions, X_("focus-on-clock"), _("Focus On Clock"), mem_fun(primary_clock, &AudioClock::focus));
 314         ActionManager::session_sensitive_actions.push_back (act);
 315         ActionManager::transport_sensitive_actions.push_back (act);
 316
 317         act = ActionManager::register_action (transport_actions, X_("primary-clock-bbt"), _("Bars & Beats"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::BBT));
 318         ActionManager::session_sensitive_actions.push_back (act);
 319         act = ActionManager::register_action (transport_actions, X_("primary-clock-minsec"), _("Minutes & Seconds"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::MinSec));
 320         ActionManager::session_sensitive_actions.push_back (act);
 321         act = ActionManager::register_action (transport_actions, X_("primary-clock-samples"), _("Samples"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::Frames));
 322         ActionManager::session_sensitive_actions.push_back (act);
 323         act = ActionManager::register_action (transport_actions, X_("primary-clock-off"), _("Off"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::Off));
 324         ActionManager::session_sensitive_actions.push_back (act);
 325
 326         act = ActionManager::register_action (transport_actions, X_("secondary-clock-bbt"), _("Bars & Beats"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::BBT));
 327         ActionManager::session_sensitive_actions.push_back (act);
 328         act = ActionManager::register_action (transport_actions, X_("secondary-clock-minsec"), _("Minutes & Seconds"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::MinSec));
 329         ActionManager::session_sensitive_actions.push_back (act);
 330         act = ActionManager::register_action (transport_actions, X_("secondary-clock-samples"), _("Samples"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::Frames));
 331         ActionManager::session_sensitive_actions.push_back (act);
 332         act = ActionManager::register_action (transport_actions, X_("secondary-clock-off"), _("Off"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::Off));
 333         ActionManager::session_sensitive_actions.push_back (act);
 334
 335         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunchIn"), _("Punch In"), mem_fun(*this, &ARDOUR_UI::toggle_punch_in));
 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_("TogglePunchOut"), _("Punch Out"), mem_fun(*this, &ARDOUR_UI::toggle_punch_out));
 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_("TogglePunch"), _("Punch In/Out"), mem_fun(*this, &ARDOUR_UI::toggle_punch));
 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_("ToggleClick"), _("Click"), mem_fun(*this, &ARDOUR_UI::toggle_click));
 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_("ToggleAutoInput"), _("Auto Input"), mem_fun(*this, &ARDOUR_UI::toggle_auto_input));
 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_("ToggleAutoPlay"), _("Auto Play"), mem_fun(*this, &ARDOUR_UI::toggle_auto_play));
 351         ActionManager::session_sensitive_actions.push_back (act);
 352         ActionManager::transport_sensitive_actions.push_back (act);
 353         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoReturn"), _("Auto Return"), mem_fun(*this, &ARDOUR_UI::toggle_auto_return));
 354         ActionManager::session_sensitive_actions.push_back (act);
 355         ActionManager::transport_sensitive_actions.push_back (act);
 356
 357         ActionManager::register_toggle_action (transport_actions, X_("ToggleVideoSync"), _("Sync startup to video"), mem_fun(*this, &ARDOUR_UI::toggle_video_sync));
 358         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleTimeMaster"), _("Time master"), mem_fun(*this, &ARDOUR_UI::toggle_time_master));
 359         ActionManager::session_sensitive_actions.push_back (act);
 360
 361         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack1"), _("Toggle Record Enable Track1"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  0U));
 362         ActionManager::session_sensitive_actions.push_back (act);
 363         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack2"), _("Toggle Record Enable Track2"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  1U));
 364         ActionManager::session_sensitive_actions.push_back (act);
 365         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack3"), _("Toggle Record Enable Track3"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  2U));
 366         ActionManager::session_sensitive_actions.push_back (act);
 367         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack4"), _("Toggle Record Enable Track4"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  3U));
 368         ActionManager::session_sensitive_actions.push_back (act);
 369         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack5"), _("Toggle Record Enable Track5"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  4U));
 370         ActionManager::session_sensitive_actions.push_back (act);
 371         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack6"), _("Toggle Record Enable Track6"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  5U));
 372         ActionManager::session_sensitive_actions.push_back (act);
 373         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack7"), _("Toggle Record Enable Track7"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  6U));
 374         ActionManager::session_sensitive_actions.push_back (act);
 375         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack8"), _("Toggle Record Enable Track8"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  7U));
 376         ActionManager::session_sensitive_actions.push_back (act);
 377         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack9"), _("Toggle Record Enable Track9"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  8U));
 378         ActionManager::session_sensitive_actions.push_back (act);
 379         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack10"), _("Toggle Record Enable Track10"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 9U));
 380         ActionManager::session_sensitive_actions.push_back (act);
 381         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack11"), _("Toggle Record Enable Track11"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 10U));
 382         ActionManager::session_sensitive_actions.push_back (act);
 383         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack12"), _("Toggle Record Enable Track12"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 11U));
 384         ActionManager::session_sensitive_actions.push_back (act);
 385         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack13"), _("Toggle Record Enable Track13"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 12U));
 386         ActionManager::session_sensitive_actions.push_back (act);
 387         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack14"), _("Toggle Record Enable Track14"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 13U));
 388         ActionManager::session_sensitive_actions.push_back (act);
 389         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack15"), _("Toggle Record Enable Track15"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 14U));
 390         ActionManager::session_sensitive_actions.push_back (act);
 391         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack16"), _("Toggle Record Enable Track16"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 15U));
 392         ActionManager::session_sensitive_actions.push_back (act);
 393         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack17"), _("Toggle Record Enable Track17"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 16U));
 394         ActionManager::session_sensitive_actions.push_back (act);
 395         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack18"), _("Toggle Record Enable Track18"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 17U));
 396         ActionManager::session_sensitive_actions.push_back (act);
 397         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack19"), _("Toggle Record Enable Track19"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 18U));
 398         ActionManager::session_sensitive_actions.push_back (act);
 399         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack20"), _("Toggle Record Enable Track20"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 19U));
 400         ActionManager::session_sensitive_actions.push_back (act);
 401         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack21"), _("Toggle Record Enable Track21"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 20U));
 402         ActionManager::session_sensitive_actions.push_back (act);
 403         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack22"), _("Toggle Record Enable Track22"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 21U));
 404         ActionManager::session_sensitive_actions.push_back (act);
 405         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack23"), _("Toggle Record Enable Track23"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 22U));
 406         ActionManager::session_sensitive_actions.push_back (act);
 407         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack24"), _("Toggle Record Enable Track24"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 23U));
 408         ActionManager::session_sensitive_actions.push_back (act);
 409         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack25"), _("Toggle Record Enable Track25"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 24U));
 410         ActionManager::session_sensitive_actions.push_back (act);
 411         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack26"), _("Toggle Record Enable Track26"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 25U));
 412         ActionManager::session_sensitive_actions.push_back (act);
 413         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack27"), _("Toggle Record Enable Track27"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 26U));
 414         ActionManager::session_sensitive_actions.push_back (act);
 415         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack28"), _("Toggle Record Enable Track28"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 27U));
 416         ActionManager::session_sensitive_actions.push_back (act);
 417         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack29"), _("Toggle Record Enable Track29"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 28U));
 418         ActionManager::session_sensitive_actions.push_back (act);
 419         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack30"), _("Toggle Record Enable Track30"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 29U));
 420         ActionManager::session_sensitive_actions.push_back (act);
 421         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack31"), _("Toggle Record Enable Track31"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 30U));
 422         ActionManager::session_sensitive_actions.push_back (act);
 423         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack32"), _("Toggle Record Enable Track32"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 31U));
 424         ActionManager::session_sensitive_actions.push_back (act);
 425
 426         Glib::RefPtr<ActionGroup> shuttle_actions = ActionGroup::create ("ShuttleActions");
 427
 428         shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Percentage)));
 429         shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Semitones)));
 430
 431         Glib::RefPtr<ActionGroup> option_actions = ActionGroup::create ("options");
 432
 433         act = ActionManager::register_toggle_action (option_actions, X_("SendMTC"), _("Send MTC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mtc));
 434         ActionManager::session_sensitive_actions.push_back (act);
 435         act = ActionManager::register_toggle_action (option_actions, X_("SendMMC"), _("Send MMC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mmc));
 436         ActionManager::session_sensitive_actions.push_back (act);
 437         act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Use MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc));
 438         ActionManager::session_sensitive_actions.push_back (act);
 439         act = ActionManager::register_toggle_action (option_actions, X_("UseMIDIClock"), _("Use MIDI Clock"), mem_fun (*this, &ARDOUR_UI::toggle_use_midi_clock));
 440         ActionManager::session_sensitive_actions.push_back (act);
 441         act = ActionManager::register_toggle_action (option_actions, X_("SendMIDIfeedback"), _("Send MIDI feedback"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_feedback));
 442         ActionManager::session_sensitive_actions.push_back (act);
 443
 444         act = ActionManager::register_toggle_action (option_actions, X_("UseOSC"), _("Use OSC"), mem_fun (*this, &ARDOUR_UI::toggle_use_osc));
 445 #ifndef HAVE_LIBLO
 446         act->set_sensitive (false);
 447 #endif
 448         act = ActionManager::register_toggle_action (option_actions, X_("ToggleTapeMachineMode"), _("Tape Machine mode"), mem_fun (*this, &ARDOUR_UI::toggle_TapeMachineMode));
 449         ActionManager::session_sensitive_actions.push_back (act);
 450
 451         ActionManager::register_toggle_action (option_actions, X_("SyncEditorAndMixerTrackOrder"), _("Sync Editor and Mixer track order"), mem_fun (*this, &ARDOUR_UI::toggle_sync_order_keys));
 452         ActionManager::register_toggle_action (option_actions, X_("StopPluginsWithTransport"), _("Stop plugins with transport"), mem_fun (*this, &ARDOUR_UI::toggle_StopPluginsWithTransport));
 453         ActionManager::register_toggle_action (option_actions, X_("VerifyRemoveLastCapture"), _("Verify remove last capture"), mem_fun (*this, &ARDOUR_UI::toggle_VerifyRemoveLastCapture));
 454         ActionManager::register_toggle_action (option_actions, X_("PeriodicSafetyBackups"), _("Make periodic safety backups"), mem_fun (*this, &ARDOUR_UI::toggle_PeriodicSafetyBackups));
 455         ActionManager::register_toggle_action (option_actions, X_("StopRecordingOnXrun"), _("Stop recording on xrun"), mem_fun (*this, &ARDOUR_UI::toggle_StopRecordingOnXrun));
 456         ActionManager::register_toggle_action (option_actions, X_("CreateXrunMarker"), _("Create marker at xrun location"), mem_fun (*this, &ARDOUR_UI::toggle_CreateXrunMarker));
 457         ActionManager::register_toggle_action (option_actions, X_("StopTransportAtEndOfSession"), _("Stop transport at session end"), mem_fun (*this, &ARDOUR_UI::toggle_StopTransportAtEndOfSession));
 458         ActionManager::register_toggle_action (option_actions, X_("GainReduceFastTransport"), _("-12dB gain reduce ffwd/rewind"), mem_fun (*this, &ARDOUR_UI::toggle_GainReduceFastTransport));
 459         ActionManager::register_toggle_action (option_actions, X_("LatchedRecordEnable"), _("Rec-enable stays engaged at stop"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedRecordEnable));
 460         ActionManager::register_toggle_action (option_actions, X_("RegionEquivalentsOverlap"), _("Region equivalents overlap"), mem_fun (*this, &ARDOUR_UI::toggle_RegionEquivalentsOverlap));
 461         ActionManager::register_toggle_action (option_actions, X_("PrimaryClockDeltaEditCursor"), _("Primary Clock delta to edit point"), mem_fun (*this, &ARDOUR_UI::toggle_PrimaryClockDeltaEditCursor));
 462         ActionManager::register_toggle_action (option_actions, X_("SecondaryClockDeltaEditCursor"), _("Secondary Clock delta to edit point"), mem_fun (*this, &ARDOUR_UI::toggle_SecondaryClockDeltaEditCursor));
 463         ActionManager::register_toggle_action (option_actions, X_("ShowTrackMeters"), _("Enable Editor Meters"), mem_fun (*this, &ARDOUR_UI::toggle_ShowTrackMeters));
 464         ActionManager::register_toggle_action (option_actions, X_("OnlyCopyImportedFiles"), _("Always copy imported files"), mem_fun (*this, &ARDOUR_UI::toggle_only_copy_imported_files));
 465         ActionManager::register_toggle_action (option_actions, X_("RubberbandingSnapsToGrid"), _("Rubberbanding Snaps to Grid"), mem_fun (*this, &ARDOUR_UI::toggle_rubberbanding_snaps_to_grid));
 466         ActionManager::register_toggle_action (option_actions, X_("AutoAnalyseAudio"), _("Auto-analyse new audio"), mem_fun (*this, &ARDOUR_UI::toggle_auto_analyse_audio));
 467
 468         ActionManager::register_toggle_action (option_actions, X_("DefaultNarrowMS"), _("Use narrow mixer strips"), mem_fun (*this, &ARDOUR_UI::toggle_use_narrow_ms));
 469         ActionManager::register_toggle_action (option_actions, X_("NameNewMarkers"), _("Name New Markers"), mem_fun (*this, &ARDOUR_UI::toggle_NameNewMarkers));
 470
 471         RadioAction::Group denormal_group;
 472
 473         ActionManager::register_toggle_action (option_actions, X_("DenormalProtection"), _("Use DC bias"), mem_fun (*this, &ARDOUR_UI::toggle_denormal_protection));
 474         ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalNone"), _("No processor handling"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalNone));
 475
 476         // as of September 10th 2007, Valgrind cannot handle various FPU flag setting instructions
 477         // so avoid them
 478
 479         if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
 480
 481                 /* we still need these actions to exist, but make them all insensitive */
 482
 483                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 484                 act->set_sensitive (false);
 485                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 486                 act->set_sensitive (false);
 487                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 488                 act->set_sensitive (false);
 489
 490         } else {
 491
 492                 FPU fpu;
 493
 494                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 495                 if (!fpu.has_flush_to_zero()) {
 496                         act->set_sensitive (false);
 497                 }
 498
 499                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 500                 if (!fpu.has_denormals_are_zero()) {
 501                         act->set_sensitive (false);
 502                 }
 503
 504                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 505                 if (!fpu.has_flush_to_zero() || !fpu.has_denormals_are_zero()) {
 506                         act->set_sensitive (false);
 507                 }
 508         }
 509
 510         act = ActionManager::register_toggle_action (option_actions, X_("DoNotRunPluginsWhileRecording"), _("Do not run plugins while recording"), mem_fun (*this, &ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording));
 511         ActionManager::session_sensitive_actions.push_back (act);
 512
 513         act = ActionManager::register_toggle_action (option_actions, X_("LatchedSolo"), _("Latched solo"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedSolo));
 514         ActionManager::session_sensitive_actions.push_back (act);
 515         act = ActionManager::register_toggle_action (option_actions, X_("ShowSoloMutes"), _("Show solo muting"), mem_fun (*this, &ARDOUR_UI::toggle_ShowSoloMutes));
 516         ActionManager::session_sensitive_actions.push_back (act);
 517
 518         /* act = ActionManager::register_action (option_actions, X_("DisableAllPlugins"), _("Disable All Plugins"), mem_fun (*this, &ARDOUR_UI::disable_all_plugins));
 519         ActionManager::session_sensitive_actions.push_back (act);
 520         act = ActionManager::register_action (option_actions, X_("ABAllPlugins"), _("A/B All Plugins"), mem_fun (*this, &ARDOUR_UI::ab_all_plugins));
 521         ActionManager::session_sensitive_actions.push_back (act); */
 522
 523         /* !!! REMEMBER THAT RADIO ACTIONS HAVE TO BE HANDLED WITH MORE FINESSE THAN SIMPLE TOGGLES !!! */
 524
 525         RadioAction::Group meter_falloff_group;
 526         RadioAction::Group meter_hold_group;
 527
 528         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffOff));
 529         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlowest));
 530         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlow));
 531         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffMedium));
 532         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFast));
 533         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFaster));
 534         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFastest));
 535
 536         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldOff));
 537         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldShort));
 538         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldMedium));
 539         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldLong));
 540
 541         RadioAction::Group file_header_group;
 542
 543         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));
 544         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));
 545         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));
 546         // 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));
 547         // 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));
 548         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));
 549
 550         RadioAction::Group file_data_group;
 551
 552
 553         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));
 554         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));
 555         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));
 556
 557         RadioAction::Group monitoring_group;
 558
 559         /* it would be nice not to even show this item, but that messes up the
 560            menus which are not dynamically modified at runtime. so we make it
 561            sensitive only if it makes sense.
 562         */
 563
 564         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseHardwareMonitoring"), _("JACK does monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), HardwareMonitoring));
 565         if (engine->can_request_hardware_monitoring()) {
 566                 act->set_sensitive (false);
 567         }
 568         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseSoftwareMonitoring"), _("Ardour does monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), SoftwareMonitoring));
 569         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));
 570
 571         RadioAction::Group solo_group;
 572
 573         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)));
 574         ActionManager::session_sensitive_actions.push_back (act);
 575         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)));
 576         ActionManager::session_sensitive_actions.push_back (act);
 577
 578         RadioAction::Group input_auto_connect_group;
 579
 580         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)));
 581         ActionManager::session_sensitive_actions.push_back (act);
 582         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)));
 583         ActionManager::session_sensitive_actions.push_back (act);
 584
 585         RadioAction::Group output_auto_connect_group;
 586
 587         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)));
 588         ActionManager::session_sensitive_actions.push_back (act);
 589         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)));
 590         ActionManager::session_sensitive_actions.push_back (act);
 591         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)));
 592         ActionManager::session_sensitive_actions.push_back (act);
 593
 594         RadioAction::Group remote_group;
 595
 596         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)));
 597         ActionManager::session_sensitive_actions.push_back (act);
 598         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)));
 599         ActionManager::session_sensitive_actions.push_back (act);
 600         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)));
 601         ActionManager::session_sensitive_actions.push_back (act);
 602
 603         act = ActionManager::register_toggle_action (option_actions, X_("AutoRebinding"), _("Auto Rebind Controls"), mem_fun (*(this->mixer), &Mixer_UI::toggle_auto_rebinding));
 604         ActionManager::session_sensitive_actions.push_back (act);
 605
 606
 607         ActionManager::add_action_group (shuttle_actions);
 608         ActionManager::add_action_group (option_actions);
 609         ActionManager::add_action_group (jack_actions);
 610         ActionManager::add_action_group (transport_actions);
 611         ActionManager::add_action_group (main_actions);
 612         ActionManager::add_action_group (common_actions);
 613 }
 614
 615 void
 616 ARDOUR_UI::toggle_control_protocol (ControlProtocolInfo* cpi)
 617 {
 618         if (!session) {
 619                 /* this happens when we build the menu bar when control protocol support
 620                    has been used in the past for some given protocol - the item needs
 621                    to be made active, but there is no session yet.
 622                 */
 623                 return;
 624         }
 625
 626         if (cpi->protocol == 0) {
 627                 ControlProtocolManager::instance().instantiate (*cpi);
 628         } else {
 629                 ControlProtocolManager::instance().teardown (*cpi);
 630         }
 631 }
 632
 633 void
 634 ARDOUR_UI::toggle_control_protocol_feedback (ControlProtocolInfo* cpi, const char* group, string action)
 635 {
 636         if (!session) {
 637                 /* this happens when we build the menu bar when control protocol support
 638                    has been used in the past for some given protocol - the item needs
 639                    to be made active, but there is no session yet.
 640                 */
 641                 return;
 642         }
 643
 644         if (cpi->protocol) {
 645                 Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (group, action.c_str());
 646
 647                 if (act) {
 648                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 649
 650                         if (tact) {
 651                                 bool x = tact->get_active();
 652
 653                                 if (x != cpi->protocol->get_feedback()) {
 654                                         cpi->protocol->set_feedback (x);
 655                                 }
 656                         }
 657                 }
 658         }
 659 }
 660
 661 void
 662 ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
 663 {
 664         Glib::RefPtr<Action> action;
 665         const char* action_name = 0;
 666
 667         switch (nframes) {
 668         case 32:
 669                 action_name = X_("JACKLatency32");
 670                 break;
 671         case 64:
 672                 action_name = X_("JACKLatency64");
 673                 break;
 674         case 128:
 675                 action_name = X_("JACKLatency128");
 676                 break;
 677         case 512:
 678                 action_name = X_("JACKLatency512");
 679                 break;
 680         case 1024:
 681                 action_name = X_("JACKLatency1024");
 682                 break;
 683         case 2048:
 684                 action_name = X_("JACKLatency2048");
 685                 break;
 686         case 4096:
 687                 action_name = X_("JACKLatency4096");
 688                 break;
 689         case 8192:
 690                 action_name = X_("JACKLatency8192");
 691                 break;
 692         default:
 693                 /* XXX can we do anything useful ? */
 694                 break;
 695         }
 696
 697         if (action_name) {
 698
 699                 action = ActionManager::get_action (X_("JACK"), action_name);
 700
 701                 if (action) {
 702                         Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
 703
 704                         if (ract && ract->get_active()) {
 705                                 engine->request_buffer_size (nframes);
 706                                 update_sample_rate (0);
 707                         }
 708                 }
 709         }
 710 }
 711
 712 void
 713 ARDOUR_UI::build_control_surface_menu ()
 714 {
 715         list<ControlProtocolInfo*>::iterator i;
 716         bool with_feedback;
 717
 718         /* !!! this has to match the top level entry from ardour.menus */
 719
 720         string ui = "<menubar name='Main' action='MainMenu'>\n<menu name='Options' action='Options'>\n<menu action='ControlSurfaces'><separator/>\n";
 721
 722         for (i = ControlProtocolManager::instance().control_protocol_info.begin(); i != ControlProtocolManager::instance().control_protocol_info.end(); ++i) {
 723
 724                 if (!(*i)->mandatory) {
 725
 726                         string action_name = "Toggle";
 727                         action_name += legalize_for_path ((*i)->name);
 728                         action_name += "Surface";
 729
 730                         string action_label = (*i)->name;
 731
 732                         Glib::RefPtr<Action> act = ActionManager::register_toggle_action (editor->editor_actions, action_name.c_str(), action_label.c_str(),
 733                                                                                           (bind (mem_fun (*this, &ARDOUR_UI::toggle_control_protocol), *i)));
 734
 735                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 736
 737                         with_feedback = false;
 738
 739                         if ((*i)->protocol || (*i)->requested) {
 740                                 tact->set_active ();
 741                         }
 742
 743                         ui += "<menuitem action='";
 744                         ui += action_name;
 745                         ui += "'/>\n";
 746
 747                         if ((*i)->supports_feedback) {
 748
 749                                 string submenu_name = action_name;
 750
 751                                 submenu_name += "SubMenu";
 752
 753                                 ActionManager::register_action (editor->editor_actions, submenu_name.c_str(), _("Controls"));
 754
 755                                 action_name += "Feedback";
 756
 757                                 Glib::RefPtr<Action> act = ActionManager::register_toggle_action (editor->editor_actions, action_name.c_str(), _("Feedback"),
 758                                                                                                   (bind (mem_fun (*this, &ARDOUR_UI::toggle_control_protocol_feedback),
 759                                                                                                          *i,
 760                                                                                                          "Editor",
 761                                                                                                          action_name)));
 762
 763                                 ui += "<menu action='";
 764                                 ui += submenu_name;
 765                                 ui += "'>\n<menuitem action='";
 766                                 ui += action_name;
 767                                 ui += "'/>\n</menu>\n";
 768
 769                                 if ((*i)->protocol) {
 770                                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 771                                         tact->set_active ((*i)->protocol->get_feedback ());
 772                                 }
 773                         }
 774                 }
 775         }
 776
 777         ui += "</menu>\n</menu>\n</menubar>\n";
 778
 779         ActionManager::ui_manager->add_ui_from_string (ui);
 780 }
 781
 782 void
 783 ARDOUR_UI::build_menu_bar ()
 784 {
 785         if (!Profile->get_sae()) {
 786                 build_control_surface_menu ();
 787         }
 788
 789         menu_bar = dynamic_cast<MenuBar*> (ActionManager::get_widget (X_("/Main")));
 790         menu_bar->set_name ("MainMenuBar");
 791
 792         /*
 793          * This is needed because this property does not get installed
 794          * until the Menu GObject class is registered, which happens
 795          * when the first menu instance is created.
 796          */
 797         // XXX bug in gtkmm causes this to popup an error message
 798         // Gtk::Settings::get_default()->property_gtk_can_change_accels() = true;
 799         // so use this instead ...
 800         gtk_settings_set_long_property (gtk_settings_get_default(), "gtk-can-change-accels", 1, "Ardour:designers");
 801
 802         wall_clock_box.add (wall_clock_label);
 803         wall_clock_box.set_name ("WallClock");
 804         wall_clock_label.set_name ("WallClock");
 805
 806         disk_space_box.add (disk_space_label);
 807         disk_space_box.set_name ("WallClock");
 808         disk_space_label.set_name ("WallClock");
 809
 810         cpu_load_box.add (cpu_load_label);
 811         cpu_load_box.set_name ("CPULoad");
 812         cpu_load_label.set_name ("CPULoad");
 813
 814         buffer_load_box.add (buffer_load_label);
 815         buffer_load_box.set_name ("BufferLoad");
 816         buffer_load_label.set_name ("BufferLoad");
 817
 818         sample_rate_box.add (sample_rate_label);
 819         sample_rate_box.set_name ("SampleRate");
 820         sample_rate_label.set_name ("SampleRate");
 821
 822 #ifndef TOP_MENUBAR
 823         menu_hbox.pack_start (*menu_bar, true, true);
 824 #else
 825         use_menubar_as_top_menubar ();
 826 #endif
 827
 828         if (!Profile->get_small_screen()) {
 829 #ifndef GTKOSX
 830                 // OSX provides its own wallclock, thank you very much
 831                 menu_hbox.pack_end (wall_clock_box, false, false, 2);
 832 #endif
 833                 menu_hbox.pack_end (disk_space_box, false, false, 4);
 834         }
 835
 836         menu_hbox.pack_end (cpu_load_box, false, false, 4);
 837         menu_hbox.pack_end (buffer_load_box, false, false, 4);
 838         menu_hbox.pack_end (sample_rate_box, false, false, 4);
 839
 840         menu_bar_base.set_name ("MainMenuBar");
 841         menu_bar_base.add (menu_hbox);
 842 }
 843
 844 void
 845 ARDOUR_UI::use_menubar_as_top_menubar ()
 846 {
 847 #ifdef GTKOSX
 848         ige_mac_menu_set_menu_bar ((GtkMenuShell*) menu_bar->gobj());
 849         // ige_mac_menu_set_quit_menu_item (some_item->gobj());
 850 #endif
 851 }
 852
 853
 854 void
 855 ARDOUR_UI::setup_clock ()
 856 {
 857         ARDOUR_UI::Clock.connect (bind (mem_fun (big_clock, &AudioClock::set), false));
 858
 859         big_clock_window = new Window (WINDOW_TOPLEVEL);
 860
 861         big_clock_window->set_keep_above (true);
 862         big_clock_window->set_border_width (0);
 863         big_clock_window->add  (big_clock);
 864
 865         WindowTitle title(Glib::get_application_name());
 866         title += _("Clock");
 867         big_clock_window->set_title (title.get_string());
 868         big_clock_window->set_type_hint (Gdk::WINDOW_TYPE_HINT_MENU);
 869         big_clock_window->signal_realize().connect (bind (sigc::ptr_fun (set_decoration), big_clock_window,  (Gdk::DECOR_BORDER|Gdk::DECOR_RESIZEH)));
 870         big_clock_window->signal_unmap().connect (bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleBigClock")));
 871
 872         manage_window (*big_clock_window);
 873 }
 874
 875 void
 876 ARDOUR_UI::float_big_clock (Gtk::Window* parent)
 877 {
 878         if (big_clock_window) {
 879                 if (parent) {
 880                         big_clock_window->set_transient_for (*parent);
 881                 } else {
 882                         gtk_window_set_transient_for (big_clock_window->gobj(), (GtkWindow*) 0);
 883                 }
 884         }
 885 }
 886