Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -62,4 +62,7 @@
 QGLMaterial *GLMoleculeObject::m_selectionBoxMaterial = NULL;
 
+QGLSceneNode *GLMoleculeObject::meshEmpty[GLMoleculeObject::DETAILTYPES_MAX];
+QGLSceneNode *GLMoleculeObject::meshSphere[GLMoleculeObject::DETAILTYPES_MAX];
+QGLSceneNode *GLMoleculeObject::meshCylinder[GLMoleculeObject::DETAILTYPES_MAX];
 
 double GLMoleculeObject::detailMinDistance[GLMoleculeObject::DETAILTYPES_MAX] = {0, 15, 30, 42};
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -75,5 +75,5 @@
 
    void initStaticMaterials();
-   void initialize(QGLView *view, QGLPainter *painter);
+   virtual void initialize(QGLView *view, QGLPainter *painter);
    virtual void draw(QGLPainter *painter, const QVector4D &cameraPlane);
    void drawSelectionBox(QGLPainter *painter);
@@ -99,4 +99,8 @@
 public:
    enum{DETAIL_HIGHEST, DETAIL_HIGH, DETAIL_MEDIUM, DETAIL_LOW, DETAILTYPES_MAX} DetailType;
+
+   static QGLSceneNode *meshEmpty[DETAILTYPES_MAX];
+   static QGLSceneNode *meshSphere[DETAILTYPES_MAX];
+   static QGLSceneNode *meshCylinder[DETAILTYPES_MAX];
 
 protected:
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -45,6 +45,6 @@
 
 private:
-  //!> grant GLWorldScene acess to reset functions
-  friend class GLWorldScene;
+  //!> grant GLMoleculeObject_molecule acess to reset functions
+  friend class GLMoleculeObject_molecule;
 
   void resetPosition();
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -43,6 +43,6 @@
 
 private:
-  //!> grant WorldScene access to reset functions
-  friend class GLWorldScene;
+  //!> grant GLMoleculeObject_molecule acess to reset functions
+  friend class GLMoleculeObject_molecule;
 
   /** Recalculates the position of the cylinder representing the bond.
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -56,10 +56,15 @@
 #include "World.hpp"
 
+#include "GLMoleculeObject_atom.hpp"
+
 GLMoleculeObject_molecule::GLMoleculeObject_molecule(QGLSceneNode *mesh[], QObject *parent, const molecule *molref) :
   GLMoleculeObject(mesh, parent),
   Observer(std::string("GLMoleculeObject_molecule")+toString(molref->getId())),
-  _molecule(molref)
+  _molecule(molref),
+  hoverAtom(NULL)
 {
   // sign on as observer (obtain non-const instance before)
+  _molecule->signOn(this, molecule::AtomInserted);
+  _molecule->signOn(this, molecule::AtomRemoved);
   /*molref->signOn(this, AtomObservable::IndexChanged);
   molref->signOn(this, AtomObservable::PositionChanged);
@@ -69,8 +74,12 @@
   World::getInstance().signOn(this, World::SelectionChanged);
   updateBoundingBox();
+
+  init();
 }
 
 GLMoleculeObject_molecule::~GLMoleculeObject_molecule()
 {
+  _molecule->signOff(this, molecule::AtomInserted);
+  _molecule->signOff(this, molecule::AtomRemoved);
   /*_atom->signOff(this, AtomObservable::IndexChanged);
   _atom->signOff(this, AtomObservable::PositionChanged);
@@ -78,4 +87,91 @@
   _atom->signOff(this, AtomObservable::BondsAdded);*/
   World::getInstance().signOff(this, World::SelectionChanged);
+}
+
+/** Initialise the WorldScene with molecules and atoms from World.
+ *
+ */
+void GLMoleculeObject_molecule::init()
+{
+  if (_molecule->begin() != _molecule->end()) {
+    for (molecule::const_iterator atomiter = _molecule->begin();
+        atomiter != _molecule->end();
+        atomiter++) {
+      // create atom objects in scene
+      atomInserted((*atomiter)->getId());
+
+      // create bond objects in scene
+      const BondList &bondlist = (*atomiter)->getListOfBonds();
+      for (BondList::const_iterator bonditer = bondlist.begin();
+          bonditer != bondlist.end();
+          ++bonditer) {
+        const bond::ptr _bond = *bonditer;
+        const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == *atomiter) ?
+            GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
+        bondInserted(_bond, side);
+      }
+    }
+  }
+}
+
+void GLMoleculeObject_molecule::addAtomBonds(
+    const bond::ptr &_bond,
+    const GLMoleculeObject_bond::SideOfBond _side
+    )
+{
+  bool bond_present = false;
+  const BondIds ids = getBondIds(_bond, _side);
+  // check whether bond is not present already
+  bond_present = BondsinSceneMap.count(ids);
+  if (!bond_present)
+    bondInserted(_bond, _side);
+  else {
+    BondsinSceneMap[ids]->resetPosition();
+    BondsinSceneMap[ids]->resetWidth();
+  }
+}
+
+void GLMoleculeObject_molecule::addAtomBonds(
+    const atom *_atom)
+{
+  const bool atom_present = AtomsinSceneMap.count(_atom->getId());
+  const BondList &bondlist = _atom->getListOfBonds();
+  for (BondList::const_iterator bonditer = bondlist.begin();
+      (bonditer != bondlist.end()) && atom_present;
+      ++bonditer) {
+    const bond::ptr _bond = *bonditer;
+    // check if OtherAtom's sphere is already present
+    const atom *OtherAtom = _bond->GetOtherAtom(_atom);
+    const bool otheratom_present = AtomsinSceneMap.count(OtherAtom->getId());
+    if (otheratom_present && atom_present) {
+      const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == _atom) ?
+          GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
+      const GLMoleculeObject_bond::SideOfBond otherside = (_bond->leftatom == _atom) ?
+          GLMoleculeObject_bond::right : GLMoleculeObject_bond::left;
+      addAtomBonds(_bond, side);
+      addAtomBonds(_bond, otherside);
+    }
+  }
+}
+
+void GLMoleculeObject_molecule::reinit()
+{
+  if (_molecule->getAtomCount() > 0) {
+    for (molecule::const_iterator atomiter = _molecule->begin();
+        atomiter != _molecule->end();
+        atomiter++) {
+      // check whether atom already exists
+      const atomId_t atomid = (*atomiter)->getId();
+      const bool atom_present = AtomsinSceneMap.count(atomid);
+      if (!atom_present)
+        atomInserted((*atomiter)->getId());
+      else
+        AtomsinSceneMap[atomid]->resetPosition();
+
+
+      // create bond objects in scene
+      addAtomBonds(*atomiter);
+    }
+  }
 }
 
