Index: src/UIElements/Views/Qt4/MoleculeList/QtMoleculeList.cpp
===================================================================
--- src/UIElements/Views/Qt4/MoleculeList/QtMoleculeList.cpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/MoleculeList/QtMoleculeList.cpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -82,5 +82,5 @@
   connect(this,SIGNAL(itemChanged(QStandardItem*)),this,SLOT(moleculeNameChanged(QStandardItem*)));
   connect(this, SIGNAL(itemChanged(QStandardItem*)), this, SLOT(checkForVisibilityChange(QStandardItem*)));
-  connect(board, SIGNAL(moleculeInserted(const moleculeId_t)), this, SLOT(moleculeInserted(const moleculeId_t)));
+  connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)), this, SLOT(moleculeInserted(QtObservedMolecule::ptr)));
   connect(board, SIGNAL(moleculeRemoved(const moleculeId_t)), this, SLOT(moleculeRemoved(const moleculeId_t)));
   connect(board, SIGNAL(moleculeIndexChanged(const moleculeId_t,const moleculeId_t)),
@@ -102,9 +102,9 @@
 }
 
-void QtMoleculeList::moleculeInserted(const moleculeId_t _id)
+void QtMoleculeList::moleculeInserted(QtObservedMolecule::ptr _mol)
 {
   // get ObservedMolecule from board
   boost::recursive_mutex::scoped_lock lock(listAccessing_mutex);
-  newMolecules.push_back( _id );
+  newMolecules.push_back( _mol );
 }
 
@@ -678,5 +678,5 @@
   list_of_group_items_t visibilityGroupItems_copy = visibilityGroupItems;
   visibilityGroupItems.clear();
-  std::vector<moleculeId_t> newMolecules_copy = newMolecules;
+  std::vector<QtObservedMolecule::ptr> newMolecules_copy = newMolecules;
   newMolecules.clear();
   std::vector<moleculeId_t> removedMolecules_copy = removedMolecules;
@@ -784,14 +784,11 @@
 
   /// 4. instantiate all new items
-  for (std::vector<moleculeId_t>::iterator moliter = newMolecules_copy.begin();
+  for (std::vector<QtObservedMolecule::ptr>::iterator moliter = newMolecules_copy.begin();
       moliter != newMolecules_copy.end(); ++moliter) {
-    QtObservedMolecule::ptr ObservedMolecule = board->getObservedMolecule(*moliter);
-    if (ObservedMolecule) {
-//     LOG(1, "Adding molecule " << ObservedMolecule->getMoleculeName());
-      // check that World knows the molecule still
-      const std::string formula = addMolecule(ObservedMolecule);
-//        LOG(1, "Adding " << formula << " to toBeSetOccurrence.");
-      toBeSetOccurrence.insert( formula );
-    }
+//   LOG(1, "Adding molecule " << ObservedMolecule->getMoleculeName());
+    // check that World knows the molecule still
+    const std::string formula = addMolecule(*moliter);
+//      LOG(1, "Adding " << formula << " to toBeSetOccurrence.");
+    toBeSetOccurrence.insert( formula );
   }
 
Index: src/UIElements/Views/Qt4/MoleculeList/QtMoleculeList.hpp
===================================================================
--- src/UIElements/Views/Qt4/MoleculeList/QtMoleculeList.hpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/MoleculeList/QtMoleculeList.hpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -65,5 +65,5 @@
 
 private slots:
-  void moleculeInserted(const moleculeId_t _id);
+  void moleculeInserted(QtObservedMolecule::ptr _mol);
   void moleculeRemoved(const moleculeId_t _id);
   void moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid);
@@ -155,5 +155,5 @@
   list_of_group_items_t visibilityGroupItems;
   //!> list of new molecules which need to be added
-  std::vector<moleculeId_t> newMolecules;
+  std::vector<QtObservedMolecule::ptr> newMolecules;
   //!> list of molecules that have been removed
   std::vector<moleculeId_t> removedMolecules;
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -58,5 +58,5 @@
     QGLSceneNode *mesh[],
     QObject *parent,
