Merge branch 'feature/iSWA' of github.com:OpenSpace/OpenSpace-Development into feature/iSWA

data/scene/default.scene

@@ -30,18 +30,18 @@ function postInitialization()
 
     openspace.printInfo("Done setting default values")
 
-    --openspace.iswa.addCygnet(0,"z", "Kameleon");
-    --openspace.iswa.addCygnet(0,"y", "Kameleon");
     --openspace.iswa.addCygnet(0,"x", "Kameleon");
+    --openspace.iswa.addCygnet(0,"y", "Kameleon");
+    --openspace.iswa.addCygnet(0,"z", "Kameleon");
     
     --openspace.iswa.addCygnet(-4,"Data");
 
-    --openspace.iswa.addCygnet(-1,"Data");
+    --penspace.iswa.addCygnet(-1,"Data");
     --openspace.iswa.addCygnet(-2,"Data");
     --openspace.iswa.addCygnet(-3,"Data");
 
-    --openspace.iswa.addCygnet(-1,"Data","GM");
     --openspace.iswa.addCygnet(-2,"Data","GM");
+    --openspace.iswa.addCygnet(-1,"Data","GM");
     --openspace.iswa.addCygnet(-3,"Data","GM");
 
     openspace.iswa.addCdfFiles("${OPENSPACE_DATA}/cdflist.json");

modules/iswa/rendering/dataplane.cpp

@@ -109,29 +109,66 @@ bool DataPlane::initialize(){
     _dataOptions.onChange([this](){ loadTexture();} );
 
     _transferFunctionsFile.onChange([this](){
+        LDEBUG(name() + " Event setTransferFunctionsFileChanged");
         setTransferFunctions(_transferFunctionsFile.value());
     });
 
-    // IswaManager::ref().eventHandler().subscribe(name(), "ValueChanged", [](std::string message, int v){
-    //     std::cout << message << v << std::endl;
-    // });
+    _groupEvent->subscribe(name(), "enabledChanged", [&](const ghoul::Dictionary& dict){
+        LDEBUG(name() + " Event enabledChanged");
+        _enabled.setValue(dict.value<bool>("enabled"));
+    });
 
-    // IswaManager::ref().eventHandler().publish("ValueChanged", "High", 5);
 
-    // IswaManager::ref().eventHandler().unsubscribe(name());
+    _groupEvent->subscribe(name(), "useLogChanged", [&](const ghoul::Dictionary& dict){
+        LDEBUG(name() + " Event useLogChanged");
+        _useLog.setValue(dict.value<bool>("useLog"));
+    });
 
-    // IswaManager::ref().eventHandler().publish("ValueChanged", "High", 5);
+    _groupEvent->subscribe(name(), "normValuesChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event normValuesChanged");
+        std::shared_ptr<glm::vec2> values;
+        bool success = dict.getValue("normValues", values);
+        if(success){
+            _normValues.setValue(*values);            
+        }
+    });
+
+    _groupEvent->subscribe(name(), "useHistogramChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event useHistogramChanged");
+        _useHistogram.setValue(dict.value<bool>("useHistogram"));
+    });
+
+    _groupEvent->subscribe(name(), "dataOptionsChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event dataOptionsChanged");
+        std::shared_ptr<std::vector<int> > values;
+        bool success = dict.getValue("dataOptions", values);
+        if(success){
+            _dataOptions.setValue(*values);            
+        }
+    });
+
+    _groupEvent->subscribe(name(), "transferFunctionsChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event transferFunctionsChanged");
+        _transferFunctionsFile.setValue(dict.value<std::string>("transferFunctions"));
+    });
+
+    _groupEvent->subscribe(name(), "backgroundValuesChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event backgroundValuesChanged");
+        std::shared_ptr<glm::vec2> values;
+        bool success = dict.getValue("backgroundValues", values);
+        if(success){
+            _backgroundValues.setValue(*values);            
+        }
+    });
+
+    _groupEvent->subscribe(name(), "clearGroup", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event clearGroup");
+        OsEng.scriptEngine().queueScript("openspace.removeSceneGraphNode('" + name() + "')");
+    });
 
     return true;
 }
 
