gtk2_ardour/rc_option_editor.cc

   1 /*
   2     Copyright (C) 2001-2011 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 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #if !defined USE_CAIRO_IMAGE_SURFACE && !defined NDEBUG
  25 #define OPTIONAL_CAIRO_IMAGE_SURFACE
  26 #endif
  27
  28 #include <cairo/cairo.h>
  29
  30 #include <boost/algorithm/string.hpp>
  31
  32 #include <gtkmm/liststore.h>
  33 #include <gtkmm/stock.h>
  34 #include <gtkmm/scale.h>
  35
  36 #include "gtkmm2ext/utils.h"
  37 #include "gtkmm2ext/gtk_ui.h"
  38 #include "gtkmm2ext/window_title.h"
  39
  40 #include "pbd/fpu.h"
  41 #include "pbd/cpus.h"
  42 #include "pbd/i18n.h"
  43
  44 #include "ardour/audio_backend.h"
  45 #include "ardour/audioengine.h"
  46 #include "ardour/control_protocol_manager.h"
  47 #include "ardour/dB.h"
  48 #include "ardour/port_manager.h"
  49 #include "ardour/plugin_manager.h"
  50 #include "ardour/profile.h"
  51 #include "ardour/rc_configuration.h"
  52 #include "ardour/transport_master_manager.h"
  53
  54 #include "control_protocol/control_protocol.h"
  55
  56 #include "waveview/wave_view.h"
  57
  58 #include "widgets/paths_dialog.h"
  59 #include "widgets/tooltips.h"
  60
  61 #include "ardour_dialog.h"
  62 #include "ardour_ui.h"
  63 #include "ardour_window.h"
  64 #include "color_theme_manager.h"
  65 #include "gui_thread.h"
  66 #include "keyboard.h"
  67 #include "meter_patterns.h"
  68 #include "midi_tracer.h"
  69 #include "rc_option_editor.h"
  70 #include "sfdb_ui.h"
  71 #include "transport_masters_dialog.h"
  72 #include "ui_config.h"
  73 #include "utils.h"
  74
  75 using namespace std;
  76 using namespace Gtk;
  77 using namespace Gtkmm2ext;
  78 using namespace PBD;
  79 using namespace ARDOUR;
  80 using namespace ARDOUR_UI_UTILS;
  81 using namespace ArdourWidgets;
  82
  83 class ClickOptions : public OptionEditorMiniPage
  84 {
  85 public:
  86         ClickOptions (RCConfiguration* c)
  87                 : _rc_config (c)
  88                 , _click_browse_button (_("Browse..."))
  89                 , _click_emphasis_browse_button (_("Browse..."))
  90         {
  91                 // TODO get rid of GTK -> use OptionEditor Widgets
  92                 Table* t = &table;
  93                 Label* l;
  94                 int row = 0;
  95
  96                 l = manage (left_aligned_label (_("Emphasis on first beat")));
  97                 _use_emphasis_on_click_check_button.add (*l);
  98                 t->attach (_use_emphasis_on_click_check_button, 1, 3, row, row + 1, FILL);
  99                 _use_emphasis_on_click_check_button.signal_toggled().connect (
 100                     sigc::mem_fun (*this, &ClickOptions::use_emphasis_on_click_toggled));
 101                 ++row;
 102
 103                 l = manage (left_aligned_label (_("Use built-in default sounds")));
 104                 _use_default_click_check_button.add (*l);
 105                 t->attach (_use_default_click_check_button, 1, 3, row, row + 1, FILL);
 106                 _use_default_click_check_button.signal_toggled().connect (
 107                     sigc::mem_fun (*this, &ClickOptions::use_default_click_toggled));
 108                 ++row;
 109
 110                 l = manage (left_aligned_label (_("Audio file:")));
 111                 t->attach (*l, 1, 2, row, row + 1, FILL);
 112                 t->attach (_click_path_entry, 2, 3, row, row + 1, FILL);
 113                 _click_browse_button.signal_clicked ().connect (
 114                     sigc::mem_fun (*this, &ClickOptions::click_browse_clicked));
 115                 t->attach (_click_browse_button, 3, 4, row, row + 1, FILL);
 116                 ++row;
 117
 118                 l = manage (left_aligned_label (_("Emphasis audio file:")));
 119                 t->attach (*l, 1, 2, row, row + 1, FILL);
 120                 t->attach (_click_emphasis_path_entry, 2, 3, row, row + 1, FILL);
 121                 _click_emphasis_browse_button.signal_clicked ().connect (
 122                     sigc::mem_fun (*this, &ClickOptions::click_emphasis_browse_clicked));
 123                 t->attach (_click_emphasis_browse_button, 3, 4, row, row + 1, FILL);
 124                 ++row;
 125
 126                 _click_fader = new FaderOption (
 127                                 "click-gain",
 128                                 _("Gain level"),
 129                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_click_gain),
 130                                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_click_gain)
 131                                 );
 132
 133                 _click_fader->add_to_page (this);
 134                 _click_fader->set_state_from_config ();
 135
 136                 _click_path_entry.signal_activate().connect (sigc::mem_fun (*this, &ClickOptions::click_changed));
 137                 _click_emphasis_path_entry.signal_activate().connect (sigc::mem_fun (*this, &ClickOptions::click_emphasis_changed));
 138
 139                 if (_rc_config->get_click_sound ().empty() &&
 140                     _rc_config->get_click_emphasis_sound().empty()) {
 141                         _use_default_click_check_button.set_active (true);
 142                         _use_emphasis_on_click_check_button.set_active (_rc_config->get_use_click_emphasis ());
 143
 144                 } else {
 145                         _use_default_click_check_button.set_active (false);
 146                         _use_emphasis_on_click_check_button.set_active (false);
 147                 }
 148         }
 149
 150         void parameter_changed (string const & p)
 151         {
 152                 if (p == "click-sound") {
 153                         _click_path_entry.set_text (_rc_config->get_click_sound());
 154                 } else if (p == "click-emphasis-sound") {
 155                         _click_emphasis_path_entry.set_text (_rc_config->get_click_emphasis_sound());
 156                 } else if (p == "use-click-emphasis") {
 157                         bool x = _rc_config->get_use_click_emphasis ();
 158                         _use_emphasis_on_click_check_button.set_active (x);
 159                 } else if (p == "click-gain") {
 160                         _click_fader->set_state_from_config ();
 161                 }
 162         }
 163
 164         void set_state_from_config ()
 165         {
 166                 parameter_changed ("click-sound");
 167                 parameter_changed ("click-emphasis-sound");
 168                 parameter_changed ("use-click-emphasis");
 169         }
 170
 171 private:
 172
 173         void click_browse_clicked ()
 174         {
 175                 SoundFileChooser sfdb (_("Choose Click"));
 176
 177                 sfdb.show_all ();
 178                 sfdb.present ();
 179
 180                 if (sfdb.run () == RESPONSE_OK) {
 181                         click_chosen (sfdb.get_filename());
 182                 }
 183         }
 184
 185         void click_chosen (string const & path)
 186         {
 187                 _click_path_entry.set_text (path);
 188                 _rc_config->set_click_sound (path);
 189         }
 190
 191         void click_changed ()
 192         {
 193                 click_chosen (_click_path_entry.get_text ());
 194         }
 195
 196         void click_emphasis_browse_clicked ()
 197         {
 198                 SoundFileChooser sfdb (_("Choose Click Emphasis"));
 199
 200                 sfdb.show_all ();
 201                 sfdb.present ();
 202
 203                 if (sfdb.run () == RESPONSE_OK) {
 204                         click_emphasis_chosen (sfdb.get_filename());
 205                 }
 206         }
 207
 208         void click_emphasis_chosen (string const & path)
 209         {
 210                 _click_emphasis_path_entry.set_text (path);
 211                 _rc_config->set_click_emphasis_sound (path);
 212         }
 213
 214         void click_emphasis_changed ()
 215         {
 216                 click_emphasis_chosen (_click_emphasis_path_entry.get_text ());
 217         }
 218
 219         void use_default_click_toggled ()
 220         {
 221                 if (_use_default_click_check_button.get_active ()) {
 222                         _rc_config->set_click_sound ("");
 223                         _rc_config->set_click_emphasis_sound ("");
 224                         _click_path_entry.set_sensitive (false);
 225                         _click_emphasis_path_entry.set_sensitive (false);
 226                         _click_browse_button.set_sensitive (false);
 227                         _click_emphasis_browse_button.set_sensitive (false);
 228                 } else {
 229                         _click_path_entry.set_sensitive (true);
 230                         _click_emphasis_path_entry.set_sensitive (true);
 231                         _click_browse_button.set_sensitive (true);
 232                         _click_emphasis_browse_button.set_sensitive (true);
 233                 }
 234         }
 235
 236         void use_emphasis_on_click_toggled ()
 237         {
 238                 if (_use_emphasis_on_click_check_button.get_active ()) {
 239                         _rc_config->set_use_click_emphasis(true);
 240                 } else {
 241                         _rc_config->set_use_click_emphasis(false);
 242                 }
 243         }
 244
 245         RCConfiguration* _rc_config;
 246         CheckButton _use_default_click_check_button;
 247         CheckButton _use_emphasis_on_click_check_button;
 248         Entry _click_path_entry;
 249         Entry _click_emphasis_path_entry;
 250         Button _click_browse_button;
 251         Button _click_emphasis_browse_button;
 252         FaderOption* _click_fader;
 253 };
 254
 255 class UndoOptions : public OptionEditorComponent
 256 {
 257 public:
 258         UndoOptions (RCConfiguration* c) :
 259                 _rc_config (c),
 260                 _limit_undo_button (_("Limit undo history to")),
 261                 _save_undo_button (_("Save undo history of"))
 262         {
 263                 // TODO get rid of GTK -> use OptionEditor SpinOption
 264                 _limit_undo_spin.set_range (0, 512);
 265                 _limit_undo_spin.set_increments (1, 10);
 266
 267                 _save_undo_spin.set_range (0, 512);
 268                 _save_undo_spin.set_increments (1, 10);
 269
 270                 _limit_undo_button.signal_toggled().connect (sigc::mem_fun (*this, &UndoOptions::limit_undo_toggled));
 271                 _limit_undo_spin.signal_value_changed().connect (sigc::mem_fun (*this, &UndoOptions::limit_undo_changed));
 272                 _save_undo_button.signal_toggled().connect (sigc::mem_fun (*this, &UndoOptions::save_undo_toggled));
 273                 _save_undo_spin.signal_value_changed().connect (sigc::mem_fun (*this, &UndoOptions::save_undo_changed));
 274         }
 275
 276         void parameter_changed (string const & p)
 277         {
 278                 if (p == "history-depth") {
 279                         int32_t const d = _rc_config->get_history_depth();
 280                         _limit_undo_button.set_active (d != 0);
 281                         _limit_undo_spin.set_sensitive (d != 0);
 282                         _limit_undo_spin.set_value (d);
 283                 } else if (p == "save-history") {
 284                         bool const x = _rc_config->get_save_history ();
 285                         _save_undo_button.set_active (x);
 286                         _save_undo_spin.set_sensitive (x);
 287                 } else if (p == "save-history-depth") {
 288                         _save_undo_spin.set_value (_rc_config->get_saved_history_depth());
 289                 }
 290         }
 291
 292         void set_state_from_config ()
 293         {
 294                 parameter_changed ("save-history");
 295                 parameter_changed ("history-depth");
 296                 parameter_changed ("save-history-depth");
 297         }
 298
 299         void limit_undo_toggled ()
 300         {
 301                 bool const x = _limit_undo_button.get_active ();
 302                 _limit_undo_spin.set_sensitive (x);
 303                 int32_t const n = x ? 16 : 0;
 304                 _limit_undo_spin.set_value (n);
 305                 _rc_config->set_history_depth (n);
 306         }
 307
 308         void limit_undo_changed ()
 309         {
 310                 _rc_config->set_history_depth (_limit_undo_spin.get_value_as_int ());
 311         }
 312
 313         void save_undo_toggled ()
 314         {
 315                 bool const x = _save_undo_button.get_active ();
 316                 _rc_config->set_save_history (x);
 317         }
 318
 319         void save_undo_changed ()
 320         {
 321                 _rc_config->set_saved_history_depth (_save_undo_spin.get_value_as_int ());
 322         }
 323
 324         void add_to_page (OptionEditorPage* p)
 325         {
 326                 int const n = p->table.property_n_rows();
 327                 Table* t = & p->table;
 328
 329                 t->resize (n + 2, 3);
 330
 331                 Label* l = manage (left_aligned_label (_("commands")));
 332                 HBox* box = manage (new HBox());
 333                 box->set_spacing (4);
 334                 box->pack_start (_limit_undo_spin, false, false);
 335                 box->pack_start (*l, true, true);
 336                 t->attach (_limit_undo_button, 1, 2, n, n +1, FILL);
 337                 t->attach (*box, 2, 3, n, n + 1, FILL | EXPAND);
 338
 339                 l = manage (left_aligned_label (_("commands")));
 340                 box = manage (new HBox());
 341                 box->set_spacing (4);
 342                 box->pack_start (_save_undo_spin, false, false);
 343                 box->pack_start (*l, true, true);
 344                 t->attach (_save_undo_button, 1, 2, n + 1, n + 2, FILL);
 345                 t->attach (*box, 2, 3, n + 1, n + 2, FILL | EXPAND);
 346         }
 347
 348         Gtk::Widget& tip_widget() {
 349                 return _limit_undo_button; // unused
 350         }
 351
 352 private:
 353         RCConfiguration* _rc_config;
 354         CheckButton _limit_undo_button;
 355         SpinButton _limit_undo_spin;
 356         CheckButton _save_undo_button;
 357         SpinButton _save_undo_spin;
 358 };
 359
 360
 361 static const struct {
 362         const char *name;
 363         guint modifier;
 364 } modifiers[] = {
 365
 366         { "Unmodified", 0 },
 367
 368 #ifdef __APPLE__
 369
 370         /* Command = Meta
 371            Option/Alt = Mod1
 372         */
 373         { "Key|Shift", GDK_SHIFT_MASK },
 374         { "Command", GDK_MOD2_MASK },
 375         { "Control", GDK_CONTROL_MASK },
 376         { "Option", GDK_MOD1_MASK },
 377         { "Command-Shift", GDK_MOD2_MASK|GDK_SHIFT_MASK },
 378         { "Command-Option", GDK_MOD2_MASK|GDK_MOD1_MASK },
 379         { "Command-Control", GDK_MOD2_MASK|GDK_CONTROL_MASK },
 380         { "Command-Option-Control", GDK_MOD2_MASK|GDK_MOD1_MASK|GDK_CONTROL_MASK },
 381         { "Option-Control", GDK_MOD1_MASK|GDK_CONTROL_MASK },
 382         { "Option-Shift", GDK_MOD1_MASK|GDK_SHIFT_MASK },
 383         { "Control-Shift", GDK_CONTROL_MASK|GDK_SHIFT_MASK },
 384         { "Shift-Command-Option", GDK_MOD5_MASK|GDK_SHIFT_MASK|GDK_MOD2_MASK },
 385
 386 #else
 387         { "Key|Shift", GDK_SHIFT_MASK },
 388         { "Control", GDK_CONTROL_MASK },
 389         { "Alt", GDK_MOD1_MASK },
 390         { "Control-Shift", GDK_CONTROL_MASK|GDK_SHIFT_MASK },
 391         { "Control-Alt", GDK_CONTROL_MASK|GDK_MOD1_MASK },
 392         { "Control-Windows", GDK_CONTROL_MASK|GDK_MOD4_MASK },
 393         { "Control-Shift-Alt", GDK_CONTROL_MASK|GDK_SHIFT_MASK|GDK_MOD1_MASK },
 394         { "Alt-Windows", GDK_MOD1_MASK|GDK_MOD4_MASK },
 395         { "Alt-Shift", GDK_MOD1_MASK|GDK_SHIFT_MASK },
 396         { "Alt-Shift-Windows", GDK_MOD1_MASK|GDK_SHIFT_MASK|GDK_MOD4_MASK },
 397         { "Mod2", GDK_MOD2_MASK },
 398         { "Mod3", GDK_MOD3_MASK },
 399         { "Windows", GDK_MOD4_MASK },
 400         { "Mod5", GDK_MOD5_MASK },
 401 #endif
 402         { 0, 0 }
 403 };
 404
 405
 406 class KeyboardOptions : public OptionEditorMiniPage
 407 {
 408 public:
 409         KeyboardOptions ()
 410                 : _delete_button_adjustment (3, 1, 12)
 411                 , _delete_button_spin (_delete_button_adjustment)
 412                 , _edit_button_adjustment (3, 1, 5)
 413                 , _edit_button_spin (_edit_button_adjustment)
 414                 , _insert_note_button_adjustment (3, 1, 5)
 415                 , _insert_note_button_spin (_insert_note_button_adjustment)
 416         {
 417                 // TODO get rid of GTK -> use OptionEditor Widgets
 418
 419                 const std::string restart_msg = _("\nChanges to this setting will only persist after your project has been saved.");
 420                 /* internationalize and prepare for use with combos */
 421
 422                 vector<string> dumb;
 423                 for (int i = 0; modifiers[i].name; ++i) {
 424                         dumb.push_back (S_(modifiers[i].name));
 425                 }
 426
 427                 set_popdown_strings (_edit_modifier_combo, dumb);
 428                 _edit_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::edit_modifier_chosen));
 429                 Gtkmm2ext::UI::instance()->set_tip (_edit_modifier_combo,
 430                                 (string_compose (_("<b>Recommended Setting: %1 + button 3 (right mouse button)</b>%2"),  Keyboard::primary_modifier_name (), restart_msg)));
 431
 432                 Table* t = &table;
 433
 434                 int row = 0;
 435                 int col = 0;
 436
 437                 Label* l = manage (left_aligned_label (_("Select Keyboard layout:")));
 438                 l->set_name ("OptionsLabel");
 439
 440                 vector<string> strs;
 441
 442                 for (map<string,string>::iterator bf = Keyboard::binding_files.begin(); bf != Keyboard::binding_files.end(); ++bf) {
 443                         strs.push_back (bf->first);
 444                 }
 445
 446                 set_popdown_strings (_keyboard_layout_selector, strs);
 447                 _keyboard_layout_selector.set_active_text (Keyboard::current_binding_name());
 448                 _keyboard_layout_selector.signal_changed().connect (sigc::mem_fun (*this, &KeyboardOptions::bindings_changed));
 449
 450                 t->attach (*l, col + 1, col + 2, row, row + 1, FILL, FILL);
 451                 t->attach (_keyboard_layout_selector, col + 2, col + 3, row, row + 1, FILL | EXPAND, FILL);
 452
 453                 ++row;
 454                 col = 0;
 455
 456                 l = manage (left_aligned_label (string_compose ("<b>%1</b>", _("When Clicking:"))));
 457                 l->set_name ("OptionEditorHeading");
 458                 l->set_use_markup (true);
 459                 t->attach (*l, col, col + 2, row, row + 1, FILL | EXPAND, FILL);
 460
 461                 ++row;
 462                 col = 1;
 463
 464                 l = manage (left_aligned_label (_("Edit using:")));
 465                 l->set_name ("OptionsLabel");
 466
 467                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 468                 t->attach (_edit_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 469
 470                 l = manage (new Label (_("+ button")));
 471                 l->set_name ("OptionsLabel");
 472
 473                 t->attach (*l, col + 3, col + 4, row, row + 1, FILL, FILL);
 474                 t->attach (_edit_button_spin, col + 4, col + 5, row, row + 1, SHRINK , FILL);
 475
 476                 _edit_button_spin.set_name ("OptionsEntry");
 477                 _edit_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::edit_button_changed));
 478
 479                 ++row;
 480                 col = 1;
 481
 482                 set_popdown_strings (_delete_modifier_combo, dumb);
 483                 _delete_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::delete_modifier_chosen));
 484                 Gtkmm2ext::UI::instance()->set_tip (_delete_modifier_combo,
 485                                 (string_compose (_("<b>Recommended Setting: %1 + button 3 (right mouse button)</b>%2"), Keyboard::tertiary_modifier_name (), restart_msg)));
 486
 487                 l = manage (left_aligned_label (_("Delete using:")));
 488                 l->set_name ("OptionsLabel");
 489
 490                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 491                 t->attach (_delete_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 492
 493                 l = manage (new Label (_("+ button")));
 494                 l->set_name ("OptionsLabel");
 495
 496                 t->attach (*l, col + 3, col + 4, row, row + 1, FILL, FILL);
 497                 t->attach (_delete_button_spin, col + 4, col + 5, row, row + 1, SHRINK, FILL);
 498
 499                 _delete_button_spin.set_name ("OptionsEntry");
 500                 _delete_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::delete_button_changed));
 501
 502                 ++row;
 503                 col = 1;
 504
 505                 set_popdown_strings (_insert_note_modifier_combo, dumb);
 506                 _insert_note_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::insert_note_modifier_chosen));
 507                 Gtkmm2ext::UI::instance()->set_tip (_insert_note_modifier_combo,
 508                                 (string_compose (_("<b>Recommended Setting: %1 + button 1 (left mouse button)</b>%2"), Keyboard::primary_modifier_name (), restart_msg)));
 509
 510                 l = manage (left_aligned_label (_("Insert note using:")));
 511                 l->set_name ("OptionsLabel");
 512
 513                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 514                 t->attach (_insert_note_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 515
 516                 l = manage (new Label (_("+ button")));
 517                 l->set_name ("OptionsLabel");
 518
 519                 t->attach (*l, col + 3, col + 4, row, row + 1, FILL, FILL);
 520                 t->attach (_insert_note_button_spin, col + 4, col + 5, row, row + 1, SHRINK, FILL);
 521
 522                 _insert_note_button_spin.set_name ("OptionsEntry");
 523                 _insert_note_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::insert_note_button_changed));
 524
 525                 ++row;
 526
 527                 l = manage (left_aligned_label (string_compose ("<b>%1</b>", _("When Beginning a Drag:"))));
 528                 l->set_name ("OptionEditorHeading");
 529                 l->set_use_markup (true);
 530                 t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
 531
 532                 ++row;
 533                 col = 1;
 534
 535                 /* copy modifier */
 536                 set_popdown_strings (_copy_modifier_combo, dumb);
 537                 _copy_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::copy_modifier_chosen));
 538                 Gtkmm2ext::UI::instance()->set_tip (_copy_modifier_combo,
 539                                                     (string_compose (_("<b>Recommended Setting: %1</b>%2"),
 540 #ifdef __APPLE__
 541                                                                      Keyboard::secondary_modifier_name (),
 542 #else
 543                                                                      Keyboard::primary_modifier_name (),
 544 #endif
 545                                                                      restart_msg)));
 546
 547                 l = manage (left_aligned_label (_("Copy items using:")));
 548                 l->set_name ("OptionsLabel");
 549
 550                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 551                 t->attach (_copy_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 552
 553                                 ++row;
 554                 col = 1;
 555
 556                 /* constraint modifier */
 557                 set_popdown_strings (_constraint_modifier_combo, dumb);
 558                 _constraint_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::constraint_modifier_chosen));
 559                 Gtkmm2ext::UI::instance()->set_tip (_constraint_modifier_combo,
 560                                                     (string_compose (_("<b>Recommended Setting: %1</b>%2"),
 561 #ifdef __APPLE__
 562                                                                      Keyboard::primary_modifier_name (),
 563 #else
 564                                                                      Keyboard::tertiary_modifier_name (),
 565 #endif
 566                                                                      restart_msg)));
 567
 568                 l = manage (left_aligned_label (_("Constrain drag using:")));
 569                 l->set_name ("OptionsLabel");
 570
 571                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 572                 t->attach (_constraint_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 573
 574                 ++row;
 575                 col = 1;
 576
 577                 /* push points */
 578                 set_popdown_strings (_push_points_combo, dumb);
 579                 _push_points_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::push_points_modifier_chosen));
 580
 581                 std::string mod_str = string_compose (X_("%1-%2"), Keyboard::primary_modifier_name (), Keyboard::level4_modifier_name ());
 582                 Gtkmm2ext::UI::instance()->set_tip (_push_points_combo,
 583                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), mod_str, restart_msg)));
 584
 585                 l = manage (left_aligned_label (_("Push points using:")));
 586                 l->set_name ("OptionsLabel");
 587
 588                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 589                 t->attach (_push_points_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 590
 591                 ++row;
 592
 593                 l = manage (left_aligned_label (string_compose ("<b>%1</b>", _("When Beginning a Trim:"))));
 594                 l->set_name ("OptionEditorHeading");
 595                 l->set_use_markup (true);
 596                 t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
 597
 598                 ++row;
 599                 col = 1;
 600
 601                 /* trim_contents */
 602                 set_popdown_strings (_trim_contents_combo, dumb);
 603                 _trim_contents_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_contents_modifier_chosen));
 604                 Gtkmm2ext::UI::instance()->set_tip (_trim_contents_combo,
 605                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), Keyboard::primary_modifier_name (), restart_msg)));
 606
 607                 l = manage (left_aligned_label (_("Trim contents using:")));
 608                 l->set_name ("OptionsLabel");
 609
 610                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 611                 t->attach (_trim_contents_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 612
 613                 ++row;
 614                 col = 1;
 615
 616                 /* anchored trim */
 617                 set_popdown_strings (_trim_anchored_combo, dumb);
 618                 _trim_anchored_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_anchored_modifier_chosen));
 619
 620                 mod_str = string_compose (X_("%1-%2"), Keyboard::primary_modifier_name (), Keyboard::tertiary_modifier_name ());
 621                 Gtkmm2ext::UI::instance()->set_tip (_trim_anchored_combo,
 622                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), mod_str, restart_msg)));
 623
 624                 l = manage (left_aligned_label (_("Anchored trim using:")));
 625                 l->set_name ("OptionsLabel");
 626
 627                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 628                 ++col;
 629                 t->attach (_trim_anchored_combo, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
 630
 631                 ++row;
 632                 col = 1;
 633
 634                 /* jump trim disabled for now
 635                 set_popdown_strings (_trim_jump_combo, dumb);
 636                 _trim_jump_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_jump_modifier_chosen));
 637
 638                 l = manage (left_aligned_label (_("Jump after trim using:")));
 639                 l->set_name ("OptionsLabel");
 640
 641                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 642                 ++col;
 643                 t->attach (_trim_jump_combo, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
 644
 645                 ++row;
 646                 col = 1;
 647                 */
 648
 649                 /* note resize relative */
 650                 set_popdown_strings (_note_size_relative_combo, dumb);
 651                 _note_size_relative_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::note_size_relative_modifier_chosen));
 652                 Gtkmm2ext::UI::instance()->set_tip (_note_size_relative_combo,
 653                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), Keyboard::tertiary_modifier_name (), restart_msg))); // XXX 2ndary
 654
 655                 l = manage (left_aligned_label (_("Resize notes relatively using:")));
 656                 l->set_name ("OptionsLabel");
 657
 658                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 659                 ++col;
 660                 t->attach (_note_size_relative_combo, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
 661
 662                 ++row;
 663
 664                 l = manage (left_aligned_label (string_compose ("<b>%1</b>", _("While Dragging:"))));
 665                 l->set_name ("OptionEditorHeading");
 666                 l->set_use_markup (true);
 667                 t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
 668
 669                 ++row;
 670                 col = 1;
 671
 672                 /* ignore snap */
 673                 set_popdown_strings (_snap_modifier_combo, dumb);
 674                 _snap_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::snap_modifier_chosen));
 675 #ifdef __APPLE__
 676                 mod_str = string_compose (X_("%1-%2"), Keyboard::level4_modifier_name (), Keyboard::tertiary_modifier_name ());
 677 #else
 678                 mod_str = Keyboard::secondary_modifier_name();
 679 #endif
 680                 Gtkmm2ext::UI::instance()->set_tip (_snap_modifier_combo,
 681                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), mod_str, restart_msg)));
 682
 683                 l = manage (left_aligned_label (_("Ignore snap using:")));
 684                 l->set_name ("OptionsLabel");
 685
 686                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 687                 t->attach (_snap_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 688
 689                 ++row;
 690                 col = 1;
 691
 692                 /* snap delta */
 693                 set_popdown_strings (_snap_delta_combo, dumb);
 694                 _snap_delta_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::snap_delta_modifier_chosen));
 695 #ifdef __APPLE__
 696                 mod_str = Keyboard::level4_modifier_name ();
 697 #else
 698                 mod_str = string_compose (X_("%1-%2"), Keyboard::secondary_modifier_name (), Keyboard::level4_modifier_name ());
 699 #endif
 700                 Gtkmm2ext::UI::instance()->set_tip (_snap_delta_combo,
 701                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), mod_str, restart_msg)));
 702
 703                 l = manage (left_aligned_label (_("Snap relatively using:")));
 704                 l->set_name ("OptionsLabel");
 705
 706                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 707                 t->attach (_snap_delta_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 708
 709                 ++row;
 710
 711                 l = manage (left_aligned_label (string_compose ("<b>%1</b>", _("While Trimming:"))));
 712                 l->set_name ("OptionEditorHeading");
 713                 l->set_use_markup (true);
 714                 t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
 715
 716                 ++row;
 717                 col = 1;
 718
 719                 /* trim_overlap */
 720                 set_popdown_strings (_trim_overlap_combo, dumb);
 721                 _trim_overlap_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_overlap_modifier_chosen));
 722
 723                 Gtkmm2ext::UI::instance()->set_tip (_trim_overlap_combo,
 724                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), Keyboard::tertiary_modifier_name (), restart_msg)));
 725
 726                 l = manage (left_aligned_label (_("Resize overlapped regions using:")));
 727                 l->set_name ("OptionsLabel");
 728
 729                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 730                 t->attach (_trim_overlap_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 731
 732                 ++row;
 733
 734                 l = manage (left_aligned_label (string_compose ("<b>%1</b>", _("While Dragging Control Points:"))));
 735                 l->set_name ("OptionEditorHeading");
 736                 l->set_use_markup (true);
 737                 t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
 738
 739                 ++row;
 740                 col = 1;
 741
 742                 /* fine adjust */
 743                 set_popdown_strings (_fine_adjust_combo, dumb);
 744                 _fine_adjust_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::fine_adjust_modifier_chosen));
 745
 746                 mod_str = string_compose (X_("%1-%2"), Keyboard::primary_modifier_name (), Keyboard::secondary_modifier_name ()); // XXX just 2ndary ?!
 747                 Gtkmm2ext::UI::instance()->set_tip (_fine_adjust_combo,
 748                                 (string_compose (_("<b>Recommended Setting: %1</b>%2"), mod_str, restart_msg)));
 749
 750                 l = manage (left_aligned_label (_("Fine adjust using:")));
 751                 l->set_name ("OptionsLabel");
 752
 753                 t->attach (*l, col, col + 1, row, row + 1, FILL, FILL);
 754                 t->attach (_fine_adjust_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 755
 756                 OptionEditorHeading* h = new OptionEditorHeading (_("Reset"));
 757                 h->add_to_page (this);
 758
 759                 RcActionButton* rb = new RcActionButton (_("Reset to recommended defaults"),
 760                                 sigc::mem_fun (*this, &KeyboardOptions::reset_to_defaults));
 761                 rb->add_to_page (this);
 762
 763                 set_state_from_config ();
 764         }
 765
 766         void parameter_changed (string const &)
 767         {
 768                 /* XXX: these aren't really config options... */
 769         }
 770
 771         void set_state_from_config ()
 772         {
 773                 _delete_button_adjustment.set_value (Keyboard::delete_button());
 774                 _insert_note_button_adjustment.set_value (Keyboard::insert_note_button());
 775                 _edit_button_adjustment.set_value (Keyboard::edit_button());
 776
 777                 for (int x = 0; modifiers[x].name; ++x) {
 778                         if (modifiers[x].modifier == (guint) ArdourKeyboard::trim_overlap_modifier ()) {
 779                                 _trim_overlap_combo.set_active_text (S_(modifiers[x].name));
 780                         }
 781                         if (modifiers[x].modifier == Keyboard::delete_modifier ()) {
 782                                 _delete_modifier_combo.set_active_text (S_(modifiers[x].name));
 783                         }
 784                         if (modifiers[x].modifier == Keyboard::edit_modifier ()) {
 785                                 _edit_modifier_combo.set_active_text (S_(modifiers[x].name));
 786                         }
 787                         if (modifiers[x].modifier == Keyboard::insert_note_modifier ()) {
 788                                 _insert_note_modifier_combo.set_active_text (S_(modifiers[x].name));
 789                         }
 790                         if (modifiers[x].modifier == (guint) Keyboard::CopyModifier) {
 791                                 _copy_modifier_combo.set_active_text (S_(modifiers[x].name));
 792                         }
 793                         if (modifiers[x].modifier == (guint) ArdourKeyboard::constraint_modifier ()) {
 794                                 _constraint_modifier_combo.set_active_text (S_(modifiers[x].name));
 795                         }
 796                         if (modifiers[x].modifier == (guint) ArdourKeyboard::push_points_modifier ()) {
 797                                 _push_points_combo.set_active_text (S_(modifiers[x].name));
 798                         }
 799                         if (modifiers[x].modifier == (guint) ArdourKeyboard::trim_contents_modifier ()) {
 800                                 _trim_contents_combo.set_active_text (S_(modifiers[x].name));
 801                         }
 802                         if (modifiers[x].modifier == (guint) ArdourKeyboard::trim_anchored_modifier ()) {
 803                                 _trim_anchored_combo.set_active_text (S_(modifiers[x].name));
 804                         }
 805 #if 0
 806                         if (modifiers[x].modifier == (guint) Keyboard::trim_jump_modifier ()) {
 807                                 _trim_jump_combo.set_active_text (S_(modifiers[x].name));
 808                         }
 809 #endif
 810                         if (modifiers[x].modifier == (guint) ArdourKeyboard::note_size_relative_modifier ()) {
 811                                 _note_size_relative_combo.set_active_text (S_(modifiers[x].name));
 812                         }
 813                         if (modifiers[x].modifier == (guint) Keyboard::snap_modifier ()) {
 814                                 _snap_modifier_combo.set_active_text (S_(modifiers[x].name));
 815                         }
 816                         if (modifiers[x].modifier == (guint) Keyboard::snap_delta_modifier ()) {
 817                                 _snap_delta_combo.set_active_text (S_(modifiers[x].name));
 818                         }
 819                         if (modifiers[x].modifier == (guint) ArdourKeyboard::fine_adjust_modifier ()) {
 820                                 _fine_adjust_combo.set_active_text (S_(modifiers[x].name));
 821                         }
 822                 }
 823         }
 824
 825         void add_to_page (OptionEditorPage* p)
 826         {
 827                 int const n = p->table.property_n_rows();
 828                 p->table.resize (n + 1, 3);
 829                 p->table.attach (box, 1, 3, n, n + 1, FILL | EXPAND, SHRINK, 0, 0);
 830         }
 831
 832 private:
 833
 834         void bindings_changed ()
 835         {
 836                 string const txt = _keyboard_layout_selector.get_active_text();
 837
 838                 /* XXX: config...?  for all this keyboard stuff */
 839
 840                 for (map<string,string>::iterator i = Keyboard::binding_files.begin(); i != Keyboard::binding_files.end(); ++i) {
 841                         if (txt == i->first) {
 842                                 if (Keyboard::load_keybindings (i->second)) {
 843                                         Keyboard::save_keybindings ();
 844                                 }
 845                         }
 846                 }
 847         }
 848
 849         void edit_modifier_chosen ()
 850         {
 851                 string const txt = _edit_modifier_combo.get_active_text();
 852
 853                 for (int i = 0; modifiers[i].name; ++i) {
 854                         if (txt == S_(modifiers[i].name)) {
 855                                 Keyboard::set_edit_modifier (modifiers[i].modifier);
 856                                 break;
 857                         }
 858                 }
 859         }
 860
 861         void delete_modifier_chosen ()
 862         {
 863                 string const txt = _delete_modifier_combo.get_active_text();
 864
 865                 for (int i = 0; modifiers[i].name; ++i) {
 866                         if (txt == S_(modifiers[i].name)) {
 867                                 Keyboard::set_delete_modifier (modifiers[i].modifier);
 868                                 break;
 869                         }
 870                 }
 871         }
 872
 873         void copy_modifier_chosen ()
 874         {
 875                 string const txt = _copy_modifier_combo.get_active_text();
 876
 877                 for (int i = 0; modifiers[i].name; ++i) {
 878                         if (txt == S_(modifiers[i].name)) {
 879                                 Keyboard::set_copy_modifier (modifiers[i].modifier);
 880                                 break;
 881                         }
 882                 }
 883         }
 884
 885         void insert_note_modifier_chosen ()
 886         {
 887                 string const txt = _insert_note_modifier_combo.get_active_text();
 888
 889                 for (int i = 0; modifiers[i].name; ++i) {
 890                         if (txt == S_(modifiers[i].name)) {
 891                                 Keyboard::set_insert_note_modifier (modifiers[i].modifier);
 892                                 break;
 893                         }
 894                 }
 895         }
 896
 897         void snap_modifier_chosen ()
 898         {
 899                 string const txt = _snap_modifier_combo.get_active_text();
 900
 901                 for (int i = 0; modifiers[i].name; ++i) {
 902                         if (txt == S_(modifiers[i].name)) {
 903                                 Keyboard::set_snap_modifier (modifiers[i].modifier);
 904                                 break;
 905                         }
 906                 }
 907         }
 908
 909         void snap_delta_modifier_chosen ()
 910         {
 911                 string const txt = _snap_delta_combo.get_active_text();
 912
 913                 for (int i = 0; modifiers[i].name; ++i) {
 914                         if (txt == S_(modifiers[i].name)) {
 915                                 Keyboard::set_snap_delta_modifier (modifiers[i].modifier);
 916                                 break;
 917                         }
 918                 }
 919         }
 920
 921         void constraint_modifier_chosen ()
 922         {
 923                 string const txt = _constraint_modifier_combo.get_active_text();
 924
 925                 for (int i = 0; modifiers[i].name; ++i) {
 926                         if (txt == S_(modifiers[i].name)) {
 927                                 ArdourKeyboard::set_constraint_modifier (modifiers[i].modifier);
 928                                 break;
 929                         }
 930                 }
 931         }
 932
 933         void trim_contents_modifier_chosen ()
 934         {
 935                 string const txt = _trim_contents_combo.get_active_text();
 936
 937                 for (int i = 0; modifiers[i].name; ++i) {
 938                         if (txt == S_(modifiers[i].name)) {
 939                                 ArdourKeyboard::set_trim_contents_modifier (modifiers[i].modifier);
 940                                 break;
 941                         }
 942                 }
 943         }
 944
 945         void trim_overlap_modifier_chosen ()
 946         {
 947                 string const txt = _trim_overlap_combo.get_active_text();
 948
 949                 for (int i = 0; modifiers[i].name; ++i) {
 950                         if (txt == S_(modifiers[i].name)) {
 951                                 ArdourKeyboard::set_trim_overlap_modifier (modifiers[i].modifier);
 952                                 break;
 953                         }
 954                 }
 955         }
 956
 957         void trim_anchored_modifier_chosen ()
 958         {
 959                 string const txt = _trim_anchored_combo.get_active_text();
 960
 961                 for (int i = 0; modifiers[i].name; ++i) {
 962                         if (txt == S_(modifiers[i].name)) {
 963                                 ArdourKeyboard::set_trim_anchored_modifier (modifiers[i].modifier);
 964                                 break;
 965                         }
 966                 }
 967         }
 968
 969         void fine_adjust_modifier_chosen ()
 970         {
 971                 string const txt = _fine_adjust_combo.get_active_text();
 972
 973                 for (int i = 0; modifiers[i].name; ++i) {
 974                         if (txt == S_(modifiers[i].name)) {
 975                                 ArdourKeyboard::set_fine_adjust_modifier (modifiers[i].modifier);
 976                                 break;
 977                         }
 978                 }
 979         }
 980
 981         void push_points_modifier_chosen ()
 982         {
 983                 string const txt = _push_points_combo.get_active_text();
 984
 985                 for (int i = 0; modifiers[i].name; ++i) {
 986                         if (txt == S_(modifiers[i].name)) {
 987                                 ArdourKeyboard::set_push_points_modifier (modifiers[i].modifier);
 988                                 break;
 989                         }
 990                 }
 991         }
 992
 993         void note_size_relative_modifier_chosen ()
 994         {
 995                 string const txt = _note_size_relative_combo.get_active_text();
 996
 997                 for (int i = 0; modifiers[i].name; ++i) {
 998                         if (txt == S_(modifiers[i].name)) {
 999                                 ArdourKeyboard::set_note_size_relative_modifier (modifiers[i].modifier);
1000                                 break;
1001                         }
1002                 }
1003         }
1004
1005         void delete_button_changed ()
1006         {
1007                 Keyboard::set_delete_button (_delete_button_spin.get_value_as_int());
1008         }
1009
1010         void edit_button_changed ()
1011         {
1012                 Keyboard::set_edit_button (_edit_button_spin.get_value_as_int());
1013         }
1014
1015         void insert_note_button_changed ()
1016         {
1017                 Keyboard::set_insert_note_button (_insert_note_button_spin.get_value_as_int());
1018         }
1019
1020         void reset_to_defaults ()
1021         {
1022                 /* when clicking*/
1023                 Keyboard::set_edit_modifier (Keyboard::PrimaryModifier);
1024                 Keyboard::set_edit_button (3);
1025                 Keyboard::set_delete_modifier (Keyboard::TertiaryModifier);
1026                 Keyboard::set_delete_button (3);
1027                 Keyboard::set_insert_note_modifier (Keyboard::PrimaryModifier);
1028                 Keyboard::set_insert_note_button (1);
1029
1030                 /* when beginning a drag */
1031 #ifdef __APPLE__
1032                 Keyboard::set_copy_modifier (Keyboard::SecondaryModifier);
1033 #else
1034                 Keyboard::set_copy_modifier (Keyboard::PrimaryModifier);
1035 #endif
1036
1037 #ifdef __APPLE__
1038                 ArdourKeyboard::set_constraint_modifier (Keyboard::PrimaryModifier);
1039 #else
1040                 ArdourKeyboard::set_constraint_modifier (Keyboard::TertiaryModifier);
1041 #endif
1042                 ArdourKeyboard::set_push_points_modifier (Keyboard::PrimaryModifier | Keyboard::Level4Modifier);
1043
1044                 /* when beginning a trim */
1045                 ArdourKeyboard::set_trim_contents_modifier (Keyboard::PrimaryModifier);
1046                 ArdourKeyboard::set_trim_anchored_modifier (Keyboard::PrimaryModifier | Keyboard::TertiaryModifier);
1047                 ArdourKeyboard::set_note_size_relative_modifier (Keyboard::TertiaryModifier); // XXX better: 2ndary
1048
1049                 /* while dragging */
1050 #ifdef __APPLE__
1051                 Keyboard::set_snap_modifier (Keyboard::TertiaryModifier);
1052 #else
1053                 Keyboard::set_snap_modifier (Keyboard::SecondaryModifier);
1054 #endif
1055 #ifdef __APPLE__
1056                 Keyboard::set_snap_delta_modifier (Keyboard::Level4Modifier);
1057 #else
1058                 Keyboard::set_snap_delta_modifier (Keyboard::SecondaryModifier | Keyboard::Level4Modifier);
1059 #endif
1060
1061                 /* while trimming */
1062                 ArdourKeyboard::set_trim_overlap_modifier (Keyboard::TertiaryModifier);
1063
1064                 /* while dragging ctrl points */
1065                 ArdourKeyboard::set_fine_adjust_modifier (/*Keyboard::PrimaryModifier | */Keyboard::SecondaryModifier); // XXX
1066
1067                 set_state_from_config ();
1068         }
1069
1070         ComboBoxText _keyboard_layout_selector;
1071         ComboBoxText _edit_modifier_combo;
1072         ComboBoxText _delete_modifier_combo;
1073         ComboBoxText _copy_modifier_combo;
1074         ComboBoxText _insert_note_modifier_combo;
1075         ComboBoxText _snap_modifier_combo;
1076         ComboBoxText _snap_delta_combo;
1077         ComboBoxText _constraint_modifier_combo;
1078         ComboBoxText _trim_contents_combo;
1079         ComboBoxText _trim_overlap_combo;
1080         ComboBoxText _trim_anchored_combo;
1081         ComboBoxText _trim_jump_combo;
1082         ComboBoxText _fine_adjust_combo;
1083         ComboBoxText _push_points_combo;
1084         ComboBoxText _note_size_relative_combo;
1085         Adjustment _delete_button_adjustment;
1086         SpinButton _delete_button_spin;
1087         Adjustment _edit_button_adjustment;
1088         SpinButton _edit_button_spin;
1089         Adjustment _insert_note_button_adjustment;
1090         SpinButton _insert_note_button_spin;
1091
1092 };
1093
1094 class FontScalingOptions : public HSliderOption
1095 {
1096         public:
1097                 FontScalingOptions ()
1098                         : HSliderOption ("font-scale", _("GUI and Font scaling"),
1099                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_font_scale),
1100                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_font_scale),
1101                                         50, 250, 1, 5,
1102                                         1024, false)
1103         {
1104                 const std::string dflt = _("100%");
1105                 const std::string empty = X_(""); // despite gtk-doc saying so, NULL does not work as reference
1106
1107                 _hscale.set_name("FontScaleSlider");
1108                 _hscale.set_draw_value(false);
1109                 _hscale.add_mark(50,  Gtk::POS_TOP, empty);
1110                 _hscale.add_mark(60,  Gtk::POS_TOP, empty);
1111                 _hscale.add_mark(70,  Gtk::POS_TOP, empty);
1112                 _hscale.add_mark(80,  Gtk::POS_TOP, empty);
1113                 _hscale.add_mark(90,  Gtk::POS_TOP, empty);
1114                 _hscale.add_mark(100, Gtk::POS_TOP, dflt);
1115                 _hscale.add_mark(125, Gtk::POS_TOP, empty);
1116                 _hscale.add_mark(150, Gtk::POS_TOP, empty);
1117                 _hscale.add_mark(175, Gtk::POS_TOP, empty);
1118                 _hscale.add_mark(200, Gtk::POS_TOP, empty);
1119                 _hscale.add_mark(250, Gtk::POS_TOP, empty);
1120
1121                 set_note (_("Adjusting the scale requires an application restart to re-layout."));
1122         }
1123
1124         void changed ()
1125         {
1126                 HSliderOption::changed ();
1127                 /* XXX: should be triggered from the parameter changed signal */
1128                 UIConfiguration::instance().reset_dpi ();
1129         }
1130 };
1131
1132 class VstTimeOutSliderOption : public HSliderOption
1133 {
1134 public:
1135         VstTimeOutSliderOption (RCConfiguration* c)
1136                 : HSliderOption ("vst-scan-timeout", _("Scan Time Out"),
1137                                 sigc::mem_fun (*c, &RCConfiguration::get_vst_scan_timeout),
1138                                 sigc::mem_fun (*c, &RCConfiguration::set_vst_scan_timeout),
1139                                 0, 3000, 50, 50)
1140         {
1141                 _label.set_alignment (1.0, 0.5); // match buttons below
1142                 _hscale.set_digits (0);
1143                 _hscale.set_draw_value(false);
1144                 _hscale.add_mark(   0,  Gtk::POS_TOP, _("\u221e")); // infinity
1145                 _hscale.add_mark( 300,  Gtk::POS_TOP, _("30 sec"));
1146                 _hscale.add_mark( 600,  Gtk::POS_TOP, _("1 min"));
1147                 _hscale.add_mark(1200,  Gtk::POS_TOP, _("2 mins"));
1148                 _hscale.add_mark(1800,  Gtk::POS_TOP, _("3 mins"));
1149                 _hscale.add_mark(2400,  Gtk::POS_TOP, _("4 mins"));
1150                 _hscale.add_mark(3000,  Gtk::POS_TOP, _("5 mins"));
1151
1152                 Gtkmm2ext::UI::instance()->set_tip(_hscale,
1153                          _("Specify the default timeout for plugin instantiation. Plugins that require more time to load will be blacklisted. A value of 0 disables the timeout."));
1154         }
1155 };
1156
1157 class ClipLevelOptions : public OptionEditorComponent
1158 {
1159 public:
1160         ClipLevelOptions ()
1161                 : _clip_level_adjustment (-.5, -50.0, 0.0, 0.1, 1.0) /* units of dB */
1162                 , _clip_level_slider (_clip_level_adjustment)
1163                 , _label (_("Waveform Clip Level (dBFS):"))
1164         {
1165                 _label.set_name ("OptionsLabel");
1166
1167                 _clip_level_adjustment.set_value (UIConfiguration::instance().get_waveform_clip_level ());
1168
1169                 _clip_level_slider.set_update_policy (UPDATE_DISCONTINUOUS);
1170
1171                 _clip_level_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &ClipLevelOptions::clip_level_changed));
1172         }
1173
1174         void parameter_changed (string const & p)
1175         {
1176                 if (p == "waveform-clip-level") {
1177                         _clip_level_adjustment.set_value (UIConfiguration::instance().get_waveform_clip_level());
1178                 }
1179                 if (p == "show-waveform-clipping") {
1180                         _clip_level_slider.set_sensitive (UIConfiguration::instance().get_show_waveform_clipping ());
1181                 }
1182         }
1183
1184         void set_state_from_config ()
1185         {
1186                 parameter_changed ("waveform-clip-level");
1187                 parameter_changed ("show-waveform-clipping");
1188         }
1189
1190         void add_to_page (OptionEditorPage* p) {
1191                 add_widgets_to_page (p, &_label, &_clip_level_slider);
1192         }
1193
1194         Gtk::Widget& tip_widget() {
1195                 return _clip_level_slider;
1196         }
1197
1198 private:
1199
1200         void clip_level_changed ()
1201         {
1202                 UIConfiguration::instance().set_waveform_clip_level (_clip_level_adjustment.get_value());
1203                 /* XXX: should be triggered from the parameter changed signal */
1204                 ArdourWaveView::WaveView::set_clip_level (_clip_level_adjustment.get_value());
1205         }
1206
1207         Adjustment _clip_level_adjustment;
1208         HScale _clip_level_slider;
1209         Label _label;
1210 };
1211
1212 class BufferingOptions : public OptionEditorComponent
1213 {
1214         public:
1215                 BufferingOptions (RCConfiguration* c)
1216                         : _rc_config (c)
1217                         , _label (_("Preset:"))
1218                         , _playback ("playback-buffer-seconds", _("Playback (seconds of buffering)"),
1219                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_audio_playback_buffer_seconds),
1220                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_audio_playback_buffer_seconds),
1221                                         1, 60, 1, 4)
1222                         , _capture ("capture-buffer-seconds", _("Recording (seconds of buffering)"),
1223                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_audio_capture_buffer_seconds),
1224                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_audio_capture_buffer_seconds),
1225                                         1, 60, 1, 4)
1226                 {
1227                         // TODO use  ComboOption
1228                         vector<string> presets;
1229
1230                         /* these must match the order of the enums for BufferingPreset */
1231                         presets.push_back (_("Small sessions (4-16 tracks)"));
1232                         presets.push_back (_("Medium sessions (16-64 tracks)"));
1233                         presets.push_back (_("Large sessions (64+ tracks)"));
1234                         presets.push_back (_("Custom (set by sliders below)"));
1235
1236                         set_popdown_strings (_buffering_presets_combo, presets);
1237                         _buffering_presets_combo.signal_changed().connect (sigc::mem_fun (*this, &BufferingOptions::preset_changed));
1238
1239                         _label.set_name ("OptionsLabel");
1240                         _label.set_alignment (0, 0.5);
1241                 }
1242
1243                 void
1244                 add_to_page (OptionEditorPage* p)
1245                 {
1246                         add_widgets_to_page (p, &_label, &_buffering_presets_combo);
1247                         _playback.add_to_page (p);
1248                         _capture.add_to_page (p);
1249                 }
1250
1251                 void parameter_changed (string const & p)
1252                 {
1253                         if (p == "buffering-preset") {
1254                                 switch (_rc_config->get_buffering_preset()) {
1255                                         case Small:
1256                                                 _playback.set_sensitive (false);
1257                                                 _capture.set_sensitive (false);
1258                                                 _buffering_presets_combo.set_active (0);
1259                                                 break;
1260                                         case Medium:
1261                                                 _playback.set_sensitive (false);
1262                                                 _capture.set_sensitive (false);
1263                                                 _buffering_presets_combo.set_active (1);
1264                                                 break;
1265                                         case Large:
1266                                                 _playback.set_sensitive (false);
1267                                                 _capture.set_sensitive (false);
1268                                                 _buffering_presets_combo.set_active (2);
1269                                                 break;
1270                                         case Custom:
1271                                                 _playback.set_sensitive (true);
1272                                                 _capture.set_sensitive (true);
1273                                                 _buffering_presets_combo.set_active (3);
1274                                                 break;
1275                                 }
1276                         }
1277                         _playback.parameter_changed (p);
1278                         _capture.parameter_changed (p);
1279                 }
1280
1281                 void set_state_from_config ()
1282                 {
1283                         parameter_changed ("buffering-preset");
1284                         _playback.set_state_from_config();
1285                         _capture.set_state_from_config();
1286                 }
1287
1288                 Gtk::Widget& tip_widget() { return _buffering_presets_combo; }
1289
1290         private:
1291
1292                 void preset_changed ()
1293                 {
1294                         int index = _buffering_presets_combo.get_active_row_number ();
1295                         if (index < 0) {
1296                                 return;
1297                         }
1298                         switch (index) {
1299                                 case 0:
1300                                         _rc_config->set_buffering_preset (Small);
1301                                         break;
1302                                 case 1:
1303                                         _rc_config->set_buffering_preset (Medium);
1304                                         break;
1305                                 case 2:
1306                                         _rc_config->set_buffering_preset (Large);
1307                                         break;
1308                                 case 3:
1309                                         _rc_config->set_buffering_preset (Custom);
1310                                         break;
1311                                 default:
1312                                         error << string_compose (_("programming error: unknown buffering preset string, index = %1"), index) << endmsg;
1313                                         break;
1314                         }
1315                 }
1316
1317                 RCConfiguration* _rc_config;
1318                 Label         _label;
1319                 HSliderOption _playback;
1320                 HSliderOption _capture;
1321                 ComboBoxText  _buffering_presets_combo;
1322 };
1323
1324 class ControlSurfacesOptions : public OptionEditorMiniPage
1325 {
1326         public:
1327                 ControlSurfacesOptions ()
1328                         : _ignore_view_change (0)
1329                 {
1330                         _store = ListStore::create (_model);
1331                         _view.set_model (_store);
1332                         _view.append_column (_("Control Surface Protocol"), _model.name);
1333                         _view.get_column(0)->set_resizable (true);
1334                         _view.get_column(0)->set_expand (true);
1335                         _view.append_column_editable (_("Enable"), _model.enabled);
1336
1337                         Gtk::HBox* edit_box = manage (new Gtk::HBox);
1338                         edit_box->set_spacing(3);
1339                         edit_box->show ();
1340
1341                         Label* label = manage (new Label);
1342                         label->set_text (_("Edit the settings for selected protocol (it must be ENABLED first):"));
1343                         edit_box->pack_start (*label, false, false);
1344                         label->show ();
1345
1346                         edit_button = manage (new Button(_("Show Protocol Settings")));
1347                         edit_button->signal_clicked().connect (sigc::mem_fun(*this, &ControlSurfacesOptions::edit_btn_clicked));
1348                         edit_box->pack_start (*edit_button, true, true);
1349                         edit_button->set_sensitive (false);
1350                         edit_button->show ();
1351
1352                         int const n = table.property_n_rows();
1353                         table.resize (n + 2, 3);
1354                         table.attach (_view, 0, 3, n, n + 1);
1355                         table.attach (*edit_box, 0, 3, n + 1, n + 2);
1356
1357                         ControlProtocolManager& m = ControlProtocolManager::instance ();
1358                         m.ProtocolStatusChange.connect (protocol_status_connection, MISSING_INVALIDATOR,
1359                                         boost::bind (&ControlSurfacesOptions::protocol_status_changed, this, _1), gui_context());
1360
1361                         _store->signal_row_changed().connect (sigc::mem_fun (*this, &ControlSurfacesOptions::view_changed));
1362                         _view.signal_button_press_event().connect_notify (sigc::mem_fun(*this, &ControlSurfacesOptions::edit_clicked));
1363                         _view.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ControlSurfacesOptions::selection_changed));
1364                 }
1365
1366                 void parameter_changed (std::string const &)
1367                 {
1368
1369                 }
1370
1371                 void set_state_from_config ()
1372                 {
1373                         _store->clear ();
1374
1375                         ControlProtocolManager& m = ControlProtocolManager::instance ();
1376                         for (list<ControlProtocolInfo*>::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) {
1377
1378                                 if (!(*i)->mandatory) {
1379                                         TreeModel::Row r = *_store->append ();
1380                                         r[_model.name] = (*i)->name;
1381                                         r[_model.enabled] = 0 != (*i)->protocol;
1382                                         r[_model.protocol_info] = *i;
1383                                 }
1384                         }
1385                 }
1386
1387         private:
1388
1389                 void protocol_status_changed (ControlProtocolInfo* cpi) {
1390                         /* find the row */
1391                         TreeModel::Children rows = _store->children();
1392
1393                         for (TreeModel::Children::iterator x = rows.begin(); x != rows.end(); ++x) {
1394                                 string n = ((*x)[_model.name]);
1395
1396                                 if ((*x)[_model.protocol_info] == cpi) {
1397                                         _ignore_view_change++;
1398                                         (*x)[_model.enabled] = 0 != cpi->protocol;
1399                                         _ignore_view_change--;
1400                                         selection_changed (); // update sensitivity
1401                                         break;
1402                                 }
1403                         }
1404                 }
1405
1406                 void selection_changed ()
1407                 {
1408                         //enable the Edit button when a row is selected for editing
1409                         TreeModel::Row row = *(_view.get_selection()->get_selected());
1410                         if (row && row[_model.enabled]) {
1411                                 ControlProtocolInfo* cpi = row[_model.protocol_info];
1412                                 edit_button->set_sensitive (cpi && cpi->protocol && cpi->protocol->has_editor ());
1413                         } else {
1414                                 edit_button->set_sensitive (false);
1415                         }
1416                 }
1417
1418                 void view_changed (TreeModel::Path const &, TreeModel::iterator const & i)
1419                 {
1420                         TreeModel::Row r = *i;
1421
1422                         if (_ignore_view_change) {
1423                                 return;
1424                         }
1425
1426                         ControlProtocolInfo* cpi = r[_model.protocol_info];
1427                         if (!cpi) {
1428                                 return;
1429                         }
1430
1431                         bool const was_enabled = (cpi->protocol != 0);
1432                         bool const is_enabled = r[_model.enabled];
1433
1434
1435                         if (was_enabled != is_enabled) {
1436
1437                                 if (!was_enabled) {
1438                                         ControlProtocolManager::instance().activate (*cpi);
1439                                 } else {
1440                                         ControlProtocolManager::instance().deactivate (*cpi);
1441                                 }
1442                         }
1443
1444                         selection_changed ();
1445                 }
1446
1447                 void edit_btn_clicked ()
1448                 {
1449                         std::string name;
1450                         ControlProtocolInfo* cpi;
1451                         TreeModel::Row row;
1452
1453                         row = *(_view.get_selection()->get_selected());
1454                         if (!row[_model.enabled]) {
1455                                 return;
1456                         }
1457                         cpi = row[_model.protocol_info];
1458                         if (!cpi || !cpi->protocol || !cpi->protocol->has_editor ()) {
1459                                 return;
1460                         }
1461                         Box* box = (Box*) cpi->protocol->get_gui ();
1462                         if (!box) {
1463                                 return;
1464                         }
1465                         if (box->get_parent()) {
1466                                 static_cast<ArdourWindow*>(box->get_parent())->present();
1467                                 return;
1468                         }
1469                         WindowTitle title (Glib::get_application_name());
1470                         title += row[_model.name];
1471                         title += _("Configuration");
1472                         /* once created, the window is managed by the surface itself (as ->get_parent())
1473                          * Surface's tear_down_gui() is called on session close, when de-activating
1474                          * or re-initializing a surface.
1475                          * tear_down_gui() hides an deletes the Window if it exists.
1476                          */
1477                         ArdourWindow* win = new ArdourWindow (*((Gtk::Window*) _view.get_toplevel()), title.get_string());
1478                         win->set_title (_("Control Protocol Settings"));
1479                         win->add (*box);
1480                         box->show ();
1481                         win->present ();
1482                 }
1483
1484                 void edit_clicked (GdkEventButton* ev)
1485                 {
1486                         if (ev->type != GDK_2BUTTON_PRESS) {
1487                                 return;
1488                         }
1489
1490                         edit_btn_clicked();
1491                 }
1492
1493                 class ControlSurfacesModelColumns : public TreeModelColumnRecord
1494         {
1495                 public:
1496
1497                         ControlSurfacesModelColumns ()
1498                         {
1499                                 add (name);
1500                                 add (enabled);
1501                                 add (protocol_info);
1502                         }
1503
1504                         TreeModelColumn<string> name;
1505                         TreeModelColumn<bool> enabled;
1506                         TreeModelColumn<ControlProtocolInfo*> protocol_info;
1507         };
1508
1509                 Glib::RefPtr<ListStore> _store;
1510                 ControlSurfacesModelColumns _model;
1511                 TreeView _view;
1512                 PBD::ScopedConnection protocol_status_connection;
1513                 uint32_t _ignore_view_change;
1514                 Gtk::Button* edit_button;
1515 };
1516
1517 class VideoTimelineOptions : public OptionEditorMiniPage
1518 {
1519         public:
1520                 VideoTimelineOptions (RCConfiguration* c)
1521                         : _rc_config (c)
1522                         , _show_video_export_info_button (_("Show Video Export Info before export"))
1523                         , _show_video_server_dialog_button (_("Show Video Server Startup Dialog"))
1524                         , _video_advanced_setup_button (_("Advanced Setup (remote video server)"))
1525                         , _xjadeo_browse_button (_("Browse..."))
1526                 {
1527                         Table* t = &table;
1528                         int n = table.property_n_rows();
1529
1530                         t->attach (_show_video_export_info_button, 1, 4, n, n + 1);
1531                         _show_video_export_info_button.signal_toggled().connect (sigc::mem_fun (*this, &VideoTimelineOptions::show_video_export_info_toggled));
1532                         Gtkmm2ext::UI::instance()->set_tip (_show_video_export_info_button,
1533                                         _("<b>When enabled</b> an information window with details is displayed before the video-export dialog."));
1534                         ++n;
1535
1536                         t->attach (_show_video_server_dialog_button, 1, 4, n, n + 1);
1537                         _show_video_server_dialog_button.signal_toggled().connect (sigc::mem_fun (*this, &VideoTimelineOptions::show_video_server_dialog_toggled));
1538                         Gtkmm2ext::UI::instance()->set_tip (_show_video_server_dialog_button,
1539                                         _("<b>When enabled</b> the video server is never launched automatically without confirmation"));
1540                         ++n;
1541
1542                         t->attach (_video_advanced_setup_button, 1, 4, n, n + 1, FILL);
1543                         _video_advanced_setup_button.signal_toggled().connect (sigc::mem_fun (*this, &VideoTimelineOptions::video_advanced_setup_toggled));
1544                         Gtkmm2ext::UI::instance()->set_tip (_video_advanced_setup_button,
1545                                         _("<b>When enabled</b> you can specify a custom video-server URL and docroot. - Do not enable this option unless you know what you are doing."));
1546                         ++n;
1547
1548                         Label* l = manage (new Label (_("Video Server URL:")));
1549                         l->set_alignment (0, 0.5);
1550                         t->attach (*l, 1, 2, n, n + 1, FILL);
1551                         t->attach (_video_server_url_entry, 2, 4, n, n + 1, FILL);
1552                         Gtkmm2ext::UI::instance()->set_tip (_video_server_url_entry,
1553                                         _("Base URL of the video-server including http prefix. This is usually 'http://hostname.example.org:1554/' and defaults to 'http://localhost:1554/' when the video-server is running locally"));
1554                         ++n;
1555
1556                         l = manage (new Label (_("Video Folder:")));
1557                         l->set_alignment (0, 0.5);
1558                         t->attach (*l, 1, 2, n, n + 1, FILL);
1559                         t->attach (_video_server_docroot_entry, 2, 4, n, n + 1);
1560                         Gtkmm2ext::UI::instance()->set_tip (_video_server_docroot_entry,
1561                                         _("Local path to the video-server document-root. Only files below this directory will be accessible by the video-server. If the server run on a remote host, it should point to a network mounted folder of the server's docroot or be left empty if it is unavailable. It is used for the local video-monitor and file-browsing when opening/adding a video file."));
1562                         ++n;
1563
1564                         l = manage (new Label (""));
1565                         t->attach (*l, 0, 4, n, n + 1, EXPAND | FILL);
1566                         ++n;
1567
1568                         l = manage (new Label (string_compose ("<b>%1</b>", _("Video Monitor"))));
1569                         l->set_use_markup (true);
1570                         l->set_alignment (0, 0.5);
1571                         t->attach (*l, 0, 4, n, n + 1, EXPAND | FILL);
1572                         ++n;
1573
1574                         l = manage (new Label (string_compose (_("Custom Path to Video Monitor (%1) - leave empty for default:"),
1575 #ifdef __APPLE__
1576                                                         "Jadeo.app"
1577 #elif defined PLATFORM_WINDOWS
1578                                                         "xjadeo.exe"
1579 #else
1580                                                         "xjadeo"
1581 #endif
1582                                                         )));
1583                         l->set_alignment (0, 0.5);
1584                         t->attach (*l, 1, 4, n, n + 1, FILL);
1585                         ++n;
1586
1587                         t->attach (_custom_xjadeo_path, 2, 3, n, n + 1, EXPAND|FILL);
1588                         Gtkmm2ext::UI::instance()->set_tip (_custom_xjadeo_path, _("Set a custom path to the Video Monitor Executable, changing this requires a restart."));
1589                         t->attach (_xjadeo_browse_button, 3, 4, n, n + 1, FILL);
1590
1591                         _video_server_url_entry.signal_changed().connect (sigc::mem_fun(*this, &VideoTimelineOptions::server_url_changed));
1592                         _video_server_url_entry.signal_activate().connect (sigc::mem_fun(*this, &VideoTimelineOptions::server_url_changed));
1593                         _video_server_docroot_entry.signal_changed().connect (sigc::mem_fun(*this, &VideoTimelineOptions::server_docroot_changed));
1594                         _video_server_docroot_entry.signal_activate().connect (sigc::mem_fun(*this, &VideoTimelineOptions::server_docroot_changed));
1595                         _custom_xjadeo_path.signal_changed().connect (sigc::mem_fun (*this, &VideoTimelineOptions::custom_xjadeo_path_changed));
1596                         _xjadeo_browse_button.signal_clicked ().connect (sigc::mem_fun (*this, &VideoTimelineOptions::xjadeo_browse_clicked));
1597                 }
1598
1599                 void server_url_changed ()
1600                 {
1601                         _rc_config->set_video_server_url (_video_server_url_entry.get_text());
1602                 }
1603
1604                 void server_docroot_changed ()
1605                 {
1606                         _rc_config->set_video_server_docroot (_video_server_docroot_entry.get_text());
1607                 }
1608
1609                 void show_video_export_info_toggled ()
1610                 {
1611                         bool const x = _show_video_export_info_button.get_active ();
1612                         _rc_config->set_show_video_export_info (x);
1613                 }
1614
1615                 void show_video_server_dialog_toggled ()
1616                 {
1617                         bool const x = _show_video_server_dialog_button.get_active ();
1618                         _rc_config->set_show_video_server_dialog (x);
1619                 }
1620
1621                 void video_advanced_setup_toggled ()
1622                 {
1623                         bool const x = _video_advanced_setup_button.get_active ();
1624                         _rc_config->set_video_advanced_setup(x);
1625                 }
1626
1627                 void custom_xjadeo_path_changed ()
1628                 {
1629                         _rc_config->set_xjadeo_binary (_custom_xjadeo_path.get_text());
1630                 }
1631
1632                 void xjadeo_browse_clicked ()
1633                 {
1634                         Gtk::FileChooserDialog dialog(_("Set Video Monitor Executable"), Gtk::FILE_CHOOSER_ACTION_OPEN);
1635                         dialog.set_filename (_rc_config->get_xjadeo_binary());
1636                         dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1637                         dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
1638                         if (dialog.run () == Gtk::RESPONSE_OK) {
1639                                 const std::string& filename = dialog.get_filename();
1640                                 if (!filename.empty() && (
1641 #ifdef __APPLE__
1642                                                         Glib::file_test (filename + "/Contents/MacOS/xjadeo", Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_EXECUTABLE) ||
1643 #endif
1644                                                         Glib::file_test (filename, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_EXECUTABLE)
1645                                                         )) {
1646                                         _rc_config->set_xjadeo_binary (filename);
1647                                 }
1648                         }
1649                 }
1650
1651                 void parameter_changed (string const & p)
1652                 {
1653                         if (p == "video-server-url") {
1654                                 _video_server_url_entry.set_text (_rc_config->get_video_server_url());
1655                         } else if (p == "video-server-docroot") {
1656                                 _video_server_docroot_entry.set_text (_rc_config->get_video_server_docroot());
1657                         } else if (p == "show-video-export-info") {
1658                                 bool const x = _rc_config->get_show_video_export_info();
1659                                 _show_video_export_info_button.set_active (x);
1660                         } else if (p == "show-video-server-dialog") {
1661                                 bool const x = _rc_config->get_show_video_server_dialog();
1662                                 _show_video_server_dialog_button.set_active (x);
1663                         } else if (p == "video-advanced-setup") {
1664                                 bool const x = _rc_config->get_video_advanced_setup();
1665                                 _video_advanced_setup_button.set_active(x);
1666                                 _video_server_docroot_entry.set_sensitive(x);
1667                                 _video_server_url_entry.set_sensitive(x);
1668                         } else if (p == "xjadeo-binary") {
1669                                 _custom_xjadeo_path.set_text (_rc_config->get_xjadeo_binary());
1670                         }
1671                 }
1672
1673                 void set_state_from_config ()
1674                 {
1675                         parameter_changed ("video-server-url");
1676                         parameter_changed ("video-server-docroot");
1677                         parameter_changed ("video-monitor-setup-dialog");
1678                         parameter_changed ("show-video-export-info");
1679                         parameter_changed ("show-video-server-dialog");
1680                         parameter_changed ("video-advanced-setup");
1681                         parameter_changed ("xjadeo-binary");
1682                 }
1683
1684         private:
1685                 RCConfiguration* _rc_config;
1686                 Entry _video_server_url_entry;
1687                 Entry _video_server_docroot_entry;
1688                 Entry _custom_xjadeo_path;
1689                 CheckButton _show_video_export_info_button;
1690                 CheckButton _show_video_server_dialog_button;
1691                 CheckButton _video_advanced_setup_button;
1692                 Button _xjadeo_browse_button;
1693 };
1694
1695 class ColumVisibilityOption : public Option
1696 {
1697         public:
1698         ColumVisibilityOption (string id, string name, uint32_t n_col, sigc::slot<uint32_t> get, sigc::slot<bool, uint32_t> set)
1699                 : Option (id, name)
1700                 , _heading (name)
1701                 , _n_col (n_col)
1702                 , _get (get)
1703                 , _set (set)
1704         {
1705                 cb = (CheckButton**) malloc (sizeof (CheckButton*) * n_col);
1706                 for (uint32_t i = 0; i < n_col; ++i) {
1707                         CheckButton* col = manage (new CheckButton (string_compose (_("Column %1"), i + 1)));
1708                         col->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &ColumVisibilityOption::column_toggled), i));
1709                         _hbox.pack_start (*col);
1710                         cb[i] = col;
1711                 }
1712                 parameter_changed (id);
1713         }
1714
1715         ~ColumVisibilityOption () {
1716                 free (cb);
1717         }
1718
1719         Gtk::Widget& tip_widget() { return _hbox; }
1720
1721         void set_state_from_config ()
1722         {
1723                 uint32_t c = _get();
1724                 for (uint32_t i = 0; i < _n_col; ++i) {
1725                         bool en = (c & (1<<i)) ? true : false;
1726                         if (cb[i]->get_active () != en) {
1727                                 cb[i]->set_active (en);
1728                         }
1729                 }
1730         }
1731
1732         void add_to_page (OptionEditorPage* p)
1733         {
1734                 _heading.add_to_page (p);
1735                 add_widget_to_page (p, &_hbox);
1736         }
1737         private:
1738
1739         void column_toggled (int b) {
1740                 uint32_t c = _get();
1741                 uint32_t cc = c;
1742                 if (cb[b]->get_active ()) {
1743                         c |= (1<<b);
1744                 } else {
1745                         c &= ~(1<<b);
1746                 }
1747                 if (cc != c) {
1748                         _set (c);
1749                 }
1750         }
1751
1752         HBox _hbox;
1753         OptionEditorHeading _heading;
1754
1755         CheckButton** cb;
1756         uint32_t _n_col;
1757         sigc::slot<uint32_t> _get;
1758         sigc::slot<bool, uint32_t> _set;
1759 };
1760
1761
1762 /** A class which allows control of visibility of some editor components usign
1763  *  a VisibilityGroup.  The caller should pass in a `dummy' VisibilityGroup
1764  *  which has the correct members, but with null widget pointers.  This
1765  *  class allows the user to set visibility of the members, the details
1766  *  of which are stored in a configuration variable which can be watched
1767  *  by parts of the editor that actually contain the widgets whose visibility
1768  *  is being controlled.
1769  */
1770
1771 class VisibilityOption : public Option
1772 {
1773 public:
1774         /** @param name User-visible name for this group.
1775          *  @param g `Dummy' VisibilityGroup (as described above).
1776          *  @param get Method to get the value of the appropriate configuration variable.
1777          *  @param set Method to set the value of the appropriate configuration variable.
1778          */
1779         VisibilityOption (string name, VisibilityGroup* g, sigc::slot<string> get, sigc::slot<bool, string> set)
1780                 : Option (g->get_state_name(), name)
1781                 , _heading (name)
1782                 , _visibility_group (g)
1783                 , _get (get)
1784                 , _set (set)
1785         {
1786                 /* Watch for changes made by the user to our members */
1787                 _visibility_group->VisibilityChanged.connect_same_thread (
1788                         _visibility_group_connection, sigc::bind (&VisibilityOption::changed, this)
1789                         );
1790         }
1791
1792         void set_state_from_config ()
1793         {
1794                 /* Set our state from the current configuration */
1795                 _visibility_group->set_state (_get ());
1796         }
1797
1798         void add_to_page (OptionEditorPage* p)
1799         {
1800                 _heading.add_to_page (p);
1801                 add_widget_to_page (p, _visibility_group->list_view ());
1802         }
1803
1804         Gtk::Widget& tip_widget() { return *_visibility_group->list_view (); }
1805
1806 private:
1807         void changed ()
1808         {
1809                 /* The user has changed something, so reflect this change
1810                    in the RCConfiguration.
1811                 */
1812                 _set (_visibility_group->get_state_value ());
1813         }
1814
1815         OptionEditorHeading _heading;
1816         VisibilityGroup* _visibility_group;
1817         sigc::slot<std::string> _get;
1818         sigc::slot<bool, std::string> _set;
1819         PBD::ScopedConnection _visibility_group_connection;
1820 };
1821
1822
1823 class MidiPortOptions : public OptionEditorMiniPage, public sigc::trackable
1824 {
1825         public:
1826                 MidiPortOptions() {
1827
1828                         setup_midi_port_view (midi_output_view, false);
1829                         setup_midi_port_view (midi_input_view, true);
1830
1831                         OptionEditorHeading* h = new OptionEditorHeading (_("MIDI Inputs"));
1832                         h->add_to_page (this);
1833
1834                         Gtk::ScrolledWindow* scroller = manage (new Gtk::ScrolledWindow);
1835                         scroller->add (midi_input_view);
1836                         scroller->set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
1837                         scroller->set_size_request (-1, 180);
1838
1839                         int n = table.property_n_rows();
1840                         table.attach (*scroller, 0, 3, n, n + 1, FILL | EXPAND);
1841
1842                         h = new OptionEditorHeading (_("MIDI Outputs"));
1843                         h->add_to_page (this);
1844
1845                         scroller = manage (new Gtk::ScrolledWindow);
1846                         scroller->add (midi_output_view);
1847                         scroller->set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
1848                         scroller->set_size_request (-1, 180);
1849
1850                         n = table.property_n_rows();
1851                         table.attach (*scroller, 0, 3, n, n + 1, FILL | EXPAND);
1852
1853                         midi_output_view.show ();
1854                         midi_input_view.show ();
1855
1856                         table.signal_show().connect (sigc::mem_fun (*this, &MidiPortOptions::on_show));
1857                 }
1858
1859                 void parameter_changed (string const&) {}
1860                 void set_state_from_config() {}
1861
1862                 void on_show () {
1863                         refill ();
1864
1865                         AudioEngine::instance()->PortRegisteredOrUnregistered.connect (connections,
1866                                         invalidator (*this),
1867                                         boost::bind (&MidiPortOptions::refill, this),
1868                                         gui_context());
1869                         AudioEngine::instance()->MidiPortInfoChanged.connect (connections,
1870                                         invalidator (*this),
1871                                         boost::bind (&MidiPortOptions::refill, this),
1872                                         gui_context());
1873                         AudioEngine::instance()->MidiSelectionPortsChanged.connect (connections,
1874                                         invalidator (*this),
1875                                         boost::bind (&MidiPortOptions::refill, this),
1876                                         gui_context());
1877                 }
1878
1879                 void refill () {
1880
1881                         if (refill_midi_ports (true, midi_input_view)) {
1882                                 input_label.show ();
1883                         } else {
1884                                 input_label.hide ();
1885                         }
1886                         if (refill_midi_ports (false, midi_output_view)) {
1887                                 output_label.show ();
1888                         } else {
1889                                 output_label.hide ();
1890                         }
1891                 }
1892
1893         private:
1894                 PBD::ScopedConnectionList connections;
1895
1896                 /* MIDI port management */
1897                 struct MidiPortColumns : public Gtk::TreeModel::ColumnRecord {
1898
1899                         MidiPortColumns () {
1900                                 add (pretty_name);
1901                                 add (music_data);
1902                                 add (control_data);
1903                                 add (selection);
1904                                 add (name);
1905                                 add (filler);
1906                         }
1907
1908                         Gtk::TreeModelColumn<std::string> pretty_name;
1909                         Gtk::TreeModelColumn<bool> music_data;
1910                         Gtk::TreeModelColumn<bool> control_data;
1911                         Gtk::TreeModelColumn<bool> selection;
1912                         Gtk::TreeModelColumn<std::string> name;
1913                         Gtk::TreeModelColumn<std::string> filler;
1914                 };
1915
1916                 MidiPortColumns midi_port_columns;
1917                 Gtk::TreeView midi_input_view;
1918                 Gtk::TreeView midi_output_view;
1919                 Gtk::Label input_label;
1920                 Gtk::Label output_label;
1921
1922                 void setup_midi_port_view (Gtk::TreeView&, bool with_selection);
1923                 bool refill_midi_ports (bool for_input, Gtk::TreeView&);
1924                 void pretty_name_edit (std::string const & path, std::string const & new_text, Gtk::TreeView*);
1925                 void midi_music_column_toggled (std::string const & path, Gtk::TreeView*);
1926                 void midi_control_column_toggled (std::string const & path, Gtk::TreeView*);
1927                 void midi_selection_column_toggled (std::string const & path, Gtk::TreeView*);
1928 };
1929
1930 void
1931 MidiPortOptions::setup_midi_port_view (Gtk::TreeView& view, bool with_selection)
1932 {
1933         int pretty_name_column;
1934         int music_column;
1935         int control_column;
1936         int selection_column;
1937         TreeViewColumn* col;
1938         Gtk::Label* l;
1939
1940         pretty_name_column = view.append_column_editable (_("Name (click to edit)"), midi_port_columns.pretty_name) - 1;
1941
1942         col = manage (new TreeViewColumn ("", midi_port_columns.music_data));
1943         col->set_alignment (ALIGN_CENTER);
1944         l = manage (new Label (_("Music Data")));
1945         set_tooltip (*l, string_compose (_("If ticked, %1 will consider this port to be a source of music performance data."), PROGRAM_NAME));
1946         col->set_widget (*l);
1947         l->show ();
1948         music_column = view.append_column (*col) - 1;
1949
1950         col = manage (new TreeViewColumn ("", midi_port_columns.control_data));
1951         col->set_alignment (ALIGN_CENTER);
1952         l = manage (new Label (_("Control Data")));
1953         set_tooltip (*l, string_compose (_("If ticked, %1 will consider this port to be a source of control data."), PROGRAM_NAME));
1954         col->set_widget (*l);
1955         l->show ();
1956         control_column = view.append_column (*col) - 1;
1957
1958         if (with_selection) {
1959                 col = manage (new TreeViewColumn (_("Follow Selection"), midi_port_columns.selection));
1960                 selection_column = view.append_column (*col) - 1;
1961                 l = manage (new Label (_("Follow Selection")));
1962                 set_tooltip (*l, string_compose (_("If ticked, and \"MIDI input follows selection\" is enabled,\n%1 will automatically connect the first selected MIDI track to this port.\n"), PROGRAM_NAME));
1963                 col->set_widget (*l);
1964                 l->show ();
1965         }
1966
1967         /* filler column so that the last real column doesn't expand */
1968         view.append_column ("", midi_port_columns.filler);
1969
1970         CellRendererText* pretty_name_cell = dynamic_cast<CellRendererText*> (view.get_column_cell_renderer (pretty_name_column));
1971         pretty_name_cell->property_editable() = true;
1972         pretty_name_cell->signal_edited().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::pretty_name_edit), &view));
1973
1974         CellRendererToggle* toggle_cell;
1975
1976         toggle_cell = dynamic_cast<CellRendererToggle*> (view.get_column_cell_renderer (music_column));
1977         toggle_cell->property_activatable() = true;
1978         toggle_cell->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::midi_music_column_toggled), &view));
1979
1980         toggle_cell = dynamic_cast<CellRendererToggle*> (view.get_column_cell_renderer (control_column));
1981         toggle_cell->property_activatable() = true;
1982         toggle_cell->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::midi_control_column_toggled), &view));
1983
1984         if (with_selection) {
1985                 toggle_cell = dynamic_cast<CellRendererToggle*> (view.get_column_cell_renderer (selection_column));
1986                 toggle_cell->property_activatable() = true;
1987                 toggle_cell->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::midi_selection_column_toggled), &view));
1988         }
1989
1990         view.get_selection()->set_mode (SELECTION_NONE);
1991         view.set_tooltip_column (4); /* port "real" name */
1992         view.get_column(0)->set_resizable (true);
1993         view.get_column(0)->set_expand (true);
1994 }
1995
1996 bool
1997 MidiPortOptions::refill_midi_ports (bool for_input, Gtk::TreeView& view)
1998 {
1999         using namespace ARDOUR;
2000
2001         std::vector<string> ports;
2002
2003         AudioEngine::instance()->get_known_midi_ports (ports);
2004
2005         if (ports.empty()) {
2006                 view.hide ();
2007                 return false;
2008         }
2009
2010         Glib::RefPtr<ListStore> model = Gtk::ListStore::create (midi_port_columns);
2011
2012         for (vector<string>::const_iterator s = ports.begin(); s != ports.end(); ++s) {
2013
2014                 if (AudioEngine::instance()->port_is_mine (*s)) {
2015                         continue;
2016                 }
2017
2018                 PortManager::MidiPortInformation mpi (AudioEngine::instance()->midi_port_information (*s));
2019
2020                 if (mpi.pretty_name.empty()) {
2021                         /* vanished since get_known_midi_ports() */
2022                         continue;
2023                 }
2024
2025                 if (for_input != mpi.input) {
2026                         continue;
2027                 }
2028
2029                 TreeModel::Row row = *(model->append());
2030
2031                 row[midi_port_columns.pretty_name] = mpi.pretty_name;
2032                 row[midi_port_columns.music_data] = mpi.properties & MidiPortMusic;
2033                 row[midi_port_columns.control_data] = mpi.properties & MidiPortControl;
2034                 row[midi_port_columns.selection] = mpi.properties & MidiPortSelection;
2035                 row[midi_port_columns.name] = *s;
2036         }
2037
2038         view.set_model (model);
2039
2040         return true;
2041 }
2042
2043 void
2044 MidiPortOptions::midi_music_column_toggled (string const & path, TreeView* view)
2045 {
2046         TreeIter iter = view->get_model()->get_iter (path);
2047
2048         if (!iter) {
2049                 return;
2050         }
2051
2052         bool new_value = ! bool ((*iter)[midi_port_columns.music_data]);
2053
2054         /* don't reset model - wait for MidiPortInfoChanged signal */
2055
2056         if (new_value) {
2057                 ARDOUR::AudioEngine::instance()->add_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortMusic);
2058         } else {
2059                 ARDOUR::AudioEngine::instance()->remove_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortMusic);
2060         }
2061 }
2062
2063 void
2064 MidiPortOptions::midi_control_column_toggled (string const & path, TreeView* view)
2065 {
2066         TreeIter iter = view->get_model()->get_iter (path);
2067
2068         if (!iter) {
2069                 return;
2070         }
2071
2072         bool new_value = ! bool ((*iter)[midi_port_columns.control_data]);
2073
2074         /* don't reset model - wait for MidiPortInfoChanged signal */
2075
2076         if (new_value) {
2077                 ARDOUR::AudioEngine::instance()->add_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortControl);
2078         } else {
2079                 ARDOUR::AudioEngine::instance()->remove_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortControl);
2080         }
2081 }
2082
2083 void
2084 MidiPortOptions::midi_selection_column_toggled (string const & path, TreeView* view)
2085 {
2086         TreeIter iter = view->get_model()->get_iter (path);
2087
2088         if (!iter) {
2089                 return;
2090         }
2091
2092         bool new_value = ! bool ((*iter)[midi_port_columns.selection]);
2093
2094         /* don't reset model - wait for MidiSelectionPortsChanged signal */
2095
2096         if (new_value) {
2097                 ARDOUR::AudioEngine::instance()->add_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortSelection);
2098         } else {
2099                 ARDOUR::AudioEngine::instance()->remove_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortSelection);
2100         }
2101 }
2102
2103 void
2104 MidiPortOptions::pretty_name_edit (std::string const & path, string const & new_text, Gtk::TreeView* view)
2105 {
2106         TreeIter iter = view->get_model()->get_iter (path);
2107
2108         if (!iter) {
2109                 return;
2110         }
2111
2112         AudioEngine::instance()->set_midi_port_pretty_name ((*iter)[midi_port_columns.name], new_text);
2113 }
2114
2115 /*============*/
2116
2117
2118 RCOptionEditor::RCOptionEditor ()
2119         : OptionEditorContainer (Config, string_compose (_("%1 Preferences"), PROGRAM_NAME))
2120         , Tabbable (*this, _("Preferences")
2121 #ifdef MIXBUS
2122                         , false // detached by default (first start, no instant.xml)
2123 #endif
2124                         ) /* pack self-as-vbox into tabbable */
2125         , _rc_config (Config)
2126         , _mixer_strip_visibility ("mixer-element-visibility")
2127 {
2128         UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &RCOptionEditor::parameter_changed));
2129
2130         /* MISC */
2131
2132         uint32_t hwcpus = hardware_concurrency ();
2133         BoolOption* bo;
2134
2135         if (hwcpus > 1) {
2136                 add_option (_("General"), new OptionEditorHeading (_("DSP CPU Utilization")));
2137
2138                 ComboOption<int32_t>* procs = new ComboOption<int32_t> (
2139                                 "processor-usage",
2140                                 _("Signal processing uses"),
2141                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_processor_usage),
2142                                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_processor_usage)
2143                                 );
2144
2145                 procs->add (-1, _("all but one processor"));
2146                 procs->add (0, _("all available processors"));
2147
2148                 for (uint32_t i = 1; i <= hwcpus; ++i) {
2149                         procs->add (i, string_compose (P_("%1 processor", "%1 processors", i), i));
2150                 }
2151
2152                 procs->set_note (string_compose (_("This setting will only take effect when %1 is restarted."), PROGRAM_NAME));
2153
2154                 add_option (_("General"), procs);
2155         }
2156
2157         /* Image cache size */
2158         add_option (_("General"), new OptionEditorHeading (_("Memory Usage")));
2159
2160         HSliderOption *sics = new HSliderOption ("waveform-cache-size",
2161                         _("Waveform image cache size (megabytes)"),
2162                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_cache_size),
2163                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_cache_size),
2164                         1, 1024, 10 /* 1 MB to 1GB in steps of 10MB */
2165                         );
2166         sics->scale().set_digits (0);
2167         Gtkmm2ext::UI::instance()->set_tip (
2168                         sics->tip_widget(),
2169                  _("Increasing the cache size uses more memory to store waveform images, which can improve graphical performance."));
2170         add_option (_("General"), sics);
2171
2172         add_option (_("General"), new OptionEditorHeading (_("Engine")));
2173
2174         add_option (_("General"),
2175              new BoolOption (
2176                      "try-autostart-engine",
2177                      _("Try to auto-launch audio/midi engine"),
2178                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_try_autostart_engine),
2179                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_try_autostart_engine)
2180                      ));
2181
2182         add_option (_("General"), new OptionEditorHeading (_("Automation")));
2183
2184         add_option (_("General"),
2185              new SpinOption<double> (
2186                      "automation-thinning-factor",
2187                      _("Thinning factor (larger value => less data)"),
2188                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_thinning_factor),
2189                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_thinning_factor),
2190                      0, 1000, 1, 20
2191                      ));
2192
2193         add_option (_("General"),
2194              new SpinOption<double> (
2195                      "automation-interval-msecs",
2196                      _("Automation sampling interval (milliseconds)"),
2197                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_interval_msecs),
2198                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_interval_msecs),
2199                      1, 1000, 1, 20
2200                      ));
2201
2202         add_option (_("General"), new OptionEditorHeading (_("Tempo")));
2203
2204         bo = new BoolOption (
2205                 "allow-non-quarter-pulse",
2206                 _("Allow non quarter-note pulse"),
2207                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_allow_non_quarter_pulse),
2208                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_allow_non_quarter_pulse)
2209                 );
2210         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
2211                                             string_compose (_("<b>When enabled</b> %1 will allow tempo to be expressed in divisions per minute\n"
2212                                                               "<b>When disabled</b> %1 will only allow tempo to be expressed in quarter notes per minute"),
2213                                                             PROGRAM_NAME));
2214         add_option (_("General"), bo);
2215
2216         if (!ARDOUR::Profile->get_mixbus()) {
2217                 add_option (_("General"), new OptionEditorHeading (_("GUI Lock")));
2218                 /* Lock GUI timeout */
2219
2220                 HSliderOption *slts = new HSliderOption("lock-gui-after-seconds",
2221                                 _("Lock timeout (seconds)"),
2222                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_lock_gui_after_seconds),
2223                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_lock_gui_after_seconds),
2224                                 0, 1000, 1, 10
2225                                 );
2226                 slts->scale().set_digits (0);
2227                 Gtkmm2ext::UI::instance()->set_tip (
2228                                 slts->tip_widget(),
2229                                 _("Lock GUI after this many idle seconds (zero to never lock)"));
2230                 add_option (_("General"), slts);
2231         } // !mixbus
2232
2233         add_option (_("General/Session"), new OptionEditorHeading (S_("Options|Undo")));
2234
2235         add_option (_("General/Session"), new UndoOptions (_rc_config));
2236
2237         add_option (_("General/Session"),
2238              new BoolOption (
2239                      "verify-remove-last-capture",
2240                      _("Verify removal of last capture"),
2241                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_verify_remove_last_capture),
2242                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_verify_remove_last_capture)
2243                      ));
2244
2245         add_option (_("General/Session"), new OptionEditorHeading (_("Session Management")));
2246
2247         add_option (_("General/Session"),
2248              new BoolOption (
2249                      "periodic-safety-backups",
2250                      _("Make periodic backups of the session file"),
2251                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_periodic_safety_backups),
2252                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_periodic_safety_backups)
2253                      ));
2254
2255         add_option (_("General/Session"),
2256              new BoolOption (
2257                      "only-copy-imported-files",
2258                      _("Always copy imported files"),
2259                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_only_copy_imported_files),
2260                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_only_copy_imported_files)
2261                      ));
2262
2263         add_option (_("General/Session"), new DirectoryOption (
2264                             X_("default-session-parent-dir"),
2265                             _("Default folder for new sessions:"),
2266                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_default_session_parent_dir),
2267                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_default_session_parent_dir)
2268                             ));
2269
2270         add_option (_("General/Session"),
2271              new SpinOption<uint32_t> (
2272                      "max-recent-sessions",
2273                      _("Maximum number of recent sessions"),
2274                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_max_recent_sessions),
2275                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_max_recent_sessions),
2276                      0, 1000, 1, 20
2277                      ));
2278
2279
2280 #if ENABLE_NLS
2281
2282         add_option (_("General/Translation"), new OptionEditorHeading (_("Internationalization")));
2283
2284         bo = new BoolOption (
2285                         "enable-translation",
2286                         _("Use translations"),
2287                         sigc::ptr_fun (ARDOUR::translations_are_enabled),
2288                         sigc::ptr_fun (ARDOUR::set_translations_enabled)
2289                         );
2290
2291         bo->set_note (string_compose (_("These settings will only take effect after %1 is restarted (if available for your language preferences)."), PROGRAM_NAME));
2292
2293         add_option (_("General/Translation"), bo);
2294
2295         parameter_changed ("enable-translation");
2296 #endif // ENABLE_NLS
2297
2298
2299         /* EDITOR */
2300
2301         add_option (_("Editor"), new OptionEditorHeading (_("General")));
2302
2303         bo = new BoolOption (
2304                      "name-new-markers",
2305                      _("Prompt for new marker names"),
2306                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_name_new_markers),
2307                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_name_new_markers)
2308                 );
2309         add_option (_("Editor"), bo);
2310         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(), _("If enabled, popup a dialog when a new marker is created to allow its name to be set as it is created."
2311                                                                 "\n\nYou can always rename markers by right-clicking on them"));
2312
2313         add_option (_("Editor"),
2314              new BoolOption (
2315                      "draggable-playhead",
2316                      _("Allow dragging of playhead"),
2317                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_draggable_playhead),
2318                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_draggable_playhead)
2319                      ));
2320
2321         ComboOption<float>* dps = new ComboOption<float> (
2322                      "draggable-playhead-speed",
2323                      _("Playhead dragging speed (%)"),
2324                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_draggable_playhead_speed),
2325                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_draggable_playhead_speed)
2326                      );
2327         dps->add (0.05, _("5%"));
2328         dps->add (0.1, _("10%"));
2329         dps->add (0.25, _("25%"));
2330         dps->add (0.5, _("50%"));
2331         dps->add (1.0, _("100%"));
2332         add_option (_("Editor"), dps);
2333
2334         ComboOption<float>* eet = new ComboOption<float> (
2335                      "extra-ui-extents-time",
2336                      _("Limit zooming & summary view to X minutes beyond session extents"),
2337                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_extra_ui_extents_time),
2338                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_extra_ui_extents_time)
2339                      );
2340         eet->add (1, _("1 minute"));
2341         eet->add (2, _("2 minutes"));
2342         eet->add (20, _("20 minutes"));
2343         eet->add (60, _("1 hour"));
2344         eet->add (60*2, _("2 hours"));
2345         eet->add (60*24, _("24 hours"));
2346         add_option (_("Editor"), eet);
2347
2348         if (!Profile->get_mixbus()) {
2349
2350                 add_option (_("Editor"),
2351                                 new BoolOption (
2352                                         "use-mouse-position-as-zoom-focus-on-scroll",
2353                                         _("Zoom to mouse position when zooming with scroll wheel"),
2354                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_mouse_position_as_zoom_focus_on_scroll),
2355                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_mouse_position_as_zoom_focus_on_scroll)
2356                                         ));
2357         }  // !mixbus
2358
2359         add_option (_("Editor"),
2360                     new BoolOption (
2361                             "use-time-rulers-to-zoom-with-vertical-drag",
2362                             _("Zoom with vertical drag in rulers"),
2363                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_time_rulers_to_zoom_with_vertical_drag),
2364                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_time_rulers_to_zoom_with_vertical_drag)
2365                             ));
2366
2367         add_option (_("Editor"),
2368                     new BoolOption (
2369                             "use-double-click-to-zoom-to-selection",
2370                             _("Double click zooms to selection"),
2371                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_double_click_to_zoom_to_selection),
2372                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_double_click_to_zoom_to_selection)
2373                             ));
2374
2375         add_option (_("Editor"),
2376                     new BoolOption (
2377                             "update-editor-during-summary-drag",
2378                             _("Update editor window during drags of the summary"),
2379                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_update_editor_during_summary_drag),
2380                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_update_editor_during_summary_drag)
2381                             ));
2382
2383         add_option (_("Editor"),
2384             new BoolOption (
2385                     "autoscroll-editor",
2386                     _("Auto-scroll editor window when dragging near its edges"),
2387                     sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_autoscroll_editor),
2388                     sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_autoscroll_editor)
2389                     ));
2390
2391         add_option (_("Editor"),
2392              new BoolComboOption (
2393                      "show-region-gain-envelopes",
2394                      _("Show gain envelopes in audio regions"),
2395                      _("in all modes"),
2396                      _("only in Draw and Internal Edit modes"),
2397                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_region_gain),
2398                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_region_gain)
2399                      ));
2400
2401         add_option (_("Editor"), new OptionEditorHeading (_("Editor Behavior")));
2402
2403         add_option (_("Editor"),
2404              new BoolOption (
2405                      "automation-follows-regions",
2406                      _("Move relevant automation when audio regions are moved"),
2407                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_follows_regions),
2408                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_follows_regions)
2409                      ));
2410
2411         bo = new BoolOption (
2412                      "new-automation-points-on-lane",
2413                      _("Ignore Y-axis click position when adding new automation-points"),
2414                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_new_automation_points_on_lane),
2415                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_new_automation_points_on_lane)
2416                      );
2417         add_option (_("Editor"), bo);
2418         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
2419                         _("<b>When enabled</b> The new points drawn in any automation lane will be placed on the existing line, regardless of mouse y-axis position."));
2420
2421         ComboOption<FadeShape>* fadeshape = new ComboOption<FadeShape> (
2422                         "default-fade-shape",
2423                         _("Default fade shape"),
2424                         sigc::mem_fun (*_rc_config,
2425                                 &RCConfiguration::get_default_fade_shape),
2426                         sigc::mem_fun (*_rc_config,
2427                                 &RCConfiguration::set_default_fade_shape)
2428                         );
2429
2430         fadeshape->add (FadeLinear,
2431                         _("Linear (for highly correlated material)"));
2432         fadeshape->add (FadeConstantPower, _("Constant power"));
2433         fadeshape->add (FadeSymmetric, _("Symmetric"));
2434         fadeshape->add (FadeSlow, _("Slow"));
2435         fadeshape->add (FadeFast, _("Fast"));
2436
2437         add_option (_("Editor"), fadeshape);
2438
2439         ComboOption<RegionEquivalence> *eqv = new ComboOption<RegionEquivalence> (
2440                      "region-equivalence",
2441                      _("Regions in active edit groups are edited together"),
2442                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_region_equivalence),
2443                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_region_equivalence)
2444                      );
2445
2446         eqv->add (Overlap, _("whenever they overlap in time"));
2447         eqv->add (Enclosed, _("if either encloses the other"));
2448         eqv->add (Exact, _("only if they have identical length, position and origin"));
2449
2450         add_option (_("Editor"), eqv);
2451
2452         ComboOption<LayerModel>* lm = new ComboOption<LayerModel> (
2453                 "layer-model",
2454                 _("Layering model"),
2455                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_layer_model),
2456                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_layer_model)
2457                 );
2458
2459         lm->add (LaterHigher, _("later is higher"));
2460         lm->add (Manual, _("manual layering"));
2461         add_option (_("Editor"), lm);
2462
2463         ComboOption<RegionSelectionAfterSplit> *rsas = new ComboOption<RegionSelectionAfterSplit> (
2464                     "region-selection-after-split",
2465                     _("After splitting selected regions, select"),
2466                     sigc::mem_fun (*_rc_config, &RCConfiguration::get_region_selection_after_split),
2467                     sigc::mem_fun (*_rc_config, &RCConfiguration::set_region_selection_after_split));
2468
2469         // TODO: decide which of these modes are really useful
2470         rsas->add(None, _("no regions"));
2471         // rsas->add(NewlyCreatedLeft, _("newly-created regions before the split"));
2472         // rsas->add(NewlyCreatedRight, _("newly-created regions after the split"));
2473         rsas->add(NewlyCreatedBoth, _("newly-created regions"));
2474         // rsas->add(Existing, _("unmodified regions in the existing selection"));
2475         // rsas->add(ExistingNewlyCreatedLeft, _("existing selection and newly-created regions before the split"));
2476         // rsas->add(ExistingNewlyCreatedRight, _("existing selection and newly-created regions after the split"));
2477         rsas->add(ExistingNewlyCreatedBoth, _("existing selection and newly-created regions"));
2478
2479         add_option (_("Editor"), rsas);
2480
2481         add_option (_("Editor/Snap"), new OptionEditorHeading (_("General Snap options:")));
2482
2483         add_option (_("Editor/Snap"),
2484                     new SpinOption<uint32_t> (
2485                             "snap-threshold",
2486                             _("Snap Threshold (pixels)"),
2487                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_snap_threshold),
2488                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_snap_threshold),
2489                             10, 200,
2490                             1, 10
2491                             ));
2492
2493         add_option (_("Editor/Snap"),
2494              new BoolOption (
2495                      "show-snapped-cursor",
2496                      _("Show \"snapped cursor\""),
2497                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_snapped_cursor),
2498                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_snapped_cursor)
2499                      ));
2500
2501         add_option (_("Editor/Snap"),
2502              new BoolOption (
2503                      "rubberbanding-snaps-to-grid",
2504                      _("Snap rubberband selection to grid"),
2505                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_rubberbanding_snaps_to_grid),
2506                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_rubberbanding_snaps_to_grid)
2507                      ));
2508
2509         add_option (_("Editor/Snap"),
2510              new BoolOption (
2511                      "grid-follows-internal",
2512                      _("Grid switches to alternate selection for Internal Edit tools"),
2513                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_grid_follows_internal),
2514                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_grid_follows_internal)
2515                      ));
2516
2517         add_option (_("Editor/Snap"),
2518              new BoolOption (
2519                      "rulers-follow-grid",
2520                      _("Rulers automatically change to follow the Grid mode selection"),
2521                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_rulers_follow_grid),
2522                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_rulers_follow_grid)
2523                      ));
2524
2525         add_option (_("Editor/Snap"), new OptionEditorHeading (_("When \"Snap\" is enabled, snap to:")));
2526
2527
2528         add_option (_("Editor/Snap"),
2529              new BoolOption (
2530                      "snap-to-marks",
2531                      _("Markers"),
2532                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_snap_to_marks),
2533                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_snap_to_marks)
2534                      ));
2535
2536         add_option (_("Editor/Snap"),
2537              new BoolOption (
2538                      "snap-to-region-sync",
2539                      _("Region Sync Points"),
2540                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_snap_to_region_sync),
2541                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_snap_to_region_sync)
2542                      ));
2543
2544         add_option (_("Editor/Snap"),
2545              new BoolOption (
2546                      "snap-to-region-start",
2547                      _("Region Starts"),
2548                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_snap_to_region_start),
2549                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_snap_to_region_start)
2550                      ));
2551
2552         add_option (_("Editor/Snap"),
2553              new BoolOption (
2554                      "snap-to-region-end",
2555                      _("Region Ends"),
2556                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_snap_to_region_end),
2557                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_snap_to_region_end)
2558                      ));
2559
2560         add_option (_("Editor/Snap"),
2561              new BoolOption (
2562                      "snap-to-grid",
2563                      _("Grid"),
2564                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_snap_to_grid),
2565                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_snap_to_grid)
2566                      ));
2567
2568         add_option (_("Editor/Modifiers"), new OptionEditorHeading (_("Keyboard Modifiers")));
2569         add_option (_("Editor/Modifiers"), new KeyboardOptions);
2570         add_option (_("Editor/Modifiers"), new OptionEditorBlank ());
2571
2572         /* MIXER -- SOLO AND MUTE */
2573
2574         add_option (_("Mixer"), new OptionEditorHeading (_("Solo")));
2575
2576         _solo_control_is_listen_control = new BoolOption (
2577                 "solo-control-is-listen-control",
2578                 _("Solo controls are Listen controls"),
2579                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_control_is_listen_control),
2580                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_control_is_listen_control)
2581                 );
2582
2583         add_option (_("Mixer"), _solo_control_is_listen_control);
2584
2585         add_option (_("Mixer"),
2586              new BoolOption (
2587                      "exclusive-solo",
2588                      _("Exclusive solo"),
2589                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_exclusive_solo),
2590                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_exclusive_solo)
2591                      ));
2592
2593         add_option (_("Mixer"),
2594              new BoolOption (
2595                      "show-solo-mutes",
2596                      _("Show solo muting"),
2597                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_solo_mutes),
2598                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_solo_mutes)
2599                      ));
2600
2601         add_option (_("Mixer"),
2602              new BoolOption (
2603                      "solo-mute-override",
2604                      _("Soloing overrides muting"),
2605                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_override),
2606                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_override)
2607                      ));
2608
2609         add_option (_("Mixer"),
2610              new FaderOption (
2611                      "solo-mute-gain",
2612                      _("Solo-in-place mute cut (dB)"),
2613                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_gain),
2614                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_gain)
2615                      ));
2616
2617         _listen_position = new ComboOption<ListenPosition> (
2618                 "listen-position",
2619                 _("Listen Position"),
2620                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_listen_position),
2621                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_listen_position)
2622                 );
2623
2624         _listen_position->add (AfterFaderListen, _("after-fader (AFL)"));
2625         _listen_position->add (PreFaderListen, _("pre-fader (PFL)"));
2626
2627         add_option (_("Mixer"), _listen_position);
2628
2629         ComboOption<PFLPosition>* pp = new ComboOption<PFLPosition> (
2630                 "pfl-position",
2631                 _("PFL signals come from"),
2632                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_pfl_position),
2633                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_pfl_position)
2634                 );
2635
2636         pp->add (PFLFromBeforeProcessors, _("before pre-fader processors"));
2637         pp->add (PFLFromAfterProcessors, _("pre-fader but after pre-fader processors"));
2638
2639         add_option (_("Mixer"), pp);
2640
2641         ComboOption<AFLPosition>* pa = new ComboOption<AFLPosition> (
2642                 "afl-position",
2643                 _("AFL signals come from"),
2644                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_afl_position),
2645                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_afl_position)
2646                 );
2647
2648         pa->add (AFLFromBeforeProcessors, _("immediately post-fader"));
2649         pa->add (AFLFromAfterProcessors, _("after post-fader processors (before pan)"));
2650
2651         add_option (_("Mixer"), pa);
2652
2653         add_option (_("Mixer"), new OptionEditorHeading (_("Default Track / Bus Muting Options")));
2654
2655         add_option (_("Mixer"),
2656              new BoolOption (
2657                      "mute-affects-pre-fader",
2658                      _("Mute affects pre-fader sends"),
2659                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_pre_fader),
2660                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_pre_fader)
2661                      ));
2662
2663         add_option (_("Mixer"),
2664              new BoolOption (
2665                      "mute-affects-post-fader",
2666                      _("Mute affects post-fader sends"),
2667                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_post_fader),
2668                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_post_fader)
2669                      ));
2670
2671         add_option (_("Mixer"),
2672              new BoolOption (
2673                      "mute-affects-control-outs",
2674                      _("Mute affects control outputs"),
2675                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_control_outs),
2676                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_control_outs)
2677                      ));
2678
2679         add_option (_("Mixer"),
2680              new BoolOption (
2681                      "mute-affects-main-outs",
2682                      _("Mute affects main outputs"),
2683                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_main_outs),
2684                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_main_outs)
2685                      ));
2686
2687
2688         if (!ARDOUR::Profile->get_mixbus()) {
2689                 add_option (_("Mixer"), new OptionEditorHeading (_("Send Routing")));
2690                 add_option (_("Mixer"),
2691                                 new BoolOption (
2692                                         "link-send-and-route-panner",
2693                                         _("Link panners of Aux and External Sends with main panner by default"),
2694                                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_link_send_and_route_panner),
2695                                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_send_and_route_panner)
2696                                         ));
2697         }
2698
2699         /* Signal Flow */
2700
2701         add_option (_("Signal Flow"), new OptionEditorHeading (_("Monitoring")));
2702
2703         ComboOption<MonitorModel>* mm = new ComboOption<MonitorModel> (
2704                 "monitoring-model",
2705                 _("Record monitoring handled by"),
2706                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_monitoring_model),
2707                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_monitoring_model)
2708                 );
2709
2710         if (AudioEngine::instance()->port_engine().can_monitor_input()) {
2711                 mm->add (HardwareMonitoring, _("via Audio Driver"));
2712         }
2713
2714         string prog (PROGRAM_NAME);
2715         boost::algorithm::to_lower (prog);
2716         mm->add (SoftwareMonitoring, string_compose (_("%1"), prog));
2717         mm->add (ExternalMonitoring, _("audio hardware"));
2718
2719         add_option (_("Signal Flow"), mm);
2720
2721         bo = new BoolOption (
2722                      "tape-machine-mode",
2723                      _("Tape machine mode"),
2724                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_tape_machine_mode),
2725                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_tape_machine_mode)
2726                      );
2727         add_option (_("Signal Flow"), bo);
2728         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
2729                         string_compose (_("<b>When enabled</b> %1 will not monitor a track's input if the transport is stopped."),
2730                                         PROGRAM_NAME));
2731
2732         if (!Profile->get_mixbus()) {
2733
2734                 add_option (_("Signal Flow"), new OptionEditorHeading (_("Track and Bus Connections")));
2735
2736                 add_option (_("Signal Flow"),
2737                                 new BoolOption (
2738                                         "auto-connect-standard-busses",
2739                                         _("Auto-connect master/monitor busses"),
2740                                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_auto_connect_standard_busses),
2741                                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_auto_connect_standard_busses)
2742                                         ));
2743
2744                 ComboOption<AutoConnectOption>* iac = new ComboOption<AutoConnectOption> (
2745                                 "input-auto-connect",
2746                                 _("Connect track inputs"),
2747                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_input_auto_connect),
2748                                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_input_auto_connect)
2749                                 );
2750
2751                 iac->add (AutoConnectPhysical, _("automatically to physical inputs"));
2752                 iac->add (ManualConnect, _("manually"));
2753
2754                 add_option (_("Signal Flow"), iac);
2755
2756                 ComboOption<AutoConnectOption>* oac = new ComboOption<AutoConnectOption> (
2757                                 "output-auto-connect",
2758                                 _("Connect track and bus outputs"),
2759                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_output_auto_connect),
2760                                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_output_auto_connect)
2761                                 );
2762
2763                 oac->add (AutoConnectPhysical, _("automatically to physical outputs"));
2764                 oac->add (AutoConnectMaster, _("automatically to master bus"));
2765                 oac->add (ManualConnect, _("manually"));
2766
2767                 add_option (_("Signal Flow"), oac);
2768
2769                 bo = new BoolOption (
2770                                 "strict-io",
2771                                 _("Use 'Strict-I/O' for new tracks or busses"),
2772                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_strict_io),
2773                                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_strict_io)
2774                                 );
2775
2776                 add_option (_("Signal Flow"), bo);
2777                 Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
2778                                 _("With strict-i/o enabled, Effect Processors will not modify the number of channels on a track. The number of output channels will always match the number of input channels."));
2779
2780         }  // !mixbus
2781
2782
2783         /* AUDIO */
2784
2785         add_option (_("Audio"), new OptionEditorHeading (_("Buffering")));
2786
2787         add_option (_("Audio"), new BufferingOptions (_rc_config));
2788
2789         add_option (_("Audio"), new OptionEditorHeading (_("Denormals")));
2790
2791         add_option (_("Audio"),
2792              new BoolOption (
2793                      "denormal-protection",
2794                      _("Use DC bias to protect against denormals"),
2795                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_denormal_protection),
2796                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_protection)
2797                      ));
2798
2799         ComboOption<DenormalModel>* dm = new ComboOption<DenormalModel> (
2800                 "denormal-model",
2801                 _("Processor handling"),
2802                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_denormal_model),
2803                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_model)
2804                 );
2805
2806         int dmsize = 1;
2807         dm->add (DenormalNone, _("no processor handling"));
2808
2809         FPU* fpu = FPU::instance();
2810
2811         if (fpu->has_flush_to_zero()) {
2812                 ++dmsize;
2813                 dm->add (DenormalFTZ, _("use FlushToZero"));
2814         } else if (_rc_config->get_denormal_model() == DenormalFTZ) {
2815                 _rc_config->set_denormal_model(DenormalNone);
2816         }
2817
2818         if (fpu->has_denormals_are_zero()) {
2819                 ++dmsize;
2820                 dm->add (DenormalDAZ, _("use DenormalsAreZero"));
2821         } else if (_rc_config->get_denormal_model() == DenormalDAZ) {
2822                 _rc_config->set_denormal_model(DenormalNone);
2823         }
2824
2825         if (fpu->has_flush_to_zero() && fpu->has_denormals_are_zero()) {
2826                 ++dmsize;
2827                 dm->add (DenormalFTZDAZ, _("use FlushToZero and DenormalsAreZero"));
2828         } else if (_rc_config->get_denormal_model() == DenormalFTZDAZ) {
2829                 _rc_config->set_denormal_model(DenormalNone);
2830         }
2831
2832         if (dmsize == 1) {
2833                 dm->set_sensitive(false);
2834         }
2835
2836         add_option (_("Audio"), dm);
2837
2838         add_option (_("Audio"), new OptionEditorHeading (_("Regions")));
2839
2840         add_option (_("Audio"),
2841              new BoolOption (
2842                      "auto-analyse-audio",
2843                      _("Enable automatic analysis of audio"),
2844                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_auto_analyse_audio),
2845                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_auto_analyse_audio)
2846                      ));
2847
2848         add_option (_("Audio"),
2849              new BoolOption (
2850                      "replicate-missing-region-channels",
2851                      _("Replicate missing region channels"),
2852                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_replicate_missing_region_channels),
2853                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_replicate_missing_region_channels)
2854                      ));
2855
2856         /* MIDI */
2857
2858         add_option (_("MIDI"), new OptionEditorHeading (_("Buffering")));
2859
2860         add_option (_("MIDI"),
2861                     new SpinOption<float> (
2862                             "midi-readahead",
2863                             _("MIDI read-ahead time (seconds)"),
2864                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_readahead),
2865                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_readahead),
2866                             0.1, 10, 0.05, 1,
2867                             "", 1.0, 2
2868                             ));
2869
2870         add_option (_("MIDI"), new OptionEditorHeading (_("Session")));
2871
2872         add_option (_("MIDI"),
2873              new SpinOption<int32_t> (
2874                      "initial-program-change",
2875                      _("Initial program change"),
2876                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_initial_program_change),
2877                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_initial_program_change),
2878                      -1, 65536, 1, 10
2879                      ));
2880
2881         add_option (_("MIDI"), new OptionEditorHeading (_("Audition")));
2882
2883         add_option (_("MIDI"),
2884              new BoolOption (
2885                      "sound-midi-notes",
2886                      _("Sound MIDI notes as they are selected in the editor"),
2887                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_sound_midi_notes),
2888                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_sound_midi_notes)
2889                      ));
2890
2891         ComboOption<std::string>* audition_synth = new ComboOption<std::string> (
2892                 "midi-audition-synth-uri",
2893                 _("MIDI Audition Synth (LV2)"),
2894                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_audition_synth_uri),
2895                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_audition_synth_uri)
2896                 );
2897
2898         audition_synth->add(X_(""), _("None"));
2899         PluginInfoList all_plugs;
2900         PluginManager& manager (PluginManager::instance());
2901 #ifdef LV2_SUPPORT
2902         all_plugs.insert (all_plugs.end(), manager.lv2_plugin_info().begin(), manager.lv2_plugin_info().end());
2903
2904         for (PluginInfoList::const_iterator i = all_plugs.begin(); i != all_plugs.end(); ++i) {
2905                 if (manager.get_status (*i) == PluginManager::Hidden) continue;
2906                 if (!(*i)->is_instrument()) continue;
2907                 if ((*i)->type != ARDOUR::LV2) continue;
2908                 if ((*i)->name.length() > 46) {
2909                         audition_synth->add((*i)->unique_id, (*i)->name.substr (0, 44) + "...");
2910                 } else {
2911                         audition_synth->add((*i)->unique_id, (*i)->name);
2912                 }
2913         }
2914 #endif
2915
2916         add_option (_("MIDI"), audition_synth);
2917
2918         /* Click */
2919
2920         add_option (_("Metronome"), new OptionEditorHeading (_("Metronome")));
2921         add_option (_("Metronome"), new ClickOptions (_rc_config));
2922         add_option (_("Metronome"), new OptionEditorHeading (_("Options")));
2923
2924         bo = new BoolOption (
2925                         "click-record-only",
2926                         _("Enable metronome only while recording"),
2927                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_click_record_only),
2928                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_click_record_only)
2929                         );
2930
2931         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
2932                         string_compose (_("<b>When enabled</b> the metronome will remain silent if %1 is <b>not recording</b>."), PROGRAM_NAME));
2933         add_option (_("Metronome"), bo);
2934         add_option (_("Metronome"), new OptionEditorBlank ());
2935
2936
2937         /* Meters */
2938
2939         add_option (S_("Preferences|Metering"), new OptionEditorHeading (_("Metering")));
2940
2941         ComboOption<float>* mht = new ComboOption<float> (
2942                 "meter-hold",
2943                 _("Peak hold time"),
2944                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_hold),
2945                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_hold)
2946                 );
2947
2948         mht->add (MeterHoldOff, _("off"));
2949         mht->add (MeterHoldShort, _("short"));
2950         mht->add (MeterHoldMedium, _("medium"));
2951         mht->add (MeterHoldLong, _("long"));
2952
2953         add_option (S_("Preferences|Metering"), mht);
2954
2955         ComboOption<float>* mfo = new ComboOption<float> (
2956                 "meter-falloff",
2957                 _("DPM fall-off"),
2958                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_falloff),
2959                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_falloff)
2960                 );
2961
2962         mfo->add (METER_FALLOFF_OFF,      _("off"));
2963         mfo->add (METER_FALLOFF_SLOWEST,  _("slowest [6.6dB/sec]"));
2964         mfo->add (METER_FALLOFF_SLOW,     _("slow [8.6dB/sec] (BBC PPM, EBU PPM)"));
2965         mfo->add (METER_FALLOFF_SLOWISH,  _("moderate [12.0dB/sec] (DIN)"));
2966         mfo->add (METER_FALLOFF_MODERATE, _("medium [13.3dB/sec] (EBU Digi PPM, IRT Digi PPM)"));
2967         mfo->add (METER_FALLOFF_MEDIUM,   _("fast [20dB/sec]"));
2968         mfo->add (METER_FALLOFF_FAST,     _("very fast [32dB/sec]"));
2969
2970         add_option (S_("Preferences|Metering"), mfo);
2971
2972         ComboOption<MeterLineUp>* mlu = new ComboOption<MeterLineUp> (
2973                 "meter-line-up-level",
2974                 _("Meter line-up level; 0dBu"),
2975                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_line_up_level),
2976                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_line_up_level)
2977                 );
2978
2979         mlu->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
2980         mlu->add (MeteringLineUp20, _("-20dBFS (SMPTE RP.0155)"));
2981         mlu->add (MeteringLineUp18, _("-18dBFS (EBU, BBC)"));
2982         mlu->add (MeteringLineUp15, _("-15dBFS (DIN)"));
2983
2984         Gtkmm2ext::UI::instance()->set_tip (mlu->tip_widget(), _("Configure meter-marks and color-knee point for dBFS scale DPM, set reference level for IEC1/Nordic, IEC2 PPM and VU meter."));
2985
2986         add_option (S_("Preferences|Metering"), mlu);
2987
2988         ComboOption<MeterLineUp>* mld = new ComboOption<MeterLineUp> (
2989                 "meter-line-up-din",
2990                 _("IEC1/DIN Meter line-up level; 0dBu"),
2991                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_line_up_din),
2992                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_line_up_din)
2993                 );
2994
2995         mld->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
2996         mld->add (MeteringLineUp20, _("-20dBFS (SMPTE RP.0155)"));
2997         mld->add (MeteringLineUp18, _("-18dBFS (EBU, BBC)"));
2998         mld->add (MeteringLineUp15, _("-15dBFS (DIN)"));
2999
3000         Gtkmm2ext::UI::instance()->set_tip (mld->tip_widget(), _("Reference level for IEC1/DIN meter."));
3001
3002         add_option (S_("Preferences|Metering"), mld);
3003
3004         ComboOption<VUMeterStandard>* mvu = new ComboOption<VUMeterStandard> (
3005                 "meter-vu-standard",
3006                 _("VU Meter standard"),
3007                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_vu_standard),
3008                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_vu_standard)
3009                 );
3010
3011         mvu->add (MeteringVUfrench,   _("0VU = -2dBu (France)"));
3012         mvu->add (MeteringVUamerican, _("0VU = 0dBu (North America, Australia)"));
3013         mvu->add (MeteringVUstandard, _("0VU = +4dBu (standard)"));
3014         mvu->add (MeteringVUeight,    _("0VU = +8dBu"));
3015
3016         add_option (S_("Preferences|Metering"), mvu);
3017
3018         HSliderOption *mpks = new HSliderOption("meter-peak",
3019                         _("Peak indicator threshold [dBFS]"),
3020                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_peak),
3021                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_peak),
3022                         -10, 0, .1, .1
3023                         );
3024
3025         Gtkmm2ext::UI::instance()->set_tip (
3026                         mpks->tip_widget(),
3027                         _("Specify the audio signal level in dBFS at and above which the meter-peak indicator will flash red."));
3028
3029         add_option (S_("Preferences|Metering"), mpks);
3030
3031         OptionEditorHeading* default_meter_head = new OptionEditorHeading (_("Default Meter Types"));
3032         default_meter_head->set_note (_("These settings apply to newly created tracks and busses. For the Master bus, this will be when a new session is created."));
3033
3034         add_option (S_("Preferences|Metering"), default_meter_head);
3035
3036         ComboOption<MeterType>* mtm = new ComboOption<MeterType> (
3037                 "meter-type-master",
3038                 _("Default Meter Type for Master Bus"),
3039                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_master),
3040                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_master)
3041                 );
3042         mtm->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
3043         mtm->add (MeterK20,     ArdourMeter::meter_type_string(MeterK20));
3044         mtm->add (MeterK14,     ArdourMeter::meter_type_string(MeterK14));
3045         mtm->add (MeterK12,     ArdourMeter::meter_type_string(MeterK12));
3046         mtm->add (MeterIEC1DIN, ArdourMeter::meter_type_string(MeterIEC1DIN));
3047         mtm->add (MeterIEC1NOR, ArdourMeter::meter_type_string(MeterIEC1NOR));
3048         mtm->add (MeterIEC2BBC, ArdourMeter::meter_type_string(MeterIEC2BBC));
3049         mtm->add (MeterIEC2EBU, ArdourMeter::meter_type_string(MeterIEC2EBU));
3050
3051         add_option (S_("Preferences|Metering"), mtm);
3052
3053
3054         ComboOption<MeterType>* mtb = new ComboOption<MeterType> (
3055                 "meter-type-bus",
3056                 _("Default meter type for busses"),
3057                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_bus),
3058                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_bus)
3059                 );
3060         mtb->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
3061         mtb->add (MeterK20,     ArdourMeter::meter_type_string(MeterK20));
3062         mtb->add (MeterK14,     ArdourMeter::meter_type_string(MeterK14));
3063         mtb->add (MeterK12,     ArdourMeter::meter_type_string(MeterK12));
3064         mtb->add (MeterIEC1DIN, ArdourMeter::meter_type_string(MeterIEC1DIN));
3065         mtb->add (MeterIEC1NOR, ArdourMeter::meter_type_string(MeterIEC1NOR));
3066         mtb->add (MeterIEC2BBC, ArdourMeter::meter_type_string(MeterIEC2BBC));
3067         mtb->add (MeterIEC2EBU, ArdourMeter::meter_type_string(MeterIEC2EBU));
3068
3069         add_option (S_("Preferences|Metering"), mtb);
3070
3071         ComboOption<MeterType>* mtt = new ComboOption<MeterType> (
3072                 "meter-type-track",
3073                 _("Default meter type for tracks"),
3074                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_track),
3075                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_track)
3076                 );
3077         mtt->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
3078         mtt->add (MeterPeak0dB, ArdourMeter::meter_type_string(MeterPeak0dB));
3079
3080         add_option (S_("Preferences|Metering"), mtt);
3081
3082         add_option (S_("Preferences|Metering"), new OptionEditorHeading (_("Post Export Analysis")));
3083
3084         add_option (S_("Preferences|Metering"),
3085              new BoolOption (
3086                      "save-export-analysis-image",
3087                      _("Save loudness analysis as image file"),
3088                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_save_export_analysis_image),
3089                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_save_export_analysis_image)
3090                      ));
3091
3092         /* TRANSPORT & Sync */
3093
3094         add_option (_("Transport"), new OptionEditorHeading (_("General")));
3095
3096         bo = new BoolOption (
3097                      "stop-at-session-end",
3098                      _("Stop at the end of the session"),
3099                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_at_session_end),
3100                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_at_session_end)
3101                      );
3102         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3103                                             string_compose (_("<b>When enabled</b> if %1 is <b>not recording</b>, it will stop the transport "
3104                                                               "when it reaches the current session end marker\n\n"
3105                                                               "<b>When disabled</b> %1 will continue to roll past the session end marker at all times"),
3106                                                             PROGRAM_NAME));
3107         add_option (_("Transport"), bo);
3108
3109         bo = new BoolOption (
3110                      "latched-record-enable",
3111                      _("Keep record-enable engaged on stop"),
3112                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_latched_record_enable),
3113                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_latched_record_enable)
3114                      );
3115         add_option (_("Transport"), bo);
3116         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3117                         _("<b>When enabled</b> master record will remain engaged when the transport transitions to stop.\n<b>When disabled</b> master record will be disabled when the transport transitions to stop."));
3118
3119         bo = new BoolOption (
3120                      "disable-disarm-during-roll",
3121                      _("Disable per-track record disarm while rolling"),
3122                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_disable_disarm_during_roll),
3123                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_disable_disarm_during_roll)
3124                      );
3125         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(), _("<b>When enabled</b> this will prevent you from accidentally stopping specific tracks recording during a take."));
3126         add_option (_("Transport"), bo);
3127
3128         bo = new BoolOption (
3129                      "quieten_at_speed",
3130                      _("12dB gain reduction during fast-forward and fast-rewind"),
3131                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_quieten_at_speed),
3132                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_quieten_at_speed)
3133                      );
3134         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3135                         _("<b>When enabled</b> this will reduce the unpleasant increase in perceived volume "
3136                                 "that occurs when fast-forwarding or rewinding through some kinds of audio"));
3137         add_option (_("Transport"), bo);
3138
3139         ComboOption<float>* psc = new ComboOption<float> (
3140                      "preroll-seconds",
3141                      _("Preroll"),
3142                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_preroll_seconds),
3143                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_preroll_seconds)
3144                      );
3145         Gtkmm2ext::UI::instance()->set_tip (psc->tip_widget(),
3146                                             (_("The amount of preroll to apply when <b>Play with Preroll</b> or <b>Record with Preroll</b>is initiated.\n\n"
3147                                                "If <b>Follow Edits</b> is enabled, the preroll is applied to the playhead position when a region is selected or trimmed.")));
3148         psc->add (-4.0, _("4 Bars"));
3149         psc->add (-2.0, _("2 Bars"));
3150         psc->add (-1.0, _("1 Bar"));
3151         psc->add (0.0, _("0 (no pre-roll)"));
3152         psc->add (0.1, _("0.1 second"));
3153         psc->add (0.25, _("0.25 second"));
3154         psc->add (0.5, _("0.5 second"));
3155         psc->add (1.0, _("1.0 second"));
3156         psc->add (2.0, _("2.0 seconds"));
3157         add_option (_("Transport"), psc);
3158
3159
3160         add_option (_("Transport"), new OptionEditorHeading (_("Looping")));
3161
3162         bo = new BoolOption (
3163                      "loop-is-mode",
3164                      _("Play loop is a transport mode"),
3165                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_loop_is_mode),
3166                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_loop_is_mode)
3167                      );
3168         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3169                                             (_("<b>When enabled</b> the loop button does not start playback but forces playback to always play the loop\n\n"
3170                                                "<b>When disabled</b> the loop button starts playing the loop, but stop then cancels loop playback")));
3171         add_option (_("Transport"), bo);
3172
3173         bo = new BoolOption (
3174                      "seamless-loop",
3175                      _("Do seamless looping (not possible when slaved to MTC, LTC etc)"),
3176                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_seamless_loop),
3177                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_seamless_loop)
3178                      );
3179         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3180                                             string_compose (_("<b>When enabled</b> this will loop by reading ahead and wrapping around at the loop point, "
3181                                                               "preventing any need to do a transport locate at the end of the loop\n\n"
3182                                                               "<b>When disabled</b> looping is done by locating back to the start of the loop when %1 reaches the end "
3183                                                               "which will often cause a small click or delay"), PROGRAM_NAME));
3184         add_option (_("Transport"), bo);
3185
3186         add_option (_("Transport"), new OptionEditorHeading (_("Dropout (xrun) Handling")));
3187         bo = new BoolOption (
3188                      "stop-recording-on-xrun",
3189                      _("Stop recording when an xrun occurs"),
3190                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun),
3191                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun)
3192                      );
3193         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3194                                             string_compose (_("<b>When enabled</b> %1 will stop recording if an over- or underrun is detected by the audio engine"),
3195                                                             PROGRAM_NAME));
3196         add_option (_("Transport"), bo);
3197
3198         bo = new BoolOption (
3199                      "create-xrun-marker",
3200                      _("Create markers where xruns occur"),
3201                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_create_xrun_marker),
3202                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_create_xrun_marker)
3203                      );
3204         add_option (_("Transport"), bo);
3205
3206
3207         /* SYNC */
3208
3209         add_option (_("Sync"), new OptionEditorHeading (_("Transport Masters")));
3210
3211         add_option (_("Sync"), new WidgetOption (X_("foo"), X_("Transport Masters"), _transport_masters_widget));
3212
3213         _sync_framerate = new BoolOption (
3214                      "timecode-sync-frame-rate",
3215                      _("Match session video frame rate to external timecode"),
3216                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_sync_frame_rate),
3217                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_sync_frame_rate)
3218                      );
3219         Gtkmm2ext::UI::instance()->set_tip
3220                 (_sync_framerate->tip_widget(),
3221                  string_compose (_("This option controls the value of the video frame rate <i>while chasing</i> an external timecode source.\n\n"
3222                                    "<b>When enabled</b> the session video frame rate will be changed to match that of the selected external timecode source.\n\n"
3223                                    "<b>When disabled</b> the session video frame rate will not be changed to match that of the selected external timecode source."
3224                                    "Instead the frame rate indication in the main clock will flash red and %1 will convert between the external "
3225                                    "timecode standard and the session standard."), PROGRAM_NAME));
3226
3227         add_option (_("Sync"), _sync_framerate);
3228
3229         add_option (_("Sync/LTC"), new OptionEditorHeading (_("Linear Timecode (LTC) Generator")));
3230
3231         add_option (_("Sync/LTC"),
3232                     new BoolOption (
3233                             "send-ltc",
3234                             _("Enable LTC generator"),
3235                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_ltc),
3236                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_ltc)
3237                             ));
3238
3239         _ltc_send_continuously = new BoolOption (
3240                             "ltc-send-continuously",
3241                             _("Send LTC while stopped"),
3242                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_ltc_send_continuously),
3243                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_ltc_send_continuously)
3244                             );
3245         Gtkmm2ext::UI::instance()->set_tip
3246                 (_ltc_send_continuously->tip_widget(),
3247                  string_compose (_("<b>When enabled</b> %1 will continue to send LTC information even when the transport (playhead) is not moving"), PROGRAM_NAME));
3248         add_option (_("Sync/LTC"), _ltc_send_continuously);
3249
3250         _ltc_volume_slider = new HSliderOption("ltcvol", _("LTC generator level [dBFS]"),
3251                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_ltc_output_volume),
3252                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_ltc_output_volume),
3253                                         -50, 0, .5, 5,
3254                                         .05, true);
3255
3256         Gtkmm2ext::UI::instance()->set_tip
3257                 (_ltc_volume_slider->tip_widget(),
3258                  _("Specify the Peak Volume of the generated LTC signal in dBFS. A good value is  0dBu ^= -18dBFS in an EBU calibrated system"));
3259
3260         add_option (_("Sync/LTC"), _ltc_volume_slider);
3261
3262
3263         add_option (_("Sync/MIDI"), new OptionEditorHeading (_("MIDI Beat Clock (Mclk) Generator")));
3264
3265         add_option (_("Sync/MIDI"),
3266                     new BoolOption (
3267                             "send-midi-clock",
3268                             _("Enable Mclk generator"),
3269                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_midi_clock),
3270                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_midi_clock)
3271                             ));
3272
3273         add_option (_("Sync/MIDI"), new OptionEditorHeading (_("MIDI Time Code (MTC) Generator")));
3274
3275         add_option (_("Sync/MIDI"),
3276                     new BoolOption (
3277                             "send-mtc",
3278                             _("Enable MTC Generator"),
3279                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_mtc),
3280                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_mtc)
3281                             ));
3282
3283         add_option (_("Sync/MIDI"),
3284                     new SpinOption<int> (
3285                             "mtc-qf-speed-tolerance",
3286                             _("Percentage either side of normal transport speed to transmit MTC"),
3287                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_mtc_qf_speed_tolerance),
3288                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_mtc_qf_speed_tolerance),
3289                             0, 20, 1, 5
3290                             ));
3291
3292         add_option (_("Sync/MIDI"), new OptionEditorHeading (_("MIDI Machine Control (MMC)")));
3293
3294         add_option (_("Sync/MIDI"),
3295                     new BoolOption (
3296                             "mmc-control",
3297                             _("Respond to MMC commands"),
3298                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_control),
3299                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_control)
3300                             ));
3301
3302         add_option (_("Sync/MIDI"),
3303                     new BoolOption (
3304                             "send-mmc",
3305                             _("Send MMC commands"),
3306                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_mmc),
3307                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_mmc)
3308                             ));
3309
3310         add_option (_("Sync/MIDI"),
3311              new SpinOption<uint8_t> (
3312                      "mmc-receive-device-id",
3313                      _("Inbound MMC device ID"),
3314                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_receive_device_id),
3315                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_receive_device_id),
3316                      0, 127, 1, 10
3317                      ));
3318
3319         add_option (_("Sync/MIDI"),
3320              new SpinOption<uint8_t> (
3321                      "mmc-send-device-id",
3322                      _("Outbound MMC device ID"),
3323                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_send_device_id),
3324                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_send_device_id),
3325                      0, 127, 1, 10
3326                      ));
3327
3328
3329         /* Control Surfaces */
3330
3331         add_option (_("Control Surfaces"), new OptionEditorHeading (_("Control Surfaces")));
3332         add_option (_("Control Surfaces"), new ControlSurfacesOptions ());
3333
3334         /* MIDI PORTs */
3335         add_option (_("MIDI Ports"), new OptionEditorHeading (_("MIDI Port Options")));
3336
3337         add_option (_("MIDI Ports"),
3338                     new BoolOption (
3339                             "midi-input-follows-selection",
3340                             _("MIDI input follows MIDI track selection"),
3341                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_input_follows_selection),
3342                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_input_follows_selection)
3343                             ));
3344
3345         add_option (_("MIDI Ports"), new MidiPortOptions ());
3346         add_option (_("MIDI Ports"), new OptionEditorBlank ());
3347
3348         /* PLUGINS */
3349
3350 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT || defined AUDIOUNIT_SUPPORT)
3351         add_option (_("Plugins"), new OptionEditorHeading (_("Scan/Discover")));
3352         add_option (_("Plugins"),
3353                         new RcActionButton (_("Scan for Plugins"),
3354                                 sigc::mem_fun (*this, &RCOptionEditor::plugin_scan_refresh)));
3355
3356 #endif
3357
3358         add_option (_("Plugins"), new OptionEditorHeading (_("General")));
3359
3360 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT || defined AUDIOUNIT_SUPPORT)
3361         bo = new BoolOption (
3362                         "show-plugin-scan-window",
3363                         _("Always Display Plugin Scan Progress"),
3364                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_plugin_scan_window),
3365                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_plugin_scan_window)
3366                         );
3367         add_option (_("Plugins"), bo);
3368         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3369                         _("<b>When enabled</b> a popup window showing plugin scan progress is displayed for indexing (cache load) and discovery (detect new plugins)"));
3370 #endif
3371
3372         bo = new BoolOption (
3373                 "plugins-stop-with-transport",
3374                 _("Silence plugins when the transport is stopped"),
3375                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugins_stop_with_transport),
3376                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_plugins_stop_with_transport)
3377                 );
3378         add_option (_("Plugins"), bo);
3379         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3380                                             _("<b>When enabled</b> plugins will be reset at transport stop. When disabled plugins will be left unchanged at transport stop.\n\nThis mostly affects plugins with a \"tail\" like Reverbs."));
3381
3382         bo = new BoolOption (
3383                 "new-plugins-active",
3384                         _("Make new plugins active"),
3385                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_new_plugins_active),
3386                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_new_plugins_active)
3387                         );
3388         add_option (_("Plugins"), bo);
3389         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3390                                             _("<b>When enabled</b> plugins will be activated when they are added to tracks/busses. When disabled plugins will be left inactive when they are added to tracks/busses"));
3391
3392         ComboOption<uint32_t>* lna = new ComboOption<uint32_t> (
3393                      "limit-n-automatables",
3394                      _("Limit automatable parameters per plugin"),
3395                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_limit_n_automatables),
3396                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_limit_n_automatables)
3397                      );
3398         lna->add (0, _("Unlimited"));
3399         lna->add (64,  _("64 parameters"));
3400         lna->add (128, _("128 parameters"));
3401         lna->add (256, _("256 parameters"));
3402         lna->add (512, _("512 parameters"));
3403         lna->add (999, _("999 parameters"));
3404         add_option (_("Plugins"), lna);
3405         Gtkmm2ext::UI::instance()->set_tip (lna->tip_widget(),
3406                                             _("Some Plugins expose an unreasonable amount of control-inputs. This option limits the number of parameters that can are listed as automatable without restricting the number of total controls.\n\nThis reduces lag in the GUI and shortens excessively long drop-down lists for plugins with a large number of control ports.\n\nNote: This only affects newly added plugins and is applied to plugin on session-reload. Already automated parameters are retained."));
3407
3408
3409 #if (defined WINDOWS_VST_SUPPORT || defined MACVST_SUPPORT || defined LXVST_SUPPORT)
3410         add_option (_("Plugins/VST"), new OptionEditorHeading (_("VST")));
3411 #if 0
3412         add_option (_("Plugins/VST"),
3413                         new RcActionButton (_("Scan for Plugins"),
3414                                 sigc::mem_fun (*this, &RCOptionEditor::plugin_scan_refresh)));
3415 #endif
3416
3417 #if (defined AUDIOUNIT_SUPPORT && defined MACVST_SUPPORT)
3418         bo = new BoolOption (
3419                         "",
3420                         _("Enable Mac VST support (requires restart or re-scan)"),
3421                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_use_macvst),
3422                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_use_macvst)
3423                         );
3424         add_option (_("Plugins/VST"), bo);
3425 #endif
3426
3427         bo = new BoolOption (
3428                         "discover-vst-on-start",
3429                         _("Scan for [new] VST Plugins on Application Start"),
3430                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_discover_vst_on_start),
3431                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_discover_vst_on_start)
3432                         );
3433         add_option (_("Plugins/VST"), bo);
3434         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3435                                             _("<b>When enabled</b> new VST plugins are searched, tested and added to the cache index on application start. When disabled new plugins will only be available after triggering a 'Scan' manually"));
3436
3437 #ifdef WINDOWS_VST_SUPPORT
3438         // currently verbose logging is only implemented for Windows VST.
3439         bo = new BoolOption (
3440                         "verbose-plugin-scan",
3441                         _("Verbose Plugin Scan"),
3442                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_verbose_plugin_scan),
3443                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_verbose_plugin_scan)
3444                         );
3445         add_option (_("Plugins/VST"), bo);
3446         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3447                                             _("<b>When enabled</b> additional information for every plugin is added to the Log Window."));
3448 #endif
3449
3450         add_option (_("Plugins/VST"), new VstTimeOutSliderOption (_rc_config));
3451
3452         add_option (_("Plugins/VST"),
3453                         new RcActionButton (_("Clear"),
3454                                 sigc::mem_fun (*this, &RCOptionEditor::clear_vst_cache),
3455                                 _("VST Cache:")));
3456
3457         add_option (_("Plugins/VST"),
3458                         new RcActionButton (_("Clear"),
3459                                 sigc::mem_fun (*this, &RCOptionEditor::clear_vst_blacklist),
3460                                 _("VST Blacklist:")));
3461 #endif
3462
3463 #ifdef LXVST_SUPPORT
3464         add_option (_("Plugins/VST"),
3465                         new RcActionButton (_("Edit"),
3466                                 sigc::mem_fun (*this, &RCOptionEditor::edit_lxvst_path),
3467                         _("Linux VST Path:")));
3468
3469         add_option (_("Plugins/VST"),
3470                         new RcConfigDisplay (
3471                                 "plugin-path-lxvst",
3472                                 _("Path:"),
3473                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugin_path_lxvst),
3474                                 0));
3475 #endif
3476
3477 #ifdef WINDOWS_VST_SUPPORT
3478         add_option (_("Plugins/VST"),
3479                         new RcActionButton (_("Edit"),
3480                                 sigc::mem_fun (*this, &RCOptionEditor::edit_vst_path),
3481                         _("Windows VST Path:")));
3482         add_option (_("Plugins/VST"),
3483                         new RcConfigDisplay (
3484                                 "plugin-path-vst",
3485                                 _("Path:"),
3486                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugin_path_vst),
3487                                 ';'));
3488 #endif
3489
3490 #ifdef AUDIOUNIT_SUPPORT
3491
3492         add_option (_("Plugins/Audio Unit"), new OptionEditorHeading (_("Audio Unit")));
3493 #if 0
3494         add_option (_("Plugins/Audio Unit"),
3495                         new RcActionButton (_("Scan for Plugins"),
3496                                 sigc::mem_fun (*this, &RCOptionEditor::plugin_scan_refresh)));
3497 #endif
3498
3499         bo = new BoolOption (
3500                         "discover-audio-units",
3501                         _("Scan for [new] AudioUnit Plugins on Application Start"),
3502                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_discover_audio_units),
3503                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_discover_audio_units)
3504                         );
3505         add_option (_("Plugins/Audio Unit"), bo);
3506         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3507                                             _("<b>When enabled</b> Audio Unit Plugins are discovered on application start. When disabled AU plugins will only be available after triggering a 'Scan' manually. The first successful scan will enable AU auto-scan, Any crash during plugin discovery will disable it."));
3508
3509         add_option (_("Plugins/Audio Unit"),
3510                         new RcActionButton (_("Clear"),
3511                                 sigc::mem_fun (*this, &RCOptionEditor::clear_au_cache),
3512                                 _("AU Cache:")));
3513
3514         add_option (_("Plugins/Audio Unit"),
3515                         new RcActionButton (_("Clear"),
3516                                 sigc::mem_fun (*this, &RCOptionEditor::clear_au_blacklist),
3517                                 _("AU Blacklist:")));
3518 #endif
3519
3520 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT || defined AUDIOUNIT_SUPPORT || defined HAVE_LV2)
3521         add_option (_("Plugins"), new OptionEditorHeading (_("Plugin GUI")));
3522         add_option (_("Plugins"),
3523              new BoolOption (
3524                      "open-gui-after-adding-plugin",
3525                      _("Automatically open the plugin GUI when adding a new plugin"),
3526                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_open_gui_after_adding_plugin),
3527                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_open_gui_after_adding_plugin)
3528                      ));
3529
3530 #if (defined LV2_SUPPORT && defined LV2_EXTENDED)
3531         add_option (_("Plugins"),
3532              new BoolOption (
3533                      "show-inline-display-by-default",
3534                      _("Show Plugin Inline Display on Mixerstrip by default"),
3535                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_inline_display_by_default),
3536                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_inline_display_by_default)
3537                      ));
3538
3539         _plugin_prefer_inline = new BoolOption (
3540                         "prefer-inline-over-gui",
3541                         _("Don't automatically open the plugin GUI when the plugin has an inline display mode"),
3542                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_prefer_inline_over_gui),
3543                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_prefer_inline_over_gui)
3544                         );
3545         add_option (_("Plugins"), _plugin_prefer_inline);
3546 #endif
3547
3548         add_option (_("Plugins"), new OptionEditorHeading (_("Instrument")));
3549
3550         bo = new BoolOption (
3551                         "ask-replace-instrument",
3552                         _("Ask to replace existing instrument plugin"),
3553                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_ask_replace_instrument),
3554                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_ask_replace_instrument)
3555                         );
3556         add_option (_("Plugins"), bo);
3557
3558         bo = new BoolOption (
3559                         "ask-setup_instrument",
3560                         _("Interactively configure instrument plugins on insert"),
3561                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_ask_setup_instrument),
3562                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_ask_setup_instrument)
3563                         );
3564         add_option (_("Plugins"), bo);
3565         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3566                         _("<b>When enabled</b> show a dialog to select instrument channel configuration before adding a multichannel plugin."));
3567
3568 #endif
3569         add_option (_("Plugins"), new OptionEditorBlank ());
3570
3571         /* INTERFACE */
3572 #if (defined OPTIONAL_CAIRO_IMAGE_SURFACE || defined CAIRO_SUPPORTS_FORCE_BUGGY_GRADIENTS_ENVIRONMENT_VARIABLE)
3573         add_option (_("Appearance"), new OptionEditorHeading (_("Graphics Acceleration")));
3574 #endif
3575
3576 #ifdef OPTIONAL_CAIRO_IMAGE_SURFACE
3577         BoolOption* bgc = new BoolOption (
3578                 "cairo-image-surface",
3579                 _("Disable Graphics Hardware Acceleration (requires restart)"),
3580                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_cairo_image_surface),
3581                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_cairo_image_surface)
3582                 );
3583
3584         Gtkmm2ext::UI::instance()->set_tip (bgc->tip_widget(), string_compose (
3585                                 _("Render large parts of the application user-interface in software, instead of using 2D-graphics acceleration.\nThis requires restarting %1 before having an effect"), PROGRAM_NAME));
3586         add_option (_("Appearance"), bgc);
3587 #endif
3588
3589 #ifdef CAIRO_SUPPORTS_FORCE_BUGGY_GRADIENTS_ENVIRONMENT_VARIABLE
3590         BoolOption* bgo = new BoolOption (
3591                 "buggy-gradients",
3592                 _("Possibly improve slow graphical performance (requires restart)"),
3593                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_buggy_gradients),
3594                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_buggy_gradients)
3595                 );
3596
3597         Gtkmm2ext::UI::instance()->set_tip (bgo->tip_widget(), string_compose (_("Disables hardware gradient rendering on buggy video drivers (\"buggy gradients patch\").\nThis requires restarting %1 before having an effect"), PROGRAM_NAME));
3598         add_option (_("Appearance"), bgo);
3599 #endif
3600         add_option (_("Appearance"), new OptionEditorHeading (_("Graphical User Interface")));
3601
3602         add_option (_("Appearance"),
3603              new BoolOption (
3604                      "widget-prelight",
3605                      _("Highlight widgets on mouseover"),
3606                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_widget_prelight),
3607                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_widget_prelight)
3608                      ));
3609
3610         add_option (_("Appearance"),
3611              new BoolOption (
3612                      "use-tooltips",
3613                      _("Show tooltips if mouse hovers over a control"),
3614                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_tooltips),
3615                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_tooltips)
3616                      ));
3617
3618         bo = new BoolOption (
3619                         "super-rapid-clock-update",
3620                         _("Update clocks at TC Frame rate"),
3621                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_super_rapid_clock_update),
3622                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_super_rapid_clock_update)
3623                         );
3624         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3625                         _("<b>When enabled</b> clock displays are updated every Timecode Frame (fps).\n\n"
3626                                 "<b>When disabled</b> clock displays are updated only every 100ms."
3627                          ));
3628         add_option (_("Appearance"), bo);
3629
3630         add_option (_("Appearance"),
3631                         new BoolOption (
3632                                 "blink-rec-arm",
3633                                 _("Blink Rec-Arm buttons"),
3634                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_blink_rec_arm),
3635                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_blink_rec_arm)
3636                                 ));
3637
3638         add_option (_("Appearance"),
3639                         new BoolOption (
3640                                 "blink-alert-indicators",
3641                                 _("Blink Alert Indicators"),
3642                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_blink_alert_indicators),
3643                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_blink_alert_indicators)
3644                                 ));
3645
3646
3647 #ifndef __APPLE__
3648         /* font scaling does nothing with GDK/Quartz */
3649         add_option (_("Appearance"), new FontScalingOptions ());
3650 #endif
3651         add_option (_("Appearance/Editor"), new OptionEditorHeading (_("General")));
3652         add_option (_("Appearance/Editor"),
3653              new BoolOption (
3654                      "show-name-highlight",
3655                      _("Use name highlight bars in region displays (requires a restart)"),
3656                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_name_highlight),
3657                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_name_highlight)
3658                      ));
3659
3660         add_option (_("Appearance/Editor"),
3661                         new BoolOption (
3662                         "color-regions-using-track-color",
3663                         _("Region color follows track color"),
3664                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_color_regions_using_track_color),
3665                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_color_regions_using_track_color)
3666                         ));
3667
3668         add_option (_("Appearance/Editor"), new OptionEditorHeading (_("Waveforms")));
3669
3670         if (!Profile->get_mixbus()) {
3671                 add_option (_("Appearance/Editor"),
3672                                 new BoolOption (
3673                                         "show-waveforms",
3674                                         _("Show waveforms in regions"),
3675                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_waveforms),
3676                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_waveforms)
3677                                         ));
3678         }  // !mixbus
3679
3680         add_option (_("Appearance/Editor"),
3681              new BoolOption (
3682                      "show-waveforms-while-recording",
3683                      _("Show waveforms while recording"),
3684                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_waveforms_while_recording),
3685                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_waveforms_while_recording)
3686                      ));
3687
3688         add_option (_("Appearance/Editor"),
3689                         new BoolOption (
3690                         "show-waveform-clipping",
3691                         _("Show waveform clipping"),
3692                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_waveform_clipping),
3693                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_waveform_clipping)
3694                         ));
3695
3696         add_option (_("Appearance/Editor"), new ClipLevelOptions ());
3697
3698         ComboOption<WaveformScale>* wfs = new ComboOption<WaveformScale> (
3699                 "waveform-scale",
3700                 _("Waveform scale"),
3701                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_scale),
3702                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_scale)
3703                 );
3704
3705         wfs->add (Linear, _("linear"));
3706         wfs->add (Logarithmic, _("logarithmic"));
3707
3708         add_option (_("Appearance/Editor"), wfs);
3709
3710         ComboOption<WaveformShape>* wfsh = new ComboOption<WaveformShape> (
3711                 "waveform-shape",
3712                 _("Waveform shape"),
3713                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_shape),
3714                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_shape)
3715                 );
3716
3717         wfsh->add (Traditional, _("traditional"));
3718         wfsh->add (Rectified, _("rectified"));
3719
3720         add_option (_("Appearance/Editor"), wfsh);
3721
3722         add_option (_("Appearance/Editor"), new OptionEditorHeading (_("Editor Meters")));
3723
3724         add_option (_("Appearance/Editor"),
3725              new BoolOption (
3726                      "show-track-meters",
3727                      _("Show meters in track headers"),
3728                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_track_meters),
3729                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_track_meters)
3730                      ));
3731
3732         add_option (_("Appearance/Editor"),
3733              new BoolOption (
3734                      "editor-stereo-only-meters",
3735                      _("Limit track header meters to stereo"),
3736                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_editor_stereo_only_meters),
3737                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_editor_stereo_only_meters)
3738                      ));
3739
3740         add_option (_("Appearance/Editor"), new OptionEditorHeading (_("MIDI Regions")));
3741
3742         add_option (_("Appearance/Editor"),
3743                     new BoolOption (
3744                             "display-first-midi-bank-as-zero",
3745                             _("Display first MIDI bank/program as 0"),
3746                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_first_midi_bank_is_zero),
3747                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_first_midi_bank_is_zero)
3748                             ));
3749
3750         add_option (_("Appearance/Editor"),
3751              new BoolOption (
3752                      "never-display-periodic-midi",
3753                      _("Don't display periodic (MTC, MMC) SysEx messages in MIDI Regions"),
3754                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_never_display_periodic_midi),
3755                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_never_display_periodic_midi)
3756                      ));
3757
3758
3759         add_option (_("Appearance/Editor"),
3760                     new BoolOption (
3761                             "use-note-bars-for-velocity",
3762                             _("Show velocity horizontally inside notes"),
3763                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_note_bars_for_velocity),
3764                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_note_bars_for_velocity)
3765                             ));
3766
3767         add_option (_("Appearance/Editor"),
3768                     new BoolOption (
3769                             "use-note-color-for-velocity",
3770                             _("Use colors to show note velocity"),
3771                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_note_color_for_velocity),
3772                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_note_color_for_velocity)
3773                             ));
3774
3775         add_option (_("Appearance/Editor"), new OptionEditorBlank ());
3776
3777         /* The names of these controls must be the same as those given in MixerStrip
3778            for the actual widgets being controlled.
3779         */
3780         _mixer_strip_visibility.add (0, X_("Input"), _("Input"));
3781         _mixer_strip_visibility.add (0, X_("PhaseInvert"), _("Phase Invert"));
3782         _mixer_strip_visibility.add (0, X_("RecMon"), _("Record & Monitor"));
3783         _mixer_strip_visibility.add (0, X_("SoloIsoLock"), _("Solo Iso / Lock"));
3784         _mixer_strip_visibility.add (0, X_("Output"), _("Output"));
3785         _mixer_strip_visibility.add (0, X_("Comments"), _("Comments"));
3786         _mixer_strip_visibility.add (0, X_("VCA"), _("VCA Assigns"));
3787
3788         add_option (_("Appearance/Mixer"),
3789                 new VisibilityOption (
3790                         _("Mixer Strip"),
3791                         &_mixer_strip_visibility,
3792                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_mixer_strip_visibility),
3793                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_mixer_strip_visibility)
3794                         )
3795                 );
3796
3797         add_option (_("Appearance/Mixer"),
3798              new BoolOption (
3799                      "default-narrow_ms",
3800                      _("Use narrow strips in the mixer for new strips by default"),
3801                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_default_narrow_ms),
3802                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_default_narrow_ms)
3803                      ));
3804
3805         ComboOption<uint32_t>* mic = new ComboOption<uint32_t> (
3806                      "max-inline-controls",
3807                      _("Limit inline-mixer-strip controls per plugin"),
3808                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_max_inline_controls),
3809                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_max_inline_controls)
3810                      );
3811         mic->add (0, _("Unlimited"));
3812         mic->add (16,  _("16 parameters"));
3813         mic->add (32,  _("32 parameters"));
3814         mic->add (64,  _("64 parameters"));
3815         mic->add (128, _("128 parameters"));
3816         add_option (_("Appearance/Mixer"), mic);
3817
3818         add_option (_("Appearance/Mixer"), new OptionEditorBlank ());
3819
3820         add_option (_("Appearance/Toolbar"), new OptionEditorHeading (_("Main Transport Toolbar Items")));
3821
3822         add_option (_("Appearance/Toolbar"),
3823              new BoolOption (
3824                      "show-toolbar-recpunch",
3825                      _("Display Record/Punch Options"),
3826                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_toolbar_recpunch),
3827                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_toolbar_recpunch)
3828                      ));
3829
3830         add_option (_("Appearance/Toolbar"),
3831              new BoolOption (
3832                      "show-toolbar-monitoring",
3833                      _("Display Monitor Options"),
3834                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_toolbar_monitoring),
3835                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_toolbar_monitoring)
3836                      ));
3837
3838         add_option (_("Appearance/Toolbar"),
3839              new BoolOption (
3840                      "show-toolbar-selclock",
3841                      _("Display Selection Clock"),
3842                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_toolbar_selclock),
3843                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_toolbar_selclock)
3844                      ));
3845
3846         if (!ARDOUR::Profile->get_small_screen()) {
3847                 add_option (_("Appearance/Toolbar"),
3848                                 new BoolOption (
3849                                         "show-secondary-clock",
3850                                         _("Display Secondary Clock"),
3851                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_secondary_clock),
3852                                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_secondary_clock)
3853                                         ));
3854         }
3855
3856         add_option (_("Appearance/Toolbar"),
3857              new BoolOption (
3858                      "show-mini-timeline",
3859                      _("Display Navigation Timeline"),
3860                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_mini_timeline),
3861                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_mini_timeline)
3862                      ));
3863
3864         add_option (_("Appearance/Toolbar"),
3865              new BoolOption (
3866                      "show-editor-meter",
3867                      _("Display Master Level Meter"),
3868                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_editor_meter),
3869                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_editor_meter)
3870                      ));
3871
3872         add_option (_("Appearance/Toolbar"),
3873                         new ColumVisibilityOption (
3874                                 "action-table-columns", _("Display Action-Buttons"), 4,
3875                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_action_table_columns),
3876                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_action_table_columns)
3877                                 )
3878                         );
3879         add_option (_("Appearance/Toolbar"), new OptionEditorBlank ());
3880
3881
3882         /* and now the theme manager */
3883
3884         add_option (_("Appearance/Theme"), new OptionEditorHeading (_("Theme")));
3885
3886         add_option (_("Appearance/Theme"), new BoolOption (
3887                                 "flat-buttons",
3888                                 _("Draw \"flat\" buttons"),
3889                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_flat_buttons),
3890                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_flat_buttons)
3891                                 ));
3892
3893         add_option (_("Appearance/Theme"), new BoolOption (
3894                                 "boxy-buttons",
3895                                 _("Draw \"boxy\" buttons"),
3896                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_boxy_buttons),
3897                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_boxy_buttons)
3898                                 ));
3899
3900         add_option (_("Appearance/Theme"), new BoolOption (
3901                                 "meter-style-led",
3902                                 _("LED meter style"),
3903                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_style_led),
3904                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_style_led)
3905                                 ));
3906
3907
3908         HSliderOption *gui_hs = new HSliderOption(
3909                         "timeline-item-gradient-depth",
3910                         _("Waveforms color gradient depth"),
3911                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_gradient_depth),
3912                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_gradient_depth),
3913                         0, 1.0, 0.05
3914                         );
3915         gui_hs->scale().set_update_policy (Gtk::UPDATE_DELAYED);
3916         add_option (_("Appearance/Theme"), gui_hs);
3917
3918         gui_hs = new HSliderOption(
3919                         "timeline-item-gradient-depth",
3920                         _("Timeline item gradient depth"),
3921                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_timeline_item_gradient_depth),
3922                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_timeline_item_gradient_depth),
3923                         0, 1.0, 0.05
3924                         );
3925         gui_hs->scale().set_update_policy (Gtk::UPDATE_DELAYED);
3926         add_option (_("Appearance/Theme"), gui_hs);
3927
3928         vector<string> icon_sets = ::get_icon_sets ();
3929         if (icon_sets.size() > 1) {
3930                 ComboOption<std::string>* io = new ComboOption<std::string> (
3931                                 "icon-set", _("Icon Set"),
3932                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_icon_set),
3933                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_icon_set)
3934                                 );
3935                 for (vector<string>::const_iterator i = icon_sets.begin (); i != icon_sets.end (); ++i) {
3936                         io->add (*i, *i);
3937                 }
3938                 add_option (_("Appearance/Theme"), io);
3939         }
3940
3941         add_option (_("Appearance/Colors"), new OptionEditorHeading (_("Colors")));
3942         add_option (_("Appearance/Colors"), new ColorThemeManager);
3943         add_option (_("Appearance/Colors"), new OptionEditorBlank ());
3944
3945         /* Quirks */
3946
3947         OptionEditorHeading* quirks_head = new OptionEditorHeading (_("Various Workarounds for Windowing Systems"));
3948
3949         quirks_head->set_note (string_compose (_("Rules for closing, minimizing, maximizing, and stay-on-top can vary \
3950 with each version of your OS, and the preferences that you've set in your OS.\n\n\
3951 You can adjust the options, below, to change how %1's windows and dialogs behave.\n\n\
3952 These settings will only take effect after %1 is restarted.\n\
3953         "), PROGRAM_NAME));
3954
3955         add_option (_("Appearance/Quirks"), quirks_head);
3956
3957         bo = new BoolOption (
3958                      "use-wm-visibility",
3959                      _("Use visibility information provided by your Window Manager/Desktop"),
3960                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_wm_visibility),
3961                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_wm_visibility)
3962                      );
3963         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget (),
3964                                 _("If you have trouble toggling between hidden Editor and Mixer windows, try changing this setting."));
3965         add_option (_("Appearance/Quirks"), bo);
3966
3967 #ifndef __APPLE__
3968         bo = new BoolOption (
3969                         "all-floating-windows-are-dialogs",
3970                         _("All floating windows are dialogs"),
3971                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_all_floating_windows_are_dialogs),
3972                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_all_floating_windows_are_dialogs)
3973                         );
3974         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget (),
3975                         _("Mark all floating windows to be type \"Dialog\" rather than using \"Utility\" for some.\nThis may help with some window managers."));
3976         add_option (_("Appearance/Quirks"), bo);
3977
3978         bo = new BoolOption (
3979                         "transients-follow-front",
3980                         _("Transient windows follow front window."),
3981                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_transients_follow_front),
3982                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_transients_follow_front)
3983                         );
3984         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget (),
3985                                 _("Make transient windows follow the front window when toggling between the editor and mixer."));
3986         add_option (_("Appearance/Quirks"), bo);
3987 #endif
3988
3989         if (!Profile->get_mixbus()) {
3990                 bo = new BoolOption (
3991                                 "floating-monitor-section",
3992                                 _("Float detached monitor-section window"),
3993                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_floating_monitor_section),
3994                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_floating_monitor_section)
3995                                 );
3996                 Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget (),
3997                                         _("When detaching the monitoring section, mark it as \"Utility\" window to stay in front."));
3998                 add_option (_("Appearance/Quirks"), bo);
3999         }
4000
4001         add_option (_("Appearance/Quirks"), new OptionEditorBlank ());
4002
4003         /* VIDEO Timeline */
4004         add_option (_("Video"), new OptionEditorHeading (_("Video Server")));
4005         add_option (_("Video"), new VideoTimelineOptions (_rc_config));
4006
4007         Widget::show_all ();
4008
4009         //trigger some parameter-changed messages which affect widget-visibility or -sensitivity
4010         parameter_changed ("send-ltc");
4011         parameter_changed ("sync-source");
4012         parameter_changed ("use-monitor-bus");
4013         parameter_changed ("open-gui-after-adding-plugin");
4014
4015         XMLNode* node = ARDOUR_UI::instance()->preferences_settings();
4016         if (node) {
4017                 /* gcc4 complains about ambiguity with Gtk::Widget::set_state
4018                    (Gtk::StateType) here !!!
4019                 */
4020                 Tabbable::set_state (*node, Stateful::loading_state_version);
4021         }
4022
4023         set_current_page (_("General"));
4024 }
4025
4026 void
4027 RCOptionEditor::set_session (Session *s)
4028 {
4029         SessionHandlePtr::set_session (s);
4030         _transport_masters_widget.set_session (s);
4031 }
4032
4033 void
4034 RCOptionEditor::parameter_changed (string const & p)
4035 {
4036         OptionEditor::parameter_changed (p);
4037
4038         if (p == "use-monitor-bus") {
4039                 bool const s = Config->get_use_monitor_bus ();
4040                 if (!s) {
4041                         /* we can't use this if we don't have a monitor bus */
4042                         Config->set_solo_control_is_listen_control (false);
4043                 }
4044                 _solo_control_is_listen_control->set_sensitive (s);
4045                 _listen_position->set_sensitive (s);
4046         } else if (p == "sync-source") {
4047                 boost::shared_ptr<TransportMaster> tm (TransportMasterManager::instance().current());
4048                 if (boost::dynamic_pointer_cast<TimecodeTransportMaster> (tm)) {
4049                         _sync_framerate->set_sensitive (true);
4050                 } else {
4051                         _sync_framerate->set_sensitive (false);
4052                 }
4053         } else if (p == "send-ltc") {
4054                 bool const s = Config->get_send_ltc ();
4055                 _ltc_send_continuously->set_sensitive (s);
4056                 _ltc_volume_slider->set_sensitive (s);
4057         } else if (p == "open-gui-after-adding-plugin" || p == "show-inline-display-by-default") {
4058 #if (defined LV2_SUPPORT && defined LV2_EXTENDED)
4059                 _plugin_prefer_inline->set_sensitive (UIConfiguration::instance().get_open_gui_after_adding_plugin() && UIConfiguration::instance().get_show_inline_display_by_default());
4060 #endif
4061         }
4062 }
4063
4064 void RCOptionEditor::plugin_scan_refresh () {
4065         PluginManager::instance().refresh();
4066 }
4067
4068 void RCOptionEditor::clear_vst_cache () {
4069         PluginManager::instance().clear_vst_cache();
4070 }
4071
4072 void RCOptionEditor::clear_vst_blacklist () {
4073         PluginManager::instance().clear_vst_blacklist();
4074 }
4075
4076 void RCOptionEditor::clear_au_cache () {
4077         PluginManager::instance().clear_au_cache();
4078 }
4079
4080 void RCOptionEditor::clear_au_blacklist () {
4081         PluginManager::instance().clear_au_blacklist();
4082 }
4083
4084 void RCOptionEditor::edit_lxvst_path () {
4085         Glib::RefPtr<Gdk::Window> win = get_parent_window ();
4086         PathsDialog *pd = new PathsDialog (
4087                 *current_toplevel(), _("Set Linux VST Search Path"),
4088                 _rc_config->get_plugin_path_lxvst(),
4089                 PluginManager::instance().get_default_lxvst_path()
4090                 );
4091         ResponseType r = (ResponseType) pd->run ();
4092         pd->hide();
4093         if (r == RESPONSE_ACCEPT) {
4094                 _rc_config->set_plugin_path_lxvst(pd->get_serialized_paths());
4095
4096                 MessageDialog msg (_("Re-scan Plugins now?"),
4097                                 false /*no markup*/, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_YES_NO, true /*modal*/);
4098                 msg.set_default_response (Gtk::RESPONSE_YES);
4099                 if (msg.run() == Gtk::RESPONSE_YES) {
4100                         msg.hide ();
4101                         plugin_scan_refresh ();
4102                 }
4103         }
4104         delete pd;
4105 }
4106
4107 void RCOptionEditor::edit_vst_path () {
4108         PathsDialog *pd = new PathsDialog (
4109                 *current_toplevel(), _("Set Windows VST Search Path"),
4110                 _rc_config->get_plugin_path_vst(),
4111                 PluginManager::instance().get_default_windows_vst_path()
4112                 );
4113         ResponseType r = (ResponseType) pd->run ();
4114         pd->hide();
4115         if (r == RESPONSE_ACCEPT) {
4116                 _rc_config->set_plugin_path_vst(pd->get_serialized_paths());
4117                 MessageDialog msg (_("Re-scan Plugins now?"),
4118                                 false /*no markup*/, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_YES_NO, true /*modal*/);
4119                 msg.set_default_response (Gtk::RESPONSE_YES);
4120                 if (msg.run() == Gtk::RESPONSE_YES) {
4121                         msg.hide ();
4122                         plugin_scan_refresh ();
4123                 }
4124         }
4125         delete pd;
4126 }
4127
4128 Gtk::Window*
4129 RCOptionEditor::use_own_window (bool and_fill_it)
4130 {
4131         bool new_window = !own_window ();
4132
4133         Gtk::Window* win = Tabbable::use_own_window (and_fill_it);
4134
4135         if (win && new_window) {
4136                 win->set_name ("PreferencesWindow");
4137                 ARDOUR_UI::instance()->setup_toplevel_window (*win, _("Preferences"), this);
4138                 win->resize (1, 1);
4139                 win->set_resizable (false);
4140         }
4141
4142         return win;
4143 }
4144
4145 XMLNode&
4146 RCOptionEditor::get_state ()
4147 {
4148         XMLNode* node = new XMLNode (X_("Preferences"));
4149         node->add_child_nocopy (Tabbable::get_state());
4150         return *node;
4151 }