-    QtObservedAtom::ptr _ObservedAtom) :
+    QtObservedAtom::ptr &_ObservedAtom) :
   GLMoleculeObject(mesh, parent),
   ObservedAtom(_ObservedAtom)
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -35,5 +35,5 @@
       QGLSceneNode *mesh[],
       QObject *parent,
-      QtObservedAtom::ptr _ObservedAtom
+      QtObservedAtom::ptr &_ObservedAtom
       );
   virtual ~GLMoleculeObject_atom();
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -84,5 +84,5 @@
     QObject *parent,
     QtObservedInstanceBoard &_board,
-    QtObservedMolecule::ptr _ObservedMolecule) :
+    QtObservedMolecule::ptr &_ObservedMolecule) :
   GLMoleculeObject((QGLSceneNode *)NULL, parent),
   owner(NULL),
@@ -99,5 +99,5 @@
     QObject *parent,
     QtObservedInstanceBoard &_board,
-    QtObservedMolecule::ptr _ObservedMolecule) :
+    QtObservedMolecule::ptr &_ObservedMolecule) :
   GLMoleculeObject(mesh, parent),
   owner(NULL),
@@ -125,5 +125,5 @@
   connect (ObservedMolecule.get(), SIGNAL(boundingboxChanged()), this, SLOT(resetBoundingBox()));
   connect (ObservedMolecule.get(), SIGNAL(indexChanged()), this, SLOT(resetIndex()));
-  connect (ObservedMolecule.get(), SIGNAL(atomInserted(const atomId_t)), this, SLOT(atomInserted(const atomId_t)));
+  connect (ObservedMolecule.get(), SIGNAL(atomInserted(QtObservedAtom::ptr)), this, SLOT(atomInserted(QtObservedAtom::ptr)));
   connect (ObservedMolecule.get(), SIGNAL(atomRemoved(const atomId_t)), this, SLOT(atomRemoved(const atomId_t)));
   connect (ObservedMolecule.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
@@ -357,9 +357,9 @@
  * @param _atom atom to add
  */
-void GLMoleculeObject_molecule::atomInserted(const atomId_t _id)
-{
-  LOG(3, "INFO: GLMoleculeObject_molecule: Received signal atomInserted for atom "+toString(_id)+".");
-
-  const QtObservedAtom::ptr _atom = board.getObservedAtom(_id);
+void GLMoleculeObject_molecule::atomInserted(QtObservedAtom::ptr _atom)
+{
+  const atomId_t atomid = _atom->getAtomIndex();
+  LOG(3, "INFO: GLMoleculeObject_molecule: Received signal atomInserted for atom "+toString(atomid)+".");
+
   if (_atom) {
     GLMoleculeObject_atom *atomObject =
@@ -369,9 +369,9 @@
             _atom);
     ASSERT( atomObject != NULL,
-        "GLMoleculeObject_molecule::atomInserted - could not create atom object for "+toString(_id));
-    AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
+        "GLMoleculeObject_molecule::atomInserted - could not create atom object for "+toString(atomid));
+    AtomNodeMap::iterator iter = AtomsinSceneMap.find(atomid);
     ASSERT(iter == AtomsinSceneMap.end(),
-        "GLMoleculeObject_molecule::atomInserted - same atom with id "+toString(_id)+" added again.");
-    AtomsinSceneMap.insert( make_pair(_id, atomObject) );
+        "GLMoleculeObject_molecule::atomInserted - same atom with id "+toString(atomid)+" added again.");
+    AtomsinSceneMap.insert( make_pair(atomid, atomObject) );
 
     qRegisterMetaType<atomId_t>("atomId_t");
@@ -387,5 +387,5 @@
 
     if (m_objectId  == -1)
-      setObjectId(_id);
+      setObjectId(atomid);
 
     emit changed();
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -45,10 +45,10 @@
       QObject *parent,
       QtObservedInstanceBoard &_board,
-      QtObservedMolecule::ptr _ObservedMolecule);
+      QtObservedMolecule::ptr &_ObservedMolecule);
   GLMoleculeObject_molecule(
       QGLSceneNode *mesh[],
       QObject *parent,
       QtObservedInstanceBoard &_board,
-      QtObservedMolecule::ptr _ObservedMolecule);
+      QtObservedMolecule::ptr &_ObservedMolecule);
   virtual ~GLMoleculeObject_molecule();
 
