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