#include "gtk2ardour-config.h"
#endif
+#if !defined USE_CAIRO_IMAGE_SURFACE && !defined NDEBUG
+#define OPTIONAL_CAIRO_IMAGE_SURFACE
+#endif
+
+#include <cairo/cairo.h>
+
#include <boost/algorithm/string.hpp>
#include <gtkmm/liststore.h>
#include "canvas/wave_view.h"
-#include "ardour_ui.h"
#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"
#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;
{
public:
ClickOptions (RCConfiguration* c, Gtk::Window* p)
- : _rc_config (c),
- _parent (p)
+ : _rc_config (c)
+ , _click_browse_button (_("Browse..."))
+ , _click_emphasis_browse_button (_("Browse..."))
{
- Table* t = manage (new Table (2, 3));
+ Table* t = manage (new Table (3, 3));
t->set_spacings (4);
- Label* l = manage (left_aligned_label (_("Click audio file:")));
+ Label* l = manage (left_aligned_label (_("Use default Click:")));
t->attach (*l, 0, 1, 0, 1, FILL);
- t->attach (_click_path_entry, 1, 2, 0, 1, FILL);
- Button* b = manage (new Button (_("Browse...")));
- b->signal_clicked().connect (sigc::mem_fun (*this, &ClickOptions::click_browse_clicked));
- t->attach (*b, 2, 3, 0, 1, FILL);
+ t->attach (_use_default_click_check_button, 1, 2, 0, 1, FILL);
+ _use_default_click_check_button.signal_toggled().connect (
+ sigc::mem_fun (*this, &ClickOptions::use_default_click_toggled));
- l = manage (left_aligned_label (_("Click emphasis audio file:")));
+ l = manage (left_aligned_label (_("Click audio file:")));
t->attach (*l, 0, 1, 1, 2, FILL);
- t->attach (_click_emphasis_path_entry, 1, 2, 1, 2, FILL);
- b = manage (new Button (_("Browse...")));
- b->signal_clicked().connect (sigc::mem_fun (*this, &ClickOptions::click_emphasis_browse_clicked));
- t->attach (*b, 2, 3, 1, 2, FILL);
+ t->attach (_click_path_entry, 1, 2, 1, 2, FILL);
+ _click_browse_button.signal_clicked ().connect (
+ sigc::mem_fun (*this, &ClickOptions::click_browse_clicked));
+ t->attach (_click_browse_button, 2, 3, 1, 2, FILL);
+
+ l = manage (left_aligned_label (_("Click emphasis audio file:")));
+ t->attach (*l, 0, 1, 2, 3, FILL);
+ t->attach (_click_emphasis_path_entry, 1, 2, 2, 3, FILL);
+ _click_emphasis_browse_button.signal_clicked ().connect (
+ sigc::mem_fun (*this, &ClickOptions::click_emphasis_browse_clicked));
+ t->attach (_click_emphasis_browse_button, 2, 3, 2, 3, FILL);
_box->pack_start (*t, false, false);
_click_path_entry.signal_activate().connect (sigc::mem_fun (*this, &ClickOptions::click_changed));
_click_emphasis_path_entry.signal_activate().connect (sigc::mem_fun (*this, &ClickOptions::click_emphasis_changed));
+
+ if (_rc_config->get_click_sound ().empty() &&
+ _rc_config->get_click_emphasis_sound().empty()) {
+ _use_default_click_check_button.set_active (true);
+
+ } else {
+ _use_default_click_check_button.set_active (false);
+ }
}
void parameter_changed (string const & p)
{
SoundFileChooser sfdb (_("Choose Click"));
+ sfdb.show_all ();
+ sfdb.present ();
+
if (sfdb.run () == RESPONSE_OK) {
click_chosen (sfdb.get_filename());
}
click_emphasis_chosen (_click_emphasis_path_entry.get_text ());
}
+ void use_default_click_toggled ()
+ {
+ if (_use_default_click_check_button.get_active ()) {
+ _rc_config->set_click_sound ("");
+ _rc_config->set_click_emphasis_sound ("");
+ _click_path_entry.set_sensitive (false);
+ _click_emphasis_path_entry.set_sensitive (false);
+ _click_browse_button.set_sensitive (false);
+ _click_emphasis_browse_button.set_sensitive (false);
+ } else {
+ _click_path_entry.set_sensitive (true);
+ _click_emphasis_path_entry.set_sensitive (true);
+ _click_browse_button.set_sensitive (true);
+ _click_emphasis_browse_button.set_sensitive (true);
+ }
+ }
+
RCConfiguration* _rc_config;
- Gtk::Window* _parent;
+ CheckButton _use_default_click_check_button;
Entry _click_path_entry;
Entry _click_emphasis_path_entry;
+ Button _click_browse_button;
+ Button _click_emphasis_browse_button;
};
class UndoOptions : public OptionEditorBox
{ "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 }
}
}
- 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");
+
+ 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, 0, 1, 0, 1, FILL | EXPAND, FILL);
- t->attach (_edit_modifier_combo, 1, 2, 0, 1, FILL | EXPAND, FILL);
+ 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));
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));
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));
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;
+
+ /* 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 overlapped 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, 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));
- l = manage (left_aligned_label (_("Keyboard layout:")));
+ 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, 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 (_push_points_combo, col + 1, col + 2, row, row + 1, FILL | EXPAND, FILL);
_box->pack_start (*t, false, false);
}
}
}
+ 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();
}
}
+ 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());
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;
class FontScalingOptions : public OptionEditorBox
{
public:
- FontScalingOptions (RCConfiguration* c) :
- _rc_config (c),
- _dpi_adjustment (50, 50, 250, 1, 10),
+ FontScalingOptions () :
+ _dpi_adjustment (100, 50, 250, 1, 5),
_dpi_slider (_dpi_adjustment)
{
- _dpi_adjustment.set_value (floor ((double)(_rc_config->get_font_scale () / 1024)));
+ _dpi_adjustment.set_value (UIConfiguration::instance().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);
_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 ((double)(_rc_config->get_font_scale() / 1024)));
+ _dpi_adjustment.set_value (UIConfiguration::instance().get_font_scale() / 1024.);
}
}
void dpi_changed ()
{
- _rc_config->set_font_scale ((long) floor (_dpi_adjustment.get_value() * 1024));
+ UIConfiguration::instance().set_font_scale ((long) floor (_dpi_adjustment.get_value() * 1024.));
/* XXX: should be triggered from the parameter changed signal */
- reset_dpi ();
+ UIConfiguration::instance().reset_dpi ();
}
- RCConfiguration* _rc_config;
Adjustment _dpi_adjustment;
HScale _dpi_slider;
};
class ClipLevelOptions : public OptionEditorBox
{
public:
- ClipLevelOptions (RCConfiguration* c)
- : _rc_config (c)
- , _clip_level_adjustment (0, -128.0, 2.0, 0.1, 1.0) /* units of dB */
+ ClipLevelOptions ()
+ : _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 (_rc_config->get_waveform_clip_level ());
+ _clip_level_adjustment.set_value (UIConfiguration::instance().get_waveform_clip_level ());
Label* l = manage (new Label (_("Waveform Clip Level (dBFS):")));
l->set_name ("OptionsLabel");
void parameter_changed (string const & p)
{
if (p == "waveform-clip-level") {
- _clip_level_adjustment.set_value (_rc_config->get_waveform_clip_level());
+ _clip_level_adjustment.set_value (UIConfiguration::instance().get_waveform_clip_level());
}
}
void clip_level_changed ()
{
- _rc_config->set_waveform_clip_level (_clip_level_adjustment.get_value());
+ UIConfiguration::instance().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());
}
- RCConfiguration* _rc_config;
Adjustment _clip_level_adjustment;
HScale _clip_level_slider;
};
, _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);
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") {
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());
Adjustment _capture_adjustment;
HScale _playback_slider;
HScale _capture_slider;
+ ComboBoxText _buffering_presets_combo;
};
class ControlSurfacesOptions : public OptionEditorBox
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;
- }
}
}
}
}
- void edit_clicked (GdkEventButton* ev)
- {
+ void edit_clicked (GdkEventButton* ev)
+ {
if (ev->type != GDK_2BUTTON_PRESS) {
return;
}
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
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;
PluginOptions (RCConfiguration* c)
: _rc_config (c)
, _display_plugin_scan_progress (_("Always Display Plugin Scan Progress"))
- , _discover_vst_on_start (_("Scan for new VST Plugins on Application Start"))
+ , _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)
{
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));
_("<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);
+ t->attach (*manage (right_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);
+ t->attach (*manage (right_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;
+
+ // 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);
void parameter_changed (string const & p) {
if (p == "show-plugin-scan-window") {
- bool const x = _rc_config->get_show_plugin_scan_window();
+ bool const x = UIConfiguration::instance().get_show_plugin_scan_window();
_display_plugin_scan_progress.set_active (x);
}
else if (p == "discover-vst-on-start") {
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);
+ }
+ 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 () {
parameter_changed ("show-plugin-scan-window");
parameter_changed ("discover-vst-on-start");
parameter_changed ("vst-scan-timeout");
+ parameter_changed ("discover-audio-units");
+ parameter_changed ("verbose-plugin-scan");
}
private:
RCConfiguration* _rc_config;
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;
void display_plugin_scan_progress_toggled () {
bool const x = _display_plugin_scan_progress.get_active();
- _rc_config->set_show_plugin_scan_window(x);
+ UIConfiguration::instance().set_show_plugin_scan_window(x);
}
void discover_vst_on_start_toggled () {
_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 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);
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) {
RCOptionEditor::RCOptionEditor ()
: OptionEditor (Config, string_compose (_("%1 Preferences"), PROGRAM_NAME))
, _rc_config (Config)
- , _mixer_strip_visibility ("mixer-strip-visibility")
+ , _mixer_strip_visibility ("mixer-element-visibility")
{
/* MISC */
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 (UIConfiguration::instance(), &UIConfiguration::get_only_copy_imported_files),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_only_copy_imported_files)
));
add_option (_("Misc"), new DirectoryOption (
/* TRANSPORT */
+ add_option (_("Transport"), new OptionEditorHeading (S_("Transport Options")));
+
BoolOption* tsf;
tsf = new BoolOption (
// 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"),
"<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"),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_sync_source)
);
- populate_sync_options ();
add_option (_("Transport"), _sync_source);
_sync_framerate = new BoolOption (
_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 & 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 & 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);
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..
new BoolOption (
"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)
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_draggable_playhead),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_draggable_playhead)
));
add_option (_("Editor"),
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 (UIConfiguration::instance(), &UIConfiguration::get_show_track_meters),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_show_editor_meter),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_editor_meter)
));
ComboOption<FadeShape>* fadeshape = new ComboOption<FadeShape> (
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 (UIConfiguration::instance(), &UIConfiguration::get_rubberbanding_snaps_to_grid),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_show_waveforms),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_show_waveforms)
));
add_option (_("Editor"),
"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 (UIConfiguration::instance(), &UIConfiguration::get_show_region_gain),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_waveform_scale),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_scale)
);
wfs->add (Linear, _("linear"));
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 (UIConfiguration::instance(), &UIConfiguration::get_waveform_shape),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_waveform_shape)
);
wfsh->add (Traditional, _("traditional"));
add_option (_("Editor"), wfsh);
- add_option (_("Editor"), new ClipLevelOptions (_rc_config));
+ add_option (_("Editor"), new ClipLevelOptions ());
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 (UIConfiguration::instance(), &UIConfiguration::get_show_waveforms_while_recording),
+ sigc::mem_fun (UIConfiguration::instance(), &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)
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_zoom_tools),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_update_editor_during_summary_drag),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_name_new_markers),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_name_new_markers)
);
add_option (_("Editor"), bo);
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 (UIConfiguration::instance(), &UIConfiguration::get_autoscroll_editor),
+ sigc::mem_fun (UIConfiguration::instance(), &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")));
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);
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",
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 (UIConfiguration::instance(), &UIConfiguration::get_never_display_periodic_midi),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_sound_midi_notes),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_sound_midi_notes)
));
add_option (_("MIDI"), new OptionEditorHeading (_("Midi Audition")));
/* USER INTERACTION */
- if (getenv ("ARDOUR_BUNDLED")) {
+ if (
+#ifdef PLATFORM_WINDOWS
+ true
+#else
+ getenv ("ARDOUR_BUNDLED")
+#endif
+ )
+ {
add_option (_("User interaction"),
new BoolOption (
"enable-translation",
/* VIDEO Timeline */
add_option (_("Video"), new VideoTimelineOptions (_rc_config));
-#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined AUDIOUNIT_SUPPORT)
/* Plugin options (currrently VST only) */
add_option (_("Plugins"), new PluginOptions (_rc_config));
#endif
/* INTERFACE */
+#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE
+ BoolOption* bgc = new BoolOption (
+ "cairo-image-surface",
+ _("Disable Graphics Hardware Acceleration (requires restart)"),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_cairo_image_surface),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_cairo_image_surface)
+ );
+
+ Gtkmm2ext::UI::instance()->set_tip (bgc->tip_widget(), string_compose (
+ _("Render large parts of the application user-interface in software, instead of using 2D-graphics acceleration.\nThis requires restarting %1 before having an effect"), PROGRAM_NAME));
+ add_option (S_("Preferences|GUI"), bgc);
+#endif
+
+#ifdef CAIRO_SUPPORTS_FORCE_BUGGY_GRADIENTS_ENVIRONMENT_VARIABLE
+ BoolOption* bgo = new BoolOption (
+ "buggy-gradients",
+ _("Possibly improve slow graphical performance (requires restart)"),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_buggy_gradients),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_buggy_gradients)
+ );
+
+ Gtkmm2ext::UI::instance()->set_tip (bgo->tip_widget(), string_compose (_("Disables hardware gradient rendering on buggy video drivers (\"buggy gradients patch\").\nThis requires restarting %1 before having an effect"), PROGRAM_NAME));
+ 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 (UIConfiguration::instance(), &UIConfiguration::get_widget_prelight),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_use_tooltips),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_use_tooltips)
));
+#endif
add_option (S_("Preferences|GUI"),
new BoolOption (
"show-name-highlight",
- _("Use name highlight bars in region displays"),
- sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_name_highlight),
- sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_name_highlight)
+ _("Use name highlight bars in region displays (requires a restart)"),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_show_name_highlight),
+ sigc::mem_fun (UIConfiguration::instance(), &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 ());
#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 (UIConfiguration::instance(), &UIConfiguration::get_super_rapid_clock_update),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_waveform_cache_size),
+ sigc::mem_fun (UIConfiguration::instance(), &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));
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)
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::get_lock_gui_after_seconds),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_lock_gui_after_seconds)
);
slts->scale().set_digits (0);
Gtkmm2ext::UI::instance()->set_tip
/* 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_("Group"), _("Group"));
- _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 (UIConfiguration::instance(), &UIConfiguration::get_mixer_strip_visibility),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_mixer_strip_visibility)
)
);
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 (UIConfiguration::instance(), &UIConfiguration::get_default_narrow_ms),
+ sigc::mem_fun (UIConfiguration::instance(), &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 (UIConfiguration::instance(), &UIConfiguration::get_meter_hold),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_hold)
);
mht->add (MeterHoldOff, _("off"));
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",
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|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 (UIConfiguration::instance(), &UIConfiguration::get_meter_line_up_level),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_line_up_level)
);
mlu->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
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 (UIConfiguration::instance(), &UIConfiguration::get_meter_line_up_din),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_line_up_din)
);
mld->add (MeteringLineUp24, _("-24dBFS (SMPTE US: 4dBu = -20dBFS)"));
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 (UIConfiguration::instance(), &UIConfiguration::get_meter_vu_standard),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_vu_standard)
);
mvu->add (MeteringVUfrench, _("0VU = -2dBu (France)"));
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 (UIConfiguration::instance(), &UIConfiguration::get_meter_peak),
+ sigc::mem_fun (UIConfiguration::instance(), &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."));
- 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 (UIConfiguration::instance(), &UIConfiguration::get_meter_style_led),
+ sigc::mem_fun (UIConfiguration::instance(), &UIConfiguration::set_meter_style_led)
));
+ /* and now the theme manager */
+
+ ThemeManager* tm = manage (new ThemeManager);
+ add_page (_("Theme"), *tm);
}
void
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());
+ }
+ }
}
projects / ardour.git / blobdiff