X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Frc_option_editor.cc;h=0fdaaae902a60a0660be12ee3002ba7e33650a2d;hb=9b75cdb26d6abaf9c7c28858fdd0d350a32adc01;hp=fc6978275772219a44170f25def153a96cf6733c;hpb=a643c9fdc08f98c7750a2474004a75e143077be9;p=ardour.git

diff --git a/gtk2_ardour/rc_option_editor.cc b/gtk2_ardour/rc_option_editor.cc
index fc69782757..0fdaaae902 100644
--- a/gtk2_ardour/rc_option_editor.cc
+++ b/gtk2_ardour/rc_option_editor.cc
@@ -21,12 +21,18 @@
 #include "gtk2ardour-config.h"
 #endif
 
+#include <cairo/cairo.h>
+
+#include <boost/algorithm/string.hpp>    
+
 #include <gtkmm/liststore.h>
 #include <gtkmm/stock.h>
 #include <gtkmm/scale.h>
+
 #include <gtkmm2ext/utils.h>
 #include <gtkmm2ext/slider_controller.h>
 #include <gtkmm2ext/gtk_ui.h>
+#include <gtkmm2ext/paths_dialog.h>
 
 #include "pbd/fpu.h"
 #include "pbd/cpus.h"
@@ -38,6 +44,9 @@
 #include "ardour/plugin_manager.h"
 #include "control_protocol/control_protocol.h"
 
+#include "canvas/wave_view.h"
+
+#include "ardour_ui.h"
 #include "ardour_window.h"
 #include "ardour_dialog.h"
 #include "gui_thread.h"
@@ -47,6 +56,8 @@
 #include "midi_port_dialog.h"
 #include "sfdb_ui.h"
 #include "keyboard.h"
+#include "theme_manager.h"
+#include "ui_config.h"
 #include "i18n.h"
 
 using namespace std;
@@ -54,13 +65,13 @@ using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace PBD;
 using namespace ARDOUR;
+using namespace ARDOUR_UI_UTILS;
 
 class ClickOptions : public OptionEditorBox
 {
 public:
 	ClickOptions (RCConfiguration* c, Gtk::Window* p)
-		: _rc_config (c),
-		  _parent (p)
+		: _rc_config (c)
 	{
 		Table* t = manage (new Table (2, 3));
 		t->set_spacings (4);
@@ -106,6 +117,9 @@ private:
 	{
 		SoundFileChooser sfdb (_("Choose Click"));
 
+		sfdb.show_all ();
+		sfdb.present ();
+
 		if (sfdb.run () == RESPONSE_OK) {
 			click_chosen (sfdb.get_filename());
 		}
@@ -146,7 +160,6 @@ private:
 	}
 
 	RCConfiguration* _rc_config;
-	Gtk::Window* _parent;
 	Entry _click_path_entry;
 	Entry _click_emphasis_path_entry;
 };
@@ -260,20 +273,22 @@ static const struct {
 	{ "Option", GDK_MOD1_MASK },
 	{ "Command-Shift", GDK_META_MASK|GDK_SHIFT_MASK },
 	{ "Command-Option", GDK_MOD1_MASK|GDK_META_MASK },
-	{ "Shift-Option", GDK_SHIFT_MASK|GDK_MOD1_MASK },
+	{ "Option-Shift", GDK_MOD1_MASK|GDK_SHIFT_MASK },
+	{ "Control-Shift", GDK_CONTROL_MASK|GDK_SHIFT_MASK },
 	{ "Shift-Command-Option", GDK_MOD5_MASK|GDK_SHIFT_MASK|GDK_META_MASK },
 
 #else
 	{ "Key|Shift", GDK_SHIFT_MASK },
 	{ "Control", GDK_CONTROL_MASK },
-	{ "Alt (Mod1)", GDK_MOD1_MASK },
+	{ "Alt", GDK_MOD1_MASK },
 	{ "Control-Shift", GDK_CONTROL_MASK|GDK_SHIFT_MASK },
 	{ "Control-Alt", GDK_CONTROL_MASK|GDK_MOD1_MASK },
 	{ "Shift-Alt", GDK_SHIFT_MASK|GDK_MOD1_MASK },
 	{ "Control-Shift-Alt", GDK_CONTROL_MASK|GDK_SHIFT_MASK|GDK_MOD1_MASK },
+	{ "Alt-Windows", GDK_MOD1_MASK|GDK_MOD4_MASK },
 	{ "Mod2", GDK_MOD2_MASK },
 	{ "Mod3", GDK_MOD3_MASK },
-	{ "Mod4", GDK_MOD4_MASK },
+	{ "Windows", GDK_MOD4_MASK },
 	{ "Mod5", GDK_MOD5_MASK },
 #endif
 	{ 0, 0 }
@@ -308,25 +323,57 @@ public:
 			}
 		}
 
-		Table* t = manage (new Table (4, 4));
+		Table* t = manage (new Table (5, 11));
 		t->set_spacings (4);
 
-		Label* l = manage (left_aligned_label (_("Edit using:")));
+		int row = 0;
+		int col = 0;
+
+		Label* l = manage (left_aligned_label (_("Select Keyboard layout:")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 0, 1, 0, 1, FILL | EXPAND, FILL);
-		t->attach (_edit_modifier_combo, 1, 2, 0, 1, FILL | EXPAND, FILL);
+		vector<string> strs;
+
+		for (map<string,string>::iterator bf = Keyboard::binding_files.begin(); bf != Keyboard::binding_files.end(); ++bf) {
+			strs.push_back (bf->first);
+		}
+
+		set_popdown_strings (_keyboard_layout_selector, strs);
+		_keyboard_layout_selector.set_active_text (Keyboard::current_binding_name());
+		_keyboard_layout_selector.signal_changed().connect (sigc::mem_fun (*this, &KeyboardOptions::bindings_changed));
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_keyboard_layout_selector, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 0;
+
+		l = manage (left_aligned_label (_("When Clicking:")));
+		l->set_name ("OptionEditorHeading");
+		t->attach (*l, col, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		l = manage (left_aligned_label (_("Edit using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_edit_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 
 		l = manage (new Label (_("+ button")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 3, 4, 0, 1, FILL | EXPAND, FILL);
-		t->attach (_edit_button_spin, 4, 5, 0, 1, FILL | EXPAND, FILL);
+		t->attach (*l, col + 3, col + 4, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_edit_button_spin, col + 4, col + 5, row, row + 1, FILL | EXPAND, FILL);
 
 		_edit_button_spin.set_name ("OptionsEntry");
 		_edit_button_adjustment.set_value (Keyboard::edit_button());
 		_edit_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::edit_button_changed));
 
+		++row;
+		col = 1;
+
 		set_popdown_strings (_delete_modifier_combo, dumb);
 		_delete_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::delete_modifier_chosen));
 
@@ -340,19 +387,21 @@ public:
 		l = manage (left_aligned_label (_("Delete using:")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 0, 1, 1, 2, FILL | EXPAND, FILL);
-		t->attach (_delete_modifier_combo, 1, 2, 1, 2, FILL | EXPAND, FILL);
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_delete_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 
 		l = manage (new Label (_("+ button")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 3, 4, 1, 2, FILL | EXPAND, FILL);
-		t->attach (_delete_button_spin, 4, 5, 1, 2, FILL | EXPAND, FILL);
+		t->attach (*l, col + 3, col + 4, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_delete_button_spin, col + 4, col + 5, row, row + 1, FILL | EXPAND, FILL);
 
 		_delete_button_spin.set_name ("OptionsEntry");
 		_delete_button_adjustment.set_value (Keyboard::delete_button());
 		_delete_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::delete_button_changed));
 
+		++row;
+		col = 1;
 
 		set_popdown_strings (_insert_note_modifier_combo, dumb);
 		_insert_note_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::insert_note_modifier_chosen));
