X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Frc_option_editor.cc;h=7dc7a1b0a9a5438691d7baa445608a75af611cec;hb=2083cd8a4ecbad69e76d3b6af2b0947c538c45ee;hp=358ff6e1071d0fcb466a9e55bbc74c1367363c9b;hpb=76cd6236e1054702925a298a3494ef51e34a285d;p=ardour.git

diff --git a/gtk2_ardour/rc_option_editor.cc b/gtk2_ardour/rc_option_editor.cc
index 358ff6e107..7dc7a1b0a9 100644
--- a/gtk2_ardour/rc_option_editor.cc
+++ b/gtk2_ardour/rc_option_editor.cc
@@ -21,6 +21,8 @@
 #include "gtk2ardour-config.h"
 #endif
 
+#include <cairo/cairo.h>
+
 #include <boost/algorithm/string.hpp>    
 
 #include <gtkmm/liststore.h>
@@ -48,6 +50,7 @@
 #include "ardour_window.h"
 #include "ardour_dialog.h"
 #include "gui_thread.h"
+#include "meter_patterns.h"
 #include "midi_tracer.h"
 #include "rc_option_editor.h"
 #include "utils.h"
@@ -271,20 +274,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 }
@@ -319,25 +324,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));
 
@@ -351,19 +388,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));
@@ -378,20 +417,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));
 
@@ -405,24 +589,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");
+
+		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;
 
-		l = manage (left_aligned_label (_("Keyboard layout:")));
+		/* 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, 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, 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 (_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);
 	}
@@ -478,6 +738,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();
@@ -502,6 +774,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());
@@ -520,8 +888,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;
@@ -541,7 +919,7 @@ public:
 	{
 		_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");
@@ -570,7 +948,7 @@ public:
 
 		_box->pack_start (*h, false, false);
 
-		set_note (_("Major font-scale changes require an application restart to re-layout."));
+		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));
 	}
@@ -661,13 +1039,34 @@ public:
                 , _playback_slider (_playback_adjustment)
 		, _capture_slider (_capture_adjustment)
 	{
+		vector<string> presets;
+
+		/* these must match the order of the enums for BufferingPreset */
+		
+		presets.push_back (_("Small sessions (4-16 tracks)"));
+		presets.push_back (_("Medium sessions (16-64 tracks)"));
+		presets.push_back (_("Large sessions (64+ tracks)"));
+		presets.push_back (_("Custom (set by sliders below)"));
+
+		set_popdown_strings (_buffering_presets_combo, presets);
+
+		Label* l = manage (new Label (_("Preset:")));
+		l->set_name ("OptionsLabel");
+		HBox* h = manage (new HBox);
+		h->set_spacing (12);
+		h->pack_start (*l, false, false);
+		h->pack_start (_buffering_presets_combo, true, true);
+		_box->pack_start (*h, false, false);
+
+		_buffering_presets_combo.signal_changed().connect (sigc::mem_fun (*this, &BufferingOptions::preset_changed));
+		
 		_playback_adjustment.set_value (_rc_config->get_audio_playback_buffer_seconds());
 
-		Label* l = manage (new Label (_("Playback (seconds of buffering):")));
+		l = manage (new Label (_("Playback (seconds of buffering):")));
 		l->set_name ("OptionsLabel");
 
 		_playback_slider.set_update_policy (UPDATE_DISCONTINUOUS);
-		HBox* h = manage (new HBox);
+		h = manage (new HBox);
 		h->set_spacing (4);
 		h->pack_start (*l, false, false);
 		h->pack_start (_playback_slider, true, true);
