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)));
 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_("ToggleRCOptionsEditor"), _("Preferences"), mem_fun(*this, &ARDOUR_UI::toggle_rc_options_window));
 206         ActionManager::register_toggle_action (common_actions, X_("ToggleSessionOptionsEditor"), _("Preferences"), mem_fun(*this, &ARDOUR_UI::toggle_session_options_window));
 207         act = ActionManager::register_toggle_action (common_actions, X_("ToggleInspector"), _("Track/Bus Inspector"), mem_fun(*this, &ARDOUR_UI::toggle_route_params_window));
 208         ActionManager::session_sensitive_actions.push_back (act);
 209         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, &RCConfiguration::set_shuttle_units), Percentage)));
 430         shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), hide_return (bind (mem_fun (*Config, &RCConfiguration::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         act = ActionManager::register_toggle_action (option_actions, X_("ToggleTapeMachineMode"), _("Tape Machine Mode"), mem_fun (*this, &ARDOUR_UI::toggle_TapeMachineMode));
 445         ActionManager::session_sensitive_actions.push_back (act);
 446
 447         ActionManager::register_toggle_action (option_actions, X_("SyncEditorAndMixerTrackOrder"), _("Sync Editor and Mixer Track Order"), mem_fun (*this, &ARDOUR_UI::toggle_sync_order_keys));
 448         ActionManager::register_toggle_action (option_actions, X_("StopPluginsWithTransport"), _("Stop Plugins with Transport"), mem_fun (*this, &ARDOUR_UI::toggle_StopPluginsWithTransport));
 449         ActionManager::register_toggle_action (option_actions, X_("NewPluginsActive"), _("New Plugins are Active"), mem_fun (*this, &ARDOUR_UI::toggle_new_plugins_active));
 450         ActionManager::register_toggle_action (option_actions, X_("VerifyRemoveLastCapture"), _("Verify Remove Last Capture"), mem_fun (*this, &ARDOUR_UI::toggle_VerifyRemoveLastCapture));
 451         ActionManager::register_toggle_action (option_actions, X_("PeriodicSafetyBackups"), _("Make Periodic Safety Backups"), mem_fun (*this, &ARDOUR_UI::toggle_PeriodicSafetyBackups));
 452         ActionManager::register_toggle_action (option_actions, X_("StopRecordingOnXrun"), _("Stop Recording on xrun"), mem_fun (*this, &ARDOUR_UI::toggle_StopRecordingOnXrun));
 453         ActionManager::register_toggle_action (option_actions, X_("CreateXrunMarker"), _("Create Marker at xrun Location"), mem_fun (*this, &ARDOUR_UI::toggle_CreateXrunMarker));
 454         ActionManager::register_toggle_action (option_actions, X_("StopTransportAtEndOfSession"), _("Stop Transport at Session End"), mem_fun (*this, &ARDOUR_UI::toggle_StopTransportAtEndOfSession));
 455         ActionManager::register_toggle_action (option_actions, X_("GainReduceFastTransport"), _("-12dB Gain Reduce ffwd/rewind"), mem_fun (*this, &ARDOUR_UI::toggle_GainReduceFastTransport));
 456         ActionManager::register_toggle_action (option_actions, X_("LatchedRecordEnable"), _("Rec-enable Stays Engaged at Stop"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedRecordEnable));
 457         ActionManager::register_toggle_action (option_actions, X_("RegionEquivalentsOverlap"), _("Region Equivalents Overlap"), mem_fun (*this, &ARDOUR_UI::toggle_RegionEquivalentsOverlap));
 458         ActionManager::register_toggle_action (option_actions, X_("PrimaryClockDeltaEditCursor"), _("Primary Clock Delta to Edit Point"), mem_fun (*this, &ARDOUR_UI::toggle_PrimaryClockDeltaEditCursor));
 459         ActionManager::register_toggle_action (option_actions, X_("SecondaryClockDeltaEditCursor"), _("Secondary Clock Delta to Edit Point"), mem_fun (*this, &ARDOUR_UI::toggle_SecondaryClockDeltaEditCursor));
 460         ActionManager::register_toggle_action (option_actions, X_("ShowTrackMeters"), _("Enable Editor Meters"), mem_fun (*this, &ARDOUR_UI::toggle_ShowTrackMeters));
 461         ActionManager::register_toggle_action (option_actions, X_("OnlyCopyImportedFiles"), _("Always Copy Imported Files"), mem_fun (*this, &ARDOUR_UI::toggle_only_copy_imported_files));
 462         ActionManager::register_toggle_action (option_actions, X_("RubberbandingSnapsToGrid"), _("Rubberbanding Snaps to Grid"), mem_fun (*this, &ARDOUR_UI::toggle_rubberbanding_snaps_to_grid));
 463         ActionManager::register_toggle_action (option_actions, X_("AutoAnalyseAudio"), _("Auto-analyse new audio"), mem_fun (*this, &ARDOUR_UI::toggle_auto_analyse_audio));
 464
 465         ActionManager::register_toggle_action (option_actions, X_("DefaultNarrowMS"), _("Use narrow mixer strips"), mem_fun (*this, &ARDOUR_UI::toggle_use_narrow_ms));
 466         ActionManager::register_toggle_action (option_actions, X_("NameNewMarkers"), _("Name New Markers"), mem_fun (*this, &ARDOUR_UI::toggle_NameNewMarkers));
 467
 468         RadioAction::Group denormal_group;
 469
 470         ActionManager::register_toggle_action (option_actions, X_("DenormalProtection"), _("Use DC bias"), mem_fun (*this, &ARDOUR_UI::toggle_denormal_protection));
 471         ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalNone"), _("No processor handling"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalNone));
 472
 473         // as of September 10th 2007, Valgrind cannot handle various FPU flag setting instructions
 474         // so avoid them
 475
 476         if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
 477
 478                 /* we still need these actions to exist, but make them all insensitive */
 479
 480                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 481                 act->set_sensitive (false);
 482                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 483                 act->set_sensitive (false);
 484                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 485                 act->set_sensitive (false);
 486
 487         } else {
 488
 489                 FPU fpu;
 490
 491                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 492                 if (!fpu.has_flush_to_zero()) {
 493                         act->set_sensitive (false);
 494                 }
 495
 496                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 497                 if (!fpu.has_denormals_are_zero()) {
 498                         act->set_sensitive (false);
 499                 }
 500
 501                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 502                 if (!fpu.has_flush_to_zero() || !fpu.has_denormals_are_zero()) {
 503                         act->set_sensitive (false);
 504                 }
 505         }
 506
 507         act = ActionManager::register_toggle_action (option_actions, X_("DoNotRunPluginsWhileRecording"), _("Do not Run Plugins While Recording"), mem_fun (*this, &ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording));
 508         ActionManager::session_sensitive_actions.push_back (act);
 509
 510         act = ActionManager::register_toggle_action (option_actions, X_("LatchedSolo"), _("Latched Solo"), mem_fun (*this, &ARDOUR_UI::toggle_LatchedSolo));
 511         ActionManager::session_sensitive_actions.push_back (act);
 512         act = ActionManager::register_toggle_action (option_actions, X_("ShowSoloMutes"), _("Show Solo Muting"), mem_fun (*this, &ARDOUR_UI::toggle_ShowSoloMutes));
 513         ActionManager::session_sensitive_actions.push_back (act);
 514         act = ActionManager::register_toggle_action (option_actions, X_("SoloMuteOverride"), _("Override Muting"), mem_fun (*this, &ARDOUR_UI::toggle_SoloMuteOverride));
 515         ActionManager::session_sensitive_actions.push_back (act);
 516
 517         /* act = ActionManager::register_action (option_actions, X_("DisableAllPlugins"), _("Disable All Plugins"), mem_fun (*this, &ARDOUR_UI::disable_all_plugins));
 518         ActionManager::session_sensitive_actions.push_back (act);
 519         act = ActionManager::register_action (option_actions, X_("ABAllPlugins"), _("A/B All Plugins"), mem_fun (*this, &ARDOUR_UI::ab_all_plugins));
 520         ActionManager::session_sensitive_actions.push_back (act); */
 521
 522         /* !!! REMEMBER THAT RADIO ACTIONS HAVE TO BE HANDLED WITH MORE FINESSE THAN SIMPLE TOGGLES !!! */
 523
 524         RadioAction::Group meter_falloff_group;
 525         RadioAction::Group meter_hold_group;
 526
 527         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffOff));
 528         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlowest));
 529         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlow));
 530         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffMedium));
 531         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFast));
 532         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFaster));
 533         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFastest));
 534
 535         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldOff));
 536         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldShort));
 537         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldMedium));
 538         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldLong));
 539
 540         RadioAction::Group file_header_group;
 541
 542         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));
 543         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));
 544         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));
 545         // 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));
 546         // 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));
 547         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));
 548
 549         RadioAction::Group file_data_group;
 550
 551
 552         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));
 553         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));
 554         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));
 555
 556         RadioAction::Group monitoring_group;
 557
 558         /* it would be nice not to even show this item, but that messes up the
 559            menus which are not dynamically modified at runtime. so we make it
 560            sensitive only if it makes sense.
 561         */
 562
 563         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseHardwareMonitoring"), _("JACK Does Monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), HardwareMonitoring));
 564         if (!engine->can_request_hardware_monitoring()) {
 565                 act->set_sensitive (false);
 566         }
 567         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseSoftwareMonitoring"), _("Ardour Does Monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), SoftwareMonitoring));
 568         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));
 569
 570         RadioAction::Group solo_group;
 571
 572         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)));
 573         ActionManager::session_sensitive_actions.push_back (act);
 574         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)));
 575         ActionManager::session_sensitive_actions.push_back (act);
 576
 577         RadioAction::Group input_auto_connect_group;
 578
 579         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)));
 580         ActionManager::session_sensitive_actions.push_back (act);
 581         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)));
 582         ActionManager::session_sensitive_actions.push_back (act);
 583
 584         RadioAction::Group output_auto_connect_group;
 585
 586         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)));
 587         ActionManager::session_sensitive_actions.push_back (act);
 588         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)));
 589         ActionManager::session_sensitive_actions.push_back (act);
 590         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)));
 591         ActionManager::session_sensitive_actions.push_back (act);
 592
 593         RadioAction::Group remote_group;
 594
 595         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)));
 596         ActionManager::session_sensitive_actions.push_back (act);
 597         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)));
 598         ActionManager::session_sensitive_actions.push_back (act);
 599         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)));
 600         ActionManager::session_sensitive_actions.push_back (act);
 601
 602         act = ActionManager::register_toggle_action (option_actions, X_("AutoRebinding"), _("Auto Rebind Controls"), mem_fun (*(this->mixer), &Mixer_UI::toggle_auto_rebinding));
 603         ActionManager::session_sensitive_actions.push_back (act);
 604
 605
 606         ActionManager::add_action_group (shuttle_actions);
 607         ActionManager::add_action_group (option_actions);
 608         ActionManager::add_action_group (jack_actions);
 609         ActionManager::add_action_group (transport_actions);
 610         ActionManager::add_action_group (main_actions);
 611         ActionManager::add_action_group (common_actions);
 612 }
 613
 614 void
 615 ARDOUR_UI::toggle_control_protocol (ControlProtocolInfo* cpi)
 616 {
 617         if (!session) {
 618                 /* this happens when we build the menu bar when control protocol support
 619                    has been used in the past for some given protocol - the item needs
 620                    to be made active, but there is no session yet.
 621                 */
 622                 return;
 623         }
 624
 625         if (cpi->protocol == 0) {
 626                 ControlProtocolManager::instance().instantiate (*cpi);
 627         } else {
 628                 ControlProtocolManager::instance().teardown (*cpi);
 629         }
 630 }
 631
 632 void
 633 ARDOUR_UI::toggle_control_protocol_feedback (ControlProtocolInfo* cpi, const char* group, string action)
 634 {
 635         if (!session) {
 636                 /* this happens when we build the menu bar when control protocol support
 637                    has been used in the past for some given protocol - the item needs
 638                    to be made active, but there is no session yet.
 639                 */
 640                 return;
 641         }
 642
 643         if (cpi->protocol) {
 644                 Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (group, action.c_str());
 645
 646                 if (act) {
 647                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 648
 649                         if (tact) {
 650                                 bool x = tact->get_active();
 651
 652                                 if (x != cpi->protocol->get_feedback()) {
 653                                         cpi->protocol->set_feedback (x);
 654                                 }
 655                         }
 656                 }
 657         }
 658 }
 659
 660 void
 661 ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
 662 {
 663         Glib::RefPtr<Action> action;
 664         const char* action_name = 0;
 665
 666         switch (nframes) {
 667         case 32:
 668                 action_name = X_("JACKLatency32");
 669                 break;
 670         case 64:
 671                 action_name = X_("JACKLatency64");
 672                 break;
 673         case 128:
 674                 action_name = X_("JACKLatency128");
 675                 break;
 676         case 512:
 677                 action_name = X_("JACKLatency512");
 678                 break;
 679         case 1024:
 680                 action_name = X_("JACKLatency1024");
 681                 break;
 682         case 2048:
 683                 action_name = X_("JACKLatency2048");
 684                 break;
 685         case 4096:
 686                 action_name = X_("JACKLatency4096");
 687                 break;
 688         case 8192:
 689                 action_name = X_("JACKLatency8192");
 690                 break;
 691         default:
 692                 /* XXX can we do anything useful ? */
 693                 break;
 694         }
 695
 696         if (action_name) {
 697
 698                 action = ActionManager::get_action (X_("JACK"), action_name);
 699
 700                 if (action) {
 701                         Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
 702
 703                         if (ract && ract->get_active()) {
 704                                 engine->request_buffer_size (nframes);
 705                                 update_sample_rate (0);
 706                         }
 707                 }
 708         }
 709 }
 710
 711 void
 712 ARDOUR_UI::build_control_surface_menu ()
 713 {
 714         list<ControlProtocolInfo*>::iterator i;
 715         bool with_feedback;
 716
 717         /* !!! this has to match the top level entry from ardour.menus */
 718
 719         string ui = "<menubar name='Main' action='MainMenu'>\n"
 720                 "<menu name='Options' action='Options'>\n"
 721                 "<menu action='ControlSurfaces'><separator/>\n";
 722
 723         for (i = ControlProtocolManager::instance().control_protocol_info.begin();
 724                         i != ControlProtocolManager::instance().control_protocol_info.end(); ++i) {
 725
 726                 if (!(*i)->mandatory) {
 727
 728                         // Enable surface
 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 (
 737                                         editor->editor_actions, action_name.c_str(), action_label.c_str(), (bind (
 738                                                         mem_fun (*this, &ARDOUR_UI::toggle_control_protocol),
 739                                                         *i)));
 740
 741                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 742
 743                         with_feedback = false;
 744
 745                         if ((*i)->protocol || (*i)->requested) {
 746                                 tact->set_active ();
 747                         }
 748
 749                         ui += "<menuitem action='";
 750                         ui += action_name;
 751                         ui += "'/>\n";
 752
 753                         // Enable feedback
 754
 755                         if ((*i)->supports_feedback) {
 756
 757                                 action_name += "Feedback";
 758                                 string feedback_label = action_label + " " + _("Feedback");
 759
 760                                 Glib::RefPtr<Action> act = ActionManager::register_toggle_action (
 761                                                 editor->editor_actions, action_name.c_str(), feedback_label.c_str(), (bind (
 762                                                                 mem_fun (*this, &ARDOUR_UI::toggle_control_protocol_feedback),
 763                                                                 *i, "Editor", action_name)));
 764
 765                                 ui += "<menuitem action='";
 766                                 ui += action_name;
 767                                 ui += "'/>\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