-void DataPlane::useLog(bool useLog){ _useLog.setValue(useLog); };
-void DataPlane::normValues(glm::vec2 normValues){  _normValues.setValue(normValues); };
-void DataPlane::useHistogram(bool useHistogram){ _useHistogram.setValue(useHistogram); };
-void DataPlane::dataOptions(std::vector<int> options){ _dataOptions.setValue(options); };
-void DataPlane::transferFunctionsFile(std::string tfPath){ _transferFunctionsFile.setValue(tfPath); };
-void DataPlane::backgroundValues(glm::vec2 backgroundValues){ _backgroundValues.setValue(backgroundValues); };
-
 bool DataPlane::loadTexture() {
 
     // if The future is done then get the new dataFile

modules/iswa/rendering/dataplane.h

@@ -42,14 +42,6 @@ friend class IswaGroup;
 
      bool initialize() override;
 
- protected:
-    virtual void useLog(bool useLog) override;
-    virtual void normValues(glm::vec2 normValues) override;
-    virtual void useHistogram(bool useHistogram) override;
-    virtual void dataOptions(std::vector<int> options) override;
-    virtual void transferFunctionsFile(std::string tfPath) override;
-    virtual void backgroundValues(glm::vec2 backgroundValues) override;
-
  private:
     virtual bool loadTexture() override;
     virtual bool updateTexture() override;

modules/iswa/rendering/datasphere.cpp

@@ -108,12 +108,12 @@ bool DataSphere::initialize(){
     return true;
 }
 
-void DataSphere::useLog(bool useLog){ _useLog.setValue(useLog); };
-void DataSphere::normValues(glm::vec2 normValues){  _normValues.setValue(normValues); };
-void DataSphere::useHistogram(bool useHistogram){ _useHistogram.setValue(useHistogram); };
-void DataSphere::dataOptions(std::vector<int> options){ _dataOptions.setValue(options); };
-void DataSphere::transferFunctionsFile(std::string tfPath){ _transferFunctionsFile.setValue(tfPath); };
-void DataSphere::backgroundValues(glm::vec2 backgroundValues){ _backgroundValues.setValue(backgroundValues); };
+// void DataSphere::useLog(bool useLog){ _useLog.setValue(useLog); };
+// void DataSphere::normValues(glm::vec2 normValues){  _normValues.setValue(normValues); };
+// void DataSphere::useHistogram(bool useHistogram){ _useHistogram.setValue(useHistogram); };
+// void DataSphere::dataOptions(std::vector<int> options){ _dataOptions.setValue(options); };
+// void DataSphere::transferFunctionsFile(std::string tfPath){ _transferFunctionsFile.setValue(tfPath); };
+// void DataSphere::backgroundValues(glm::vec2 backgroundValues){ _backgroundValues.setValue(backgroundValues); };
 
 bool DataSphere::loadTexture(){
     

modules/iswa/rendering/datasphere.h

@@ -42,12 +42,12 @@ public:
      bool initialize() override;
     
 protected:
-    virtual void useLog(bool useLog) override;
-    virtual void normValues(glm::vec2 normValues) override;
-    virtual void useHistogram(bool useHistogram) override;
-    virtual void dataOptions(std::vector<int> options) override;
-    virtual void transferFunctionsFile(std::string tfPath) override;
-    virtual void backgroundValues(glm::vec2 backgroundValues) override;
+    // virtual void useLog(bool useLog) override;
+    // virtual void normValues(glm::vec2 normValues) override;
+    // virtual void useHistogram(bool useHistogram) override;
+    // virtual void dataOptions(std::vector<int> options) override;
+    // virtual void transferFunctionsFile(std::string tfPath) override;
+    // virtual void backgroundValues(glm::vec2 backgroundValues) override;
 
 private:
     virtual bool loadTexture() override; 

modules/iswa/rendering/iswacygnet.cpp

@@ -37,6 +37,7 @@ IswaCygnet::IswaCygnet(const ghoul::Dictionary& dictionary)
     , _delete("delete", "Delete")
     , _shader(nullptr)
     ,_type(IswaManager::CygnetType::NoType)
+    ,_groupEvent()
     ,_group(nullptr)
     ,_textureDirty(false)
 {
@@ -111,7 +112,10 @@ bool IswaCygnet::initialize(){
     _textures.push_back(nullptr);
     
     if(!_data->groupName.empty()){
-        _group = IswaManager::ref().registerToGroup(_data->groupName, _type, this);
+        _groupEvent = IswaManager::ref().groupEvent(_data->groupName, _type);
+        _group = IswaManager::ref().registerToGroup(_data->groupName, _type);
+        std::cout << "Register groupEvent: " << (_groupEvent != nullptr) << std::endl;
+        std::cout << "Register group: " << (_group != nullptr) << std::endl;
     }
     
     initializeTime();
@@ -123,8 +127,10 @@ bool IswaCygnet::initialize(){
 }
 
 bool IswaCygnet::deinitialize(){
-    if(!_data->groupName.empty())
-        IswaManager::ref().unregisterFromGroup(_data->groupName, this);
+     if(!_data->groupName.empty())
+        _groupEvent->unsubscribe(name());
+    //     IswaManager::ref().unregisterFromGroup(_data->groupName, this);
+
 
     unregisterProperties();
     destroyGeometry();

modules/iswa/rendering/iswacygnet.h

@@ -30,6 +30,7 @@
 
 #include <memory>
 #include <chrono>
+#include <ghoul/designpattern/event.h>
 #include <openspace/properties/propertyowner.h>
 #include <modules/kameleon/include/kameleonwrapper.h>
 #include <openspace/properties/scalarproperty.h>
@@ -81,12 +82,12 @@ public:
     void update(const UpdateData& data) override;
 
 protected:
-    virtual void useLog(bool useLog){};
-    virtual void normValues(glm::vec2 normValues){};
-    virtual void useHistogram(bool useHistogram){};
-    virtual void dataOptions(std::vector<int> options){};
-    virtual void transferFunctionsFile(std::string tfPath){};
-    virtual void backgroundValues(glm::vec2 backgroundValues){};
+    // virtual void useLog(bool useLog){};
+    // virtual void normValues(glm::vec2 normValues){};
+    // virtual void useHistogram(bool useHistogram){};
+    // virtual void dataOptions(std::vector<int> options){};
+    // virtual void transferFunctionsFile(std::string tfPath){};
+    // virtual void backgroundValues(glm::vec2 backgroundValues){};
 
 
     void enabled(bool enabled){_enabled.setValue(enabled);};
@@ -125,6 +126,8 @@ protected:
     std::vector<std::shared_ptr<TransferFunction>> _transferFunctions;
     std::future<DownloadManager::MemoryFile> _futureObject;
 
+    std::shared_ptr<ghoul::Event<ghoul::Dictionary> > _groupEvent;
+
     std::shared_ptr<IswaGroup> _group;
 
     IswaManager::CygnetType _type;

modules/iswa/rendering/iswagroup.cpp

@@ -30,7 +30,7 @@ namespace {
 
 namespace openspace {
 
-IswaGroup::IswaGroup(std::string  name)
+IswaGroup::IswaGroup(std::string name, IswaManager::CygnetType type)
     :_enabled("enabled", "Enabled", true)
     ,_useLog("useLog","Use Logarithm", false)
     ,_useHistogram("_useHistogram", "Use Histogram", false)
@@ -40,7 +40,7 @@ IswaGroup::IswaGroup(std::string  name)
     ,_delete("delete", "Delete")
     ,_dataOptions("dataOptions", "Data Options")
     // ,_id(id)
-    ,_type(IswaManager::CygnetType::NoType)
+    ,_type(type)
     // ,_dataProcessor(nullptr)
 {
     setName(name);
@@ -61,50 +61,37 @@ IswaGroup::IswaGroup(std::string  name)
             _useHistogram.value(),
             _normValues
     );
+    _groupEvent = std::make_shared<ghoul::Event<ghoul::Dictionary> >();
+    registerProperties();
 }
 
 IswaGroup::~IswaGroup(){
-    _cygnets.clear();
+    //_cygnets.clear();
 }
 
-void IswaGroup::registerCygnet(IswaCygnet* cygnet, IswaManager::CygnetType type){
-    if(_cygnets.empty()){
-        _type = type;
-        registerProperties();
-    }
+// void IswaGroup::registerCygnet(IswaCygnet* cygnet, IswaManager::CygnetType type){
+//     if(_cygnets.empty()){
+//         _type = type;
+//         registerProperties();
+//     }
 
-    if(type != _type){
-        LWARNING("Can't register cygnet with a different type from the group");
-        return;
-    }
+//     if(type != _type){
+//         LWARNING("Can't register cygnet with a different type from the group");
+//         return;
+//     }
 
-    if(type == IswaManager::CygnetType::Data){
-        DataPlane* dataplane = static_cast<DataPlane*>(cygnet);
+//     if(type == IswaManager::CygnetType::Data){
+//         DataPlane* dataplane = static_cast<DataPlane*>(cygnet);
         
-        dataplane->useLog(_useLog.value());
-        dataplane->useHistogram(_useHistogram.value());
-        dataplane->normValues(_normValues.value());
-        dataplane->backgroundValues(_backgroundValues.value());
-        dataplane->transferFunctionsFile(_transferFunctionsFile.value());
-        dataplane->dataOptions(_dataOptions.value());
-    }
-    _cygnets.push_back(cygnet);
-}
-
-void IswaGroup::unregisterCygnet(IswaCygnet* cygnet){
-    auto it = std::find(
-        _cygnets.begin(),
-        _cygnets.end(),
-        cygnet
-        );
-
-    if(it != _cygnets.end())
-        _cygnets.erase(it);
-
-    if(_cygnets.empty())
-        unregisterProperties();
-}
-
+//         dataplane->useLog(_useLog.value());
+//         dataplane->useHistogram(_useHistogram.value());
+//         dataplane->normValues(_normValues.value());
+//         dataplane->backgroundValues(_backgroundValues.value());
+//         dataplane->transferFunctionsFile(_transferFunctionsFile.value());
+//         dataplane->dataOptions(_dataOptions.value());
+//     }
+//     _cygnets.push_back(cygnet);
+// }
 
 void IswaGroup::registerOptions(const std::vector<properties::SelectionProperty::Option>& options){
     if(_type == IswaManager::CygnetType::Data){
@@ -120,12 +107,10 @@ void IswaGroup::registerOptions(const std::vector<properties::SelectionProperty:
             }
             _dataOptions.setValue(std::vector<int>(1,0));
         }
-        for(auto cygnet : _cygnets)
-            static_cast<DataPlane*>(cygnet)->dataOptions(_dataOptions.value());
     }
 }
 
-bool IswaGroup::checkType(IswaManager::CygnetType type){
+bool IswaGroup::isType(IswaManager::CygnetType type){
     if(_type == IswaManager::CygnetType::NoType) return true;
     return (_type == type);
 }
@@ -134,8 +119,8 @@ void IswaGroup::registerProperties(){
     OsEng.gui()._iswa.registerProperty(&_enabled);
 
     _enabled.onChange([this]{
-        for(auto cygnet : _cygnets)
-            cygnet->enabled(_enabled.value());
+        LDEBUG("Group " + name() + " published enabledChanged");
+        _groupEvent->publish("enabledChanged", ghoul::Dictionary({{"enabled", _enabled.value()}}));
     });
 
 
@@ -148,36 +133,35 @@ void IswaGroup::registerProperties(){
         OsEng.gui()._iswa.registerProperty(&_dataOptions);
 
         _useLog.onChange([this]{
-            for(auto cygnet : _cygnets)
-                cygnet->useLog(_useLog.value());
+            LDEBUG("Group " + name() + " published useLogChanged");
+            _groupEvent->publish("useLogChanged", ghoul::Dictionary({{"useLog", _useLog.value()}}));
         });
 
         _useHistogram.onChange([this]{
-            for(auto cygnet : _cygnets)
-                cygnet->useHistogram(_useHistogram.value());
+            LDEBUG("Group " + name() + " published useHistogramChanged");
+            _groupEvent->publish("useHistogramChanged", ghoul::Dictionary({{"useHistogram", _useHistogram.value()}}));
         });
 
         _normValues.onChange([this]{
-            for(auto cygnet : _cygnets)
-                cygnet->normValues(_normValues.value());
+            LDEBUG("Group " + name() + " published normValuesChanged");
+            _groupEvent->publish("normValuesChanged", ghoul::Dictionary({{"normValues", std::make_shared<glm::vec2>(_normValues.value())}}));
         });
 
         _backgroundValues.onChange([this]{
-            for(auto cygnet : _cygnets)
-                cygnet->backgroundValues(_backgroundValues.value());
+            LDEBUG("Group " + name() + " published backgroundValuesChanged");
+            _groupEvent->publish("backgroundValuesChanged", ghoul::Dictionary({{"backgroundValues", std::make_shared<glm::vec2>(_backgroundValues.value())}}));
         });
 
         _transferFunctionsFile.onChange([this]{
-            for(auto cygnet : _cygnets)
-                cygnet->transferFunctionsFile(_transferFunctionsFile.value());
+            LDEBUG("Group " + name() + " published transferFunctionsChanged");
+            _groupEvent->publish("transferFunctionsChanged", ghoul::Dictionary({{"transferFunctions", _transferFunctionsFile.value()}}));
         });
 
 
         _dataOptions.onChange([this]{
-            for(auto cygnet : _cygnets)
-                cygnet->dataOptions(_dataOptions.value());
+            LDEBUG("Group " + name() + " published dataOptionsChanged");
+            _groupEvent->publish("dataOptionsChanged", ghoul::Dictionary({{"dataOptions", std::make_shared<std::vector<int> >(_dataOptions.value())}}));
         });
-
     }
 
     OsEng.gui()._iswa.registerProperty(&_delete);
@@ -193,10 +177,7 @@ void IswaGroup::unregisterProperties(){
 }
 
 void IswaGroup::clearGroup(){
-    for(auto it = _cygnets.begin(); it != _cygnets.end();){
-        OsEng.scriptEngine().queueScript("openspace.removeSceneGraphNode('" + (*it)->name() + "')");
-        it = _cygnets.erase(it);
-    }
+    _groupEvent->publish("clearGroup", ghoul::Dictionary());
     unregisterProperties();
 }
 

modules/iswa/rendering/iswagroup.h

@@ -25,6 +25,7 @@
 #ifndef __ISWAGROUP_H__
 #define __ISWAGROUP_H__
 
+#include <ghoul/designpattern/event.h>
 #include <openspace/properties/propertyowner.h>
 #include <openspace/properties/selectionproperty.h>
 #include <openspace/properties/vectorproperty.h>
@@ -41,14 +42,14 @@ class IswaCygnet;
 
 class IswaGroup : public properties::PropertyOwner{
 public:
-	IswaGroup(std::string name);
+	IswaGroup(std::string name, IswaManager::CygnetType type);
 	~IswaGroup();
-	void registerCygnet(IswaCygnet* cygnet, IswaManager::CygnetType type);
-	void unregisterCygnet(IswaCygnet* cygnet);
+	//void registerCygnet(IswaCygnet* cygnet, IswaManager::CygnetType type);
+	//void unregisterCygnet(IswaCygnet* cygnet);
 	void registerOptions(const std::vector<properties::SelectionProperty::Option>& options);
-	bool checkType(IswaManager::CygnetType type);
+	bool isType(IswaManager::CygnetType type);
 	void clearGroup();
-
+	std::shared_ptr<ghoul::Event<ghoul::Dictionary> > groupEvent(){ return _groupEvent; };
 	std::shared_ptr<DataProcessor> dataProcessor();
 
 	// bool useLog(){return _useLog.value();};
@@ -79,9 +80,9 @@ private:
 	// int groupId;
 	// IswaCygnet cygnet;
 	int _id;
-
+	std::shared_ptr<ghoul::Event<ghoul::Dictionary> > _groupEvent;
     std::shared_ptr<DataProcessor> _dataProcessor;
-	std::vector<IswaCygnet* > _cygnets;
+	//std::vector<IswaCygnet* > _cygnets;
 	IswaManager::CygnetType _type;
 };
 

modules/iswa/rendering/kameleonplane.cpp

@@ -124,7 +124,10 @@ bool KameleonPlane::initialize(){
     
 
     if(!_data->groupName.empty()){
-        _group = IswaManager::ref().registerToGroup(_data->groupName, _type, this);
+        _groupEvent = IswaManager::ref().groupEvent(_data->groupName, _type);
+        std::cout << "Register groupEvent: " << (_groupEvent != nullptr) << std::endl;
+        _group = IswaManager::ref().registerToGroup(_data->groupName, _type);
+        std::cout << "Register group " << (_group != nullptr) << std::endl;
     }
     
     initializeTime();
@@ -182,20 +185,70 @@ bool KameleonPlane::initialize(){
         updateTexture();
     });
 
-    fillOptions();
+    _transferFunctionsFile.onChange([this](){
+        LDEBUG(name() + " Event setTransferFunctionsFileChanged");
+        setTransferFunctions(_transferFunctionsFile.value());
+    });
 
+    _groupEvent->subscribe(name(), "enabledChanged", [&](const ghoul::Dictionary& dict){
+        LDEBUG(name() + " Event enabledChanged");
+        _enabled.setValue(dict.value<bool>("enabled"));
+    });
+
+
+    _groupEvent->subscribe(name(), "useLogChanged", [&](const ghoul::Dictionary& dict){
+        LDEBUG(name() + " Event useLogChanged");
+        _useLog.setValue(dict.value<bool>("useLog"));
+    });
+
+    _groupEvent->subscribe(name(), "normValuesChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event normValuesChanged");
+        std::shared_ptr<glm::vec2> values;
+        bool success = dict.getValue("normValues", values);
+        if(success){
+            _normValues.setValue(*values);            
+        }
+    });
+
+    _groupEvent->subscribe(name(), "useHistogramChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event useHistogramChanged");
+        _useHistogram.setValue(dict.value<bool>("useHistogram"));
+    });
+
+    _groupEvent->subscribe(name(), "dataOptionsChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event dataOptionsChanged");
+        std::shared_ptr<std::vector<int> > values;
+        bool success = dict.getValue("dataOptions", values);
+        if(success){
+            _dataOptions.setValue(*values);            
+        }
+    });
+
+    _groupEvent->subscribe(name(), "transferFunctionsChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event transferFunctionsChanged");
+        _transferFunctionsFile.setValue(dict.value<std::string>("transferFunctions"));
+    });
+
+    _groupEvent->subscribe(name(), "backgroundValuesChanged", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event backgroundValuesChanged");
+        std::shared_ptr<glm::vec2> values;
+        bool success = dict.getValue("backgroundValues", values);
+        if(success){
+            _backgroundValues.setValue(*values);            
+        }
+    });
+
+    _groupEvent->subscribe(name(), "clearGroup", [&](ghoul::Dictionary dict){
+        LDEBUG(name() + " Event clearGroup");
+        OsEng.scriptEngine().queueScript("openspace.removeSceneGraphNode('" + name() + "')");
+    });
+
+    fillOptions();
     updateTexture();
 
 	return true;
 }
 
