summaryrefslogtreecommitdiffstats
path: root/src/client
diff options
context:
space:
mode:
Diffstat (limited to 'src/client')
-rw-r--r--src/client/.clang-tidy3
-rw-r--r--src/client/BlockModel.cpp129
-rw-r--r--src/client/ClientStore.cpp202
-rw-r--r--src/client/GraphModel.cpp66
-rw-r--r--src/client/ObjectModel.cpp31
-rw-r--r--src/client/PluginModel.cpp109
-rw-r--r--src/client/PluginUI.cpp101
-rw-r--r--src/client/PortModel.cpp21
-rw-r--r--src/client/ingen_client.cpp17
-rw-r--r--src/client/meson.build50
-rw-r--r--src/client/wscript24
11 files changed, 414 insertions, 339 deletions
diff --git a/src/client/.clang-tidy b/src/client/.clang-tidy
new file mode 100644
index 00000000..2561514f
--- /dev/null
+++ b/src/client/.clang-tidy
@@ -0,0 +1,3 @@
+Checks: >
+ -google-readability-todo,
+InheritParentConfig: true
diff --git a/src/client/BlockModel.cpp b/src/client/BlockModel.cpp
index f9eaa26e..998c118d 100644
--- a/src/client/BlockModel.cpp
+++ b/src/client/BlockModel.cpp
@@ -16,48 +16,51 @@
#include "ingen/client/BlockModel.hpp"
+#include "ingen/Atom.hpp"
+#include "ingen/Forge.hpp"
#include "ingen/URIs.hpp"
-#include "ingen/World.hpp"
+#include "ingen/client/PluginModel.hpp"
#include "ingen/client/PortModel.hpp"
+#include "lilv/lilv.h"
+#include "lv2/core/lv2.h"
+#include "raul/Path.hpp"
+#include "raul/Symbol.hpp"
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstring>
+#include <memory>
#include <string>
-
-namespace ingen {
-namespace client {
-
-BlockModel::BlockModel(URIs& uris,
- const SPtr<PluginModel>& plugin,
- const Raul::Path& path)
- : ObjectModel(uris, path)
- , _plugin_uri(plugin->uri())
- , _plugin(plugin)
- , _num_values(0)
- , _min_values(nullptr)
- , _max_values(nullptr)
-{
-}
-
-BlockModel::BlockModel(URIs& uris,
- const URI& plugin_uri,
- const Raul::Path& path)
- : ObjectModel(uris, path)
- , _plugin_uri(plugin_uri)
- , _num_values(0)
- , _min_values(nullptr)
- , _max_values(nullptr)
-{
-}
+#include <utility>
+
+namespace ingen::client {
+
+BlockModel::BlockModel(URIs& uris,
+ const std::shared_ptr<PluginModel>& plugin,
+ const raul::Path& path)
+ : ObjectModel(uris, path)
+ , _plugin_uri(plugin->uri())
+ , _plugin(plugin)
+ , _num_values(0)
+ , _min_values(nullptr)
+ , _max_values(nullptr)
+{}
+
+BlockModel::BlockModel(URIs& uris, URI plugin_uri, const raul::Path& path)
+ : ObjectModel(uris, path)
+ , _plugin_uri(std::move(plugin_uri))
+ , _num_values(0)
+ , _min_values(nullptr)
+ , _max_values(nullptr)
+{}
BlockModel::BlockModel(const BlockModel& copy)
: ObjectModel(copy)
, _plugin_uri(copy._plugin_uri)
, _num_values(copy._num_values)
- , _min_values((float*)malloc(sizeof(float) * _num_values))
- , _max_values((float*)malloc(sizeof(float) * _num_values))
+ , _min_values(static_cast<float*>(malloc(sizeof(float) * _num_values)))
+ , _max_values(static_cast<float*>(malloc(sizeof(float) * _num_values)))
{
memcpy(_min_values, copy._min_values, sizeof(float) * _num_values);
memcpy(_max_values, copy._max_values, sizeof(float) * _num_values);
@@ -69,7 +72,7 @@ BlockModel::~BlockModel()
}
void
-BlockModel::remove_port(const SPtr<PortModel>& port)
+BlockModel::remove_port(const std::shared_ptr<PortModel>& port)
{
for (auto i = _ports.begin(); i != _ports.end(); ++i) {
if ((*i) == port) {
@@ -81,7 +84,7 @@ BlockModel::remove_port(const SPtr<PortModel>& port)
}
void
-BlockModel::remove_port(const Raul::Path& port_path)
+BlockModel::remove_port(const raul::Path& port_path)
{
for (auto i = _ports.begin(); i != _ports.end(); ++i) {
if ((*i)->path() == port_path) {
@@ -103,26 +106,26 @@ BlockModel::clear()
}
void
-BlockModel::add_child(const SPtr<ObjectModel>& c)
+BlockModel::add_child(const std::shared_ptr<ObjectModel>& c)
{
assert(c->parent().get() == this);
//ObjectModel::add_child(c);
- SPtr<PortModel> pm = dynamic_ptr_cast<PortModel>(c);
+ auto pm = std::dynamic_pointer_cast<PortModel>(c);
assert(pm);
add_port(pm);
}
bool
-BlockModel::remove_child(const SPtr<ObjectModel>& c)
+BlockModel::remove_child(const std::shared_ptr<ObjectModel>& c)
{
assert(c->path().is_child_of(path()));
assert(c->parent().get() == this);
//bool ret = ObjectModel::remove_child(c);
- SPtr<PortModel> pm = dynamic_ptr_cast<PortModel>(c);
+ auto pm = std::dynamic_pointer_cast<PortModel>(c);
assert(pm);
remove_port(pm);
@@ -131,7 +134,7 @@ BlockModel::remove_child(const SPtr<ObjectModel>& c)
}
void
-BlockModel::add_port(const SPtr<PortModel>& pm)
+BlockModel::add_port(const std::shared_ptr<PortModel>& pm)
{
assert(pm);
assert(pm->path().is_child_of(path()));
@@ -144,18 +147,18 @@ BlockModel::add_port(const SPtr<PortModel>& pm)
_signal_new_port.emit(pm);
}
-SPtr<const PortModel>
-BlockModel::get_port(const Raul::Symbol& symbol) const
+std::shared_ptr<const PortModel>
+BlockModel::get_port(const raul::Symbol& symbol) const
{
for (auto p : _ports) {
if (p->symbol() == symbol) {
return p;
}
}
- return SPtr<PortModel>();
+ return std::shared_ptr<PortModel>();
}
-SPtr<const PortModel>
+std::shared_ptr<const PortModel>
BlockModel::get_port(uint32_t index) const
{
return _ports[index];
@@ -170,10 +173,11 @@ BlockModel::port(uint32_t index) const
}
void
-BlockModel::default_port_value_range(const SPtr<const PortModel>& port,
- float& min,
- float& max,
- uint32_t srate) const
+BlockModel::default_port_value_range(
+ const std::shared_ptr<const PortModel>& port,
+ float& min,
+ float& max,
+ uint32_t srate) const
{
// Default control values
min = 0.0;
@@ -198,16 +202,17 @@ BlockModel::default_port_value_range(const SPtr<const PortModel>& port,
}
if (port->port_property(_uris.lv2_sampleRate)) {
- min *= srate;
- max *= srate;
+ const auto frate = static_cast<float>(srate);
+ min *= frate;
+ max *= frate;
}
}
void
-BlockModel::port_value_range(const SPtr<const PortModel>& port,
- float& min,
- float& max,
- uint32_t srate) const
+BlockModel::port_value_range(const std::shared_ptr<const PortModel>& port,
+ float& min,
+ float& max,
+ uint32_t srate) const
{
assert(port->parent().get() == this);
@@ -224,12 +229,13 @@ BlockModel::port_value_range(const SPtr<const PortModel>& port,
}
if (max <= min) {
- max = min + 1.0;
+ max = min + 1.0f;
}
if (port->port_property(_uris.lv2_sampleRate)) {
- min *= srate;
- max *= srate;
+ const auto frate = static_cast<float>(srate);
+ min *= frate;
+ max *= frate;
}
}
@@ -239,15 +245,17 @@ BlockModel::label() const
const Atom& name_property = get_property(_uris.lv2_name);
if (name_property.type() == _uris.forge.String) {
return name_property.ptr<char>();
- } else if (plugin_model()) {
+ }
+
+ if (plugin_model()) {
return plugin_model()->human_name();
- } else {
- return symbol().c_str();
}
+
+ return symbol().c_str();
}
std::string
-BlockModel::port_label(const SPtr<const PortModel>& port) const
+BlockModel::port_label(const std::shared_ptr<const PortModel>& port) const
{
const Atom& name = port->get_property(URI(LV2_CORE__name));
if (name.is_valid() && name.type() == _uris.forge.String) {
@@ -274,9 +282,9 @@ BlockModel::port_label(const SPtr<const PortModel>& port) const
}
void
-BlockModel::set(const SPtr<ObjectModel>& model)
+BlockModel::set(const std::shared_ptr<ObjectModel>& model)
{
- SPtr<BlockModel> block = dynamic_ptr_cast<BlockModel>(model);
+ auto block = std::dynamic_pointer_cast<BlockModel>(model);
if (block) {
_plugin_uri = block->_plugin_uri;
_plugin = block->_plugin;
@@ -285,5 +293,4 @@ BlockModel::set(const SPtr<ObjectModel>& model)
ObjectModel::set(model);
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/ClientStore.cpp b/src/client/ClientStore.cpp
index a42efd16..7cfd439d 100644
--- a/src/client/ClientStore.cpp
+++ b/src/client/ClientStore.cpp
@@ -16,7 +16,12 @@
#include "ingen/client/ClientStore.hpp"
+#include "ingen/Atom.hpp"
+#include "ingen/Forge.hpp"
#include "ingen/Log.hpp"
+#include "ingen/Properties.hpp"
+#include "ingen/Resource.hpp"
+#include "ingen/URIs.hpp"
#include "ingen/client/ArcModel.hpp"
#include "ingen/client/BlockModel.hpp"
#include "ingen/client/GraphModel.hpp"
@@ -24,20 +29,23 @@
#include "ingen/client/PluginModel.hpp"
#include "ingen/client/PortModel.hpp"
#include "ingen/client/SigClientInterface.hpp"
+#include "ingen/paths.hpp"
+#include "raul/Path.hpp"
-#include <boost/variant/apply_visitor.hpp>
+#include <sigc++/functors/mem_fun.h>
#include <cassert>
#include <cstdint>
+#include <memory>
#include <string>
#include <utility>
+#include <variant>
-namespace ingen {
-namespace client {
+namespace ingen::client {
-ClientStore::ClientStore(URIs& uris,
- Log& log,
- SPtr<SigClientInterface> emitter)
+ClientStore::ClientStore(URIs& uris,
+ Log& log,
+ const std::shared_ptr<SigClientInterface>& emitter)
: _uris(uris)
, _log(log)
, _emitter(emitter)
@@ -57,16 +65,16 @@ ClientStore::clear()
}
void
-ClientStore::add_object(SPtr<ObjectModel> object)
+ClientStore::add_object(const std::shared_ptr<ObjectModel>& object)
{
// If we already have "this" object, merge the existing one into the new
// one (with precedence to the new values).
auto existing = find(object->path());
if (existing != end()) {
- dynamic_ptr_cast<ObjectModel>(existing->second)->set(object);
+ std::dynamic_pointer_cast<ObjectModel>(existing->second)->set(object);
} else {
if (!object->path().is_root()) {
- SPtr<ObjectModel> parent = _object(object->path().parent());
+ const std::shared_ptr<ObjectModel> parent = _object(object->path().parent());
if (parent) {
assert(object->path().is_child_of(parent->path()));
object->set_parent(parent);
@@ -84,26 +92,26 @@ ClientStore::add_object(SPtr<ObjectModel> object)
}
}
- for (auto p : object->properties()) {
+ for (const auto& p : object->properties()) {
object->signal_property().emit(p.first, p.second);
}
}
-SPtr<ObjectModel>
-ClientStore::remove_object(const Raul::Path& path)
+std::shared_ptr<ObjectModel>
+ClientStore::remove_object(const raul::Path& path)
{
// Find the object, the "top" of the tree to remove
- const iterator top = find(path);
+ const auto top = find(path);
if (top == end()) {
- return SPtr<ObjectModel>();
+ return nullptr;
}
- SPtr<ObjectModel> object = dynamic_ptr_cast<ObjectModel>(top->second);
+ auto object = std::dynamic_pointer_cast<ObjectModel>(top->second);
// Remove object and any adjacent arcs from parent if applicable
if (object && object->parent()) {
- SPtr<PortModel> port = dynamic_ptr_cast<PortModel>(object);
- if (port && dynamic_ptr_cast<GraphModel>(port->parent())) {
+ auto port = std::dynamic_pointer_cast<PortModel>(object);
+ if (port && std::dynamic_pointer_cast<GraphModel>(port->parent())) {
disconnect_all(port->parent()->path(), path);
if (port->parent()->parent()) {
disconnect_all(port->parent()->parent()->path(), path);
@@ -129,69 +137,69 @@ ClientStore::remove_object(const Raul::Path& path)
return object;
}
-SPtr<PluginModel>
+std::shared_ptr<PluginModel>
ClientStore::_plugin(const URI& uri)
{
- const Plugins::iterator i = _plugins->find(uri);
- return (i == _plugins->end()) ? SPtr<PluginModel>() : (*i).second;
+ const auto i = _plugins->find(uri);
+ return (i == _plugins->end()) ? std::shared_ptr<PluginModel>() : (*i).second;
}
-SPtr<PluginModel>
+std::shared_ptr<PluginModel>
ClientStore::_plugin(const Atom& uri)
{
/* FIXME: Should probably be stored with URIs rather than strings, to make
this a fast case. */
- const Plugins::iterator i = _plugins->find(URI(_uris.forge.str(uri, false)));
- return (i == _plugins->end()) ? SPtr<PluginModel>() : (*i).second;
+ const auto i = _plugins->find(URI(_uris.forge.str(uri, false)));
+ return (i == _plugins->end()) ? std::shared_ptr<PluginModel>() : (*i).second;
}
-SPtr<const PluginModel>
+std::shared_ptr<const PluginModel>
ClientStore::plugin(const URI& uri) const
{
return const_cast<ClientStore*>(this)->_plugin(uri);
}
-SPtr<ObjectModel>
-ClientStore::_object(const Raul::Path& path)
+std::shared_ptr<ObjectModel>
+ClientStore::_object(const raul::Path& path)
{
- const iterator i = find(path);
+ const auto i = find(path);
if (i == end()) {
- return SPtr<ObjectModel>();
- } else {
- SPtr<ObjectModel> model = dynamic_ptr_cast<ObjectModel>(i->second);
- assert(model);
- assert(model->path().is_root() || model->parent());
- return model;
+ return nullptr;
}
+
+ auto model = std::dynamic_pointer_cast<ObjectModel>(i->second);
+ assert(model);
+ assert(model->path().is_root() || model->parent());
+ return model;
}
-SPtr<const ObjectModel>
-ClientStore::object(const Raul::Path& path) const
+std::shared_ptr<const ObjectModel>
+ClientStore::object(const raul::Path& path) const
{
return const_cast<ClientStore*>(this)->_object(path);
}
-SPtr<Resource>
+std::shared_ptr<Resource>
ClientStore::_resource(const URI& uri)
{
if (uri_is_path(uri)) {
return _object(uri_to_path(uri));
- } else {
- return _plugin(uri);
}
+
+ return _plugin(uri);
}
-SPtr<const Resource>
+std::shared_ptr<const Resource>
ClientStore::resource(const URI& uri) const
{
return const_cast<ClientStore*>(this)->_resource(uri);
}
void
-ClientStore::add_plugin(SPtr<PluginModel> pm)
+ClientStore::add_plugin(const std::shared_ptr<PluginModel>& pm)
{
- SPtr<PluginModel> existing = _plugin(pm->uri());
+ const std::shared_ptr<PluginModel> existing = _plugin(pm->uri());
if (existing) {
existing->set(pm);
} else {
@@ -225,7 +233,7 @@ ClientStore::operator()(const Copy&)
void
ClientStore::operator()(const Move& msg)
{
- const iterator top = find(msg.old_path);
+ const auto top = find(msg.old_path);
if (top != end()) {
rename(top, msg.new_path);
}
@@ -234,29 +242,30 @@ ClientStore::operator()(const Move& msg)
void
ClientStore::message(const Message& msg)
{
- boost::apply_visitor(*this, msg);
+ std::visit(*this, msg);
}
void
ClientStore::operator()(const Put& msg)
{
- using Iterator = Properties::const_iterator;
-
const auto& uri = msg.uri;
const auto& properties = msg.properties;
- bool is_graph, is_block, is_port, is_output;
+ bool is_block = false;
+ bool is_graph = false;
+ bool is_output = false;
+ bool is_port = false;
Resource::type(uris(), properties,
is_graph, is_block, is_port, is_output);
// Check for specially handled types
- const Iterator t = properties.find(_uris.rdf_type);
+ const auto t = properties.find(_uris.rdf_type);
if (t != properties.end()) {
const Atom& type(t->second);
if (_uris.pset_Preset == type) {
- const Iterator p = properties.find(_uris.lv2_appliesTo);
- const Iterator l = properties.find(_uris.rdfs_label);
- SPtr<PluginModel> plug;
+ const auto p = properties.find(_uris.lv2_appliesTo);
+ const auto l = properties.find(_uris.rdfs_label);
+ std::shared_ptr<PluginModel> plug;
if (p == properties.end()) {
_log.error("Preset <%1%> with no plugin\n", uri.c_str());
} else if (l == properties.end()) {
@@ -270,10 +279,12 @@ ClientStore::operator()(const Put& msg)
plug->add_preset(uri, l->second.ptr<char>());
}
return;
- } else if (_uris.ingen_Graph == type) {
+ }
+
+ if (_uris.ingen_Graph == type) {
is_graph = true;
} else if (_uris.ingen_Internal == type || _uris.lv2_Plugin == type) {
- SPtr<PluginModel> p(new PluginModel(uris(), uri, type, properties));
+ const std::shared_ptr<PluginModel> p{new PluginModel(uris(), uri, type, properties)};
add_plugin(p);
return;
}
@@ -284,9 +295,9 @@ ClientStore::operator()(const Put& msg)
return;
}
- const Raul::Path path(uri_to_path(uri));
+ const raul::Path path(uri_to_path(uri));
- SPtr<ObjectModel> obj = dynamic_ptr_cast<ObjectModel>(_object(path));
+ auto obj = std::dynamic_pointer_cast<ObjectModel>(_object(path));
if (obj) {
obj->set_properties(properties);
return;
@@ -297,7 +308,7 @@ ClientStore::operator()(const Put& msg)
}
if (is_graph) {
- SPtr<GraphModel> model(new GraphModel(uris(), path));
+ const std::shared_ptr<GraphModel> model{new GraphModel(uris(), path)};
model->set_properties(properties);
add_object(model);
} else if (is_block) {
@@ -306,33 +317,35 @@ ClientStore::operator()(const Put& msg)
p = properties.find(_uris.ingen_prototype);
}
- SPtr<PluginModel> plug;
+ std::shared_ptr<PluginModel> plug;
if (p->second.is_valid() && (p->second.type() == _uris.forge.URI ||
p->second.type() == _uris.forge.URID)) {
- const URI uri(_uris.forge.str(p->second, false));
- if (!(plug = _plugin(uri))) {
- plug = SPtr<PluginModel>(
- new PluginModel(uris(), uri, Atom(), Properties()));
+ const URI plugin_uri(_uris.forge.str(p->second, false));
+ if (!(plug = _plugin(plugin_uri))) {
+ plug = std::make_shared<PluginModel>(uris(),
+ plugin_uri,
+ Atom(),
+ Properties());
add_plugin(plug);
}
- SPtr<BlockModel> bm(new BlockModel(uris(), plug, path));
+ const std::shared_ptr<BlockModel> bm{new BlockModel(uris(), plug, path)};
bm->set_properties(properties);
add_object(bm);
} else {
_log.warn("Block %1% has no prototype\n", path.c_str());
}
} else if (is_port) {
- PortModel::Direction pdir = (is_output)
+ const PortModel::Direction pdir = (is_output)
? PortModel::Direction::OUTPUT
: PortModel::Direction::INPUT;
- uint32_t index = 0;
- const Iterator i = properties.find(_uris.lv2_index);
+ uint32_t index = 0;
+ const auto i = properties.find(_uris.lv2_index);
if (i != properties.end() && i->second.type() == _uris.forge.Int) {
index = i->second.get<int32_t>();
}
- SPtr<PortModel> p(new PortModel(uris(), path, index, pdir));
+ const std::shared_ptr<PortModel> p{new PortModel(uris(), path, index, pdir)};
p->set_properties(properties);
add_object(p);
} else {
@@ -354,9 +367,9 @@ ClientStore::operator()(const Delta& msg)
return;
}
- const Raul::Path path(uri_to_path(uri));
+ const raul::Path path(uri_to_path(uri));
- SPtr<ObjectModel> obj = _object(path);
+ const std::shared_ptr<ObjectModel> obj = _object(path);
if (obj) {
obj->remove_properties(msg.remove);
obj->add_properties(msg.add);
@@ -377,7 +390,7 @@ ClientStore::operator()(const SetProperty& msg)
predicate.c_str(), _uris.forge.str(value, false));
return;
}
- SPtr<Resource> subject = _resource(subject_uri);
+ const std::shared_ptr<Resource> subject = _resource(subject_uri);
if (subject) {
if (predicate == _uris.ingen_activity) {
/* Activity is transient, trigger any live actions (like GUI
@@ -387,7 +400,7 @@ ClientStore::operator()(const SetProperty& msg)
subject->set_property(predicate, value, msg.ctx);
}
} else {
- SPtr<PluginModel> plugin = _plugin(subject_uri);
+ const std::shared_ptr<PluginModel> plugin = _plugin(subject_uri);
if (plugin) {
plugin->set_property(predicate, value);
} else if (predicate != _uris.ingen_activity) {
@@ -397,26 +410,26 @@ ClientStore::operator()(const SetProperty& msg)
}
}
-SPtr<GraphModel>
-ClientStore::connection_graph(const Raul::Path& tail_path,
- const Raul::Path& head_path)
+std::shared_ptr<GraphModel>
+ClientStore::connection_graph(const raul::Path& tail_path,
+ const raul::Path& head_path)
{
- SPtr<GraphModel> graph;
+ std::shared_ptr<GraphModel> graph;
if (tail_path.parent() == head_path.parent()) {
- graph = dynamic_ptr_cast<GraphModel>(_object(tail_path.parent()));
+ graph = std::dynamic_pointer_cast<GraphModel>(_object(tail_path.parent()));
}
if (!graph && tail_path.parent() == head_path.parent().parent()) {
- graph = dynamic_ptr_cast<GraphModel>(_object(tail_path.parent()));
+ graph = std::dynamic_pointer_cast<GraphModel>(_object(tail_path.parent()));
}
if (!graph && tail_path.parent().parent() == head_path.parent()) {
- graph = dynamic_ptr_cast<GraphModel>(_object(head_path.parent()));
+ graph = std::dynamic_pointer_cast<GraphModel>(_object(head_path.parent()));
}
if (!graph) {
- graph = dynamic_ptr_cast<GraphModel>(_object(tail_path.parent().parent()));
+ graph = std::dynamic_pointer_cast<GraphModel>(_object(tail_path.parent().parent()));
}
if (!graph) {
@@ -428,21 +441,21 @@ ClientStore::connection_graph(const Raul::Path& tail_path,
}
bool
-ClientStore::attempt_connection(const Raul::Path& tail_path,
- const Raul::Path& head_path)
+ClientStore::attempt_connection(const raul::Path& tail_path,
+ const raul::Path& head_path)
{
- SPtr<PortModel> tail = dynamic_ptr_cast<PortModel>(_object(tail_path));
- SPtr<PortModel> head = dynamic_ptr_cast<PortModel>(_object(head_path));
+ auto tail = std::dynamic_pointer_cast<PortModel>(_object(tail_path));
+ auto head = std::dynamic_pointer_cast<PortModel>(_object(head_path));
if (tail && head) {
- SPtr<GraphModel> graph = connection_graph(tail_path, head_path);
- SPtr<ArcModel> arc(new ArcModel(tail, head));
+ const std::shared_ptr<GraphModel> graph = connection_graph(tail_path, head_path);
+ const std::shared_ptr<ArcModel> arc(new ArcModel(tail, head));
graph->add_arc(arc);
return true;
- } else {
- _log.warn("Failed to connect %1% => %2%\n", tail_path, head_path);
- return false;
}
+
+ _log.warn("Failed to connect %1% => %2%\n", tail_path, head_path);
+ return false;
}
void
@@ -454,9 +467,9 @@ ClientStore::operator()(const Connect& msg)
void
ClientStore::operator()(const Disconnect& msg)
{
- SPtr<PortModel> tail = dynamic_ptr_cast<PortModel>(_object(msg.tail));
- SPtr<PortModel> head = dynamic_ptr_cast<PortModel>(_object(msg.head));
- SPtr<GraphModel> graph = connection_graph(msg.tail, msg.head);
+ auto tail = std::dynamic_pointer_cast<PortModel>(_object(msg.tail));
+ auto head = std::dynamic_pointer_cast<PortModel>(_object(msg.head));
+ auto graph = connection_graph(msg.tail, msg.head);
if (graph) {
graph->remove_arc(tail.get(), head.get());
}
@@ -465,8 +478,8 @@ ClientStore::operator()(const Disconnect& msg)
void
ClientStore::operator()(const DisconnectAll& msg)
{
- SPtr<GraphModel> graph = dynamic_ptr_cast<GraphModel>(_object(msg.graph));
- SPtr<ObjectModel> object = _object(msg.path);
+ auto graph = std::dynamic_pointer_cast<GraphModel>(_object(msg.graph));
+ auto object = _object(msg.path);
if (!graph || !object) {
_log.error("Bad disconnect all notification %1% in %2%\n",
@@ -475,8 +488,8 @@ ClientStore::operator()(const DisconnectAll& msg)
}
const GraphModel::Arcs arcs = graph->arcs();
- for (auto a : arcs) {
- SPtr<ArcModel> arc = dynamic_ptr_cast<ArcModel>(a.second);
+ for (const auto& a : arcs) {
+ auto arc = std::dynamic_pointer_cast<ArcModel>(a.second);
if (arc->tail()->parent() == object
|| arc->head()->parent() == object
|| arc->tail()->path() == msg.path
@@ -486,5 +499,4 @@ ClientStore::operator()(const DisconnectAll& msg)
}
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/GraphModel.cpp b/src/client/GraphModel.cpp
index 90ab2964..45d0eb31 100644
--- a/src/client/GraphModel.cpp
+++ b/src/client/GraphModel.cpp
@@ -16,48 +16,52 @@
#include "ingen/client/GraphModel.hpp"
+#include "ingen/Atom.hpp"
#include "ingen/URIs.hpp"
#include "ingen/client/ArcModel.hpp"
#include "ingen/client/BlockModel.hpp"
-#include "ingen/client/ClientStore.hpp"
+#include "ingen/client/ObjectModel.hpp"
+#include "ingen/client/PortModel.hpp"
+#include "raul/Path.hpp"
#include <cassert>
+#include <map>
+#include <memory>
#include <string>
#include <utility>
-namespace ingen {
-namespace client {
+namespace ingen::client {
void
-GraphModel::add_child(const SPtr<ObjectModel>& c)
+GraphModel::add_child(const std::shared_ptr<ObjectModel>& c)
{
assert(c->parent().get() == this);
- SPtr<PortModel> pm = dynamic_ptr_cast<PortModel>(c);
+ auto pm = std::dynamic_pointer_cast<PortModel>(c);
if (pm) {
add_port(pm);
return;
}
- SPtr<BlockModel> bm = dynamic_ptr_cast<BlockModel>(c);
+ auto bm = std::dynamic_pointer_cast<BlockModel>(c);
if (bm) {
_signal_new_block.emit(bm);
}
}
bool
-GraphModel::remove_child(const SPtr<ObjectModel>& o)
+GraphModel::remove_child(const std::shared_ptr<ObjectModel>& o)
{
assert(o->path().is_child_of(path()));
assert(o->parent().get() == this);
- SPtr<PortModel> pm = dynamic_ptr_cast<PortModel>(o);
+ auto pm = std::dynamic_pointer_cast<PortModel>(o);
if (pm) {
remove_arcs_on(pm);
remove_port(pm);
}
- SPtr<BlockModel> bm = dynamic_ptr_cast<BlockModel>(o);
+ auto bm = std::dynamic_pointer_cast<BlockModel>(o);
if (bm) {
_signal_removed_block.emit(bm);
}
@@ -66,21 +70,21 @@ GraphModel::remove_child(const SPtr<ObjectModel>& o)
}
void
-GraphModel::remove_arcs_on(const SPtr<PortModel>& p)
+GraphModel::remove_arcs_on(const std::shared_ptr<PortModel>& p)
{
// Remove any connections which referred to this object,
// since they can't possibly exist anymore
- for (auto j = _arcs.begin(); j != _arcs.end();) {
+ for (auto j = _graph_arcs.begin(); j != _graph_arcs.end();) {
auto next = j;
++next;
- SPtr<ArcModel> arc = dynamic_ptr_cast<ArcModel>(j->second);
+ auto arc = std::dynamic_pointer_cast<ArcModel>(j->second);
if (arc->tail_path().parent() == p->path()
|| arc->tail_path() == p->path()
|| arc->head_path().parent() == p->path()
|| arc->head_path() == p->path()) {
_signal_removed_arc.emit(arc);
- _arcs.erase(j); // Cuts our reference
+ _graph_arcs.erase(j); // Cuts our reference
}
j = next;
}
@@ -89,23 +93,23 @@ GraphModel::remove_arcs_on(const SPtr<PortModel>& p)
void
GraphModel::clear()
{
- _arcs.clear();
+ _graph_arcs.clear();
BlockModel::clear();
- assert(_arcs.empty());
+ assert(_graph_arcs.empty());
assert(_ports.empty());
}
-SPtr<ArcModel>
+std::shared_ptr<ArcModel>
GraphModel::get_arc(const Node* tail, const Node* head)
{
- auto i = _arcs.find(std::make_pair(tail, head));
- if (i != _arcs.end()) {
- return dynamic_ptr_cast<ArcModel>(i->second);
- } else {
- return SPtr<ArcModel>();
+ auto i = _graph_arcs.find(std::make_pair(tail, head));
+ if (i != _graph_arcs.end()) {
+ return std::dynamic_pointer_cast<ArcModel>(i->second);
}
+
+ return nullptr;
}
/** Add a connection to this graph.
@@ -116,7 +120,7 @@ GraphModel::get_arc(const Node* tail, const Node* head)
* this graph is a fatal error.
*/
void
-GraphModel::add_arc(const SPtr<ArcModel>& arc)
+GraphModel::add_arc(const std::shared_ptr<ArcModel>& arc)
{
// Store should have 'resolved' the connection already
assert(arc);
@@ -130,15 +134,16 @@ GraphModel::add_arc(const SPtr<ArcModel>& arc)
assert(arc->head()->parent().get() == this
|| arc->head()->parent()->parent().get() == this);
- SPtr<ArcModel> existing = get_arc(
+ const std::shared_ptr<ArcModel> existing = get_arc(
arc->tail().get(), arc->head().get());
if (existing) {
assert(arc->tail() == existing->tail());
assert(arc->head() == existing->head());
} else {
- _arcs.emplace(std::make_pair(arc->tail().get(), arc->head().get()),
- arc);
+ _graph_arcs.emplace(std::make_pair(arc->tail().get(),
+ arc->head().get()),
+ arc);
_signal_new_arc.emit(arc);
}
}
@@ -146,11 +151,11 @@ GraphModel::add_arc(const SPtr<ArcModel>& arc)
void
GraphModel::remove_arc(const Node* tail, const Node* head)
{
- auto i = _arcs.find(std::make_pair(tail, head));
- if (i != _arcs.end()) {
- SPtr<ArcModel> arc = dynamic_ptr_cast<ArcModel>(i->second);
+ auto i = _graph_arcs.find(std::make_pair(tail, head));
+ if (i != _graph_arcs.end()) {
+ auto arc = std::dynamic_pointer_cast<ArcModel>(i->second);
_signal_removed_arc.emit(arc);
- _arcs.erase(i);
+ _graph_arcs.erase(i);
}
}
@@ -175,5 +180,4 @@ GraphModel::polyphonic() const
return poly.is_valid() && poly.get<int32_t>();
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/ObjectModel.cpp b/src/client/ObjectModel.cpp
index b1a27590..0c3bf517 100644
--- a/src/client/ObjectModel.cpp
+++ b/src/client/ObjectModel.cpp
@@ -16,31 +16,35 @@
#include "ingen/client/ObjectModel.hpp"
+#include "ingen/Atom.hpp"
#include "ingen/Node.hpp"
+#include "ingen/Properties.hpp"
+#include "ingen/Resource.hpp"
#include "ingen/URIs.hpp"
+#include "ingen/paths.hpp"
+#include "raul/Path.hpp"
+#include "raul/Symbol.hpp"
#include <cassert>
#include <cstdint>
+#include <map>
#include <string>
#include <utility>
-namespace ingen {
-namespace client {
+namespace ingen::client {
-ObjectModel::ObjectModel(URIs& uris, const Raul::Path& path)
+ObjectModel::ObjectModel(URIs& uris, const raul::Path& path)
: Node(uris, path)
, _path(path)
, _symbol((path == "/") ? "root" : path.symbol())
-{
-}
+{}
ObjectModel::ObjectModel(const ObjectModel& copy)
: Node(copy)
, _parent(copy._parent)
, _path(copy._path)
, _symbol(copy._symbol)
-{
-}
+{}
bool
ObjectModel::is_a(const URIs::Quark& type) const
@@ -81,34 +85,33 @@ ObjectModel::polyphonic() const
* `o` as correct. The paths of the two models MUST be equal.
*/
void
-ObjectModel::set(const SPtr<ObjectModel>& o)
+ObjectModel::set(const std::shared_ptr<ObjectModel>& o)
{
assert(_path == o->path());
if (o->_parent) {
_parent = o->_parent;
}
- for (auto v : o->properties()) {
+ for (const auto& v : o->properties()) {
Resource::set_property(v.first, v.second);
_signal_property.emit(v.first, v.second);
}
}
void
-ObjectModel::set_path(const Raul::Path& p)
+ObjectModel::set_path(const raul::Path& p)
{
_path = p;
- _symbol = Raul::Symbol(p.is_root() ? "root" : p.symbol());
+ _symbol = raul::Symbol(p.is_root() ? "root" : p.symbol());
set_uri(path_to_uri(p));
_signal_moved.emit();
}
void
-ObjectModel::set_parent(const SPtr<ObjectModel>& p)
+ObjectModel::set_parent(const std::shared_ptr<ObjectModel>& p)
{
assert(_path.is_child_of(p->path()));
_parent = p;
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/PluginModel.cpp b/src/client/PluginModel.cpp
index f0e3c3a0..333bf568 100644
--- a/src/client/PluginModel.cpp
+++ b/src/client/PluginModel.cpp
@@ -17,23 +17,20 @@
#include "ingen/client/PluginModel.hpp"
#include "ingen/Atom.hpp"
-#include "ingen/client/GraphModel.hpp"
#include "ingen/client/PluginUI.hpp"
-#include "raul/Path.hpp"
-#include "ingen_config.h"
-
-#include <boost/optional/optional.hpp>
+#include "lilv/lilv.h"
+#include "lv2/core/lv2.h"
+#include "raul/Symbol.hpp"
#include <cctype>
#include <cstring>
-#include <iosfwd>
+#include <memory>
#include <string>
#include <utility>
using std::string;
-namespace ingen {
-namespace client {
+namespace ingen::client {
LilvWorld* PluginModel::_lilv_world = nullptr;
const LilvPlugins* PluginModel::_lilv_plugins = nullptr;
@@ -46,13 +43,12 @@ PluginModel::PluginModel(URIs& uris,
const Properties& properties)
: Resource(uris, uri)
, _type(type)
- , _fetched(false)
{
if (!_type.is_valid()) {
if (uri.string().find("ingen-internals") != string::npos) {
- _type = uris.ingen_Internal.urid;
+ _type = uris.ingen_Internal.urid_atom();
} else {
- _type = uris.lv2_Plugin.urid; // Assume LV2 and hope for the best...
+ _type = uris.lv2_Plugin.urid_atom(); // Assume LV2 and hope for the best...
}
}
@@ -112,33 +108,39 @@ PluginModel::get_property(const URI& key) const
}
str = str.substr(last_delim + 1);
- std::string symbol = Raul::Symbol::symbolify(str);
+ const std::string symbol = raul::Symbol::symbolify(str);
set_property(_uris.lv2_symbol, _uris.forge.alloc(symbol));
return get_property(key);
}
if (_lilv_plugin) {
- boost::optional<const Atom&> ret;
- LilvNode* lv2_pred = lilv_new_uri(_lilv_world, key.c_str());
- LilvNodes* values = lilv_plugin_get_value(_lilv_plugin, lv2_pred);
+ const Atom* ret = nullptr;
+ LilvNode* lv2_pred = lilv_new_uri(_lilv_world, key.c_str());
+ LilvNodes* values = lilv_plugin_get_value(_lilv_plugin, lv2_pred);
lilv_node_free(lv2_pred);
- LILV_FOREACH(nodes, i, values) {
- const LilvNode* val = lilv_nodes_get(values, i);
- if (lilv_node_is_uri(val)) {
- ret = set_property(
- key, _uris.forge.make_urid(URI(lilv_node_as_uri(val))));
+ LILV_FOREACH (nodes, i, values) {
+ const LilvNode* value = lilv_nodes_get(values, i);
+ if (lilv_node_is_uri(value)) {
+ ret = &set_property(
+ key, _uris.forge.make_urid(URI(lilv_node_as_uri(value))));
break;
- } else if (lilv_node_is_string(val)) {
- ret = set_property(
- key, _uris.forge.alloc(lilv_node_as_string(val)));
+ }
+
+ if (lilv_node_is_string(value)) {
+ ret = &set_property(
+ key, _uris.forge.alloc(lilv_node_as_string(value)));
break;
- } else if (lilv_node_is_float(val)) {
- ret = set_property(
- key, _uris.forge.make(lilv_node_as_float(val)));
+ }
+
+ if (lilv_node_is_float(value)) {
+ ret = &set_property(
+ key, _uris.forge.make(lilv_node_as_float(value)));
break;
- } else if (lilv_node_is_int(val)) {
- ret = set_property(
- key, _uris.forge.make(lilv_node_as_int(val)));
+ }
+
+ if (lilv_node_is_int(value)) {
+ ret = &set_property(
+ key, _uris.forge.make(lilv_node_as_int(value)));
break;
}
}
@@ -153,7 +155,7 @@ PluginModel::get_property(const URI& key) const
}
void
-PluginModel::set(SPtr<PluginModel> p)
+PluginModel::set(const std::shared_ptr<PluginModel>& p)
{
_type = p->_type;
@@ -161,7 +163,7 @@ PluginModel::set(SPtr<PluginModel> p)
_lilv_plugin = p->_lilv_plugin;
}
- for (auto v : p->properties()) {
+ for (const auto& v : p->properties()) {
Resource::set_property(v.first, v.second);
_signal_property.emit(v.first, v.second);
}
@@ -176,15 +178,15 @@ PluginModel::add_preset(const URI& uri, const std::string& label)
_signal_preset.emit(uri, label);
}
-Raul::Symbol
+raul::Symbol
PluginModel::default_block_symbol() const
{
const Atom& name_atom = get_property(_uris.lv2_symbol);
if (name_atom.is_valid() && name_atom.type() == _uris.forge.String) {
- return Raul::Symbol::symbolify(name_atom.ptr<char>());
- } else {
- return Raul::Symbol("_");
+ return raul::Symbol::symbolify(name_atom.ptr<char>());
}
+
+ return raul::Symbol("_");
}
string
@@ -193,18 +195,18 @@ PluginModel::human_name() const
const Atom& name_atom = get_property(_uris.doap_name);
if (name_atom.type() == _uris.forge.String) {
return name_atom.ptr<char>();
- } else {
- return default_block_symbol().c_str();
}
+
+ return default_block_symbol().c_str();
}
string
-PluginModel::port_human_name(uint32_t i) const
+PluginModel::port_human_name(const uint32_t index) const
{
if (_lilv_plugin) {
- const LilvPort* port = lilv_plugin_get_port_by_index(_lilv_plugin, i);
+ const LilvPort* port = lilv_plugin_get_port_by_index(_lilv_plugin, index);
LilvNode* name = lilv_port_get_name(_lilv_plugin, port);
- const string ret(lilv_node_as_string(name));
+ string ret(lilv_node_as_string(name));
lilv_node_free(name);
return ret;
}
@@ -212,14 +214,14 @@ PluginModel::port_human_name(uint32_t i) const
}
PluginModel::ScalePoints
-PluginModel::port_scale_points(uint32_t i) const
+PluginModel::port_scale_points(const uint32_t index) const
{
// TODO: Non-float scale points
ScalePoints points;
if (_lilv_plugin) {
- const LilvPort* port = lilv_plugin_get_port_by_index(_lilv_plugin, i);
+ const LilvPort* port = lilv_plugin_get_port_by_index(_lilv_plugin, index);
LilvScalePoints* sp = lilv_port_get_scale_points(_lilv_plugin, port);
- LILV_FOREACH(scale_points, i, sp) {
+ LILV_FOREACH (scale_points, i, sp) {
const LilvScalePoint* p = lilv_scale_points_get(sp, i);
points.emplace(
lilv_node_as_float(lilv_scale_point_get_value(p)),
@@ -241,12 +243,12 @@ PluginModel::has_ui() const
return false;
}
-SPtr<PluginUI>
-PluginModel::ui(ingen::World& world,
- SPtr<const BlockModel> block) const
+std::shared_ptr<PluginUI>
+PluginModel::ui(ingen::World& world,
+ const std::shared_ptr<const BlockModel>& block) const
{
if (!_lilv_plugin) {
- return SPtr<PluginUI>();
+ return nullptr;
}
return PluginUI::create(world, block, _lilv_plugin);
@@ -258,9 +260,9 @@ heading(const std::string& text, bool html, unsigned level)
if (html) {
const std::string tag = std::string("h") + std::to_string(level);
return std::string("<") + tag + ">" + text + "</" + tag + ">\n";
- } else {
- return text + ":\n\n";
}
+
+ return text + ":\n\n";
}
static std::string
@@ -268,13 +270,13 @@ link(const std::string& addr, bool html)
{
if (html) {
return std::string("<a href=\"") + addr + "\">" + addr + "</a>";
- } else {
- return addr;
}
+
+ return addr;
}
std::string
-PluginModel::get_documentation(const LilvNode* subject, bool html) const
+PluginModel::get_documentation(const LilvNode* subject, bool html)
{
std::string doc;
@@ -358,5 +360,4 @@ PluginModel::set_lilv_world(LilvWorld* world)
_lilv_plugins = lilv_world_get_all_plugins(_lilv_world);
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/PluginUI.cpp b/src/client/PluginUI.cpp
index a997d716..61813cab 100644
--- a/src/client/PluginUI.cpp
+++ b/src/client/PluginUI.cpp
@@ -16,31 +16,40 @@
#include "ingen/client/PluginUI.hpp"
-#include "ingen/Interface.hpp"
+#include "ingen/Atom.hpp"
+#include "ingen/Forge.hpp"
#include "ingen/Log.hpp"
+#include "ingen/URI.hpp"
#include "ingen/URIs.hpp"
+#include "ingen/World.hpp"
#include "ingen/client/BlockModel.hpp"
#include "ingen/client/PortModel.hpp"
+#include "lilv/lilv.h"
#include "lv2/atom/atom.h"
+#include "lv2/core/lv2.h"
#include "lv2/ui/ui.h"
+#include "raul/Symbol.hpp"
+#include "suil/suil.h"
+
+#include <sigc++/signal.h>
#include <cstring>
+#include <memory>
#include <string>
#include <utility>
-namespace ingen {
-namespace client {
+namespace ingen::client {
SuilHost* PluginUI::ui_host = nullptr;
-static SPtr<const PortModel>
+static std::shared_ptr<const PortModel>
get_port(PluginUI* ui, uint32_t port_index)
{
if (port_index >= ui->block()->ports().size()) {
ui->world().log().error("%1% UI tried to access invalid port %2%\n",
ui->block()->plugin()->uri().c_str(),
port_index);
- return SPtr<const PortModel>();
+ return nullptr;
}
return ui->block()->ports()[port_index];
}
@@ -52,9 +61,9 @@ lv2_ui_write(SuilController controller,
uint32_t format,
const void* buffer)
{
- PluginUI* const ui = (PluginUI*)controller;
- const URIs& uris = ui->world().uris();
- SPtr<const PortModel> port = get_port(ui, port_index);
+ auto* const ui = static_cast<PluginUI*>(controller);
+ const URIs& uris = ui->world().uris();
+ auto port = get_port(ui, port_index);
if (!port) {
return;
}
@@ -67,10 +76,10 @@ lv2_ui_write(SuilController controller,
ui->block()->plugin()->uri().c_str());
return;
}
- const float value = *(const float*)buffer;
+ const float value = *static_cast<const float*>(buffer);
if (port->value().type() == uris.atom_Float &&
value == port->value().get<float>()) {
- return; // Ignore feedback
+ return; // Ignore feedback
}
ui->signal_property_changed()(
@@ -79,10 +88,11 @@ lv2_ui_write(SuilController controller,
ui->world().forge().make(value),
Resource::Graph::DEFAULT);
- } else if (format == uris.atom_eventTransfer.urid.get<LV2_URID>()) {
- const LV2_Atom* atom = (const LV2_Atom*)buffer;
- Atom val = ui->world().forge().alloc(
- atom->size, atom->type, LV2_ATOM_BODY_CONST(atom));
+ } else if (format == uris.atom_eventTransfer.urid()) {
+ const auto* atom = static_cast<const LV2_Atom*>(buffer);
+ const Atom val =
+ Forge::alloc(atom->size, atom->type, LV2_ATOM_BODY_CONST(atom));
+
ui->signal_property_changed()(port->uri(),
uris.ingen_activity,
val,
@@ -97,7 +107,7 @@ lv2_ui_write(SuilController controller,
static uint32_t
lv2_ui_port_index(SuilController controller, const char* port_symbol)
{
- PluginUI* const ui = (PluginUI*)controller;
+ auto* const ui = static_cast<PluginUI*>(controller);
const BlockModel::Ports& ports = ui->block()->ports();
for (uint32_t i = 0; i < ports.size(); ++i) {
@@ -114,8 +124,8 @@ lv2_ui_subscribe(SuilController controller,
uint32_t protocol,
const LV2_Feature* const* features)
{
- PluginUI* const ui = (PluginUI*)controller;
- SPtr<const PortModel> port = get_port(ui, port_index);
+ auto* const ui = static_cast<PluginUI*>(controller);
+ const std::shared_ptr<const PortModel> port = get_port(ui, port_index);
if (!port) {
return 1;
}
@@ -135,8 +145,8 @@ lv2_ui_unsubscribe(SuilController controller,
uint32_t protocol,
const LV2_Feature* const* features)
{
- PluginUI* const ui = (PluginUI*)controller;
- SPtr<const PortModel> port = get_port(ui, port_index);
+ auto* const ui = static_cast<PluginUI*>(controller);
+ auto port = get_port(ui, port_index);
if (!port) {
return 1;
}
@@ -150,24 +160,22 @@ lv2_ui_unsubscribe(SuilController controller,
return 0;
}
-PluginUI::PluginUI(ingen::World& world,
- SPtr<const BlockModel> block,
- LilvUIs* uis,
- const LilvUI* ui,
- const LilvNode* ui_type)
- : _world(world)
- , _block(std::move(block))
- , _instance(nullptr)
- , _uis(uis)
- , _ui(ui)
- , _ui_node(lilv_node_duplicate(lilv_ui_get_uri(ui)))
- , _ui_type(lilv_node_duplicate(ui_type))
-{
-}
+PluginUI::PluginUI(ingen::World& world,
+ std::shared_ptr<const BlockModel> block,
+ LilvUIs* uis,
+ const LilvUI* ui,
+ const LilvNode* ui_type)
+ : _world(world)
+ , _block(std::move(block))
+ , _uis(uis)
+ , _ui(ui)
+ , _ui_node(lilv_node_duplicate(lilv_ui_get_uri(ui)))
+ , _ui_type(lilv_node_duplicate(ui_type))
+{}
PluginUI::~PluginUI()
{
- for (uint32_t i : _subscribed_ports) {
+ for (const uint32_t i : _subscribed_ports) {
lv2_ui_unsubscribe(this, i, 0, nullptr);
}
suil_instance_free(_instance);
@@ -177,10 +185,10 @@ PluginUI::~PluginUI()
lilv_world_unload_resource(_world.lilv_world(), lilv_ui_get_uri(_ui));
}
-SPtr<PluginUI>
-PluginUI::create(ingen::World& world,
- SPtr<const BlockModel> block,
- const LilvPlugin* plugin)
+std::shared_ptr<PluginUI>
+PluginUI::create(ingen::World& world,
+ const std::shared_ptr<const BlockModel>& block,
+ const LilvPlugin* plugin)
{
if (!PluginUI::ui_host) {
PluginUI::ui_host = suil_host_new(lv2_ui_write,
@@ -196,7 +204,7 @@ PluginUI::create(ingen::World& world,
LilvUIs* uis = lilv_plugin_get_uis(plugin);
const LilvUI* ui = nullptr;
const LilvNode* ui_type = nullptr;
- LILV_FOREACH(uis, u, uis) {
+ LILV_FOREACH (uis, u, uis) {
const LilvUI* this_ui = lilv_uis_get(uis, u);
if (lilv_ui_is_supported(this_ui,
suil_ui_supported,
@@ -210,11 +218,11 @@ PluginUI::create(ingen::World& world,
if (!ui) {
lilv_node_free(gtk_ui);
- return SPtr<PluginUI>();
+ return nullptr;
}
// Create the PluginUI, but don't instantiate yet
- SPtr<PluginUI> ret(new PluginUI(world, block, uis, ui, ui_type));
+ std::shared_ptr<PluginUI> ret(new PluginUI(world, block, uis, ui, ui_type));
ret->_features = world.lv2_features().lv2_features(
world, const_cast<BlockModel*>(block.get()));
@@ -238,7 +246,7 @@ PluginUI::instantiate()
LilvNode* ui_plugin = lilv_new_uri(lworld, LV2_UI__plugin);
LilvNodes* notes = lilv_world_find_nodes(
lworld, lilv_ui_get_uri(_ui), ui_portNotification, nullptr);
- LILV_FOREACH(nodes, n, notes) {
+ LILV_FOREACH (nodes, n, notes) {
const LilvNode* note = lilv_nodes_get(notes, n);
const LilvNode* sym = lilv_world_get(lworld, note, uris.lv2_symbol, nullptr);
const LilvNode* plug = lilv_world_get(lworld, note, ui_plugin, nullptr);
@@ -253,7 +261,7 @@ PluginUI::instantiate()
plugin_uri, lilv_node_as_string(_ui_node));
} else if (!strcmp(lilv_node_as_uri(plug), plugin_uri.c_str())) {
// Notification is valid and for this plugin
- uint32_t index = lv2_ui_port_index(this, lilv_node_as_string(sym));
+ const uint32_t index = lv2_ui_port_index(this, lilv_node_as_string(sym));
if (index != LV2UI_INVALID_PORT_INDEX) {
lv2_ui_subscribe(this, index, 0, nullptr);
_subscribed_ports.insert(index);
@@ -287,7 +295,7 @@ PluginUI::instantiate()
if (!_instance) {
_world.log().error("Failed to instantiate LV2 UI\n");
// Cancel any subscriptions
- for (uint32_t i : _subscribed_ports) {
+ for (const uint32_t i : _subscribed_ports) {
lv2_ui_unsubscribe(this, i, 0, nullptr);
}
return false;
@@ -299,7 +307,7 @@ PluginUI::instantiate()
SuilWidget
PluginUI::get_widget()
{
- return (SuilWidget*)suil_instance_get_widget(_instance);
+ return suil_instance_get_widget(_instance);
}
void
@@ -337,5 +345,4 @@ PluginUI::is_resizable() const
return !fs_matches && !nrs_matches;
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/PortModel.cpp b/src/client/PortModel.cpp
index 6b2d011f..73f273c7 100644
--- a/src/client/PortModel.cpp
+++ b/src/client/PortModel.cpp
@@ -14,14 +14,20 @@
along with Ingen. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "ingen/client/BlockModel.hpp"
#include "ingen/client/PortModel.hpp"
+#include "ingen/Properties.hpp"
+#include "ingen/URI.hpp"
+#include "ingen/URIs.hpp"
+#include "ingen/client/ObjectModel.hpp"
+#include "lv2/urid/urid.h"
+
#include <cstdint>
+#include <map>
+#include <memory>
#include <utility>
-namespace ingen {
-namespace client {
+namespace ingen::client {
void
PortModel::on_property(const URI& uri, const Atom& value)
@@ -55,7 +61,7 @@ bool
PortModel::is_uri() const
{
// FIXME: Resource::has_property doesn't work, URI != URID
- for (auto p : properties()) {
+ for (const auto& p : properties()) {
if (p.second.type() == _uris.atom_URID &&
static_cast<LV2_URID>(p.second.get<int32_t>()) == _uris.atom_URID) {
return true;
@@ -65,11 +71,11 @@ PortModel::is_uri() const
}
void
-PortModel::set(const SPtr<ObjectModel>& model)
+PortModel::set(const std::shared_ptr<ObjectModel>& model)
{
ObjectModel::set(model);
- SPtr<PortModel> port = dynamic_ptr_cast<PortModel>(model);
+ auto port = std::dynamic_pointer_cast<PortModel>(model);
if (port) {
_index = port->_index;
_direction = port->_direction;
@@ -77,5 +83,4 @@ PortModel::set(const SPtr<ObjectModel>& model)
}
}
-} // namespace client
-} // namespace ingen
+} // namespace ingen::client
diff --git a/src/client/ingen_client.cpp b/src/client/ingen_client.cpp
index f76fae0b..63705ebc 100644
--- a/src/client/ingen_client.cpp
+++ b/src/client/ingen_client.cpp
@@ -15,19 +15,26 @@
*/
#include "ingen/Module.hpp"
-#include "ingen/World.hpp"
-#include "ingen_config.h"
-struct IngenClientModule : public ingen::Module {
+namespace ingen {
+
+class World;
+
+namespace client {
+
+struct ClientModule : public ingen::Module {
void load(ingen::World& world) override {}
};
+} // namespace client
+} // namespace ingen
+
extern "C" {
-ingen::Module*
+INGEN_MODULE_EXPORT ingen::Module*
ingen_module_load()
{
- return new IngenClientModule();
+ return new ingen::client::ClientModule();
}
} // extern "C"
diff --git a/src/client/meson.build b/src/client/meson.build
new file mode 100644
index 00000000..7c040634
--- /dev/null
+++ b/src/client/meson.build
@@ -0,0 +1,50 @@
+# Copyright 2022 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: 0BSD OR GPL-3.0-or-later
+
+################
+# Dependencies #
+################
+
+sigcpp_dep = dependency('sigc++-2.0', include_type: 'system')
+
+##########
+# Module #
+##########
+
+client_sources = files(
+ 'BlockModel.cpp',
+ 'ClientStore.cpp',
+ 'GraphModel.cpp',
+ 'ObjectModel.cpp',
+ 'PluginModel.cpp',
+ 'PluginUI.cpp',
+ 'PortModel.cpp',
+ 'ingen_client.cpp',
+)
+
+client_dependencies = [
+ boost_dep,
+ ingen_dep,
+ lilv_dep,
+ lv2_dep,
+ raul_dep,
+ sigcpp_dep,
+ suil_dep,
+]
+
+libingen_client = shared_library(
+ 'ingen_client',
+ client_sources,
+ cpp_args: cpp_suppressions + platform_defines + ['-DINGEN_CLIENT_INTERNAL'],
+ dependencies: client_dependencies,
+ gnu_symbol_visibility: 'hidden',
+ implicit_include_directories: false,
+ include_directories: ingen_include_dirs,
+ install: true,
+ install_dir: ingen_module_dir,
+)
+
+ingen_client_dep = declare_dependency(
+ dependencies: client_dependencies,
+ link_with: libingen_client,
+)
diff --git a/src/client/wscript b/src/client/wscript
deleted file mode 100644
index 394c9e4d..00000000
--- a/src/client/wscript
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/env python
-
-
-def build(bld):
- obj = bld(features = 'cxx cxxshlib',
- cflags = ['-fvisibility=hidden'],
- includes = ['../..'],
- export_includes = ['../..'],
- name = 'libingen_client',
- target = 'ingen_client',
- install_path = '${LIBDIR}',
- use = 'libingen',
- uselib = 'GLIBMM LV2 LILV SUIL RAUL SERD SORD SIGCPP')
-
- obj.source = '''
- BlockModel.cpp
- ClientStore.cpp
- GraphModel.cpp
- ObjectModel.cpp
- PluginModel.cpp
- PluginUI.cpp
- PortModel.cpp
- ingen_client.cpp
- '''
generated by cgit v1.2.1 (git 2.18.0) at 2024-04-19 20:40:49 +0000