set_latency_label ();
smaller_hbox->pack_start (latency_button, false, false, 10);
- smaller_hbox->pack_start (preset_combo, false, false);
+ smaller_hbox->pack_start (_preset_box, false, false);
smaller_hbox->pack_start (add_button, false, false);
smaller_hbox->pack_start (save_button, false, false);
smaller_hbox->pack_start (delete_button, false, false);
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::control_combo_changed), control_ui));
- mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::parameter_changed, this, control_ui), gui_context());
+ mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::ui_parameter_changed, this, control_ui), gui_context());
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::control_combo_changed), control_ui));
- mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::parameter_changed, this, control_ui), gui_context());
+ mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::ui_parameter_changed, this, control_ui), gui_context());
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
automation_state_changed (control_ui);
- mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::parameter_changed, this, control_ui), gui_context());
+ mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::ui_parameter_changed, this, control_ui), gui_context());
mcontrol->alist()->automation_state_changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::automation_state_changed, this, control_ui), gui_context());
input_controls.push_back (control_ui);
output_controls.push_back (control_ui);
}
- mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::parameter_changed, this, control_ui), gui_context());
+ mcontrol->Changed.connect (control_connections, invalidator (*this), boost::bind (&GenericPluginUI::ui_parameter_changed, this, control_ui), gui_context());
return control_ui;
}
}
void
-GenericPluginUI::parameter_changed (ControlUI* cui)
+GenericPluginUI::ui_parameter_changed (ControlUI* cui)
{
if (!cui->update_pending) {
cui->update_pending = true;
void
LV2PluginUI::parameter_changed (uint32_t port_index, float val)
{
- //cout << "parameter_changed" << endl;
+ PlugUIBase::parameter_changed (port_index, val);
+
if (val != _values[port_index]) {
parameter_update(port_index, val);
}
}
}
}
-
- _lv2->ParameterChanged.connect (parameter_connection, invalidator (*this), ui_bind (&LV2PluginUI::parameter_changed, this, _1, _2), gui_context());
}
LV2PluginUI::~LV2PluginUI ()
int package (Gtk::Window&);
private:
+
+ void parameter_changed (uint32_t, float);
+
boost::shared_ptr<ARDOUR::LV2Plugin> _lv2;
std::vector<int> _output_ports;
sigc::connection _screen_update_connection;
void lv2ui_instantiate(const std::string& title);
- void parameter_changed(uint32_t, float);
void parameter_update(uint32_t, float);
bool configure_handler (GdkEventConfigure*);
void save_plugin_setting ();
virtual bool on_window_show(const std::string& title);
virtual void on_window_hide();
-
- PBD::ScopedConnection parameter_connection;
};
#endif // HAVE_SLV2
set_role("plugin_ui");
if (_pluginui) {
- _pluginui->update_presets ();
+ _pluginui->update_preset_list ();
+ _pluginui->update_preset ();
}
if (_pluginui) {
latency_gui (0),
plugin_analysis_expander (_("Plugin analysis"))
{
- //preset_combo.set_use_arrows_always(true);
- update_presets ();
- update_sensitivity ();
-
- preset_combo.set_size_request (100, -1);
- preset_combo.set_active_text ("");
- preset_combo.signal_changed().connect(sigc::mem_fun(*this, &PlugUIBase::setting_selected));
- no_load_preset = false;
+ _preset_combo.set_size_request (100, -1);
+ _preset_modified.set_size_request (16, -1);
+ _preset_combo.signal_changed().connect(sigc::mem_fun(*this, &PlugUIBase::preset_selected));
+ _no_load_preset = 0;
+
+ _preset_box.pack_start (_preset_combo);
+ _preset_box.pack_start (_preset_modified);
+ update_preset_list ();
+ update_preset ();
+
add_button.set_name ("PluginAddButton");
add_button.signal_clicked().connect (sigc::mem_fun (*this, &PlugUIBase::add_plugin_setting));
insert->DropReferences.connect (death_connection, invalidator (*this), boost::bind (&PlugUIBase::plugin_going_away, this), gui_context());
- plugin->PresetAdded.connect (preset_added_connection, invalidator (*this), boost::bind (&PlugUIBase::update_presets, this), gui_context ());
- plugin->PresetRemoved.connect (preset_removed_connection, invalidator (*this), boost::bind (&PlugUIBase::update_presets, this), gui_context ());
+ plugin->PresetAdded.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::preset_added_or_removed, this), gui_context ());
+ plugin->PresetRemoved.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::preset_added_or_removed, this), gui_context ());
+ plugin->PresetLoaded.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::update_preset, this), gui_context ());
+ plugin->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::parameter_changed, this, _1, _2), gui_context ());
}
PlugUIBase::~PlugUIBase()
}
void
-PlugUIBase::setting_selected ()
+PlugUIBase::preset_selected ()
{
- if (no_load_preset) {
+ if (_no_load_preset) {
return;
}
- if (preset_combo.get_active_text().length() > 0) {
- const Plugin::PresetRecord* pr = plugin->preset_by_label(preset_combo.get_active_text());
+ if (_preset_combo.get_active_text().length() > 0) {
+ const Plugin::PresetRecord* pr = plugin->preset_by_label (_preset_combo.get_active_text());
if (pr) {
- plugin->load_preset (pr->uri);
- update_sensitivity ();
+ plugin->load_preset (*pr);
} else {
warning << string_compose(_("Plugin preset %1 not found"),
- preset_combo.get_active_text()) << endmsg;
+ _preset_combo.get_active_text()) << endmsg;
}
}
}
plugin->remove_preset (d.name ());
}
- if (plugin->save_preset (d.name())) {
- preset_combo.set_active_text (d.name());
+ Plugin::PresetRecord const r = plugin->save_preset (d.name());
+ if (!r.uri.empty ()) {
+ plugin->load_preset (r);
}
break;
}
void
PlugUIBase::save_plugin_setting ()
{
- string const name = preset_combo.get_active_text ();
+ string const name = _preset_combo.get_active_text ();
plugin->remove_preset (name);
- plugin->save_preset (name);
- preset_combo.set_active_text (name);
+ Plugin::PresetRecord const r = plugin->save_preset (name);
+ if (!r.uri.empty ()) {
+ plugin->load_preset (r);
+ }
}
void
PlugUIBase::delete_plugin_setting ()
{
- plugin->remove_preset (preset_combo.get_active_text ());
-
- vector<ARDOUR::Plugin::PresetRecord> presets = plugin->get_presets();
- if (presets.empty ()) {
- preset_combo.set_active_text ("");
- } else {
- preset_combo.set_active_text (presets.front().label);
- }
+ plugin->remove_preset (_preset_combo.get_active_text ());
}
void
}
void
-PlugUIBase::update_presets ()
+PlugUIBase::update_preset_list ()
{
vector<string> preset_labels;
vector<ARDOUR::Plugin::PresetRecord> presets = plugin->get_presets();
- no_load_preset = true;
+ ++_no_load_preset;
for (vector<ARDOUR::Plugin::PresetRecord>::const_iterator i = presets.begin(); i != presets.end(); ++i) {
- preset_labels.push_back(i->label);
+ preset_labels.push_back (i->label);
}
- set_popdown_strings (preset_combo, preset_labels);
+ set_popdown_strings (_preset_combo, preset_labels);
- no_load_preset = false;
+ --_no_load_preset;
+}
+
+void
+PlugUIBase::update_preset ()
+{
+ Plugin::PresetRecord p = plugin->last_preset();
+
+ ++_no_load_preset;
+ _preset_combo.set_active_text (p.label);
+ --_no_load_preset;
- update_sensitivity ();
+ save_button.set_sensitive (!p.uri.empty() && p.user);
+ delete_button.set_sensitive (!p.uri.empty() && p.user);
+
+ update_preset_modified ();
}
void
-PlugUIBase::update_sensitivity ()
+PlugUIBase::update_preset_modified ()
{
- bool const have_user_preset =
- !preset_combo.get_model()->children().empty() && preset_combo.get_active_row_number() >= plugin->first_user_preset_index();
+ if (plugin->last_preset().uri.empty()) {
+ _preset_modified.set_text ("");
+ return;
+ }
- save_button.set_sensitive (have_user_preset);
- delete_button.set_sensitive (have_user_preset);
+ bool const c = plugin->parameter_changed_since_last_preset ();
+ if (_preset_modified.get_text().empty() == c) {
+ _preset_modified.set_text (c ? "*" : "");
+ }
+}
+
+void
+PlugUIBase::parameter_changed (uint32_t, float)
+{
+ update_preset_modified ();
+}
+
+void
+PlugUIBase::preset_added_or_removed ()
+{
+ /* Update both the list and the currently-displayed preset */
+ update_preset_list ();
+ update_preset ();
}
class LatencyGUI;
class ArdourDialog;
-class PlugUIBase : public virtual sigc::trackable
+class PlugUIBase : public virtual sigc::trackable, public PBD::ScopedConnectionList
{
public:
PlugUIBase (boost::shared_ptr<ARDOUR::PluginInsert>);
virtual void activate () {}
virtual void deactivate () {}
- virtual void update_presets ();
+ void update_preset_list ();
+ void update_preset ();
void latency_button_clicked ();
protected:
boost::shared_ptr<ARDOUR::PluginInsert> insert;
boost::shared_ptr<ARDOUR::Plugin> plugin;
- Gtk::ComboBoxText preset_combo;
+ Gtk::HBox _preset_box;
+ Gtk::ComboBoxText _preset_combo;
+ Gtk::Label _preset_modified;
Gtk::Button add_button;
Gtk::Button save_button;
Gtk::Button delete_button;
Gtk::Image* focus_out_image;
Gtk::Image* focus_in_image;
- bool no_load_preset;
+ int _no_load_preset;
- virtual void setting_selected ();
+ virtual void preset_selected ();
void add_plugin_setting ();
void save_plugin_setting ();
void delete_plugin_setting ();
void toggle_plugin_analysis ();
void processor_active_changed (boost::weak_ptr<ARDOUR::Processor> p);
void plugin_going_away ();
- void update_sensitivity ();
+ virtual void parameter_changed (uint32_t, float);
+ void preset_added_or_removed ();
+ void update_preset_modified ();
PBD::ScopedConnection death_connection;
PBD::ScopedConnection active_connection;
void build ();
ControlUI* build_control_ui (guint32 port_index, boost::shared_ptr<ARDOUR::AutomationControl>);
std::vector<std::string> setup_scale_values(guint32 port_index, ControlUI* cui);
- void parameter_changed (ControlUI* cui);
+ void ui_parameter_changed (ControlUI* cui);
void toggle_parameter_changed (ControlUI* cui);
void update_control_display (ControlUI* cui);
void control_port_toggled (ControlUI* cui);
: PlugUIBase (pi),
vst (vp)
{
- update_presets ();
-
fst_run_editor (vst->fst());
preset_box.set_spacing (6);
preset_box.pack_end (delete_button, false, false);
preset_box.pack_end (save_button, false, false);
preset_box.pack_end (add_button, false, false);
- preset_box.pack_end (preset_combo, false, false);
+ preset_box.pack_end (_preset_box, false, false);
bypass_button.set_active (!insert->active());
}
void
-VSTPluginUI::setting_selected ()
+VSTPluginUI::preset_selected ()
{
- int const r = preset_combo.get_active_row_number ();
-
- if (r < vst->first_user_preset_index()) {
- /* This is a plugin-provided preset.
- We can't dispatch directly here; too many plugins expects only one GUI thread.
- */
- vst->fst()->want_program = r;
- } else {
- /* This is a user preset. This method knows about the direct dispatch restriction, too */
- plugin->load_preset (preset_combo.get_active_text());
- }
-
socket.grab_focus ();
- update_sensitivity ();
+ PlugUIBase::preset_selected ();
}
int
bool configure_handler (GdkEventConfigure*, Gtk::Socket*);
void save_plugin_setting ();
- void setting_selected ();
+ void preset_selected ();
};
bool parameter_is_input (uint32_t) const;
bool parameter_is_output (uint32_t) const;
- XMLNode& get_state();
int set_state(const XMLNode& node, int);
bool save_preset (std::string name);
bool load_preset (const std::string& preset_label);
- std::vector<PresetRecord> get_presets ();
std::string current_preset() const;
bool has_editor () const;
static std::string maybe_fix_broken_au_id (const std::string&);
private:
+ void find_presets ();
+
boost::shared_ptr<CAComponent> comp;
boost::shared_ptr<CAAudioUnit> unit;
int set_input_format (AudioStreamBasicDescription&);
int set_stream_format (int scope, uint32_t cnt, AudioStreamBasicDescription&);
void discover_parameters ();
+ void add_state (XMLNode *) const;
std::vector<std::pair<uint32_t, uint32_t> > parameter_map;
uint32_t current_maxbuf;
bool parameter_is_output(uint32_t) const;
bool parameter_is_toggled(uint32_t) const;
- XMLNode& get_state();
int set_state (const XMLNode&, int version);
- std::vector<PresetRecord> get_presets ();
- bool load_preset (const std::string& uri);
+ bool load_preset (PresetRecord);
bool has_editor() const { return false; }
uint32_t _index;
bool _was_activated;
+ void find_presets ();
+
void init (void *mod, uint32_t index, framecnt_t rate);
void run_in_place (pframes_t nsamples);
void latency_compute_run ();
std::string preset_envvar () const;
std::string preset_source (std::string) const;
bool write_preset_file (std::string);
+ void add_state (XMLNode *) const;
};
class LadspaPluginInfo : public PluginInfo {
bool is_external_ui() const;
SLV2Port slv2_port(uint32_t i) { return slv2_plugin_get_port_by_index(_plugin, i); }
- const char* port_symbol(uint32_t port);
+ const char* port_symbol (uint32_t port) const;
const LV2_Feature* const* features() { return _features; }
static uint32_t midi_event_type() { return _midi_event_type; }
- XMLNode& get_state();
int set_state(const XMLNode& node, int version);
bool save_preset (std::string uri);
void remove_preset (std::string uri);
- bool load_preset (const std::string& uri);
- virtual std::vector<Plugin::PresetRecord> get_presets();
+ bool load_preset (PresetRecord);
+ std::string current_preset () const;
bool has_editor() const;
void latency_compute_run ();
std::string do_save_preset (std::string);
void do_remove_preset (std::string);
+ void find_presets ();
+ void add_state (XMLNode *) const;
};
bool max_unbound;
};
+ XMLNode& get_state ();
+ virtual int set_state (const XMLNode &, int version);
+
virtual std::string unique_id() const = 0;
virtual const char * label() const = 0;
virtual const char * name() const = 0;
void realtime_handle_transport_stopped ();
- bool save_preset (std::string);
- void remove_preset (std::string);
- virtual bool load_preset (const std::string& uri) = 0;
-
struct PresetRecord {
- PresetRecord (const std::string& u, const std::string& l) : uri(u), label(l) {}
+ PresetRecord () : user (true) {}
+ PresetRecord (const std::string& u, const std::string& l, bool s = true) : uri (u), label (l), user (s) {}
+
+ bool operator!= (PresetRecord const & a) const {
+ return uri != a.uri || label != a.label;
+ }
+
std::string uri;
std::string label;
+ bool user;
};
+ PresetRecord save_preset (std::string);
+ void remove_preset (std::string);
+
+ virtual bool load_preset (PresetRecord);
+
const PresetRecord * preset_by_label (const std::string &);
const PresetRecord * preset_by_uri (const std::string &);
- /** Return this plugin's presets; should add them to _presets */
- virtual std::vector<PresetRecord> get_presets () = 0;
- virtual std::string current_preset () const { return std::string(); }
+ std::vector<PresetRecord> get_presets ();
+ /** @return Last preset to be requested; the settings may have
+ * been changed since; find out with parameter_changed_since_last_preset.
+ */
+ PresetRecord last_preset () const {
+ return _last_preset;
+ }
+
+ bool parameter_changed_since_last_preset () const {
+ return _parameter_changed_since_last_preset;
+ }
+
virtual int first_user_preset_index () const {
return 0;
}
/** Emitted when a preset is added or removed, respectively */
PBD::Signal0<void> PresetAdded;
PBD::Signal0<void> PresetRemoved;
-
- /* XXX: no-one listens to this */
- static PBD::Signal0<bool> PresetFileExists;
- virtual bool has_editor() const = 0;
+ /** Emitted when a preset has been loaded */
+ PBD::Signal0<void> PresetLoaded;
+
+ virtual bool has_editor () const = 0;
- PBD::Signal2<void,uint32_t,float> ParameterChanged;
+ /** Emitted when any parameter changes */
+ PBD::Signal2<void, uint32_t, float> ParameterChanged;
/* NOTE: this block of virtual methods looks like the interface
to a Processor, but Plugin does not inherit from Processor.
friend class PluginInsert;
friend struct PluginInsert::PluginControl;
- virtual void set_parameter (uint32_t which, float val) = 0;
+ virtual void set_parameter (uint32_t which, float val);
/** Do the actual saving of the current plugin settings to a preset of the provided name.
* Should return a URI on success, or an empty string on failure.
std::map<std::string, PresetRecord> _presets;
private:
-
+
+ /** Fill _presets with our presets */
+ virtual void find_presets () = 0;
+
+ /** Add state to an existing XMLNode */
+ virtual void add_state (XMLNode *) const = 0;
+
+ bool _have_presets;
MidiStateTracker _tracker;
BufferSet _pending_stop_events;
bool _have_pending_stop_events;
+ PresetRecord _last_preset;
+ bool _parameter_changed_since_last_preset;
};
PluginPtr find_plugin(ARDOUR::Session&, std::string unique_id, ARDOUR::PluginType);
bool parameter_is_input(uint32_t i) const { return true; }
bool parameter_is_output(uint32_t i) const { return false; }
- bool load_preset (const std::string& preset_label);
- virtual std::vector<PresetRecord> get_presets ();
+ bool load_preset (PresetRecord);
int first_user_preset_index () const;
bool has_editor () const;
- XMLNode& get_state();
int set_state (XMLNode const &, int);
AEffect * plugin () const { return _plugin; }
void do_remove_preset (std::string name);
std::string do_save_preset (std::string name);
- gchar* get_chunk (bool);
+ gchar* get_chunk (bool) const;
int set_chunk (gchar const *, bool);
XMLTree * presets_tree () const;
std::string presets_file () const;
+ void find_presets ();
+ bool load_user_preset (PresetRecord);
+ bool load_plugin_preset (PresetRecord);
+ void add_state (XMLNode *) const;
FSTHandle* handle;
FST* _fst;
fd = open (path.c_str(), O_WRONLY|O_CREAT|O_EXCL, 0664);
while (fd < 0) {
if (errno == EEXIST) {
- /* tell any UI's that this file already exists and ask them what to do */
- bool overwrite = Plugin::PresetFileExists(); // EMIT SIGNAL
- if (overwrite) {
- fd = open (path.c_str(), O_WRONLY, 0664);
- continue;
- } else {
- return 0;
- }
+ error << string_compose (_("Preset file %1 exists; not overwriting"), path);
+ } else {
+ error << string_compose (_("Cannot open preset file %1 (%2)"), path, strerror (errno)) << endmsg;
}
- error << string_compose (_("Cannot open preset file %1 (%2)"), path, strerror (errno)) << endmsg;
CFRelease (xmlData);
return -1;
}
void
AUPlugin::set_parameter (uint32_t which, float val)
{
- if (which < descriptors.size()) {
- const AUParameterDescriptor& d (descriptors[which]);
- TRACE_API ("set parameter %d in scope %d element %d to %f\n", d.id, d.scope, d.element, val);
- unit->SetParameter (d.id, d.scope, d.element, val);
-
- /* tell the world what we did */
-
- AudioUnitEvent theEvent;
-
- theEvent.mEventType = kAudioUnitEvent_ParameterValueChange;
- theEvent.mArgument.mParameter.mAudioUnit = unit->AU();
- theEvent.mArgument.mParameter.mParameterID = d.id;
- theEvent.mArgument.mParameter.mScope = d.scope;
- theEvent.mArgument.mParameter.mElement = d.element;
-
- TRACE_API ("notify about parameter change\n");
- AUEventListenerNotify (NULL, NULL, &theEvent);
+ if (which >= descriptors.size()) {
+ return;
}
+
+ const AUParameterDescriptor& d (descriptors[which]);
+ TRACE_API ("set parameter %d in scope %d element %d to %f\n", d.id, d.scope, d.element, val);
+ unit->SetParameter (d.id, d.scope, d.element, val);
+
+ /* tell the world what we did */
+
+ AudioUnitEvent theEvent;
+
+ theEvent.mEventType = kAudioUnitEvent_ParameterValueChange;
+ theEvent.mArgument.mParameter.mAudioUnit = unit->AU();
+ theEvent.mArgument.mParameter.mParameterID = d.id;
+ theEvent.mArgument.mParameter.mScope = d.scope;
+ theEvent.mArgument.mParameter.mElement = d.element;
+
+ TRACE_API ("notify about parameter change\n");
+ AUEventListenerNotify (NULL, NULL, &theEvent);
+
+ Plugin::set_parameter (which, val);
}
float
return false;
}
-XMLNode&
-AUPlugin::get_state()
+void
+AUPlugin::add_state (XMLNode* root)
{
LocaleGuard lg (X_("POSIX"));
- XMLNode *root = new XMLNode (state_node_name());
#ifdef AU_STATE_SUPPORT
CFDataRef xmlData;
TRACE_API ("get preset state\n");
if (unit->GetAUPreset (propertyList) != noErr) {
- return *root;
+ return;
}
// Convert the property list into XML data.
seen_get_state_message = true;
}
#endif
-
- return *root;
}
int
-AUPlugin::set_state(const XMLNode& node, int /* version*/)
+AUPlugin::set_state(const XMLNode& node, int version)
{
#ifdef AU_STATE_SUPPORT
int ret = -1;
CFRelease (propertyList);
}
+ Plugin::set_state (node, version);
return ret;
#else
if (!seen_set_state_message) {
PROGRAM_NAME)
<< endmsg;
}
- return 0;
+ return Plugin::set_state (node, version);
#endif
}
bool
-AUPlugin::load_preset (const string& preset_label)
+AUPlugin::load_preset (PluginRecord r)
{
+ Plugin::load_preset (r);
+
#ifdef AU_STATE_SUPPORT
bool ret = false;
CFPropertyListRef propertyList;
return preset_name;
}
-vector<Plugin::PresetRecord>
-AUPlugin::get_presets ()
+void
+AUPlugin::find_presets ()
{
- vector<Plugin::PresetRecord> presets;
-
#ifdef AU_STATE_SUPPORT
vector<string*>* preset_files;
PathScanner scanner;
preset_files = scanner (preset_search_path, au_preset_filter, this, true, true, -1, true);
if (!preset_files) {
- return presets;
+ return;
}
for (vector<string*>::iterator x = preset_files->begin(); x != preset_files->end(); ++x) {
/* now fill the vector<string> with the names we have */
for (UserPresetMap::iterator i = user_preset_map.begin(); i != user_preset_map.end(); ++i) {
- presets.push_back (Plugin::PresetRecord (i->second, i->first));
+ _presets.insert (i->second, Plugin::PresetRecord (i->second, i->first));
}
/* add factory presets */
for (FactoryPresetMap::iterator i = factory_preset_map.begin(); i != factory_preset_map.end(); ++i) {
- presets.push_back (Plugin::PresetRecord ("", i->first));
+ /* XXX: dubious */
+ string const uri = string_compose ("%1", _presets.size ());
+ _presets.push_back (uri, Plugin::PresetRecord (uri, i->first));
}
#endif
-
- return presets;
}
bool
{
if (which < _descriptor->PortCount) {
_shadow_data[which] = (LADSPA_Data) val;
-#if 0
- ParameterChanged (Parameter(PluginAutomation, 0, which), val); /* EMIT SIGNAL */
+#if 0
if (which < parameter_count() && controls[which]) {
controls[which]->Changed ();
}
"invalid"), name())
<< endmsg;
}
+
+ Plugin::set_parameter (which, val);
}
float
return 0;
}
-XMLNode&
-LadspaPlugin::get_state()
+void
+LadspaPlugin::add_state (XMLNode* root) const
{
- XMLNode *root = new XMLNode(state_node_name());
XMLNode *child;
char buf[16];
LocaleGuard lg (X_("POSIX"));
root->add_child_nocopy (*child);
}
}
-
- return *root;
}
int
if (version < 3000) {
return set_state_2X (node, version);
}
-
+
XMLNodeList nodes;
XMLProperty *prop;
XMLNodeConstIterator iter;
nodes = node.children ("Port");
- for(iter = nodes.begin(); iter != nodes.end(); ++iter){
+ for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
child = *iter;
latency_compute_run ();
- return 0;
+ return Plugin::set_state (node, version);
}
int
}
-vector<Plugin::PresetRecord>
-LadspaPlugin::get_presets ()
+void
+LadspaPlugin::find_presets ()
{
- vector<PresetRecord> result;
uint32_t id;
std::string unique (unique_id());
if (!isdigit (unique[0])) {
- return result;
+ return;
}
id = atol (unique.c_str());
if (set_uris) {
for (uint32_t i = 0; i < (uint32_t) set_uris->count; ++i) {
if (char* label = lrdf_get_label(set_uris->items[i])) {
- PresetRecord rec(set_uris->items[i], label);
- result.push_back(rec);
+ PresetRecord rec (set_uris->items[i], label);
_presets.insert (make_pair (set_uris->items[i], rec));
}
}
lrdf_free_uris(set_uris);
}
-
- return result;
}
bool
-LadspaPlugin::load_preset (const string& preset_uri)
+LadspaPlugin::load_preset (PresetRecord r)
{
- lrdf_defaults* defs = lrdf_get_setting_values(preset_uri.c_str());
+ lrdf_defaults* defs = lrdf_get_setting_values (r.uri.c_str());
if (defs) {
for (uint32_t i = 0; i < (uint32_t) defs->count; ++i) {
lrdf_free_setting_values(defs);
}
+ Plugin::load_preset (r);
return true;
}
}
const char*
-LV2Plugin::port_symbol (uint32_t index)
+LV2Plugin::port_symbol (uint32_t index) const
{
SLV2Port port = slv2_plugin_get_port_by_index(_plugin, index);
if (!port) {
{
if (which < slv2_plugin_get_num_ports(_plugin)) {
_shadow_data[which] = val;
- ParameterChanged (which, val); /* EMIT SIGNAL */
#if 0
if (which < parameter_count() && controls[which]) {
"This is a bug in either %2 or the LV2 plugin (%3)"),
name(), PROGRAM_NAME, unique_id()) << endmsg;
}
+
+ Plugin::set_parameter (which, val);
}
float
return NULL;
}
-XMLNode&
-LV2Plugin::get_state()
+void
+LV2Plugin::add_state (XMLNode* root) const
{
- XMLNode *root = new XMLNode(state_node_name());
XMLNode *child;
char buf[16];
LocaleGuard lg (X_("POSIX"));
warning << string_compose(
_("Plugin \"%1\% failed to return LV2 persist data"),
unique_id());
- return *root; // FIXME: Possibly inconsistent state
+ return;
}
LV2PFile file = lv2_pfile_open(state_path.c_str(), true);
root->add_property("state-file", state_filename);
}
-
- return *root;
}
-vector<Plugin::PresetRecord>
-LV2Plugin::get_presets()
+void
+LV2Plugin::find_presets ()
{
- vector<PresetRecord> result;
SLV2Results presets = slv2_plugin_query_sparql(_plugin,
"PREFIX lv2p: <http://lv2plug.in/ns/dev/presets#>\n"
"PREFIX dc: <http://dublincore.org/documents/dcmi-namespace/>\n"
"SELECT ?p ?name WHERE { <> lv2p:hasPreset ?p . ?p dc:title ?name }\n");
+
for (; !slv2_results_finished(presets); slv2_results_next(presets)) {
SLV2Value uri = slv2_results_get_binding_value(presets, 0);
SLV2Value name = slv2_results_get_binding_value(presets, 1);
PresetRecord rec(slv2_value_as_string(uri), slv2_value_as_string(name));
- result.push_back(rec);
_presets.insert(std::make_pair(slv2_value_as_string(uri), rec));
}
+
slv2_results_free(presets);
- return result;
}
bool
-LV2Plugin::load_preset(const string& uri)
+LV2Plugin::load_preset (PresetRecord r)
{
+ Plugin::load_preset (r);
+
const string query = string(
"PREFIX lv2p: <http://lv2plug.in/ns/dev/presets#>\n"
"PREFIX dc: <http://dublincore.org/documents/dcmi-namespace/>\n"
- "SELECT ?sym ?val WHERE { <") + uri + "> lv2:port ?port . "
+ "SELECT ?sym ?val WHERE { <") + r.uri + "> lv2:port ?port . "
" ?port lv2:symbol ?sym ; lv2p:value ?val . }";
SLV2Results values = slv2_plugin_query_sparql(_plugin, query.c_str());
for (; !slv2_results_finished(values); slv2_results_next(values)) {
latency_compute_run ();
- return 0;
+ return Plugin::set_state (node, version);
}
int
using namespace ARDOUR;
using namespace PBD;
-PBD::Signal0<bool> Plugin::PresetFileExists;
-
Plugin::Plugin (AudioEngine& e, Session& s)
: _engine (e)
, _session (s)
, _cycles (0)
+ , _have_presets (false)
, _have_pending_stop_events (false)
+ , _parameter_changed_since_last_preset (false)
{
}
, _session (other._session)
, _info (other._info)
, _cycles (0)
+ , _have_presets (false)
, _have_pending_stop_events (false)
+ , _parameter_changed_since_last_preset (false)
{
}
{
do_remove_preset (name);
_presets.erase (preset_by_label (name)->uri);
+
+ _last_preset.uri = "";
+ _parameter_changed_since_last_preset = false;
PresetRemoved (); /* EMIT SIGNAL */
}
-bool
+/** @return PresetRecord with empty URI on failure */
+Plugin::PresetRecord
Plugin::save_preset (string name)
{
string const uri = do_save_preset (name);
_presets.insert (make_pair (uri, PresetRecord (uri, name)));
PresetAdded (); /* EMIT SIGNAL */
}
-
- return !uri.empty ();
+
+ return PresetRecord (uri, name);
}
PluginPtr
_tracker.resolve_notes (_pending_stop_events.get_midi (0), 0);
_have_pending_stop_events = true;
}
+
+vector<Plugin::PresetRecord>
+Plugin::get_presets ()
+{
+ if (!_have_presets) {
+ find_presets ();
+ _have_presets = true;
+ }
+
+ vector<PresetRecord> p;
+ for (map<string, PresetRecord>::const_iterator i = _presets.begin(); i != _presets.end(); ++i) {
+ p.push_back (i->second);
+ }
+
+ return p;
+}
+
+/** Set parameters using a preset */
+bool
+Plugin::load_preset (PresetRecord r)
+{
+ _last_preset = r;
+ _parameter_changed_since_last_preset = false;
+
+ PresetLoaded (); /* EMIT SIGNAL */
+ return true;
+}
+
+void
+Plugin::set_parameter (uint32_t which, float val)
+{
+ _parameter_changed_since_last_preset = true;
+ ParameterChanged (Evoral::Parameter (PluginAutomation, 0, which), val); /* EMIT SIGNAL */
+}
+
+int
+Plugin::set_state (const XMLNode& node, int version)
+{
+ XMLProperty const * p = node.property (X_("last-preset-uri"));
+ if (p) {
+ _last_preset.uri = p->value ();
+ }
+
+ p = node.property (X_("last-preset-label"));
+ if (p) {
+ _last_preset.label = p->value ();
+ }
+
+ p = node.property (X_("parameter-changed-since-last-preset"));
+ if (p) {
+ _parameter_changed_since_last_preset = string_is_affirmative (p->value ());
+ }
+
+ return 0;
+}
+
+XMLNode &
+Plugin::get_state ()
+{
+ XMLNode* root = new XMLNode (state_node_name ());
+ LocaleGuard lg (X_("POSIX"));
+
+ root->add_property (X_("last-preset-uri"), _last_preset.uri);
+ root->add_property (X_("last-preset-label"), _last_preset.label);
+ root->add_property (X_("parameter-changed-since-last-preset"), _parameter_changed_since_last_preset ? X_("yes") : X_("no"));
+
+ add_state (root);
+ return *root;
+}
case audioMasterAutomate:
SHOW_CALLBACK ("amc: audioMasterAutomate\n");
// index, value, returns 0
- if (effect) {
- effect->setParameter (effect, index, opt);
+ if (plug) {
+ plug->set_parameter (index, opt);
}
return 0;
VSTPlugin::set_parameter (uint32_t which, float val)
{
_plugin->setParameter (_plugin, which, val);
- //ParameterChanged (which, val); /* EMIT SIGNAL */
+
+ if (_fst->want_program == -1 && _fst->want_chunk == 0) {
+ /* Heinous hack: Plugin::set_parameter below updates the `modified' status of the
+ current preset, but if _fst->want_program is not -1 then there is a preset
+ setup pending or in progress, which we don't want any `modified' updates
+ to happen for. So we only do this if _fst->want_program is -1.
+ */
+ Plugin::set_parameter (which, val);
+ }
}
float
* @return 0-terminated base64-encoded data; must be passed to g_free () by caller.
*/
gchar *
-VSTPlugin::get_chunk (bool single)
+VSTPlugin::get_chunk (bool single) const
{
guchar* data;
int32_t data_size = _plugin->dispatcher (_plugin, 23 /* effGetChunk */, single ? 1 : 0, 0, &data, 0);
return r;
}
-XMLNode&
-VSTPlugin::get_state()
+void
+VSTPlugin::add_state (XMLNode* root) const
{
- XMLNode *root = new XMLNode (state_node_name());
LocaleGuard lg (X_("POSIX"));
if (_fst->current_program != -1) {
gchar* data = get_chunk (false);
if (data == 0) {
- return *root;
+ return;
}
/* store information */
root->add_child_nocopy (*parameters);
}
-
- return *root;
}
int
-VSTPlugin::set_state(const XMLNode& node, int)
+VSTPlugin::set_state (const XMLNode& node, int version)
{
LocaleGuard lg (X_("POSIX"));
}
+ Plugin::set_state (node, version);
return ret;
}
}
bool
-VSTPlugin::load_preset (const string& name)
+VSTPlugin::load_preset (PresetRecord r)
+{
+ bool s;
+
+ if (r.user) {
+ s = load_user_preset (r);
+ } else {
+ s = load_plugin_preset (r);
+ }
+
+ if (s) {
+ Plugin::load_preset (r);
+ }
+
+ return s;
+}
+
+bool
+VSTPlugin::load_plugin_preset (PresetRecord r)
{
+ /* This is a plugin-provided preset.
+ We can't dispatch directly here; too many plugins expects only one GUI thread.
+ */
+
+ /* Extract the index of this preset from the URI */
+ int id;
+ int index;
+ int const p = sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index);
+ assert (p == 2);
+
+ _fst->want_program = index;
+ return true;
+}
+
+bool
+VSTPlugin::load_user_preset (PresetRecord r)
+{
+ /* This is a user preset; we load it, and this code also knows about the
+ non-direct-dispatch thing.
+ */
+
boost::shared_ptr<XMLTree> t (presets_tree ());
if (t == 0) {
return false;
}
XMLNode* root = t->root ();
-
+
for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
XMLProperty* uri = (*i)->property (X_("uri"));
assert (uri);
assert (label);
-
- if (label->value() != name) {
+
+ if (label->value() != r.label) {
continue;
}
-
+
if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
/* Load a user preset chunk from our XML file and send it via a circuitous route to the plugin */
}
return false;
-
+
} else {
for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
if ((*j)->name() == X_("Parameter")) {
-
- XMLProperty* index = (*j)->property (X_("index"));
- XMLProperty* value = (*j)->property (X_("value"));
-
- assert (index);
- assert (value);
-
- set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
+
+ XMLProperty* index = (*j)->property (X_("index"));
+ XMLProperty* value = (*j)->property (X_("value"));
+
+ assert (index);
+ assert (value);
+
+ set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
}
}
-
+
return true;
}
}
-
+
return false;
}
}
/* we already know it can support processReplacing */
-
_plugin->processReplacing (_plugin, ins, outs, nframes);
return 0;
}
}
-vector<Plugin::PresetRecord>
-VSTPlugin::get_presets ()
+void
+VSTPlugin::find_presets ()
{
- vector<PresetRecord> p;
-
/* Built-in presets */
int const vst_version = _plugin->dispatcher (_plugin, effGetVstVersion, 0, 0, NULL, 0);
for (int i = 0; i < _plugin->numPrograms; ++i) {
- PresetRecord r (string_compose (X_("VST:%1:%2"), unique_id (), i), "");
+ PresetRecord r (string_compose (X_("VST:%1:%2"), unique_id (), i), "", false);
if (vst_version >= 2) {
char buf[256];
r.label = string_compose (_("Preset %1"), i);
}
- p.push_back (r);
_presets.insert (make_pair (r.uri, r));
}
assert (uri);
assert (label);
- PresetRecord r (uri->value(), label->value());
- p.push_back (r);
+ PresetRecord r (uri->value(), label->value(), true);
_presets.insert (make_pair (r.uri, r));
}
}
- return p;
}
/** @return XMLTree with our user presets; could be a new one if no existing
projects / ardour.git / commitdiff