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