@@ -367,20 +416,165 @@ public:
 		l = manage (left_aligned_label (_("Insert note using:")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 0, 1, 2, 3, FILL | EXPAND, FILL);
-		t->attach (_insert_note_modifier_combo, 1, 2, 2, 3, FILL | EXPAND, FILL);
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_insert_note_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 
 		l = manage (new Label (_("+ button")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 3, 4, 2, 3, FILL | EXPAND, FILL);
-		t->attach (_insert_note_button_spin, 4, 5, 2, 3, FILL | EXPAND, FILL);
+		t->attach (*l, col + 3, col + 4, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_insert_note_button_spin, col + 4, col + 5, row, row + 1, FILL | EXPAND, FILL);
 
 		_insert_note_button_spin.set_name ("OptionsEntry");
 		_insert_note_button_adjustment.set_value (Keyboard::insert_note_button());
 		_insert_note_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::insert_note_button_changed));
 
+		++row;
+
+		l = manage (left_aligned_label (_("When Beginning a Drag:")));
+		l->set_name ("OptionEditorHeading");
+		t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* copy modifier */
+		set_popdown_strings (_copy_modifier_combo, dumb);
+		_copy_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::copy_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) Keyboard::CopyModifier) {
+				_copy_modifier_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Copy items using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_copy_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+				++row;
+		col = 1;
+
+		/* constraint modifier */
+		set_popdown_strings (_constraint_modifier_combo, dumb);
+		_constraint_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::constraint_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::constraint_modifier ()) {
+				_constraint_modifier_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Constrain drag using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_constraint_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
 
+		l = manage (left_aligned_label (_("When Beginning a Trim:")));
+		l->set_name ("OptionEditorHeading");
+		t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* trim_contents */
+		set_popdown_strings (_trim_contents_combo, dumb);
+		_trim_contents_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_contents_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::trim_contents_modifier ()) {
+				_trim_contents_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Trim contents using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_trim_contents_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* anchored trim */
+		set_popdown_strings (_trim_anchored_combo, dumb);
+		_trim_anchored_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_anchored_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::trim_anchored_modifier ()) {
+				_trim_anchored_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Anchored trim using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		++col;
+		t->attach (_trim_anchored_combo, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* jump trim disabled for now
+		set_popdown_strings (_trim_jump_combo, dumb);
+		_trim_jump_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_jump_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) Keyboard::trim_jump_modifier ()) {
+				_trim_jump_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Jump after trim using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		++col;
+		t->attach (_trim_jump_combo, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+		*/
+
+		/* note resize relative */
+		set_popdown_strings (_note_size_relative_combo, dumb);
+		_note_size_relative_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::note_size_relative_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::note_size_relative_modifier ()) {
+				_note_size_relative_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Resize notes relatively using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		++col;
+		t->attach (_note_size_relative_combo, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+
+		l = manage (left_aligned_label (_("While Dragging:")));
+		l->set_name ("OptionEditorHeading");
+		t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* ignore snap */
 		set_popdown_strings (_snap_modifier_combo, dumb);
 		_snap_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::snap_modifier_chosen));
 
@@ -394,24 +588,100 @@ public:
 		l = manage (left_aligned_label (_("Ignore snap using:")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 0, 1, 3, 4, FILL | EXPAND, FILL);
-		t->attach (_snap_modifier_combo, 1, 2, 3, 4, FILL | EXPAND, FILL);
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_snap_modifier_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 
-		vector<string> strs;
+		++row;
+		col = 1;
 
-		for (map<string,string>::iterator bf = Keyboard::binding_files.begin(); bf != Keyboard::binding_files.end(); ++bf) {
-			strs.push_back (bf->first);
+		/* snap delta */
+		set_popdown_strings (_snap_delta_combo, dumb);
+		_snap_delta_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::snap_delta_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) Keyboard::snap_delta_modifier ()) {
+				_snap_delta_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
 		}
 
-		set_popdown_strings (_keyboard_layout_selector, strs);
-		_keyboard_layout_selector.set_active_text (Keyboard::current_binding_name());
-		_keyboard_layout_selector.signal_changed().connect (sigc::mem_fun (*this, &KeyboardOptions::bindings_changed));
+		l = manage (left_aligned_label (_("Snap relatively using:")));
+		l->set_name ("OptionsLabel");
 
-		l = manage (left_aligned_label (_("Keyboard layout:")));
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_snap_delta_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+
+		l = manage (left_aligned_label (_("While Trimming:")));
+		l->set_name ("OptionEditorHeading");
+		t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* trim_overlap */
+		set_popdown_strings (_trim_overlap_combo, dumb);
+		_trim_overlap_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::trim_overlap_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::trim_overlap_modifier ()) {
+				_trim_overlap_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Resize overlaped regions using:")));
 		l->set_name ("OptionsLabel");
 
-		t->attach (*l, 0, 1, 4, 5, FILL | EXPAND, FILL);
-		t->attach (_keyboard_layout_selector, 1, 2, 4, 5, FILL | EXPAND, FILL);
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_trim_overlap_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+
+		l = manage (left_aligned_label (_("While Dragging Control Points:")));
+		l->set_name ("OptionEditorHeading");
+		t->attach (*l, 0, 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* fine adjust */
+		set_popdown_strings (_fine_adjust_combo, dumb);
+		_fine_adjust_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::fine_adjust_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::fine_adjust_modifier ()) {
+				_fine_adjust_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Fine adjust using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_fine_adjust_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
+
+		++row;
+		col = 1;
+
+		/* push points */
+		set_popdown_strings (_push_points_combo, dumb);
+		_push_points_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::push_points_modifier_chosen));
+
+		for (int x = 0; modifiers[x].name; ++x) {
+			if (modifiers[x].modifier == (guint) ArdourKeyboard::push_points_modifier ()) {
+				_push_points_combo.set_active_text (S_(modifiers[x].name));
+				break;
+			}
+		}
+
+		l = manage (left_aligned_label (_("Push points using:")));
+		l->set_name ("OptionsLabel");
+
+		t->attach (*l, col, col + 1, row, row + 1, FILL | EXPAND, FILL);
+		t->attach (_push_points_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
 
 		_box->pack_start (*t, false, false);
 	}
@@ -467,6 +737,18 @@ private:
 		}
 	}
 
+	void copy_modifier_chosen ()
+	{
+		string const txt = _copy_modifier_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				Keyboard::set_copy_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
 	void insert_note_modifier_chosen ()
 	{
 		string const txt = _insert_note_modifier_combo.get_active_text();
@@ -491,6 +773,102 @@ private:
 		}
 	}
 
