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