summaryrefslogtreecommitdiffstats
path: root/src/gui/PropertiesWindow.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/gui/PropertiesWindow.cpp')
-rw-r--r--src/gui/PropertiesWindow.cpp199
1 files changed, 36 insertions, 163 deletions
diff --git a/src/gui/PropertiesWindow.cpp b/src/gui/PropertiesWindow.cpp
index f2e2b9cf..b357514d 100644
--- a/src/gui/PropertiesWindow.cpp
+++ b/src/gui/PropertiesWindow.cpp
@@ -23,12 +23,14 @@
#include "ingen/Interface.hpp"
#include "ingen/Log.hpp"
+#include "ingen/URIMap.hpp"
#include "ingen/World.hpp"
#include "ingen/client/BlockModel.hpp"
#include "ingen/client/PluginModel.hpp"
#include "App.hpp"
#include "PropertiesWindow.hpp"
+#include "RDFS.hpp"
using namespace std;
@@ -81,16 +83,17 @@ PropertiesWindow::PropertiesWindow(BaseObjectType* cobject,
void
PropertiesWindow::reset()
{
- _table->children().clear();
- _table->resize(1, 3);
- _table->property_n_rows() = 1;
+ _property_connection.disconnect();
- _records.clear();
_key_store->clear();
_value_store->clear();
+ _records.clear();
- _property_connection.disconnect();
_model.reset();
+
+ _table->children().clear();
+ _table->resize(1, 3);
+ _table->property_n_rows() = 1;
}
void
@@ -100,132 +103,6 @@ PropertiesWindow::present(SharedPtr<const ObjectModel> model)
Gtk::Window::present();
}
-/** Set @p types to its super/sub class closure.
- * @param super If true, find all superclasses, otherwise all subclasses
- */
-static void
-get_classes(World* world, URISet& types, bool super)
-{
- LilvNode* rdfs_subClassOf = lilv_new_uri(
- world->lilv_world(), LILV_NS_RDFS "subClassOf");
-
- unsigned added = 0;
- do {
- added = 0;
- URISet klasses;
- for (URISet::iterator t = types.begin(); t != types.end(); ++t) {
- LilvNode* type = lilv_new_uri(world->lilv_world(), t->c_str());
- LilvNodes* matches = (super)
- ? lilv_world_find_nodes(
- world->lilv_world(), type, rdfs_subClassOf, NULL)
- : lilv_world_find_nodes(
- world->lilv_world(), NULL, rdfs_subClassOf, type);
- LILV_FOREACH(nodes, m, matches) {
- const LilvNode* klass_node = lilv_nodes_get(matches, m);
- if (lilv_node_is_uri(klass_node)) {
- Raul::URI klass(lilv_node_as_uri(klass_node));
- if (!types.count(klass)) {
- ++added;
- klasses.insert(klass);
- }
- }
- }
- lilv_nodes_free(matches);
- lilv_node_free(type);
- }
- types.insert(klasses.begin(), klasses.end());
- } while (added > 0);
-
- lilv_node_free(rdfs_subClassOf);
-}
-
-/** Get all the types which this model is an instance of */
-static URISet
-get_types(World* world, SharedPtr<const ObjectModel> model)
-{
- typedef Resource::Properties::const_iterator PropIter;
- typedef std::pair<PropIter, PropIter> PropRange;
-
- // Start with every rdf:type
- URISet types;
- PropRange range = model->properties().equal_range(world->uris().rdf_type);
- for (PropIter t = range.first; t != range.second; ++t) {
- types.insert(Raul::URI(t->second.get_uri()));
- if (world->uris().ingen_Graph == t->second.get_uri()) {
- // Add lv2:Plugin as a type for graphs so plugin properties show up
- types.insert(world->uris().lv2_Plugin);
- }
- }
-
- // Add every superclass of every type, recursively
- get_classes(world, types, true);
-
- return types;
-}
-
-/** Get all the properties with domains appropriate to this model */
-static URISet
-get_properties(World* world, SharedPtr<const ObjectModel> model)
-{
- URISet properties;
- URISet types = get_types(world, model);
-
- LilvNode* rdf_type = lilv_new_uri(world->lilv_world(),
- LILV_NS_RDF "type");
- LilvNode* rdf_Property = lilv_new_uri(world->lilv_world(),
- LILV_NS_RDF "Property");
- LilvNode* rdfs_domain = lilv_new_uri(world->lilv_world(),
- LILV_NS_RDFS "domain");
-
- LilvNodes* props = lilv_world_find_nodes(
- world->lilv_world(), NULL, rdf_type, rdf_Property);
- LILV_FOREACH(nodes, p, props) {
- const LilvNode* prop = lilv_nodes_get(props, p);
- if (lilv_node_is_uri(prop)) {
- LilvNodes* domains = lilv_world_find_nodes(
- world->lilv_world(), prop, rdfs_domain, NULL);
- unsigned n_matching_domains = 0;
- LILV_FOREACH(nodes, d, domains) {
- const LilvNode* domain_node = lilv_nodes_get(domains, d);
- const Raul::URI domain(lilv_node_as_uri(domain_node));
- if (types.count(domain)) {
- ++n_matching_domains;
- }
- }
-
- if (lilv_nodes_size(domains) == 0 || (
- n_matching_domains > 0 &&
- n_matching_domains == lilv_nodes_size(domains))) {
- properties.insert(Raul::URI(lilv_node_as_uri(prop)));
- }
-
- lilv_nodes_free(domains);
- }
- }
-
- lilv_node_free(rdfs_domain);
- lilv_node_free(rdf_Property);
- lilv_node_free(rdf_type);
-
- return properties;
-}
-
-static Glib::ustring
-get_label(World* world, const LilvNode* node)
-{
- LilvNode* rdfs_label = lilv_new_uri(
- world->lilv_world(), LILV_NS_RDFS "label");
- LilvNodes* labels = lilv_world_find_nodes(
- world->lilv_world(), node, rdfs_label, NULL);
-
- const LilvNode* first = lilv_nodes_get_first(labels);
- Glib::ustring label = first ? lilv_node_as_string(first) : "";
-
- lilv_nodes_free(labels);
- lilv_node_free(rdfs_label);
- return label;
-}
-
void
PropertiesWindow::add_property(const Raul::URI& uri, const Raul::Atom& value)
{
@@ -236,7 +113,7 @@ PropertiesWindow::add_property(const Raul::URI& uri, const Raul::Atom& value)
// Column 0: Property
LilvNode* prop = lilv_new_uri(world->lilv_world(), uri.c_str());
- Glib::ustring lab_text = get_label(world, prop);
+ Glib::ustring lab_text = RDFS::label(world, prop);
if (lab_text.empty()) {
lab_text = world->rdf_world()->prefixes().qualify(uri);
}
@@ -278,10 +155,10 @@ PropertiesWindow::set_object(SharedPtr<const ObjectModel> model)
world->lilv_world(), LILV_NS_RDF "type");
// Populate key combo
- const URISet props = get_properties(world, model);
+ const URISet props = RDFS::properties(world, model);
for (URISet::const_iterator p = props.begin(); p != props.end(); ++p) {
LilvNode* prop = lilv_new_uri(world->lilv_world(), p->c_str());
- const Glib::ustring label = get_label(world, prop);
+ const Glib::ustring label = RDFS::label(world, prop);
if (label.empty()) {
continue;
}
@@ -293,7 +170,7 @@ PropertiesWindow::set_object(SharedPtr<const ObjectModel> model)
LILV_FOREACH(nodes, r, range) {
ranges.insert(Raul::URI(lilv_node_as_string(lilv_nodes_get(range, r))));
}
- get_classes(world, ranges, false);
+ RDFS::classes(world, ranges, false);
bool show = false;
for (URISet::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
@@ -373,6 +250,16 @@ PropertiesWindow::create_value_widget(const Raul::URI& uri, const Raul::Atom& va
sigc::mem_fun(this, &PropertiesWindow::value_edited),
uri));
return widget;
+ } else if (value.type() == forge.URID) {
+ const char* val_uri = _app->world()->uri_map().unmap_uri(value.get_int32());
+ Gtk::Entry* widget = manage(new Gtk::Entry());
+ if (val_uri) {
+ widget->set_text(val_uri);
+ }
+ widget->signal_changed().connect(sigc::bind(
+ sigc::mem_fun(this, &PropertiesWindow::value_edited),
+ uri));
+ return widget;
} else if (value.type() == forge.String) {
Gtk::Entry* widget = manage(new Gtk::Entry());
widget->set_text(value.get_string());
@@ -382,8 +269,8 @@ PropertiesWindow::create_value_widget(const Raul::URI& uri, const Raul::Atom& va
return widget;
}
- _app->log().error(Raul::fmt("Unable to create widget for value %1%\n")
- % forge.str(value));
+ _app->log().error(Raul::fmt("Unable to create widget for value %1% type %2%\n")
+ % forge.str(value) % value.type());
return NULL;
}
@@ -483,19 +370,21 @@ PropertiesWindow::key_changed()
{
World* world = _app->world();
- const Gtk::ListStore::Row row = *(_key_combo->get_active());
- Glib::ustring prop_uri = row[_combo_columns.uri_col];
+ _value_store->clear();
+ const Gtk::ListStore::iterator iter = _key_combo->get_active();
+ if (!iter) {
+ return;
+ }
+
+ const Gtk::ListStore::Row row = *iter;
+ Glib::ustring prop_uri = row[_combo_columns.uri_col];
if (prop_uri.empty()) {
return;
}
- _value_store->clear();
-
LilvNode* rdfs_range = lilv_new_uri(
world->lilv_world(), LILV_NS_RDFS "range");
- LilvNode* rdf_type = lilv_new_uri(
- world->lilv_world(), LILV_NS_RDF "type");
LilvNode* prop = lilv_new_uri(
world->lilv_world(), prop_uri.c_str());
@@ -507,28 +396,13 @@ PropertiesWindow::key_changed()
LILV_FOREACH(nodes, r, range) {
ranges.insert(Raul::URI(lilv_node_as_string(lilv_nodes_get(range, r))));
}
- get_classes(world, ranges, false);
+ RDFS::classes(world, ranges, false);
// Get all objects in range
- typedef std::map<Raul::URI, Glib::ustring> Values;
- Values values;
- for (URISet::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
- LilvNode* range = lilv_new_uri(world->lilv_world(), i->c_str());
- LilvNodes* objects = lilv_world_find_nodes(
- world->lilv_world(), NULL, rdf_type, range);
- LILV_FOREACH(nodes, o, objects) {
- const LilvNode* object = lilv_nodes_get(objects, o);
- const Glib::ustring label = get_label(world, object);
- values.insert(
- std::make_pair(
- Raul::URI(lilv_node_as_string(object)),
- label));
- }
- lilv_node_free(range);
- }
+ RDFS::Objects values = RDFS::instances(world, ranges);
// Fill value selector with suitable objects
- for (Values::const_iterator i = values.begin(); i != values.end(); ++i) {
+ for (RDFS::Objects::const_iterator i = values.begin(); i != values.end(); ++i) {
if (!i->second.empty()) {
Gtk::ListStore::iterator vi = _value_store->append();
Gtk::ListStore::Row vrow = *vi;
@@ -538,7 +412,6 @@ PropertiesWindow::key_changed()
}
lilv_node_free(prop);
- lilv_node_free(rdf_type);
lilv_node_free(rdfs_range);
}
@@ -587,7 +460,7 @@ void
PropertiesWindow::ok_clicked()
{
apply_clicked();
- cancel_clicked();
+ Gtk::Window::hide();
}
} // namespace GUI