+	void snap_delta_modifier_chosen ()
+	{
+		string const txt = _snap_delta_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				Keyboard::set_snap_delta_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void constraint_modifier_chosen ()
+	{
+		string const txt = _constraint_modifier_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_constraint_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void trim_contents_modifier_chosen ()
+	{
+		string const txt = _trim_contents_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_trim_contents_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void trim_overlap_modifier_chosen ()
+	{
+		string const txt = _trim_overlap_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_trim_overlap_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void trim_anchored_modifier_chosen ()
+	{
+		string const txt = _trim_anchored_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_trim_anchored_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void fine_adjust_modifier_chosen ()
+	{
+		string const txt = _fine_adjust_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_fine_adjust_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void push_points_modifier_chosen ()
+	{
+		string const txt = _push_points_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_push_points_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
+	void note_size_relative_modifier_chosen ()
+	{
+		string const txt = _note_size_relative_combo.get_active_text();
+
+		for (int i = 0; modifiers[i].name; ++i) {
+			if (txt == _(modifiers[i].name)) {
+				ArdourKeyboard::set_note_size_relative_modifier (modifiers[i].modifier);
+				break;
+			}
+		}
+	}
+
 	void delete_button_changed ()
 	{
 		Keyboard::set_delete_button (_delete_button_spin.get_value_as_int());
@@ -509,8 +887,18 @@ private:
 	ComboBoxText _keyboard_layout_selector;
 	ComboBoxText _edit_modifier_combo;
 	ComboBoxText _delete_modifier_combo;
+	ComboBoxText _copy_modifier_combo;
 	ComboBoxText _insert_note_modifier_combo;
 	ComboBoxText _snap_modifier_combo;
+	ComboBoxText _snap_delta_combo;
+	ComboBoxText _constraint_modifier_combo;
+	ComboBoxText _trim_contents_combo;
+	ComboBoxText _trim_overlap_combo;
+	ComboBoxText _trim_anchored_combo;
+	ComboBoxText _trim_jump_combo;
+	ComboBoxText _fine_adjust_combo;
+	ComboBoxText _push_points_combo;
+	ComboBoxText _note_size_relative_combo;
 	Adjustment _delete_button_adjustment;
 	SpinButton _delete_button_spin;
 	Adjustment _edit_button_adjustment;
@@ -523,17 +911,35 @@ private:
 class FontScalingOptions : public OptionEditorBox
 {
 public:
-	FontScalingOptions (RCConfiguration* c) :
-		_rc_config (c),
-		_dpi_adjustment (50, 50, 250, 1, 10),
+	FontScalingOptions (UIConfiguration* uic) :
+		_ui_config (uic),
+		_dpi_adjustment (100, 50, 250, 1, 5),
 		_dpi_slider (_dpi_adjustment)
 	{
-		_dpi_adjustment.set_value (floor (_rc_config->get_font_scale () / 1024));
+		_dpi_adjustment.set_value (_ui_config->get_font_scale() / 1024.);
 
-		Label* l = manage (new Label (_("Font scaling:")));
+		Label* l = manage (new Label (_("GUI and Font scaling:")));
 		l->set_name ("OptionsLabel");
 
+		 const Glib::ustring dflt = _("Default");
+		 const Glib::ustring empty = X_(""); // despite gtk-doc saying so, NULL does not work as reference
+
+		_dpi_slider.set_name("FontScaleSlider");
 		_dpi_slider.set_update_policy (UPDATE_DISCONTINUOUS);
+		_dpi_slider.set_draw_value(false);
+		_dpi_slider.add_mark(50,  Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(60,  Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(70,  Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(80,  Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(90,  Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(100, Gtk::POS_TOP, dflt);
+		_dpi_slider.add_mark(125, Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(150, Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(175, Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(200, Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(225, Gtk::POS_TOP, empty);
+		_dpi_slider.add_mark(250, Gtk::POS_TOP, empty);
+
 		HBox* h = manage (new HBox);
 		h->set_spacing (4);
 		h->pack_start (*l, false, false);
@@ -541,13 +947,15 @@ public:
 
 		_box->pack_start (*h, false, false);
 
+		set_note (_("Adjusting the scale require an application restart to re-layout."));
+
 		_dpi_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &FontScalingOptions::dpi_changed));
 	}
 
 	void parameter_changed (string const & p)
 	{
 		if (p == "font-scale") {
-			_dpi_adjustment.set_value (floor (_rc_config->get_font_scale() / 1024));
+			_dpi_adjustment.set_value (_ui_config->get_font_scale() / 1024.);
 		}
 	}
 
@@ -560,16 +968,66 @@ private:
 
 	void dpi_changed ()
 	{
-		_rc_config->set_font_scale ((long) floor (_dpi_adjustment.get_value() * 1024));
+		_ui_config->set_font_scale ((long) floor (_dpi_adjustment.get_value() * 1024.));
 		/* XXX: should be triggered from the parameter changed signal */
 		reset_dpi ();
 	}
 
-	RCConfiguration* _rc_config;
+	UIConfiguration* _ui_config;
 	Adjustment _dpi_adjustment;
 	HScale _dpi_slider;
 };
 
+class ClipLevelOptions : public OptionEditorBox
+{
+public:
+	ClipLevelOptions (UIConfiguration* c) 
+		: _ui_config (c)
+		, _clip_level_adjustment (-.5, -50.0, 0.0, 0.1, 1.0) /* units of dB */
+		, _clip_level_slider (_clip_level_adjustment)
+	{
+		_clip_level_adjustment.set_value (_ui_config->get_waveform_clip_level ());
+
+		Label* l = manage (new Label (_("Waveform Clip Level (dBFS):")));
+		l->set_name ("OptionsLabel");
+
+		_clip_level_slider.set_update_policy (UPDATE_DISCONTINUOUS);
+		HBox* h = manage (new HBox);
+		h->set_spacing (4);
+		h->pack_start (*l, false, false);
+		h->pack_start (_clip_level_slider, true, true);
+
+		_box->pack_start (*h, false, false);
+
+		_clip_level_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &ClipLevelOptions::clip_level_changed));
+	}
+
+	void parameter_changed (string const & p)
+	{
+		if (p == "waveform-clip-level") {
+			_clip_level_adjustment.set_value (_ui_config->get_waveform_clip_level());
+		}
+	}
+
+	void set_state_from_config ()
+	{
+		parameter_changed ("waveform-clip-level");
+	}
+
+private:
+
+	void clip_level_changed ()
+	{
+		_ui_config->set_waveform_clip_level (_clip_level_adjustment.get_value());
+		/* XXX: should be triggered from the parameter changed signal */
+		ArdourCanvas::WaveView::set_clip_level (_clip_level_adjustment.get_value());
+	}
+
+	UIConfiguration* _ui_config;
+	Adjustment _clip_level_adjustment;
+	HScale _clip_level_slider;
+};
+
 class BufferingOptions : public OptionEditorBox
 {
 public:
@@ -737,17 +1195,7 @@ private:
 			if (!was_enabled) {
 				ControlProtocolManager::instance().activate (*cpi);
 			} else {
-				Gtk::Window* win = r[_model.editor];
-				if (win) {
-					win->hide ();
-				}
-
 				ControlProtocolManager::instance().deactivate (*cpi);
-					
-				if (win) {
-					delete win;
-					r[_model.editor] = 0;
-				}
 			}
 		}
 
@@ -759,8 +1207,8 @@ private:
 		}
 	}
 
-        void edit_clicked (GdkEventButton* ev)
-        {
+	void edit_clicked (GdkEventButton* ev)
+	{
 		if (ev->type != GDK_2BUTTON_PRESS) {
 			return;
 		}
@@ -770,26 +1218,32 @@ private:
 		TreeModel::Row row;
 
 		row = *(_view.get_selection()->get_selected());
-
-		Window* win = row[_model.editor];
-		if (win && !win->is_visible()) {
-			win->present ();
-		} else {
-			cpi = row[_model.protocol_info];
-
-			if (cpi && cpi->protocol && cpi->protocol->has_editor ()) {
-				Box* box = (Box*) cpi->protocol->get_gui ();
-				if (box) {
-					string title = row[_model.name];
-					ArdourWindow* win = new ArdourWindow (_parent, title);
-					win->set_title ("Control Protocol Options");
-					win->add (*box);
-					box->show ();
-					win->present ();
-					row[_model.editor] = win;
-				}
-			}
+		if (!row[_model.enabled]) {
+			return;
+		}
+		cpi = row[_model.protocol_info];
+		if (!cpi || !cpi->protocol || !cpi->protocol->has_editor ()) {
+			return;
 		}
+		Box* box = (Box*) cpi->protocol->get_gui ();
+		if (!box) {
+			return;
+		}
+		if (box->get_parent()) {
+			static_cast<ArdourWindow*>(box->get_parent())->present();
+			return;
+		}
+		string title = row[_model.name];
+		/* once created, the window is managed by the surface itself (as ->get_parent())
+		 * Surface's tear_down_gui() is called on session close, when de-activating
+		 * or re-initializing a surface.
+		 * tear_down_gui() hides an deletes the Window if it exists.
+		 */
+		ArdourWindow* win = new ArdourWindow (_parent, title);
+		win->set_title ("Control Protocol Options");
+		win->add (*box);
+		box->show ();
+		win->present ();
 	}
 
         class ControlSurfacesModelColumns : public TreeModelColumnRecord
@@ -802,14 +1256,12 @@ private:
 			add (enabled);
 			add (feedback);
 			add (protocol_info);
-			add (editor);
 		}
 
 		TreeModelColumn<string> name;
 		TreeModelColumn<bool> enabled;
 		TreeModelColumn<bool> feedback;
 		TreeModelColumn<ControlProtocolInfo*> protocol_info;
-	        TreeModelColumn<Gtk::Window*> editor;
 	};
 
 	Glib::RefPtr<ListStore> _store;
@@ -938,6 +1390,224 @@ private:
 	CheckButton _video_advanced_setup_button;
 };
 
+class PluginOptions : public OptionEditorBox
+{
+public:
+	PluginOptions (RCConfiguration* c, UIConfiguration* uic)
+		: _rc_config (c)
+		, _ui_config (uic)
+		, _display_plugin_scan_progress (_("Always Display Plugin Scan Progress"))
+		, _discover_vst_on_start (_("Scan for [new] VST Plugins on Application Start"))
+		, _discover_au_on_start (_("Scan for AudioUnit Plugins on Application Start"))
+		, _timeout_adjustment (0, 0, 3000, 50, 50)
+		, _timeout_slider (_timeout_adjustment)
+	{
+		Label *l;
+		std::stringstream ss;
+		Table* t = manage (new Table (2, 6));
+		t->set_spacings (4);
+		Button* b;
+		int n = 0;
+
+		ss << "<b>" << _("General") << "</b>";
+		l = manage (left_aligned_label (ss.str()));
+		l->set_use_markup (true);
+		t->attach (*manage (new Label ("")), 0, 3, n, n+1, FILL | EXPAND); ++n;
+		t->attach (*l, 0, 2, n, n+1, FILL | EXPAND); ++n;
+
+		b = manage (new Button (_("Scan for Plugins")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::refresh_clicked));
+		t->attach (*b, 0, 2, n, n+1, FILL); ++n;
+
+		t->attach (_display_plugin_scan_progress, 0, 2, n, n+1); ++n;
+		_display_plugin_scan_progress.signal_toggled().connect (sigc::mem_fun (*this, &PluginOptions::display_plugin_scan_progress_toggled));
+		Gtkmm2ext::UI::instance()->set_tip (_display_plugin_scan_progress,
+					    _("<b>When enabled</b> a popup window showing plugin scan progress is displayed for indexing (cache load) and discovery (detect new plugins)"));
+
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
+		_timeout_slider.set_digits (0);
+		_timeout_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &PluginOptions::timeout_changed));
+
+		Gtkmm2ext::UI::instance()->set_tip(_timeout_slider,
+			 _("Specify the default timeout for plugin instantiation in 1/10 seconds. Plugins that require more time to load will be blacklisted. A value of 0 disables the timeout."));
+
+		l = manage (left_aligned_label (_("Scan Time Out [deciseconds]")));;
+		HBox* h = manage (new HBox);
+		h->set_spacing (4);
+		h->pack_start (*l, false, false);
+		h->pack_start (_timeout_slider, true, true);
+		t->attach (*h, 0, 2, n, n+1); ++n;
+
+		ss.str("");
+		ss << "<b>" << _("VST") << "</b>";
+		l = manage (left_aligned_label (ss.str()));
+		l->set_use_markup (true);
+		t->attach (*manage (new Label ("")), 0, 3, n, n+1, FILL | EXPAND); ++n;
+		t->attach (*l, 0, 2, n, n+1, FILL | EXPAND); ++n;
+
+		b = manage (new Button (_("Clear VST Cache")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::clear_vst_cache_clicked));
+		t->attach (*b, 0, 1, n, n+1, FILL);
+
+		b = manage (new Button (_("Clear VST Blacklist")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::clear_vst_blacklist_clicked));
+		t->attach (*b, 1, 2, n, n+1, FILL);
+		++n;
+
+		t->attach (_discover_vst_on_start, 0, 2, n, n+1); ++n;
+		_discover_vst_on_start.signal_toggled().connect (sigc::mem_fun (*this, &PluginOptions::discover_vst_on_start_toggled));
+		Gtkmm2ext::UI::instance()->set_tip (_discover_vst_on_start,
+					    _("<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"));
+
+#ifdef LXVST_SUPPORT
+		t->attach (*manage (left_aligned_label (_("Linux VST Path:"))), 0, 1, n, n+1);
+		b = manage (new Button (_("Edit")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::edit_lxvst_path_clicked));
+		t->attach (*b, 1, 2, n, n+1, FILL); ++n;
+#endif
+
+#ifdef WINDOWS_VST_SUPPORT
+		t->attach (*manage (left_aligned_label (_("Windows VST Path:"))), 0, 1, n, n+1);
+		b = manage (new Button (_("Edit")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::edit_vst_path_clicked));
+		t->attach (*b, 1, 2, n, n+1, FILL); ++n;
+#endif
+#endif // any VST
+
+#ifdef AUDIOUNIT_SUPPORT
+		ss.str("");
+		ss << "<b>" << _("Audio Unit") << "</b>";
+		l = manage (left_aligned_label (ss.str()));
+		l->set_use_markup (true);
+		t->attach (*manage (new Label ("")), 0, 3, n, n+1, FILL | EXPAND); ++n;
+		t->attach (*l, 0, 2, n, n+1, FILL | EXPAND); ++n;
+
+		t->attach (_discover_au_on_start, 0, 2, n, n+1); ++n;
+		_discover_au_on_start.signal_toggled().connect (sigc::mem_fun (*this, &PluginOptions::discover_au_on_start_toggled));
+		Gtkmm2ext::UI::instance()->set_tip (_discover_au_on_start,
+					    _("<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."));
+
+		++n;
+		b = manage (new Button (_("Clear AU Cache")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::clear_au_cache_clicked));
+		t->attach (*b, 0, 1, n, n+1, FILL);
+
+		b = manage (new Button (_("Clear AU Blacklist")));
+		b->signal_clicked().connect (sigc::mem_fun (*this, &PluginOptions::clear_au_blacklist_clicked));
+		t->attach (*b, 1, 2, n, n+1, FILL);
+		++n;
+#endif
+
+		_box->pack_start (*t,true,true);
+	}
+
+	void parameter_changed (string const & p) {
+		if (p == "show-plugin-scan-window") {
+			bool const x = _ui_config->get_show_plugin_scan_window();
+			_display_plugin_scan_progress.set_active (x);
+		}
+		else if (p == "discover-vst-on-start") {
+			bool const x = _rc_config->get_discover_vst_on_start();
+			_discover_vst_on_start.set_active (x);
+		}
+		else if (p == "vst-scan-timeout") {
+			int const x = _rc_config->get_vst_scan_timeout();
+			_timeout_adjustment.set_value (x);
+		}
+		else if (p == "discover-audio-units") {
+			bool const x = _rc_config->get_discover_audio_units();
+			_discover_au_on_start.set_active (x);
+		}
+	}
+
+	void set_state_from_config () {
+		parameter_changed ("show-plugin-scan-window");
+		parameter_changed ("discover-vst-on-start");
+		parameter_changed ("vst-scan-timeout");
+		parameter_changed ("discover-audio-units");
+	}
+
+private:
+	RCConfiguration* _rc_config;
+	UIConfiguration* _ui_config;
+	CheckButton _display_plugin_scan_progress;
+	CheckButton _discover_vst_on_start;
+	CheckButton _discover_au_on_start;
+	Adjustment _timeout_adjustment;
+	HScale _timeout_slider;
+
+	void display_plugin_scan_progress_toggled () {
+		bool const x = _display_plugin_scan_progress.get_active();
+		_ui_config->set_show_plugin_scan_window(x);
+	}
+
+	void discover_vst_on_start_toggled () {
+		bool const x = _discover_vst_on_start.get_active();
+		_rc_config->set_discover_vst_on_start(x);
+	}
+
+	void discover_au_on_start_toggled () {
+		bool const x = _discover_au_on_start.get_active();
+		_rc_config->set_discover_audio_units(x);
+	}
+
+	void timeout_changed () {
+		int x = floor(_timeout_adjustment.get_value());
+		_rc_config->set_vst_scan_timeout(x);
+	}
+
+	void clear_vst_cache_clicked () {
+		PluginManager::instance().clear_vst_cache();
+	}
+
+	void clear_vst_blacklist_clicked () {
+		PluginManager::instance().clear_vst_blacklist();
+	}
+
+	void clear_au_cache_clicked () {
+		PluginManager::instance().clear_au_cache();
+	}
+
+	void clear_au_blacklist_clicked () {
+		PluginManager::instance().clear_au_blacklist();
+	}
+
+
+	void edit_vst_path_clicked () {
+		Gtkmm2ext::PathsDialog *pd = new Gtkmm2ext::PathsDialog (
+				_("Set Windows VST Search Path"),
+				_rc_config->get_plugin_path_vst(),
+				PluginManager::instance().get_default_windows_vst_path()
+			);
+		ResponseType r = (ResponseType) pd->run ();
+		pd->hide();
+		if (r == RESPONSE_ACCEPT) {
+			_rc_config->set_plugin_path_vst(pd->get_serialized_paths());
+		}
+		delete pd;
+	}
+
+	// todo consolidate with edit_vst_path_clicked..
+	void edit_lxvst_path_clicked () {
+		Gtkmm2ext::PathsDialog *pd = new Gtkmm2ext::PathsDialog (
+				_("Set Linux VST Search Path"),
+				_rc_config->get_plugin_path_lxvst(),
+				PluginManager::instance().get_default_lxvst_path()
+				);
+		ResponseType r = (ResponseType) pd->run ();
+		pd->hide();
+		if (r == RESPONSE_ACCEPT) {
+			_rc_config->set_plugin_path_lxvst(pd->get_serialized_paths());
+		}
+		delete pd;
+	}
+
+	void refresh_clicked () {
+		PluginManager::instance().refresh();
+	}
+};
+
+
 /** A class which allows control of visibility of some editor components usign
  *  a VisibilityGroup.  The caller should pass in a `dummy' VisibilityGroup
  *  which has the correct members, but with null widget pointers.  This
@@ -1003,7 +1673,8 @@ private:
 RCOptionEditor::RCOptionEditor ()
 	: OptionEditor (Config, string_compose (_("%1 Preferences"), PROGRAM_NAME))
         , _rc_config (Config)
-	, _mixer_strip_visibility ("mixer-strip-visibility")
+	, _ui_config (ARDOUR_UI::config())
+	, _mixer_strip_visibility ("mixer-element-visibility")
 {
 	/* MISC */
 
@@ -1059,8 +1730,8 @@ RCOptionEditor::RCOptionEditor ()
 	     new BoolOption (
 		     "only-copy-imported-files",
 		     _("Always copy imported files"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_only_copy_imported_files),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_only_copy_imported_files)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_only_copy_imported_files),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_only_copy_imported_files)
 		     ));
 
 	add_option (_("Misc"), new DirectoryOption (
@@ -1124,6 +1795,17 @@ RCOptionEditor::RCOptionEditor ()
 	// Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), _(""));
 	add_option (_("Transport"), tsf);
 
+	tsf = new BoolOption (
+		     "loop-is-mode",
+		     _("Play loop is a transport mode"),
+		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_loop_is_mode),
+		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_loop_is_mode)
+		     );
+	Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), 
+					    (_("<b>When enabled</b> the loop button does not start playback but forces playback to always play the loop\n\n"
+					       "<b>When disabled</b> the loop button starts playing the loop, but stop then cancels loop playback")));
+	add_option (_("Transport"), tsf);
+	
 	tsf = new BoolOption (
 		     "stop-recording-on-xrun",
 		     _("Stop recording when an xrun occurs"),
@@ -1198,7 +1880,6 @@ RCOptionEditor::RCOptionEditor ()
 		sigc::mem_fun (*_rc_config, &RCConfiguration::set_sync_source)
 		);
 
-	populate_sync_options ();
 	add_option (_("Transport"), _sync_source);
 
 	_sync_framerate = new BoolOption (
@@ -1219,13 +1900,21 @@ RCOptionEditor::RCOptionEditor ()
 
 	_sync_genlock = new BoolOption (
 		"timecode-source-is-synced",
-		_("External timecode is sync locked"),
+		_("Sync-lock timecode to clock (disable drift compensation)"),
 		sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_source_is_synced),
 		sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_source_is_synced)
 		);
 	Gtkmm2ext::UI::instance()->set_tip 
-		(_sync_genlock->tip_widget(), 
-		 _("<b>When enabled</b> indicates that the selected external timecode source shares sync (Black &amp; Burst, Wordclock, etc) with the audio interface."));
+		(_sync_genlock->tip_widget(),
+		 string_compose (_("<b>When enabled</b> %1 will never varispeed when slaved to external timecode. "
+				   "Sync Lock indicates that the selected external timecode source shares clock-sync "
+				   "(Black &amp; Burst, Wordclock, etc) with the audio interface. "
+				   "This option disables drift compensation. The transport speed is fixed at 1.0. "
+				   "Vari-speed LTC will be ignored and cause drift."
+				   "\n\n"
+				   "<b>When disabled</b> %1 will compensate for potential drift, regardless if the "
+				   "timecode sources shares clock sync."
+				  ), PROGRAM_NAME));
 
 
 	add_option (_("Transport"), _sync_genlock);
@@ -1262,6 +1951,8 @@ RCOptionEditor::RCOptionEditor ()
 	AudioEngine::instance()->get_physical_inputs (DataType::AUDIO, physical_inputs);
 	_ltc_port->set_popdown_strings (physical_inputs);
 
+	populate_sync_options ();
+
 	add_option (_("Transport"), _ltc_port);
 
 	// TODO; rather disable this button than not compile it..
@@ -1277,7 +1968,7 @@ RCOptionEditor::RCOptionEditor ()
 
 	_ltc_send_continuously = new BoolOption (
 			    "ltc-send-continuously",
-			    _("send LTC while stopped"),
+			    _("Send LTC while stopped"),
 			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_ltc_send_continuously),
 			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_ltc_send_continuously)
 			    );
