diff --git a/modules/iswa/rendering/dataplane.cpp b/modules/iswa/rendering/dataplane.cpp
index fd78a311c6..220634181d 100644
--- a/modules/iswa/rendering/dataplane.cpp
+++ b/modules/iswa/rendering/dataplane.cpp
@@ -74,7 +74,6 @@ bool DataPlane::initialize(){
     IswaCygnet::initialize();
 
     if(_group){
-        std::cout << "add to group" << std::endl;
         _dataProcessor = _group->dataProcessor();
     }else{
         OsEng.gui()._iswa.registerProperty(&_useLog);
@@ -110,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
diff --git a/modules/iswa/rendering/dataplane.h b/modules/iswa/rendering/dataplane.h
index b9548d35e9..0df396ce4c 100644
--- a/modules/iswa/rendering/dataplane.h
+++ b/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;
diff --git a/modules/iswa/rendering/datasphere.cpp b/modules/iswa/rendering/datasphere.cpp
index f77c0dec1e..5bc310f7c4 100644
--- a/modules/iswa/rendering/datasphere.cpp
+++ b/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(){
     
diff --git a/modules/iswa/rendering/datasphere.h b/modules/iswa/rendering/datasphere.h
index 629194cd83..d4062df57e 100644
--- a/modules/iswa/rendering/datasphere.h
+++ b/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; 
diff --git a/modules/iswa/rendering/iswacygnet.cpp b/modules/iswa/rendering/iswacygnet.cpp
index 2703482d10..2b6bbae820 100644
--- a/modules/iswa/rendering/iswacygnet.cpp
+++ b/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)
 {
     _data = std::make_shared<Metadata>();
@@ -110,8 +111,10 @@ bool IswaCygnet::initialize(){
     _textures.push_back(nullptr);
     
     if(!_data->groupName.empty()){
-        _group = IswaManager::ref().registerToGroup(_data->groupName, _type, this);
-        std::cout << "Register group " << (_group != nullptr) << std::endl;
+        _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();
@@ -124,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();
diff --git a/modules/iswa/rendering/iswacygnet.h b/modules/iswa/rendering/iswacygnet.h
index bcb027df6b..d482f33160 100644
--- a/modules/iswa/rendering/iswacygnet.h
+++ b/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;
diff --git a/modules/iswa/rendering/iswagroup.cpp b/modules/iswa/rendering/iswagroup.cpp
index 2958a53bc0..ee839feb10 100644
--- a/modules/iswa/rendering/iswagroup.cpp
+++ b/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", true)
@@ -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();
 }
 
diff --git a/modules/iswa/rendering/iswagroup.h b/modules/iswa/rendering/iswagroup.h
index 424ceda866..3acec78224 100644
--- a/modules/iswa/rendering/iswagroup.h
+++ b/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;
 };
 
diff --git a/modules/iswa/rendering/kameleonplane.cpp b/modules/iswa/rendering/kameleonplane.cpp
index de00077ba4..6a8dff2520 100644
--- a/modules/iswa/rendering/kameleonplane.cpp
+++ b/modules/iswa/rendering/kameleonplane.cpp
@@ -119,7 +119,9 @@ bool KameleonPlane::initialize(){
     _textures.push_back(nullptr);
     
     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;
     }
     
@@ -177,17 +179,68 @@ bool KameleonPlane::initialize(){
         updateTexture();
     });
 
+    _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() + "')");
+    });
+
     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::cout << "loadTexture()" << std::endl;
 
diff --git a/modules/iswa/rendering/kameleonplane.h b/modules/iswa/rendering/kameleonplane.h
index f04a1833a9..74293115ef 100644
--- a/modules/iswa/rendering/kameleonplane.h
+++ b/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;
diff --git a/modules/iswa/util/iswamanager.cpp b/modules/iswa/util/iswamanager.cpp
index 7e3d13f8e8..9c5e771d4b 100644
--- a/modules/iswa/util/iswamanager.cpp
+++ b/modules/iswa/util/iswamanager.cpp
@@ -203,21 +203,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);
@@ -431,7 +446,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;
     }
 
@@ -455,7 +470,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;
     }
 
diff --git a/modules/iswa/util/iswamanager.h b/modules/iswa/util/iswamanager.h
index 72b1e484ab..56cc5fae9f 100644
--- a/modules/iswa/util/iswamanager.h
+++ b/modules/iswa/util/iswamanager.h
@@ -84,7 +84,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);
@@ -94,7 +95,7 @@ public:
 
     static scripting::ScriptEngine::LuaLibrary luaLibrary();
 
-    ghoul::Event<std::string, int>& iswaEvent(){
+    ghoul::Event<>& iswaEvent(){
         return _iswaEvent;
     }
 
@@ -121,7 +122,7 @@ private:
     std::map<std::string, std::shared_ptr<IswaGroup>> _groups;
     std::map<int, std::shared_ptr<CygnetInfo>> _cygnetInformation;
 
-    ghoul::Event<std::string, int> _iswaEvent;
+    ghoul::Event<> _iswaEvent;
 
 };