@@ -693,6 +1092,31 @@ public:
 
 	void parameter_changed (string const & p)
 	{
+		if (p == "buffering-preset") {
+			switch (_rc_config->get_buffering_preset()) {
+			case Small:
+				_playback_slider.set_sensitive (false);
+				_capture_slider.set_sensitive (false);
+				_buffering_presets_combo.set_active (0);
+				break;
+			case Medium:
+				_playback_slider.set_sensitive (false);
+				_capture_slider.set_sensitive (false);
+				_buffering_presets_combo.set_active (1);
+				break;
+			case Large:
+				_playback_slider.set_sensitive (false);
+				_capture_slider.set_sensitive (false);
+				_buffering_presets_combo.set_active (2);
+				break;
+			case Custom:
+				_playback_slider.set_sensitive (true);
+				_capture_slider.set_sensitive (true);
+				_buffering_presets_combo.set_active (3);
+				break;
+			}
+		}
+
 		if (p == "playback-buffer-seconds") {
 			_playback_adjustment.set_value (_rc_config->get_audio_playback_buffer_seconds());
 		} else if (p == "capture-buffer-seconds") {
@@ -702,12 +1126,38 @@ public:
 
 	void set_state_from_config ()
 	{
+		parameter_changed ("buffering-preset");
 		parameter_changed ("playback-buffer-seconds");
 		parameter_changed ("capture-buffer-seconds");
 	}
 
 private:
 
+	void preset_changed ()
+	{
+		int index = _buffering_presets_combo.get_active_row_number ();
+		if (index < 0) {
+			return;
+		}
+		switch (index) {
+		case 0:
+			_rc_config->set_buffering_preset (Small);
+			break;
+		case 1:
+			_rc_config->set_buffering_preset (Medium);
+			break;
+		case 2:
+			_rc_config->set_buffering_preset (Large);
+			break;
+		case 3:
+			_rc_config->set_buffering_preset (Custom);
+			break;
+		default:
+			error << string_compose (_("programming error: unknown buffering preset string, index = %1"), index) << endmsg;
+			break;
+		}
+	}
+	
 	void playback_changed ()
 	{
 		_rc_config->set_audio_playback_buffer_seconds ((long) _playback_adjustment.get_value());
@@ -723,6 +1173,7 @@ private:
 	Adjustment _capture_adjustment;
 	HScale _playback_slider;
 	HScale _capture_slider;
+	ComboBoxText _buffering_presets_combo;
 };
 
 class ControlSurfacesOptions : public OptionEditorBox
@@ -1022,6 +1473,7 @@ public:
 		, _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"))
+		, _verbose_plugin_scan (_("Verbose Plugin Scan"))
 		, _timeout_adjustment (0, 0, 3000, 50, 50)
 		, _timeout_slider (_timeout_adjustment)
 	{
@@ -1094,14 +1546,37 @@ public:
 		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;
+
+		// currently verbose logging is only implemented for Windows VST.
+		t->attach (_verbose_plugin_scan, 0, 2, n, n+1); ++n;
+		_verbose_plugin_scan.signal_toggled().connect (sigc::mem_fun (*this, &PluginOptions::verbose_plugin_scan_toggled));
+		Gtkmm2ext::UI::instance()->set_tip (_verbose_plugin_scan,
+					    _("<b>When enabled</b> additional information for every plugin is added to the Log Window."));
 #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);
@@ -1124,6 +1599,10 @@ public:
 			bool const x = _rc_config->get_discover_audio_units();
 			_discover_au_on_start.set_active (x);
 		}
+		else if (p == "verbose-plugin-scan") {
+			bool const x = _rc_config->get_verbose_plugin_scan();
+			_verbose_plugin_scan.set_active (x);
+		}
 	}
 
 	void set_state_from_config () {
@@ -1131,6 +1610,7 @@ public:
 		parameter_changed ("discover-vst-on-start");
 		parameter_changed ("vst-scan-timeout");
 		parameter_changed ("discover-audio-units");
+		parameter_changed ("verbose-plugin-scan");
 	}
 
 private:
@@ -1139,6 +1619,7 @@ private:
 	CheckButton _display_plugin_scan_progress;
 	CheckButton _discover_vst_on_start;
 	CheckButton _discover_au_on_start;
+	CheckButton _verbose_plugin_scan;
 	Adjustment _timeout_adjustment;
 	HScale _timeout_slider;
 
@@ -1157,6 +1638,11 @@ private:
 		_rc_config->set_discover_audio_units(x);
 	}
 