@@ -1302,12 +1993,12 @@ RCOptionEditor::RCOptionEditor ()
 
 	/* EDITOR */
 
-	add_option (_("Editor"),
+	add_option (S_("Editor"),
 	     new BoolOption (
-		     "link-region-and-track-selection",
-		     _("Link selection of regions and tracks"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_link_region_and_track_selection),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_region_and_track_selection)
+		     "draggable-playhead",
+		     _("Allow dragging of playhead"),
+		     sigc::mem_fun (*ARDOUR_UI::config(), &UIConfiguration::get_draggable_playhead),
+		     sigc::mem_fun (*ARDOUR_UI::config(), &UIConfiguration::set_draggable_playhead)
 		     ));
 
 	add_option (_("Editor"),
@@ -1322,18 +2013,37 @@ RCOptionEditor::RCOptionEditor ()
 	     new BoolOption (
 		     "show-track-meters",
 		     _("Show meters on tracks in the editor"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_track_meters),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_track_meters)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_track_meters),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_track_meters)
 		     ));
 
 	add_option (_("Editor"),
 	     new BoolOption (
 		     "show-editor-meter",
 		     _("Display master-meter in the toolbar"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_editor_meter),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_editor_meter)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_editor_meter),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_editor_meter)
 		     ));
 
+	ComboOption<FadeShape>* fadeshape = new ComboOption<FadeShape> (
+			"default-fade-shape",
+			_("Default fade shape"),
+			sigc::mem_fun (*_rc_config,
+				&RCConfiguration::get_default_fade_shape),
+			sigc::mem_fun (*_rc_config,
+				&RCConfiguration::set_default_fade_shape)
+			);
+
+	fadeshape->add (FadeLinear,
+			_("Linear (for highly correlated material)"));
+	fadeshape->add (FadeConstantPower, _("Constant power"));
+	fadeshape->add (FadeSymmetric, _("Symmetric"));
+	fadeshape->add (FadeSlow, _("Slow"));
+	fadeshape->add (FadeFast, _("Fast"));
+
+	add_option (_("Editor"), fadeshape);
+
+
 	bco = new BoolComboOption (
 		     "use-overlap-equivalency",
 		     _("Regions in active edit groups are edited together"),
@@ -1345,20 +2055,31 @@ RCOptionEditor::RCOptionEditor ()
 
 	add_option (_("Editor"), bco);
 
+	ComboOption<LayerModel>* lm = new ComboOption<LayerModel> (
+		"layer-model",
+		_("Layering model"),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::get_layer_model),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::set_layer_model)
+		);
+
+	lm->add (LaterHigher, _("later is higher"));
+	lm->add (Manual, _("manual layering"));
+	add_option (_("Editor"), lm);
+
 	add_option (_("Editor"),
 	     new BoolOption (
 		     "rubberbanding-snaps-to-grid",
 		     _("Make rubberband selection rectangle snap to the grid"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_rubberbanding_snaps_to_grid),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_rubberbanding_snaps_to_grid)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_rubberbanding_snaps_to_grid),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_rubberbanding_snaps_to_grid)
 		     ));
 
 	add_option (_("Editor"),
 	     new BoolOption (
 		     "show-waveforms",
 		     _("Show waveforms in regions"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_waveforms),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_waveforms)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_waveforms),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_waveforms)
 		     ));
 
 	add_option (_("Editor"),
@@ -1366,16 +2087,16 @@ RCOptionEditor::RCOptionEditor ()
 		     "show-region-gain-envelopes",
 		     _("Show gain envelopes in audio regions"),
 		     _("in all modes"),
-		     _("only in region gain mode"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_region_gain),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_region_gain)
+		     _("only in Draw and Internal Edit modes"),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_region_gain),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_region_gain)
 		     ));
 
 	ComboOption<WaveformScale>* wfs = new ComboOption<WaveformScale> (
 		"waveform-scale",
 		_("Waveform scale"),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::get_waveform_scale),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::set_waveform_scale)
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_waveform_scale),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_waveform_scale)
 		);
 
 	wfs->add (Linear, _("linear"));