-void KameleonPlane::useLog(bool useLog){ _useLog.setValue(useLog); };
-void KameleonPlane::normValues(glm::vec2 normValues){  _normValues.setValue(normValues); };
-void KameleonPlane::useHistogram(bool useHistogram){ _useHistogram.setValue(useHistogram); };
-void KameleonPlane::dataOptions(std::vector<int> options){ _dataOptions.setValue(options); };
-void KameleonPlane::transferFunctionsFile(std::string tfPath){ _transferFunctionsFile.setValue(tfPath); };
-void KameleonPlane::backgroundValues(glm::vec2 backgroundValues){ _backgroundValues.setValue(backgroundValues); };
-
 bool KameleonPlane::loadTexture() {
     std::vector<int> selectedOptions = _dataOptions.value();
     auto options = _dataOptions.options();

modules/iswa/rendering/kameleonplane.h

@@ -40,13 +40,6 @@
 
      bool initialize() override;
     
- protected:
-    virtual void useLog(bool useLog) override;
-    virtual void normValues(glm::vec2 normValues) override;
-    virtual void useHistogram(bool useHistogram) override;
-    virtual void dataOptions(std::vector<int> options) override;
-    virtual void transferFunctionsFile(std::string tfPath) override;
-    virtual void backgroundValues(glm::vec2 backgroundValues) override;
     
  private:
  	virtual bool loadTexture() override;

modules/iswa/util/iswamanager.cpp

@@ -212,21 +212,36 @@ std::string IswaManager::iswaUrl(int id, std::string type){
     return url;
 }
 
-std::shared_ptr<IswaGroup> IswaManager::registerToGroup(std::string name, CygnetType type, IswaCygnet* cygnet){
-    if(_groups.find(name) == _groups.end()){
-        _groups.insert(std::pair<std::string, std::shared_ptr<IswaGroup>>(name, std::make_shared<IswaGroup>(name)));
+std::shared_ptr<ghoul::Event<ghoul::Dictionary> > IswaManager::groupEvent(std::string groupName, CygnetType type){
+
+    // Do some type checking and get the groupEvent
+    if(_groups.find(groupName) == _groups.end()){
+        _groups.insert(std::pair<std::string, std::shared_ptr<IswaGroup>>(groupName, std::make_shared<IswaGroup>(groupName, type)));
+    } else if(!_groups[groupName]->isType(type)){
+        LWARNING("Can't subscribe to Events from groups with diffent type");
+        return nullptr;
     }
 
-    _groups[name]->registerCygnet(cygnet, type);
-    return _groups[name];
+    return _groups[groupName]->groupEvent();
 }
 
-void IswaManager::unregisterFromGroup(std::string name, IswaCygnet* cygnet){
-    if(_groups.find(name) != _groups.end()){
-        _groups[name]->unregisterCygnet(cygnet);
+std::shared_ptr<IswaGroup> IswaManager::registerToGroup(std::string groupName, CygnetType type){
+    if(_groups.find(groupName) == _groups.end()){
+        _groups.insert(std::pair<std::string, std::shared_ptr<IswaGroup>>(groupName, std::make_shared<IswaGroup>(groupName, type)));
+    } else if(!_groups[groupName]->isType(type)){
+        LWARNING("Can't subscribe to Events from groups with diffent type");
+        return nullptr;
     }
+
+    return _groups[groupName];
 }
 
+// void IswaManager::unregisterFromGroup(std::string name, IswaCygnet* cygnet){
+//     if(_groups.find(name) != _groups.end()){
+//         _groups[name]->unregisterCygnet(cygnet);
+//     }
+// }
+
 void IswaManager::registerOptionsToGroup(std::string name, const std::vector<properties::SelectionProperty::Option>& options){
     if(_groups.find(name) != _groups.end()){
         _groups[name]->registerOptions(options);
@@ -439,7 +454,7 @@ void IswaManager::createPlane(std::shared_ptr<MetadataFuture> data){
 
     if(!data->group.empty()){
         auto it = _groups.find(data->group);
-        if(it == _groups.end() || (*it).second->checkType((CygnetType) data->type))
+        if(it == _groups.end() || (*it).second->isType((CygnetType) data->type))
             name += "_" + data->group;
     }
 
@@ -463,7 +478,7 @@ void IswaManager::createSphere(std::shared_ptr<MetadataFuture> data){
 
     if(!data->group.empty()){
         auto it = _groups.find(data->group);
-        if(it == _groups.end() || (*it).second->checkType((CygnetType) data->type))
+        if(it == _groups.end() || (*it).second->isType((CygnetType) data->type))
             name += "_" + data->group;
     }
 

modules/iswa/util/iswamanager.h

@@ -93,7 +93,8 @@ public:
     std::future<DownloadManager::MemoryFile> fetchDataCygnet(int id);
     std::string iswaUrl(int id, std::string type = "image");
 
-    std::shared_ptr<IswaGroup> registerToGroup(std::string name, CygnetType type, IswaCygnet* cygnet);
+    std::shared_ptr<ghoul::Event<ghoul::Dictionary> > groupEvent(std::string name, CygnetType type);
+    std::shared_ptr<IswaGroup> registerToGroup(std::string name, CygnetType type);
     void unregisterFromGroup(std::string name, IswaCygnet* cygnet);
     void registerOptionsToGroup(std::string name, const std::vector<properties::SelectionProperty::Option>& options);
     std::shared_ptr<IswaGroup> iswaGroup(std::string name);
@@ -105,7 +106,7 @@ public:
 
     static scripting::ScriptEngine::LuaLibrary luaLibrary();
 
-    ghoul::Event<std::string, int>& iswaEvent(){
+    ghoul::Event<>& iswaEvent(){
         return _iswaEvent;
     }
 
@@ -135,7 +136,7 @@ private:
     // std::vector<CdfInfo> _cdfInformation;
     std::map<std::string, std::vector<CdfInfo>> _cdfInformation;
 
-    ghoul::Event<std::string, int> _iswaEvent;
+    ghoul::Event<> _iswaEvent;
 
 };