Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision 273c8a207d79d5a69b073ffc4c58dd18220aa90b)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision bd676856deb95da62852a3d3d0a1bfdd7e404f1b)
@@ -49,6 +49,6 @@
 
 private slots:
-  //!> grant GLMoleculeObject_molecule acess to reset functions
-  friend class GLMoleculeObject_molecule;
+  //!> grant GLWorldScene access to SideOfBond
+  friend class GLWorldScene;
 
   /** Recalculates the element of the cylinder representing the bond.
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 273c8a207d79d5a69b073ffc4c58dd18220aa90b)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision bd676856deb95da62852a3d3d0a1bfdd7e404f1b)
@@ -99,15 +99,21 @@
   }
   connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)),
-      this, SLOT(moleculeInserted(QtObservedMolecule::ptr)));
+      this, SLOT(insertMolecule(QtObservedMolecule::ptr)));
   connect(board, SIGNAL(moleculeRemoved(ObservedValue_Index_t)),
-      this, SLOT(moleculeRemoved(ObservedValue_Index_t)));
+      this, SLOT(removeMolecule(ObservedValue_Index_t)));
+
   connect(board, SIGNAL(atomInserted(QtObservedAtom::ptr)),
-      this, SLOT(atomInserted(QtObservedAtom::ptr)));
+      this, SLOT(connectAtom(QtObservedAtom::ptr)), Qt::DirectConnection);
+  connect(this, SIGNAL(atomConnected(QtObservedAtom::ptr)),
+      this, SLOT(insertAtom(QtObservedAtom::ptr)));
   connect(board, SIGNAL(atomRemoved(ObservedValue_Index_t)),
-      this, SLOT(atomRemoved(ObservedValue_Index_t)));
+      this, SLOT(removeAtom(ObservedValue_Index_t)));
+
   connect(board, SIGNAL(bondInserted(QtObservedBond::ptr)),
-      this, SLOT(bondInserted(QtObservedBond::ptr)));
+      this, SLOT(connectBond(QtObservedBond::ptr)), Qt::DirectConnection);
+  connect(this, SIGNAL(bondConnected(QtObservedBond::ptr)),
+      this, SLOT(insertBond(QtObservedBond::ptr)));
   connect(board, SIGNAL(bondRemoved(ObservedValue_Index_t)),
-      this, SLOT(bondRemoved(ObservedValue_Index_t)));
+      this, SLOT(removeBond(ObservedValue_Index_t)));
 
 //  connect(this, SIGNAL(updated()), this, SLOT(update()));
@@ -120,11 +126,11 @@
 }
 
-void GLWorldScene::atomClicked(atomId_t no)
-{
-   LOG(3, "INFO: GLMoleculeObject_molecule - atom " << no << " has been clicked.");
+void GLWorldScene::clickAtom(atomId_t no)
+{
+   LOG(3, "INFO: GLWorldScene - atom " << no << " has been clicked.");
    const atom * const Walker = const_cast<const World &>(World::getInstance()).
        getAtom(AtomById(no));
    ASSERT( Walker != NULL,
-       "GLWorldScene::atomClicked() - clicked atom has disappeared.");
+       "GLWorldScene::clickAtom() - clicked atom has disappeared.");
    if (selectionMode == SelectAtom){
      if (!World::getInstance().isSelected(Walker))
@@ -144,29 +150,59 @@
 }
 
+/** Prepares adding an atom to the scene
+ *
+ * We need to listen to moleculeChanged() in order to properly re-parent()
+ * this QObject
+ *
+ * @param _atom atom to connect
+ */
+void GLWorldScene::connectAtom(QtObservedAtom::ptr _atom)
+{
+  connect(_atom.get(), SIGNAL(moleculeChanged()), this, SLOT(reparentAtom()));
+
+  {
+    const ObservedValue_Index_t atomid = _atom->getIndex();
+    boost::recursive_mutex::scoped_lock lock(AtomNodeParentMap_mutex);
+    AtomNodeParentMap[atomid] = static_cast<QObject *>(this);
+  }
+
+  emit atomConnected(_atom);
+}
+
 /** Adds an atom to the scene.
  *
  * @param _atom atom to add
  */
