Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 026bef57c11cf9d09d87056dab378f0b357f2a4c)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -29,4 +29,5 @@
 
 class GLWorldScene;
+class QtInstanceInformationBoard;
 
 class GLMoleculeObject_atom : public GLMoleculeObject, Observer
@@ -108,4 +109,5 @@
 
 private:
+  friend class QtInstanceInformationBoard;
   /** Observed Values **/
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 026bef57c11cf9d09d87056dab378f0b357f2a4c)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -34,4 +34,5 @@
 class GLMoleculeObject_atom;
 class GLWorldScene;
+class QtInstanceInformationBoard;
 
 class GLMoleculeObject_molecule : public GLMoleculeObject, public Observer
@@ -147,4 +148,5 @@
 
 private:
+  friend class QtInstanceInformationBoard;
   /** Observed Values **/
 
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 026bef57c11cf9d09d87056dab378f0b357f2a4c)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -49,4 +49,5 @@
 #include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_shape.hpp"
 
+#include "UIElements/Views/Qt4/QtInstanceInformationBoard.hpp"
 #include "UIElements/Views/Qt4/QtSelectionChangedAgent.hpp"
 
@@ -72,7 +73,10 @@
 using namespace MoleCuilder;
 
-GLWorldScene::GLWorldScene(QObject *parent) :
-    QObject(parent),
-    selectionMode(SelectAtom)
+GLWorldScene::GLWorldScene(
+    QtInstanceInformationBoard * _board,
+    QObject *parent) :
+  QObject(parent),
+  selectionMode(SelectAtom),
+  board(_board)
 {
   int sphereDetails[] = {5, 3, 2, 0};
@@ -90,4 +94,12 @@
     GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
+  connect(board, SIGNAL(moleculeIndexChanged(const moleculeId_t, const moleculeId_t)),
+      this, SLOT(moleculeIndexChanged(const moleculeId_t, const moleculeId_t)));
+  connect(board, SIGNAL(moleculeInserted(const moleculeId_t)),
+      this, SLOT(moleculeInserted(const moleculeId_t)));
+  connect(board, SIGNAL(moleculeRemoved(const moleculeId_t)),
+      this, SLOT(moleculeRemoved(const moleculeId_t)));
+  connect(board, SIGNAL(moleculeIndexChanged(const moleculeId_t, const moleculeId_t)),
+      this, SLOT(moleculeIndexChanged(const moleculeId_t, const moleculeId_t)));
 
 //  connect(this, SIGNAL(updated()), this, SLOT(update()));
@@ -359,4 +371,23 @@
 }
 
+void GLWorldScene::moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid)
+{
+  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_oldid);
+  if ( iter == MoleculesinSceneMap.end()) {
+    RemovalMolecule_t::iterator removeiter =
+        RemovalMolecules.find(_oldid);
+    ASSERT( removeiter != RemovalMolecules.end(),
+        "GLWorldScene::moleculeIndexChanged() - cannot find id "+toString(_oldid)+" in any map.");
+    RemovalMolecules.erase(removeiter);
+    RemovalMolecules.insert(_newid);
+  } else {
+    LOG(1, "DEBUG: Changing GLMoleculeObject_molecule from " << _oldid << " to id " << _newid);
+    GLMoleculeObject_molecule* molObject = iter->second;
+    MoleculesinSceneMap.erase(iter);
+    MoleculesinSceneMap.insert(
+        std::make_pair( _newid, molObject) );
+  }
+}
+
 void GLWorldScene::moleculesVisibilityChanged(const moleculeId_t _id, bool _visible)
 {
@@ -506,8 +537,9 @@
   boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
+  // use direct connection as it's lightweight and we avoid index change troubles
   if (iter != MoleculesinSceneMap.end())
     QMetaObject::invokeMethod(iter->second,        // pointer to a QObject
                             "AtomSelected",       // member name (no parameters here)
-                            Qt::QueuedConnection,     // connection type
+                            Qt::DirectConnection,     // connection type
                             Q_ARG(const atomId_t, _id));     // parameters
   else
@@ -520,8 +552,9 @@
   boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
+  // use direct connection as it's lightweight and we avoid index change troubles
   if (iter != MoleculesinSceneMap.end())
     QMetaObject::invokeMethod(iter->second,        // pointer to a QObject
                             "AtomUnselected",       // member name (no parameters here)
-                            Qt::QueuedConnection,     // connection type
+                            Qt::DirectConnection,     // connection type
                             Q_ARG(const atomId_t, _id));     // parameters
   else
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 026bef57c11cf9d09d87056dab378f0b357f2a4c)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -41,4 +41,6 @@
 class QtSelectionChangedAgent;
 
