gtk2_ardour/ardour_ui_ed.cc

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