-void GLWorldScene::atomInserted(QtObservedAtom::ptr _atom)
+void GLWorldScene::insertAtom(QtObservedAtom::ptr _atom)
 {
   LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "
       << _atom->getAtomIndex());
 
-  GLMoleculeObject_atom *atomObject =
-      new GLMoleculeObject_atom(
-          GLMoleculeObject::meshSphere,
-          this, /* parent is GLWorldScene */
-          _atom);
-  ASSERT( atomObject != NULL,
-      "GLWorldScene::atomInserted - could not create atom object for "
-      +toString(_atom->getAtomIndex()));
   const ObservedValue_Index_t atomid = _atom->getIndex();
+  QObject *parent = static_cast<QObject *>(this);
+  GLMoleculeObject_atom *atomObject = NULL;
+  {
+    boost::recursive_mutex::scoped_lock lock(AtomNodeParentMap_mutex);
+    AtomNodeParentMap_t::iterator parentiter = AtomNodeParentMap.find(atomid);
+    if (parentiter != AtomNodeParentMap.end())
+      parent = parentiter->second;
+    else
+      AtomNodeParentMap[atomid] = parent;
+
+    atomObject = new GLMoleculeObject_atom(
+            GLMoleculeObject::meshSphere,
+            parent,
+            _atom);
+    ASSERT( atomObject != NULL,
+        "GLWorldScene::atomInserted - could not create atom object for "
+        +toString(_atom->getAtomIndex()));
+  }
   AtomNodeMap::iterator iter = AtomsinSceneMap.find(atomid);
   ASSERT(iter == AtomsinSceneMap.end(),
-      "GLWorldScene::atomInserted - same atom with id "
+      "GLWorldScene::insertAtom - same atom with id "
       +toString(_atom->getAtomIndex())+" added again.");
   AtomsinSceneMap.insert( make_pair(atomid, atomObject) );
 
-  connect (atomObject, SIGNAL(clicked(atomId_t)), this, SLOT(atomClicked(atomId_t)));
+  connect (atomObject, SIGNAL(clicked(atomId_t)), this, SLOT(clickAtom(atomId_t)));
   connect (atomObject, SIGNAL(changed()), this, SIGNAL(changed()));
   connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
@@ -181,5 +217,5 @@
  * @param _atomid index of the atom that is removed
  */
-void GLWorldScene::atomRemoved(ObservedValue_Index_t _atomid)
+void GLWorldScene::removeAtom(ObservedValue_Index_t _atomid)
 {
   LOG(3, "INFO: GLWorldScene: Received signal atomRemoved for atom "+toString(_atomid)+".");
@@ -189,18 +225,55 @@
   AtomNodeMap::iterator iter = AtomsinSceneMap.find(_atomid);
   ASSERT(iter != AtomsinSceneMap.end(),
-      "GLWorldScene::atomRemoved() - atom "+toString(_atomid)+" not on display.");
+      "GLWorldScene::removeAtom() - atom "+toString(_atomid)+" not on display.");
   GLMoleculeObject_atom *atomObject = iter->second;
   AtomsinSceneMap.erase(iter);
   delete atomObject;
-
+  {
+    boost::recursive_mutex::scoped_lock lock(AtomNodeParentMap_mutex);
+    AtomNodeParentMap.erase(_atomid);
+  }
   emit changed();
   emit changeOccured();
 }
 
+/** Prepares adding a bond to the scene
+ *
+ * We need to listen to moleculeChanged() in order to properly re-parent()
+ * this QObject
+ *
+ * @param _bond bond to connect
+ */
+void GLWorldScene::connectBond(QtObservedBond::ptr _bond)
+{
+  connect(_bond.get(), SIGNAL(leftmoleculeChanged()), this, SLOT(reparentBondLeft()));
+  connect(_bond.get(), SIGNAL(rightmoleculeChanged()), this, SLOT(reparentBondRight()));
+
+  {
+    const ObservedValue_Index_t bondid = _bond->getIndex();
+    boost::recursive_mutex::scoped_lock lock(BondNodeParentMap_mutex);
+    std::vector<QObject *> parents(2, static_cast<QObject *>(this));
+    if ((_bond->getLeftAtom() != NULL) && (_bond->getLeftAtom()->getMoleculeRef() != NULL)) {
+      const ObservedValue_Index_t molid = _bond->getLeftAtom()->getMoleculeRef()->getIndex();
+      const MoleculeNodeMap::iterator leftiter = MoleculesinSceneMap.find(molid);
+      if (leftiter != MoleculesinSceneMap.end())
+        parents[0] = leftiter->second;
+    }
+    if ((_bond->getRightAtom() != NULL) && (_bond->getRightAtom()->getMoleculeRef() != NULL)) {
+      const ObservedValue_Index_t molid = _bond->getRightAtom()->getMoleculeRef()->getIndex();
+      const MoleculeNodeMap::iterator leftiter = MoleculesinSceneMap.find(molid);
+      if (leftiter != MoleculesinSceneMap.end())
+        parents[1] = leftiter->second;
+    }
+    BondNodeParentMap.insert( std::make_pair(bondid, parents) );
+  }
+
+  emit bondConnected(_bond);
+}
+
 /** Adds a bond to the scene.
  *
  * @param _bond bond to add
  */