@@ -78,5 +78,5 @@
 
   void wasClicked();
-  void atomInserted(const atomId_t _id);
+  void atomInserted(QtObservedAtom::ptr _atom);
   void atomRemoved(const atomId_t _id);
   void bondInserted(const atomId_t, const atomId_t, const GLMoleculeObject_bond::SideOfBond side);
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -93,14 +93,14 @@
     GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
-  connect(board, SIGNAL(moleculeInserted(const moleculeId_t)),
-      this, SLOT(moleculeInserted(const moleculeId_t)));
+  connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)),
+      this, SLOT(moleculeInserted(QtObservedMolecule::ptr)));
   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(board, SIGNAL(atomInserted(const moleculeId_t, const atomId_t)),
-      this, SLOT(atomInserted(const moleculeId_t, const atomId_t)), Qt::DirectConnection);
+  connect(board, SIGNAL(atomInserted(QtObservedAtom::ptr)),
+      this, SLOT(atomInserted(QtObservedAtom::ptr)));
   connect(board, SIGNAL(atomRemoved(const moleculeId_t, const atomId_t)),
-      this, SLOT(atomRemoved(const moleculeId_t, const atomId_t)), Qt::DirectConnection);
+      this, SLOT(atomRemoved(const moleculeId_t, const atomId_t)));
 
 //  connect(this, SIGNAL(updated()), this, SLOT(update()));
@@ -156,19 +156,24 @@
  * @param _atomid atom to insert
  */
-void GLWorldScene::atomInserted(const moleculeId_t _molid, const atomId_t _atomid)
-{
-  boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
-
-  LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "+toString(_atomid)+".");
+void GLWorldScene::atomInserted(QtObservedAtom::ptr _atom)
+{
+  ASSERT (_atom,
+      "GLWorldScene::moleculeInserted() - received shared_ptr for atom is empty?");
+  const atomId_t atomid = _atom->getAtomIndex();
+  const atomId_t molid = _atom->getAtomMoleculeIndex();
+  LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "+toString(atomid)+".");
 
   // check of molecule is already present
-  MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(_molid);
+  MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
   if (moliter != MoleculesinSceneMap.end()) {
     // no action, is also caught via QtObservedMolecule by GLMoleculeObject_molecule
   } else {
     // store signal for when it is instantiated
-    if (MoleculeMissedStateMap.count(_molid) == 0)
-      MoleculeMissedStateMap.insert( std::make_pair(_molid ,StateChangeMap_t()) );
-    MoleculeMissedStateMap[_molid].insert( std::make_pair(_atomid, atomInsertedState) );
+    if (MoleculeMissedStateMap.count(molid) == 0)
+      MoleculeMissedStateMap.insert( std::make_pair(molid ,StateChangeMap_t()) );
+    MoleculeMissedStateMap[molid].insert( std::make_pair(atomid, atomInsertedState) );
+    QtObservedAtomMap[atomid] = _atom;
+    LOG(3, "INFO: GLWorldScene: Placing atomInserted for atom " << atomid
+         << " and molecule " << molid << " into missed state map.");
   }
 }
@@ -194,4 +199,6 @@
       MoleculeMissedStateMap.insert( std::make_pair(_molid ,StateChangeMap_t()) );
     MoleculeMissedStateMap[_molid].insert( std::make_pair(_atomid, atomRemovedState) );
+    LOG(3, "INFO: GLWorldScene: Placing atomRemoved for atom " << _atomid
+         << " and molecule " << _molid << " into missed state map.");
   }
 }
@@ -201,113 +208,119 @@
  * @param _mol molecule to insert
  */
