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