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