Rename C++ signals to cleaner Gtkmm convention.

git-svn-id: http://svn.drobilla.net/lad/ingen@734 a436a847-0d15-0410-975c-d299462d15a1

11 files changed, 120 insertions, 120 deletions

diff --git a/src/libs/client/NodeModel.cpp b/src/libs/client/NodeModel.cpp
index c5aa3f61..55f1217b 100644
--- a/src/libs/client/NodeModel.cpp
+++ b/src/libs/client/NodeModel.cpp
@@ -51,7 +51,7 @@ void
 NodeModel::remove_port(SharedPtr<PortModel> port)
 {
 	_ports.remove(port);
-	removed_port_sig.emit(port);
+	signal_removed_port.emit(port);
 }
 
 
@@ -117,7 +117,7 @@ NodeModel::add_port(SharedPtr<PortModel> pm)
 	assert(existing == _ports.end());
 
 	_ports.push_back(pm);
-	new_port_sig.emit(pm);
+	signal_new_port.emit(pm);
 }
 
 
diff --git a/src/libs/client/NodeModel.hpp b/src/libs/client/NodeModel.hpp
index fe7faa0a..3c110099 100644
--- a/src/libs/client/NodeModel.hpp
+++ b/src/libs/client/NodeModel.hpp
@@ -61,8 +61,8 @@ public:
 	void port_value_range(SharedPtr<PortModel> port, float& min, float& max);
 	
 	// Signals
-	sigc::signal<void, SharedPtr<PortModel> > new_port_sig; 
-	sigc::signal<void, SharedPtr<PortModel> > removed_port_sig; 
+	sigc::signal<void, SharedPtr<PortModel> > signal_new_port; 
+	sigc::signal<void, SharedPtr<PortModel> > signal_removed_port; 
 	
 protected:
 	friend class Store;
diff --git a/src/libs/client/ObjectModel.cpp b/src/libs/client/ObjectModel.cpp
index fe7b6aaf..673a5c60 100644
--- a/src/libs/client/ObjectModel.cpp
+++ b/src/libs/client/ObjectModel.cpp
@@ -58,7 +58,7 @@ ObjectModel::add_child(SharedPtr<ObjectModel> o)
 #endif
 
 	_children.insert(make_pair(o->path().name(), o));
-	new_child_sig.emit(o);
+	signal_new_child.emit(o);
 }
 
 bool
@@ -71,7 +71,7 @@ ObjectModel::remove_child(SharedPtr<ObjectModel> o)
 	if (i != _children.end()) {
 		assert(i->second == o);
 		_children.erase(i);
-		removed_child_sig.emit(o);
+		signal_removed_child.emit(o);
 		return true;
 	} else {
 		cerr << "[ObjectModel::remove_child] " << _path
@@ -102,7 +102,7 @@ ObjectModel::add_metadata(const MetadataMap& data)
 {
 	for (MetadataMap::const_iterator i = data.begin(); i != data.end(); ++i) {
 		_metadata[i->first] = i->second;
-		metadata_update_sig.emit(i->first, i->second);
+		signal_metadata.emit(i->first, i->second);
 	}
 }
 
@@ -111,7 +111,7 @@ void
 ObjectModel::set_polyphonic(bool polyphonic)
 {
 	_polyphonic = polyphonic;
-	polyphonic_sig.emit(polyphonic);
+	signal_polyphonic.emit(polyphonic);
 }
 
 
@@ -136,7 +136,7 @@ ObjectModel::set(SharedPtr<ObjectModel> model)
 		}
 
 		_metadata[other->first] = other->second;
-		metadata_update_sig.emit(other->first, other->second);
+		signal_metadata.emit(other->first, other->second);
 	}
 }
 
diff --git a/src/libs/client/ObjectModel.hpp b/src/libs/client/ObjectModel.hpp
index 6d2675fb..a9aff7d8 100644
--- a/src/libs/client/ObjectModel.hpp
+++ b/src/libs/client/ObjectModel.hpp
@@ -58,7 +58,7 @@ public:
 
 	const Atom& get_metadata(const string& key) const;
 	void set_metadata(const string& key, const Atom& value)
