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

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"
@@ -69 +70 @@
 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 +77 @@
   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 +107 @@
 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 +125 @@
 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){
@@ -429 +150 @@
      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(mol->getId());
+       SelectionMoleculeById(ids);
      else
-       SelectionNotMoleculeById(mol->getId());
+       SelectionNotMoleculeById(ids);
    }
    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)
 {
@@ -453 +450 @@
 }
 
-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);
+}