+	void verbose_plugin_scan_toggled () {
+		bool const x = _verbose_plugin_scan.get_active();
+		_rc_config->set_verbose_plugin_scan(x);
+	}
+
 	void timeout_changed () {
 		int x = floor(_timeout_adjustment.get_value());
 		_rc_config->set_vst_scan_timeout(x);
@@ -1170,6 +1656,15 @@ private:
 		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"),
@@ -1381,6 +1876,8 @@ RCOptionEditor::RCOptionEditor ()
 
 	/* TRANSPORT */
 
+	add_option (_("Transport"), new OptionEditorHeading (S_("Transport Options")));
+
 	BoolOption* tsf;
 
 	tsf = new BoolOption (
@@ -1392,17 +1889,6 @@ RCOptionEditor::RCOptionEditor ()
 	// Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), _(""));
 	add_option (_("Transport"), tsf);
 
-	tsf = new BoolOption (
-		     "stop-recording-on-xrun",
-		     _("Stop recording when an xrun occurs"),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun),
-		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun)
-		     );
-	Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), 
-					    string_compose (_("<b>When enabled</b> %1 will stop recording if an over- or underrun is detected by the audio engine"),
-							    PROGRAM_NAME));
-	add_option (_("Transport"), tsf);
-
 	tsf = new BoolOption (
 		     "loop-is-mode",
 		     _("Play loop is a transport mode"),
@@ -1414,6 +1900,17 @@ RCOptionEditor::RCOptionEditor ()
 					       "<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"),
+		     sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun),
+		     sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun)
+		     );
+	Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(), 
+					    string_compose (_("<b>When enabled</b> %1 will stop recording if an over- or underrun is detected by the audio engine"),
+							    PROGRAM_NAME));
+	add_option (_("Transport"), tsf);
+
 	tsf = new BoolOption (
 		     "create-xrun-marker",
 		     _("Create markers where xruns occur"),
@@ -1477,7 +1974,6 @@ RCOptionEditor::RCOptionEditor ()
 		sigc::mem_fun (*_rc_config, &RCConfiguration::set_sync_source)
 		);
 
-	populate_sync_options ();
 	add_option (_("Transport"), _sync_source);
 
 	_sync_framerate = new BoolOption (
@@ -1498,13 +1994,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);
@@ -1541,6 +2045,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..
@@ -1643,6 +2149,17 @@ 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",
@@ -1664,7 +2181,7 @@ RCOptionEditor::RCOptionEditor ()
 		     "show-region-gain-envelopes",
 		     _("Show gain envelopes in audio regions"),
 		     _("in all modes"),
-		     _("only in region gain mode"),
+		     _("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)
 		     ));
@@ -1719,14 +2236,6 @@ RCOptionEditor::RCOptionEditor ()
 			    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 (*_ui_config, &UIConfiguration::get_link_editor_and_mixer_selection),
-		     sigc::mem_fun (*_ui_config, &UIConfiguration::set_link_editor_and_mixer_selection)
-		     ));
-
 	bo = new BoolOption (
 		     "name-new-markers",
 		     _("Name new markers"),
@@ -1851,20 +2360,34 @@ RCOptionEditor::RCOptionEditor ()
 		sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_model)
 		);
 
+	int dmsize = 1;
 	dm->add (DenormalNone, _("no processor handling"));
 
-	FPU fpu;
+	FPU* fpu = FPU::instance();
 