-		{ _metadata.insert(make_pair(key, value)); metadata_update_sig.emit(key, value); }
+		{ _metadata.insert(make_pair(key, value)); signal_metadata.emit(key, value); }
 
 	typedef Raul::Table<string, SharedPtr<ObjectModel> > Children;
 
@@ -71,19 +71,19 @@ public:
 	SharedPtr<ObjectModel> get_child(const string& name) const;
 
 	// Signals
-	sigc::signal<void, const string&, const Atom&> metadata_update_sig; 
-	sigc::signal<void, SharedPtr<ObjectModel> >    new_child_sig; 
-	sigc::signal<void, SharedPtr<ObjectModel> >    removed_child_sig; 
-	sigc::signal<void, bool>                       polyphonic_sig; 
-	sigc::signal<void>                             destroyed_sig; 
-	sigc::signal<void>                             renamed_sig; 
+	sigc::signal<void, SharedPtr<ObjectModel> >    signal_new_child; 
+	sigc::signal<void, SharedPtr<ObjectModel> >    signal_removed_child; 
+	sigc::signal<void, const string&, const Atom&> signal_metadata; 
+	sigc::signal<void, bool>                       signal_polyphonic; 
+	sigc::signal<void>                             signal_destroyed; 
+	sigc::signal<void>                             signal_renamed; 
 
 protected:
 	friend class Store;
 	
 	ObjectModel(const Path& path, bool polyphonic);
 	
-	virtual void set_path(const Path& p) { _path = p; renamed_sig.emit(); }
+	virtual void set_path(const Path& p) { _path = p; signal_renamed.emit(); }
 	virtual void set_parent(SharedPtr<ObjectModel> p) { assert(p); _parent = p; }
 	virtual void add_child(SharedPtr<ObjectModel> c);
 	virtual bool remove_child(SharedPtr<ObjectModel> c);
diff --git a/src/libs/client/PatchModel.cpp b/src/libs/client/PatchModel.cpp
index 3702a41a..b50e4fd0 100644
--- a/src/libs/client/PatchModel.cpp
+++ b/src/libs/client/PatchModel.cpp
@@ -42,7 +42,7 @@ PatchModel::add_child(SharedPtr<ObjectModel> c)
 	
 	SharedPtr<NodeModel> nm = PtrCast<NodeModel>(c);
 	if (nm)
-		new_node_sig.emit(nm);
+		signal_new_node.emit(nm);
 }
 
 SharedPtr<NodeModel>
@@ -75,7 +75,7 @@ PatchModel::remove_child(SharedPtr<ObjectModel> o)
 				|| cm->src_port_path() == o->path()
 				|| cm->dst_port_path().parent() == o->path()
 				|| cm->dst_port_path() == o->path()) {
-			removed_connection_sig.emit(cm);
+			signal_removed_connection.emit(cm);
 			_connections.erase(j); // cuts our reference
 			assert(!get_connection(cm->src_port_path(), cm->dst_port_path())); // no duplicates
 		}
@@ -85,7 +85,7 @@ PatchModel::remove_child(SharedPtr<ObjectModel> o)
 	if (ObjectModel::remove_child(o)) {
 		SharedPtr<NodeModel> nm = PtrCast<NodeModel>(o);
 		if (nm) {
-			removed_node_sig.emit(nm);
+			signal_removed_node.emit(nm);
 		}
 		return true;
 	} else {
@@ -154,7 +154,7 @@ PatchModel::add_connection(SharedPtr<ConnectionModel> cm)
 		assert(cm->dst_port() == existing->dst_port());
 	} else {
 		_connections.push_back(cm);
-		new_connection_sig.emit(cm);
+		signal_new_connection.emit(cm);
 	}
 }
 
