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
1887                 AudioEngine::instance()->PortRegisteredOrUnregistered.connect (connections,
1888                                                                                invalidator (*this),
1889                                                                                boost::bind (&MidiPortOptions::refill, this),
1890                                                                                gui_context());
1891                 AudioEngine::instance()->MidiPortInfoChanged.connect (connections,
1892                                                                       invalidator (*this),
1893                                                                       boost::bind (&MidiPortOptions::refill, this),
1894                                                                       gui_context());
1895                 AudioEngine::instance()->MidiSelectionPortsChanged.connect (connections,
1896                                                                             invalidator (*this),
1897                                                                             boost::bind (&MidiPortOptions::refill, this),
1898                                                                             gui_context());
1899         }
1900
1901         void refill () {
1902
1903                 if (refill_midi_ports (true, midi_input_view)) {
1904                         input_label.show ();
1905                 } else {
1906                        input_label.hide ();
1907                 }
1908                 if (refill_midi_ports (false, midi_output_view)) {
1909                         output_label.show ();
1910                 } else {
1911                         output_label.hide ();
1912                 }
1913         }
1914
1915   private:
1916         PBD::ScopedConnectionList connections;
1917
1918         /* MIDI port management */
1919         struct MidiPortColumns : public Gtk::TreeModel::ColumnRecord {
1920
1921                 MidiPortColumns () {
1922                         add (pretty_name);
1923                         add (music_data);
1924                         add (control_data);
1925                         add (selection);
1926                         add (name);
1927                         add (filler);
1928                 }
1929
1930                 Gtk::TreeModelColumn<std::string> pretty_name;
1931                 Gtk::TreeModelColumn<bool> music_data;
1932                 Gtk::TreeModelColumn<bool> control_data;
1933                 Gtk::TreeModelColumn<bool> selection;
1934                 Gtk::TreeModelColumn<std::string> name;
1935                 Gtk::TreeModelColumn<std::string> filler;
1936         };
1937
1938         MidiPortColumns midi_port_columns;
1939         Gtk::TreeView midi_input_view;
1940         Gtk::TreeView midi_output_view;
1941         Gtk::Label input_label;
1942         Gtk::Label output_label;
1943
1944         void setup_midi_port_view (Gtk::TreeView&, bool with_selection);
1945         bool refill_midi_ports (bool for_input, Gtk::TreeView&);
1946         void pretty_name_edit (std::string const & path, std::string const & new_text, Gtk::TreeView*);
1947         void midi_music_column_toggled (std::string const & path, Gtk::TreeView*);
1948         void midi_control_column_toggled (std::string const & path, Gtk::TreeView*);
1949         void midi_selection_column_toggled (std::string const & path, Gtk::TreeView*);
1950 };
1951
1952 void
1953 MidiPortOptions::setup_midi_port_view (Gtk::TreeView& view, bool with_selection)
1954 {
1955         int pretty_name_column;
1956         int music_column;
1957         int control_column;
1958         int selection_column;
1959         TreeViewColumn* col;
1960         Gtk::Label* l;
1961
1962         pretty_name_column = view.append_column_editable (_("Name (click to edit)"), midi_port_columns.pretty_name) - 1;
1963
1964         col = manage (new TreeViewColumn ("", midi_port_columns.music_data));
1965         col->set_alignment (ALIGN_CENTER);
1966         l = manage (new Label (_("Music Data")));
1967         set_tooltip (*l, string_compose (_("If ticked, %1 will consider this port to be a source of music performance data."), PROGRAM_NAME));
1968         col->set_widget (*l);
1969         l->show ();
1970         music_column = view.append_column (*col) - 1;
1971
1972         col = manage (new TreeViewColumn ("", midi_port_columns.control_data));
1973         col->set_alignment (ALIGN_CENTER);
1974         l = manage (new Label (_("Control Data")));
1975         set_tooltip (*l, string_compose (_("If ticked, %1 will consider this port to be a source of control data."), PROGRAM_NAME));
1976         col->set_widget (*l);
1977         l->show ();
1978         control_column = view.append_column (*col) - 1;
1979
1980         if (with_selection) {
1981                 col = manage (new TreeViewColumn (_("Follow Selection"), midi_port_columns.selection));
1982                 selection_column = view.append_column (*col) - 1;
1983                 l = manage (new Label (_("Follow Selection")));
1984                 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));
1985                 col->set_widget (*l);
1986                 l->show ();
1987         }
1988
1989         /* filler column so that the last real column doesn't expand */
1990         view.append_column ("", midi_port_columns.filler);
1991
1992         CellRendererText* pretty_name_cell = dynamic_cast<CellRendererText*> (view.get_column_cell_renderer (pretty_name_column));
1993         pretty_name_cell->property_editable() = true;
1994         pretty_name_cell->signal_edited().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::pretty_name_edit), &view));
1995
1996         CellRendererToggle* toggle_cell;
1997
1998         toggle_cell = dynamic_cast<CellRendererToggle*> (view.get_column_cell_renderer (music_column));
1999         toggle_cell->property_activatable() = true;
2000         toggle_cell->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::midi_music_column_toggled), &view));
2001
2002         toggle_cell = dynamic_cast<CellRendererToggle*> (view.get_column_cell_renderer (control_column));
2003         toggle_cell->property_activatable() = true;
2004         toggle_cell->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::midi_control_column_toggled), &view));
2005
2006         if (with_selection) {
2007                 toggle_cell = dynamic_cast<CellRendererToggle*> (view.get_column_cell_renderer (selection_column));
2008                 toggle_cell->property_activatable() = true;
2009                 toggle_cell->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiPortOptions::midi_selection_column_toggled), &view));
2010         }
2011
2012         view.get_selection()->set_mode (SELECTION_NONE);
2013         view.set_tooltip_column (4); /* port "real" name */
2014 }
2015
2016 bool
2017 MidiPortOptions::refill_midi_ports (bool for_input, Gtk::TreeView& view)
2018 {
2019         using namespace ARDOUR;
2020
2021         std::vector<string> ports;
2022
2023         AudioEngine::instance()->get_known_midi_ports (ports);
2024
2025         if (ports.empty()) {
2026                 view.hide ();
2027                 return false;
2028         }
2029
2030         Glib::RefPtr<ListStore> model = Gtk::ListStore::create (midi_port_columns);
2031
2032         for (vector<string>::const_iterator s = ports.begin(); s != ports.end(); ++s) {
2033
2034                 if (AudioEngine::instance()->port_is_mine (*s)) {
2035                         continue;
2036                 }
2037
2038                 PortManager::MidiPortInformation mpi (AudioEngine::instance()->midi_port_information (*s));
2039
2040                 if (mpi.pretty_name.empty()) {
2041                         /* vanished since get_known_midi_ports() */
2042                         continue;
2043                 }
2044
2045                 if (for_input != mpi.input) {
2046                         continue;
2047                 }
2048
2049                 TreeModel::Row row = *(model->append());
2050
2051                 row[midi_port_columns.pretty_name] = mpi.pretty_name;
2052                 row[midi_port_columns.music_data] = mpi.properties & MidiPortMusic;
2053                 row[midi_port_columns.control_data] = mpi.properties & MidiPortControl;
2054                 row[midi_port_columns.selection] = mpi.properties & MidiPortSelection;
2055                 row[midi_port_columns.name] = *s;
2056         }
2057
2058         view.set_model (model);
2059
2060         return true;
2061 }
2062
2063 void
2064 MidiPortOptions::midi_music_column_toggled (string const & path, TreeView* view)
2065 {
2066         TreeIter iter = view->get_model()->get_iter (path);
2067
2068         if (!iter) {
2069                 return;
2070         }
2071
2072         bool new_value = ! bool ((*iter)[midi_port_columns.music_data]);
2073
2074         /* don't reset model - wait for MidiPortInfoChanged signal */
2075
2076         if (new_value) {
2077                 ARDOUR::AudioEngine::instance()->add_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortMusic);
2078         } else {
2079                 ARDOUR::AudioEngine::instance()->remove_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortMusic);
2080         }
2081 }
2082
2083 void
2084 MidiPortOptions::midi_control_column_toggled (string const & path, TreeView* view)
2085 {
2086         TreeIter iter = view->get_model()->get_iter (path);
2087
2088         if (!iter) {
2089                 return;
2090         }
2091
2092         bool new_value = ! bool ((*iter)[midi_port_columns.control_data]);
2093
2094         /* don't reset model - wait for MidiPortInfoChanged signal */
2095
2096         if (new_value) {
2097                 ARDOUR::AudioEngine::instance()->add_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortControl);
2098         } else {
2099                 ARDOUR::AudioEngine::instance()->remove_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortControl);
2100         }
2101 }
2102
2103 void
2104 MidiPortOptions::midi_selection_column_toggled (string const & path, TreeView* view)
2105 {
2106         TreeIter iter = view->get_model()->get_iter (path);
2107
2108         if (!iter) {
2109                 return;
2110         }
2111
2112         bool new_value = ! bool ((*iter)[midi_port_columns.selection]);
2113
2114         /* don't reset model - wait for MidiSelectionPortsChanged signal */
2115
2116         if (new_value) {
2117                 ARDOUR::AudioEngine::instance()->add_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortSelection);
2118         } else {
2119                 ARDOUR::AudioEngine::instance()->remove_midi_port_flags ((*iter)[midi_port_columns.name], MidiPortSelection);
2120         }
2121 }
2122
2123 void
2124 MidiPortOptions::pretty_name_edit (std::string const & path, string const & new_text, Gtk::TreeView* view)
2125 {
2126         TreeIter iter = view->get_model()->get_iter (path);
2127
2128         if (!iter) {
2129                 return;
2130         }
2131
2132         boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
2133         if (backend) {
2134                 ARDOUR::PortEngine::PortHandle ph = backend->get_port_by_name ((*iter)[midi_port_columns.name]);
2135                 if (ph) {
2136                         backend->set_port_property (ph, "http://jackaudio.org/metadata/pretty-name", new_text, "");
2137                         (*iter)[midi_port_columns.pretty_name] = new_text;
2138                 }
2139         }
2140 }
2141
2142 /*============*/
2143
2144
2145 RCOptionEditor::RCOptionEditor ()
2146         : OptionEditorContainer (Config, string_compose (_("%1 Preferences"), PROGRAM_NAME))
2147         , Tabbable (*this, _("Preferences")) /* pack self-as-vbox into tabbable */
2148         , _rc_config (Config)
2149         , _mixer_strip_visibility ("mixer-element-visibility")
2150 {
2151         UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &RCOptionEditor::parameter_changed));
2152
2153         /* MISC */
2154
2155         uint32_t hwcpus = hardware_concurrency ();
2156         BoolOption* bo;
2157         BoolComboOption* bco;
2158
2159         if (hwcpus > 1) {
2160                 add_option (_("Misc"), new OptionEditorHeading (_("DSP CPU Utilization")));
2161
2162                 ComboOption<int32_t>* procs = new ComboOption<int32_t> (
2163                         "processor-usage",
2164                         _("Signal processing uses"),
2165                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_processor_usage),
2166                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_processor_usage)
2167                         );
2168
2169                 procs->add (-1, _("all but one processor"));
2170                 procs->add (0, _("all available processors"));
2171
2172                 for (uint32_t i = 1; i <= hwcpus; ++i) {
2173                         procs->add (i, string_compose (P_("%1 processor", "%1 processors", i), i));
2174                 }
2175
2176                 procs->set_note (string_compose (_("This setting will only take effect when %1 is restarted."), PROGRAM_NAME));
2177
2178                 add_option (_("Misc"), procs);
2179         }
2180
2181         add_option (_("Misc"), new OptionEditorHeading (S_("Options|Undo")));
2182
2183         add_option (_("Misc"), new UndoOptions (_rc_config));
2184
2185         add_option (_("Misc"),
2186              new BoolOption (
2187                      "verify-remove-last-capture",
2188                      _("Verify removal of last capture"),
2189                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_verify_remove_last_capture),
2190                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_verify_remove_last_capture)
2191                      ));
2192
2193         add_option (_("Misc"), new OptionEditorHeading (_("Session Management")));
2194
2195         add_option (_("Misc"),
2196              new BoolOption (
2197                      "periodic-safety-backups",
2198                      _("Make periodic backups of the session file"),
2199                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_periodic_safety_backups),
2200                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_periodic_safety_backups)
2201                      ));
2202
2203         add_option (_("Misc"),
2204              new BoolOption (
2205                      "only-copy-imported-files",
2206                      _("Always copy imported files"),
2207                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_only_copy_imported_files),
2208                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_only_copy_imported_files)
2209                      ));
2210
2211         add_option (_("Misc"), new DirectoryOption (
2212                             X_("default-session-parent-dir"),
2213                             _("Default folder for new sessions:"),
2214                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_default_session_parent_dir),
2215                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_default_session_parent_dir)
2216                             ));
2217
2218         add_option (_("Misc"),
2219              new SpinOption<uint32_t> (
2220                      "max-recent-sessions",
2221                      _("Maximum number of recent sessions"),
2222                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_max_recent_sessions),
2223                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_max_recent_sessions),
2224                      0, 1000, 1, 20
2225                      ));
2226
2227         add_option (_("Misc/Click"), new OptionEditorHeading (_("Click")));
2228
2229         add_option (_("Misc/Click"), new ClickOptions (_rc_config));
2230
2231         add_option (_("Misc/Click"),
2232              new FaderOption (
2233                      "click-gain",
2234                      _("Click gain level"),
2235                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_click_gain),
2236                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_click_gain)
2237                      ));
2238
2239         add_option (_("Misc"), new OptionEditorHeading (_("Automation")));
2240
2241         add_option (_("Misc"),
2242              new SpinOption<double> (
2243                      "automation-thinning-factor",
2244                      _("Thinning factor (larger value => less data)"),
2245                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_thinning_factor),
2246                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_thinning_factor),
2247                      0, 1000, 1, 20
2248                      ));
2249
2250         add_option (_("Misc"),
2251              new SpinOption<double> (
2252                      "automation-interval-msecs",
2253                      _("Automation sampling interval (milliseconds)"),
2254                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_interval_msecs),
2255                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_interval_msecs),
2256                      1, 1000, 1, 20
2257                      ));
2258
2259         /* TRANSPORT */
2260
2261         add_option (_("Transport"), new OptionEditorHeading (S_("Transport Options")));
2262
2263         BoolOption* tsf;
2264
2265         tsf = new BoolOption (
2266                      "latched-record-enable",
2267                      _("Keep record-enable engaged on stop"),
2268                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_latched_record_enable),
2269                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_latched_record_enable)
2270                      );
2271         // Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), _(""));
2272         add_option (_("Transport"), tsf);
2273
2274         tsf = new BoolOption (
2275                      "loop-is-mode",
2276                      _("Play loop is a transport mode"),
2277                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_loop_is_mode),
2278                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_loop_is_mode)
2279                      );
2280         Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
2281                                             (_("<b>When enabled</b> the loop button does not start playback but forces playback to always play the loop\n\n"
2282                                                "<b>When disabled</b> the loop button starts playing the loop, but stop then cancels loop playback")));
2283         add_option (_("Transport"), tsf);
2284
2285         tsf = new BoolOption (
2286                      "stop-recording-on-xrun",
2287                      _("Stop recording when an xrun occurs"),
2288                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun),
2289                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun)
2290                      );
2291         Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
2292                                             string_compose (_("<b>When enabled</b> %1 will stop recording if an over- or underrun is detected by the audio engine"),
2293                                                             PROGRAM_NAME));
2294         add_option (_("Transport"), tsf);
2295
2296         tsf = new BoolOption (
2297                      "create-xrun-marker",
2298                      _("Create markers where xruns occur"),
2299                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_create_xrun_marker),
2300                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_create_xrun_marker)
2301                      );
2302         // Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), _(""));
2303         add_option (_("Transport"), tsf);
2304
2305         tsf = new BoolOption (
2306                      "stop-at-session-end",
2307                      _("Stop at the end of the session"),
2308                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_at_session_end),
2309                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_at_session_end)
2310                      );
2311         Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
2312                                             string_compose (_("<b>When enabled</b> if %1 is <b>not recording</b>, it will stop the transport "
2313                                                               "when it reaches the current session end marker\n\n"
2314                                                               "<b>When disabled</b> %1 will continue to roll past the session end marker at all times"),
2315                                                             PROGRAM_NAME));
2316         add_option (_("Transport"), tsf);
2317
2318         tsf = new BoolOption (
2319                      "seamless-loop",
2320                      _("Do seamless looping (not possible when slaved to MTC, LTC etc)"),
2321                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_seamless_loop),
2322                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_seamless_loop)
2323                      );
2324         Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
2325                                             string_compose (_("<b>When enabled</b> this will loop by reading ahead and wrapping around at the loop point, "
2326                                                               "preventing any need to do a transport locate at the end of the loop\n\n"
2327                                                               "<b>When disabled</b> looping is done by locating back to the start of the loop when %1 reaches the end "
2328                                                               "which will often cause a small click or delay"), PROGRAM_NAME));
2329         add_option (_("Transport"), tsf);
2330
2331         tsf = new BoolOption (
2332                      "disable-disarm-during-roll",
2333                      _("Disable per-track record disarm while rolling"),
2334                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_disable_disarm_during_roll),
2335                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_disable_disarm_during_roll)
2336                      );
2337         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"));
2338         add_option (_("Transport"), tsf);
2339
2340         tsf = new BoolOption (
2341                      "quieten_at_speed",
2342                      _("12dB gain reduction during fast-forward and fast-rewind"),
2343                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_quieten_at_speed),
2344                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_quieten_at_speed)
2345                      );
2346         Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), _("This will reduce the unpleasant increase in perceived volume "
2347                                                    "that occurs when fast-forwarding or rewinding through some kinds of audio"));
2348         add_option (_("Transport"), tsf);
2349
2350         ComboOption<float>* psc = new ComboOption<float> (
2351                      "preroll-seconds",
2352                      _("Preroll"),
2353                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_preroll_seconds),
2354                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_preroll_seconds)
2355                      );
2356         Gtkmm2ext::UI::instance()->set_tip (psc->tip_widget(),
2357                                             (_("The amount of preroll (in seconds) to apply when <b>Play with Preroll</b> is initiated.\n\n"
2358                                                "If <b>Follow Edits</b> is enabled, the preroll is applied to the playhead position when a region is selected or trimmed.")));
2359         psc->add (0.0, _("0 (no pre-roll)"));
2360         psc->add (0.1, _("0.1 second"));
2361         psc->add (0.25, _("0.25 second"));
2362         psc->add (0.5, _("0.5 second"));
2363         psc->add (1.0, _("1.0 second"));
2364         psc->add (2.0, _("2.0 seconds"));
2365         add_option (_("Transport"), psc);
2366
2367         add_option (_("Transport/Sync"), new OptionEditorHeading (S_("Synchronization and Slave Options")));
2368
2369         _sync_source = new ComboOption<SyncSource> (
2370                 "sync-source",
2371                 _("External timecode source"),
2372                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_sync_source),
2373                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_sync_source)
2374                 );
2375
2376         add_option (_("Transport/Sync"), _sync_source);
2377
2378         _sync_framerate = new BoolOption (
2379                      "timecode-sync-frame-rate",
2380                      _("Match session video frame rate to external timecode"),
2381                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_sync_frame_rate),
2382                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_sync_frame_rate)
2383                      );
2384         Gtkmm2ext::UI::instance()->set_tip
2385                 (_sync_framerate->tip_widget(),
2386                  string_compose (_("This option controls the value of the video frame rate <i>while chasing</i> an external timecode source.\n\n"
2387                                    "<b>When enabled</b> the session video frame rate will be changed to match that of the selected external timecode source.\n\n"
2388                                    "<b>When disabled</b> the session video frame rate will not be changed to match that of the selected external timecode source."
2389                                    "Instead the frame rate indication in the main clock will flash red and %1 will convert between the external "
2390                                    "timecode standard and the session standard."), PROGRAM_NAME));
2391
2392         add_option (_("Transport/Sync"), _sync_framerate);
2393
2394         _sync_genlock = new BoolOption (
2395                 "timecode-source-is-synced",
2396                 _("Sync-lock timecode to clock (disable drift compensation)"),
2397                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_source_is_synced),
2398                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_source_is_synced)
2399                 );
2400         Gtkmm2ext::UI::instance()->set_tip
2401                 (_sync_genlock->tip_widget(),
2402                  string_compose (_("<b>When enabled</b> %1 will never varispeed when slaved to external timecode. "
2403                                    "Sync Lock indicates that the selected external timecode source shares clock-sync "
2404                                    "(Black &amp; Burst, Wordclock, etc) with the audio interface. "
2405                                    "This option disables drift compensation. The transport speed is fixed at 1.0. "
2406                                    "Vari-speed LTC will be ignored and cause drift."
2407                                    "\n\n"
2408                                    "<b>When disabled</b> %1 will compensate for potential drift, regardless if the "
2409                                    "timecode sources shares clock sync."
2410                                   ), PROGRAM_NAME));
2411
2412
2413         add_option (_("Transport/Sync"), _sync_genlock);
2414
2415         _sync_source_2997 = new BoolOption (
2416                 "timecode-source-2997",
2417                 _("Lock to 29.9700 fps instead of 30000/1001"),
2418                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_source_2997),
2419                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_source_2997)
2420                 );
2421         Gtkmm2ext::UI::instance()->set_tip
2422                 (_sync_source_2997->tip_widget(),
2423                  _("<b>When enabled</b> the external timecode source is assumed to use 29.97 fps instead of 30000/1001.\n"
2424                          "SMPTE 12M-1999 specifies 29.97df as 30000/1001. The spec further mentions that "
2425                          "drop-frame timecode has an accumulated error of -86ms over a 24-hour period.\n"
2426                          "Drop-frame timecode would compensate exactly for a NTSC color frame rate of 30 * 0.9990 (ie 29.970000). "
2427                          "That is not the actual rate. However, some vendors use that rate - despite it being against the specs - "
2428                          "because the variant of using exactly 29.97 fps has zero timecode drift.\n"
2429                          ));
2430
2431         add_option (_("Transport/Sync"), _sync_source_2997);
2432
2433         add_option (_("Transport/Sync"), new OptionEditorHeading (S_("LTC Reader")));
2434
2435         _ltc_port = new ComboStringOption (
2436                 "ltc-source-port",
2437                 _("LTC incoming port"),
2438                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_ltc_source_port),
2439                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_ltc_source_port)
2440                 );
2441
2442         vector<string> physical_inputs;
2443         physical_inputs.push_back (_("None"));
2444         AudioEngine::instance()->get_physical_inputs (DataType::AUDIO, physical_inputs);
2445         _ltc_port->set_popdown_strings (physical_inputs);
2446
2447         populate_sync_options ();
2448         AudioEngine::instance()->Running.connect (engine_started_connection, MISSING_INVALIDATOR, boost::bind (&RCOptionEditor::populate_sync_options, this), gui_context());
2449
2450         add_option (_("Transport/Sync"), _ltc_port);
2451
2452         // TODO; rather disable this button than not compile it..
2453         add_option (_("Transport/Sync"), new OptionEditorHeading (S_("LTC Generator")));
2454
2455         add_option (_("Transport/Sync"),
2456                     new BoolOption (
2457                             "send-ltc",
2458                             _("Enable LTC generator"),
2459                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_ltc),
2460                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_ltc)
2461                             ));
2462
2463         _ltc_send_continuously = new BoolOption (
2464                             "ltc-send-continuously",
2465                             _("Send LTC while stopped"),
2466                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_ltc_send_continuously),
2467                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_ltc_send_continuously)
2468                             );
2469         Gtkmm2ext::UI::instance()->set_tip
2470                 (_ltc_send_continuously->tip_widget(),
2471                  string_compose (_("<b>When enabled</b> %1 will continue to send LTC information even when the transport (playhead) is not moving"), PROGRAM_NAME));
2472         add_option (_("Transport"), _ltc_send_continuously);
2473
2474         _ltc_volume_adjustment = new Gtk::Adjustment(-18, -50, 0, .5, 5);
2475         _ltc_volume_adjustment->set_value (20 * log10(_rc_config->get_ltc_output_volume()));
2476         _ltc_volume_adjustment->signal_value_changed().connect (sigc::mem_fun (*this, &RCOptionEditor::ltc_generator_volume_changed));
2477         _ltc_volume_slider = new HSliderOption("ltcvol", _("LTC generator level"), *_ltc_volume_adjustment);
2478
2479         Gtkmm2ext::UI::instance()->set_tip
2480                 (_ltc_volume_slider->tip_widget(),
2481                  _("Specify the Peak Volume of the generated LTC signal in dBFS. A good value is  0dBu ^= -18dBFS in an EBU calibrated system"));
2482
2483         add_option (_("Transport/Sync"), _ltc_volume_slider);
2484
2485         /* EDITOR */
2486
2487         add_option (_("Editor"),
2488              new BoolOption (
2489                      "rubberbanding-snaps-to-grid",
2490                      _("Make rubberband selection rectangle snap to the grid"),
2491                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_rubberbanding_snaps_to_grid),
2492                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_rubberbanding_snaps_to_grid)
2493                      ));
2494
2495         bo = new BoolOption (
2496                      "name-new-markers",
2497                      _("Name new markers"),
2498                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_name_new_markers),
2499                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_name_new_markers)
2500                 );
2501         add_option (_("Editor"), bo);
2502         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."
2503                                                                 "\n\nYou can always rename markers by right-clicking on them"));
2504
2505         add_option (S_("Editor"),
2506              new BoolOption (
2507                      "draggable-playhead",
2508                      _("Allow dragging of playhead"),
2509                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_draggable_playhead),
2510                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_draggable_playhead)
2511                      ));
2512
2513         add_option (_("Editor"),
2514              new BoolOption (
2515                      "show-editor-meter",
2516                      _("Display master-meter in the toolbar"),
2517                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_editor_meter),
2518                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_editor_meter)
2519                      ));
2520
2521 if (!Profile->get_mixbus()) {
2522         add_option (_("Editor"),
2523                     new BoolOption (
2524                             "show-zoom-tools",
2525                             _("Show zoom toolbar (if torn off)"),
2526                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_zoom_tools),
2527                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_zoom_tools)
2528                             ));
2529
2530         add_option (_("Editor"),
2531                     new BoolOption (
2532                             "use-mouse-position-as-zoom-focus-on-scroll",
2533                             _("Always use mouse cursor position as zoom focus when zooming using mouse scroll wheel"),
2534                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_mouse_position_as_zoom_focus_on_scroll),
2535                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_mouse_position_as_zoom_focus_on_scroll)
2536                             ));
2537 }  // !mixbus
2538
2539         add_option (_("Editor"),
2540                     new BoolOption (
2541                             "use-time-rulers-to-zoom-with-vertical-drag",
2542                             _("Use time rulers area to zoom when clicking and dragging vertically"),
2543                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_time_rulers_to_zoom_with_vertical_drag),
2544                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_time_rulers_to_zoom_with_vertical_drag)
2545                             ));
2546
2547         add_option (_("Editor"),
2548                     new BoolOption (
2549                             "update-editor-during-summary-drag",
2550                             _("Update editor window during drags of the summary"),
2551                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_update_editor_during_summary_drag),
2552                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_update_editor_during_summary_drag)
2553                             ));
2554
2555         add_option (_("Editor"),
2556             new BoolOption (
2557                     "autoscroll-editor",
2558                     _("Auto-scroll editor window when dragging near its edges"),
2559                     sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_autoscroll_editor),
2560                     sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_autoscroll_editor)
2561                     ));
2562
2563         add_option (_("Editor"),
2564              new BoolComboOption (
2565                      "show-region-gain-envelopes",
2566                      _("Show gain envelopes in audio regions"),
2567                      _("in all modes"),
2568                      _("only in Draw and Internal Edit modes"),
2569                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_region_gain),
2570                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_region_gain)
2571                      ));
2572
2573         add_option (_("Editor"), new OptionEditorHeading (_("Editor Behavior")));
2574
2575         add_option (_("Editor"),
2576              new BoolOption (
2577                      "automation-follows-regions",
2578                      _("Move relevant automation when audio regions are moved"),
2579                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_follows_regions),
2580                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_follows_regions)
2581                      ));
2582
2583         ComboOption<FadeShape>* fadeshape = new ComboOption<FadeShape> (
2584                         "default-fade-shape",
2585                         _("Default fade shape"),
2586                         sigc::mem_fun (*_rc_config,
2587                                 &RCConfiguration::get_default_fade_shape),
2588                         sigc::mem_fun (*_rc_config,
2589                                 &RCConfiguration::set_default_fade_shape)
2590                         );
2591
2592         fadeshape->add (FadeLinear,
2593                         _("Linear (for highly correlated material)"));
2594         fadeshape->add (FadeConstantPower, _("Constant power"));
2595         fadeshape->add (FadeSymmetric, _("Symmetric"));
2596         fadeshape->add (FadeSlow, _("Slow"));
2597         fadeshape->add (FadeFast, _("Fast"));
2598
2599         add_option (_("Editor"), fadeshape);
2600
2601
2602         bco = new BoolComboOption (
2603                      "use-overlap-equivalency",
2604                      _("Regions in active edit groups are edited together"),
2605                      _("whenever they overlap in time"),
2606                      _("only if they have identical length, position and origin"),
2607                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_use_overlap_equivalency),
2608                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_use_overlap_equivalency)
2609                      );
2610
2611         add_option (_("Editor"), bco);
2612
2613         ComboOption<LayerModel>* lm = new ComboOption<LayerModel> (
2614                 "layer-model",
2615                 _("Layering model"),
2616                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_layer_model),
2617                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_layer_model)
2618                 );
2619
2620         lm->add (LaterHigher, _("later is higher"));
2621         lm->add (Manual, _("manual layering"));
2622         add_option (_("Editor"), lm);
2623
2624         ComboOption<RegionSelectionAfterSplit> *rsas = new ComboOption<RegionSelectionAfterSplit> (
2625                     "region-selection-after-split",
2626                     _("After splitting selected regions, select"),
2627                     sigc::mem_fun (*_rc_config, &RCConfiguration::get_region_selection_after_split),
2628                     sigc::mem_fun (*_rc_config, &RCConfiguration::set_region_selection_after_split));
2629
2630         // TODO: decide which of these modes are really useful
2631         rsas->add(None, _("no regions"));
2632         // rsas->add(NewlyCreatedLeft, _("newly-created regions before the split"));
2633         // rsas->add(NewlyCreatedRight, _("newly-created regions after the split"));
2634         rsas->add(NewlyCreatedBoth, _("newly-created regions"));
2635         // rsas->add(Existing, _("unmodified regions in the existing selection"));
2636         // rsas->add(ExistingNewlyCreatedLeft, _("existing selection and newly-created regions before the split"));
2637         // rsas->add(ExistingNewlyCreatedRight, _("existing selection and newly-created regions after the split"));
2638         rsas->add(ExistingNewlyCreatedBoth, _("existing selection and newly-created regions"));
2639
2640         add_option (_("Editor"), rsas);
2641
2642         add_option (_("Editor/Waveforms"), new OptionEditorHeading (_("Waveforms")));
2643
2644 if (!Profile->get_mixbus()) {
2645         add_option (_("Editor/Waveforms"),
2646              new BoolOption (
2647                      "show-waveforms",
2648                      _("Show waveforms in regions"),
2649                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_waveforms),
2650                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_waveforms)
2651                      ));
2652 }  // !mixbus
2653
2654         add_option (_("Editor/Waveforms"),
2655              new BoolOption (
2656                      "show-waveforms-while-recording",
2657                      _("Show waveforms for audio while it is being recorded"),
2658                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_waveforms_while_recording),
2659                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_waveforms_while_recording)
2660                      ));
2661
2662         ComboOption<WaveformScale>* wfs = new ComboOption<WaveformScale> (
2663                 "waveform-scale",
2664                 _("Waveform scale"),
2665                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_scale),
2666                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_scale)
2667                 );
2668
2669         wfs->add (Linear, _("linear"));
2670         wfs->add (Logarithmic, _("logarithmic"));
2671
2672         add_option (_("Editor/Waveforms"), wfs);
2673
2674         ComboOption<WaveformShape>* wfsh = new ComboOption<WaveformShape> (
2675                 "waveform-shape",
2676                 _("Waveform shape"),
2677                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_shape),
2678                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_shape)
2679                 );
2680
2681         wfsh->add (Traditional, _("traditional"));
2682         wfsh->add (Rectified, _("rectified"));
2683
2684         add_option (_("Editor/Waveforms"), wfsh);
2685
2686         add_option (_("Editor/Waveforms"), new ClipLevelOptions ());
2687
2688
2689         /* AUDIO */
2690
2691         add_option (_("Audio"), new OptionEditorHeading (_("Buffering")));
2692
2693         add_option (_("Audio"), new BufferingOptions (_rc_config));
2694
2695         add_option (_("Audio"), new OptionEditorHeading (_("Monitoring")));
2696
2697         ComboOption<MonitorModel>* mm = new ComboOption<MonitorModel> (
2698                 "monitoring-model",
2699                 _("Record monitoring handled by"),
2700                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_monitoring_model),
2701                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_monitoring_model)
2702                 );
2703
2704         if (AudioEngine::instance()->port_engine().can_monitor_input()) {
2705                 mm->add (HardwareMonitoring, _("via Audio Driver"));
2706         }
2707
2708         string prog (PROGRAM_NAME);
2709         boost::algorithm::to_lower (prog);
2710         mm->add (SoftwareMonitoring, string_compose (_("%1"), prog));
2711         mm->add (ExternalMonitoring, _("audio hardware"));
2712
2713         add_option (_("Audio"), mm);
2714
2715         add_option (_("Audio"),
2716              new BoolOption (
2717                      "tape-machine-mode",
2718                      _("Tape machine mode"),
2719                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_tape_machine_mode),
2720                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_tape_machine_mode)
2721                      ));
2722
2723         add_option (_("Audio"), new OptionEditorHeading (_("Connection of tracks and busses")));
2724 if (!Profile->get_mixbus()) {
2725
2726         add_option (_("Audio"),
2727                     new BoolOption (
2728                             "auto-connect-standard-busses",
2729                             _("Auto-connect master/monitor busses"),
2730                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_auto_connect_standard_busses),
2731                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_auto_connect_standard_busses)
2732                             ));
2733
2734         ComboOption<AutoConnectOption>* iac = new ComboOption<AutoConnectOption> (
2735                 "input-auto-connect",
2736                 _("Connect track inputs"),
2737                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_input_auto_connect),
2738                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_input_auto_connect)
2739                 );
2740
2741         iac->add (AutoConnectPhysical, _("automatically to physical inputs"));
2742         iac->add (ManualConnect, _("manually"));
2743
2744         add_option (_("Audio"), iac);
2745
2746         ComboOption<AutoConnectOption>* oac = new ComboOption<AutoConnectOption> (
2747                 "output-auto-connect",
2748                 _("Connect track and bus outputs"),
2749                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_output_auto_connect),
2750                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_output_auto_connect)
2751                 );
2752
2753         oac->add (AutoConnectPhysical, _("automatically to physical outputs"));
2754         oac->add (AutoConnectMaster, _("automatically to master bus"));
2755         oac->add (ManualConnect, _("manually"));
2756
2757         add_option (_("Audio"), oac);
2758
2759         bo = new BoolOption (
2760                         "strict-io",
2761                         _("Use 'Strict-I/O' for new tracks or Busses"),
2762                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_strict_io),
2763                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_strict_io)
2764                         );
2765
2766         add_option (_("Audio"), bo);
2767         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
2768                         _("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."));
2769
2770 }  // !mixbus
2771
2772         add_option (_("Audio"), new OptionEditorHeading (_("Denormals")));
2773
2774         add_option (_("Audio"),
2775              new BoolOption (
2776                      "denormal-protection",
2777                      _("Use DC bias to protect against denormals"),
2778                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_denormal_protection),
2779                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_protection)
2780                      ));
2781
2782         ComboOption<DenormalModel>* dm = new ComboOption<DenormalModel> (
2783                 "denormal-model",
2784                 _("Processor handling"),
2785                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_denormal_model),
2786                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_model)
2787                 );
2788
2789         int dmsize = 1;
2790         dm->add (DenormalNone, _("no processor handling"));
2791
2792         FPU* fpu = FPU::instance();
2793
2794         if (fpu->has_flush_to_zero()) {
2795                 ++dmsize;
2796                 dm->add (DenormalFTZ, _("use FlushToZero"));
2797         } else if (_rc_config->get_denormal_model() == DenormalFTZ) {
2798                 _rc_config->set_denormal_model(DenormalNone);
2799         }
2800
2801         if (fpu->has_denormals_are_zero()) {
2802                 ++dmsize;
2803                 dm->add (DenormalDAZ, _("use DenormalsAreZero"));
2804         } else if (_rc_config->get_denormal_model() == DenormalDAZ) {
2805                 _rc_config->set_denormal_model(DenormalNone);
2806         }
2807
2808         if (fpu->has_flush_to_zero() && fpu->has_denormals_are_zero()) {
2809                 ++dmsize;
2810                 dm->add (DenormalFTZDAZ, _("use FlushToZero and DenormalsAreZero"));
2811         } else if (_rc_config->get_denormal_model() == DenormalFTZDAZ) {
2812                 _rc_config->set_denormal_model(DenormalNone);
2813         }
2814
2815         if (dmsize == 1) {
2816                 dm->set_sensitive(false);
2817         }
2818
2819         add_option (_("Audio"), dm);
2820
2821         add_option (_("Audio"), new OptionEditorHeading (_("Regions")));
2822
2823         add_option (_("Audio"),
2824              new BoolOption (
2825                      "auto-analyse-audio",
2826                      _("Enable automatic analysis of audio"),
2827                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_auto_analyse_audio),
2828                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_auto_analyse_audio)
2829                      ));
2830
2831         add_option (_("Audio"),
2832              new BoolOption (
2833                      "replicate-missing-region-channels",
2834                      _("Replicate missing region channels"),
2835                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_replicate_missing_region_channels),
2836                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_replicate_missing_region_channels)
2837                      ));
2838
2839         /* SOLO AND MUTE */
2840
2841         add_option (_("Solo & mute"), new OptionEditorHeading (_("Solo")));
2842
2843         _solo_control_is_listen_control = new BoolOption (
2844                 "solo-control-is-listen-control",
2845                 _("Solo controls are Listen controls"),
2846                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_control_is_listen_control),
2847                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_control_is_listen_control)
2848                 );
2849
2850         add_option (_("Solo & mute"), _solo_control_is_listen_control);
2851
2852         add_option (_("Solo & mute"),
2853              new BoolOption (
2854                      "exclusive-solo",
2855                      _("Exclusive solo"),
2856                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_exclusive_solo),
2857                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_exclusive_solo)
2858                      ));
2859
2860         add_option (_("Solo & mute"),
2861              new BoolOption (
2862                      "show-solo-mutes",
2863                      _("Show solo muting"),
2864                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_solo_mutes),
2865                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_solo_mutes)
2866                      ));
2867
2868         add_option (_("Solo & mute"),
2869              new BoolOption (
2870                      "solo-mute-override",
2871                      _("Soloing overrides muting"),
2872                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_override),
2873                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_override)
2874                      ));
2875
2876         add_option (_("Solo & mute"),
2877              new FaderOption (
2878                      "solo-mute-gain",
2879                      _("Solo-in-place mute cut (dB)"),
2880                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_gain),
2881                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_gain)
2882                      ));
2883
2884         _listen_position = new ComboOption<ListenPosition> (
2885                 "listen-position",
2886                 _("Listen Position"),
2887                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_listen_position),
2888                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_listen_position)
2889                 );
2890
2891         _listen_position->add (AfterFaderListen, _("after-fader (AFL)"));
2892         _listen_position->add (PreFaderListen, _("pre-fader (PFL)"));
2893
2894         add_option (_("Solo & mute"), _listen_position);
2895
2896         ComboOption<PFLPosition>* pp = new ComboOption<PFLPosition> (
2897                 "pfl-position",
2898                 _("PFL signals come from"),
2899                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_pfl_position),
2900                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_pfl_position)
2901                 );
2902
2903         pp->add (PFLFromBeforeProcessors, _("before pre-fader processors"));
2904         pp->add (PFLFromAfterProcessors, _("pre-fader but after pre-fader processors"));
2905
2906         add_option (_("Solo & mute"), pp);
2907
2908         ComboOption<AFLPosition>* pa = new ComboOption<AFLPosition> (
2909                 "afl-position",
2910                 _("AFL signals come from"),
2911                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_afl_position),
2912                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_afl_position)
2913                 );
2914
2915         pa->add (AFLFromBeforeProcessors, _("immediately post-fader"));
2916         pa->add (AFLFromAfterProcessors, _("after post-fader processors (before pan)"));
2917
2918         add_option (_("Solo & mute"), pa);
2919
2920         add_option (_("Solo & mute"), new OptionEditorHeading (_("Default track / bus muting options")));
2921
2922         add_option (_("Solo & mute"),
2923              new BoolOption (
2924                      "mute-affects-pre-fader",
2925                      _("Mute affects pre-fader sends"),
2926                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_pre_fader),
2927                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_pre_fader)
2928                      ));
2929
2930         add_option (_("Solo & mute"),
2931              new BoolOption (
2932                      "mute-affects-post-fader",
2933                      _("Mute affects post-fader sends"),
2934                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_post_fader),
2935                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_post_fader)
2936                      ));
2937
2938         add_option (_("Solo & mute"),
2939              new BoolOption (
2940                      "mute-affects-control-outs",
2941                      _("Mute affects control outputs"),
2942                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_control_outs),
2943                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_control_outs)
2944                      ));
2945
2946         add_option (_("Solo & mute"),
2947              new BoolOption (
2948                      "mute-affects-main-outs",
2949                      _("Mute affects main outputs"),
2950                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_main_outs),
2951                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_main_outs)
2952                      ));
2953
2954
2955 if (!ARDOUR::Profile->get_mixbus()) {
2956         add_option (_("Solo & mute"), new OptionEditorHeading (_("Send Routing")));
2957         add_option (_("Solo & mute"),
2958              new BoolOption (
2959                      "link-send-and-route-panner",
2960                      _("Link panners of Aux and External Sends with main panner by default"),
2961                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_link_send_and_route_panner),
2962                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_send_and_route_panner)
2963                      ));
2964 }
2965
2966         add_option (_("MIDI"), new OptionEditorHeading (_("MIDI Preferences")));
2967
2968         add_option (_("MIDI"),
2969                     new SpinOption<float> (
2970                             "midi-readahead",
2971                             _("MIDI read-ahead time (seconds)"),
2972                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_readahead),
2973                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_readahead),
2974                             0.1, 10, 0.1, 1,
2975                             "", 1.0, 1
2976                             ));
2977
2978         add_option (_("MIDI"),
2979              new SpinOption<int32_t> (
2980                      "initial-program-change",
2981                      _("Initial program change"),
2982                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_initial_program_change),
2983                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_initial_program_change),
2984                      -1, 65536, 1, 10
2985                      ));
2986
2987         add_option (_("MIDI"),
2988                     new BoolOption (
2989                             "display-first-midi-bank-as-zero",
2990                             _("Display first MIDI bank/program as 0"),
2991                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_first_midi_bank_is_zero),
2992                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_first_midi_bank_is_zero)
2993                             ));
2994
2995         add_option (_("MIDI"),
2996              new BoolOption (
2997                      "never-display-periodic-midi",
2998                      _("Never display periodic MIDI messages (MTC, MIDI Clock)"),
2999                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_never_display_periodic_midi),
3000                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_never_display_periodic_midi)
3001                      ));
3002
3003         add_option (_("MIDI"),
3004              new BoolOption (
3005                      "sound-midi-notes",
3006                      _("Sound MIDI notes as they are selected in the editor"),
3007                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_sound_midi_notes),
3008                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_sound_midi_notes)
3009                      ));
3010
3011         add_option (_("MIDI"),
3012                     new BoolOption (
3013                             "midi-feedback",
3014                             _("Send MIDI control feedback"),
3015                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_feedback),
3016                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_feedback)
3017                             ));
3018
3019         add_option (_("MIDI/Ports"),
3020                     new BoolOption (
3021                             "get-midi-input-follows-selection",
3022                             _("MIDI input follows MIDI track selection"),
3023                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_input_follows_selection),
3024                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_input_follows_selection)
3025                             ));
3026
3027         add_option (_("MIDI/Ports"), new MidiPortOptions ());
3028
3029         add_option (_("MIDI/Sync"), new OptionEditorHeading (_("MIDI Clock")));
3030
3031         add_option (_("MIDI/Sync"),
3032                     new BoolOption (
3033                             "send-midi-clock",
3034                             _("Send MIDI Clock"),
3035                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_midi_clock),
3036                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_midi_clock)
3037                             ));
3038
3039         add_option (_("MIDI/Sync"), new OptionEditorHeading (_("MIDI Time Code (MTC)")));
3040
3041         add_option (_("MIDI/Sync"),
3042                     new BoolOption (
3043                             "send-mtc",
3044                             _("Send MIDI Time Code"),
3045                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_mtc),
3046                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_mtc)
3047                             ));
3048
3049         add_option (_("MIDI/Sync"),
3050                     new SpinOption<int> (
3051                             "mtc-qf-speed-tolerance",
3052                             _("Percentage either side of normal transport speed to transmit MTC"),
3053                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_mtc_qf_speed_tolerance),
3054                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_mtc_qf_speed_tolerance),
3055                             0, 20, 1, 5
3056                             ));
3057
3058         add_option (_("MIDI/Sync"), new OptionEditorHeading (_("Midi Machine Control (MMC)")));
3059
3060         add_option (_("MIDI/Sync"),
3061                     new BoolOption (
3062                             "mmc-control",
3063                             _("Obey MIDI Machine Control commands"),
3064                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_control),
3065                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_control)
3066                             ));
3067
3068         add_option (_("MIDI/Sync"),
3069                     new BoolOption (
3070                             "send-mmc",
3071                             _("Send MIDI Machine Control commands"),
3072                             sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_mmc),
3073                             sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_mmc)
3074                             ));
3075
3076         add_option (_("MIDI/Sync"),
3077              new SpinOption<uint8_t> (
3078                      "mmc-receive-device-id",
3079                      _("Inbound MMC device ID"),
3080                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_receive_device_id),
3081                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_receive_device_id),
3082                      0, 128, 1, 10
3083                      ));
3084
3085         add_option (_("MIDI/Sync"),
3086              new SpinOption<uint8_t> (
3087                      "mmc-send-device-id",
3088                      _("Outbound MMC device ID"),
3089                      sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_send_device_id),
3090                      sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_send_device_id),
3091                      0, 128, 1, 10
3092                      ));
3093
3094         add_option (_("MIDI"), new OptionEditorHeading (_("Midi Audition")));
3095
3096         ComboOption<std::string>* audition_synth = new ComboOption<std::string> (
3097                 "midi-audition-synth-uri",
3098                 _("Midi Audition Synth (LV2)"),
3099                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_audition_synth_uri),
3100                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_audition_synth_uri)
3101                 );
3102
3103         audition_synth->add(X_(""), _("None"));
3104         PluginInfoList all_plugs;
3105         PluginManager& manager (PluginManager::instance());
3106 #ifdef LV2_SUPPORT
3107         all_plugs.insert (all_plugs.end(), manager.lv2_plugin_info().begin(), manager.lv2_plugin_info().end());
3108
3109         for (PluginInfoList::const_iterator i = all_plugs.begin(); i != all_plugs.end(); ++i) {
3110                 if (manager.get_status (*i) == PluginManager::Hidden) continue;
3111                 if (!(*i)->is_instrument()) continue;
3112                 if ((*i)->type != ARDOUR::LV2) continue;
3113                 audition_synth->add((*i)->unique_id, (*i)->name);
3114         }
3115 #endif
3116
3117         add_option (_("MIDI"), audition_synth);
3118
3119         /* USER INTERACTION */
3120
3121         if (
3122 #ifdef PLATFORM_WINDOWS
3123                         true
3124 #else
3125                         getenv ("ARDOUR_BUNDLED")
3126 #endif
3127            )
3128         {
3129                 add_option (_("User interaction"),
3130                             new BoolOption (
3131                                     "enable-translation",
3132                                     string_compose (_("Use translations of %1 messages\n"
3133                                                       "   <i>(requires a restart of %1 to take effect)</i>\n"
3134                                                       "   <i>(if available for your language preferences)</i>"), PROGRAM_NAME),
3135                                     sigc::ptr_fun (ARDOUR::translations_are_enabled),
3136                                     sigc::ptr_fun (ARDOUR::set_translations_enabled)));
3137         }
3138
3139         add_option (_("User interaction"), new OptionEditorHeading (_("Keyboard")));
3140
3141         add_option (_("User interaction"), new KeyboardOptions);
3142
3143         /* Control Surfaces */
3144
3145         add_option (_("Control Surfaces"), new ControlSurfacesOptions);
3146
3147         /* VIDEO Timeline */
3148         add_option (_("Video"), new VideoTimelineOptions (_rc_config));
3149
3150 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT || defined AUDIOUNIT_SUPPORT)
3151         add_option (_("Plugins"),
3152                         new RcActionButton (_("Scan for Plugins"),
3153                                 sigc::mem_fun (*this, &RCOptionEditor::plugin_scan_refresh)));
3154
3155 #endif
3156
3157         add_option (_("Plugins"), new OptionEditorHeading (_("General")));
3158
3159 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT || defined AUDIOUNIT_SUPPORT)
3160         bo = new BoolOption (
3161                         "show-plugin-scan-window",
3162                         _("Always Display Plugin Scan Progress"),
3163                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_plugin_scan_window),
3164                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_plugin_scan_window)
3165                         );
3166         add_option (_("Plugins"), bo);
3167         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3168                         _("<b>When enabled</b> a popup window showing plugin scan progress is displayed for indexing (cache load) and discovery (detect new plugins)"));
3169 #endif
3170
3171         bo = new BoolOption (
3172                 "plugins-stop-with-transport",
3173                 _("Silence plugins when the transport is stopped"),
3174                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugins_stop_with_transport),
3175                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_plugins_stop_with_transport)
3176                 );
3177         add_option (_("Plugins"), bo);
3178         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3179                                             _("<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."));
3180
3181         bo = new BoolOption (
3182                 "new-plugins-active",
3183                         _("Make new plugins active"),
3184                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_new_plugins_active),
3185                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_new_plugins_active)
3186                         );
3187         add_option (_("Plugins"), bo);
3188         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3189                                             _("<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"));
3190
3191 #if (defined WINDOWS_VST_SUPPORT || defined MACVST_SUPPORT || defined LXVST_SUPPORT)
3192         add_option (_("Plugins/VST"), new OptionEditorHeading (_("VST")));
3193         add_option (_("Plugins/VST"),
3194                         new RcActionButton (_("Scan for Plugins"),
3195                                 sigc::mem_fun (*this, &RCOptionEditor::plugin_scan_refresh)));
3196
3197 #if (defined AUDIOUNIT_SUPPORT && defined MACVST_SUPPORT)
3198         bo = new BoolOption (
3199                         "",
3200                         _("Enable Mac VST support (requires restart or re-scan)"),
3201                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_use_macvst),
3202                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_use_macvst)
3203                         );
3204         add_option (_("Plugins/VST"), bo);
3205 #endif
3206
3207         bo = new BoolOption (
3208                         "discover-vst-on-start",
3209                         _("Scan for [new] VST Plugins on Application Start"),
3210                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_discover_vst_on_start),
3211                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_discover_vst_on_start)
3212                         );
3213         add_option (_("Plugins/VST"), bo);
3214         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3215                                             _("<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"));
3216
3217 #ifdef WINDOWS_VST_SUPPORT
3218         // currently verbose logging is only implemented for Windows VST.
3219         bo = new BoolOption (
3220                         "verbose-plugin-scan",
3221                         _("Verbose Plugin Scan"),
3222                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_verbose_plugin_scan),
3223                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_verbose_plugin_scan)
3224                         );
3225         add_option (_("Plugins/VST"), bo);
3226         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3227                                             _("<b>When enabled</b> additional information for every plugin is added to the Log Window."));
3228 #endif
3229
3230         add_option (_("Plugins/VST"), new VstTimeOutSliderOption (_rc_config));
3231
3232         add_option (_("Plugins/VST"),
3233                         new RcActionButton (_("Clear"),
3234                                 sigc::mem_fun (*this, &RCOptionEditor::clear_vst_cache),
3235                                 _("VST Cache:")));
3236
3237         add_option (_("Plugins/VST"),
3238                         new RcActionButton (_("Clear"),
3239                                 sigc::mem_fun (*this, &RCOptionEditor::clear_vst_blacklist),
3240                                 _("VST Blacklist:")));
3241 #endif
3242
3243 #ifdef LXVST_SUPPORT
3244         add_option (_("Plugins/VST"),
3245                         new RcActionButton (_("Edit"),
3246                                 sigc::mem_fun (*this, &RCOptionEditor::edit_lxvst_path),
3247                         _("Linux VST Path:")));
3248
3249         add_option (_("Plugins/VST"),
3250                         new RcConfigDisplay (
3251                                 "plugin-path-lxvst",
3252                                 _("Path:"),
3253                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugin_path_lxvst),
3254                                 0));
3255 #endif
3256
3257 #ifdef WINDOWS_VST_SUPPORT
3258         add_option (_("Plugins/VST"),
3259                         new RcActionButton (_("Edit"),
3260                                 sigc::mem_fun (*this, &RCOptionEditor::edit_vst_path),
3261                         _("Windows VST Path:")));
3262         add_option (_("Plugins"),
3263                         new RcConfigDisplay (
3264                                 "plugin-path-vst",
3265                                 _("Path:"),
3266                                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugin_path_vst),
3267                                 ';'));
3268 #endif
3269
3270 #ifdef AUDIOUNIT_SUPPORT
3271
3272         add_option (_("Plugins/Audio Unit"), new OptionEditorHeading (_("Audio Unit")));
3273         add_option (_("Plugins/Audio Unit"),
3274                         new RcActionButton (_("Scan for Plugins"),
3275                                 sigc::mem_fun (*this, &RCOptionEditor::plugin_scan_refresh)));
3276
3277         bo = new BoolOption (
3278                         "discover-audio-units",
3279                         _("Scan for [new] AudioUnit Plugins on Application Start"),
3280                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_discover_audio_units),
3281                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_discover_audio_units)
3282                         );
3283         add_option (_("Plugins/Audio Unit"), bo);
3284         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3285                                             _("<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."));
3286
3287         add_option (_("Plugins/Audio Unit"),
3288                         new RcActionButton (_("Clear"),
3289                                 sigc::mem_fun (*this, &RCOptionEditor::clear_au_cache),
3290                                 _("AU Cache:")));
3291
3292         add_option (_("Plugins/Audio Unit"),
3293                         new RcActionButton (_("Clear"),
3294                                 sigc::mem_fun (*this, &RCOptionEditor::clear_au_blacklist),
3295                                 _("AU Blacklist:")));
3296 #endif
3297
3298 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT || defined AUDIOUNIT_SUPPORT || defined HAVE_LV2)
3299         add_option (_("Plugins"), new OptionEditorHeading (_("Plugin GUI")));
3300         add_option (_("Plugins"),
3301              new BoolOption (
3302                      "open-gui-after-adding-plugin",
3303                      _("Automatically open the plugin GUI when adding a new plugin"),
3304                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_open_gui_after_adding_plugin),
3305                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_open_gui_after_adding_plugin)
3306                      ));
3307
3308 #if (defined LV2_SUPPORT && defined LV2_EXTENDED)
3309         add_option (_("Plugins"),
3310              new BoolOption (
3311                      "show-inline-display-by-default",
3312                      _("Show Plugin Inline Display on Mixerstrip by default"),
3313                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_inline_display_by_default),
3314                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_inline_display_by_default)
3315                      ));
3316
3317         _plugin_prefer_inline = new BoolOption (
3318                         "prefer-inline-over-gui",
3319                         _("Don't automatically open the plugin GUI when the plugin has an inline display mode"),
3320                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_prefer_inline_over_gui),
3321                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_prefer_inline_over_gui)
3322                         );
3323         add_option (_("Plugins"), _plugin_prefer_inline);
3324 #endif
3325
3326         add_option (_("Plugins"), new OptionEditorHeading (_("Instrument")));
3327
3328         bo = new BoolOption (
3329                         "ask-replace-instrument",
3330                         _("Ask to replace existing instrument plugin"),
3331                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_ask_replace_instrument),
3332                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_ask_replace_instrument)
3333                         );
3334         add_option (_("Plugins"), bo);
3335
3336         bo = new BoolOption (
3337                         "ask-setup_instrument",
3338                         _("Interactively configure instrument plugins on insert"),
3339                         sigc::mem_fun (*_rc_config, &RCConfiguration::get_ask_setup_instrument),
3340                         sigc::mem_fun (*_rc_config, &RCConfiguration::set_ask_setup_instrument)
3341                         );
3342         add_option (_("Plugins"), bo);
3343         Gtkmm2ext::UI::instance()->set_tip (bo->tip_widget(),
3344                         _("<b>When enabled</b> show a dialog to select instrument channel configuration before adding a multichannel plugin."));
3345
3346 #endif
3347
3348         /* INTERFACE */
3349
3350 #ifdef OPTIONAL_CAIRO_IMAGE_SURFACE
3351         BoolOption* bgc = new BoolOption (
3352                 "cairo-image-surface",
3353                 _("Disable Graphics Hardware Acceleration (requires restart)"),
3354                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_cairo_image_surface),
3355                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_cairo_image_surface)
3356                 );
3357
3358         Gtkmm2ext::UI::instance()->set_tip (bgc->tip_widget(), string_compose (
3359                                 _("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));
3360         add_option (S_("Preferences|GUI"), bgc);
3361 #endif
3362
3363 #ifdef CAIRO_SUPPORTS_FORCE_BUGGY_GRADIENTS_ENVIRONMENT_VARIABLE
3364         BoolOption* bgo = new BoolOption (
3365                 "buggy-gradients",
3366                 _("Possibly improve slow graphical performance (requires restart)"),
3367                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_buggy_gradients),
3368                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_buggy_gradients)
3369                 );
3370
3371         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));
3372         add_option (S_("Preferences|GUI"), bgo);
3373 #endif
3374
3375         add_option (S_("Preferences|GUI"),
3376              new BoolOption (
3377                      "use-wm-visibility",
3378                      _("Use Window Manager/Desktop visibility information"),
3379                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_wm_visibility),
3380                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_wm_visibility)
3381                      ));
3382
3383         add_option (S_("Preferences|GUI"),
3384              new BoolOption (
3385                      "widget-prelight",
3386                      _("Graphically indicate mouse pointer hovering over various widgets"),
3387                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_widget_prelight),
3388                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_widget_prelight)
3389                      ));
3390
3391         add_option (S_("Preferences|GUI"),
3392              new BoolOption (
3393                      "use-tooltips",
3394                      _("Show tooltips if mouse hovers over a control"),
3395                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_use_tooltips),
3396                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_tooltips)
3397                      ));
3398
3399         add_option (S_("Preferences|GUI"),
3400              new BoolOption (
3401                      "show-name-highlight",
3402                      _("Use name highlight bars in region displays (requires a restart)"),
3403                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_name_highlight),
3404                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_name_highlight)
3405                      ));
3406
3407         add_option (S_("Preferences|GUI"),
3408                     new BoolOption (
3409                             "super-rapid-clock-update",
3410                             _("Update transport clock display at FPS instead of every 100ms"),
3411                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_super_rapid_clock_update),
3412                             sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_super_rapid_clock_update)
3413                             ));
3414
3415
3416 #ifndef __APPLE__
3417         /* font scaling does nothing with GDK/Quartz */
3418         add_option (S_("Preferences|GUI"), new FontScalingOptions ());
3419 #endif
3420
3421         /* Image cache size */
3422
3423         Gtk::Adjustment *ics = manage (new Gtk::Adjustment(0, 1, 1024, 10)); /* 1 MB to 1GB in steps of 10MB */
3424         HSliderOption *sics = new HSliderOption("waveform-cache-size",
3425                                                 _("Waveform image cache size (megabytes)"),
3426                                                 ics,
3427                                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_waveform_cache_size),
3428                                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_cache_size)
3429                         );
3430         sics->scale().set_digits (0);
3431         Gtkmm2ext::UI::instance()->set_tip
3432                 (sics->tip_widget(),
3433                  _("Increasing the cache size uses more memory to store waveform images, which can improve graphical performance."));
3434         add_option (S_("Preferences|GUI"), sics);
3435
3436 if (!ARDOUR::Profile->get_mixbus()) {
3437         /* Lock GUI timeout */
3438
3439         Gtk::Adjustment *lts = manage (new Gtk::Adjustment(0, 0, 1000, 1, 10));
3440         HSliderOption *slts = new HSliderOption("lock-gui-after-seconds",
3441                                                 _("Lock timeout (seconds)"),
3442                                                 lts,
3443                                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_lock_gui_after_seconds),
3444                                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_lock_gui_after_seconds)
3445                         );
3446         slts->scale().set_digits (0);
3447         Gtkmm2ext::UI::instance()->set_tip
3448                 (slts->tip_widget(),
3449                  _("Lock GUI after this many idle seconds (zero to never lock)"));
3450         add_option (S_("Preferences|GUI"), slts);
3451 } // !mixbus
3452
3453         /* The names of these controls must be the same as those given in MixerStrip
3454            for the actual widgets being controlled.
3455         */
3456         _mixer_strip_visibility.add (0, X_("Input"), _("Input"));
3457         _mixer_strip_visibility.add (0, X_("PhaseInvert"), _("Phase Invert"));
3458         _mixer_strip_visibility.add (0, X_("RecMon"), _("Record & Monitor"));
3459         _mixer_strip_visibility.add (0, X_("SoloIsoLock"), _("Solo Iso / Lock"));
3460         _mixer_strip_visibility.add (0, X_("Output"), _("Output"));
3461         _mixer_strip_visibility.add (0, X_("Comments"), _("Comments"));
3462         _mixer_strip_visibility.add (0, X_("VCA"), _("VCA Assigns"));
3463
3464         add_option (
3465                 S_("Preferences|GUI"),
3466                 new VisibilityOption (
3467                         _("Mixer Strip"),
3468                         &_mixer_strip_visibility,
3469                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_mixer_strip_visibility),
3470                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_mixer_strip_visibility)
3471                         )
3472                 );
3473
3474         add_option (S_("Preferences|GUI"),
3475              new BoolOption (
3476                      "default-narrow_ms",
3477                      _("Use narrow strips in the mixer by default"),
3478                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_default_narrow_ms),
3479                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_default_narrow_ms)
3480                      ));
3481
3482         add_option (S_("Preferences|GUI"),
3483                         new ColumVisibilityOption (
3484                                 "action-table-columns", _("Action Script Button Visibility"), 3,
3485                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_action_table_columns),
3486                                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_action_table_columns)
3487                                 )
3488                         );
3489
3490         add_option (S_("Preferences|Metering"), new OptionEditorHeading (_("Metering")));
3491
3492         ComboOption<float>* mht = new ComboOption<float> (
3493                 "meter-hold",
3494                 _("Peak hold time"),
3495                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_hold),
3496                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_hold)
3497                 );
3498
3499         mht->add (MeterHoldOff, _("off"));
3500         mht->add (MeterHoldShort, _("short"));
3501         mht->add (MeterHoldMedium, _("medium"));
3502         mht->add (MeterHoldLong, _("long"));
3503
3504         add_option (S_("Preferences|Metering"), mht);
3505
3506         ComboOption<float>* mfo = new ComboOption<float> (
3507                 "meter-falloff",
3508                 _("DPM fall-off"),
3509                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_falloff),
3510                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_falloff)
3511                 );
3512
3513         mfo->add (METER_FALLOFF_OFF,      _("off"));
3514         mfo->add (METER_FALLOFF_SLOWEST,  _("slowest [6.6dB/sec]"));
3515         mfo->add (METER_FALLOFF_SLOW,     _("slow [8.6dB/sec] (BBC PPM, EBU PPM)"));
3516         mfo->add (METER_FALLOFF_SLOWISH,  _("moderate [12.0dB/sec] (DIN)"));
3517         mfo->add (METER_FALLOFF_MODERATE, _("medium [13.3dB/sec] (EBU Digi PPM, IRT Digi PPM)"));
3518         mfo->add (METER_FALLOFF_MEDIUM,   _("fast [20dB/sec]"));
3519         mfo->add (METER_FALLOFF_FAST,     _("very fast [32dB/sec]"));
3520
3521         add_option (S_("Preferences|Metering"), mfo);
3522
3523         ComboOption<MeterLineUp>* mlu = new ComboOption<MeterLineUp> (
3524                 "meter-line-up-level",
3525                 _("Meter line-up level; 0dBu"),
3526                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_line_up_level),
3527                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_line_up_level)
3528                 );
3529
3530         mlu->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
3531         mlu->add (MeteringLineUp20, _("-20dBFS (SMPTE RP.0155)"));
3532         mlu->add (MeteringLineUp18, _("-18dBFS (EBU, BBC)"));
3533         mlu->add (MeteringLineUp15, _("-15dBFS (DIN)"));
3534
3535         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."));
3536
3537         add_option (S_("Preferences|Metering"), mlu);
3538
3539         ComboOption<MeterLineUp>* mld = new ComboOption<MeterLineUp> (
3540                 "meter-line-up-din",
3541                 _("IEC1/DIN Meter line-up level; 0dBu"),
3542                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_line_up_din),
3543                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_line_up_din)
3544                 );
3545
3546         mld->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
3547         mld->add (MeteringLineUp20, _("-20dBFS (SMPTE RP.0155)"));
3548         mld->add (MeteringLineUp18, _("-18dBFS (EBU, BBC)"));
3549         mld->add (MeteringLineUp15, _("-15dBFS (DIN)"));
3550
3551         Gtkmm2ext::UI::instance()->set_tip (mld->tip_widget(), _("Reference level for IEC1/DIN meter."));
3552
3553         add_option (S_("Preferences|Metering"), mld);
3554
3555         ComboOption<VUMeterStandard>* mvu = new ComboOption<VUMeterStandard> (
3556                 "meter-vu-standard",
3557                 _("VU Meter standard"),
3558                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_vu_standard),
3559                 sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_vu_standard)
3560                 );
3561
3562         mvu->add (MeteringVUfrench,   _("0VU = -2dBu (France)"));
3563         mvu->add (MeteringVUamerican, _("0VU = 0dBu (North America, Australia)"));
3564         mvu->add (MeteringVUstandard, _("0VU = +4dBu (standard)"));
3565         mvu->add (MeteringVUeight,    _("0VU = +8dBu"));
3566
3567         add_option (S_("Preferences|Metering"), mvu);
3568
3569         Gtk::Adjustment *mpk = manage (new Gtk::Adjustment(0, -10, 0, .1, .1));
3570         HSliderOption *mpks = new HSliderOption("meter-peak",
3571                         _("Peak threshold [dBFS]"),
3572                         mpk,
3573                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_peak),
3574                         sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_peak)
3575                         );
3576
3577
3578         ComboOption<MeterType>* mtm = new ComboOption<MeterType> (
3579                 "meter-type-master",
3580                 _("Default Meter Type for Master Bus"),
3581                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_master),
3582                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_master)
3583                 );
3584         mtm->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
3585         mtm->add (MeterK20,     ArdourMeter::meter_type_string(MeterK20));
3586         mtm->add (MeterK14,     ArdourMeter::meter_type_string(MeterK14));
3587         mtm->add (MeterK12,     ArdourMeter::meter_type_string(MeterK12));
3588         mtm->add (MeterIEC1DIN, ArdourMeter::meter_type_string(MeterIEC1DIN));
3589         mtm->add (MeterIEC1NOR, ArdourMeter::meter_type_string(MeterIEC1NOR));
3590         mtm->add (MeterIEC2BBC, ArdourMeter::meter_type_string(MeterIEC2BBC));
3591         mtm->add (MeterIEC2EBU, ArdourMeter::meter_type_string(MeterIEC2EBU));
3592
3593         add_option (S_("Preferences|Metering"), mtm);
3594
3595
3596         ComboOption<MeterType>* mtb = new ComboOption<MeterType> (
3597                 "meter-type-bus",
3598                 _("Default Meter Type for Busses"),
3599                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_bus),
3600                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_bus)
3601                 );
3602         mtb->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
3603         mtb->add (MeterK20,     ArdourMeter::meter_type_string(MeterK20));
3604         mtb->add (MeterK14,     ArdourMeter::meter_type_string(MeterK14));
3605         mtb->add (MeterK12,     ArdourMeter::meter_type_string(MeterK12));
3606         mtb->add (MeterIEC1DIN, ArdourMeter::meter_type_string(MeterIEC1DIN));
3607         mtb->add (MeterIEC1NOR, ArdourMeter::meter_type_string(MeterIEC1NOR));
3608         mtb->add (MeterIEC2BBC, ArdourMeter::meter_type_string(MeterIEC2BBC));
3609         mtb->add (MeterIEC2EBU, ArdourMeter::meter_type_string(MeterIEC2EBU));
3610
3611         add_option (S_("Preferences|Metering"), mtb);
3612
3613         ComboOption<MeterType>* mtt = new ComboOption<MeterType> (
3614                 "meter-type-track",
3615                 _("Default Meter Type for Tracks"),
3616                 sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_track),
3617                 sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_track)
3618                 );
3619         mtt->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
3620         mtt->add (MeterPeak0dB, ArdourMeter::meter_type_string(MeterPeak0dB));
3621
3622         add_option (S_("Preferences|Metering"), mtt);
3623
3624
3625         Gtkmm2ext::UI::instance()->set_tip
3626                 (mpks->tip_widget(),
3627                  _("Specify the audio signal level in dBFS at and above which the meter-peak indicator will flash red."));
3628
3629         add_option (S_("Preferences|Metering"), mpks);
3630
3631         add_option (S_("Preferences|Metering"),
3632              new BoolOption (
3633                      "meter-style-led",
3634                      _("LED meter style"),
3635                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_meter_style_led),
3636                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_style_led)
3637                      ));
3638
3639         add_option (S_("Preferences|Metering"), new OptionEditorHeading (_("Editor Meters")));
3640
3641         add_option (S_("Preferences|Metering"),
3642              new BoolOption (
3643                      "show-track-meters",
3644                      _("Show meters on tracks in the editor"),
3645                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_track_meters),
3646                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_track_meters)
3647                      ));
3648
3649         add_option (S_("Preferences|Metering"),
3650              new BoolOption (
3651                      "editor-stereo-only-meters",
3652                      _("Show at most stereo meters in the track-header"),
3653                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_editor_stereo_only_meters),
3654                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_editor_stereo_only_meters)
3655                      ));
3656
3657         add_option (S_("Preferences|Metering"), new OptionEditorHeading (_("Post Export Analysis")));
3658
3659         add_option (S_("Preferences|Metering"),
3660              new BoolOption (
3661                      "save-export-analysis-image",
3662                      _("Save loudness analysis as image file"),
3663                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_save_export_analysis_image),
3664                      sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_save_export_analysis_image)
3665                      ));
3666
3667         /* and now the theme manager */
3668
3669         ThemeManager* tm = manage (new ThemeManager);
3670         add_page (_("Theme"), *tm);
3671
3672         add_option (_("Theme/Colors"), new ColorThemeManager);
3673
3674         Widget::show_all ();
3675
3676         //trigger some parameter-changed messages which affect widget-visibility or -sensitivity
3677         parameter_changed ("send-ltc");
3678         parameter_changed ("sync-source");
3679         parameter_changed ("use-monitor-bus");
3680         parameter_changed ("open-gui-after-adding-plugin");
3681
3682         XMLNode* node = ARDOUR_UI::instance()->preferences_settings();
3683         if (node) {
3684                 /* gcc4 complains about ambiguity with Gtk::Widget::set_state
3685                    (Gtk::StateType) here !!!
3686                 */
3687                 Tabbable::set_state (*node, Stateful::loading_state_version);
3688         }
3689 }
3690
3691 void
3692 RCOptionEditor::parameter_changed (string const & p)
3693 {
3694         OptionEditor::parameter_changed (p);
3695
3696         if (p == "use-monitor-bus") {
3697                 bool const s = Config->get_use_monitor_bus ();
3698                 if (!s) {
3699                         /* we can't use this if we don't have a monitor bus */
3700                         Config->set_solo_control_is_listen_control (false);
3701                 }
3702                 _solo_control_is_listen_control->set_sensitive (s);
3703                 _listen_position->set_sensitive (s);
3704         } else if (p == "sync-source") {
3705                 _sync_source->set_sensitive (true);
3706                 if (_session) {
3707                         _sync_source->set_sensitive (!_session->config.get_external_sync());
3708                 }
3709                 switch(Config->get_sync_source()) {
3710                 case ARDOUR::MTC:
3711                 case ARDOUR::LTC:
3712                         _sync_genlock->set_sensitive (true);
3713                         _sync_framerate->set_sensitive (true);
3714                         _sync_source_2997->set_sensitive (true);
3715                         break;
3716                 default:
3717                         _sync_genlock->set_sensitive (false);
3718                         _sync_framerate->set_sensitive (false);
3719                         _sync_source_2997->set_sensitive (false);
3720                         break;
3721                 }
3722         } else if (p == "send-ltc") {
3723                 bool const s = Config->get_send_ltc ();
3724                 _ltc_send_continuously->set_sensitive (s);
3725                 _ltc_volume_slider->set_sensitive (s);
3726         } else if (p == "open-gui-after-adding-plugin" || p == "show-inline-display-by-default") {
3727 #if (defined LV2_SUPPORT && defined LV2_EXTENDED)
3728                 _plugin_prefer_inline->set_sensitive (UIConfiguration::instance().get_open_gui_after_adding_plugin() && UIConfiguration::instance().get_show_inline_display_by_default());
3729 #endif
3730         }
3731 }
3732
3733 void RCOptionEditor::ltc_generator_volume_changed () {
3734         _rc_config->set_ltc_output_volume (pow(10, _ltc_volume_adjustment->get_value() / 20));
3735 }
3736
3737 void RCOptionEditor::plugin_scan_refresh () {
3738         PluginManager::instance().refresh();
3739 }
3740
3741 void RCOptionEditor::clear_vst_cache () {
3742         PluginManager::instance().clear_vst_cache();
3743 }
3744
3745 void RCOptionEditor::clear_vst_blacklist () {
3746         PluginManager::instance().clear_vst_blacklist();
3747 }
3748
3749 void RCOptionEditor::clear_au_cache () {
3750         PluginManager::instance().clear_au_cache();
3751 }
3752
3753 void RCOptionEditor::clear_au_blacklist () {
3754         PluginManager::instance().clear_au_blacklist();
3755 }
3756
3757 void RCOptionEditor::edit_lxvst_path () {
3758         Glib::RefPtr<Gdk::Window> win = get_parent_window ();
3759         Gtkmm2ext::PathsDialog *pd = new Gtkmm2ext::PathsDialog (
3760                 *current_toplevel(), _("Set Linux VST Search Path"),
3761                 _rc_config->get_plugin_path_lxvst(),
3762                 PluginManager::instance().get_default_lxvst_path()
3763                 );
3764         ResponseType r = (ResponseType) pd->run ();
3765         pd->hide();
3766         if (r == RESPONSE_ACCEPT) {
3767                 _rc_config->set_plugin_path_lxvst(pd->get_serialized_paths());
3768         }
3769         delete pd;
3770 }
3771
3772 void RCOptionEditor::edit_vst_path () {
3773         Gtkmm2ext::PathsDialog *pd = new Gtkmm2ext::PathsDialog (
3774                 *current_toplevel(), _("Set Windows VST Search Path"),
3775                 _rc_config->get_plugin_path_vst(),
3776                 PluginManager::instance().get_default_windows_vst_path()
3777                 );
3778         ResponseType r = (ResponseType) pd->run ();
3779         pd->hide();
3780         if (r == RESPONSE_ACCEPT) {
3781                 _rc_config->set_plugin_path_vst(pd->get_serialized_paths());
3782         }
3783         delete pd;
3784 }
3785
3786
3787 void
3788 RCOptionEditor::populate_sync_options ()
3789 {
3790         vector<SyncSource> sync_opts = ARDOUR::get_available_sync_options ();
3791
3792         _sync_source->clear ();
3793
3794         for (vector<SyncSource>::iterator i = sync_opts.begin(); i != sync_opts.end(); ++i) {
3795                 _sync_source->add (*i, sync_source_to_string (*i));
3796         }
3797
3798         if (sync_opts.empty()) {
3799                 _sync_source->set_sensitive(false);
3800         } else {
3801                 if (std::find(sync_opts.begin(), sync_opts.end(), _rc_config->get_sync_source()) == sync_opts.end()) {
3802                         _rc_config->set_sync_source(sync_opts.front());
3803                 }
3804         }
3805
3806         parameter_changed ("sync-source");
3807 }
3808
3809 Gtk::Window*
3810 RCOptionEditor::use_own_window (bool and_fill_it)
3811 {
3812         bool new_window = !own_window ();
3813
3814         Gtk::Window* win = Tabbable::use_own_window (and_fill_it);
3815
3816         if (win && new_window) {
3817                 win->set_name ("PreferencesWindow");
3818                 ARDOUR_UI::instance()->setup_toplevel_window (*win, _("Preferences"), this);
3819         }
3820
3821         return win;
3822 }
3823
3824 XMLNode&
3825 RCOptionEditor::get_state ()
3826 {
3827         XMLNode* node = new XMLNode (X_("Preferences"));
3828         node->add_child_nocopy (Tabbable::get_state());
3829         return *node;
3830 }