X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Frc_option_editor.cc;h=722612d21c9ffaec7d3c6d863c384c0640119aa3;hb=b502bbc61895d61c39bf240b47e8a3664be2c541;hp=acf4c06db4b6b47f8705e02a14855e5633039ef6;hpb=ce525ae440d7707304cd2233be929cbbc64b4943;p=ardour.git diff --git a/gtk2_ardour/rc_option_editor.cc b/gtk2_ardour/rc_option_editor.cc index acf4c06db4..722612d21c 100644 --- a/gtk2_ardour/rc_option_editor.cc +++ b/gtk2_ardour/rc_option_editor.cc @@ -1,15 +1,26 @@ +#ifdef WAF_BUILD +#include "gtk2ardour-config.h" +#endif + #include #include #include #include #include + #include "pbd/fpu.h" +#include "pbd/cpus.h" + #include "midi++/manager.h" -#include "midi++/factory.h" + +#include "ardour/audioengine.h" #include "ardour/dB.h" #include "ardour/rc_configuration.h" #include "ardour/control_protocol_manager.h" #include "control_protocol/control_protocol.h" + +#include "gui_thread.h" +#include "midi_tracer.h" #include "rc_option_editor.h" #include "utils.h" #include "midi_port_dialog.h" @@ -18,207 +29,11 @@ #include "i18n.h" using namespace std; -using namespace sigc; using namespace Gtk; using namespace Gtkmm2ext; using namespace PBD; using namespace ARDOUR; -class MIDIPorts : public OptionEditorBox -{ -public: - MIDIPorts (RCConfiguration* c, list* > const & o) - : _rc_config (c), - _add_port_button (Stock::ADD), - _port_combos (o) - { - _store = ListStore::create (_model); - _view.set_model (_store); - _view.append_column (_("Name"), _model.name); - _view.get_column(0)->set_resizable (true); - _view.get_column(0)->set_expand (true); - _view.append_column_editable (_("Online"), _model.online); - _view.append_column_editable (_("Trace input"), _model.trace_input); - _view.append_column_editable (_("Trace output"), _model.trace_output); - - HBox* h = manage (new HBox); - h->set_spacing (4); - h->pack_start (_view, true, true); - - VBox* v = manage (new VBox); - v->set_spacing (4); - v->pack_start (_add_port_button, false, false); - h->pack_start (*v, false, false); - - _box->pack_start (*h); - - ports_changed (); - - _store->signal_row_changed().connect (mem_fun (*this, &MIDIPorts::model_changed)); - - _add_port_button.signal_clicked().connect (mem_fun (*this, &MIDIPorts::add_port_clicked)); - } - - void parameter_changed (string const &) {} - void set_state_from_config () {} - -private: - - void model_changed (TreeModel::Path const &, TreeModel::iterator const & i) - { - TreeModel::Row r = *i; - - MIDI::Port* port = r[_model.port]; - if (!port) { - return; - } - - if (port->input()) { - - if (r[_model.online] == port->input()->offline()) { - port->input()->set_offline (!r[_model.online]); - } - - if (r[_model.trace_input] != port->input()->tracing()) { - port->input()->trace (r[_model.trace_input], &cerr, string (port->name()) + _(" input: ")); - } - } - - if (port->output()) { - - if (r[_model.trace_output] != port->output()->tracing()) { - port->output()->trace (r[_model.trace_output], &cerr, string (port->name()) + _(" output: ")); - } - - } - } - - void setup_ports_combo (ComboOption* c) - { - c->clear (); - MIDI::Manager::PortList const & ports = MIDI::Manager::instance()->get_midi_ports (); - for (MIDI::Manager::PortList::const_iterator i = ports.begin(); i != ports.end(); ++i) { - c->add ((*i)->name(), (*i)->name()); - } - } - - void ports_changed () - { - /* XXX: why is this coming from here? */ - MIDI::Manager::PortList const & ports = MIDI::Manager::instance()->get_midi_ports (); - - _store->clear (); - - for (MIDI::Manager::PortList::const_iterator i = ports.begin(); i != ports.end(); ++i) { - - TreeModel::Row r = *_store->append (); - - r[_model.name] = (*i)->name(); - - if ((*i)->input()) { - r[_model.online] = !(*i)->input()->offline(); - (*i)->input()->OfflineStatusChanged.connect (bind (mem_fun (*this, &MIDIPorts::port_offline_changed), (*i))); - r[_model.trace_input] = (*i)->input()->tracing(); - } - - if ((*i)->output()) { - r[_model.trace_output] = (*i)->output()->tracing(); - } - - r[_model.port] = (*i); - } - - for (list* >::iterator i = _port_combos.begin(); i != _port_combos.end(); ++i) { - setup_ports_combo (*i); - } - } - - void port_offline_changed (MIDI::Port* p) - { - if (!p->input()) { - return; - } - - for (TreeModel::Children::iterator i = _store->children().begin(); i != _store->children().end(); ++i) { - if ((*i)[_model.port] == p) { - (*i)[_model.online] = !p->input()->offline(); - } - } - } - - void add_port_clicked () - { - MidiPortDialog dialog; - - dialog.set_position (WIN_POS_MOUSE); - - dialog.show (); - - int const r = dialog.run (); - - switch (r) { - case RESPONSE_ACCEPT: - break; - default: - return; - break; - } - - Glib::ustring const mode = dialog.port_mode_combo.get_active_text (); - string smod; - - if (mode == _("input")) { - smod = X_("input"); - } else if (mode == (_("output"))) { - smod = X_("output"); - } else { - smod = "duplex"; - } - - XMLNode node (X_("MIDI-port")); - - node.add_property ("tag", dialog.port_name.get_text()); - node.add_property ("device", X_("ardour")); // XXX this can't be right for all types - node.add_property ("type", MIDI::PortFactory::default_port_type()); - node.add_property ("mode", smod); - - if (MIDI::Manager::instance()->add_port (node) != 0) { - ports_changed (); - } - } - - class MIDIModelColumns : public TreeModelColumnRecord - { - public: - MIDIModelColumns () - { - add (name); - add (online); - add (trace_input); - add (trace_output); - add (port); - } - - TreeModelColumn name; - TreeModelColumn online; - TreeModelColumn trace_input; - TreeModelColumn trace_output; - TreeModelColumn port; - }; - - RCConfiguration* _rc_config; - Glib::RefPtr _store; - MIDIModelColumns _model; - TreeView _view; - Button _add_port_button; - ComboBoxText _mtc_combo; - ComboBoxText _midi_clock_combo; - ComboBoxText _mmc_combo; - ComboBoxText _mpc_combo; - list* > _port_combos; -}; - - class ClickOptions : public OptionEditorBox { public: @@ -234,7 +49,7 @@ public: 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 (mem_fun (*this, &ClickOptions::click_browse_clicked)); + b->signal_clicked().connect (sigc::mem_fun (*this, &ClickOptions::click_browse_clicked)); t->attach (*b, 2, 3, 0, 1, FILL); l = manage (new Label (_("Click emphasis audio file:"))); @@ -242,7 +57,7 @@ public: 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 (mem_fun (*this, &ClickOptions::click_emphasis_browse_clicked)); + b->signal_clicked().connect (sigc::mem_fun (*this, &ClickOptions::click_emphasis_browse_clicked)); t->attach (*b, 2, 3, 1, 2, FILL); _box->pack_start (*t, false, false); @@ -336,10 +151,10 @@ public: _box->pack_start (*t); - _limit_undo_button.signal_toggled().connect (mem_fun (*this, &UndoOptions::limit_undo_toggled)); - _limit_undo_spin.signal_value_changed().connect (mem_fun (*this, &UndoOptions::limit_undo_changed)); - _save_undo_button.signal_toggled().connect (mem_fun (*this, &UndoOptions::save_undo_toggled)); - _save_undo_spin.signal_value_changed().connect (mem_fun (*this, &UndoOptions::save_undo_changed)); + _limit_undo_button.signal_toggled().connect (sigc::mem_fun (*this, &UndoOptions::limit_undo_toggled)); + _limit_undo_spin.signal_value_changed().connect (sigc::mem_fun (*this, &UndoOptions::limit_undo_changed)); + _save_undo_button.signal_toggled().connect (sigc::mem_fun (*this, &UndoOptions::save_undo_toggled)); + _save_undo_spin.signal_value_changed().connect (sigc::mem_fun (*this, &UndoOptions::save_undo_changed)); } void parameter_changed (string const & p) @@ -416,10 +231,10 @@ static const struct { { "Command", GDK_META_MASK }, { "Control", GDK_CONTROL_MASK }, { "Option", GDK_MOD1_MASK }, - { "Command-Shift", GDK_MOD1_MASK|GDK_SHIFT_MASK }, - { "Command-Option", GDK_MOD1_MASK|GDK_MOD5_MASK }, - { "Shift-Option", GDK_SHIFT_MASK|GDK_MOD5_MASK }, - { "Shift-Command-Option", GDK_MOD5_MASK|GDK_SHIFT_MASK|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 }, + { "Shift-Command-Option", GDK_MOD5_MASK|GDK_SHIFT_MASK|GDK_META_MASK }, #else { "Shift", GDK_SHIFT_MASK }, @@ -445,7 +260,10 @@ public: _delete_button_adjustment (3, 1, 12), _delete_button_spin (_delete_button_adjustment), _edit_button_adjustment (3, 1, 5), - _edit_button_spin (_edit_button_adjustment) + _edit_button_spin (_edit_button_adjustment), + _insert_note_button_adjustment (3, 1, 5), + _insert_note_button_spin (_insert_note_button_adjustment) + { /* internationalize and prepare for use with combos */ @@ -456,7 +274,7 @@ public: } set_popdown_strings (_edit_modifier_combo, dumb); - _edit_modifier_combo.signal_changed().connect (mem_fun(*this, &KeyboardOptions::edit_modifier_chosen)); + _edit_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::edit_modifier_chosen)); for (int x = 0; modifiers[x].name; ++x) { if (modifiers[x].modifier == Keyboard::edit_modifier ()) { @@ -483,10 +301,10 @@ public: _edit_button_spin.set_name ("OptionsEntry"); _edit_button_adjustment.set_value (Keyboard::edit_button()); - _edit_button_adjustment.signal_value_changed().connect (mem_fun(*this, &KeyboardOptions::edit_button_changed)); + _edit_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::edit_button_changed)); set_popdown_strings (_delete_modifier_combo, dumb); - _delete_modifier_combo.signal_changed().connect (mem_fun(*this, &KeyboardOptions::delete_modifier_chosen)); + _delete_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::delete_modifier_chosen)); for (int x = 0; modifiers[x].name; ++x) { if (modifiers[x].modifier == Keyboard::delete_modifier ()) { @@ -510,10 +328,39 @@ public: _delete_button_spin.set_name ("OptionsEntry"); _delete_button_adjustment.set_value (Keyboard::delete_button()); - _delete_button_adjustment.signal_value_changed().connect (mem_fun(*this, &KeyboardOptions::delete_button_changed)); + _delete_button_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::delete_button_changed)); + + + set_popdown_strings (_insert_note_modifier_combo, dumb); + _insert_note_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::insert_note_modifier_chosen)); + + for (int x = 0; modifiers[x].name; ++x) { + if (modifiers[x].modifier == Keyboard::insert_note_modifier ()) { + _insert_note_modifier_combo.set_active_text (_(modifiers[x].name)); + break; + } + } + + l = manage (new Label (_("Insert note using:"))); + l->set_name ("OptionsLabel"); + l->set_alignment (0, 0.5); + + t->attach (*l, 0, 1, 2, 3, FILL | EXPAND, FILL); + t->attach (_insert_note_modifier_combo, 1, 2, 2, 3, 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); + _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)); + + set_popdown_strings (_snap_modifier_combo, dumb); - _snap_modifier_combo.signal_changed().connect (mem_fun(*this, &KeyboardOptions::snap_modifier_chosen)); + _snap_modifier_combo.signal_changed().connect (sigc::mem_fun(*this, &KeyboardOptions::snap_modifier_chosen)); for (int x = 0; modifiers[x].name; ++x) { if (modifiers[x].modifier == (guint) Keyboard::snap_modifier ()) { @@ -526,8 +373,8 @@ public: l->set_name ("OptionsLabel"); l->set_alignment (0, 0.5); - t->attach (*l, 0, 1, 2, 3, FILL | EXPAND, FILL); - t->attach (_snap_modifier_combo, 1, 2, 2, 3, FILL | EXPAND, FILL); + t->attach (*l, 0, 1, 3, 4, FILL | EXPAND, FILL); + t->attach (_snap_modifier_combo, 1, 2, 3, 4, FILL | EXPAND, FILL); vector strs; @@ -537,14 +384,14 @@ public: set_popdown_strings (_keyboard_layout_selector, strs); _keyboard_layout_selector.set_active_text (Keyboard::current_binding_name()); - _keyboard_layout_selector.signal_changed().connect (mem_fun (*this, &KeyboardOptions::bindings_changed)); + _keyboard_layout_selector.signal_changed().connect (sigc::mem_fun (*this, &KeyboardOptions::bindings_changed)); l = manage (new Label (_("Keyboard layout:"))); l->set_name ("OptionsLabel"); l->set_alignment (0, 0.5); - t->attach (*l, 0, 1, 3, 4, FILL | EXPAND, FILL); - t->attach (_keyboard_layout_selector, 1, 2, 3, 4, FILL | EXPAND, FILL); + t->attach (*l, 0, 1, 4, 5, FILL | EXPAND, FILL); + t->attach (_keyboard_layout_selector, 1, 2, 4, 5, FILL | EXPAND, FILL); _box->pack_start (*t, false, false); } @@ -600,6 +447,18 @@ private: } } + void insert_note_modifier_chosen () + { + string const txt = _insert_note_modifier_combo.get_active_text(); + + for (int i = 0; modifiers[i].name; ++i) { + if (txt == _(modifiers[i].name)) { + Keyboard::set_insert_note_modifier (modifiers[i].modifier); + break; + } + } + } + void snap_modifier_chosen () { string const txt = _snap_modifier_combo.get_active_text(); @@ -622,14 +481,23 @@ private: Keyboard::set_edit_button (_edit_button_spin.get_value_as_int()); } + void insert_note_button_changed () + { + Keyboard::set_insert_note_button (_insert_note_button_spin.get_value_as_int()); + } + ComboBoxText _keyboard_layout_selector; ComboBoxText _edit_modifier_combo; ComboBoxText _delete_modifier_combo; + ComboBoxText _insert_note_modifier_combo; ComboBoxText _snap_modifier_combo; Adjustment _delete_button_adjustment; SpinButton _delete_button_spin; Adjustment _edit_button_adjustment; SpinButton _edit_button_spin; + Adjustment _insert_note_button_adjustment; + SpinButton _insert_note_button_spin; + }; class FontScalingOptions : public OptionEditorBox @@ -653,7 +521,7 @@ public: _box->pack_start (*h, false, false); - _dpi_adjustment.signal_value_changed().connect (mem_fun (*this, &FontScalingOptions::dpi_changed)); + _dpi_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &FontScalingOptions::dpi_changed)); } void parameter_changed (string const & p) @@ -682,85 +550,85 @@ private: HScale _dpi_slider; }; -class SoloMuteOptions : public OptionEditorBox +class BufferingOptions : public OptionEditorBox { public: - SoloMuteOptions (RCConfiguration* c) : - _rc_config (c), - // 0.781787 is the value needed for gain to be set to 0. - _db_adjustment (0.781787, 0.0, 1.0, 0.01, 0.1) - + BufferingOptions (RCConfiguration* c) + : _rc_config (c) + , _playback_adjustment (5, 1, 60, 1, 4) + , _capture_adjustment (5, 1, 60, 1, 4) + , _playback_slider (_playback_adjustment) + , _capture_slider (_capture_adjustment) { - if ((pix = ::get_icon ("fader_belt_h")) == 0) { - throw failed_constructor(); - } + _playback_adjustment.set_value (_rc_config->get_audio_playback_buffer_seconds()); - _db_slider = manage (new HSliderController (pix, - &_db_adjustment, - false)); + Label* 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->set_spacing (4); + h->pack_start (*l, false, false); + h->pack_start (_playback_slider, true, true); - parameter_changed ("solo-mute-gain"); + _box->pack_start (*h, false, false); + + _capture_adjustment.set_value (_rc_config->get_audio_capture_buffer_seconds()); - Label* l = manage (new Label (_("Solo mute cut (dB):"))); + l = manage (new Label (_("Recording (seconds of buffering):"))); l->set_name ("OptionsLabel"); - HBox* h = manage (new HBox); + _capture_slider.set_update_policy (UPDATE_DISCONTINUOUS); + h = manage (new HBox); h->set_spacing (4); h->pack_start (*l, false, false); - h->pack_start (*_db_slider, false, false); - h->pack_start (_db_display, false, false); - - set_size_request_to_display_given_text (_db_display, "-99.0", 12, 12); + h->pack_start (_capture_slider, true, true); _box->pack_start (*h, false, false); - - _db_adjustment.signal_value_changed().connect (mem_fun (*this, &SoloMuteOptions::db_changed)); + + _capture_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &BufferingOptions::capture_changed)); + _playback_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &BufferingOptions::playback_changed)); } void parameter_changed (string const & p) { - if (p == "solo-mute-gain") { - gain_t val = _rc_config->get_solo_mute_gain(); - - _db_adjustment.set_value (gain_to_slider_position (val)); - - char buf[16]; - - if (val == 0.0) { - snprintf (buf, sizeof (buf), "-inf"); - } else { - snprintf (buf, sizeof (buf), "%.2f", accurate_coefficient_to_dB (val)); - } - - _db_display.set_text (buf); - } + if (p == "playback-buffer-seconds") { + _playback_adjustment.set_value (_rc_config->get_audio_playback_buffer_seconds()); + } else if (p == "capture-buffer-seconds") { + _capture_adjustment.set_value (_rc_config->get_audio_capture_buffer_seconds()); + } } void set_state_from_config () { - parameter_changed ("solo-mute-gain"); + parameter_changed ("playback-buffer-seconds"); + parameter_changed ("capture-buffer-seconds"); } private: - void db_changed () + void playback_changed () { - _rc_config->set_solo_mute_gain (slider_position_to_gain (_db_adjustment.get_value())); + _rc_config->set_audio_playback_buffer_seconds ((long) _playback_adjustment.get_value()); + } + + void capture_changed () + { + _rc_config->set_audio_capture_buffer_seconds ((long) _capture_adjustment.get_value()); } RCConfiguration* _rc_config; - Adjustment _db_adjustment; - Gtkmm2ext::HSliderController* _db_slider; - Glib::RefPtr pix; - Entry _db_display; + Adjustment _playback_adjustment; + Adjustment _capture_adjustment; + HScale _playback_slider; + HScale _capture_slider; }; - class ControlSurfacesOptions : public OptionEditorBox { public: - ControlSurfacesOptions () + ControlSurfacesOptions (ArdourDialog& parent) + : _parent (parent) { _store = ListStore::create (_model); _view.set_model (_store); @@ -772,7 +640,14 @@ public: _box->pack_start (_view, false, false); - _store->signal_row_changed().connect (mem_fun (*this, &ControlSurfacesOptions::model_changed)); + Label* label = manage (new Label); + label->set_markup (string_compose (X_("%1"), _("Double-click on a name to edit settings for an enabled protocol"))); + + _box->pack_start (*label, false, false); + label->show (); + + _store->signal_row_changed().connect (sigc::mem_fun (*this, &ControlSurfacesOptions::model_changed)); + _view.signal_button_press_event().connect_notify (sigc::mem_fun(*this, &ControlSurfacesOptions::edit_clicked)); } void parameter_changed (std::string const &) @@ -827,6 +702,38 @@ private: } } + void edit_clicked (GdkEventButton* ev) + { + if (ev->type != GDK_2BUTTON_PRESS) { + return; + } + + std::string name; + ControlProtocolInfo* cpi; + 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]; + ArdourDialog* win = new ArdourDialog (_parent, title); + win->get_vbox()->pack_start (*box, false, false); + box->show (); + win->present (); + row[_model.editor] = win; + } + } + } + } + class ControlSurfacesModelColumns : public TreeModelColumnRecord { public: @@ -837,33 +744,58 @@ private: add (enabled); add (feedback); add (protocol_info); + add (editor); } TreeModelColumn name; TreeModelColumn enabled; TreeModelColumn feedback; TreeModelColumn protocol_info; + TreeModelColumn editor; }; Glib::RefPtr _store; ControlSurfacesModelColumns _model; TreeView _view; + Gtk::Window& _parent; }; RCOptionEditor::RCOptionEditor () - : OptionEditor (Config, _("Ardour Preferences")), - _rc_config (Config) + : OptionEditor (Config, string_compose (_("%1 Preferences"), PROGRAM_NAME)) + , _rc_config (Config) { /* MISC */ + uint32_t hwcpus = hardware_concurrency (); + + if (hwcpus > 1) { + add_option (_("Misc"), new OptionEditorHeading (_("DSP CPU Utilization"))); + + ComboOption* procs = new ComboOption ( + "processor-usage", + _("Signal processing uses"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_processor_usage), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_processor_usage) + ); + + procs->add (-1, _("all but one processor")); + procs->add (0, _("all available processors")); + + for (uint32_t i = 1; i <= hwcpus; ++i) { + procs->add (i, string_compose (_("%1 processors"), i)); + } + + add_option (_("Misc"), procs); + } + add_option (_("Misc"), new OptionEditorHeading (_("Metering"))); ComboOption* mht = new ComboOption ( "meter-hold", _("Meter hold time"), - mem_fun (*_rc_config, &RCConfiguration::get_meter_hold), - mem_fun (*_rc_config, &RCConfiguration::set_meter_hold) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_hold), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_hold) ); mht->add (MeterHoldOff, _("off")); @@ -876,8 +808,8 @@ RCOptionEditor::RCOptionEditor () ComboOption* mfo = new ComboOption ( "meter-falloff", _("Meter fall-off"), - mem_fun (*_rc_config, &RCConfiguration::get_meter_falloff), - mem_fun (*_rc_config, &RCConfiguration::set_meter_falloff) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_meter_falloff), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_meter_falloff) ); mfo->add (METER_FALLOFF_OFF, _("off")); @@ -905,106 +837,126 @@ RCOptionEditor::RCOptionEditor () new BoolOption ( "verify-remove-last-capture", _("Verify removal of last capture"), - mem_fun (*_rc_config, &RCConfiguration::get_verify_remove_last_capture), - mem_fun (*_rc_config, &RCConfiguration::set_verify_remove_last_capture) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_verify_remove_last_capture), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_verify_remove_last_capture) )); add_option (_("Misc"), new BoolOption ( "periodic-safety-backups", _("Make periodic backups of the session file"), - mem_fun (*_rc_config, &RCConfiguration::get_periodic_safety_backups), - mem_fun (*_rc_config, &RCConfiguration::set_periodic_safety_backups) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_periodic_safety_backups), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_periodic_safety_backups) )); add_option (_("Misc"), new BoolOption ( "sync-all-route-ordering", _("Syncronise editor and mixer track order"), - mem_fun (*_rc_config, &RCConfiguration::get_sync_all_route_ordering), - mem_fun (*_rc_config, &RCConfiguration::set_sync_all_route_ordering) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_sync_all_route_ordering), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_sync_all_route_ordering) )); add_option (_("Misc"), new BoolOption ( "only-copy-imported-files", _("Always copy imported files"), - mem_fun (*_rc_config, &RCConfiguration::get_only_copy_imported_files), - mem_fun (*_rc_config, &RCConfiguration::set_only_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) )); add_option (_("Misc"), new BoolOption ( "default-narrow_ms", _("Use narrow mixer strips"), - mem_fun (*_rc_config, &RCConfiguration::get_default_narrow_ms), - mem_fun (*_rc_config, &RCConfiguration::set_default_narrow_ms) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_default_narrow_ms), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_default_narrow_ms) )); add_option (_("Misc"), new BoolOption ( "name-new-markers", _("Name new markers"), - mem_fun (*_rc_config, &RCConfiguration::get_name_new_markers), - mem_fun (*_rc_config, &RCConfiguration::set_name_new_markers) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_name_new_markers), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_name_new_markers) )); + add_option (_("Misc"), new OptionEditorHeading (_("Click"))); + + add_option (_("Misc"), new ClickOptions (_rc_config, this)); + /* TRANSPORT */ add_option (_("Transport"), new BoolOption ( "latched-record-enable", _("Keep record-enable engaged on stop"), - mem_fun (*_rc_config, &RCConfiguration::get_latched_record_enable), - mem_fun (*_rc_config, &RCConfiguration::set_latched_record_enable) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_latched_record_enable), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_latched_record_enable) )); add_option (_("Transport"), new BoolOption ( "stop-recording-on-xrun", _("Stop recording when an xrun occurs"), - mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun), - mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun) )); add_option (_("Transport"), new BoolOption ( "create-xrun-marker", _("Create markers where xruns occur"), - mem_fun (*_rc_config, &RCConfiguration::get_create_xrun_marker), - mem_fun (*_rc_config, &RCConfiguration::set_create_xrun_marker) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_create_xrun_marker), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_create_xrun_marker) )); add_option (_("Transport"), new BoolOption ( "stop-at-session-end", _("Stop at the end of the session"), - mem_fun (*_rc_config, &RCConfiguration::get_stop_at_session_end), - mem_fun (*_rc_config, &RCConfiguration::set_stop_at_session_end) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_at_session_end), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_at_session_end) + )); + + add_option (_("Transport"), + new BoolOption ( + "seamless-loop", + _("Do seamless looping (not possible when slaved to MTC, JACK etc)"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_seamless_loop), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_seamless_loop) )); add_option (_("Transport"), new BoolOption ( "primary-clock-delta-edit-cursor", _("Primary clock delta to edit cursor"), - mem_fun (*_rc_config, &RCConfiguration::get_primary_clock_delta_edit_cursor), - mem_fun (*_rc_config, &RCConfiguration::set_primary_clock_delta_edit_cursor) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_primary_clock_delta_edit_cursor), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_primary_clock_delta_edit_cursor) )); add_option (_("Transport"), new BoolOption ( "secondary-clock-delta-edit-cursor", _("Secondary clock delta to edit cursor"), - mem_fun (*_rc_config, &RCConfiguration::get_secondary_clock_delta_edit_cursor), - mem_fun (*_rc_config, &RCConfiguration::set_secondary_clock_delta_edit_cursor) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_secondary_clock_delta_edit_cursor), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_secondary_clock_delta_edit_cursor) )); add_option (_("Transport"), new BoolOption ( "disable-disarm-during-roll", - _("Disable record disarm when transport is rolling"), - mem_fun (*_rc_config, &RCConfiguration::get_disable_disarm_during_roll), - mem_fun (*_rc_config, &RCConfiguration::set_disable_disarm_during_roll) + _("Disable per-track record disarm while rolling"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_disable_disarm_during_roll), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_disable_disarm_during_roll) + )); + + add_option (_("Transport"), + new BoolOption ( + "quieten_at_speed", + _("12dB gain reduction during fast-forward and fast-rewind"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_quieten_at_speed), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_quieten_at_speed) )); /* EDITOR */ @@ -1013,55 +965,55 @@ RCOptionEditor::RCOptionEditor () new BoolOption ( "link-region-and-track-selection", _("Link selection of regions and tracks"), - mem_fun (*_rc_config, &RCConfiguration::get_link_region_and_track_selection), - mem_fun (*_rc_config, &RCConfiguration::set_link_region_and_track_selection) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_link_region_and_track_selection), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_link_region_and_track_selection) )); add_option (_("Editor"), new BoolOption ( "automation-follows-regions", - _("Move relevant automation when regions are moved"), - mem_fun (*_rc_config, &RCConfiguration::get_automation_follows_regions), - mem_fun (*_rc_config, &RCConfiguration::set_automation_follows_regions) + _("Move relevant automation when audio regions are moved"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_automation_follows_regions), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_automation_follows_regions) )); add_option (_("Editor"), new BoolOption ( "show-track-meters", _("Show meters on tracks in the editor"), - mem_fun (*_rc_config, &RCConfiguration::get_show_track_meters), - mem_fun (*_rc_config, &RCConfiguration::set_show_track_meters) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_track_meters), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_track_meters) )); add_option (_("Editor"), new BoolOption ( "use-overlap-equivalency", _("Use overlap equivalency for regions"), - mem_fun (*_rc_config, &RCConfiguration::get_use_overlap_equivalency), - mem_fun (*_rc_config, &RCConfiguration::set_use_overlap_equivalency) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_use_overlap_equivalency), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_use_overlap_equivalency) )); add_option (_("Editor"), new BoolOption ( "rubberbanding-snaps-to-grid", _("Make rubberband selection rectangle snap to the grid"), - mem_fun (*_rc_config, &RCConfiguration::get_rubberbanding_snaps_to_grid), - mem_fun (*_rc_config, &RCConfiguration::set_rubberbanding_snaps_to_grid) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_rubberbanding_snaps_to_grid), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_rubberbanding_snaps_to_grid) )); add_option (_("Editor"), new BoolOption ( "show-waveforms", _("Show waveforms in regions"), - mem_fun (*_rc_config, &RCConfiguration::get_show_waveforms), - mem_fun (*_rc_config, &RCConfiguration::set_show_waveforms) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_waveforms), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_waveforms) )); ComboOption* wfs = new ComboOption ( "waveform-scale", _("Waveform scale"), - mem_fun (*_rc_config, &RCConfiguration::get_waveform_scale), - mem_fun (*_rc_config, &RCConfiguration::set_waveform_scale) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_waveform_scale), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_waveform_scale) ); wfs->add (Linear, _("linear")); @@ -1072,8 +1024,8 @@ RCOptionEditor::RCOptionEditor () ComboOption* wfsh = new ComboOption ( "waveform-shape", _("Waveform shape"), - mem_fun (*_rc_config, &RCConfiguration::get_waveform_shape), - mem_fun (*_rc_config, &RCConfiguration::set_waveform_shape) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_waveform_shape), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_waveform_shape) ); wfsh->add (Traditional, _("traditional")); @@ -1081,77 +1033,94 @@ RCOptionEditor::RCOptionEditor () add_option (_("Editor"), wfsh); - /* AUDIO */ - - add_option (_("Audio"), new OptionEditorHeading (_("Solo"))); - - - add_option (_("Audio"), + add_option (_("Editor"), new BoolOption ( - "solo-control-is-listen-control", - _("Solo controls are Listen controls"), - mem_fun (*_rc_config, &RCConfiguration::get_solo_control_is_listen_control), - mem_fun (*_rc_config, &RCConfiguration::set_solo_control_is_listen_control) + "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) )); - ComboOption* lp = new ComboOption ( - "listen-position", - _("Listen Position"), - mem_fun (*_rc_config, &RCConfiguration::get_listen_position), - mem_fun (*_rc_config, &RCConfiguration::set_listen_position) - ); + 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) + )); - lp->add (AfterFaderListen, _("after-fader listen")); - lp->add (PreFaderListen, _("pre-fader listen")); + add_option (_("Editor"), + new BoolOption ( + "color-regions-using-track-color", + _("Color regions using their track's color"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_color_regions_using_track_color), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_color_regions_using_track_color) + )); - add_option (_("Audio"), lp); - add_option (_("Audio"), new SoloMuteOptions (_rc_config)); + /* AUDIO */ - add_option (_("Audio"), - new BoolOption ( - "solo-latched", - _("Latched solo"), - mem_fun (*_rc_config, &RCConfiguration::get_solo_latched), - mem_fun (*_rc_config, &RCConfiguration::set_solo_latched) - )); + add_option (_("Audio"), new OptionEditorHeading (_("Buffering"))); - add_option (_("Audio"), - new BoolOption ( - "show-solo-mutes", - _("Show solo muting"), - mem_fun (*_rc_config, &RCConfiguration::get_show_solo_mutes), - mem_fun (*_rc_config, &RCConfiguration::set_show_solo_mutes) - )); + add_option (_("Audio"), new BufferingOptions (_rc_config)); + + add_option (_("Audio"), new OptionEditorHeading (_("Monitoring"))); add_option (_("Audio"), new BoolOption ( - "solo-mute-override", - _("Override muting"), - mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_override), - mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_override) + "use-monitor-bus", + _("Use a monitor bus (allows AFL/PFL and more control)"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_use_monitor_bus), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_use_monitor_bus) )); - add_option (_("Audio"), new OptionEditorHeading (_("Monitoring"))); - ComboOption* mm = new ComboOption ( "monitoring-model", - _("Monitoring handled by"), - mem_fun (*_rc_config, &RCConfiguration::get_monitoring_model), - mem_fun (*_rc_config, &RCConfiguration::set_monitoring_model) + _("Record monitoring handled by"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_monitoring_model), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_monitoring_model) ); - mm->add (HardwareMonitoring, _("JACK")); +#ifndef __APPLE__ + /* no JACK monitoring on CoreAudio */ + if (AudioEngine::instance()->can_request_hardware_monitoring()) { + mm->add (HardwareMonitoring, _("JACK")); + } +#endif mm->add (SoftwareMonitoring, _("ardour")); mm->add (ExternalMonitoring, _("audio hardware")); add_option (_("Audio"), mm); + + ComboOption* pp = new ComboOption ( + "pfl-position", + _("PFL signals come from"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_pfl_position), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_pfl_position) + ); + + pp->add (PFLFromBeforeProcessors, _("before pre-fader processors")); + pp->add (PFLFromAfterProcessors, _("pre-fader but after pre-fader processors")); + + add_option (_("Audio"), pp); + + ComboOption* pa = new ComboOption ( + "afl-position", + _("AFL signals come from"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_afl_position), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_afl_position) + ); + + pa->add (AFLFromBeforeProcessors, _("post-fader but before post-fader processors")); + pa->add (AFLFromAfterProcessors, _("after post-fader processors")); + + add_option (_("Audio"), pa); add_option (_("Audio"), new BoolOption ( "tape-machine-mode", _("Tape machine mode"), - mem_fun (*_rc_config, &RCConfiguration::get_tape_machine_mode), - mem_fun (*_rc_config, &RCConfiguration::set_tape_machine_mode) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_tape_machine_mode), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_tape_machine_mode) )); add_option (_("Audio"), new OptionEditorHeading (_("Connection of tracks and busses"))); @@ -1160,15 +1129,15 @@ RCOptionEditor::RCOptionEditor () new BoolOption ( "auto-connect-standard-busses", _("Auto-connect master/monitor busses"), - mem_fun (*_rc_config, &RCConfiguration::get_auto_connect_standard_busses), - mem_fun (*_rc_config, &RCConfiguration::set_auto_connect_standard_busses) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_auto_connect_standard_busses), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_auto_connect_standard_busses) )); ComboOption* iac = new ComboOption ( "input-auto-connect", - _("Connect track and bus inputs"), - mem_fun (*_rc_config, &RCConfiguration::get_input_auto_connect), - mem_fun (*_rc_config, &RCConfiguration::set_input_auto_connect) + _("Connect track inputs"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_input_auto_connect), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_input_auto_connect) ); iac->add (AutoConnectPhysical, _("automatically to physical inputs")); @@ -1179,12 +1148,12 @@ RCOptionEditor::RCOptionEditor () ComboOption* oac = new ComboOption ( "output-auto-connect", _("Connect track and bus outputs"), - mem_fun (*_rc_config, &RCConfiguration::get_output_auto_connect), - mem_fun (*_rc_config, &RCConfiguration::set_output_auto_connect) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_output_auto_connect), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_output_auto_connect) ); oac->add (AutoConnectPhysical, _("automatically to physical outputs")); - oac->add (AutoConnectMaster, _("automatically to master outputs")); + oac->add (AutoConnectMaster, _("automatically to master bus")); oac->add (ManualConnect, _("manually")); add_option (_("Audio"), oac); @@ -1195,15 +1164,15 @@ RCOptionEditor::RCOptionEditor () new BoolOption ( "denormal-protection", _("Use DC bias to protect against denormals"), - mem_fun (*_rc_config, &RCConfiguration::get_denormal_protection), - mem_fun (*_rc_config, &RCConfiguration::set_denormal_protection) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_denormal_protection), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_protection) )); ComboOption* dm = new ComboOption ( "denormal-model", _("Processor handling"), - mem_fun (*_rc_config, &RCConfiguration::get_denormal_model), - mem_fun (*_rc_config, &RCConfiguration::set_denormal_model) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_denormal_model), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_denormal_model) ); dm->add (DenormalNone, _("no processor handling")); @@ -1230,78 +1199,188 @@ RCOptionEditor::RCOptionEditor () new BoolOption ( "plugins-stop-with-transport", _("Stop plugins when the transport is stopped"), - mem_fun (*_rc_config, &RCConfiguration::get_plugins_stop_with_transport), - mem_fun (*_rc_config, &RCConfiguration::set_plugins_stop_with_transport) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_plugins_stop_with_transport), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_plugins_stop_with_transport) )); add_option (_("Audio"), new BoolOption ( "do-not-record-plugins", _("Disable plugins during recording"), - mem_fun (*_rc_config, &RCConfiguration::get_do_not_record_plugins), - mem_fun (*_rc_config, &RCConfiguration::set_do_not_record_plugins) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_do_not_record_plugins), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_do_not_record_plugins) )); add_option (_("Audio"), new BoolOption ( "new-plugins-active", _("Make new plugins active"), - mem_fun (*_rc_config, &RCConfiguration::get_new_plugins_active), - mem_fun (*_rc_config, &RCConfiguration::set_new_plugins_active) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_new_plugins_active), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_new_plugins_active) )); add_option (_("Audio"), new BoolOption ( "auto-analyse-audio", _("Enable automatic analysis of audio"), - mem_fun (*_rc_config, &RCConfiguration::get_auto_analyse_audio), - mem_fun (*_rc_config, &RCConfiguration::set_auto_analyse_audio) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_auto_analyse_audio), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_auto_analyse_audio) + )); + + add_option (_("Audio"), + new BoolOption ( + "replicate-missing-region-channels", + _("Replicate missing region channels"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_replicate_missing_region_channels), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_replicate_missing_region_channels) + )); + + /* SOLO AND MUTE */ + + add_option (_("Solo / mute"), + new FaderOption ( + "solo-mute-gain", + _("Solo mute cut (dB)"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_gain), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_gain) + )); + + _solo_control_is_listen_control = new BoolOption ( + "solo-control-is-listen-control", + _("Solo controls are Listen controls"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_control_is_listen_control), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_control_is_listen_control) + ); + + add_option (_("Solo / mute"), _solo_control_is_listen_control); + + _listen_position = new ComboOption ( + "listen-position", + _("Listen Position"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_listen_position), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_listen_position) + ); + + _listen_position->add (AfterFaderListen, _("after-fader listen")); + _listen_position->add (PreFaderListen, _("pre-fader listen")); + + add_option (_("Solo / mute"), _listen_position); + + parameter_changed ("use-monitor-bus"); + + add_option (_("Solo / mute"), + new BoolOption ( + "exclusive-solo", + _("Exclusive solo"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_exclusive_solo), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_exclusive_solo) + )); + + add_option (_("Solo / mute"), + new BoolOption ( + "show-solo-mutes", + _("Show solo muting"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_show_solo_mutes), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_show_solo_mutes) + )); + + add_option (_("Solo / mute"), + new BoolOption ( + "solo-mute-override", + _("Soloing overrides muting"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_override), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_override) )); - /* MIDI CONTROL */ - - list* > midi_combos; - - midi_combos.push_back (new ComboOption ( - "mtc-port-name", - _("Receive MTC via"), - mem_fun (*_rc_config, &RCConfiguration::get_mtc_port_name), - mem_fun (*_rc_config, &RCConfiguration::set_mtc_port_name) - )); - - midi_combos.push_back (new ComboOption ( - "midi-clock-port-name", - _("Receive MIDI clock via"), - mem_fun (*_rc_config, &RCConfiguration::get_midi_clock_port_name), - mem_fun (*_rc_config, &RCConfiguration::set_midi_clock_port_name) - )); - - midi_combos.push_back (new ComboOption ( - "mmc-port-name", - _("Receive MMC via"), - mem_fun (*_rc_config, &RCConfiguration::get_mmc_port_name), - mem_fun (*_rc_config, &RCConfiguration::set_mmc_port_name) - )); - - midi_combos.push_back (new ComboOption ( - "midi-port-name", - _("Receive MIDI parameter control via"), - mem_fun (*_rc_config, &RCConfiguration::get_midi_port_name), - mem_fun (*_rc_config, &RCConfiguration::set_midi_port_name) - )); + add_option (_("Solo / mute"), new OptionEditorHeading (_("Default track / bus muting options"))); - add_option (_("MIDI control"), new MIDIPorts (_rc_config, midi_combos)); + add_option (_("Solo / mute"), + new BoolOption ( + "mute-affects-pre-fader", + _("Mute affects pre-fader sends"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_pre_fader), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_pre_fader) + )); - for (list* >::iterator i = midi_combos.begin(); i != midi_combos.end(); ++i) { - add_option (_("MIDI control"), *i); - } + add_option (_("Solo / mute"), + new BoolOption ( + "mute-affects-post-fader", + _("Mute affects post-fader sends"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_post_fader), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_post_fader) + )); + + add_option (_("Solo / mute"), + new BoolOption ( + "mute-affects-control-outs", + _("Mute affects control outputs"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_control_outs), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_control_outs) + )); + + add_option (_("Solo / mute"), + new BoolOption ( + "mute-affects-main-outs", + _("Mute affects main outputs"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mute_affects_main_outs), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mute_affects_main_outs) + )); + + add_option (_("MIDI control"), + new BoolOption ( + "send-midi-clock", + _("Send MIDI Clock"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_midi_clock), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_midi_clock) + )); + + add_option (_("MIDI control"), + new BoolOption ( + "send-mtc", + _("Send MIDI Time Code"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_mtc), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_mtc) + )); + + add_option (_("MIDI control"), + new SpinOption ( + "mtc-qf-speed-tolerance", + _("Percentage either side of normal transport speed to transmit MTC"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mtc_qf_speed_tolerance), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mtc_qf_speed_tolerance), + 0, 20, 1, 5 + )); + + add_option (_("MIDI control"), + new BoolOption ( + "mmc-control", + _("Obey MIDI Machine Control commands"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_control), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_control) + )); + + add_option (_("MIDI control"), + new BoolOption ( + "send-mmc", + _("Send MIDI Machine Control commands"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_send_mmc), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_send_mmc) + )); + + add_option (_("MIDI control"), + new BoolOption ( + "midi-feedback", + _("Send MIDI control feedback"), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_midi_feedback), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_midi_feedback) + )); add_option (_("MIDI control"), new SpinOption ( "mmc-receive-device-id", _("Inbound MMC device ID"), - mem_fun (*_rc_config, &RCConfiguration::get_mmc_receive_device_id), - mem_fun (*_rc_config, &RCConfiguration::set_mmc_receive_device_id), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_receive_device_id), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_receive_device_id), 0, 128, 1, 10 )); @@ -1309,8 +1388,8 @@ RCOptionEditor::RCOptionEditor () new SpinOption ( "mmc-send-device-id", _("Outbound MMC device ID"), - mem_fun (*_rc_config, &RCConfiguration::get_mmc_send_device_id), - mem_fun (*_rc_config, &RCConfiguration::set_mmc_send_device_id), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_mmc_send_device_id), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_mmc_send_device_id), 0, 128, 1, 10 )); @@ -1318,20 +1397,20 @@ RCOptionEditor::RCOptionEditor () new SpinOption ( "initial-program-change", _("Initial program change"), - mem_fun (*_rc_config, &RCConfiguration::get_initial_program_change), - mem_fun (*_rc_config, &RCConfiguration::set_initial_program_change), + sigc::mem_fun (*_rc_config, &RCConfiguration::get_initial_program_change), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_initial_program_change), -1, 65536, 1, 10 )); /* CONTROL SURFACES */ - add_option (_("Control surfaces"), new ControlSurfacesOptions); + add_option (_("Control surfaces"), new ControlSurfacesOptions (*this)); ComboOption* rm = new ComboOption ( "remote-model", _("Control surface remote ID"), - mem_fun (*_rc_config, &RCConfiguration::get_remote_model), - mem_fun (*_rc_config, &RCConfiguration::set_remote_model) + sigc::mem_fun (*_rc_config, &RCConfiguration::get_remote_model), + sigc::mem_fun (*_rc_config, &RCConfiguration::set_remote_model) ); rm->add (UserOrdered, _("assigned by user")); @@ -1340,13 +1419,23 @@ RCOptionEditor::RCOptionEditor () add_option (_("Control surfaces"), rm); - /* CLICK */ - - add_option (_("Click"), new ClickOptions (_rc_config, this)); - /* KEYBOARD */ add_option (_("Keyboard"), new KeyboardOptions); } - +void +RCOptionEditor::parameter_changed (string const & p) +{ + OptionEditor::parameter_changed (p); + + if (p == "use-monitor-bus") { + bool const s = Config->get_use_monitor_bus (); + if (!s) { + /* we can't use this if we don't have a monitor bus */ + Config->set_solo_control_is_listen_control (false); + } + _solo_control_is_listen_control->set_sensitive (s); + _listen_position->set_sensitive (s); + } +}