@@ -108,4 +204,26 @@
           << notification->getChannelNo() << ".";
 #endif
+    switch (notification->getChannelNo()) {
+      case molecule::AtomInserted:
+      {
+        const atomId_t _id = _molecule->lastChanged()->getId();
+  #ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been inserted.";
+  #endif
+        atomInserted(_id);
+        break;
+      }
+      case World::AtomRemoved:
+      {
+        const atomId_t _id = _molecule->lastChanged()->getId();
+  #ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been removed.";
+  #endif
+        atomRemoved(_id);
+        break;
+      }
+      default:
+        break;
+    }
   }else{
     // notification from world
@@ -125,2 +243,172 @@
 }
 
+void GLMoleculeObject_molecule::initialize(QGLView *view, QGLPainter *painter)
+{
+  // Initialize all of the mesh objects that we have as children.
+//  GLMoleculeObject::initialize(view, painter);
+   foreach (QObject *obj, children()) {
+     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
+       if (meshobj)
+         meshobj->initialize(view, painter);
+   }
+}
+
+void GLMoleculeObject_molecule::draw(QGLPainter *painter, const QVector4D &cameraPlane)
+{
+   // Draw all of the mesh objects that we have as children.
+  GLMoleculeObject::draw(painter, cameraPlane);
+   foreach (QObject *obj, children()) {
+     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
+       if (meshobj)
+         meshobj->draw(painter, cameraPlane);
+   }
+}
+
+/** Adds an atom of this molecule to the scene.
+ *
+ * @param _atom atom to add
+ */
+void GLMoleculeObject_molecule::atomInserted(const atomicNumber_t _id)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "+toString(_id)+".");
+  GLMoleculeObject_atom *atomObject = new GLMoleculeObject_atom(GLMoleculeObject::meshSphere, this, _id);
+  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
+  ASSERT(iter == AtomsinSceneMap.end(),
+      "GLWorldScene::atomAdded() - same atom with id "+toString(_id)+" added again.");
+  AtomsinSceneMap.insert( make_pair(_id, atomObject) );
+
+  qRegisterMetaType<atomId_t>("atomId_t");
+  qRegisterMetaType<bond::ptr>("bond::ptr");
+  qRegisterMetaType<GLMoleculeObject_bond::SideOfBond>("GLMoleculeObject_bond::SideOfBond");
+  connect (atomObject, SIGNAL(clicked(atomId_t)), this, SIGNAL(atomClicked(atomId_t)));
+  connect (atomObject, SIGNAL(changed()), this, SIGNAL(changed()));
+  connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
+  connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
+  connect (atomObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
+  connect (atomObject, SIGNAL(BondsInserted(const bond::ptr , const GLMoleculeObject_bond::SideOfBond)), this, SLOT(bondInserted(const bond::ptr , const GLMoleculeObject_bond::SideOfBond)));
+  connect (atomObject, SIGNAL(indexChanged(GLMoleculeObject_atom*, int, int)), this, SIGNAL(changeAtomId(GLMoleculeObject_atom*, int, int)));
+
+  updateBoundingBox();
+
+  //bondsChanged(_atom);
+  emit changeOccured();
+}
+
+/** Removes an atom of this molecule from the scene.
+ *
+ * We just the id as the atom might have already been destroyed.
+ *
+ * @param _id id of atom to remove
+ */
+void GLMoleculeObject_molecule::atomRemoved(const atomicNumber_t _id)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal atomRemoved for atom "+toString(_id)+".");
+  // bonds are removed by signal coming from ~bond
+  // remove atoms
+  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
+  ASSERT(iter != AtomsinSceneMap.end(),
+      "GLWorldScene::atomRemoved() - atom "+toString(_id)+" not on display.");
+  GLMoleculeObject_atom *atomObject = iter->second;
+  atomObject->disconnect();
+  AtomsinSceneMap.erase(iter);
+  delete atomObject;
+
+  updateBoundingBox();
+
+  emit changeOccured();
+}
+
+void GLMoleculeObject_molecule::hoverChangedSignalled(GLMoleculeObject *ob)
+{
+  // Find the atom, ob corresponds to.
+  hoverAtom = NULL;
+  GLMoleculeObject_atom *atomObject = dynamic_cast<GLMoleculeObject_atom *>(ob);
+  if (atomObject){
+    for (AtomNodeMap::iterator iter = AtomsinSceneMap.begin();iter != AtomsinSceneMap.end(); ++ iter){
+      if (iter->second == atomObject)
+        hoverAtom = World::getInstance().getAtom(AtomById(iter->first));
+    }
+  }
+
+  // Propagate signal.
+  emit hoverChanged(hoverAtom);
+}
+
+
+/** Helper function to get bond ids in the correct order for BondNodeMap.
+ *
+ * \return pair of ids in correct order.
+ */
+GLMoleculeObject_molecule::BondIds GLMoleculeObject_molecule::getBondIds(
+    const bond::ptr _bond,
+    const enum GLMoleculeObject_bond::SideOfBond _side)
+{
+  BondIds ids;
+  switch (_side) {
+    case GLMoleculeObject_bond::left:
+      ids = std::make_pair(_bond->leftatom->getId(), _bond->rightatom->getId());
+      break;
+    case GLMoleculeObject_bond::right:
+      ids = std::make_pair(_bond->rightatom->getId(), _bond->leftatom->getId());
+      break;
+  }
+  return ids;
+}
+
+/** Adds a bond to the scene.
+ *
+ * @param _bond bond to add
+ * @param side which side of the bond (left or right)
+ */
+void GLMoleculeObject_molecule::bondInserted(const bond::ptr _bond, const enum GLMoleculeObject_bond::SideOfBond _side)
+{
+  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bond "+toString(*_bond)+".");
+  //LOG(4, "INFO: Currently present bonds " << BondsinSceneMap << ".");
+
+  const BondIds ids = getBondIds(_bond, _side);
+  BondNodeMap::iterator iter = BondsinSceneMap.find(ids);
+  if (iter == BondsinSceneMap.end()) {
+    GLMoleculeObject_bond * bondObject =
+        new GLMoleculeObject_bond(GLMoleculeObject::meshCylinder, this, _bond, _side);
+    connect (
+        bondObject, SIGNAL(BondRemoved(const atomId_t, const atomId_t)),
+        this, SLOT(bondRemoved(const atomId_t, const atomId_t)));
+    connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
+    BondsinSceneMap.insert( make_pair(ids, bondObject) );
+  //    BondIdsinSceneMap.insert( Leftids );
+  } else {
+    iter->second->resetPosition();
+    iter->second->resetWidth();
+  }
+  emit changeOccured();
+}
+
+/** Removes a bond from the scene.
+ *
+ * @param _bond bond to remove
+ */
+void GLMoleculeObject_molecule::bondRemoved(const atomId_t leftnr, const atomId_t rightnr)
+{
+  LOG(3, "INFO: GLWorldScene::bondRemoved() - Removing bond between "+toString(leftnr)+" and "+toString(rightnr)+".");
+  {
+    // left bond
+    const BondIds Leftids( make_pair(leftnr, rightnr) );
+    BondNodeMap::iterator leftiter = BondsinSceneMap.find( Leftids );
+    ASSERT(leftiter != BondsinSceneMap.end(),
+        "GLWorldScene::bondRemoved() - bond "+toString(leftnr)+"-"
+        +toString(rightnr)+" not on display.");
+    GLMoleculeObject_bond *bondObject = leftiter->second;
+    bondObject->disconnect();
+    BondsinSceneMap.erase(leftiter);
+    delete bondObject; // is done by signal from bond itself
+    //LOG(4, "INFO: Still present bonds " << BondsinSceneMap << ".");
+  }
+
+  emit changeOccured();
+}
+
+std::ostream &operator<<(std::ostream &ost, const GLMoleculeObject_molecule::BondIds &t)
+{
+  ost << t.first << "," << t.second;
+  return ost;
+}
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -22,4 +22,6 @@
 class atom;
 class bond;