-void GLWorldScene::moleculeInserted(const moleculeId_t _id)
-{
-  LOG(3, "INFO: GLWorldScene: Received signal moleculeInserted for molecule "+toString(_id)+".");
+void GLWorldScene::moleculeInserted(QtObservedMolecule::ptr _mol)
+{
+  ASSERT (_mol,
+      "GLWorldScene::moleculeInserted() - received shared_ptr for molecule is empty?");
+  const moleculeId_t molid = _mol->getMolIndex();
+  LOG(3, "INFO: GLWorldScene: Received signal moleculeInserted for molecule "+toString(molid)+".");
 
   boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
 
-  MoleculeNodeMap::const_iterator iter = MoleculesinSceneMap.find(_id);
+  MoleculeNodeMap::const_iterator iter = MoleculesinSceneMap.find(molid);
   ASSERT( iter == MoleculesinSceneMap.end(),
-      "GLWorldScene::moleculeInserted() - molecule's id "+toString(_id)+" already present.");
+      "GLWorldScene::moleculeInserted() - molecule's id "+toString(molid)+" already present.");
 
   // check whether molecule is still present
-  if (RemovalMolecules.count(_id) != 0) {
-    RemovalMolecules.erase(_id);
+  if (RemovalMolecules.count(molid) != 0) {
+    RemovalMolecules.erase(molid);
     return;
   }
-  if (const_cast<const World &>(World::getInstance()).getMolecule(MoleculeById(_id)) == NULL) {
-    ELOG(2, "Molecule with id " << _id << " has disappeared.");
-    return;
-  }
 
   // add new object
-  LOG(1, "DEBUG: Adding GLMoleculeObject_molecule to id " << _id);
-  const QtObservedMolecule::ptr mol = board->getObservedMolecule(_id);
-  if (mol) {
-    GLMoleculeObject_molecule *molObject =
-        new GLMoleculeObject_molecule(
-            GLMoleculeObject::meshEmpty,
-            this,
-            *board,
-            mol);
-    ASSERT( molObject != NULL,
-        "GLWorldScene::moleculeInserted - could not create molecule object for "+toString(_id));
-    MoleculesinSceneMap.insert( make_pair(_id, molObject) );
-
-    // now handle all state changes that came up before the instantiation
-    while (MoleculeMissedStateMap.count(_id) != 0) {
-//      ASSERT( !MoleculeMissedStateMap[_id].empty(),
+  LOG(1, "DEBUG: Adding GLMoleculeObject_molecule to id " << molid);
+  GLMoleculeObject_molecule *molObject =
+      new GLMoleculeObject_molecule(
+          GLMoleculeObject::meshEmpty,
+          this,
+          *board,
+          _mol);
+  ASSERT( molObject != NULL,
+      "GLWorldScene::moleculeInserted - could not create molecule object for "+toString(molid));
+#ifndef NDEBUG
+  std::pair<MoleculeNodeMap::iterator, bool> inserter =
+#endif
+  MoleculesinSceneMap.insert( make_pair(molid, molObject) );
+  ASSERT(inserter.second,
+      "GLWorldScene::moleculeInserted() - molecule "+toString(molid)+" already present in scene.");
+
+  // now handle all state changes that came up before the instantiation
+  if (MoleculeMissedStateMap.count(molid) != 0) {
+//      ASSERT( !MoleculeMissedStateMap[molid].empty(),
 //          "GLWorldScene::moleculeInserted() - we have an empty state change map for molecule with id "
-//          +toString(_id));
-      boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
-      for (StateChangeMap_t::iterator iter = MoleculeMissedStateMap[_id].begin();
-          !MoleculeMissedStateMap[_id].empty();
-          iter = MoleculeMissedStateMap[_id].begin()) {
-        std::pair<StateChangeMap_t::iterator, StateChangeMap_t::iterator> rangeiter =
-            MoleculeMissedStateMap[_id].equal_range(iter->first);
-        const size_t StateCounts = std::distance(rangeiter.first, rangeiter.second);
-        if (StateCounts > 1) {
-          // more than one state change, have to combine
-          typedef std::map<StateChangeType, size_t> StateChangeAmounts_t;
-          StateChangeAmounts_t StateChangeAmounts;
-          for (StateChangeMap_t::const_iterator stateiter = rangeiter.first;
-              stateiter != rangeiter.second; ++stateiter)
-            ++StateChangeAmounts[stateiter->second];
-          ASSERT( StateChangeAmounts[atomInsertedState] >= StateChangeAmounts[atomRemovedState],
-              "GLWorldScene::moleculeInserted() - more atomRemoved states than atomInserted for atom "
-              +toString(iter->first));
-          if (StateChangeAmounts[atomInsertedState] > StateChangeAmounts[atomRemovedState]) {
+//          +toString(molid));
+    boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
+    for (StateChangeMap_t::iterator iter = MoleculeMissedStateMap[molid].begin();
+        !MoleculeMissedStateMap[molid].empty();
+        iter = MoleculeMissedStateMap[molid].begin()) {
+      std::pair<StateChangeMap_t::iterator, StateChangeMap_t::iterator> rangeiter =
+          MoleculeMissedStateMap[molid].equal_range(iter->first);
+      const size_t StateCounts = std::distance(rangeiter.first, rangeiter.second);
+      if (StateCounts > 1) {
+        // more than one state change, have to combine
+        typedef std::map<StateChangeType, size_t> StateChangeAmounts_t;
+        StateChangeAmounts_t StateChangeAmounts;
+        for (StateChangeMap_t::const_iterator stateiter = rangeiter.first;
+            stateiter != rangeiter.second; ++stateiter)
+          ++StateChangeAmounts[stateiter->second];
+        ASSERT( StateChangeAmounts[atomInsertedState] >= StateChangeAmounts[atomRemovedState],
+            "GLWorldScene::moleculeInserted() - more atomRemoved states "
+            +toString(StateChangeAmounts[atomRemovedState])+" than atomInserted "
+            +toString(StateChangeAmounts[atomInsertedState])+" for atom "+toString(iter->first));
+        if (StateChangeAmounts[atomInsertedState] > StateChangeAmounts[atomRemovedState]) {
+          LOG(1, "INFO: invoking atomInserted for atom " << iter->first);
+          QMetaObject::invokeMethod(molObject,        // pointer to a QObject
+                                    "atomInserted",       // member name (no parameters here)
+                                    Qt::QueuedConnection,     // connection type
+                                    Q_ARG(QtObservedAtom::ptr, QtObservedAtomMap[iter->first]));     // parameters
+        } else {
+          LOG(1, "INFO: Atom " << iter->first << " has been inserted and removed already.");
+        }
+        // removed all state changes for this atom
+        MoleculeMissedStateMap[molid].erase(rangeiter.first, rangeiter.second);
+      } else {
+        // can only be an insertion
+        switch (rangeiter.first->second) {
+          case atomRemovedState:
+            ASSERT( 0,
+                "GLWorldScene::moleculeInserted() - atomRemoved state without atomInserted for atom "
+                +toString(iter->first));
+            break;
+          case atomInsertedState:
+          {
             LOG(1, "INFO: invoking atomInserted for atom " << iter->first);
             QMetaObject::invokeMethod(molObject,        // pointer to a QObject
                                       "atomInserted",       // member name (no parameters here)
                                       Qt::QueuedConnection,     // connection type
-                                      Q_ARG(const atomId_t, iter->first));     // parameters
-          } else {
-            LOG(1, "INFO: Atom " << iter->first << " has been inserted and removed already.");
+                                      Q_ARG(QtObservedAtom::ptr, QtObservedAtomMap[iter->first]));     // parameters
+            break;
           }
-        } else {
-          // can only be an insertion
-          switch (rangeiter.first->second) {
-            case atomRemovedState:
-              ASSERT( 0,
-                  "GLWorldScene::moleculeInserted() - atomRemoved state without atomInserted for atom "
-                  +toString(iter->first));
-              break;
-            case atomInsertedState:
-              LOG(1, "INFO: invoking atomInserted for atom " << iter->first);
-              QMetaObject::invokeMethod(molObject,        // pointer to a QObject
-                                        "atomInserted",       // member name (no parameters here)
-                                        Qt::QueuedConnection,     // connection type
-                                        Q_ARG(const atomId_t, iter->first));     // parameters
-              break;
-            default:
-              ASSERT( 0,
-                  "GLWorldScene::moleculeInserted() - there are unknown change states.");
-              break;
-          }
+          default:
+            ASSERT( 0,
+                "GLWorldScene::moleculeInserted() - there are unknown change states.");
+            break;
         }
         // removed state changes for this atom
-        MoleculeMissedStateMap[_id].erase(iter);
+        MoleculeMissedStateMap[molid].erase(iter);
       }
     }
-
-    connect (molObject, SIGNAL(changed()), this, SIGNAL(changed()));
-    connect (molObject, SIGNAL(changeOccured()), this, SIGNAL(changeOccured()));
-    connect (molObject, SIGNAL(atomClicked(atomId_t)), this, SLOT(atomClicked(atomId_t)));
-    connect (molObject, SIGNAL(moleculeClicked(moleculeId_t)), this, SLOT(moleculeClicked(moleculeId_t)));
-    connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
-    connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
-    connect (molObject, SIGNAL(hoverChanged(const atomId_t)), this, SIGNAL(hoverChanged(const atomId_t)));
-    connect (molObject, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SIGNAL(hoverChanged(const moleculeId_t, int)));
-    connect (molObject, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SIGNAL(hoverChanged(const moleculeId_t, int)));
-
-    emit changed();
-    emit changeOccured();
-  }
+  }
+
+  connect (molObject, SIGNAL(changed()), this, SIGNAL(changed()));
+  connect (molObject, SIGNAL(changeOccured()), this, SIGNAL(changeOccured()));
+  connect (molObject, SIGNAL(atomClicked(atomId_t)), this, SLOT(atomClicked(atomId_t)));
+  connect (molObject, SIGNAL(moleculeClicked(moleculeId_t)), this, SLOT(moleculeClicked(moleculeId_t)));
+  connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
+  connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
+  connect (molObject, SIGNAL(hoverChanged(const atomId_t)), this, SIGNAL(hoverChanged(const atomId_t)));
+  connect (molObject, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SIGNAL(hoverChanged(const moleculeId_t, int)));
+  connect (molObject, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SIGNAL(hoverChanged(const moleculeId_t, int)));
+
+  emit changed();
+  emit changeOccured();
 
   // remove state change map for the molecule
   {
     boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
-    MoleculeMissedStateMap.erase(_id);
+    MoleculeMissedStateMap.erase(molid);
   }
 }
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 5aec20876fc61913a0a9d0db96a5769b7fff9150)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 1b07b163ff2a979bea3ff3471229c224b188c9f0)
@@ -27,6 +27,7 @@
 #include "types.hpp"
 
-class atom;
-class molecule;
+#include "UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp"
+#include "UIElements/Qt4/InstanceBoard/QtObservedMolecule.hpp"
+
 class Shape;
 
@@ -88,8 +89,8 @@
   void moleculeClicked(moleculeId_t no);
   void moleculeRemoved(const moleculeId_t _id);
-  void moleculeInserted(const moleculeId_t _id);
+  void moleculeInserted(QtObservedMolecule::ptr);
   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);
+  void atomInserted(QtObservedAtom::ptr);
   void setSelectionModeAtom();
   void setSelectionModeMolecule();
@@ -122,8 +123,11 @@
     MAX_StateChangeType
   };
+  typedef std::map< atomId_t, QtObservedAtom::ptr> QtObservedAtomMap_t;
   typedef std::multimap< atomId_t, StateChangeType> StateChangeMap_t;
   typedef std::map< moleculeId_t, StateChangeMap_t> MoleculeMissedStateMap_t;
   //!> map of all missed state changes
   MoleculeMissedStateMap_t MoleculeMissedStateMap;
+  //!> map to contain all QtObservedAtom that have not been instantiated so far
+  QtObservedAtomMap_t QtObservedAtomMap;
   //!> flag to indicate whether state map is currently worked on
   boost::recursive_mutex MoleculeMissedStateMap_mutex;