@@ -1386,8 +2107,8 @@ RCOptionEditor::RCOptionEditor ()
 	ComboOption<WaveformShape>* wfsh = new ComboOption<WaveformShape> (
 		"waveform-shape",
 		_("Waveform shape"),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::get_waveform_shape),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::set_waveform_shape)
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_waveform_shape),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_waveform_shape)
 		);
 
 	wfsh->add (Traditional, _("traditional"));
@@ -1395,51 +2116,37 @@ RCOptionEditor::RCOptionEditor ()
 
 	add_option (_("Editor"), wfsh);
 
+	add_option (_("Editor"), new ClipLevelOptions (_ui_config));
+
 	add_option (_("Editor"),
 	     new BoolOption (
 		     "show-waveforms-while-recording",
 		     _("Show waveforms for audio while it is being recorded"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_waveforms_while_recording),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_waveforms_while_recording)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_waveforms_while_recording),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_waveforms_while_recording)
 		     ));
 
 	add_option (_("Editor"),
 		    new BoolOption (
 			    "show-zoom-tools",
 			    _("Show zoom toolbar"),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_zoom_tools),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_zoom_tools)
-			    ));
-
-	add_option (_("Editor"),
-		    new BoolOption (
-			    "color-regions-using-track-color",
-			    _("Color regions using their track's color"),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_color_regions_using_track_color),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_color_regions_using_track_color)
+			    sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_zoom_tools),
+			    sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_zoom_tools)
 			    ));
 
 	add_option (_("Editor"),
 		    new BoolOption (
 			    "update-editor-during-summary-drag",
 			    _("Update editor window during drags of the summary"),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_update_editor_during_summary_drag),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_update_editor_during_summary_drag)