+class GLMoleculeObject_atom;
+class GLWorldScene;
 class molecule;
 
@@ -38,9 +40,58 @@
   void recieveNotification(Observable *publisher, Notification_ptr notification);
 
+  void initialize(QGLView *view, QGLPainter *painter);
+  void draw(QGLPainter *painter, const QVector4D &cameraPlane);
+
+  typedef std::pair< atomId_t, atomId_t> BondIds;
+  friend std::ostream &operator<<(std::ostream &ost, const BondIds &t);
+
+  static BondIds getBondIds(
+      const bond::ptr _bond,
+      const enum GLMoleculeObject_bond::SideOfBond side);
+
+  void selected(const bool _isSelected)
+  { isSelected = _isSelected; }
+
+signals:
+  void changed();
+  void changeOccured();
+  void hoverChanged(const atom*);
+  void atomClicked(atomId_t no);
+  void changeAtomId(GLMoleculeObject_atom *, int, int);
+
+private slots:
+  //!> grant GLWorldScene access to private slots
+  friend class GLWorldScene;
+
+  void atomInserted(const atomicNumber_t _id);
+  void atomRemoved(const atomicNumber_t _id);
+  void bondInserted(const bond::ptr _bond, const GLMoleculeObject_bond::SideOfBond side);
+  void bondRemoved(const atomId_t leftnr, const atomId_t rightnr);
+  void hoverChangedSignalled(GLMoleculeObject *ob);
+
 private:
+  void init();
+  void reinit();
+
+  void addAtomBonds(
+      const bond::ptr &_bond,
+      const GLMoleculeObject_bond::SideOfBond _side
+      );
+  void addAtomBonds(const atom *_atom);
+
+  //!> states whether selection box is additionally drawn or not
+  bool isSelected;
 
   const molecule *_molecule;
+
+  typedef std::map< atomId_t, GLMoleculeObject_atom* > AtomNodeMap;
+  typedef std::map< BondIds , GLMoleculeObject_bond* > BondNodeMap;
+  AtomNodeMap AtomsinSceneMap;
+  BondNodeMap BondsinSceneMap;
+
+  const atom *hoverAtom;
 };
 
+std::ostream &operator<<(std::ostream &ost, const GLMoleculeObject_molecule::BondIds &t);
 
 
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -60,4 +60,5 @@
 #include "Bond/bond.hpp"
 #include "Descriptors/AtomIdDescriptor.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
 #include "Helpers/helpers.hpp"
 #include "Shapes/ShapeRegistry.hpp"
@@ -69,13 +70,6 @@
 using namespace MoleCuilder;
 
-std::ostream &operator<<(std::ostream &ost, const GLWorldScene::BondIds &t)
-{
-  ost << t.first << "," << t.second;
-  return ost;
-}
-
 GLWorldScene::GLWorldScene(QObject *parent)
