gtk2_ardour/ardour_ui_ed.cc

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