+			    sigc::mem_fun (*_ui_config, &UIConfiguration::get_update_editor_during_summary_drag),
+			    sigc::mem_fun (*_ui_config, &UIConfiguration::set_update_editor_during_summary_drag)
 			    ));
 
-	add_option (_("Editor"),
-	     new BoolOption (
-		     "link-editor-and-mixer-selection",
-		     _("Synchronise editor and mixer selection"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_link_editor_and_mixer_selection),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_editor_and_mixer_selection)
-		     ));
-
 	bo = new BoolOption (
 		     "name-new-markers",
 		     _("Name new markers"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_name_new_markers),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_name_new_markers)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_name_new_markers),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_name_new_markers)
 		);
 	
 	add_option (_("Editor"), bo);
@@ -1450,10 +2157,29 @@ RCOptionEditor::RCOptionEditor ()
 	    new BoolOption (
 		    "autoscroll-editor",
 		    _("Auto-scroll editor window when dragging near its edges"),
-		    sigc::mem_fun (*_rc_config, &RCConfiguration::get_autoscroll_editor),
-		    sigc::mem_fun (*_rc_config, &RCConfiguration::set_autoscroll_editor)
+		    sigc::mem_fun (*_ui_config, &UIConfiguration::get_autoscroll_editor),
+		    sigc::mem_fun (*_ui_config, &UIConfiguration::set_autoscroll_editor)
 		    ));
 
+	ComboOption<RegionSelectionAfterSplit> *rsas = new ComboOption<RegionSelectionAfterSplit> (
+		    "region-selection-after-split",
+		    _("After splitting selected regions, select"),
+		    sigc::mem_fun (*_rc_config, &RCConfiguration::get_region_selection_after_split),
+		    sigc::mem_fun (*_rc_config, &RCConfiguration::set_region_selection_after_split));
+
+	// TODO: decide which of these modes are really useful
+	rsas->add(None, _("no regions"));
+	// rsas->add(NewlyCreatedLeft, _("newly-created regions before the split"));
+	// rsas->add(NewlyCreatedRight, _("newly-created regions after the split"));
+	rsas->add(NewlyCreatedBoth, _("newly-created regions"));
+	// rsas->add(Existing, _("unmodified regions in the existing selection"));
+	// rsas->add(ExistingNewlyCreatedLeft, _("existing selection and newly-created regions before the split"));
+	// rsas->add(ExistingNewlyCreatedRight, _("existing selection and newly-created regions after the split"));
+	rsas->add(ExistingNewlyCreatedBoth, _("existing selection and newly-created regions"));
+
+	add_option (_("Editor"), rsas);
+
+
 	/* AUDIO */
 
 	add_option (_("Audio"), new OptionEditorHeading (_("Buffering")));
@@ -1473,7 +2199,9 @@ RCOptionEditor::RCOptionEditor ()
                 mm->add (HardwareMonitoring, _("via Audio Driver"));
         }
 
-	mm->add (SoftwareMonitoring, _("ardour"));
+	string prog (PROGRAM_NAME);
+	boost::algorithm::to_lower (prog);
+	mm->add (SoftwareMonitoring, string_compose (_("%1"), prog));
 	mm->add (ExternalMonitoring, _("audio hardware"));
 
 	add_option (_("Audio"), mm);