-void GLWorldScene::bondInserted(QtObservedBond::ptr _bond)
+void GLWorldScene::insertBond(QtObservedBond::ptr _bond)
 {
   static const std::vector< GLMoleculeObject_bond::SideOfBond > bondsides =
@@ -208,16 +281,28 @@
           (GLMoleculeObject_bond::left)
           (GLMoleculeObject_bond::right);
-  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bonds " << _bond->getBondIndex());
-  //LOG(4, "INFO: Currently present bonds " << BondsinSceneMap << ".");
+  LOG(3, "INFO: GLWorldScene::insertBond() - Adding bonds " << _bond->getBondIndex());
 
   const ObservedValue_Index_t bondid = _bond->getIndex();
-  BondNodeMap::iterator iter = BondsinSceneMap.find(bondid);
-  ASSERT( iter == BondsinSceneMap.end(),
-      "GLWorldScene::bondInserted() - bond "+toString(bondid)+" is already known.");
-  for (size_t i=0;i<2;++i) {
-    GLMoleculeObject_bond * bondObject =
-        new GLMoleculeObject_bond(GLMoleculeObject::meshCylinder, this, _bond, bondsides[i]);
-    connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
-    BondsinSceneMap.insert( std::make_pair(bondid, bondObject) );
+  std::vector<QObject *> parents(2, static_cast<QObject *>(this));
+  {
+    boost::recursive_mutex::scoped_lock lock(BondNodeParentMap_mutex);
+    BondNodeParentMap_t::iterator parentiter = BondNodeParentMap.find(bondid);
+    if (parentiter != BondNodeParentMap.end()) {
+      parents = parentiter->second;
+    } else
+      BondNodeParentMap.insert( std::make_pair(bondid, parents) );
+
+    BondNodeMap::iterator iter = BondsinSceneMap.find(bondid);
+    ASSERT( iter == BondsinSceneMap.end(),
+        "GLWorldScene::insertBond() - bond "+toString(bondid)+" is already known.");
+    for (size_t i=0;i<2;++i) {
+      GLMoleculeObject_bond *bondObject = new GLMoleculeObject_bond(
+              GLMoleculeObject::meshCylinder,
+              parents[i],
+              _bond,
+              bondsides[i]);
+      connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
+      BondsinSceneMap.insert( std::make_pair(bondid, bondObject) );
+    }
   }
 
@@ -230,16 +315,23 @@
  * @param _bondid id of bond to remove
  */
-void GLWorldScene::bondRemoved(ObservedValue_Index_t _bondid)
-{
-  LOG(3, "INFO: GLWorldScene::bondRemoved() - Removing bond to id " << _bondid);
+void GLWorldScene::removeBond(ObservedValue_Index_t _bondid)
+{
+  LOG(3, "INFO: GLWorldScene::removedBond() - Removing bond to id " << _bondid);
 
   // left bond
-  BondNodeMap::iterator iter = BondsinSceneMap.find(_bondid);
-  ASSERT( iter != BondsinSceneMap.end(),
-      "GLWorldScene::bondRemoved() - could not find bond to id "+toString(_bondid));
-  GLMoleculeObject_bond *bondObject = iter->second;
-  delete bondObject; // is done by signal from bond itself
-  //LOG(4, "INFO: Still present bonds " << BondsinSceneMap << ".");
-  BondsinSceneMap.erase(iter);
+  std::pair<BondNodeMap::iterator, BondNodeMap::iterator> iters =
+      BondsinSceneMap.equal_range(_bondid);
+  ASSERT( iters.first != iters.second,
+      "GLWorldScene::removedBond() - could not find bond to id "+toString(_bondid));
+  for (BondNodeMap::iterator iter = iters.first; iter != iters.second; ++iter) {
+    GLMoleculeObject_bond *bondObject = iter->second;
+    delete bondObject; // is done by signal from bond itself
+    //LOG(4, "INFO: Still present bonds " << BondsinSceneMap << ".");
+  }
+  BondsinSceneMap.erase(_bondid);
+  {
+    boost::recursive_mutex::scoped_lock lock(BondNodeParentMap_mutex);
+    BondNodeParentMap.erase(_bondid);
+  }
 
   emit changed();
@@ -270,5 +362,5 @@
 }
 
-void GLWorldScene::moleculeClicked(moleculeId_t no)
+void GLWorldScene::clickMolecule(moleculeId_t no)
 {
    LOG(3, "INFO: GLMoleculeObject_molecule - mol " << no << " has been clicked.");
@@ -288,5 +380,5 @@
  * @param _mol molecule to insert
  */
-void GLWorldScene::moleculeInserted(QtObservedMolecule::ptr _mol)
+void GLWorldScene::insertMolecule(QtObservedMolecule::ptr _mol)
 {
   const ObservedValue_Index_t molid = _mol->getIndex();
@@ -296,5 +388,5 @@
   MoleculeNodeMap::const_iterator iter = MoleculesinSceneMap.find(molid);
   ASSERT( iter == MoleculesinSceneMap.end(),
-      "GLWorldScene::moleculeInserted() - molecule's id "+toString(_mol->getMolIndex())
+      "GLWorldScene::insertMolecule() - molecule's id "+toString(_mol->getMolIndex())
       +" already present.");
 
@@ -307,5 +399,5 @@
           _mol);
   ASSERT( molObject != NULL,
-      "GLWorldScene::moleculeInserted - could not create molecule object for "
+      "GLWorldScene::insertMolecule - could not create molecule object for "
       +toString(_mol->getMolIndex()));
 #ifndef NDEBUG
@@ -314,5 +406,5 @@
   MoleculesinSceneMap.insert( make_pair(molid, molObject) );
   ASSERT(inserter.second,
-      "GLWorldScene::moleculeInserted() - molecule "+toString(_mol->getMolIndex())
+      "GLWorldScene::insertMolecule() - molecule "+toString(_mol->getMolIndex())
       +" already present in scene.");
 
@@ -328,5 +420,5 @@
  * @param _molid index of the molecule to remove
  */
-void GLWorldScene::moleculeRemoved(ObservedValue_Index_t _molid)
+void GLWorldScene::removeMolecule(ObservedValue_Index_t _molid)
 {
   LOG(3, "INFO: GLWorldScene: Received signal moleculeRemoved for molecule "+toString(_molid)+".");
@@ -334,5 +426,5 @@
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
   ASSERT ( iter != MoleculesinSceneMap.end(),
-      "GLWorldScene::moleculeRemoved() - to be removed molecule "+toString(_molid)
+      "GLWorldScene::removeMolecule() - to be removed molecule "+toString(_molid)
       +" is already gone.");
   // check if it's already empty
@@ -357,4 +449,113 @@
   emit changed();
   emit changeOccured();
+}
+
+/** Changes the parent of an object in the scene.
+ *
+ * \param _id index of the object whose parent to change
+ * \param _ob new parent
+ */
+void GLWorldScene::reparentAtom()
+{
+  QtObservedAtom *walker = dynamic_cast<QtObservedAtom *>(sender());
+  boost::recursive_mutex::scoped_lock lock(AtomNodeParentMap_mutex);
+  const ObservedValue_Index_t walkerid = walker->getIndex();
+  AtomNodeParentMap_t::iterator parentiter = AtomNodeParentMap.find(walkerid);
+  ASSERT( parentiter != AtomNodeParentMap.end(),
+      "GLWorldScene::reparentAtom() - could not find object to id "+toString(walkerid));
+  AtomNodeMap::iterator atomiter = AtomsinSceneMap.find(walkerid);
+  ASSERT( atomiter != AtomsinSceneMap.end(),
+      "GLWorldScene::reparentAtom() - could not find GLMoleculeObject to id "+toString(walkerid));
+  if (walker->getMoleculeRef() != NULL) {
+    const ObservedValue_Index_t molid = walker->getMoleculeRef()->getIndex();
+    MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
+    if (moliter != MoleculesinSceneMap.end()) {
+      parentiter->second = moliter->second;
+      atomiter->second->setParent(moliter->second);
+    } else {
+      // associated molecule has not yet been instantiated, keep in mind
+      ASSERT(0,
+          "GLWorldScene::reparentAtom() - new molecule not present yet?");
+    }
+  } else {
+    parentiter->second = static_cast<QObject*>(this);
+    atomiter->second->setParent(this);
+  }
+}
+
+/** Changes the parent of an object in the scene.
+ *
+ * \param _id index of the object whose parent to change
+ * \param _ob new parent
+ */
+void GLWorldScene::reparentBondLeft()
+{
+  QtObservedBond *bond = dynamic_cast<QtObservedBond *>(sender());
+  boost::recursive_mutex::scoped_lock lock(BondNodeParentMap_mutex);
+  const ObservedValue_Index_t bondid = bond->getIndex();
+  BondNodeParentMap_t::iterator parentiter = BondNodeParentMap.find(bondid);
+  ASSERT( parentiter != BondNodeParentMap.end(),
+      "GLWorldScene::reparentBondLeft() - could not find object to id "+toString(bondid));
+  BondNodeMap::iterator bonditer = BondsinSceneMap.find(bondid);
+  ASSERT( bonditer != BondsinSceneMap.end(),
+      "GLWorldScene::reparentBondLeft() - could not find GLMoleculeObject to id "+toString(bondid));
+  if (bonditer->second->BondSide != GLMoleculeObject_bond::left)
+    ++bonditer;
+  ASSERT( (bonditer->first == bondid)
+      && (bonditer->second->BondSide == GLMoleculeObject_bond::left),
+      "GLWorldScene::reparentBondLeft() - could not find left-side bond.");
+  if ((bond->getLeftAtom() != NULL) && (bond->getLeftAtom()->getMoleculeRef() != NULL)) {
+    const ObservedValue_Index_t molid = bond->getLeftAtom()->getMoleculeRef()->getIndex();
+    MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
+    if (moliter != MoleculesinSceneMap.end()) {
+      parentiter->second[0] = moliter->second;
+      bonditer->second->setParent(moliter->second);
+    } else {
+      // associated molecule has not yet been instantiated, keep in mind
+      ASSERT(0,
+          "GLWorldScene::reparentBondLeft() - new molecule not present yet?");
+    }
+  } else {
+    parentiter->second[0] = static_cast<QObject*>(this);
+    bonditer->second->setParent(this);
+  }
+}
+
+/** Changes the parent of an object in the scene.
+ *
+ * \param _id index of the object whose parent to change
+ * \param _ob new parent
+ */
+void GLWorldScene::reparentBondRight()
+{
+  QtObservedBond *bond = dynamic_cast<QtObservedBond *>(sender());
+  boost::recursive_mutex::scoped_lock lock(BondNodeParentMap_mutex);
+  const ObservedValue_Index_t bondid = bond->getIndex();
+  BondNodeParentMap_t::iterator parentiter = BondNodeParentMap.find(bondid);
+  ASSERT( parentiter != BondNodeParentMap.end(),
+      "GLWorldScene::reparentBondLeft() - could not find object to id "+toString(bondid));
+  BondNodeMap::iterator bonditer = BondsinSceneMap.find(bondid);
+  ASSERT( bonditer != BondsinSceneMap.end(),
+      "GLWorldScene::reparentBondLeft() - could not find GLMoleculeObject to id "+toString(bondid));
+  if (bonditer->second->BondSide != GLMoleculeObject_bond::right)
+    ++bonditer;
+  ASSERT( (bonditer->first == bondid)
+      && (bonditer->second->BondSide == GLMoleculeObject_bond::right),
+      "GLWorldScene::reparentBondLeft() - could not find right-side bond.");
+  if ((bond->getRightAtom() != NULL) && (bond->getRightAtom()->getMoleculeRef() != NULL)) {
+    const ObservedValue_Index_t molid = bond->getRightAtom()->getMoleculeRef()->getIndex();
+    MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
+    if (moliter != MoleculesinSceneMap.end()) {
+      parentiter->second[1] = moliter->second;
+      bonditer->second->setParent(moliter->second);
+    } else {
+      // associated molecule has not yet been instantiated, keep in mind
+      ASSERT(0,
+          "GLWorldScene::reparentBondRight() - new molecule not present yet?");
+    }
+  } else {
+    parentiter->second[1] = static_cast<QObject*>(this);
+    bonditer->second->setParent(this);
+  }
 }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 273c8a207d79d5a69b073ffc4c58dd18220aa90b)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision bd676856deb95da62852a3d3d0a1bfdd7e404f1b)
@@ -19,4 +19,6 @@
 
 #include <iosfwd>
+
+#include <boost/thread/recursive_mutex.hpp>
 
 #include "Bond/bond.hpp"
@@ -83,16 +85,25 @@
   void hoverChanged(const atomId_t);
   void hoverChanged(const moleculeId_t, int);
+  void atomConnected(QtObservedAtom::ptr);
+  void bondConnected(QtObservedBond::ptr);
 
 private slots:
-  void atomClicked(atomId_t no);
-  void atomRemoved(ObservedValue_Index_t _atomid);
-  void atomInserted(QtObservedAtom::ptr);
-  void bondRemoved(ObservedValue_Index_t _bondid);
-  void bondInserted(QtObservedBond::ptr);
-  void moleculeClicked(moleculeId_t no);
-  void moleculeRemoved(ObservedValue_Index_t _molid);
-  void moleculeInserted(QtObservedMolecule::ptr);
+
+  void clickAtom(atomId_t no);
+  void connectAtom(QtObservedAtom::ptr);
+  void insertAtom(QtObservedAtom::ptr);
+  void removeAtom(ObservedValue_Index_t _atomid);
+
+  void connectBond(QtObservedBond::ptr);
+  void insertBond(QtObservedBond::ptr);
+  void removeBond(ObservedValue_Index_t _bondid);
+
+  void clickMolecule(moleculeId_t no);
+  void insertMolecule(QtObservedMolecule::ptr);
+  void removeMolecule(ObservedValue_Index_t _molid);
+
   void setSelectionModeAtom();
   void setSelectionModeMolecule();
+
   void addShape(const std::string &_name);
   void removeShape(const std::string &_name);
@@ -100,4 +111,8 @@
   void moleculesVisibilityChanged(ObservedValue_Index_t _id, bool _visible);
   void hoverChangedSignalled(GLMoleculeObject *ob);
+
+  void reparentAtom();
+  void reparentBondLeft();
+  void reparentBondRight();
 
 public:
@@ -111,6 +126,14 @@
   typedef std::map< ObservedValue_Index_t , GLMoleculeObject_molecule* > MoleculeNodeMap;
   typedef std::map< ObservedValue_Index_t, GLMoleculeObject_atom* > AtomNodeMap;
-  typedef std::map< ObservedValue_Index_t, GLMoleculeObject_bond* > BondNodeMap;
+  typedef std::multimap< ObservedValue_Index_t, GLMoleculeObject_bond* > BondNodeMap;
   typedef std::map< std::string , GLMoleculeObject_shape* > ShapeNodeMap;
+
+  //!> typedef for storing the current parent to each node in scene
+  typedef std::map<ObservedValue_Index_t, QObject *> AtomNodeParentMap_t;
+  typedef std::map<ObservedValue_Index_t, std::vector<QObject *> > BondNodeParentMap_t;
+
+  //!> mutex to ascertain atomic access to NodeParentMaps
+  boost::recursive_mutex AtomNodeParentMap_mutex;
+  boost::recursive_mutex BondNodeParentMap_mutex;
 
   AtomNodeMap AtomsinSceneMap;
@@ -118,4 +141,6 @@
   MoleculeNodeMap MoleculesinSceneMap;
   ShapeNodeMap ShapesinSceneMap;
+  AtomNodeParentMap_t AtomNodeParentMap;
+  BondNodeParentMap_t BondNodeParentMap;
 
   SelectionModeType selectionMode;
