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 256:
 688                 action_name = X_("JACKLatency256");
 689                 break;
 690         case 512:
 691                 action_name = X_("JACKLatency512");
 692                 break;
 693         case 1024:
 694                 action_name = X_("JACKLatency1024");
 695                 break;
 696         case 2048:
 697                 action_name = X_("JACKLatency2048");
 698                 break;
 699         case 4096:
 700                 action_name = X_("JACKLatency4096");
 701                 break;
 702         case 8192:
 703                 action_name = X_("JACKLatency8192");
 704                 break;
 705         default:
 706                 /* XXX can we do anything useful ? */
 707                 break;
 708         }
 709
 710         if (action_name) {
 711
 712                 action = ActionManager::get_action (X_("JACK"), action_name);
 713
 714                 if (action) {
 715                         Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
 716
 717                         if (ract && ract->get_active()) {
 718                                 engine->request_buffer_size (nframes);
 719                                 update_sample_rate (0);
 720                         }
 721                 }
 722         }
 723 }
 724
 725 void
 726 ARDOUR_UI::build_control_surface_menu ()
 727 {
 728         list<ControlProtocolInfo*>::iterator i;
 729         bool with_feedback;
 730
 731         /* !!! this has to match the top level entry from ardour.menus */
 732
 733         string ui = "<menubar name='Main' action='MainMenu'>\n<menu name='Options' action='Options'>\n<menu action='ControlSurfaces'><separator/>\n";
 734
 735         for (i = ControlProtocolManager::instance().control_protocol_info.begin(); i != ControlProtocolManager::instance().control_protocol_info.end(); ++i) {
 736
 737                 if (!(*i)->mandatory) {
 738
 739                         string action_name = "Toggle";
 740                         action_name += legalize_for_path ((*i)->name);
 741                         action_name += "Surface";
 742
 743                         string action_label = (*i)->name;
 744
 745                         Glib::RefPtr<Action> act = ActionManager::register_toggle_action (editor->editor_actions, action_name.c_str(), action_label.c_str(),
 746                                                                                           (bind (mem_fun (*this, &ARDOUR_UI::toggle_control_protocol), *i)));
 747
 748                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 749
 750                         with_feedback = false;
 751
 752                         if ((*i)->protocol || (*i)->requested) {
 753                                 tact->set_active ();
 754                         }
 755
 756                         ui += "<menuitem action='";
 757                         ui += action_name;
 758                         ui += "'/>\n";
 759
 760                         if ((*i)->supports_feedback) {
 761
 762                                 string submenu_name = action_name;
 763
 764                                 submenu_name += "SubMenu";
 765
 766                                 ActionManager::register_action (editor->editor_actions, submenu_name.c_str(), _("Controls"));
 767
 768                                 action_name += "Feedback";
 769
 770                                 Glib::RefPtr<Action> act = ActionManager::register_toggle_action (editor->editor_actions, action_name.c_str(), _("Feedback"),
 771                                                                                                   (bind (mem_fun (*this, &ARDOUR_UI::toggle_control_protocol_feedback),
 772                                                                                                          *i,
 773                                                                                                          "Editor",
 774                                                                                                          action_name)));
 775
 776                                 ui += "<menu action='";
 777                                 ui += submenu_name;
 778                                 ui += "'>\n<menuitem action='";
 779                                 ui += action_name;
 780                                 ui += "'/>\n</menu>\n";
 781
 782                                 if ((*i)->protocol) {
 783                                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 784                                         tact->set_active ((*i)->protocol->get_feedback ());
 785                                 }
 786                         }
 787                 }
 788         }
 789
 790         ui += "</menu>\n</menu>\n</menubar>\n";
 791
 792         ActionManager::ui_manager->add_ui_from_string (ui);
 793 }
 794
 795 void
 796 ARDOUR_UI::build_menu_bar ()
 797 {
 798         if (!Profile->get_sae()) {
 799                 build_control_surface_menu ();
 800         }
 801
 802         menu_bar = dynamic_cast<MenuBar*> (ActionManager::get_widget (X_("/Main")));
 803         menu_bar->set_name ("MainMenuBar");
 804
 805         /*
 806          * This is needed because this property does not get installed
 807          * until the Menu GObject class is registered, which happens
 808          * when the first menu instance is created.
 809          */
 810         // XXX bug in gtkmm causes this to popup an error message
 811         // Gtk::Settings::get_default()->property_gtk_can_change_accels() = true;
 812         // so use this instead ...
 813         gtk_settings_set_long_property (gtk_settings_get_default(), "gtk-can-change-accels", 1, "Ardour:designers");
 814
 815         wall_clock_box.add (wall_clock_label);
 816         wall_clock_box.set_name ("WallClock");
 817         wall_clock_label.set_name ("WallClock");
 818
 819         disk_space_box.add (disk_space_label);
 820         disk_space_box.set_name ("WallClock");
 821         disk_space_label.set_name ("WallClock");
 822
 823         cpu_load_box.add (cpu_load_label);
 824         cpu_load_box.set_name ("CPULoad");
 825         cpu_load_label.set_name ("CPULoad");
 826
 827         buffer_load_box.add (buffer_load_label);
 828         buffer_load_box.set_name ("BufferLoad");
 829         buffer_load_label.set_name ("BufferLoad");
 830
 831         sample_rate_box.add (sample_rate_label);
 832         sample_rate_box.set_name ("SampleRate");
 833         sample_rate_label.set_name ("SampleRate");
 834
 835 #ifndef TOP_MENUBAR
 836         menu_hbox.pack_start (*menu_bar, true, true);
 837 #else
 838         use_menubar_as_top_menubar ();
 839 #endif
 840         if (!Profile->get_small_screen()) {
 841 #ifndef GTKOSX
 842                 // OSX provides its own wallclock, thank you very much
 843                 menu_hbox.pack_end (wall_clock_box, false, false, 2);
 844 #endif
 845                 menu_hbox.pack_end (disk_space_box, false, false, 4);
 846         }
 847         menu_hbox.pack_end (cpu_load_box, false, false, 4);
 848         menu_hbox.pack_end (buffer_load_box, false, false, 4);
 849         menu_hbox.pack_end (sample_rate_box, false, false, 4);
 850
 851         menu_bar_base.set_name ("MainMenuBar");
 852         menu_bar_base.add (menu_hbox);
 853 }
 854
 855 void
 856 ARDOUR_UI::use_menubar_as_top_menubar ()
 857 {
 858         Gtk::Widget* widget;
 859         Application* app = Application::instance ();
 860
 861         /* Quit will be taken of separately */
 862
 863         if ((widget = ActionManager::get_widget ("/ui/Main/Session/Quit"))) {
 864                 widget->hide ();
 865         }
 866
 867         GtkApplicationMenuGroup* group = app->add_app_menu_group ();
 868
 869         if ((widget = ActionManager::get_widget ("/ui/Main/Help/About"))) {
 870                 app->add_app_menu_item (group, dynamic_cast<MenuItem*>(widget));
 871         }
 872
 873         if ((widget = ActionManager::get_widget ("/ui/Main/WindowMenu/ToggleOptionsEditor"))) {
 874                 app->add_app_menu_item (group, dynamic_cast<MenuItem*>(widget));
 875         }
 876
 877         app->set_menu_bar (*menu_bar);
 878
 879         app->ShouldQuit.connect (sigc::mem_fun (*this, &ARDOUR_UI::queue_finish));
 880         app->ShouldLoad.connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_load));
 881 }
 882
 883 void
 884 ARDOUR_UI::setup_clock ()
 885 {
 886         ARDOUR_UI::Clock.connect (bind (mem_fun (big_clock, &AudioClock::set), false));
 887
 888         big_clock_window = new Window (WINDOW_TOPLEVEL);
 889
 890         big_clock_window->set_keep_above (true);
 891         big_clock_window->set_border_width (0);
 892         big_clock_window->add  (big_clock);
 893         big_clock_window->signal_key_press_event().connect (bind (sigc::ptr_fun (relay_key_press), big_clock_window));
 894
 895         big_clock_window->set_title (_("Clock"));
 896         big_clock_window->set_type_hint (Gdk::WINDOW_TYPE_HINT_UTILITY);
 897         big_clock_window->signal_realize().connect (bind (sigc::ptr_fun (set_decoration), big_clock_window,  (Gdk::DECOR_BORDER|Gdk::DECOR_RESIZEH)));
 898         big_clock_window->signal_unmap().connect (bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleBigClock")));
 899
 900         manage_window (*big_clock_window);
 901 }
 902
 903 void
 904 ARDOUR_UI::float_big_clock (Gtk::Window* parent)
 905 {
 906         if (big_clock_window) {
 907                 if (parent) {
 908                         big_clock_window->set_transient_for (*parent);
 909                 } else {
 910                         gtk_window_set_transient_for (big_clock_window->gobj(), (GtkWindow*) 0);
 911                 }
 912         }
 913 }
 914