@@ -1538,20 +2266,34 @@ RCOptionEditor::RCOptionEditor ()
 		sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_model)
 		);
 
+	int dmsize = 1;
 	dm->add (DenormalNone, _("no processor handling"));
 
 	FPU fpu;
 
 	if (fpu.has_flush_to_zero()) {
+		++dmsize;
 		dm->add (DenormalFTZ, _("use FlushToZero"));
+	} else if (_rc_config->get_denormal_model() == DenormalFTZ) {
+		_rc_config->set_denormal_model(DenormalNone);
 	}
 
 	if (fpu.has_denormals_are_zero()) {
+		++dmsize;
 		dm->add (DenormalDAZ, _("use DenormalsAreZero"));
+	} else if (_rc_config->get_denormal_model() == DenormalDAZ) {
+		_rc_config->set_denormal_model(DenormalNone);
 	}
 
 	if (fpu.has_flush_to_zero() && fpu.has_denormals_are_zero()) {
+		++dmsize;
 		dm->add (DenormalFTZDAZ, _("use FlushToZero and DenormalsAreZero"));
+	} else if (_rc_config->get_denormal_model() == DenormalFTZDAZ) {
+		_rc_config->set_denormal_model(DenormalNone);
+	}
+
+	if (dmsize == 1) {
+		dm->set_sensitive(false);
 	}
 
 	add_option (_("Audio"), dm);
@@ -1574,6 +2316,8 @@ RCOptionEditor::RCOptionEditor ()
 		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_new_plugins_active)
 		     ));
 
+	add_option (_("Audio"), new OptionEditorHeading (_("Regions")));
+
 	add_option (_("Audio"),
 	     new BoolOption (
 		     "auto-analyse-audio",
@@ -1717,6 +2461,16 @@ RCOptionEditor::RCOptionEditor ()
 		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_send_and_route_panner)
 		     ));
 
+	add_option (_("MIDI"),
+		    new SpinOption<float> (
+			    "midi-readahead",
+			    _("MIDI read-ahead time (seconds)"),
+			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_readahead),
+			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_readahead),
+			    0.1, 10, 0.1, 1,
+			    "", 1.0, 1
+			    ));
+
 	add_option (_("MIDI"),
 		    new BoolOption (
 			    "send-midi-clock",
@@ -1795,7 +2549,7 @@ RCOptionEditor::RCOptionEditor ()
 
 	add_option (_("MIDI"),
 		    new BoolOption (
-			    "diplay-first-midi-bank-as-zero",
+			    "display-first-midi-bank-as-zero",
 			    _("Display first MIDI bank/program as 0"),
 			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_first_midi_bank_is_zero),
 			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_first_midi_bank_is_zero)
@@ -1805,16 +2559,16 @@ RCOptionEditor::RCOptionEditor ()
 	     new BoolOption (
 		     "never-display-periodic-midi",
 		     _("Never display periodic MIDI messages (MTC, MIDI Clock)"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_never_display_periodic_midi),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_never_display_periodic_midi)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_never_display_periodic_midi),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_never_display_periodic_midi)
 		     ));
 
 	add_option (_("MIDI"),
 	     new BoolOption (
 		     "sound-midi-notes",
 		     _("Sound MIDI notes as they are selected"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_sound_midi_notes),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_sound_midi_notes)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_sound_midi_notes),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_sound_midi_notes)
 		     ));
 
 	add_option (_("MIDI"), new OptionEditorHeading (_("Midi Audition")));
@@ -1844,7 +2598,14 @@ RCOptionEditor::RCOptionEditor ()
 
 	/* USER INTERACTION */
 
-	if (getenv ("ARDOUR_BUNDLED")) {
+	if (
+#ifdef PLATFORM_WINDOWS
+			true
+#else
+			getenv ("ARDOUR_BUNDLED")
+#endif
+	   )
+	{
 		add_option (_("User interaction"), 
 			    new BoolOption (
 				    "enable-translation",
@@ -1878,53 +2639,112 @@ RCOptionEditor::RCOptionEditor ()
 	/* VIDEO Timeline */
 	add_option (_("Video"), new VideoTimelineOptions (_rc_config));
 
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined AUDIOUNIT_SUPPORT)
+	/* Plugin options (currrently VST only) */
+	add_option (_("Plugins"), new PluginOptions (_rc_config, _ui_config));
+#endif
+
 	/* INTERFACE */
 
+#ifdef CAIRO_SUPPORTS_FORCE_BUGGY_GRADIENTS_ENVIRONMENT_VARIABLE
+	BoolOption* bgo = new BoolOption (
+		"buggy-gradients",
+		_("Possibly improve slow graphical performance"),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_buggy_gradients),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_buggy_gradients)
+		);
+
+	Gtkmm2ext::UI::instance()->set_tip (bgo->tip_widget(), string_compose (_("This requires restarting %1 before having an effect"), PROGRAM_NAME));
+	add_option (S_("Preferences|GUI"), bgo);
+#endif
+	
 	add_option (S_("Preferences|GUI"),
 	     new BoolOption (
 		     "widget-prelight",
 		     _("Graphically indicate mouse pointer hovering over various widgets"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_widget_prelight),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_widget_prelight)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_widget_prelight),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_widget_prelight)
 		     ));
 
+#ifdef TOOLTIPS_GOT_FIXED
 	add_option (S_("Preferences|GUI"),
 	     new BoolOption (
 		     "use-tooltips",
 		     _("Show tooltips if mouse hovers over a control"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_use_tooltips),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_use_tooltips)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_use_tooltips),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_use_tooltips)
+		     ));
+#endif
+
+	add_option (S_("Preferences|GUI"),
+	     new BoolOption (
+		     "show-name-highlight",
+		     _("Use name highlight bars in region displays (requires a restart)"),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_show_name_highlight),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_show_name_highlight)
 		     ));
 
 #ifndef GTKOSX
 	/* font scaling does nothing with GDK/Quartz */
-	add_option (S_("Preferences|GUI"), new FontScalingOptions (_rc_config));
+	add_option (S_("Preferences|GUI"), new FontScalingOptions (_ui_config));
 #endif
 
 	add_option (S_("GUI"),
 		    new BoolOption (
 			    "super-rapid-clock-update",
-			    _("update transport clock display every 40ms instead of every 100ms"),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::get_super_rapid_clock_update),
-			    sigc::mem_fun (*_rc_config, &RCConfiguration::set_super_rapid_clock_update)
+			    _("update transport clock display at FPS instead of every 100ms"),
+			    sigc::mem_fun (*_ui_config, &UIConfiguration::get_super_rapid_clock_update),
+			    sigc::mem_fun (*_ui_config, &UIConfiguration::set_super_rapid_clock_update)
 			    ));
 
+
+	/* Image cache size */
+
+	Gtk::Adjustment *ics = manage (new Gtk::Adjustment(0, 1, 1024, 10)); /* 1 MB to 1GB in steps of 10MB */
+	HSliderOption *sics = new HSliderOption("waveform-cache-size",
+						_("Waveform image cache size (megabytes)"),
+						ics,
+						sigc::mem_fun (*ARDOUR_UI::config(), &UIConfiguration::get_waveform_cache_size),
+						sigc::mem_fun (*ARDOUR_UI::config(), &UIConfiguration::set_waveform_cache_size)
+			);
+	sics->scale().set_digits (0);
+	Gtkmm2ext::UI::instance()->set_tip
+		(sics->tip_widget(),
+		 _("Larger values lead to using more memory to store images of waveforms, which can improve graphical performance."));
+	add_option (S_("Preferences|GUI"), sics);
+	
+	/* Lock GUI timeout */
+
+	Gtk::Adjustment *lts = manage (new Gtk::Adjustment(0, 0, 1000, 1, 10));
+	HSliderOption *slts = new HSliderOption("lock-gui-after-seconds",
+						_("Lock timeout (seconds)"),
+						lts,
+						sigc::mem_fun (*ARDOUR_UI::config(), &UIConfiguration::get_lock_gui_after_seconds),
+						sigc::mem_fun (*ARDOUR_UI::config(), &UIConfiguration::set_lock_gui_after_seconds)
+			);
+	slts->scale().set_digits (0);
+	Gtkmm2ext::UI::instance()->set_tip
+		(slts->tip_widget(),
+		 _("Lock GUI after this many idle seconds (zero to never lock)"));
+	add_option (S_("Preferences|GUI"), slts);
+
 	/* The names of these controls must be the same as those given in MixerStrip
 	   for the actual widgets being controlled.
 	*/