-   : QObject(parent),
-     hoverAtom(NULL)
+   : QObject(parent)
 {
   int sphereDetails[] = {5, 3, 2, 0};
@@ -83,16 +77,17 @@
   for (int i=0;i<GLMoleculeObject::DETAILTYPES_MAX;i++){
     QGLBuilder emptyBuilder;
-    meshEmpty[i] = emptyBuilder.finalizedSceneNode();
+    GLMoleculeObject::meshEmpty[i] = emptyBuilder.finalizedSceneNode();
     QGLBuilder sphereBuilder;
     sphereBuilder << QGLSphere(2.0, sphereDetails[i]);
-    meshSphere[i] = sphereBuilder.finalizedSceneNode();
-    meshSphere[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    GLMoleculeObject::meshSphere[i] = sphereBuilder.finalizedSceneNode();
+    GLMoleculeObject::meshSphere[i]->setOption(QGLSceneNode::CullBoundingBox, true);
     QGLBuilder cylinderBuilder;
     cylinderBuilder << QGLCylinder(.25,.25,1.0,cylinderDetails[i]);
-    meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
-    meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    GLMoleculeObject::meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
+    GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
 
   connect(this, SIGNAL(updated()), this, SLOT(update()));
+
 
   setSelectionMode(SelectAtom);
@@ -112,24 +107,11 @@
 void GLWorldScene::init()
 {
-  const std::vector<atom*> &atoms = World::getInstance().getAllAtoms();
-
-  if (atoms.size() > 0) {
-    for (std::vector<atom*>::const_iterator atomiter = atoms.begin();
-        atomiter != atoms.end();
-        atomiter++) {
-      // create atom objects in scene
-      atomInserted((*atomiter)->getId());
-
-      // create bond objects in scene
-      const BondList &bondlist = (*atomiter)->getListOfBonds();
-      for (BondList::const_iterator bonditer = bondlist.begin();
-          bonditer != bondlist.end();
-          ++bonditer) {
-        const bond::ptr _bond = *bonditer;
-        const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == *atomiter) ?
-            GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
-        bondInserted(_bond, side);
-      }
-    }
+  const std::vector<molecule *> &molecules = World::getInstance().getAllMolecules();
+
+  for (std::vector<molecule*>::const_iterator moliter = molecules.begin();
+      moliter != molecules.end();
+      moliter++) {
+    // create molecule objects in scene
+    moleculeInserted(*moliter);
   }
 }
@@ -143,281 +125,20 @@
 void GLWorldScene::update()
 {
-  const std::vector<atom*> &atoms = World::getInstance().getAllAtoms();
-
-  if (atoms.size() > 0) {
-    for (std::vector<atom*>::const_iterator atomiter = atoms.begin();
-        atomiter != atoms.end();
-        atomiter++) {
-      // check whether atom already exists
-      const atomId_t atomid = (*atomiter)->getId();
-      const bool atom_present = AtomsinSceneMap.count(atomid);
-      if (!atom_present)
-        atomInserted((*atomiter)->getId());
-      else
-        AtomsinSceneMap[atomid]->resetPosition();
-
-
-      // create bond objects in scene
-      const BondList &bondlist = (*atomiter)->getListOfBonds();
-      for (BondList::const_iterator bonditer = bondlist.begin();
-          bonditer != bondlist.end();
-          ++bonditer) {
-        const bond::ptr _bond = *bonditer;
-        const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == *atomiter) ?
-            GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
-        bool bond_present = false;
-        const BondIds ids = getBondIds(_bond,side);
-        if (atom_present) {
-          // check whether bond is not present already
-          bond_present = BondsinSceneMap.count(ids);
-        }
-        if (!bond_present)
-          bondInserted(_bond, side);
-        else {
-          BondsinSceneMap[ids]->resetPosition();
-          BondsinSceneMap[ids]->resetWidth();
-        }
-      }
-    }
-  }
-}
-
-/** Adds an atom to the scene.
- *
- * @param _atom atom to add
- */
-void GLWorldScene::atomInserted(const atomicNumber_t _id)
-{
-  LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "+toString(_id)+".");
-  GLMoleculeObject_atom *atomObject = new GLMoleculeObject_atom(meshSphere, this, _id);
-  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
-  ASSERT(iter == AtomsinSceneMap.end(),
-      "GLWorldScene::atomAdded() - same atom with id "+toString(_id)+" added again.");
-  AtomsinSceneMap.insert( make_pair(_id, atomObject) );
-
-  qRegisterMetaType<atomId_t>("atomId_t");
-  qRegisterMetaType<bond::ptr>("bond::ptr");
-  qRegisterMetaType<GLMoleculeObject_bond::SideOfBond>("GLMoleculeObject_bond::SideOfBond");
-  connect (atomObject, SIGNAL(clicked(atomId_t)), this, SLOT(atomClicked(atomId_t)));
-  connect (atomObject, SIGNAL(changed()), this, SIGNAL(changed()));
-  connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
-  connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
-  connect (atomObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
-  connect (atomObject, SIGNAL(BondsInserted(const bond::ptr , const GLMoleculeObject_bond::SideOfBond)), this, SLOT(bondInserted(const bond::ptr , const GLMoleculeObject_bond::SideOfBond)));
-  connect (atomObject, SIGNAL(indexChanged(GLMoleculeObject_atom*, int, int)), this, SLOT(changeAtomId(GLMoleculeObject_atom*, int, int)));
-  //bondsChanged(_atom);
-  emit changeOccured();
-}
-
-/** Removes an atom from the scene.
- *
- * We just the id as the atom might have already been destroyed.
- *
- * @param _id id of atom to remove
- */
-void GLWorldScene::atomRemoved(const atomicNumber_t _id)
-{
-  LOG(3, "INFO: GLWorldScene: Received signal atomRemoved for atom "+toString(_id)+".");
-  // bonds are removed by signal coming from ~bond
-  // remove atoms
-  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
-  ASSERT(iter != AtomsinSceneMap.end(),
-      "GLWorldScene::atomRemoved() - atom "+toString(_id)+" not on display.");
-  GLMoleculeObject_atom *atomObject = iter->second;
-  atomObject->disconnect();
-  AtomsinSceneMap.erase(iter);
-  delete atomObject;
-  emit changeOccured();
-}
-
-/** ....
- *
- */
-void GLWorldScene::worldSelectionChanged()
-{
-  LOG(3, "INFO: GLWorldScene: Received signal selectionChanged.");
-
-  const std::vector<molecule*> &molecules = World::getInstance().getAllMolecules();
-
-  if (molecules.size() > 0) {
-    for (std::vector<molecule*>::const_iterator Runner = molecules.begin();
-        Runner != molecules.end();
-        Runner++) {
-
-      MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find((*Runner)->getId());
-      bool isSelected = World::getInstance().isSelected(*Runner);
-
-      // molecule selected but not in scene?
-      if (isSelected && (iter == MoleculesinSceneMap.end())){
-        // -> create new mesh
-        GLMoleculeObject_molecule *molObject = new GLMoleculeObject_molecule(meshEmpty, this, *Runner);
-        MoleculesinSceneMap.insert( make_pair((*Runner)->getId(), molObject) );
-        connect (molObject, SIGNAL(changed()), this, SIGNAL(changed()));
-        connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
-        connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
-        emit changed();
-        emit changeOccured();
-      }
-
-      // molecule not selected but in scene?
-      if (!isSelected && (iter != MoleculesinSceneMap.end())){
-        // -> remove from scene
-        moleculeRemoved(*Runner);
-      }
-
-    }
-  }
-}
-
-/** Removes a molecule from the scene.
- *
- * @param _molecule molecule to remove
- */
-void GLWorldScene::moleculeRemoved(const molecule *_molecule)
-{
-  LOG(3, "INFO: GLWorldScene: Received signal moleculeRemoved for molecule "+toString(_molecule->getId())+".");
-  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molecule->getId());
-
-  // only remove if the molecule is in the scene
-  //  (= is selected)
-  if (iter != MoleculesinSceneMap.end()){
-    GLMoleculeObject_molecule *molObject = iter->second;
-    molObject->disconnect();
-    MoleculesinSceneMap.erase(iter);
-    delete molObject;
-    emit changed();
-    emit changeOccured();
-  }
-}
-
-/** Helper function to get bond ids in the correct order for BondNodeMap.
- *
- * \return pair of ids in correct order.
- */
-GLWorldScene::BondIds GLWorldScene::getBondIds(
-    const bond::ptr _bond,
-    const enum GLMoleculeObject_bond::SideOfBond _side) const
-{
-  BondIds ids;
-  switch (_side) {
-    case GLMoleculeObject_bond::left:
-      ids = std::make_pair(_bond->leftatom->getId(), _bond->rightatom->getId());
-      break;
-    case GLMoleculeObject_bond::right:
-      ids = std::make_pair(_bond->rightatom->getId(), _bond->leftatom->getId());
-      break;
-  }
-  return ids;
-}
-
-/** Adds a bond to the scene.
- *
- * @param _bond bond to add
- * @param side which side of the bond (left or right)
- */
-void GLWorldScene::bondInserted(const bond::ptr _bond, const enum GLMoleculeObject_bond::SideOfBond _side)
-{
-  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bond "+toString(*_bond)+".");
-  //LOG(4, "INFO: Currently present bonds " << BondsinSceneMap << ".");
-
-  const BondIds ids = getBondIds(_bond, _side);
-  BondNodeMap::iterator iter = BondsinSceneMap.find(ids);
-  if (iter == BondsinSceneMap.end()) {
-    GLMoleculeObject_bond * bondObject =
-        new GLMoleculeObject_bond(meshCylinder, this, _bond, _side);
-    connect (
-        bondObject, SIGNAL(BondRemoved(const atomId_t, const atomId_t)),
-        this, SLOT(bondRemoved(const atomId_t, const atomId_t)));
-    connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
-    BondsinSceneMap.insert( make_pair(ids, bondObject) );
-  //    BondIdsinSceneMap.insert( Leftids );
-  } else {
-    iter->second->resetPosition();
-    iter->second->resetWidth();
-  }
-  emit changeOccured();
-}
-
-/** Removes a bond from the scene.
- *
- * @param _bond bond to remove
- */
-void GLWorldScene::bondRemoved(const atomId_t leftnr, const atomId_t rightnr)
-{
-  LOG(3, "INFO: GLWorldScene::bondRemoved() - Removing bond between "+toString(leftnr)+" and "+toString(rightnr)+".");
-  {
-    // left bond
-    const BondIds Leftids( make_pair(leftnr, rightnr) );
-    BondNodeMap::iterator leftiter = BondsinSceneMap.find( Leftids );
-    ASSERT(leftiter != BondsinSceneMap.end(),
-        "GLWorldScene::bondRemoved() - bond "+toString(leftnr)+"-"
-        +toString(rightnr)+" not on display.");
-    GLMoleculeObject_bond *bondObject = leftiter->second;
-    BondsinSceneMap.erase(leftiter);
-    delete bondObject; // is done by signal from bond itself
-    //LOG(4, "INFO: Still present bonds " << BondsinSceneMap << ".");
-  }
-
-  emit changeOccured();
-}
-
-/** Adds a shape to the scene.
- *
- * uses ShapeRegistry::lastChanged()
- *
- */
-void GLWorldScene::addShape()
-{
-  Shape &shape = *ShapeRegistry::getInstance().lastChanged();
-  GLMoleculeObject_shape *shapeObject = new GLMoleculeObject_shape(shape, this);
-  ShapeNodeMap::iterator iter = ShapesinSceneMap.find(shape.getName());
-  ASSERT(iter == ShapesinSceneMap.end(),
-      "GLWorldScene::addShape() - same shape "+shape.getName()+" added again.");
-  ShapesinSceneMap.insert( make_pair(shape.getName(), shapeObject) );
-}
-
-void GLWorldScene::removeShape()
-{
-  Shape &shape = *ShapeRegistry::getInstance().lastChanged();
-  ShapeNodeMap::iterator iter = ShapesinSceneMap.find(shape.getName());
-  ASSERT(iter != ShapesinSceneMap.end(),
-      "GLWorldScene::removeShape() - shape "+shape.getName()+" not in scene.");
-  ShapesinSceneMap.erase(iter);
-  delete(iter->second);
-}
-
-void GLWorldScene::updateSelectedShapes()
-{
-  foreach (QObject *obj, children()) {
-    GLMoleculeObject_shape *shapeobj = qobject_cast<GLMoleculeObject_shape *>(obj);
-      if (shapeobj){
-        shapeobj->enable(ShapeRegistry::getInstance().isSelected(shapeobj->getShape()));
-      }
-  }
-}
-
-void GLWorldScene::initialize(QGLView *view, QGLPainter *painter) const
-{
-  // Initialize all of the mesh objects that we have as children.
-   foreach (QObject *obj, children()) {
-     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
-       if (meshobj)
-         meshobj->initialize(view, painter);
-   }
-}
-
-void GLWorldScene::draw(QGLPainter *painter, const QVector4D &cameraPlane) const
-{
-   // Draw all of the mesh objects that we have as children.
-   foreach (QObject *obj, children()) {
-     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
-       if (meshobj)
-         meshobj->draw(painter, cameraPlane);
-   }
+  const std::vector<molecule *> &molecules = World::getInstance().getAllMolecules();
+
+  for (std::vector<molecule*>::const_iterator moliter = molecules.begin();
+      moliter != molecules.end();
+      moliter++) {
+    // check whether molecule already exists
+    const moleculeId_t molid = (*moliter)->getId();
+    const bool mol_present = MoleculesinSceneMap.count(molid);
+    if (!mol_present)
+      moleculeInserted(*moliter);
+  }
 }
 
 void GLWorldScene::atomClicked(atomId_t no)
 {
-   LOG(3, "INFO: GLWorldScene - atom " << no << " has been clicked.");
+   LOG(3, "INFO: GLMoleculeObject_molecule - atom " << no << " has been clicked.");
    const atom *Walker = World::getInstance().getAtom(AtomById(no));
    if (selectionMode == SelectAtom){
@@ -437,4 +158,251 @@
 }
 
+
+/** Adds an atom to the scene.
+ *
+ * @param _atom atom to add
+ */
+void GLWorldScene::atomInserted(const atomId_t _id)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "+toString(_id)+".");
+  // find associated molecule
+  const moleculeId_t molid = World::getInstance().getAtom(AtomById(_id))->getMolecule()->getId();
+  MoleculeNodeMap::const_iterator moliter = MoleculesinSceneMap.find(molid );
+  ASSERT(moliter != MoleculesinSceneMap.end(),
+      "GLWorldScene::atomAdded() - molecule with id of "+toString(molid)
+      +" atom with id "+toString(_id)+" is unknown.");
+  GLMoleculeObject_molecule *molObject = moliter->second;
+
+  // add atom to internal list
+#ifndef NDEBUG
+  AtomMoleculeMap::const_iterator atomiter = AtomsinSceneMap.find(_id);
+    ASSERT(atomiter == AtomsinSceneMap.end(),
+        "GLWorldScene::atomRemoved() - atom "+toString(_id)+" already known.");
+#endif
+  AtomsinSceneMap.insert( std::make_pair( _id, molObject ));
+
+  // inform its GlMoleculeObject_molecule.
+  molObject->atomInserted(_id);
+
+  // emit change
+  emit changeOccured();
+}
+
+/** Removes an atom from the scene.
+ *
+ * We just the id as the atom might have already been destroyed.
+ *
+ * @param _id id of atom to remove
+ */
+void GLWorldScene::atomRemoved(const atomId_t _id)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal atomRemoved for atom "+toString(_id)+".");
+  // find associated molecule
+  AtomMoleculeMap::iterator iter = AtomsinSceneMap.find(_id);
+  ASSERT(iter != AtomsinSceneMap.end(),
+      "GLWorldScene::atomRemoved() - atom "+toString(_id)+" not on display.");
+  GLMoleculeObject_molecule *molObject = iter->second;
+
+  // remove from internal list
+  AtomsinSceneMap.erase(iter);
+
+  // inform its GlMoleculeObject_molecule.
+  molObject->atomRemoved(_id);
+
+  // emit change
+  emit changeOccured();
+}
+
+/** ....
+ *
+ */
+void GLWorldScene::worldSelectionChanged()
+{
+  LOG(3, "INFO: GLWorldScene: Received signal selectionChanged.");
+
+  const std::vector<molecule*> &molecules = World::getInstance().getAllMolecules();
+
+  if (molecules.size() > 0) {
+    for (std::vector<molecule*>::const_iterator Runner = molecules.begin();
+        Runner != molecules.end();
+        Runner++) {
+
+      // molecule selected but not in scene?
+      const bool isSelected = World::getInstance().isSelected(*Runner);
+      if (isSelected){
+        MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find((*Runner)->getId());
+        ASSERT( iter != MoleculesinSceneMap.end(),
+            "GLWorldScene::worldSelectionChanged() - selected molecule is unknown.");
+        GLMoleculeObject_molecule *molObject = iter->second;
+        // inform molecule object
+        molObject->selected(isSelected);
+      }
+    }
+  }
+}
+
+/** Inserts a molecule into the scene.
+ *
+ * @param _mol molecule to insert
+ */
+void GLWorldScene::moleculeInserted(const molecule * _mol)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal moleculeRemoved for molecule "+toString(_mol->getId())+".");
+  MoleculeNodeMap::const_iterator iter = MoleculesinSceneMap.find(_mol->getId());
+  ASSERT( iter == MoleculesinSceneMap.end(),
+      "GLWorldScene::moleculeInserted() - molecule's id "+toString(_mol->getId())+" already present.");
+
+  // add new object
+  GLMoleculeObject_molecule *molObject = new GLMoleculeObject_molecule(GLMoleculeObject::meshEmpty, this, _mol);
+  MoleculesinSceneMap.insert( make_pair(_mol->getId(), molObject) );
+  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(changeAtomId(GLMoleculeObject_atom *, int, int)), this, SLOT(changeAtomId(GLMoleculeObject_atom *, int, int)));
+  connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
+  connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
+  connect (molObject, SIGNAL(hoverChanged(const atom *)), this, SIGNAL(hoverChanged(const atom *)));
+  emit changed();
+  emit changeOccured();
+}
+
+/** Removes a molecule from the scene.
+ *
+ * @param _id id of molecule to remove
+ */
+void GLWorldScene::moleculeRemoved(const moleculeId_t _id)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal moleculeRemoved for molecule "+toString(_id)+".");
+  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_id);
+  ASSERT( iter != MoleculesinSceneMap.end(),
+      "GLWorldScene::moleculeInserted() - molecule's id "+toString(_id)+" is unknown.");
+
+  GLMoleculeObject_molecule *molObject = iter->second;
+  molObject->disconnect();
+  MoleculesinSceneMap.erase(iter);
+  delete molObject;
+  emit changed();
+  emit changeOccured();
+}
+
+/** Adds a bond to the scene.
+ *
+ * @param _bond bond to add
+ * @param side which side of the bond (left or right)
+ */
+void GLWorldScene::bondInserted(const bond::ptr _bond, const enum GLMoleculeObject_bond::SideOfBond _side)
+{
+  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bond "+toString(*_bond)+".");
+  //LOG(4, "INFO: Currently present bonds " << BondsinSceneMap << ".");
+  // bond partners must both belong to same atom
+  ASSERT( _bond->leftatom->getMolecule() == _bond->rightatom->getMolecule(),
+      "GLWorldScene::bondInserted() - bond partners do not belong to same molecule.");
+
+  // find associated molecule object
+  const moleculeId_t molid = _bond->leftatom->getMolecule()->getId();
+  MoleculeNodeMap::const_iterator moliter = MoleculesinSceneMap.find(molid );
+  ASSERT(moliter != MoleculesinSceneMap.end(),
+      "GLWorldScene::bondInserted() - molecule with id of "+toString(molid)
+      +" atom with id "+toString(_bond->leftatom->getId())+" is unknown.");
+  GLMoleculeObject_molecule *molObject = moliter->second;
+
+  // add to internal list
+  const GLMoleculeObject_molecule::BondIds ids =
+      GLMoleculeObject_molecule::getBondIds(_bond, _side);
+  BondMoleculeMap::const_iterator iter = BondsinSceneMap.find(ids);
+  ASSERT(iter == BondsinSceneMap.end(),
+      "GLWorldScene::bondInserted() - bond with ids "+toString(ids.first)
+      +","+toString(ids.second)+" already present.");
+  BondsinSceneMap.insert( std::make_pair( ids, molObject ));
+
+  // inform its GlMoleculeObject_molecule.
+  molObject->bondInserted(_bond, _side);
+
+  // emit change
+  emit changeOccured();
+}
+
+/** Removes a bond from the scene.
+ *
+ * @param _bond bond to remove
+ */
+void GLWorldScene::bondRemoved(const atomId_t leftnr, const atomId_t rightnr)
+{
+  LOG(3, "INFO: GLWorldScene::bondRemoved() - Removing bond between "+toString(leftnr)+" and "+toString(rightnr)+".");
+  {
+    // left bond
+    const GLMoleculeObject_molecule::BondIds Leftids( make_pair(leftnr, rightnr) );
+    BondMoleculeMap::iterator leftiter = BondsinSceneMap.find( Leftids );
+    ASSERT(leftiter != BondsinSceneMap.end(),
+        "GLWorldScene::bondRemoved() - bond "+toString(leftnr)+"-"
+        +toString(rightnr)+" not on display.");
+    GLMoleculeObject_molecule *molObject = leftiter->second;
+
+    // remove from internal list
+    BondsinSceneMap.erase(leftiter);
+
+    // inform its GlMoleculeObject_molecule.
+    molObject->bondRemoved( leftnr, rightnr );
+  }
+
+  // emit change
+  emit changeOccured();
+}
+
+/** Adds a shape to the scene.
+ *
+ * uses ShapeRegistry::lastChanged()
+ *
+ */
+void GLWorldScene::addShape()
+{
+  Shape &shape = *ShapeRegistry::getInstance().lastChanged();
+  GLMoleculeObject_shape *shapeObject = new GLMoleculeObject_shape(shape, this);
+  ShapeNodeMap::iterator iter = ShapesinSceneMap.find(shape.getName());
+  ASSERT(iter == ShapesinSceneMap.end(),
+      "GLWorldScene::addShape() - same shape "+shape.getName()+" added again.");
+  ShapesinSceneMap.insert( make_pair(shape.getName(), shapeObject) );
+}
+
+void GLWorldScene::removeShape()
+{
+  Shape &shape = *ShapeRegistry::getInstance().lastChanged();
+  ShapeNodeMap::iterator iter = ShapesinSceneMap.find(shape.getName());
+  ASSERT(iter != ShapesinSceneMap.end(),
+      "GLWorldScene::removeShape() - shape "+shape.getName()+" not in scene.");
+  ShapesinSceneMap.erase(iter);
+  delete(iter->second);
+}
+
+void GLWorldScene::updateSelectedShapes()
+{
+  foreach (QObject *obj, children()) {
+    GLMoleculeObject_shape *shapeobj = qobject_cast<GLMoleculeObject_shape *>(obj);
+      if (shapeobj){
+        shapeobj->enable(ShapeRegistry::getInstance().isSelected(shapeobj->getShape()));
+      }
+  }
+}
+
+void GLWorldScene::initialize(QGLView *view, QGLPainter *painter) const
+{
+  // Initialize all of the mesh objects that we have as children.
+   foreach (QObject *obj, children()) {
+     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
+       if (meshobj)
+         meshobj->initialize(view, painter);
+   }
+}
+
+void GLWorldScene::draw(QGLPainter *painter, const QVector4D &cameraPlane) const
+{
+   // Draw all of the mesh objects that we have as children.
+   foreach (QObject *obj, children()) {
+     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
+       if (meshobj)
+         meshobj->draw(painter, cameraPlane);
+   }
+}
+
 void GLWorldScene::setSelectionMode(SelectionModeType mode)
 {
@@ -453,32 +421,29 @@
 }
 