@@ -165,7 +165,7 @@ PatchModel::remove_connection(const string& src_port_path, const string& dst_por
 	for (list<SharedPtr<ConnectionModel> >::iterator i = _connections.begin(); i != _connections.end(); ++i) {
 		SharedPtr<ConnectionModel> cm = (*i);
 		if (cm->src_port_path() == src_port_path && cm->dst_port_path() == dst_port_path) {
-			removed_connection_sig.emit(cm);
+			signal_removed_connection.emit(cm);
 			_connections.erase(i); // cuts our reference
 			assert(!get_connection(src_port_path, dst_port_path)); // no duplicates
 			return;
@@ -182,7 +182,7 @@ PatchModel::enable()
 {
 	if (!_enabled) {
 		_enabled = true;
-		enabled_sig.emit();
+		signal_enabled.emit();
 	}
 }
 
@@ -192,7 +192,7 @@ PatchModel::disable()
 {
 	if (_enabled) {
 		_enabled = false;
-		disabled_sig.emit();
+		signal_disabled.emit();
 	}
 }
 
diff --git a/src/libs/client/PatchModel.hpp b/src/libs/client/PatchModel.hpp
index 16e145e9..77b597d5 100644
--- a/src/libs/client/PatchModel.hpp
+++ b/src/libs/client/PatchModel.hpp
@@ -59,17 +59,17 @@ public:
 	bool get_editable() const { return _editable; }
 	void set_editable(bool e) { if (_editable != e) {
 		_editable = e;
-		editable_sig.emit(e);
+		signal_editable.emit(e);
 	} }
 	
 	// Signals
-	sigc::signal<void, SharedPtr<NodeModel> >       new_node_sig; 
-	sigc::signal<void, SharedPtr<NodeModel> >       removed_node_sig; 
-	sigc::signal<void, SharedPtr<ConnectionModel> > new_connection_sig; 
-	sigc::signal<void, SharedPtr<ConnectionModel> > removed_connection_sig;
-	sigc::signal<void>                              enabled_sig;
-	sigc::signal<void>                              disabled_sig;
-	sigc::signal<void, bool>                        editable_sig;
+	sigc::signal<void, SharedPtr<NodeModel> >       signal_new_node; 
+	sigc::signal<void, SharedPtr<NodeModel> >       signal_removed_node; 
+	sigc::signal<void, SharedPtr<ConnectionModel> > signal_new_connection; 
+	sigc::signal<void, SharedPtr<ConnectionModel> > signal_removed_connection;
+	sigc::signal<void>                              signal_enabled;
+	sigc::signal<void>                              signal_disabled;
+	sigc::signal<void, bool>                        signal_editable;
 
 private:
 	friend class Store;
diff --git a/src/libs/client/PortModel.hpp b/src/libs/client/PortModel.hpp
index b8d1f094..a75c5bcf 100644
--- a/src/libs/client/PortModel.hpp
+++ b/src/libs/client/PortModel.hpp
@@ -61,14 +61,14 @@ public:
 	{
 		if (val != _current_val) {
 			_current_val = val;
-			control_change_sig.emit(val);
+			signal_control.emit(val);
 		}
 	}
 
 	// Signals
-	sigc::signal<void, float>                 control_change_sig; ///< "Control" ports only
-	sigc::signal<void, SharedPtr<PortModel> > connection_sig;
-	sigc::signal<void, SharedPtr<PortModel> > disconnection_sig;
+	sigc::signal<void, float>                 signal_control; ///< "Control" ports only
+	sigc::signal<void, SharedPtr<PortModel> > signal_connection;
+	sigc::signal<void, SharedPtr<PortModel> > signal_disconnection;
 
 private:
 	friend class Store;
@@ -87,8 +87,8 @@ private:
 	void add_child(SharedPtr<ObjectModel> c)    { throw; }
 	bool remove_child(SharedPtr<ObjectModel> c) { throw; }
 	
-	void connected_to(SharedPtr<PortModel> p)      { ++_connections; connection_sig.emit(p); }
-	void disconnected_from(SharedPtr<PortModel> p) { --_connections; disconnection_sig.emit(p); }
+	void connected_to(SharedPtr<PortModel> p)      { ++_connections; signal_connection.emit(p); }
+	void disconnected_from(SharedPtr<PortModel> p) { --_connections; signal_disconnection.emit(p); }
 	
 	string    _type;
 	Direction _direction;
diff --git a/src/libs/client/SigClientInterface.hpp b/src/libs/client/SigClientInterface.hpp
index 7e020ca2..bdfdd783 100644
--- a/src/libs/client/SigClientInterface.hpp
+++ b/src/libs/client/SigClientInterface.hpp
@@ -43,29 +43,29 @@ public:
 
 	// Signal parameters match up directly with ClientInterface calls
 	
-	sigc::signal<void, int32_t>                            response_ok_sig;
-	sigc::signal<void, int32_t, string>                    response_error_sig;
-	sigc::signal<void>                                     bundle_begin_sig; 
-	sigc::signal<void>                                     bundle_end_sig; 
-	sigc::signal<void, string>                             error_sig; 
-	sigc::signal<void, uint32_t>                           num_plugins_sig; 
-	sigc::signal<void, string, string, string>             new_plugin_sig; 
-	sigc::signal<void, string, uint32_t>                   new_patch_sig; 
-	sigc::signal<void, string, string, bool, uint32_t>     new_node_sig; 
-	sigc::signal<void, string, string, bool>               new_port_sig; 
-	sigc::signal<void, string, bool>                       polyphonic_sig; 
-	sigc::signal<void, string>                             patch_enabled_sig; 
-	sigc::signal<void, string>                             patch_disabled_sig; 
-	sigc::signal<void, string, uint32_t>                   patch_polyphony_sig; 
-	sigc::signal<void, string>                             patch_cleared_sig; 
-	sigc::signal<void, string, string>                     object_renamed_sig; 
-	sigc::signal<void, string>                             object_destroyed_sig; 
-	sigc::signal<void, string, string>                     connection_sig; 
-	sigc::signal<void, string, string>                     disconnection_sig; 
-	sigc::signal<void, string, string, Raul::Atom>         metadata_update_sig; 
-	sigc::signal<void, string, float>                      control_change_sig; 
-	sigc::signal<void, string, uint32_t, uint32_t, string> program_add_sig; 
-	sigc::signal<void, string, uint32_t, uint32_t>         program_remove_sig; 
+	sigc::signal<void, int32_t>                            signal_response_ok;
+	sigc::signal<void, int32_t, string>                    signal_response_error;
+	sigc::signal<void>                                     signal_bundle_begin; 
+	sigc::signal<void>                                     signal_bundle_end; 
+	sigc::signal<void, string>                             signal_error; 
+	sigc::signal<void, uint32_t>                           signal_num_plugins; 
+	sigc::signal<void, string, string, string>             signal_new_plugin; 
+	sigc::signal<void, string, uint32_t>                   signal_new_patch; 
+	sigc::signal<void, string, string, bool, uint32_t>     signal_new_node; 
+	sigc::signal<void, string, string, bool>               signal_new_port; 
+	sigc::signal<void, string, bool>                       signal_polyphonic; 
+	sigc::signal<void, string>                             signal_patch_enabled; 
+	sigc::signal<void, string>                             signal_patch_disabled; 
+	sigc::signal<void, string, uint32_t>                   signal_patch_polyphony; 
+	sigc::signal<void, string>                             signal_patch_cleared; 
+	sigc::signal<void, string, string>                     signal_object_renamed; 
+	sigc::signal<void, string>                             signal_object_destroyed; 
+	sigc::signal<void, string, string>                     signal_connection; 
+	sigc::signal<void, string, string>                     signal_disconnection; 
+	sigc::signal<void, string, string, Raul::Atom>         signal_metadata_update; 
+	sigc::signal<void, string, float>                      signal_control_change; 
+	sigc::signal<void, string, uint32_t, uint32_t, string> signal_program_add; 
+	sigc::signal<void, string, uint32_t, uint32_t>         signal_program_remove; 
 
 protected:
 
@@ -81,64 +81,64 @@ protected:
 	void transfer_begin() {}
 	void transfer_end()   {}
 
-	void num_plugins(uint32_t num) { num_plugins_sig.emit(num); }
+	void num_plugins(uint32_t num) { signal_num_plugins.emit(num); }
 
 	void response_ok(int32_t id)
-		{ response_ok_sig.emit(id); }
+		{ signal_response_ok.emit(id); }
 
 	void response_error(int32_t id, const string& msg)
-		{ response_error_sig.emit(id, msg); }
+		{ signal_response_error.emit(id, msg); }
 	
 	void error(const string& msg)
-		{ error_sig.emit(msg); }
+		{ signal_error.emit(msg); }
 	
 	void new_plugin(const string& uri, const string& type_uri, const string& name)
-		{ new_plugin_sig.emit(uri, type_uri, name); }
+		{ signal_new_plugin.emit(uri, type_uri, name); }
 	
 	void new_patch(const string& path, uint32_t poly)
-		{ new_patch_sig.emit(path, poly); }
+		{ signal_new_patch.emit(path, poly); }
 	
 	void new_node(const string& plugin_uri, const string& node_path, bool is_polyphonic, uint32_t num_ports)
-		{ new_node_sig.emit(plugin_uri, node_path, is_polyphonic, num_ports); }
+		{ signal_new_node.emit(plugin_uri, node_path, is_polyphonic, num_ports); }
 	
 	void new_port(const string& path, const string& data_type, bool is_output)
-		{ new_port_sig.emit(path, data_type, is_output); }
+		{ signal_new_port.emit(path, data_type, is_output); }
 
 	void connection(const string& src_port_path, const string& dst_port_path)
-		{ connection_sig.emit(src_port_path, dst_port_path); }
+		{ signal_connection.emit(src_port_path, dst_port_path); }
 
 	void object_destroyed(const string& path)
-		{ object_destroyed_sig.emit(path); }
+		{ signal_object_destroyed.emit(path); }
 	
 	void patch_enabled(const string& path)
-		{ patch_enabled_sig.emit(path); }
+		{ signal_patch_enabled.emit(path); }
 	
 	void patch_disabled(const string& path)
-		{ patch_disabled_sig.emit(path); }
+		{ signal_patch_disabled.emit(path); }
 	
 	void patch_polyphony(const string& path, uint32_t poly)
-		{ patch_polyphony_sig.emit(path, poly); }
+		{ signal_patch_polyphony.emit(path, poly); }
 
 	void patch_cleared(const string& path)
-		{ patch_cleared_sig.emit(path); }
+		{ signal_patch_cleared.emit(path); }
 
 	void object_renamed(const string& old_path, const string& new_path)
-		{ object_renamed_sig.emit(old_path, new_path); }
+		{ signal_object_renamed.emit(old_path, new_path); }
 	
 	void disconnection(const string& src_port_path, const string& dst_port_path)
-		{ disconnection_sig.emit(src_port_path, dst_port_path); }
+		{ signal_disconnection.emit(src_port_path, dst_port_path); }
 	
 	void metadata_update(const string& path, const string& key, const Raul::Atom& value)
-		{ metadata_update_sig.emit(path, key, value); }
+		{ signal_metadata_update.emit(path, key, value); }
 
 	void control_change(const string& port_path, float value)
-		{ control_change_sig.emit(port_path, value); }
+		{ signal_control_change.emit(port_path, value); }
 
 	void program_add(const string& path, uint32_t bank, uint32_t program, const string& name)
-		{ program_add_sig.emit(path, bank, program, name); }
+		{ signal_program_add.emit(path, bank, program, name); }
 	
 	void program_remove(const string& path, uint32_t bank, uint32_t program)
-		{ program_remove_sig.emit(path, bank, program); }
+		{ signal_program_remove.emit(path, bank, program); }
 
 protected:
 	SigClientInterface() {}
diff --git a/src/libs/client/Store.cpp b/src/libs/client/Store.cpp
index 1ca94cce..e3d93d60 100644
--- a/src/libs/client/Store.cpp
+++ b/src/libs/client/Store.cpp
@@ -36,21 +36,21 @@ Store::Store(SharedPtr<EngineInterface> engine, SharedPtr<SigClientInterface> em
 : _engine(engine)
 , _emitter(emitter)
 {
-	emitter->object_destroyed_sig.connect(sigc::mem_fun(this, &Store::destruction_event));
-	emitter->object_renamed_sig.connect(sigc::mem_fun(this, &Store::rename_event));
-	emitter->new_plugin_sig.connect(sigc::mem_fun(this, &Store::new_plugin_event));
-	emitter->new_patch_sig.connect(sigc::mem_fun(this, &Store::new_patch_event));
-	emitter->new_node_sig.connect(sigc::mem_fun(this, &Store::new_node_event));
-	emitter->new_port_sig.connect(sigc::mem_fun(this, &Store::new_port_event));
-	emitter->polyphonic_sig.connect(sigc::mem_fun(this, &Store::polyphonic_event));
-	emitter->patch_enabled_sig.connect(sigc::mem_fun(this, &Store::patch_enabled_event));
-	emitter->patch_disabled_sig.connect(sigc::mem_fun(this, &Store::patch_disabled_event));
-	emitter->patch_polyphony_sig.connect(sigc::mem_fun(this, &Store::patch_polyphony_event));
-	emitter->patch_cleared_sig.connect(sigc::mem_fun(this, &Store::patch_cleared_event));
-	emitter->connection_sig.connect(sigc::mem_fun(this, &Store::connection_event));
-	emitter->disconnection_sig.connect(sigc::mem_fun(this, &Store::disconnection_event));
-	emitter->metadata_update_sig.connect(sigc::mem_fun(this, &Store::metadata_update_event));
-	emitter->control_change_sig.connect(sigc::mem_fun(this, &Store::control_change_event));
+	emitter->signal_object_destroyed.connect(sigc::mem_fun(this, &Store::destruction_event));
+	emitter->signal_object_renamed.connect(sigc::mem_fun(this, &Store::rename_event));
+	emitter->signal_new_plugin.connect(sigc::mem_fun(this, &Store::new_plugin_event));
+	emitter->signal_new_patch.connect(sigc::mem_fun(this, &Store::new_patch_event));
+	emitter->signal_new_node.connect(sigc::mem_fun(this, &Store::new_node_event));
+	emitter->signal_new_port.connect(sigc::mem_fun(this, &Store::new_port_event));
+	emitter->signal_polyphonic.connect(sigc::mem_fun(this, &Store::polyphonic_event));
+	emitter->signal_patch_enabled.connect(sigc::mem_fun(this, &Store::patch_enabled_event));
+	emitter->signal_patch_disabled.connect(sigc::mem_fun(this, &Store::patch_disabled_event));
+	emitter->signal_patch_polyphony.connect(sigc::mem_fun(this, &Store::patch_polyphony_event));
+	emitter->signal_patch_cleared.connect(sigc::mem_fun(this, &Store::patch_cleared_event));
+	emitter->signal_connection.connect(sigc::mem_fun(this, &Store::connection_event));
+	emitter->signal_disconnection.connect(sigc::mem_fun(this, &Store::disconnection_event));
+	emitter->signal_metadata_update.connect(sigc::mem_fun(this, &Store::metadata_update_event));
+	emitter->signal_control_change.connect(sigc::mem_fun(this, &Store::control_change_event));
 }
 
 
@@ -243,7 +243,7 @@ Store::add_object(SharedPtr<ObjectModel> object)
 				assert(parent && (object->parent() == parent));
 				
 				_objects[object->path()] = object;
-				new_object_sig.emit(object);
+				signal_new_object.emit(object);
 				
 				resolve_metadata_orphans(parent);
 				resolve_orphans(parent);
@@ -257,7 +257,7 @@ Store::add_object(SharedPtr<ObjectModel> object)
 			}
 		} else {
 			_objects[object->path()] = object;
-			new_object_sig.emit(object);
+			signal_new_object.emit(object);
 		}
 
 	}
@@ -278,7 +278,7 @@ Store::remove_object(const Path& path)
 		//cout << "[Store] Removed " << path << endl;
 
 		if (result)
-			result->destroyed_sig.emit();
+			result->signal_destroyed.emit();
 
 		if (result->path() != "/") {
 			assert(result->parent());
diff --git a/src/libs/client/Store.hpp b/src/libs/client/Store.hpp
index 4565dbc2..6b0ec7d3 100644
--- a/src/libs/client/Store.hpp
+++ b/src/libs/client/Store.hpp
@@ -66,7 +66,7 @@ public:
 	typedef Raul::PathTable<SharedPtr<ObjectModel> > Objects;
 	const Objects& objects() const { return _objects; }
 
-	sigc::signal<void, SharedPtr<ObjectModel> > new_object_sig; 
+	sigc::signal<void, SharedPtr<ObjectModel> > signal_new_object; 
 private:
 
 	void add_object(SharedPtr<ObjectModel> object);
diff --git a/src/libs/client/ThreadedSigClientInterface.hpp b/src/libs/client/ThreadedSigClientInterface.hpp
index 105db4f4..22f03118 100644
--- a/src/libs/client/ThreadedSigClientInterface.hpp
+++ b/src/libs/client/ThreadedSigClientInterface.hpp
@@ -47,26 +47,26 @@ public:
 	ThreadedSigClientInterface(uint32_t queue_size)
 	: _enabled(true)
 	, _sigs(queue_size)
-	, response_ok_slot(response_ok_sig.make_slot())
-	, response_error_slot(response_error_sig.make_slot())
-	, error_slot(error_sig.make_slot())
-	, new_plugin_slot(new_plugin_sig.make_slot())
-	, new_patch_slot(new_patch_sig.make_slot())
-	, new_node_slot(new_node_sig.make_slot())
-	, new_port_slot(new_port_sig.make_slot())
-	, polyphonic_slot(polyphonic_sig.make_slot())
-	, connection_slot(connection_sig.make_slot())
-	, patch_enabled_slot(patch_enabled_sig.make_slot())
-	, patch_disabled_slot(patch_disabled_sig.make_slot())
-	, patch_polyphony_slot(patch_polyphony_sig.make_slot())
-	, patch_cleared_slot(patch_cleared_sig.make_slot())
-	, object_destroyed_slot(object_destroyed_sig.make_slot())
-	, object_renamed_slot(object_renamed_sig.make_slot())
-	, disconnection_slot(disconnection_sig.make_slot())
-	, metadata_update_slot(metadata_update_sig.make_slot())
-	, control_change_slot(control_change_sig.make_slot())
-	, program_add_slot(program_add_sig.make_slot())
-	, program_remove_slot(program_remove_sig.make_slot())
+	, response_ok_slot(signal_response_ok.make_slot())
+	, response_error_slot(signal_response_error.make_slot())
+	, error_slot(signal_error.make_slot())
+	, new_plugin_slot(signal_new_plugin.make_slot())
+	, new_patch_slot(signal_new_patch.make_slot())
+	, new_node_slot(signal_new_node.make_slot())
+	, new_port_slot(signal_new_port.make_slot())
+	, polyphonic_slot(signal_polyphonic.make_slot())
+	, connection_slot(signal_connection.make_slot())
+	, patch_enabled_slot(signal_patch_enabled.make_slot())
+	, patch_disabled_slot(signal_patch_disabled.make_slot())
+	, patch_polyphony_slot(signal_patch_polyphony.make_slot())
+	, patch_cleared_slot(signal_patch_cleared.make_slot())
+	, object_destroyed_slot(signal_object_destroyed.make_slot())
+	, object_renamed_slot(signal_object_renamed.make_slot())
+	, disconnection_slot(signal_disconnection.make_slot())
+	, metadata_update_slot(signal_metadata_update.make_slot())
+	, control_change_slot(signal_control_change.make_slot())
+	, program_add_slot(signal_program_add.make_slot())
+	, program_remove_slot(signal_program_remove.make_slot())
 	{}
 
 	void enable()  { _enabled = true; }