+	_mixer_strip_visibility.add (0, X_("Input"), _("Input"));
 	_mixer_strip_visibility.add (0, X_("PhaseInvert"), _("Phase Invert"));
-	_mixer_strip_visibility.add (0, X_("SoloSafe"), _("Solo Safe"));
-	_mixer_strip_visibility.add (0, X_("SoloIsolated"), _("Solo Isolated"));
+	_mixer_strip_visibility.add (0, X_("RecMon"), _("Record & Monitor"));
+	_mixer_strip_visibility.add (0, X_("SoloIsoLock"), _("Solo Iso / Lock"));
+	_mixer_strip_visibility.add (0, X_("Output"), _("Output"));
 	_mixer_strip_visibility.add (0, X_("Comments"), _("Comments"));
-	_mixer_strip_visibility.add (0, X_("MeterPoint"), _("Meter Point"));
 	
 	add_option (
 		S_("Preferences|GUI"),
 		new VisibilityOption (
 			_("Mixer Strip"),
 			&_mixer_strip_visibility,
-			sigc::mem_fun (*_rc_config, &RCConfiguration::get_mixer_strip_visibility),
-			sigc::mem_fun (*_rc_config, &RCConfiguration::set_mixer_strip_visibility)
+			sigc::mem_fun (*_ui_config, &UIConfiguration::get_mixer_strip_visibility),
+			sigc::mem_fun (*_ui_config, &UIConfiguration::set_mixer_strip_visibility)
 			)
 		);
 
@@ -1932,17 +2752,17 @@ RCOptionEditor::RCOptionEditor ()
 	     new BoolOption (
 		     "default-narrow_ms",
 		     _("Use narrow strips in the mixer by default"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_default_narrow_ms),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_default_narrow_ms)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_default_narrow_ms),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_default_narrow_ms)
 		     ));
 
-	add_option (S_("Preferences|GUI"), new OptionEditorHeading (_("Metering")));
+	add_option (S_("Preferences|Metering"), new OptionEditorHeading (_("Metering")));
 
 	ComboOption<float>* mht = new ComboOption<float> (
 		"meter-hold",
 		_("Peak hold time"),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_hold),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_hold)
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_meter_hold),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_hold)
 		);
 
 	mht->add (MeterHoldOff, _("off"));
@@ -1950,7 +2770,7 @@ RCOptionEditor::RCOptionEditor ()
 	mht->add (MeterHoldMedium, _("medium"));
 	mht->add (MeterHoldLong, _("long"));
 
-	add_option (S_("Preferences|GUI"), mht);
+	add_option (S_("Preferences|Metering"), mht);
 
 	ComboOption<float>* mfo = new ComboOption<float> (
 		"meter-falloff",
@@ -1969,13 +2789,13 @@ RCOptionEditor::RCOptionEditor ()
 	mfo->add (METER_FALLOFF_FASTER,   _("faster [46dB/sec]"));
 	mfo->add (METER_FALLOFF_FASTEST,  _("fastest [70dB/sec]"));
 
-	add_option (S_("Preferences|GUI"), mfo);
+	add_option (S_("Preferences|Metering"), mfo);
 
 	ComboOption<MeterLineUp>* mlu = new ComboOption<MeterLineUp> (
 		"meter-line-up-level",
 		_("Meter line-up level; 0dBu"),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_line_up_level),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_line_up_level)
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_meter_line_up_level),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_line_up_level)
 		);
 
 	mlu->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
@@ -1985,13 +2805,13 @@ RCOptionEditor::RCOptionEditor ()
 
 	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."));
 
-	add_option (S_("Preferences|GUI"), mlu);
+	add_option (S_("Preferences|Metering"), mlu);
 
 	ComboOption<MeterLineUp>* mld = new ComboOption<MeterLineUp> (
 		"meter-line-up-din",
 		_("IEC1/DIN Meter line-up level; 0dBu"),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_line_up_din),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_line_up_din)
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_meter_line_up_din),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_line_up_din)
 		);
 
 	mld->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
@@ -2001,13 +2821,13 @@ RCOptionEditor::RCOptionEditor ()
 
 	Gtkmm2ext::UI::instance()->set_tip (mld->tip_widget(), _("Reference level for IEC1/DIN meter."));
 
-	add_option (S_("Preferences|GUI"), mld);
+	add_option (S_("Preferences|Metering"), mld);
 
 	ComboOption<VUMeterStandard>* mvu = new ComboOption<VUMeterStandard> (
 		"meter-vu-standard",
 		_("VU Meter standard"),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_vu_standard),
-		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_vu_standard)
+		sigc::mem_fun (*_ui_config, &UIConfiguration::get_meter_vu_standard),
+		sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_vu_standard)
 		);
 
 	mvu->add (MeteringVUfrench,   _("0VU = -2dBu (France)"));
@@ -2015,30 +2835,34 @@ RCOptionEditor::RCOptionEditor ()
 	mvu->add (MeteringVUstandard, _("0VU = +4dBu (standard)"));
 	mvu->add (MeteringVUeight,    _("0VU = +8dBu"));
 
-	add_option (S_("Preferences|GUI"), mvu);
+	add_option (S_("Preferences|Metering"), mvu);
 
 	Gtk::Adjustment *mpk = manage (new Gtk::Adjustment(0, -10, 0, .1, .1));
 	HSliderOption *mpks = new HSliderOption("meter-peak",
 			_("Peak threshold [dBFS]"),
 			mpk,
-			sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_peak),
-			sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_peak)
+			sigc::mem_fun (*_ui_config, &UIConfiguration::get_meter_peak),
+			sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_peak)
 			);
 
 	Gtkmm2ext::UI::instance()->set_tip
 		(mpks->tip_widget(),
 		 _("Specify the audio signal level in dbFS at and above which the meter-peak indicator will flash red."));
 
-	add_option (S_("Preferences|GUI"), mpks);
+	add_option (S_("Preferences|Metering"), mpks);
 
-	add_option (S_("Preferences|GUI"),
+	add_option (S_("Preferences|Metering"),
 	     new BoolOption (
 		     "meter-style-led",
 		     _("LED meter style"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_style_led),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_style_led)
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::get_meter_style_led),
+		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_style_led)
 		     ));
 
+	/* and now the theme manager */
+
+	ThemeManager* tm = manage (new ThemeManager);
+	add_page (_("Theme"), *tm);
 }
 
 void
@@ -2093,4 +2917,12 @@ RCOptionEditor::populate_sync_options ()
 	for (vector<SyncSource>::iterator i = sync_opts.begin(); i != sync_opts.end(); ++i) {
 		_sync_source->add (*i, sync_source_to_string (*i));
 	}
+
+	if (sync_opts.empty()) {
+		_sync_source->set_sensitive(false);
+	} else {
+		if (std::find(sync_opts.begin(), sync_opts.end(), _rc_config->get_sync_source()) == sync_opts.end()) {
+			_rc_config->set_sync_source(sync_opts.front());
+		}
+	}
 }