#include <gtkmm/scale.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/slider_controller.h>
+
#include "pbd/fpu.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"
private:
+ typedef std::map<MIDI::Port*,MidiTracer*> PortTraceMap;
+ PortTraceMap port_input_trace_map;
+ PortTraceMap port_output_trace_map;
+
void model_changed (TreeModel::Path const &, TreeModel::iterator const & i)
{
TreeModel::Row r = *i;
}
if (r[_model.trace_input] != port->input()->tracing()) {
- port->input()->trace (r[_model.trace_input], &cerr, string (port->name()) + _(" input: "));
+ PortTraceMap::iterator x = port_input_trace_map.find (port);
+ MidiTracer* mt;
+
+ if (x == port_input_trace_map.end()) {
+ mt = new MidiTracer (port->name() + string (" [input]"), *port->input());
+ port_input_trace_map.insert (pair<MIDI::Port*,MidiTracer*> (port, mt));
+ } else {
+ mt = x->second;
+ }
+ mt->present ();
}
}
if (port->output()) {
if (r[_model.trace_output] != port->output()->tracing()) {
- port->output()->trace (r[_model.trace_output], &cerr, string (port->name()) + _(" output: "));
+ PortTraceMap::iterator x = port_output_trace_map.find (port);
+ MidiTracer* mt;
+
+ if (x == port_output_trace_map.end()) {
+ mt = new MidiTracer (port->name() + string (" [output]"), *port->output());
+ port_output_trace_map.insert (pair<MIDI::Port*,MidiTracer*> (port, mt));
+ } else {
+ mt = x->second;
+ }
+ mt->present ();
}
}
if ((*i)->input()) {
r[_model.online] = !(*i)->input()->offline();
- (*i)->input()->OfflineStatusChanged.connect (port_connections, boost::bind (&MIDIPorts::port_offline_changed, this, (*i)));
+ (*i)->input()->OfflineStatusChanged.connect (port_connections, MISSING_INVALIDATOR, boost::bind (&MIDIPorts::port_offline_changed, this, (*i)), gui_context());
r[_model.trace_input] = (*i)->input()->tracing();
}
{ "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 },
}
_db_slider = manage (new HSliderController (pix,
- &_db_adjustment,
- false,
- 115));
-
+ &_db_adjustment,
+ 115,
+ false));
parameter_changed ("solo-mute-gain");
h->pack_start (*l, false, false);
h->pack_start (*_db_slider, false, false);
h->pack_start (_db_display, false, false);
+ h->show_all ();
set_size_request_to_display_given_text (_db_display, "-99.0", 12, 12);
class ControlSurfacesOptions : public OptionEditorBox
{
public:
- ControlSurfacesOptions ()
+ ControlSurfacesOptions (ArdourDialog& parent)
+ : _parent (parent)
{
_store = ListStore::create (_model);
_view.set_model (_store);
_box->pack_start (_view, false, false);
+ Label* label = manage (new Label);
+ label->set_markup (string_compose (X_("<i>%1</i>"), _("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 &)
}
}
+ 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:
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;
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 */
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 */
add_option (_("Editor"),
add_option (_("Editor"), wfsh);
+ 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)
+ ));
+
/* AUDIO */
add_option (_("Audio"), new OptionEditorHeading (_("Solo")));
-
add_option (_("Audio"),
new BoolOption (
"solo-control-is-listen-control",
add_option (_("Audio"),
new BoolOption (
- "solo-latched",
- _("Latched solo"),
- sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_latched),
- sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_latched)
+ "exclusive-solo",
+ _("Exclusive solo"),
+ sigc::mem_fun (*_rc_config, &RCConfiguration::get_exclusive_solo),
+ sigc::mem_fun (*_rc_config, &RCConfiguration::set_exclusive_solo)
));
add_option (_("Audio"),
add_option (_("Audio"),
new BoolOption (
"solo-mute-override",
- _("Override muting"),
+ _("Soloing overrides muting"),
sigc::mem_fun (*_rc_config, &RCConfiguration::get_solo_mute_override),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_solo_mute_override)
));
add_option (_("Audio"), new OptionEditorHeading (_("Monitoring")));
+ add_option (_("Audio"),
+ new BoolOption (
+ "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)
+ ));
+
ComboOption<MonitorModel>* mm = new ComboOption<MonitorModel> (
"monitoring-model",
_("Monitoring handled by"),
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 (_("MIDI control"), *i);
}
+ 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 BoolOption (
"mmc-control",
/* CONTROL SURFACES */
- add_option (_("Control surfaces"), new ControlSurfacesOptions);
+ add_option (_("Control surfaces"), new ControlSurfacesOptions (*this));
ComboOption<RemoteModel>* rm = new ComboOption<RemoteModel> (
"remote-model",