+class QtInstanceInformationBoard;
+
 /** This class contains a list of all molecules in the world.
  *
@@ -48,5 +50,7 @@
   Q_OBJECT
 public:
-  GLWorldScene(QObject *parent=0);
+  GLWorldScene(
+      QtInstanceInformationBoard * _board,
+      QObject *parent=0);
   virtual ~GLWorldScene();
 
@@ -88,4 +92,5 @@
   void moleculeRemoved(const moleculeId_t _id);
   void moleculeInserted(const moleculeId_t _id);
+  void moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid);
   void atomRemoved(const moleculeId_t _molid, const atomId_t _atomid);
   void atomInserted(const moleculeId_t _molid, const atomId_t _atomid);
@@ -133,4 +138,6 @@
 
   SelectionModeType selectionMode;
+
+  QtInstanceInformationBoard * board;
 };
 
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 026bef57c11cf9d09d87056dab378f0b357f2a4c)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -65,8 +65,14 @@
 #include "WorldTime.hpp"
 
-GLWorldView::GLWorldView(QWidget *parent)
-  : QGLView(parent), Observer("GLWorldView"), worldscene(NULL), changesPresent(false), needsRedraw(false)
-{
-  worldscene = new GLWorldScene(this);
+GLWorldView::GLWorldView(
+    QtInstanceInformationBoard * _board,
+    QWidget *parent) :
+  QGLView(parent),
+  Observer("GLWorldView"),
+  worldscene(NULL),
+  changesPresent(false),
+  needsRedraw(false)
+{
+  worldscene = new GLWorldScene(_board, this);
 
   setOption(QGLView::ObjectPicking, true);
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp	(revision 026bef57c11cf9d09d87056dab378f0b357f2a4c)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -28,4 +28,6 @@
 class QtSelectionChangedAgent;
 
+class QtInstanceInformationBoard;
+
 /** This class is the view on the 3D representation of the World, i.e. the whole
  * of all molecules (consisting of atoms).
@@ -36,5 +38,7 @@
   Q_OBJECT
 public:
-  GLWorldView(QWidget *parent=0);
+  GLWorldView(
+      QtInstanceInformationBoard * _board,
+      QWidget *parent=0);
   virtual ~GLWorldView();
 
Index: src/UIElements/Views/Qt4/QtInstanceInformationBoard.cpp
===================================================================
--- src/UIElements/Views/Qt4/QtInstanceInformationBoard.cpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
+++ src/UIElements/Views/Qt4/QtInstanceInformationBoard.cpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -0,0 +1,405 @@
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2015 Frederik Heber. All rights reserved.
+ *
+ *
+ *   This file is part of MoleCuilder.
+ *
+ *    MoleCuilder is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    MoleCuilder is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * QtInstanceInformationBoard.cpp
+ *
+ *  Created on: Oct 17, 2015
+ *      Author: heber
+ */
+
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "QtInstanceInformationBoard.hpp"
+
+#include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp"
+#include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp"
+
+#include "CodePatterns/MemDebug.hpp"
+
+#include "CodePatterns/Log.hpp"
+
+#include "Atom/atom.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "molecule.hpp"
+#include "World.hpp"
+
+QtInstanceInformationBoard::QtInstanceInformationBoard(QWidget * _parent) :
+  QWidget(_parent),
+  Observer("QtInstanceInformationBoard"),
+  WorldSignedOn(false),
+  atomSubjectKilled(
+      boost::bind(&QtInstanceInformationBoard::atomcountsubjectKilled, this, _1)),
+  moleculeSubjectKilled(
+      boost::bind(&QtInstanceInformationBoard::moleculecountsubjectKilled, this, _1)),
+  lastremovedatom((atomId_t)-1),
+  lastremovedmolecule((moleculeId_t)-1)
+{
+  // be first (besides ObservedValues to know about new insertions)
+  World::getInstance().signOn(this, World::AtomInserted, GlobalObservableInfo::PriorityLevel(int(-10)));
+  World::getInstance().signOn(this, World::AtomRemoved, GlobalObservableInfo::PriorityLevel(int(-10)));
+  World::getInstance().signOn(this, World::MoleculeInserted, GlobalObservableInfo::PriorityLevel(int(-10)));
+  World::getInstance().signOn(this, World::MoleculeRemoved, GlobalObservableInfo::PriorityLevel(int(-10)));
+  WorldSignedOn = true;
+}
+
+QtInstanceInformationBoard::~QtInstanceInformationBoard()
+{
+  if (WorldSignedOn) {
+    World::getInstance().signOff(this, World::AtomInserted);
+    World::getInstance().signOff(this, World::AtomRemoved);
+    World::getInstance().signOff(this, World::MoleculeInserted);
+    World::getInstance().signOff(this, World::MoleculeRemoved);
+  }
+  // sign off from all remaining molecules and atoms
+  for (SignedOn_t::iterator iter = AtomSignedOn.begin(); !AtomSignedOn.empty();
+      iter = AtomSignedOn.begin()) {
+    (*iter)->signOff(this, atom::IndexChanged);
+    AtomSignedOn.erase(iter);
+  }
+
+  for (SignedOn_t::iterator iter = MoleculeSignedOn.begin(); !MoleculeSignedOn.empty();
+      iter = MoleculeSignedOn.begin()) {
+    (*iter)->signOff(this, molecule::IndexChanged);
+    MoleculeSignedOn.erase(iter);
+  }
+}
+
+void QtInstanceInformationBoard::update(Observable *publisher)
+{
+  ASSERT(0,
+      "QtInstanceInformationBoard::update() - we are not signed on to general updates.");
+}
+
+void QtInstanceInformationBoard::subjectKilled(Observable *publisher)
+{
+  SignedOn_t::iterator iter = AtomSignedOn.find(publisher);
+  if ( iter != AtomSignedOn.end()) {
+    LOG(3, "DEBUG: InstanceBoard got subjectKilled() from atom " << publisher);
+    AtomSignedOn.erase(iter);
+  } else {
+    iter = MoleculeSignedOn.find(publisher);
+    if ( iter != MoleculeSignedOn.end()) {
+      LOG(3, "DEBUG: InstanceBoard got subjectKilled() from molecule " << publisher);
+      MoleculeSignedOn.erase(iter);
+    } else {
+      ASSERT(0,
+          "QtObservedInstanceBoard::subjectKilled() - could not find signedOn for atom/molecule "+toString(publisher));
+    }
+  }
+}
+
+void QtInstanceInformationBoard::recieveNotification(Observable *publisher, Notification_ptr notification)
+{
+  if (static_cast<World *>(publisher) == World::getPointer()) {
+    switch (notification->getChannelNo()) {
+      case World::MoleculeInserted:
+      {
+        const moleculeId_t _id = const_cast<const World &>(World::getInstance()).lastChangedMolId();
+  #ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that molecule "+toString(_id)+" has been inserted.";
+  #endif
+        LOG(3, "DEBUG: InformationBoard got moleculeInserted signal for molecule " << _id);
+        const molecule * const _molecule = const_cast<const World &>(World::getInstance()).
+            getMolecule(MoleculeById(_id));
+        if (_molecule != NULL) {
+          ObservedValues_t ObservedValues(GLMoleculeObject_molecule::MAX_ObservedTypes);
+          LOG(3, "DEBUG: InformationBoard initializes ObservedValues for molecule " << _id);
+          GLMoleculeObject_molecule::initObservedValues(
+              ObservedValues,
+              _id,
+              _molecule,
+              moleculeSubjectKilled);
+#ifndef NDEBUG
+          std::pair<moleculeObservedValues_t::iterator, bool> inserter =
+#endif
+              moleculeObservedValues.insert(
+                  std::make_pair( _id, ObservedValues));
+          ASSERT( inserter.second,
+              "QtInstanceInformationBoard::recieveNotification() - could not insert ObservedValues for"
+              +toString(_id)+".");
+          // we need to check for index changes
+          LOG(3, "DEBUG: InformationBoard signOn()s to molecule " << _id);
+          _molecule->signOn(this, molecule::IndexChanged);
+          MoleculeSignedOn.insert( static_cast<Observable *>(const_cast<molecule *>(_molecule)) );
+
+          emit moleculeInserted(_id);
+        } else {
+          ELOG(1, "QtInstanceInformationBoard got MoleculeInserted for unknown molecule id " << _id);
+        }
+        break;
+      }
+      case World::MoleculeRemoved:
+      {
+        const moleculeId_t _id = const_cast<const World &>(World::getInstance()).lastChangedMolId();
+        LOG(3, "DEBUG: InformationBoard got MoleculeRemoved signal for molecule " << _id);
+        // note down such that ObservedValues are simply dropped
+        lastremovedmolecule = _id;
+        break;
+      }
+      case World::AtomInserted:
+      {
+        const atomId_t _id = const_cast<const World &>(World::getInstance()).lastChangedAtomId();
+  #ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been inserted.";
+  #endif
+        LOG(3, "DEBUG: InformationBoard got atomInserted signal for atom " << _id);
+        const atom * const _atom = const_cast<const World &>(World::getInstance()).
+            getAtom(AtomById(_id));
+        if (_atom!= NULL) {
+          ObservedValues_t ObservedValues(GLMoleculeObject_atom::MAX_ObservedTypes);
+          LOG(3, "DEBUG: InformationBoard initializes ObservedValues for atom " << _id);
+          GLMoleculeObject_atom::initObservedValues(
+              ObservedValues,
+              _id,
+              _atom,
+              atomSubjectKilled);
+#ifndef NDEBUG
+          std::pair<atomObservedValues_t::iterator, bool> inserter =
+#endif
+              atomObservedValues.insert(
+                  std::make_pair( _id, ObservedValues));
+          ASSERT( inserter.second,
+              "QtInstanceInformationBoard::recieveNotification() - could not insert ObservedValues for"
+              +toString(_id)+".");
+          // we need to check for index changes
+          LOG(3, "DEBUG: InformationBoard signOn()s to atom " << _id);
+          _atom->signOn(this, atom::IndexChanged);
+          AtomSignedOn.insert( static_cast<Observable *>(const_cast<atom *>(_atom)) );
+        } else {
+          ELOG(1, "QtInstanceInformationBoard got AtomInserted for unknown atom id " << _id);
+        }
+        break;
+      }
+      case World::AtomRemoved:
+      {
+        const atomId_t _id = const_cast<const World &>(World::getInstance()).lastChangedAtomId();
+        LOG(3, "DEBUG: InformationBoard got AtomRemoved signal for atom " << _id);
+        // note down such that ObservedValues are simply dropped
+        lastremovedatom = _id;
+        break;
+      }
+      default:
+        ASSERT(0, "QtInstanceInformationBoard::recieveNotification() - we cannot get here for World.");
+        break;
+    }
+  } else if (dynamic_cast<molecule *>(publisher) != NULL) {
+    const moleculeId_t molid = const_cast<const World &>(World::getInstance()).lastChangedMolId();
+    switch (notification->getChannelNo()) {
+      case molecule::AtomInserted:
+      {
+        const molecule * const _molecule = const_cast<const World &>(World::getInstance()).
+            getMolecule(MoleculeById(molid));
+        if (_molecule != NULL) {
+          const atomId_t atomid = const_cast<const molecule *>(_molecule)->lastChangedAtomId();
+          LOG(3, "DEBUG: InformationBoard got AtomInserted signal for atom "
+              << atomid << " from molecule " << molid);
+          // check whether atom's observedvalues are present
+          ASSERT( atomObservedValues.find(atomid) != atomObservedValues.end(),
+              "QtInstanceInformationBoard::recieveNotification() - ObservedValues for atom "
+              +toString(atomid)+" are not present yet.");
+          // and emit
+          emit atomInserted(molid, atomid);
+        } else {
+          ELOG(2, "QtInstanceInformationBoard::recieveNotification() - molecule "
+              << molid << " has disappeared.");
+        }
+        break;
+      }
+      case molecule::AtomRemoved:
+      {
+        const molecule * const _molecule = const_cast<const World &>(World::getInstance()).
+            getMolecule(MoleculeById(molid));
+        if (_molecule != NULL) {
+          const atomId_t atomid = const_cast<const molecule *>(_molecule)->lastChangedAtomId();
+          LOG(3, "DEBUG: InformationBoard got AtomRemoved signal for atom "
+              << atomid << " from molecule " << molid);
+          emit atomRemoved(molid, atomid);
+        }
+        break;
+      }
+      case molecule::IndexChanged:
+      {
+        // molecule has changed its index
+        const moleculeId_t newmoleculeId = dynamic_cast<molecule *>(publisher)->getId();
+        LOG(3, "DEBUG: InformationBoard got IndexChanged from molecule " << molid << " to " << newmoleculeId);
+        {
+          moleculeObservedValues_t::iterator iter = moleculeObservedValues.find(molid);
+          // change id here only if still present
+          if (iter != moleculeObservedValues.end()) {
+            ObservedValues_t obsvalues = iter->second;
+            moleculeObservedValues.erase(iter);
+            ASSERT( moleculeObservedValues.find(newmoleculeId) == moleculeObservedValues.end(),
+                "QtInstanceInformationBoard::recieveNotification() - ObservedValues for atom "
+                +toString(newmoleculeId)+" already present.");
+            moleculeObservedValues.insert( std::make_pair(newmoleculeId, obsvalues) );
+        //    if (!inserter.second)
+        //      ELOG(1, "QtInformationBoard could not insert molecule id change "
+        //          << molid << "->" << newmoleculeId);
+          }
+        }
+        // no need update SignedOn, ref does not change
+        emit moleculeIndexChanged(molid, newmoleculeId);
+        break;
+      }
+      default:
+        ASSERT(0, "QtInstanceInformationBoard::recieveNotification() - we cannot get here.");
+        break;
+    }
+  } else if (dynamic_cast<atom *>(publisher) != NULL) {
+    const atomId_t oldatomId = const_cast<const World &>(World::getInstance()).lastChangedAtomId();
+    switch (notification->getChannelNo()) {
+      case AtomObservable::IndexChanged:
+      {
+        const atomId_t newatomId = dynamic_cast<atom *>(publisher)->getId();
+        LOG(3, "DEBUG: InformationBoard got IndexChanged from atom " << oldatomId << " to " << newatomId);
+        // update atomObservedValues
+        {
+          atomObservedValues_t::iterator iter = atomObservedValues.find(oldatomId);
+          // change id here only if still present
+          if (iter != atomObservedValues.end()) {
+            ObservedValues_t obsvalues = iter->second;
+            atomObservedValues.erase(iter);
+            ASSERT( atomObservedValues.find(newatomId) == atomObservedValues.end(),
+                "QtInstanceInformationBoard::recieveNotification() - ObservedValues for atom "
+                +toString(newatomId)+" already present.");
+            atomObservedValues.insert( std::make_pair(newatomId, obsvalues) );
+      //    if (!inserter.second)
+      //      ELOG(1, "QtInformationBoard could not insert atom id change "
+      //          << oldatomId << "->" << newatomId);
+          }
+        }
+        // no need update SignedOn, ref does not change
+        emit atomIndexChanged(oldatomId, newatomId);
+        break;
+      }
+      default:
+        ASSERT(0, "QtInstanceInformationBoard::recieveNotification() - we cannot get here.");
+        break;
+    }
+  } else {
+    ASSERT(0, "QtInstanceInformationBoard::recieveNotification() - notification from unknown source.");
+  }
+}
+
+void QtInstanceInformationBoard::atomcountsubjectKilled(const atomId_t _atomid)
+{
+  LOG(3, "DEBUG: InformationBoard got subjectKilled() for a value of atom " << _atomid);
+  atomsubjectKilledCount_t::iterator iter = atomsubjectKilledCount.find(_atomid);
+  if (iter == atomsubjectKilledCount.end()) {
+    std::pair<atomsubjectKilledCount_t::iterator, bool> inserter =
+        atomsubjectKilledCount.insert( std::make_pair(_atomid, 0) );
+    iter = inserter.first;
+  }
+  ++(iter->second);
+
+  if (iter->second > GLMoleculeObject_atom::MAX_ObservedTypes) {
+    atomsubjectKilledCount.erase(iter);
+  }
+}
+
+void QtInstanceInformationBoard::moleculecountsubjectKilled(const moleculeId_t _molid)
+{
+  LOG(3, "DEBUG: InformationBoard got subjectKilled() for a value of molecule " << _molid);
+  moleculesubjectKilledCount_t::iterator iter = moleculesubjectKilledCount.find(_molid);
+  if (iter == moleculesubjectKilledCount.end()) {
+    std::pair<moleculesubjectKilledCount_t::iterator, bool> inserter =
+        moleculesubjectKilledCount.insert( std::make_pair(_molid, 0) );
+    iter = inserter.first;
+  }
+  ++(iter->second);
+
+  if (iter->second > GLMoleculeObject_molecule::MAX_ObservedTypes) {
+    // then free the instance
+    emit moleculeRemoved(_molid);
+    moleculesubjectKilledCount.erase(iter);
+  }
+}
+
+QtInstanceInformationBoard::ObservedValues_t
+QtInstanceInformationBoard::getAtomObservedValues(const atomId_t _id)
+{
+  ObservedValues_t returnvalues;
+  const atomObservedValues_t::iterator iter = atomObservedValues.find(_id);
+  ASSERT(iter != atomObservedValues.end(),
+      "QtInstanceInformationBoard::getAtomObservedValues() - atom values not present for id"
+      +toString(_id));
+  if (iter->first == _id) {
+    returnvalues = iter->second;
+    atomObservedValues.erase(iter);
+  }
+  return returnvalues;
+}
+
+QtInstanceInformationBoard::ObservedValues_t
+QtInstanceInformationBoard::getMoleculeObservedValues(const moleculeId_t _id)
+{
+  ObservedValues_t returnvalues;
+  const moleculeObservedValues_t::iterator iter = moleculeObservedValues.find(_id);
+  ASSERT(iter != moleculeObservedValues.end(),
+      "getMoleculeObservedValues::getAtomObservedValues() - molecule values not present for id"
+      +toString(_id));
+  if (iter->first == _id) {
+    returnvalues = iter->second;
+    moleculeObservedValues.erase(iter);
+  }
+  return returnvalues;
+}
+
+void QtInstanceInformationBoard::returnAtomObservedValues(
+    const atomId_t _id,
+    ObservedValues_t &_observedvalues)
+{
+  if (lastremovedatom != _id) {
+#ifndef NDEBUG
+    std::pair<atomObservedValues_t::iterator, bool> inserter =
+#endif
+        atomObservedValues.insert(
+            std::make_pair( _id, _observedvalues) );
+    ASSERT( inserter.second,
+        "QtInstanceInformationBoard::returnAtomObservedValues() - could not insert ObservedValues for"
+        +toString(_id)+".");
+  } else
+    lastremovedatom = (atomId_t)-1;
+}
+
+void QtInstanceInformationBoard::returnMoleculeObservedValues(
+    const moleculeId_t _id,
+    ObservedValues_t &_observedvalues)
+{
+  if (lastremovedmolecule != _id) {
+#ifndef NDEBUG
+      std::pair<moleculeObservedValues_t::iterator, bool> inserter =
+#endif
+          moleculeObservedValues.insert(
+              std::make_pair( _id, _observedvalues) );
+      ASSERT( inserter.second,
+          "QtInstanceInformationBoard::returnMoleculeObservedValues() - could not insert ObservedValues for"
+          +toString(_id)+".");
+  } else
+    lastremovedmolecule = (moleculeId_t)-1;
+}
Index: src/UIElements/Views/Qt4/QtInstanceInformationBoard.hpp
===================================================================
--- src/UIElements/Views/Qt4/QtInstanceInformationBoard.hpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
+++ src/UIElements/Views/Qt4/QtInstanceInformationBoard.hpp	(revision 15c8a9b3bc531ef54d3a92deddc382002414247c)
@@ -0,0 +1,168 @@
+/*
+ * QtInstanceInformationBoard.hpp
+ *
+ *  Created on: Oct 17, 2015
+ *      Author: heber
+ */
+
+
+#ifndef QTINSTANCEINFORMATIONBOARD_HPP_
+#define QTINSTANCEINFORMATIONBOARD_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtGui/QWidget>
+
+#include <map>
+#include <vector>
+
+#include <boost/any.hpp>
+
+#include "CodePatterns/Observer/Observer.hpp"
+#include "CodePatterns/ObservedValue.hpp"
+
+#include "types.hpp"
+
+class GLWorldScene;
+class GLMoleculeObject_atom;
+class GLMoleculeObject_bond;
+class GLMoleculeObject_molecule;
+
+/** The QtInstanceInformationBoard is the central class for communicating instance
+ * creation and destruction from MoleCuilder into the QtGui realm. It should be
+ * thought of as an interface to allow for safe multi-threaded computing.
+ *
+ * The idea is as follows: As soon as a molecule is instantiated, all the QtGui
+ * needs to access the instance (for displaying it) is wrapped up in a
+ * ObservedValue. This ObservedValue separates the lifetime of the molecule object
+ * from the information contained therein and thus makes the visual representation
+ * independent of the life time. The Observer/Observable signal from the World,
+ * i.e. World::MoleculeInserted, is caught (directly within the same thread) by
+ * the QtInstanceInformationBoard. Here, we instantiate all ObservedValue's needed
+ * for this specific molecule and store them in an internal map. Next, we emit
+ * a Qt signal informing the QtGui part about the new molecule.
+ * At some later stage, the QtGui will (probably in a different thread)
+ * instantiate a GLMoleculeObject_molecule as a visual representation of the
+ * molecule. It requests the ObservedValues from the QtInstanceInformationBoard
+ * and uses these directly.
+ * The QtInstanceInformationBoard also records all subjectKilled() signals from
+ * each ObservedValue. Additionally, each class using the ObservedValues
+ * additionally informs the QtInstanceInformationBoard when subjectKilled() was
+ * called. If subjectKilled() for each ObservedValue of a molecule and from the
+ * visual representation have been received, a removal Qt signal is emitted.
+ *
+ * The same holds for the atom
+ */
+class QtInstanceInformationBoard : public QWidget, public Observer
+{
+  Q_OBJECT
+
+public:
+  /** typedef for a vector of ObservedValue's (each is due to templating its
+   * own type. Therefore, we need to use boost::any).
+   */
+  typedef std::vector<boost::any> ObservedValues_t;
+
+  /** Cstor of QtInstanceInformationBoard.
+   *
+   */
+  QtInstanceInformationBoard(QWidget * _parent=0);
+
+  /** Dstor of QtInstanceInformationBoard.
+   *
+   */
+  ~QtInstanceInformationBoard();
+
+  // Observer functions
+  void update(Observable *publisher);
+  void subjectKilled(Observable *publisher);
+  void recieveNotification(Observable *publisher, Notification_ptr notification);
+
+  ObservedValues_t getAtomObservedValues(const atomId_t _id);
+  ObservedValues_t getMoleculeObservedValues(const moleculeId_t _id);
+
+  void returnAtomObservedValues(const atomId_t _id, ObservedValues_t &_observedvalues);
+  void returnMoleculeObservedValues(const moleculeId_t _id, ObservedValues_t &_observedvalues);
+
+signals:
+  void atomInserted(const moleculeId_t _molid, const atomId_t _atomid);
+  void atomRemoved(const moleculeId_t _molid, const atomId_t _atomid);
+  void atomIndexChanged(const atomId_t _oldid, const atomId_t _newid);
+  void moleculeInserted(const moleculeId_t _molid);
+  void moleculeRemoved(const moleculeId_t _molid);
+  void moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid);
+
+private:
+  friend class GLWorldScene;
+  friend class GLMoleculeObject_atom;
+  friend class GLMoleculeObject_bond;
+  friend class GLMoleculeObject_molecule;
+
+  //!> indicating whether we are still signedOn to World or not
+  bool WorldSignedOn;
+
+  typedef std::multiset<Observable *> SignedOn_t;
+  //!> map indicating to which atom we are currently signed on
+  SignedOn_t AtomSignedOn;
+  //!> map indicating to which molecule we are currently signed on
+  SignedOn_t MoleculeSignedOn;
+
+  /** Counts how many atom's ObservedValues got subjectKilled.
+   *
+   * This is used to give removal signal only when each and every
+   * ObservedValue (and the instance itself) has been subjectKilled by the
+   * monitored Observable. Only then can we safely remove the instance.
+   *
+   * \param _atomid id of the atom
+   */
+  void atomcountsubjectKilled(const atomId_t _atomid);
+
+  /** Counts how many molecule's ObservedValues got subjectKilled.
+   *
+   * This is used to give removal signal only when each and every
+   * ObservedValue (and the instance itself) has been subjectKilled by the
+   * monitored Observable. Only then can we safely remove the instance.
+   *
+   * \param _molid id of the molecule
+   */
+  void moleculecountsubjectKilled(const moleculeId_t _molid);
+
+  //!> typedef for map with subjectKilledCounts for each atom
+  typedef typename std::map<atomId_t, size_t> atomsubjectKilledCount_t;
+
+  //!> typedef for map with subjectKilledCounts for each molecule
+  typedef typename std::map<moleculeId_t, size_t> moleculesubjectKilledCount_t;
+
+  //!> counts how many ObservedValues have already been subjectKilled()
+  atomsubjectKilledCount_t atomsubjectKilledCount;
+
+  //!> counts how many ObservedValues have already been subjectKilled()
+  moleculesubjectKilledCount_t moleculesubjectKilledCount;
+
+  //!> typedef for the map of id to each one's ObservedValues
+  typedef typename std::map<atomId_t, ObservedValues_t> atomObservedValues_t;
+  //!> map containing all ObservedValues for each atom, associated by id
+  atomObservedValues_t atomObservedValues;
+
+  //!> typedef for the map of id to each one's ObservedValues
+  typedef typename std::map<moleculeId_t, ObservedValues_t> moleculeObservedValues_t;
+  //!> map containing all ObservedValues for each molecule, associated by id
+  moleculeObservedValues_t moleculeObservedValues;
+
+  //!> stored callback function for notifying QtInstanceInformationBoard about subjectKilled in atom
+  boost::function<void (atomId_t)> atomSubjectKilled;
+  //!> stored callback function for notifying QtInstanceInformationBoard about subjectKilled in molecule
+  boost::function<void (moleculeId_t)> moleculeSubjectKilled;
+
+  //!> note down atom id of last removed atom to drop its ObservedValues
+  atomId_t lastremovedatom;
+
+  //!> note down molecule id of last removed molecule to drop its ObservedValues
+  moleculeId_t lastremovedmolecule;
+
+};
+
+#endif /* QTINSTANCEINFORMATIONBOARD_HPP_ */
