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