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)));
 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_("Metadata"), _("Metadata"));
 140         ActionManager::session_sensitive_actions.push_back (act);
 141
 142         act = ActionManager::register_action (main_actions, X_("EditMetadata"), _("Edit Metadata"),  mem_fun(*this, &ARDOUR_UI::edit_metadata));
 143         ActionManager::session_sensitive_actions.push_back (act);
 144
 145         act = ActionManager::register_action (main_actions, X_("ImportMetadata"), _("Import Metadata"),  mem_fun(*this, &ARDOUR_UI::import_metadata));
 146         ActionManager::session_sensitive_actions.push_back (act);
 147
 148         act = ActionManager::register_action (main_actions, X_("ExportAudio"), _("Export To Audio File(s)..."),  mem_fun (*editor, &PublicEditor::export_audio));
 149         ActionManager::session_sensitive_actions.push_back (act);
 150
 151         act = ActionManager::register_action (main_actions, X_("Export"), _("Export"));
 152         ActionManager::session_sensitive_actions.push_back (act);
 153
 154         act = ActionManager::register_action (main_actions, X_("CleanupUnused"), _("Cleanup Unused Sources"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::cleanup));
 155         ActionManager::session_sensitive_actions.push_back (act);
 156         act = ActionManager::register_action (main_actions, X_("FlushWastebasket"), _("Flush Wastebasket"),  mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::flush_trash));
 157         ActionManager::session_sensitive_actions.push_back (act);
 158
 159         /* JACK actions for controlling ... JACK */
 160
 161         Glib::RefPtr<ActionGroup> jack_actions = ActionGroup::create (X_("JACK"));
 162         ActionManager::register_action (jack_actions, X_("JACK"), _("JACK"));
 163         ActionManager::register_action (jack_actions, X_("Latency"), _("Latency"));
 164
 165         act = ActionManager::register_action (jack_actions, X_("JACKReconnect"), _("Reconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_jack));
 166         ActionManager::jack_opposite_sensitive_actions.push_back (act);
 167
 168         act = ActionManager::register_action (jack_actions, X_("JACKDisconnect"), _("Disconnect"), mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_jack));
 169         ActionManager::jack_sensitive_actions.push_back (act);
 170
 171         RadioAction::Group jack_latency_group;
 172
 173         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));
 174         ActionManager::jack_sensitive_actions.push_back (act);
 175         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));
 176         ActionManager::jack_sensitive_actions.push_back (act);
 177         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));
 178         ActionManager::jack_sensitive_actions.push_back (act);
 179         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));
 180         ActionManager::jack_sensitive_actions.push_back (act);
 181         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));
 182         ActionManager::jack_sensitive_actions.push_back (act);
 183         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));
 184         ActionManager::jack_sensitive_actions.push_back (act);
 185         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));
 186         ActionManager::jack_sensitive_actions.push_back (act);
 187         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));
 188         ActionManager::jack_sensitive_actions.push_back (act);
 189         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));
 190         ActionManager::jack_sensitive_actions.push_back (act);
 191
 192         /* these actions are intended to be shared across all windows */
 193
 194         common_actions = ActionGroup::create (X_("Common"));
 195         ActionManager::register_action (main_actions, X_("WindowMenu"), _("Window"));
 196         ActionManager::register_action (common_actions, X_("Quit"), _("Quit"), (hide_return (mem_fun(*this, &ARDOUR_UI::finish))));
 197
 198         /* windows visibility actions */
 199
 200         ActionManager::register_toggle_action (common_actions, X_("ToggleMaximalEditor"), _("Maximise Editor Space"), mem_fun (*this, &ARDOUR_UI::toggle_editing_space));
 201
 202         ActionManager::register_action (common_actions, X_("goto-editor"), _("Show Editor"),  mem_fun(*this, &ARDOUR_UI::goto_editor_window));
 203         ActionManager::register_action (common_actions, X_("goto-mixer"), _("Show Mixer"),  mem_fun(*this, &ARDOUR_UI::goto_mixer_window));
 204         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));
 205         ActionManager::register_toggle_action (common_actions, X_("ToggleOptionsEditor"), _("Preferences"), mem_fun(*this, &ARDOUR_UI::toggle_options_window));
 206         act = ActionManager::register_toggle_action (common_actions, X_("ToggleInspector"), _("Track/Bus Inspector"), mem_fun(*this, &ARDOUR_UI::toggle_route_params_window));
 207         ActionManager::session_sensitive_actions.push_back (act);
 208         ActionManager::session_sensitive_actions.push_back (act);
 209         act = ActionManager::register_toggle_action (common_actions, X_("ToggleLocations"), _("Locations"), mem_fun(*this, &ARDOUR_UI::toggle_location_window));
 210         ActionManager::session_sensitive_actions.push_back (act);
 211         act = ActionManager::register_toggle_action (common_actions, X_("ToggleBigClock"), _("Big Clock"), mem_fun(*this, &ARDOUR_UI::toggle_big_clock_window));
 212         ActionManager::session_sensitive_actions.push_back (act);
 213         ActionManager::register_action (common_actions, X_("About"), _("About"),  mem_fun(*this, &ARDOUR_UI::show_about));
 214         ActionManager::register_toggle_action (common_actions, X_("ToggleThemeManager"), _("Theme Manager"), mem_fun(*this, &ARDOUR_UI::toggle_theme_manager));
 215         ActionManager::register_toggle_action (common_actions, X_("ToggleKeyEditor"), _("Keybindings"), mem_fun(*this, &ARDOUR_UI::toggle_key_editor));
 216         ActionManager::register_toggle_action (common_actions, X_("ToggleBundleManager"), _("Bundle Manager"), mem_fun(*this, &ARDOUR_UI::toggle_bundle_manager));
 217
 218         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));
 219         ActionManager::session_sensitive_actions.push_back (act);
 220         act = ActionManager::register_action (common_actions, X_("AddAudioBus"), _("Add Audio Bus"), bind (mem_fun(*this, &ARDOUR_UI::session_add_audio_bus), 1, 1, 1));
 221         ActionManager::session_sensitive_actions.push_back (act);
 222         act = ActionManager::register_action (common_actions, X_("AddMIDITrack"), _("Add MIDI Track"), bind (mem_fun(*this, &ARDOUR_UI::session_add_midi_track), 1));
 223         ActionManager::session_sensitive_actions.push_back (act);
 224         //act = ActionManager::register_action (common_actions, X_("AddMidiBus"), _("Add Midi Bus"), mem_fun(*this, &ARDOUR_UI::session_add_midi_bus));
 225         //ActionManager::session_sensitive_actions.push_back (act);
 226         act = ActionManager::register_action (common_actions, X_("Save"), _("Save"),  bind (mem_fun(*this, &ARDOUR_UI::save_state), string("")));
 227         ActionManager::session_sensitive_actions.push_back (act);
 228         act = ActionManager::register_action (common_actions, X_("RemoveLastCapture"), _("Remove Last Capture"), mem_fun(*this, &ARDOUR_UI::remove_last_capture));
 229         ActionManager::session_sensitive_actions.push_back (act);
 230
 231         Glib::RefPtr<ActionGroup> transport_actions = ActionGroup::create (X_("Transport"));
 232
 233         /* do-nothing action for the "transport" menu bar item */
 234
 235         ActionManager::register_action (transport_actions, X_("Transport"), _("Transport"));
 236
 237         /* these two are not used by key bindings, instead use ToggleRoll for that. these two do show up in
 238            menus and via button proxies.
 239         */
 240
 241         act = ActionManager::register_action (transport_actions, X_("Stop"), _("Stop"), mem_fun(*this, &ARDOUR_UI::transport_stop));
 242         ActionManager::session_sensitive_actions.push_back (act);
 243         ActionManager::transport_sensitive_actions.push_back (act);
 244         act = ActionManager::register_action (transport_actions, X_("Roll"), _("Roll"), mem_fun(*this, &ARDOUR_UI::transport_roll));
 245         ActionManager::session_sensitive_actions.push_back (act);
 246         ActionManager::transport_sensitive_actions.push_back (act);
 247
 248         ActionManager::register_action (transport_actions, X_("ToggleRoll"), _("Start/Stop"), bind (mem_fun (*editor, &PublicEditor::toggle_playback), false));
 249         ActionManager::session_sensitive_actions.push_back (act);
 250         ActionManager::transport_sensitive_actions.push_back (act);
 251         ActionManager::register_action (transport_actions, X_("ToggleRollForgetCapture"), _("Stop and Forget Capture"), bind (mem_fun(*editor, &PublicEditor::toggle_playback), true));
 252         ActionManager::session_sensitive_actions.push_back (act);
 253         ActionManager::transport_sensitive_actions.push_back (act);
 254
 255         /* these two behave as follows:
 256
 257            - if transport speed != 1.0 or != -1.0, change speed to 1.0 or -1.0 (respectively)
 258            - otherwise do nothing
 259         */
 260
 261         ActionManager::register_action (transport_actions, X_("TransitionToRoll"), _("Transition To Roll"), bind (mem_fun (*editor, &PublicEditor::transition_to_rolling), true));
 262         ActionManager::session_sensitive_actions.push_back (act);
 263         ActionManager::session_sensitive_actions.push_back (act);
 264
 265         ActionManager::register_action (transport_actions, X_("TransitionToReverse"), _("Transition To Reverse"), bind (mem_fun (*editor, &PublicEditor::transition_to_rolling), false));
 266         ActionManager::session_sensitive_actions.push_back (act);
 267         ActionManager::session_sensitive_actions.push_back (act);
 268
 269
 270         act = ActionManager::register_action (transport_actions, X_("Loop"), _("Play Loop Range"), mem_fun(*this, &ARDOUR_UI::toggle_session_auto_loop));
 271         ActionManager::session_sensitive_actions.push_back (act);
 272         ActionManager::transport_sensitive_actions.push_back (act);
 273         act = ActionManager::register_action (transport_actions, X_("PlaySelection"), _("Play Selection"), mem_fun(*this, &ARDOUR_UI::transport_play_selection));
 274         ActionManager::session_sensitive_actions.push_back (act);
 275         ActionManager::transport_sensitive_actions.push_back (act);
 276
 277         act = ActionManager::register_action (transport_actions, X_("Record"), _("Enable Record"), bind (mem_fun(*this, &ARDOUR_UI::transport_record), false));
 278         ActionManager::session_sensitive_actions.push_back (act);
 279         act = ActionManager::register_action (transport_actions, X_("record-roll"), _("Start Recording"), bind (mem_fun(*this, &ARDOUR_UI::transport_record), true));
 280         ActionManager::session_sensitive_actions.push_back (act);
 281         ActionManager::transport_sensitive_actions.push_back (act);
 282         act = ActionManager::register_action (transport_actions, X_("Rewind"), _("Rewind"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 0));
 283         ActionManager::session_sensitive_actions.push_back (act);
 284         ActionManager::transport_sensitive_actions.push_back (act);
 285         act = ActionManager::register_action (transport_actions, X_("RewindSlow"), _("Rewind (Slow)"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), -1));
 286         ActionManager::session_sensitive_actions.push_back (act);
 287         ActionManager::transport_sensitive_actions.push_back (act);
 288         act = ActionManager::register_action (transport_actions, X_("RewindFast"), _("Rewind (Fast)"), bind (mem_fun(*this, &ARDOUR_UI::transport_rewind), 1));
 289         ActionManager::session_sensitive_actions.push_back (act);
 290         ActionManager::transport_sensitive_actions.push_back (act);
 291         act = ActionManager::register_action (transport_actions, X_("Forward"), _("Forward"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 0));
 292         ActionManager::session_sensitive_actions.push_back (act);
 293         ActionManager::transport_sensitive_actions.push_back (act);
 294         act = ActionManager::register_action (transport_actions, X_("ForwardSlow"), _("Forward (Slow)"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), -1));
 295         ActionManager::session_sensitive_actions.push_back (act);
 296         ActionManager::transport_sensitive_actions.push_back (act);
 297         act = ActionManager::register_action (transport_actions, X_("ForwardFast"), _("Forward (Fast)"), bind (mem_fun(*this, &ARDOUR_UI::transport_forward), 1));
 298         ActionManager::session_sensitive_actions.push_back (act);
 299         ActionManager::transport_sensitive_actions.push_back (act);
 300         act = ActionManager::register_action (transport_actions, X_("GotoZero"), _("Goto Zero"), mem_fun(*this, &ARDOUR_UI::transport_goto_zero));
 301         ActionManager::session_sensitive_actions.push_back (act);
 302         ActionManager::transport_sensitive_actions.push_back (act);
 303         act = ActionManager::register_action (transport_actions, X_("GotoStart"), _("Goto Start"), mem_fun(*this, &ARDOUR_UI::transport_goto_start));
 304         ActionManager::session_sensitive_actions.push_back (act);
 305         ActionManager::transport_sensitive_actions.push_back (act);
 306         act = ActionManager::register_action (transport_actions, X_("GotoEnd"), _("Goto End"), mem_fun(*this, &ARDOUR_UI::transport_goto_end));
 307         ActionManager::session_sensitive_actions.push_back (act);
 308         ActionManager::transport_sensitive_actions.push_back (act);
 309         act = ActionManager::register_action (transport_actions, X_("GotoWallClock"), _("Goto Wall Clock"), mem_fun(*this, &ARDOUR_UI::transport_goto_wallclock));
 310         ActionManager::session_sensitive_actions.push_back (act);
 311         ActionManager::transport_sensitive_actions.push_back (act);
 312
 313         act = ActionManager::register_action (transport_actions, X_("focus-on-clock"), _("Focus On Clock"), mem_fun(primary_clock, &AudioClock::focus));
 314         ActionManager::session_sensitive_actions.push_back (act);
 315         ActionManager::transport_sensitive_actions.push_back (act);
 316
 317         act = ActionManager::register_action (transport_actions, X_("primary-clock-bbt"), _("Bars & Beats"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::BBT));
 318         ActionManager::session_sensitive_actions.push_back (act);
 319         act = ActionManager::register_action (transport_actions, X_("primary-clock-minsec"), _("Minutes & Seconds"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::MinSec));
 320         ActionManager::session_sensitive_actions.push_back (act);
 321         act = ActionManager::register_action (transport_actions, X_("primary-clock-samples"), _("Samples"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::Frames));
 322         ActionManager::session_sensitive_actions.push_back (act);
 323         act = ActionManager::register_action (transport_actions, X_("primary-clock-off"), _("Off"), bind (mem_fun(primary_clock, &AudioClock::set_mode), AudioClock::Off));
 324         ActionManager::session_sensitive_actions.push_back (act);
 325
 326         act = ActionManager::register_action (transport_actions, X_("secondary-clock-bbt"), _("Bars & Beats"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::BBT));
 327         ActionManager::session_sensitive_actions.push_back (act);
 328         act = ActionManager::register_action (transport_actions, X_("secondary-clock-minsec"), _("Minutes & Seconds"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::MinSec));
 329         ActionManager::session_sensitive_actions.push_back (act);
 330         act = ActionManager::register_action (transport_actions, X_("secondary-clock-samples"), _("Samples"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::Frames));
 331         ActionManager::session_sensitive_actions.push_back (act);
 332         act = ActionManager::register_action (transport_actions, X_("secondary-clock-off"), _("Off"), bind (mem_fun(secondary_clock, &AudioClock::set_mode), AudioClock::Off));
 333         ActionManager::session_sensitive_actions.push_back (act);
 334
 335         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunchIn"), _("Punch In"), mem_fun(*this, &ARDOUR_UI::toggle_punch_in));
 336         ActionManager::session_sensitive_actions.push_back (act);
 337         ActionManager::transport_sensitive_actions.push_back (act);
 338         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunchOut"), _("Punch Out"), mem_fun(*this, &ARDOUR_UI::toggle_punch_out));
 339         ActionManager::session_sensitive_actions.push_back (act);
 340         ActionManager::transport_sensitive_actions.push_back (act);
 341         act = ActionManager::register_toggle_action (transport_actions, X_("TogglePunch"), _("Punch In/Out"), mem_fun(*this, &ARDOUR_UI::toggle_punch));
 342         ActionManager::session_sensitive_actions.push_back (act);
 343         ActionManager::transport_sensitive_actions.push_back (act);
 344         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleClick"), _("Click"), mem_fun(*this, &ARDOUR_UI::toggle_click));
 345         ActionManager::session_sensitive_actions.push_back (act);
 346         ActionManager::transport_sensitive_actions.push_back (act);
 347         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoInput"), _("Auto Input"), mem_fun(*this, &ARDOUR_UI::toggle_auto_input));
 348         ActionManager::session_sensitive_actions.push_back (act);
 349         ActionManager::transport_sensitive_actions.push_back (act);
 350         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoPlay"), _("Auto Play"), mem_fun(*this, &ARDOUR_UI::toggle_auto_play));
 351         ActionManager::session_sensitive_actions.push_back (act);
 352         ActionManager::transport_sensitive_actions.push_back (act);
 353         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleAutoReturn"), _("Auto Return"), mem_fun(*this, &ARDOUR_UI::toggle_auto_return));
 354         ActionManager::session_sensitive_actions.push_back (act);
 355         ActionManager::transport_sensitive_actions.push_back (act);
 356
 357         ActionManager::register_toggle_action (transport_actions, X_("ToggleVideoSync"), _("Sync startup to video"), mem_fun(*this, &ARDOUR_UI::toggle_video_sync));
 358         act = ActionManager::register_toggle_action (transport_actions, X_("ToggleTimeMaster"), _("Time Master"), mem_fun(*this, &ARDOUR_UI::toggle_time_master));
 359         ActionManager::session_sensitive_actions.push_back (act);
 360
 361         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack1"), _("Toggle Record Enable Track1"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  0U));
 362         ActionManager::session_sensitive_actions.push_back (act);
 363         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack2"), _("Toggle Record Enable Track2"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  1U));
 364         ActionManager::session_sensitive_actions.push_back (act);
 365         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack3"), _("Toggle Record Enable Track3"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  2U));
 366         ActionManager::session_sensitive_actions.push_back (act);
 367         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack4"), _("Toggle Record Enable Track4"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  3U));
 368         ActionManager::session_sensitive_actions.push_back (act);
 369         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack5"), _("Toggle Record Enable Track5"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  4U));
 370         ActionManager::session_sensitive_actions.push_back (act);
 371         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack6"), _("Toggle Record Enable Track6"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  5U));
 372         ActionManager::session_sensitive_actions.push_back (act);
 373         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack7"), _("Toggle Record Enable Track7"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  6U));
 374         ActionManager::session_sensitive_actions.push_back (act);
 375         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack8"), _("Toggle Record Enable Track8"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  7U));
 376         ActionManager::session_sensitive_actions.push_back (act);
 377         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack9"), _("Toggle Record Enable Track9"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable),  8U));
 378         ActionManager::session_sensitive_actions.push_back (act);
 379         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack10"), _("Toggle Record Enable Track10"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 9U));
 380         ActionManager::session_sensitive_actions.push_back (act);
 381         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack11"), _("Toggle Record Enable Track11"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 10U));
 382         ActionManager::session_sensitive_actions.push_back (act);
 383         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack12"), _("Toggle Record Enable Track12"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 11U));
 384         ActionManager::session_sensitive_actions.push_back (act);
 385         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack13"), _("Toggle Record Enable Track13"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 12U));
 386         ActionManager::session_sensitive_actions.push_back (act);
 387         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack14"), _("Toggle Record Enable Track14"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 13U));
 388         ActionManager::session_sensitive_actions.push_back (act);
 389         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack15"), _("Toggle Record Enable Track15"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 14U));
 390         ActionManager::session_sensitive_actions.push_back (act);
 391         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack16"), _("Toggle Record Enable Track16"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 15U));
 392         ActionManager::session_sensitive_actions.push_back (act);
 393         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack17"), _("Toggle Record Enable Track17"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 16U));
 394         ActionManager::session_sensitive_actions.push_back (act);
 395         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack18"), _("Toggle Record Enable Track18"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 17U));
 396         ActionManager::session_sensitive_actions.push_back (act);
 397         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack19"), _("Toggle Record Enable Track19"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 18U));
 398         ActionManager::session_sensitive_actions.push_back (act);
 399         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack20"), _("Toggle Record Enable Track20"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 19U));
 400         ActionManager::session_sensitive_actions.push_back (act);
 401         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack21"), _("Toggle Record Enable Track21"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 20U));
 402         ActionManager::session_sensitive_actions.push_back (act);
 403         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack22"), _("Toggle Record Enable Track22"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 21U));
 404         ActionManager::session_sensitive_actions.push_back (act);
 405         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack23"), _("Toggle Record Enable Track23"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 22U));
 406         ActionManager::session_sensitive_actions.push_back (act);
 407         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack24"), _("Toggle Record Enable Track24"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 23U));
 408         ActionManager::session_sensitive_actions.push_back (act);
 409         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack25"), _("Toggle Record Enable Track25"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 24U));
 410         ActionManager::session_sensitive_actions.push_back (act);
 411         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack26"), _("Toggle Record Enable Track26"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 25U));
 412         ActionManager::session_sensitive_actions.push_back (act);
 413         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack27"), _("Toggle Record Enable Track27"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 26U));
 414         ActionManager::session_sensitive_actions.push_back (act);
 415         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack28"), _("Toggle Record Enable Track28"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 27U));
 416         ActionManager::session_sensitive_actions.push_back (act);
 417         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack29"), _("Toggle Record Enable Track29"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 28U));
 418         ActionManager::session_sensitive_actions.push_back (act);
 419         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack30"), _("Toggle Record Enable Track30"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 29U));
 420         ActionManager::session_sensitive_actions.push_back (act);
 421         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack31"), _("Toggle Record Enable Track31"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 30U));
 422         ActionManager::session_sensitive_actions.push_back (act);
 423         act = ActionManager::register_action (common_actions, X_("ToggleRecordEnableTrack32"), _("Toggle Record Enable Track32"), bind (mem_fun(*this, &ARDOUR_UI::toggle_record_enable), 31U));
 424         ActionManager::session_sensitive_actions.push_back (act);
 425
 426         Glib::RefPtr<ActionGroup> shuttle_actions = ActionGroup::create ("ShuttleActions");
 427
 428         shuttle_actions->add (Action::create (X_("SetShuttleUnitsPercentage"), _("Percentage")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Percentage)));
 429         shuttle_actions->add (Action::create (X_("SetShuttleUnitsSemitones"), _("Semitones")), hide_return (bind (mem_fun (*Config, &Configuration::set_shuttle_units), Semitones)));
 430
 431         Glib::RefPtr<ActionGroup> option_actions = ActionGroup::create ("options");
 432
 433         act = ActionManager::register_toggle_action (option_actions, X_("SendMTC"), _("Send MTC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mtc));
 434         ActionManager::session_sensitive_actions.push_back (act);
 435         act = ActionManager::register_toggle_action (option_actions, X_("SendMMC"), _("Send MMC"), mem_fun (*this, &ARDOUR_UI::toggle_send_mmc));
 436         ActionManager::session_sensitive_actions.push_back (act);
 437         act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Use MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc));
 438         ActionManager::session_sensitive_actions.push_back (act);
 439         act = ActionManager::register_toggle_action (option_actions, X_("SendMidiClock"), _("Send MIDI Clock"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_clock));
 440         ActionManager::session_sensitive_actions.push_back (act);
 441         act = ActionManager::register_toggle_action (option_actions, X_("SendMIDIfeedback"), _("Send MIDI Feedback"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_feedback));
 442         ActionManager::session_sensitive_actions.push_back (act);
 443         act = ActionManager::register_toggle_action (option_actions, X_("ToggleTapeMachineMode"), _("Tape Machine Mode"), mem_fun (*this, &ARDOUR_UI::toggle_TapeMachineMode));
 444         ActionManager::session_sensitive_actions.push_back (act);
 445
 446         ActionManager::register_toggle_action (option_actions, X_("SyncEditorAndMixerTrackOrder"), _("Sync Editor and Mixer Track Order"), mem_fun (*this, &ARDOUR_UI::toggle_sync_order_keys));
 447         ActionManager::register_toggle_action (option_actions, X_("StopPluginsWithTransport"), _("Stop Plugins with Transport"), mem_fun (*this, &ARDOUR_UI::toggle_StopPluginsWithTransport));
 448         ActionManager::register_toggle_action (option_actions, X_("NewPluginsActive"), _("New Plugins are Active"), mem_fun (*this, &ARDOUR_UI::toggle_new_plugins_active));
 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         ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalNone"), _("No processor handling"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalNone));
 471
 472         // as of September 10th 2007, Valgrind cannot handle various FPU flag setting instructions
 473         // so avoid them
 474
 475         if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
 476
 477                 /* we still need these actions to exist, but make them all insensitive */
 478
 479                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 480                 act->set_sensitive (false);
 481                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 482                 act->set_sensitive (false);
 483                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 484                 act->set_sensitive (false);
 485
 486         } else {
 487
 488                 FPU fpu;
 489
 490                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZ"), _("Use FlushToZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZ));
 491                 if (!fpu.has_flush_to_zero()) {
 492                         act->set_sensitive (false);
 493                 }
 494
 495                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalDAZ"), _("Use DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalDAZ));
 496                 if (!fpu.has_denormals_are_zero()) {
 497                         act->set_sensitive (false);
 498                 }
 499
 500                 act = ActionManager::register_radio_action (option_actions, denormal_group, X_("DenormalFTZDAZ"), _("Use FlushToZero & DenormalsAreZero"), bind (mem_fun (*this, &ARDOUR_UI::set_denormal_model), DenormalFTZDAZ));
 501                 if (!fpu.has_flush_to_zero() || !fpu.has_denormals_are_zero()) {
 502                         act->set_sensitive (false);
 503                 }
 504         }
 505
 506         act = ActionManager::register_toggle_action (option_actions, X_("DoNotRunPluginsWhileRecording"), _("Do not Run Plugins While Recording"), mem_fun (*this, &ARDOUR_UI::toggle_DoNotRunPluginsWhileRecording));
 507         ActionManager::session_sensitive_actions.push_back (act);
 508
 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         act = ActionManager::register_toggle_action (option_actions, X_("SoloMuteOverride"), _("Override Muting"), mem_fun (*this, &ARDOUR_UI::toggle_SoloMuteOverride));
 514         ActionManager::session_sensitive_actions.push_back (act);
 515
 516         /* act = ActionManager::register_action (option_actions, X_("DisableAllPlugins"), _("Disable All Plugins"), mem_fun (*this, &ARDOUR_UI::disable_all_plugins));
 517         ActionManager::session_sensitive_actions.push_back (act);
 518         act = ActionManager::register_action (option_actions, X_("ABAllPlugins"), _("A/B All Plugins"), mem_fun (*this, &ARDOUR_UI::ab_all_plugins));
 519         ActionManager::session_sensitive_actions.push_back (act); */
 520
 521         /* !!! REMEMBER THAT RADIO ACTIONS HAVE TO BE HANDLED WITH MORE FINESSE THAN SIMPLE TOGGLES !!! */
 522
 523         RadioAction::Group meter_falloff_group;
 524         RadioAction::Group meter_hold_group;
 525
 526         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffOff));
 527         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlowest"), _("Slowest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlowest));
 528         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffSlow"), _("Slow"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffSlow));
 529         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffMedium));
 530         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFast"), _("Fast"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFast));
 531         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFaster"), _("Faster"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFaster));
 532         ActionManager::register_radio_action (option_actions, meter_falloff_group, X_("MeterFalloffFastest"), _("Fastest"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_falloff), MeterFalloffFastest));
 533
 534         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldOff"), _("Off"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldOff));
 535         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldShort"), _("Short"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldShort));
 536         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldMedium"), _("Medium"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldMedium));
 537         ActionManager::register_radio_action (option_actions, meter_hold_group,  X_("MeterHoldLong"), _("Long"), bind (mem_fun (*this, &ARDOUR_UI::set_meter_hold), MeterHoldLong));
 538
 539         RadioAction::Group file_header_group;
 540
 541         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));
 542         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));
 543         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));
 544         // 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));
 545         // 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));
 546         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));
 547
 548         RadioAction::Group file_data_group;
 549
 550
 551         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));
 552         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));
 553         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));
 554
 555         RadioAction::Group monitoring_group;
 556
 557         /* it would be nice not to even show this item, but that messes up the
 558            menus which are not dynamically modified at runtime. so we make it
 559            sensitive only if it makes sense.
 560         */
 561
 562         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseHardwareMonitoring"), _("JACK Does Monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), HardwareMonitoring));
 563         if (!engine->can_request_hardware_monitoring()) {
 564                 act->set_sensitive (false);
 565         }
 566         act = ActionManager::register_radio_action (option_actions, monitoring_group, X_("UseSoftwareMonitoring"), _("Ardour Does Monitoring"), bind (mem_fun (*this, &ARDOUR_UI::set_monitor_model), SoftwareMonitoring));
 567         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));
 568
 569         RadioAction::Group solo_group;
 570
 571         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)));
 572         ActionManager::session_sensitive_actions.push_back (act);
 573         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)));
 574         ActionManager::session_sensitive_actions.push_back (act);
 575
 576         RadioAction::Group input_auto_connect_group;
 577
 578         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)));
 579         ActionManager::session_sensitive_actions.push_back (act);
 580         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)));
 581         ActionManager::session_sensitive_actions.push_back (act);
 582
 583         RadioAction::Group output_auto_connect_group;
 584
 585         act = ActionManager::register_radio_action (option_actions, output_auto_connect_group, X_("OutputAutoConnectPhysical"), _("Auto-connect Outputs to Physical Outputs"), hide_return (bind (mem_fun (*this, &ARDOUR_UI::set_output_auto_connect), AutoConnectPhysical)));
 586         ActionManager::session_sensitive_actions.push_back (act);
 587         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)));
 588         ActionManager::session_sensitive_actions.push_back (act);
 589         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)));
 590         ActionManager::session_sensitive_actions.push_back (act);
 591
 592         RadioAction::Group remote_group;
 593
 594         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)));
 595         ActionManager::session_sensitive_actions.push_back (act);
 596         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)));
 597         ActionManager::session_sensitive_actions.push_back (act);
 598         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)));
 599         ActionManager::session_sensitive_actions.push_back (act);
 600
 601         act = ActionManager::register_toggle_action (option_actions, X_("AutoRebinding"), _("Auto Rebind Controls"), mem_fun (*(this->mixer), &Mixer_UI::toggle_auto_rebinding));
 602         ActionManager::session_sensitive_actions.push_back (act);
 603
 604
 605         ActionManager::add_action_group (shuttle_actions);
 606         ActionManager::add_action_group (option_actions);
 607         ActionManager::add_action_group (jack_actions);
 608         ActionManager::add_action_group (transport_actions);
 609         ActionManager::add_action_group (main_actions);
 610         ActionManager::add_action_group (common_actions);
 611 }
 612
 613 void
 614 ARDOUR_UI::toggle_control_protocol (ControlProtocolInfo* cpi)
 615 {
 616         if (!session) {
 617                 /* this happens when we build the menu bar when control protocol support
 618                    has been used in the past for some given protocol - the item needs
 619                    to be made active, but there is no session yet.
 620                 */
 621                 return;
 622         }
 623
 624         if (cpi->protocol == 0) {
 625                 ControlProtocolManager::instance().instantiate (*cpi);
 626         } else {
 627                 ControlProtocolManager::instance().teardown (*cpi);
 628         }
 629 }
 630
 631 void
 632 ARDOUR_UI::toggle_control_protocol_feedback (ControlProtocolInfo* cpi, const char* group, string action)
 633 {
 634         if (!session) {
 635                 /* this happens when we build the menu bar when control protocol support
 636                    has been used in the past for some given protocol - the item needs
 637                    to be made active, but there is no session yet.
 638                 */
 639                 return;
 640         }
 641
 642         if (cpi->protocol) {
 643                 Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (group, action.c_str());
 644
 645                 if (act) {
 646                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 647
 648                         if (tact) {
 649                                 bool x = tact->get_active();
 650
 651                                 if (x != cpi->protocol->get_feedback()) {
 652                                         cpi->protocol->set_feedback (x);
 653                                 }
 654                         }
 655                 }
 656         }
 657 }
 658
 659 void
 660 ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
 661 {
 662         Glib::RefPtr<Action> action;
 663         const char* action_name = 0;
 664
 665         switch (nframes) {
 666         case 32:
 667                 action_name = X_("JACKLatency32");
 668                 break;
 669         case 64:
 670                 action_name = X_("JACKLatency64");
 671                 break;
 672         case 128:
 673                 action_name = X_("JACKLatency128");
 674                 break;
 675         case 512:
 676                 action_name = X_("JACKLatency512");
 677                 break;
 678         case 1024:
 679                 action_name = X_("JACKLatency1024");
 680                 break;
 681         case 2048:
 682                 action_name = X_("JACKLatency2048");
 683                 break;
 684         case 4096:
 685                 action_name = X_("JACKLatency4096");
 686                 break;
 687         case 8192:
 688                 action_name = X_("JACKLatency8192");
 689                 break;
 690         default:
 691                 /* XXX can we do anything useful ? */
 692                 break;
 693         }
 694
 695         if (action_name) {
 696
 697                 action = ActionManager::get_action (X_("JACK"), action_name);
 698
 699                 if (action) {
 700                         Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
 701
 702                         if (ract && ract->get_active()) {
 703                                 engine->request_buffer_size (nframes);
 704                                 update_sample_rate (0);
 705                         }
 706                 }
 707         }
 708 }
 709
 710 void
 711 ARDOUR_UI::build_control_surface_menu ()
 712 {
 713         list<ControlProtocolInfo*>::iterator i;
 714         bool with_feedback;
 715
 716         /* !!! this has to match the top level entry from ardour.menus */
 717
 718         string ui = "<menubar name='Main' action='MainMenu'>\n"
 719                 "<menu name='Options' action='Options'>\n"
 720                 "<menu action='ControlSurfaces'><separator/>\n";
 721
 722         for (i = ControlProtocolManager::instance().control_protocol_info.begin();
 723                         i != ControlProtocolManager::instance().control_protocol_info.end(); ++i) {
 724
 725                 if (!(*i)->mandatory) {
 726
 727                         // Enable surface
 728
 729                         string action_name = "Toggle";
 730                         action_name += legalize_for_path ((*i)->name);
 731                         action_name += "Surface";
 732
 733                         string action_label = (*i)->name;
 734
 735                         Glib::RefPtr<Action> act = ActionManager::register_toggle_action (
 736                                         editor->editor_actions, action_name.c_str(), action_label.c_str(), (bind (
 737                                                         mem_fun (*this, &ARDOUR_UI::toggle_control_protocol),
 738                                                         *i)));
 739
 740                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 741
 742                         with_feedback = false;
 743
 744                         if ((*i)->protocol || (*i)->requested) {
 745                                 tact->set_active ();
 746                         }
 747
 748                         ui += "<menuitem action='";
 749                         ui += action_name;
 750                         ui += "'/>\n";
 751
 752                         // Enable feedback
 753
 754                         if ((*i)->supports_feedback) {
 755
 756                                 action_name += "Feedback";
 757                                 string feedback_label = action_label + " " + _("Feedback");
 758
 759                                 Glib::RefPtr<Action> act = ActionManager::register_toggle_action (
 760                                                 editor->editor_actions, action_name.c_str(), feedback_label.c_str(), (bind (
 761                                                                 mem_fun (*this, &ARDOUR_UI::toggle_control_protocol_feedback),
 762                                                                 *i, "Editor", action_name)));
 763
 764                                 ui += "<menuitem action='";
 765                                 ui += action_name;
 766                                 ui += "'/>\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