Changes in src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp [d7cad1:ce4126]

File:

• src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp (modified) (7 diffs)

src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp

@@ -60 +60 @@
 #include "Bond/bond.hpp"
 #include "Descriptors/AtomIdDescriptor.hpp"
-#include "Descriptors/MoleculeIdDescriptor.hpp"
 #include "Helpers/helpers.hpp"
 #include "Shapes/ShapeRegistry.hpp"
@@ -70 +69 @@
 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)
+   : QObject(parent),
+     hoverAtom(NULL)
 {
   int sphereDetails[] = {5, 3, 2, 0};
@@ -77 +83 @@
   for (int i=0;i<GLMoleculeObject::DETAILTYPES_MAX;i++){
     QGLBuilder emptyBuilder;
-    GLMoleculeObject::meshEmpty[i] = emptyBuilder.finalizedSceneNode();
+    meshEmpty[i] = emptyBuilder.finalizedSceneNode();
     QGLBuilder sphereBuilder;
     sphereBuilder << QGLSphere(2.0, sphereDetails[i]);
-    GLMoleculeObject::meshSphere[i] = sphereBuilder.finalizedSceneNode();
-    GLMoleculeObject::meshSphere[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    meshSphere[i] = sphereBuilder.finalizedSceneNode();
+    meshSphere[i]->setOption(QGLSceneNode::CullBoundingBox, true);
     QGLBuilder cylinderBuilder;
     cylinderBuilder << QGLCylinder(.25,.25,1.0,cylinderDetails[i]);
-    GLMoleculeObject::meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
-    GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
+    meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
 
   connect(this, SIGNAL(updated()), this, SLOT(update()));
-
 
   setSelectionMode(SelectAtom);
@@ -107 +112 @@
 void GLWorldScene::init()
 {
-  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);
+  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);
+      }
+    }
   }
 }
@@ -125 +143 @@
 void GLWorldScene::update()
 {
-  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);
-  }
+  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);
+   }
 }
 
 void GLWorldScene::atomClicked(atomId_t no)
 {
-   LOG(3, "INFO: GLMoleculeObject_molecule - atom " << no << " has been clicked.");
+   LOG(3, "INFO: GLWorldScene - atom " << no << " has been clicked.");
    const atom *Walker = World::getInstance().getAtom(AtomById(no));
    if (selectionMode == SelectAtom){
@@ -150 +429 @@
      const molecule *mol = Walker->getMolecule();
      ASSERT(mol, "Atom without molecule has been clicked.");
-     molids_t ids(1, mol->getId());
      if (!World::getInstance().isSelected(mol))
-       SelectionMoleculeById(ids);
+       SelectionMoleculeById(mol->getId());
      else
-       SelectionNotMoleculeById(ids);
+       SelectionNotMoleculeById(mol->getId());
    }
    emit clicked(no);
 }
 
-void GLWorldScene::moleculeClicked(moleculeId_t no)
-{
-   LOG(3, "INFO: GLMoleculeObject_molecule - mol " << no << " has been clicked.");
-   const molecule *mol= World::getInstance().getMolecule(MoleculeById(no));
-   ASSERT(mol, "Atom without molecule has been clicked.");
-   molids_t ids(1, mol->getId());
-   if (!World::getInstance().isSelected(mol))
-     SelectionMoleculeById(ids);
-   else
-     SelectionNotMoleculeById(ids);
-   emit clicked(no);
-}
-
-
-/** 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(moleculeClicked(moleculeId_t)), this, SLOT(moleculeClicked(moleculeId_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 &)));
-  connect (molObject, SIGNAL(hoverChanged(const molecule &, int)), this, SIGNAL(hoverChanged(const molecule &, int)));
-  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();
-}
-
-void GLWorldScene::moleculesVisibilityChanged(const moleculeId_t _id, bool _visible)
-{
-  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->setVisible(_visible);
-
-  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)
 {
@@ -450 +453 @@
 }
 
+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.
-  AtomMoleculeMap::iterator iter = AtomsinSceneMap.find(oldId);
+  AtomNodeMap::iterator iter = AtomsinSceneMap.find(oldId);
   ASSERT(iter != AtomsinSceneMap.end(),
-        "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
+        "GLWorldScene::objectIdChangedSignalled() - atom with id "+toString(oldId)+" not on display.");
+  GLMoleculeObject_atom *atomObject = iter->second;
   AtomsinSceneMap.erase(iter);
 
   // Reinsert with new id.
-  {
-    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);
-}
+  AtomsinSceneMap.insert( make_pair(newId, atomObject) );
+}
+