-void GLWorldScene::hoverChangedSignalled(GLMoleculeObject *ob)
-{
-  // Find the atom, ob corresponds to.
-  hoverAtom = NULL;
-  GLMoleculeObject_atom *atomObject = dynamic_cast<GLMoleculeObject_atom *>(ob);
-  if (atomObject){
-    for (AtomNodeMap::iterator iter = AtomsinSceneMap.begin();iter != AtomsinSceneMap.end(); ++ iter){
-      if (iter->second == atomObject)
-        hoverAtom = World::getInstance().getAtom(AtomById(iter->first));
-    }
-  }
-
-  // Propagate signal.
-  emit hoverChanged(hoverAtom);
-}
-
 void GLWorldScene::changeAtomId(GLMoleculeObject_atom *ob, int oldId, int newId)
 {
   LOG(3, "INFO: GLWorldScene - change atom id " << oldId << " to " << newId << ".");
   // Remove from map.
-  AtomNodeMap::iterator iter = AtomsinSceneMap.find(oldId);
+  AtomMoleculeMap::iterator iter = AtomsinSceneMap.find(oldId);
   ASSERT(iter != AtomsinSceneMap.end(),
-        "GLWorldScene::objectIdChangedSignalled() - atom with id "+toString(oldId)+" not on display.");
-  GLMoleculeObject_atom *atomObject = iter->second;
+        "GLWorldScene::changeAtomId() - atom with old id "+toString(oldId)+" not on display.");
+  GLMoleculeObject_molecule *molObject = iter->second;
+
+  // erase by signalling removal
+  molObject->atomRemoved(oldId);
+
+  // remove from internal list
   AtomsinSceneMap.erase(iter);
 
   // Reinsert with new id.
