gtk2_ardour/rc_option_editor.cc

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