X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Frc_option_editor.cc;h=0450948f57dc3c3b97ac51b4088775bd5d103276;hb=5e7d9d30e28e8022661497244ccd43a1f5a836c6;hp=ef3c66153edbbbb8d7f48162a945677195deb16d;hpb=03229f4fe9c92cc922c7c46be2c90448be31fa90;p=ardour.git diff --git a/gtk2_ardour/rc_option_editor.cc b/gtk2_ardour/rc_option_editor.cc index ef3c66153e..0450948f57 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 + #include #include @@ -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" @@ -65,6 +68,121 @@ using namespace PBD; using namespace ARDOUR; using namespace ARDOUR_UI_UTILS; +class AutoReturnTargetOptions : public OptionEditorBox +{ + public: + AutoReturnTargetOptions (RCConfiguration* c, Gtk::Window* p) + : _rc_config (c) + , range_selection_button (_("Play Range Selection")) + , last_roll_button (_("Play from Last Roll")) + , loop_button (_("Play Loop")) + , region_selection_button (_("Play Region Selection")) + , toggle_button (_("Enable/Disable all options")) + { + _box->pack_start (range_selection_button, false, false); + range_selection_button.signal_toggled().connect (sigc::mem_fun (*this, &AutoReturnTargetOptions::range_selection_toggled)); + + _box->pack_start (loop_button, false, false); + loop_button.signal_toggled().connect (sigc::mem_fun (*this, &AutoReturnTargetOptions::loop_toggled)); + + _box->pack_start (region_selection_button, false, false); + region_selection_button.signal_toggled().connect (sigc::mem_fun (*this, &AutoReturnTargetOptions::region_selection_toggled)); + + _box->pack_start (last_roll_button, false, false); + last_roll_button.signal_toggled().connect (sigc::mem_fun (*this, &AutoReturnTargetOptions::last_roll_toggled)); + + HBox* hbox = manage (new HBox); + /* keep the toggle button small */ + hbox->pack_start (toggle_button, false, false); + _box->pack_start (*hbox, false, false); + + toggle_button.signal_clicked().connect (sigc::mem_fun (*this, &AutoReturnTargetOptions::toggle)); + + Gtkmm2ext::UI::instance()->set_tip (range_selection_button, + _("If enabled, playhead will always start from the beginning of the current range selection.\n\nIf disabled or no range selection, see the next choice in this list")); + Gtkmm2ext::UI::instance()->set_tip (loop_button, + _("If enabled, playhead will always start from the beginning of the loop range.\n\nIf disabled or no loop range, see the next choice in this list")); + Gtkmm2ext::UI::instance()->set_tip (region_selection_button, + _("If enabled, playhead will always start from the beginning of the first selected region.\n\nIf disabled or no region selection, see the next choice in this list")); + Gtkmm2ext::UI::instance()->set_tip (last_roll_button, + _("If enabled, playhead will always start from the last position where it was started.\n\nIf disabled it will start from wherever it is currently located")); + + Gtkmm2ext::UI::instance()->set_tip (toggle_button, + _("Change status of all buttons above to all enabled or all disabled")); + } + + void parameter_changed (string const & p) + { + if (p == "auto-return-target-list") { + AutoReturnTarget art = _rc_config->get_auto_return_target_list(); + range_selection_button.set_active (art & RangeSelectionStart); + loop_button.set_active (art & Loop); + region_selection_button.set_active (art & RegionSelectionStart); + last_roll_button.set_active (art & LastLocate); + } + } + + void set_state_from_config () + { + parameter_changed ("auto-return-target-list"); + } + + private: + + void range_selection_toggled () { + AutoReturnTarget art = _rc_config->get_auto_return_target_list (); + if (range_selection_button.get_active ()) { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art | RangeSelectionStart)); + } else { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art & ~RangeSelectionStart)); + } + } + void last_roll_toggled () { + AutoReturnTarget art = _rc_config->get_auto_return_target_list (); + if (last_roll_button.get_active ()) { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art | LastLocate)); + } else { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art & ~LastLocate)); + } + } + void region_selection_toggled () { + AutoReturnTarget art = _rc_config->get_auto_return_target_list (); + if (region_selection_button.get_active ()) { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art | RegionSelectionStart)); + } else { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art & ~RegionSelectionStart)); + } + } + void loop_toggled () { + AutoReturnTarget art = _rc_config->get_auto_return_target_list (); + if (loop_button.get_active ()) { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art | Loop)); + } else { + _rc_config->set_auto_return_target_list (AutoReturnTarget (art & ~Loop)); + } + } + + void toggle () { + AutoReturnTarget art = _rc_config->get_auto_return_target_list (); + if (art) { + _rc_config->set_auto_return_target_list (AutoReturnTarget (0)); + } else { + _rc_config->set_auto_return_target_list (AutoReturnTarget (RangeSelectionStart| + RegionSelectionStart| + Loop| + LastLocate)); + } + } + + RCConfiguration* _rc_config; + + Gtk::CheckButton range_selection_button; + Gtk::CheckButton last_roll_button; + Gtk::CheckButton loop_button; + Gtk::CheckButton region_selection_button; + Gtk::Button toggle_button; +}; + class ClickOptions : public OptionEditorBox { public: @@ -271,20 +389,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 +439,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 strs; + + for (map::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 +503,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 +532,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 +704,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 strs; + ++row; + col = 1; - for (map::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; + + /* 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 (_("Keyboard layout:"))); + 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 +853,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 +889,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 +1003,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 +1034,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 +1063,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)); } @@ -1022,6 +1515,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,6 +1588,12 @@ 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, + _("When enabled additional information for every plugin is added to the Log Window.")); #endif #endif // any VST @@ -1141,6 +1641,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 () { @@ -1148,6 +1652,7 @@ public: parameter_changed ("discover-vst-on-start"); parameter_changed ("vst-scan-timeout"); parameter_changed ("discover-audio-units"); + parameter_changed ("verbose-plugin-scan"); } private: @@ -1156,6 +1661,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; @@ -1174,6 +1680,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); @@ -1407,6 +1918,10 @@ RCOptionEditor::RCOptionEditor () /* TRANSPORT */ + add_option (_("Transport"), new OptionEditorHeading (S_("Playhead Behaviour"))); + add_option (_("Transport"), new AutoReturnTargetOptions (_rc_config, this)); + add_option (_("Transport"), new OptionEditorHeading (S_("Transport Options"))); + BoolOption* tsf; tsf = new BoolOption ( @@ -1418,17 +1933,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 (_("When enabled %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"), @@ -1440,6 +1944,17 @@ RCOptionEditor::RCOptionEditor () "When disabled 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 (_("When enabled %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"), @@ -1503,7 +2018,6 @@ RCOptionEditor::RCOptionEditor () sigc::mem_fun (*_rc_config, &RCConfiguration::set_sync_source) ); - populate_sync_options (); add_option (_("Transport"), _sync_source); _sync_framerate = new BoolOption ( @@ -1524,7 +2038,7 @@ RCOptionEditor::RCOptionEditor () _sync_genlock = new BoolOption ( "timecode-source-is-synced", - _("Sync lock timecode to clock - Disable drift compensation."), + _("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) ); @@ -1533,8 +2047,8 @@ RCOptionEditor::RCOptionEditor () string_compose (_("When enabled %1 will never varispeed when slaved to external timecode. " "Sync Lock indicates that the selected external timecode source shares clock-sync " "(Black & Burst, Wordclock, etc) with the audio interface. " - "This option disables drift compensation. The transport speed is fixed at 1.0." - "Varispeed LTC will be ignored and cause drift." + "This option disables drift compensation. The transport speed is fixed at 1.0. " + "Vari-speed LTC will be ignored and cause drift." "\n\n" "When disabled %1 will compensate for potential drift, regardless if the " "timecode sources shares clock sync." @@ -1575,6 +2089,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.. @@ -1677,6 +2193,17 @@ RCOptionEditor::RCOptionEditor () add_option (_("Editor"), bco); + ComboOption* lm = new ComboOption ( + "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", @@ -1698,7 +2225,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) )); @@ -1753,14 +2280,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"), @@ -1885,20 +2404,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); @@ -2066,6 +2599,16 @@ RCOptionEditor::RCOptionEditor () sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_send_and_route_panner) )); + add_option (_("MIDI"), + new SpinOption ( + "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", @@ -2193,7 +2736,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", @@ -2234,6 +2784,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", @@ -2273,6 +2835,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)); @@ -2405,6 +2983,54 @@ RCOptionEditor::RCOptionEditor () sigc::mem_fun (*_ui_config, &UIConfiguration::set_meter_peak) ); + + ComboOption* mtm = new ComboOption ( + "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* mtb = new ComboOption ( + "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* mtt = new ComboOption ( + "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.")); @@ -2477,4 +3103,12 @@ RCOptionEditor::populate_sync_options () for (vector::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()); + } + } }