-  AtomsinSceneMap.insert( make_pair(newId, atomObject) );
-}
-
+  {
+    AtomMoleculeMap::iterator iter = AtomsinSceneMap.find(newId);
+    ASSERT(iter == AtomsinSceneMap.end(),
+          "GLWorldScene::changeAtomId() - atom with new id "+toString(newId)+" already known.");
+  }
+  AtomsinSceneMap.insert( make_pair(newId, molObject) );
+
+  // inform molecule object
+  molObject->atomInserted(oldId);
+}
+
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -75,11 +75,12 @@
   void clicked(atomId_t);
   void doubleClicked();
-  void hoverChanged(const atom*);
+  void hoverChanged(const atom *);
 
 private slots:
   void atomClicked(atomId_t no);
-  void atomInserted(const atomicNumber_t _id);
-  void atomRemoved(const atomicNumber_t _id);
-  void moleculeRemoved(const molecule *_molecule);
+  void atomInserted(const atomId_t _id);
+  void atomRemoved(const atomId_t _id);
+  void moleculeRemoved(const moleculeId_t _id);
+  void moleculeInserted(const molecule * _mol);
   void worldSelectionChanged();
   void bondInserted(const bond::ptr _bond, const GLMoleculeObject_bond::SideOfBond side);
@@ -87,5 +88,4 @@
   void setSelectionModeAtom();
   void setSelectionModeMolecule();