-	if (fpu.has_flush_to_zero()) {
+	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()) {
+	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()) {
+	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);
@@ -2032,6 +2555,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",
@@ -2159,7 +2692,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",
@@ -2200,6 +2740,18 @@ RCOptionEditor::RCOptionEditor ()
 
 	/* 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",
@@ -2239,6 +2791,22 @@ RCOptionEditor::RCOptionEditor ()
 			    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(),
+		 _("Increasing the cache size uses more memory to store waveform images, 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));
@@ -2308,12 +2876,10 @@ RCOptionEditor::RCOptionEditor ()
 	mfo->add (METER_FALLOFF_OFF,      _("off"));
 	mfo->add (METER_FALLOFF_SLOWEST,  _("slowest [6.6dB/sec]"));
 	mfo->add (METER_FALLOFF_SLOW,     _("slow [8.6dB/sec] (BBC PPM, EBU PPM)"));
-	mfo->add (METER_FALLOFF_SLOWISH,  _("slowish [12.0dB/sec] (DIN)"));
-	mfo->add (METER_FALLOFF_MODERATE, _("moderate [13.3dB/sec] (EBU Digi PPM, IRT Digi PPM)"));
-	mfo->add (METER_FALLOFF_MEDIUM,   _("medium [20dB/sec]"));
-	mfo->add (METER_FALLOFF_FAST,     _("fast [32dB/sec]"));
-	mfo->add (METER_FALLOFF_FASTER,   _("faster [46dB/sec]"));
-	mfo->add (METER_FALLOFF_FASTEST,  _("fastest [70dB/sec]"));
+	mfo->add (METER_FALLOFF_SLOWISH,  _("moderate [12.0dB/sec] (DIN)"));
+	mfo->add (METER_FALLOFF_MODERATE, _("medium [13.3dB/sec] (EBU Digi PPM, IRT Digi PPM)"));
+	mfo->add (METER_FALLOFF_MEDIUM,   _("fast [20dB/sec]"));
+	mfo->add (METER_FALLOFF_FAST,     _("very fast [32dB/sec]"));
 
 	add_option (S_("Preferences|Metering"), mfo);
 
@@ -2371,6 +2937,54 @@ RCOptionEditor::RCOptionEditor ()
 			sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_peak)
 			);
 
+
+	ComboOption<MeterType>* mtm = new ComboOption<MeterType> (
+		"meter-type-master",
+		_("Default Meter Type for Master Bus"),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_master),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_master)
+		);
+	mtm->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
+	mtm->add (MeterK20,     ArdourMeter::meter_type_string(MeterK20));
+	mtm->add (MeterK14,     ArdourMeter::meter_type_string(MeterK14));
+	mtm->add (MeterK12,     ArdourMeter::meter_type_string(MeterK12));
+	mtm->add (MeterIEC1DIN, ArdourMeter::meter_type_string(MeterIEC1DIN));
+	mtm->add (MeterIEC1NOR, ArdourMeter::meter_type_string(MeterIEC1NOR));
+	mtm->add (MeterIEC2BBC, ArdourMeter::meter_type_string(MeterIEC2BBC));
+	mtm->add (MeterIEC2EBU, ArdourMeter::meter_type_string(MeterIEC2EBU));
+
+	add_option (S_("Preferences|Metering"), mtm);
+
+
+	ComboOption<MeterType>* mtb = new ComboOption<MeterType> (
+		"meter-type-bus",
+		_("Default Meter Type for Busses"),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_bus),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_bus)
+		);
+	mtb->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
+	mtb->add (MeterK20,     ArdourMeter::meter_type_string(MeterK20));
+	mtb->add (MeterK14,     ArdourMeter::meter_type_string(MeterK14));
+	mtb->add (MeterK12,     ArdourMeter::meter_type_string(MeterK12));
+	mtb->add (MeterIEC1DIN, ArdourMeter::meter_type_string(MeterIEC1DIN));
+	mtb->add (MeterIEC1NOR, ArdourMeter::meter_type_string(MeterIEC1NOR));
+	mtb->add (MeterIEC2BBC, ArdourMeter::meter_type_string(MeterIEC2BBC));
+	mtb->add (MeterIEC2EBU, ArdourMeter::meter_type_string(MeterIEC2EBU));
+
+	add_option (S_("Preferences|Metering"), mtb);
+
+	ComboOption<MeterType>* mtt = new ComboOption<MeterType> (
+		"meter-type-track",
+		_("Default Meter Type for Tracks"),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_type_track),
+		sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_type_track)
+		);
+	mtt->add (MeterPeak,    ArdourMeter::meter_type_string(MeterPeak));
+	mtt->add (MeterPeak0dB, ArdourMeter::meter_type_string(MeterPeak0dB));
+
+	add_option (S_("Preferences|Metering"), mtt);
+
+
 	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."));
@@ -2443,4 +3057,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());
+		}
+	}
 }