-  void hoverChangedSignalled(GLMoleculeObject *ob);
   void changeAtomId(GLMoleculeObject_atom *ob, int oldId, int newOd);
   void addShape();
@@ -100,29 +100,16 @@
 
 private:
-  typedef std::pair< atomId_t, atomId_t> BondIds;
-  friend std::ostream &operator<<(std::ostream &ost, const BondIds &t);
 
-  BondIds getBondIds(
-      const bond::ptr _bond,
-      const enum GLMoleculeObject_bond::SideOfBond side) const;
-
-  typedef std::map< atomId_t, GLMoleculeObject_atom* > AtomNodeMap;
-  typedef std::map< BondIds , GLMoleculeObject_bond* > BondNodeMap;
+  typedef std::map< atomId_t, GLMoleculeObject_molecule* > AtomMoleculeMap;
+  typedef std::map< GLMoleculeObject_molecule::BondIds , GLMoleculeObject_molecule* > BondMoleculeMap;
   typedef std::map< moleculeId_t , GLMoleculeObject_molecule* > MoleculeNodeMap;
   typedef std::map< std::string , GLMoleculeObject_shape* > ShapeNodeMap;
-  AtomNodeMap AtomsinSceneMap;
-  BondNodeMap BondsinSceneMap;
+  AtomMoleculeMap AtomsinSceneMap;
+  BondMoleculeMap BondsinSceneMap;
   MoleculeNodeMap MoleculesinSceneMap;
   ShapeNodeMap ShapesinSceneMap;
 
-  QGLSceneNode *meshEmpty[GLMoleculeObject::DETAILTYPES_MAX];
-  QGLSceneNode *meshSphere[GLMoleculeObject::DETAILTYPES_MAX];
-  QGLSceneNode *meshCylinder[GLMoleculeObject::DETAILTYPES_MAX];
-
   SelectionModeType selectionMode;
-  const atom *hoverAtom;
 };
 
-std::ostream &operator<<(std::ostream &ost, const GLWorldScene::BondIds &t);
-
 #endif /* GLWORLDSCENE_HPP_ */
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -78,5 +78,6 @@
   //changeMaterials(false);
 
-  qRegisterMetaType<atomicNumber_t>("atomicNumber_t");
+  qRegisterMetaType<atomId_t>("atomId_t");
+  qRegisterMetaType<moleculeId_t>("moleculeId_t");
 
   connect(this, SIGNAL(ShapeAdded()), worldscene, SLOT(addShape()));
@@ -86,9 +87,7 @@
   connect(worldscene, SIGNAL(changed()), this, SIGNAL(changed()));
   connect(worldscene, SIGNAL(hoverChanged(const atom *)), this, SLOT(sceneHoverSignalled(const atom *)));
-  connect(this, SIGNAL(atomInserted(const atomicNumber_t)), worldscene, SLOT(atomInserted(const atomicNumber_t)));
-  connect(this, SIGNAL(atomRemoved(const atomicNumber_t)), worldscene, SLOT(atomRemoved(const atomicNumber_t)));
   connect(this, SIGNAL(worldSelectionChanged()), worldscene, SLOT(worldSelectionChanged()));
-  connect(this, SIGNAL(moleculeRemoved(const molecule *)), worldscene, SLOT(moleculeRemoved(const molecule *)));
-  //connect(this, SIGNAL(moleculeInserted(const molecule *)), worldscene, SLOT(moleculeInserted(const molecule *)));
+  connect(this, SIGNAL(moleculeRemoved(const moleculeId_t)), worldscene, SLOT(moleculeRemoved(const moleculeId_t)));
+  connect(this, SIGNAL(moleculeInserted(const molecule *)), worldscene, SLOT(moleculeInserted(const molecule *)));
   //connect(this, SIGNAL(changed()), this, SLOT(updateGL()));
   connect(this, SIGNAL(changed()), this, SLOT(sceneChangeSignalled()));
@@ -96,6 +95,4 @@
   // sign on to changes in the world
   World::getInstance().signOn(this);
-  World::getInstance().signOn(this, World::AtomInserted);
-  World::getInstance().signOn(this, World::AtomRemoved);
   World::getInstance().signOn(this, World::MoleculeInserted);
   World::getInstance().signOn(this, World::MoleculeRemoved);
@@ -338,22 +335,4 @@
   if (static_cast<World *>(publisher) == World::getPointer()) {
     switch (notification->getChannelNo()) {
-      case World::AtomInserted:
-      {
-        const atomicNumber_t _id = World::getInstance().lastChanged<atom>()->getId();
-  #ifdef LOG_OBSERVER
-        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been inserted.";
-  #endif
-        emit atomInserted(_id);
-        break;
-      }
-      case World::AtomRemoved:
-      {
-        const atomicNumber_t _id = World::getInstance().lastChanged<atom>()->getId();
-  #ifdef LOG_OBSERVER
-        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been removed.";
-  #endif
-        emit atomRemoved(_id);
-        break;
-      }
       case World::SelectionChanged:
       {
@@ -366,18 +345,18 @@
       case World::MoleculeInserted:
       {
-        const molecule *_molecule = World::getInstance().lastChanged<molecule>();
+        const molecule * _mol = World::getInstance().lastChanged<molecule>();
   #ifdef LOG_OBSERVER
-        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that molecule "+toString(_molecule->getId())+" has been removed.";
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that molecule "+toString(_mol->getId())+" has been removed.";
   #endif
-        emit moleculeInserted(_molecule);
+        emit moleculeInserted(_mol);
         break;
       }
       case World::MoleculeRemoved:
       {
-        const molecule *_molecule = World::getInstance().lastChanged<molecule>();
+        const moleculeId_t _id = World::getInstance().lastChanged<molecule>()->getId();
   #ifdef LOG_OBSERVER
-        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that molecule "+toString(_molecule->getId())+" has been removed.";
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that molecule "+toString(_id)+" has been removed.";
   #endif
-        emit moleculeRemoved(_molecule);
+        emit moleculeRemoved(_id);
         break;
       }
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp	(revision 1b6cec8a7217342cc34f00da7084bcec75e948a3)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp	(revision 8c001aeb40538cff3bf30540d0cc0b8359472d75)
@@ -58,8 +58,6 @@
   void changed();
   void TimeChanged();
-  void atomInserted(const atomicNumber_t _id);
-  void atomRemoved(const atomicNumber_t _id);
-  void moleculeInserted(const molecule *_molecule);
-  void moleculeRemoved(const molecule *_molecule);
+  void moleculeInserted(const molecule * _mol);
+  void moleculeRemoved(const moleculeId_t _id);
   void worldSelectionChanged();
   void hoverChanged(const atom *_atom);
