Changeset 0ac85c3 for src/UIElements

src/UIElements/CommandLineUI/CommandLineParser.cpp

r7b38d3	r0ac85c3
443	443	// force action queue to stop thread
444	444	ActionQueue::getInstance().stop();
	445	ActionQueue::getInstance().clearTempQueue();
445	446	#endif
446	447	ActionQueue::getInstance().clearQueue();

src/UIElements/Qt4/QtMainWindow.cpp

-              r7b38d3
+              r0ac85c3
   settings.endGroup();
+  connect(glWorldView,SIGNAL(hoverChanged(const atom*)), infoBox,SLOT(atomHover(const atom*)));
+  qRegisterMetaType<moleculeId_t>("moleculeId_t");
+  connect(glWorldView,SIGNAL(hoverChanged(const atom&)), infoBox,SLOT(atomHover(const atom&)));
+  connect(glWorldView,SIGNAL(hoverChanged(const molecule&, int)), infoBox,SLOT(moleculeHover(const molecule&)));
+  connect(moleculeList,SIGNAL(moleculesVisibilityChanged(const moleculeId_t,bool)), glWorldView, SIGNAL(moleculesVisibilityChanged(const moleculeId_t,bool)));
+}

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

-              r7b38d3
+              r0ac85c3
 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};
 …
+{
    //mesh->setParent(this);
+   for (int i=0;i<DETAILTYPES_MAX;i++)
+     m_mesh[i] = mesh[i];
+  for (int i=0;i<DETAILTYPES_MAX;i++)
+    m_mesh[i] = mesh[i];
+  MeshFreeType = free_none;
+   m_scaleX = 1.0f;
+   m_scaleY = 1.0f;
+   m_scaleZ = 1.0f;
+   m_rotationAngle = 0.0f;
+   m_effect = 0;
+   m_objectId = -1;
+   m_hovering = false;
+   m_selected = false;
+   m_visible = true;
+   m_material = 0;
+   initStaticMaterials();
+}
+GLMoleculeObject::GLMoleculeObject(QGLSceneNode *mesh, QObject *parent)
+   : QObject(parent)
+{
+   //mesh->setParent(this);
+  for (int i=0;i<DETAILTYPES_MAX;i++)
+    m_mesh[i] = mesh;
+  MeshFreeType = free_none;
    m_scaleX = 1.0f;
    m_scaleY = 1.0f;
 …
+}
 GLMoleculeObject::GLMoleculeObject(QGLSceneNode *mesh, QObject *parent)
+GLMoleculeObject::GLMoleculeObject(QGLAbstractScene *scene, QObject *parent)
    : QObject(parent)
+{
    //mesh->setParent(this);
    for (int i=0;i<DETAILTYPES_MAX;i++)
      m_mesh[i] = mesh;
+  for (int i=0;i<DETAILTYPES_MAX;i++)
+    m_mesh[i] = scene->mainNode();
+  MeshFreeType = free_none;
    m_scaleX = 1.0f;
    m_scaleY = 1.0f;
 …
+}
-GLMoleculeObject::GLMoleculeObject(QGLAbstractScene *scene, QObject *parent)
-   : QObject(parent)
+{
-   scene->setParent(this);
-   for (int i=0;i<DETAILTYPES_MAX;i++)
-     m_mesh[i] = scene->mainNode();
-   m_scaleX = 1.0f;
-   m_scaleY = 1.0f;
-   m_scaleZ = 1.0f;
-   m_rotationAngle = 0.0f;
-   m_effect = 0;
-   m_objectId = -1;
-   m_hovering = false;
-   m_selected = false;
-   m_material = 0;
-   initStaticMaterials();
+}
 GLMoleculeObject::~GLMoleculeObject()
+{
 …
    painter->modelViewMatrix().push();
    painter->modelViewMatrix().translate(m_position);
+   if ((m_scaleX != 1.0f) || (m_scaleY != 1.0f) || (m_scaleZ != 1.0f))
+     painter->modelViewMatrix().scale(m_scaleX, m_scaleY, m_scaleZ);
    if (m_rotationAngle != 0.0f)
      painter->modelViewMatrix().rotate(m_rotationAngle, m_rotationVector);
-   painter->modelViewMatrix().scale(m_scaleX, m_scaleY, m_scaleZ);
    // Apply the material and effect to the painter.
 …
+  }
+}
+void GLMoleculeObject::setVisible(bool value)
+{
+  if (value != m_visible){
+    m_visible = value;
+    emit changed();
+  }
+}
+void GLMoleculeObject::updateMesh(QGLSceneNode *mesh)
+{
+  if (m_mesh[0] != NULL) {
+    switch(MeshFreeType) {
+    case free_all:
+      for (int i=0;i<DETAILTYPES_MAX;i++)
+        delete m_mesh[i];
+      break;
+    case free_single:
+      delete m_mesh[0];
+      break;
+    default:
+    case free_none:
+      break;
+    }
+  }
+  MeshFreeType = free_single;
+  for (int i=0;i<DETAILTYPES_MAX;i++)
+    m_mesh[i] = mesh;
+}

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp

-              r7b38d3
+              r0ac85c3
    void setSelected(bool value);
+   bool visible() const { return m_visible; }
+   virtual void setVisible(bool value);
    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);
 …
    static void cleanMaterialMap();
+   void updateMesh(QGLSceneNode *scene);
    typedef std::map< size_t, QGLMaterial *> ElementMaterialMap;
    static ElementMaterialMap ElementNoMaterialMap;
 …
    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:
 …
    QGLSceneNode *m_mesh[DETAILTYPES_MAX];
+   enum enum_MeshFreeType {
+     free_all,
+     free_single,
+     free_none
+   } MeshFreeType;
    QGLAbstractScene *m_scene;
    QVector3D m_position;
 …
    bool m_hovering;
    bool m_selected;
+   bool m_visible;
 };

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

-              r7b38d3
+              r0ac85c3
   GLMoleculeObject(mesh, parent),
   Observer(std::string("GLMoleculeObject_atom")+toString(_id)),
+  atomicid(_id)
+  atomicid(_id),
+  uptodatePosition(false),
+  uptodateElement(false)
+{
   // sign on as observer (obtain non-const instance before)
 …
     ELOG(2, "Atom with id "+toString(atomicid)+" is already gone.");
+  }
+  uptodatePosition = true;
+}
 …
+  }
   setScale( radius / 4. );
+  uptodateElement = true;
+}
 …
   // selected?
   setSelected(World::getInstance().isAtomSelected(atomicid));
+}
+void GLMoleculeObject_atom::draw(QGLPainter *painter, const QVector4D &cameraPlane)
+{
+  // hook to update prior to painting
+  if (!uptodatePosition)
+    resetPosition();
+  if (!uptodateElement)
+    resetElement();
+  // call old hook to do the actual paining
+  GLMoleculeObject::draw(painter, cameraPlane);
+}
 …
     switch (notification->getChannelNo()) {
       case AtomObservable::ElementChanged:
+        resetElement();
+        emit changed();
+        uptodateElement = false;
         break;
       case AtomObservable::IndexChanged:
 …
         break;
       case AtomObservable::PositionChanged:
+        resetPosition();
+        emit changed();
+        uptodatePosition = false;
         break;
       case AtomObservable::BondsAdded:
 …
         const atom *_atom = World::getInstance().getAtom(AtomById(atomicid));
         if (_atom != NULL) {
+          // make sure position is up-to-date
+          if (!uptodatePosition)
+            resetPosition();
           ASSERT(!_atom->getListOfBonds().empty(),
               "GLMoleculeObject_atom::recieveNotification() - received BondsAdded but ListOfBonds is empty.");

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp

-              r7b38d3
+              r0ac85c3
   virtual ~GLMoleculeObject_atom();
+  void draw(QGLPainter *painter, const QVector4D &cameraPlane);
   // Observer functions
   void update(Observable *publisher);
 …
 private:
   //!> grant GLWorldScene acess to reset functions
   friend class GLWorldScene;
+  //!> grant GLMoleculeObject_molecule acess to reset functions
+  friend class GLMoleculeObject_molecule;
   void resetPosition();
 …
   const atomId_t atomicid;
+  bool uptodatePosition;
+  bool uptodateElement;
 };

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp

-              r7b38d3
+              r0ac85c3
 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.

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

-              r7b38d3
+              r0ac85c3
 #include <Qt3D/qglscenenode.h>
+#include <Qt3D/qglbuilder.h>
 #include "CodePatterns/MemDebug.hpp"
 …
 #include "Element/element.hpp"
 #include "LinearAlgebra/Vector.hpp"
+#include "LinkedCell/PointCloudAdaptor.hpp"
+#include "LinkedCell/linkedcell.hpp"
+#include "Tesselation/tesselation.hpp"
+#include "Tesselation/BoundaryLineSet.hpp"
+#include "Tesselation/BoundaryTriangleSet.hpp"
+#include "Tesselation/CandidateForTesselation.hpp"
+#include "Atom/TesselPoint.hpp"
 #include "World.hpp"
+GLMoleculeObject_molecule::GLMoleculeObject_molecule(QGLSceneNode *mesh[], QObject *parent, const molecule *molref) :
+  GLMoleculeObject(mesh, parent),
+#include "GLMoleculeObject_atom.hpp"
+static QGLSceneNode *createMoleculeMesh(const molecule *molref, QObject *parent)
+{
+//  Shape shape = molref->getBoundingSphere();
+  double minradius = 2.; // TODO: set to maximum bond length value
+  LOG(3, "DEBUG: Molecule fits into sphere of radius " << minradius);
+  if (minradius < 1.)
+    minradius = 1.;
+  QGeometryData geo;
+  // we need at least three points for tesselation
+  if (molref->getAtomCount() >= 3) {
+    // Tesselate the points.
+    Tesselation T;
+    PointCloudAdaptor<molecule> cloud(const_cast<molecule *>(molref), molref->getName());
+    T(cloud, minradius);
+    // Fill the points into a Qt geometry.
+    LinkedCell_deprecated LinkedList(cloud, minradius);
+    std::map<int, int> indices;
+    std::map<int, Vector> normals;
+    int index = 0;
+    for (PointMap::const_iterator piter = T.PointsOnBoundary.begin();
+        piter != T.PointsOnBoundary.end(); ++piter) {
+      const Vector &point = piter->second->getPosition();
+      // add data to the primitive
+      geo.appendVertex(QVector3D(point[0], point[1], point[2]));
+      Vector normalvector;
+      for (LineMap::const_iterator lineiter = piter->second->lines.begin();
+          lineiter != piter->second->lines.end(); ++lineiter)
+        for (TriangleMap::const_iterator triangleiter = lineiter->second->triangles.begin();
+            triangleiter != lineiter->second->triangles.end(); ++triangleiter)
+          normalvector +=
+              triangleiter->second->NormalVector;
+      normalvector.Normalize();
+      geo.appendNormal(QVector3D(normalvector[0], normalvector[1], normalvector[2]));
+      geo.appendColor(QColor(1, 1, 1, 1));
+      geo.appendTexCoord(QVector2D(0, 0));
+      indices.insert( std::make_pair( piter->second->getNr(), index++));
+    }
+    // Fill the tesselated triangles into the geometry.
+    for (TriangleMap::const_iterator runner = T.TrianglesOnBoundary.begin();
+        runner != T.TrianglesOnBoundary.end(); runner++) {
+      int v[3];
+      for (size_t i=0; i<3; ++i)
+        v[i] = runner->second->endpoints[i]->getNr();
+      // Sort the vertices so the triangle is clockwise (relative to the normal vector).
+      Vector cross = T.PointsOnBoundary[v[1]]->getPosition() - T.PointsOnBoundary[v[0]]->getPosition();
+      cross.VectorProduct(T.PointsOnBoundary[v[2]]->getPosition() - T.PointsOnBoundary[v[0]]->getPosition());
+      if (cross.ScalarProduct(runner->second->NormalVector) > 0)
+        geo.appendIndices(indices[v[0]], indices[v[1]], indices[v[2]]);
+      else
+        geo.appendIndices(indices[v[0]], indices[v[2]], indices[v[1]]);
+    }
+  }
+  // Build a mesh from the geometry.
+  QGLBuilder builder;
+  builder.addTriangles(geo);
+  QGLSceneNode *mesh = builder.finalizedSceneNode();
+  return mesh;
+}
+GLMoleculeObject_molecule::GLMoleculeObject_molecule(QObject *parent, const molecule *molref) :
+  GLMoleculeObject(createMoleculeMesh(molref, parent), parent),
   Observer(std::string("GLMoleculeObject_molecule")+toString(molref->getId())),
+  _molecule(molref)
+  isBoundingBoxUptodate(true),
+  isSignedOn(false),
+  _molecule(molref),
+  TesselationHullUptodate(true),
+  hoverAtom(NULL)
+{
   // sign on as observer (obtain non-const instance before)
+  _molecule->signOn(this, molecule::AtomInserted);
+  _molecule->signOn(this, molecule::AtomRemoved);
+  _molecule->signOn(this, molecule::AtomMoved);
+  isSignedOn = true;
   /*molref->signOn(this, AtomObservable::IndexChanged);
   molref->signOn(this, AtomObservable::PositionChanged);
 …
   World::getInstance().signOn(this, World::SelectionChanged);
   updateBoundingBox();
+  // initially, atoms and bonds should be visible
+  m_visible = false;
+  init();
+  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
+  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
+  connect( this, SIGNAL(clicked()), this, SLOT(wasClicked()));
+}
+GLMoleculeObject_molecule::GLMoleculeObject_molecule(QGLSceneNode *mesh[], QObject *parent, const molecule *molref) :
+  GLMoleculeObject(mesh, parent),
+  Observer(std::string("GLMoleculeObject_molecule")+toString(molref->getId())),
+  isBoundingBoxUptodate(true),
+  isSignedOn(false),
+  _molecule(molref),
+  TesselationHullUptodate(true),
+  hoverAtom(NULL)
+{
+  // sign on as observer (obtain non-const instance before)
+  _molecule->signOn(this, molecule::AtomInserted);
+  _molecule->signOn(this, molecule::AtomRemoved);
+  _molecule->signOn(this, molecule::AtomMoved);
+  isSignedOn = true;
+  /*molref->signOn(this, AtomObservable::IndexChanged);
+  molref->signOn(this, AtomObservable::PositionChanged);
+  molref->signOn(this, AtomObservable::ElementChanged);
+  molref->signOn(this, AtomObservable::BondsAdded);*/
+  setMaterial(getMaterial(1));
+  World::getInstance().signOn(this, World::SelectionChanged);
+  updateBoundingBox();
+  // initially, atoms and bonds should be visible
+  m_visible = false;
+  init();
+  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
+  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
+  connect( this, SIGNAL(clicked()), this, SLOT(wasClicked()));
+}
 GLMoleculeObject_molecule::~GLMoleculeObject_molecule()
+{
+  if (isSignedOn) {
+    _molecule->signOff(this, molecule::AtomInserted);
+    _molecule->signOff(this, molecule::AtomRemoved);
+    _molecule->signOff(this, molecule::AtomMoved);
+  }
   /*_atom->signOff(this, AtomObservable::IndexChanged);
   _atom->signOff(this, AtomObservable::PositionChanged);
 …
+}
+/** Initialise the WorldScene with molecules and atoms from World.
+ *
+ */
+void GLMoleculeObject_molecule::init()
+{
+  if (_molecule->begin() != _molecule->end()) {
+    int atomicid = -1;
+    for (molecule::const_iterator atomiter = _molecule->begin();
+        atomiter != _molecule->end();
+        atomiter++) {
+      // create atom objects in scene
+      atomicid = (*atomiter)->getId();
+      atomInserted(atomicid);
+      // 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);
+      }
+    }
+    // set id to one of the atom's as either mol or atoms is present at the same time
+    setObjectId(atomicid);
+  }
+}
+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);
+    }
+  }
+}
 void GLMoleculeObject_molecule::updateBoundingBox()
+{
+  isBoundingBoxUptodate = true;
   Shape shape = _molecule->getBoundingSphere();
   Vector v = shape.getCenter();
 …
 void GLMoleculeObject_molecule::subjectKilled(Observable *publisher)
+{}
+{
+  isSignedOn = false;
+}
 void GLMoleculeObject_molecule::recieveNotification(Observable *publisher, Notification_ptr notification)
 …
           << 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
+        TesselationHullUptodate = false;
+        isBoundingBoxUptodate = false;
+        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
+        TesselationHullUptodate = false;
+        isBoundingBoxUptodate = false;
+        atomRemoved(_id);
+        break;
+      }
+      case molecule::AtomMoved:
+      {
+  #ifdef LOG_OBSERVER
+        const atomId_t _id = _molecule->lastChanged()->getId();
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been inserted.";
+  #endif
+        TesselationHullUptodate = false;
+        isBoundingBoxUptodate = false;
+        break;
+      }
+      default:
+        break;
+    }
   }else{
     // notification from world
 …
+}
+void GLMoleculeObject_molecule::initialize(QGLView *view, QGLPainter *painter)
+{
+  // Initialize all of the mesh objects that we have as children.
+  if (m_visible) {
+    GLMoleculeObject::initialize(view, painter);
+  } else {
+   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 either molecule's mesh or all atoms and bonds
+  if (m_visible) {
+    updateTesselationHull();
+    painter->modelViewMatrix().push();
+    // Apply the material and effect to the painter.
+    QGLMaterial *material;
+    if (m_hovering)
+        material = m_hoverMaterial;
+    else if (m_selected)
+        material = m_selectionMaterial;
+    else
+        material = m_material;
+    ASSERT(material, "GLMoleculeObject::draw: chosen material is NULL");
+    painter->setColor(material->diffuseColor());
+    painter->setFaceMaterial(QGL::AllFaces, material);
+    if (m_effect)
+        painter->setUserEffect(m_effect);
+    else
+        painter->setStandardEffect(QGL::LitMaterial);
+    // Mark the object for object picking purposes.
+    int prevObjectId = painter->objectPickId();
+    if (m_objectId != -1)
+        painter->setObjectPickId(m_objectId);
+    m_mesh[0]->draw(painter);
+    // Turn off the user effect, if present.
+    if (m_effect)
+        painter->setStandardEffect(QGL::LitMaterial);
+    // Revert to the previous object identifier.
+    painter->setObjectPickId(prevObjectId);
+    // Restore the modelview matrix.
+    painter->modelViewMatrix().pop();
+    //    GLMoleculeObject::draw(painter, cameraPlane);
+  } else {
+    // 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);
+    }
+    // update bounding box prior to selection
+    if (!isBoundingBoxUptodate)
+      updateBoundingBox();
+    painter->modelViewMatrix().push();
+    painter->modelViewMatrix().translate(m_position);
+    if ((m_scaleX != 1.0f) || (m_scaleY != 1.0f) || (m_scaleZ != 1.0f))
+      painter->modelViewMatrix().scale(m_scaleX, m_scaleY, m_scaleZ);
+    if (m_rotationAngle != 0.0f)
+      painter->modelViewMatrix().rotate(m_rotationAngle, m_rotationVector);
+    // Draw a box around the mesh, if selected.
+    if (m_selected)
+      drawSelectionBox(painter);
+    // Restore the modelview matrix.
+    painter->modelViewMatrix().pop();
+  }
+}
+/** 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)));
+  isBoundingBoxUptodate = false;
+  if (m_objectId  == -1)
+    setObjectId(_id);
+  // add all bonds
+  const atom *Walker = World::getInstance().getAtom(AtomById(_id));
+  addAtomBonds(Walker);
+  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
+  if (m_objectId == _id)
+    setObjectId(-1);
+  // 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;
+  isBoundingBoxUptodate = false;
+  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);
+  } else {
+    // Find the atom, ob corresponds to.
+    GLMoleculeObject_molecule *moleculeObject = dynamic_cast<GLMoleculeObject_molecule *>(ob);
+    if (moleculeObject == this){
+      // Propagate signal.
+      emit hoverChanged(*_molecule, 0);
+    }
+  }
+}
+/** 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();
+}
+void GLMoleculeObject_molecule::setVisible(bool value)
+{
+  // first update the mesh if we are going to be visible now
+  if (value)
+    updateTesselationHull();
+  // then emit onward
+  GLMoleculeObject::setVisible(value);
+}
+void GLMoleculeObject_molecule::updateTesselationHull()
+{
+  if (!TesselationHullUptodate) {
+    updateMesh(createMoleculeMesh(_molecule, parent()));
+    TesselationHullUptodate = true;
+  }
+}
+std::ostream &operator<<(std::ostream &ost, const GLMoleculeObject_molecule::BondIds &t)
+{
+  ost << t.first << "," << t.second;
+  return ost;
+}
+void GLMoleculeObject_molecule::wasClicked()
+{
+  LOG(4, "INFO: GLMoleculeObject_molecule: atom " << _molecule->getId() << " has been clicked");
+  emit moleculeClicked(_molecule->getId());
+}

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp

-              r7b38d3
+              r0ac85c3
 class atom;
 class bond;
+class GLMoleculeObject_atom;
+class GLWorldScene;
 class molecule;
 …
   Q_OBJECT
 public:
+  GLMoleculeObject_molecule(QObject *parent, const molecule *molref);
   GLMoleculeObject_molecule(QGLSceneNode *mesh[], QObject *parent, const molecule *molref);
   virtual ~GLMoleculeObject_molecule();
 …
   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 hoverChanged(const molecule&, int);
+  void atomClicked(atomId_t no);
+  void moleculeClicked(moleculeId_t no);
+  void changeAtomId(GLMoleculeObject_atom *, int, int);
+private slots:
+  //!> grant GLWorldScene access to private slots
+  friend class GLWorldScene;
+  void wasClicked();
+  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);
+  void setVisible(bool value);
 private:
+  void init();
+  void reinit();
+  void addAtomBonds(
+      const bond::ptr &_bond,
+      const GLMoleculeObject_bond::SideOfBond _side
+      );
+  void addAtomBonds(const atom *_atom);
+  void updateTesselationHull();
+  //!> states whether selection box is additionally drawn or not
+  bool isSelected;
+  bool isBoundingBoxUptodate;
+  //!> whether we are signed on to the associated molecule
+  bool isSignedOn;
   const molecule *_molecule;
+  bool TesselationHullUptodate;
+  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);

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

r7b38d3	r0ac85c3
63	63	typedef QGLSceneNode *MeshList[GLMoleculeObject::DETAILTYPES_MAX];
64	64
65		QGLSceneNode createShapeMesh(Shape &shape, QObject parent)
	65	static QGLSceneNode createShapeMesh(Shape &shape, QObject parent)
66	66	{
67	67	size_t NumPointsonSurface = 200;

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

-              r7b38d3
+              r0ac85c3
 #include "Bond/bond.hpp"
 #include "Descriptors/AtomIdDescriptor.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
 #include "Helpers/helpers.hpp"
 #include "Shapes/ShapeRegistry.hpp"
 …
 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};
 …
   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);
 …
 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);
+  }
+}
 …
 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){
 …
      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)
+{
 …
+}
-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);
+}

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

-              r7b38d3
+              r0ac85c3
   void clicked(atomId_t);
   void doubleClicked();
+  void hoverChanged(const atom*);
+  void hoverChanged(const atom &);
+  void hoverChanged(const molecule &, int);
 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 moleculeClicked(moleculeId_t no);
+  void moleculeRemoved(const moleculeId_t _id);
+  void moleculeInserted(const molecule * _mol);
   void worldSelectionChanged();
   void bondInserted(const bond::ptr _bond, const GLMoleculeObject_bond::SideOfBond side);
 …
   void setSelectionModeAtom();
   void setSelectionModeMolecule();
-  void hoverChangedSignalled(GLMoleculeObject *ob);
   void changeAtomId(GLMoleculeObject_atom *ob, int oldId, int newOd);
   void addShape();
   void removeShape();
   void update();
+  void moleculesVisibilityChanged(const moleculeId_t _id, bool _visible);
 public:
 …
 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_ */

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

-              r7b38d3
+              r0ac85c3
   setOption(QGLView::ObjectPicking, true);
   setOption(QGLView::CameraNavigation, false);
+  setFocusPolicy(Qt::StrongFocus);
   setCameraControlMode(Rotate);
   defaultEyeSeparation = 4.0;
 …
   //changeMaterials(false);
+  qRegisterMetaType<atomicNumber_t>("atomicNumber_t");
+  qRegisterMetaType<atomId_t>("atomId_t");
+  qRegisterMetaType<moleculeId_t>("moleculeId_t");
   connect(this, SIGNAL(ShapeAdded()), worldscene, SLOT(addShape()));
 …
   connect(worldscene, SIGNAL(changeOccured()), this, SLOT(changeSignalled()));
   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(worldscene, SIGNAL(hoverChanged(const atom &)), this, SLOT(sceneHoverSignalled(const atom &)));
+  connect(worldscene, SIGNAL(hoverChanged(const molecule &, int)), this, SLOT(sceneHoverSignalled(const molecule &, int)));
   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()));
+  connect(this, SIGNAL(moleculesVisibilityChanged(const moleculeId_t,bool)), worldscene, SLOT(moleculesVisibilityChanged(const moleculeId_t,bool)));
   // 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);
 …
   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:
+      {
 …
       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;
+      }
 …
 void GLWorldView::keyPressEvent(QKeyEvent *e)
+{
+  // Find the distance between the eye and focus point.
+  QVector3D d = camera()->eye() - camera()->center();
+//  LOG(1, "Distance vector eye and center is "
+//      << d.x() << "," << d.y() << "," << d.z());
+  // scale the move unit by the eye <-> domain center distance
+  const double key_move_unit = 0.04*(d.length()/50.);
   if (e->key() == Qt::Key_Tab) {
     // The Tab key turns the ShowPicking option on and off,
 …
     setOption(QGLView::ShowPicking, ((options() & QGLView::ShowPicking) == 0));
     updateGL();
+  } else if ((e->key() == Qt::Key_Minus) || (e->key() == Qt::Key_Plus)) {
+    // Scale the distance.
+    if (e->key() == Qt::Key_Minus)
+      d *= 1.2;
+    else if (e->key() == Qt::Key_Plus)
+      d /= 1.2;
+    // Set new eye position.
+    camera()->setEye(camera()->center() + d);
+  } else if ((e->key() == Qt::Key_Left) || (e->key() == Qt::Key_Right)) {
+    // Translate the camera.
+    const double d = (e->key() == Qt::Key_Left) ? -key_move_unit : key_move_unit;
+    camera()->translateCenter( d, 0., 0);
+    camera()->translateEye( d, 0., 0);
+  } else if ((e->key() == Qt::Key_Up) || (e->key() == Qt::Key_Down)) {
+    // Translate the camera.
+    const double d = (e->key() == Qt::Key_Up) ? -key_move_unit : key_move_unit;
+    camera()->translateCenter( 0., d, 0);
+    camera()->translateEye( 0., d, 0);
+  } else if ((e->key() == Qt::Key_PageUp) || (e->key() == Qt::Key_PageDown)) {
+    // Translate the camera.
+    const double d = (e->key() == Qt::Key_PageUp) ? -key_move_unit : key_move_unit;
+    camera()->translateCenter( 0., 0., d);
+    camera()->translateEye( 0., 0., d);
+  }
   QGLView::keyPressEvent(e);
 …
+}
 void GLWorldView::sceneHoverSignalled(const atom *_atom)
+void GLWorldView::sceneHoverSignalled(const atom &_atom)
+{
   emit hoverChanged(_atom);
+}
+void GLWorldView::sceneHoverSignalled(const molecule &_mol, int _i)
+{
+  emit hoverChanged(_mol, _i);
+}

src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp

-              r7b38d3
+              r0ac85c3
   void checkChanges();
   void sceneChangeSignalled();
+  void sceneHoverSignalled(const atom *_atom);
+  void sceneHoverSignalled(const atom &_atom);
+  void sceneHoverSignalled(const molecule &_mol, int);
   void changeDreiBein();
   void changeDomain();
 …
   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);
+  void hoverChanged(const atom &_atom);
+  void hoverChanged(const molecule &_mol, int);
   void ShapeAdded();
   void ShapeRemoved();
+  void moleculesVisibilityChanged(const moleculeId_t,bool);
 protected:

src/UIElements/Views/Qt4/QtInfoBox.cpp

-              r7b38d3
+              r0ac85c3
     QTabWidget(),
     curAtom(NULL), nextAtom(NULL),
+    curMolecule(NULL), nextMolecule(NULL),
     page_mol(NULL), page_atom(NULL)
+{
 …
+}
+void QtInfoBox::atomHover(const atom *_atom)
+{
+  nextAtom = _atom;
+void QtInfoBox::atomHover(const atom &_atom)
+{
+  nextAtom = &_atom;
+  timer->start(500);
+}
+void QtInfoBox::moleculeHover(const molecule &_mol)
+{
+  nextMolecule = &_mol;
   timer->start(500);
+}
 …
   if (nextAtom)
     showAtom(nextAtom);
+  if (nextMolecule)
+    showMolecule(nextMolecule);
+}
 …
   curAtom = _atom;
+  nextAtom = NULL;
+  nextMolecule = NULL;
   // Show new tabs.
 …
         setCurrentIndex(currentPage);
+    }
+  }
+}
+void QtInfoBox::showMolecule(const molecule *_mol)
+{
+  currentPage = currentIndex();
+  // Remove old tabs.
+  clearTabs();
+  curMolecule = _mol;
+  nextAtom = NULL;
+  nextMolecule = NULL;
+  // Show new tabs.
+  if (curMolecule){
+    page_mol = new QtMoleculeInfoPage(curMolecule, this);
+    addTab(page_mol, "Molecule");
+    connect(page_mol, SIGNAL(moleculeKilled()), this, SLOT(clearTabs()));
+    if (currentPage > 0)
+      setCurrentIndex(currentPage);
+  }
+}

src/UIElements/Views/Qt4/QtInfoBox.hpp

-              r7b38d3
+              r0ac85c3
   void showAtom(const atom *_atom);
+  void showMolecule(const molecule *_mol);
 public slots:
+  void atomHover(const atom *_atom);
+  void atomHover(const atom &_atom);
+  void moleculeHover(const molecule &_mol);
   void timerTimeout();
 …
   const atom *curAtom;
   const atom *nextAtom;
+  const molecule *curMolecule;
+  const molecule *nextMolecule;
   QtMoleculeInfoPage *page_mol;
   QtAtomInfoPage *page_atom;

src/UIElements/Views/Qt4/QtMoleculeList.cpp

-              r7b38d3
+              r0ac85c3
 // these attributes are skipped so far
 const int QtMoleculeList::COLUMNCOUNT = COLUMNTYPES_MAX;
 const char *QtMoleculeList::COLUMNNAMES[QtMoleculeList::COLUMNCOUNT]={"Name","Atoms","Formula","Occurrence"/*,"Size"*/};
+const char *QtMoleculeList::COLUMNNAMES[QtMoleculeList::COLUMNCOUNT]={"Name","Visibility", "Atoms","Formula","Occurrence"/*,"Size"*/};
 QtMoleculeList::QtMoleculeList(QWidget * _parent) :
 …
   setHeaderLabels(header);
   World::getInstance().signOn(this);//, World::MoleculeInserted);
   //World::getInstance().signOn(this, World::MoleculeRemoved);
+  World::getInstance().signOn(this, World::MoleculeInserted);
+  World::getInstance().signOn(this, World::MoleculeRemoved);
 …
   clearing = false;
   selecting = false;
+  ChangingChildrensVisibility = false;
   refill();
 …
   //connect(this,SIGNAL(cellChanged(int,int)),this,SLOT(moleculeChanged(int,int)));
   connect(selectionModel(),SIGNAL(selectionChanged(QItemSelection, QItemSelection)),this,SLOT(rowsSelected(QItemSelection, QItemSelection)));
+  connect(this, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(visibilityChanged(QTreeWidgetItem*, int)));
+}
 QtMoleculeList::~QtMoleculeList()
+{
   World::getInstance().signOff(this);//, World::MoleculeInserted);
   //World::getInstance().signOff(this, World::MoleculeRemoved);
+  World::getInstance().signOff(this, World::MoleculeInserted);
+  World::getInstance().signOff(this, World::MoleculeRemoved);
+}
 void QtMoleculeList::update(Observable *publisher) {
+  ASSERT(0,
+      "QtMoleculeList::update() - we did not sign up for any global updates.");
+}
+void QtMoleculeList::recieveNotification(Observable *publisher, Notification_ptr notification) {
   if (selecting)
 …
   dirty = true;
+  // force an update from Qt...
+  clearing = true;
+  clear();
+  clearing = false;
+}
+}
 void QtMoleculeList::refill() {
 …
   clear();
+  // list of (unique) formulas in the world
+  std::vector<Formula> formula;
+  formula.clear();
+  FormulaVisibilityCountMap.clear();
   for (std::vector<molecule*>::const_iterator iter = molecules.begin();
 …
     // find group if already in list
     QTreeWidgetItem *groupItem = NULL;
+    for (unsigned int j=0;j<formula.size();j++)
+      if ((*iter)->getFormula() == formula[j]){
+        groupItem = topLevelItem(j);
+        break;
+      }
+    const std::string &molecule_formula = (*iter)->getFormula().toString();
+    FormulaTreeItemMap_t::const_iterator formulaiter =
+        formula.find(molecule_formula);
     // new molecule type -> create new group
+    if (!groupItem){
+      formula.push_back((*iter)->getFormula());
+    if (formulaiter == formula.end()){
+      // insert new formula entry into visibility
+#ifndef NDEBUG
+      std::pair< FormulaVisibilityCountMap_t::iterator, bool> visibilityinserter =
+#endif
+          FormulaVisibilityCountMap.insert(
+              std::make_pair( molecule_formula, (unsigned int)0) );
+      ASSERT( visibilityinserter.second,
+          "QtMoleculeList::refill() - molecule with formula "
+          +molecule_formula+" already in FormulaVisibilityCountMap.");
+      // create item and place into Map with formula as key
       groupItem = new QTreeWidgetItem(this);
+      groupItem->setText(0, QString("default"));
+      groupItem->setText(1, QString::number(0));
+      groupItem->setText(2, QString(""));
+      groupItem->setText(3, "0");
+      formula.insert( std::make_pair(molecule_formula, groupItem) );
+      // fill item
+      groupItem->setText(NAME, QString("default"));
+      groupItem->setFlags((groupItem->flags() | Qt::ItemIsUserCheckable) ^ Qt::ItemIsSelectable);
+      groupItem->setCheckState(VISIBILITY, Qt::Unchecked);
+      groupItem->setText(ATOMCOUNT, QString::number(0));
+      groupItem->setText(FORMULA, QString(""));
+      groupItem->setText(OCCURRENCE, "0");
       groupItem->setData(0, Qt::UserRole, QVariant(-1));
+    } else {
+      groupItem = formulaiter->second;
+    }
     // add molecule
     QTreeWidgetItem *molItem = new QTreeWidgetItem(groupItem);
+    molItem->setText(0, QString((*iter)->getName().c_str()));
+    molItem->setText(1, QString::number((*iter)->getAtomCount()));
+    molItem->setText(2, QString((*iter)->getFormula().toString().c_str()));
+    molItem->setText(NAME, QString((*iter)->getName().c_str()));
+    molItem->setFlags(molItem->flags() | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable);
+    molItem->setCheckState(VISIBILITY, Qt::Unchecked);
+    molItem->setText(ATOMCOUNT, QString::number((*iter)->getAtomCount()));
+    molItem->setText(FORMULA, QString(molecule_formula.c_str()));
     const int index = (*iter)->getId();
     molItem->setData(0, Qt::UserRole, QVariant(index));
     molItem->setSelected(World::getInstance().isSelected(*iter));
     // increase group occurrence
     int count = groupItem->text(3).toInt() + 1;
     groupItem->setText(3, QString::number(count));
+    int count = groupItem->text(OCCURRENCE).toInt() + 1;
+    groupItem->setText(OCCURRENCE, QString::number(count));
+  }
   dirty = false;
 …
 void QtMoleculeList::subjectKilled(Observable *publisher) {
+}
+void QtMoleculeList::visibilityChanged(QTreeWidgetItem* item, int column)
+{
+  if ((!clearing) && (!ChangingChildrensVisibility))
+    if (column == VISIBILITY) {
+      const moleculeId_t molid = item->data(0, Qt::UserRole).toInt();
+      const bool visible = item->checkState(VISIBILITY);
+      if (molid != (unsigned int)-1) { // molecule item
+        const molecule * const _molecule =
+            World::getInstance().getMolecule(MoleculeById(molid));
+        ASSERT( _molecule != NULL,
+            "QtMoleculeList::visibilityChanged() - molecule with id "
+            +toString(molid)+" is not known to World.");
+        const std::string &molecule_formula = _molecule->getFormula().toString();
+        ASSERT( FormulaVisibilityCountMap.count(molecule_formula) != 0,
+            "QtMoleculeList::visibilityChanged() - molecule with formula " +molecule_formula
+            +" is not present in FormulaVisibilityCountMap.");
+        // get parent
+        QTreeWidgetItem *groupItem = item->parent();
+        ASSERT( groupItem != NULL,
+            "QtMoleculeList::visibilityChanged() - item with id "+toString(molid)
+            +" has not parent?");
+        // check whether we have to set the group item
+        ChangingChildrensVisibility = true;
+        if (visible) {
+          ++(FormulaVisibilityCountMap[molecule_formula]);
+          // compare with occurence/total number of molecules
+          if (FormulaVisibilityCountMap[molecule_formula] ==
+              (unsigned int)(groupItem->text(OCCURRENCE).toInt()))
+            groupItem->setCheckState(VISIBILITY, Qt::Checked);
+        } else {
+          --(FormulaVisibilityCountMap[molecule_formula]);
+          // none selected anymore?
+          if (FormulaVisibilityCountMap[molecule_formula] == 0)
+            groupItem->setCheckState(VISIBILITY, Qt::Unchecked);
+        }
+        ChangingChildrensVisibility = false;
+        emit moleculesVisibilityChanged(molid, visible);
+      } else { // group item
+        // go through all children, but don't enter for groupItem once more
+        ChangingChildrensVisibility = true;
+        for (int i=0;i<item->childCount();++i) {
+          QTreeWidgetItem *molItem = item->child(i);
+          const moleculeId_t molid = molItem->data(0, Qt::UserRole).toInt();
+          ASSERT( molid != (unsigned int)-1,
+              "QtMoleculeList::visibilityChanged() - to child with index"
+              +toString(i)+" there is no molecule?");
+          molItem->setCheckState(VISIBILITY, visible ? Qt::Checked : Qt::Unchecked);
+          // emit signal
+          emit moleculesVisibilityChanged(molid, visible);
+        }
+        // set current number of visible children
+        const std::string molecule_formula =
+            item->text(FORMULA).toStdString();
+        FormulaVisibilityCountMap[molecule_formula] =
+            visible ? item->text(OCCURRENCE).toInt() : 0;
+        ChangingChildrensVisibility = false;
+      }
+    }
+}
 …
   // Select all molecules which belong to newly selected rows.
   QModelIndex index;
+  QModelIndexList items = selected.indexes();
+  foreach (index, items)
+    if (index.column() == 0){
+      int mol_id = model()->data(index, Qt::UserRole).toInt();
+      if (mol_id < 0)
+        continue;
+      //std::cout << "select molecule" << std::endl;
+      MoleCuilder::SelectionMoleculeById(mol_id);
+    }
+  {
+    QModelIndexList items = selected.indexes();
+    molids_t ids;
+    ids.reserve(items.size());
+    foreach (index, items)
+      if (index.column() == 0){
+        int mol_id = model()->data(index, Qt::UserRole).toInt();
+        if (mol_id < 0)
+          continue;
+        ids.push_back(mol_id);
+        //std::cout << "select molecule" << std::endl;
+      }
+    MoleCuilder::SelectionMoleculeById(ids);
+  }
   // Unselect all molecules which belong to newly unselected rows.
+  items = deselected.indexes();
+  foreach (index, items)
+    if (index.column() == 0){
+      int mol_id = model()->data(index, Qt::UserRole).toInt();
+      if (mol_id < 0)
+        continue;
+      //std::cout << "unselect molecule" << std::endl;
+      MoleCuilder::SelectionNotMoleculeById(mol_id);
+    }
+  {
+    QModelIndexList items = deselected.indexes();
+    molids_t ids;
+    ids.reserve(items.size());
+    foreach (index, items)
+      if (index.column() == 0){
+        int mol_id = model()->data(index, Qt::UserRole).toInt();
+        if (mol_id < 0)
+          continue;
+        //std::cout << "unselect molecule" << std::endl;
+        ids.push_back(mol_id);
+      }
+    MoleCuilder::SelectionNotMoleculeById(ids);
+  }
   selecting = false;

src/UIElements/Views/Qt4/QtMoleculeList.hpp

-              r7b38d3
+              r0ac85c3
 #endif
+#include <QtGui/QTreeWidget>
+#include <QtGui/QTreeWidget>
+#include <map>
+#include <string>
 #include "CodePatterns/Observer/Observer.hpp"
+#include "types.hpp"
 class molecule;
 …
 protected:
   virtual void update(Observable *publisher);
+  virtual void recieveNotification(Observable *publisher, Notification_ptr notification);
   virtual void subjectKilled(Observable *publisher);
   virtual void paintEvent(QPaintEvent * event);
 …
   static const int COLUMNCOUNT;
   enum {NAME,ATOMCOUNT,FORMULA,OCCURRENCE,COLUMNTYPES_MAX} COLUMNTYPES;
+  enum {NAME,VISIBILITY,ATOMCOUNT,FORMULA,OCCURRENCE,COLUMNTYPES_MAX} COLUMNTYPES;
   static const char *COLUMNNAMES[];
 private slots:
   void moleculeChanged();
+  void visibilityChanged(QTreeWidgetItem*, int);
   void rowsSelected(const QItemSelection & selected, const QItemSelection & deselected);
 …
   void moleculeSelected(molecule*);
   void moleculeUnSelected(molecule*);
+  void moleculesVisibilityChanged(const moleculeId_t, bool);
 private:
 …
   bool clearing;
   bool selecting;
+  bool ChangingChildrensVisibility;
+  typedef std::map<std::string, unsigned int> FormulaVisibilityCountMap_t;
+  FormulaVisibilityCountMap_t FormulaVisibilityCountMap;
+  typedef std::map<std::string, QTreeWidgetItem*> FormulaTreeItemMap_t;
+  //!> map of (unique) formulas in the world
+  FormulaTreeItemMap_t formula;
 };

src/UIElements/Views/Qt4/QtToolBar.cpp

-              r7b38d3
+              r0ac85c3
  */
 // include config.h
 #ifdef HAVE_CONFIG_H
 …
 #endif
 #include "QtToolBar.hpp"
 #include "CodePatterns/MemDebug.hpp"
+#include "CodePatterns/Observer/Notification.hpp"
+#include "Actions/ActionQueue.hpp"
 QtToolBar::QtToolBar(QWidget * _parent) :
+  QToolBar(_parent)
+  QToolBar(_parent),
+  Observer("QToolBar"),
+  ActionQueue_observing(false),
+  undoaction(addActionItem("undo", "undo the last Action", "edit-undo")),
+  redoaction(addActionItem("redo", "redo the last Action", "edit-redo"))
+{
+  addActionItem("undo", "undo the last Action", "edit-undo");
+  addActionItem("redo", "redo the last Action", "edit-redo");
+  // gray out undo/redo buttons initially
+  undoaction->setEnabled(false);
+  redoaction->setEnabled(false);
+  // sign in
+  MoleCuilder::ActionQueue::getInstance().signOn(this, MoleCuilder::ActionQueue::ActionQueued);
+  ActionQueue_observing = true;
+}
 …
 QtToolBar::~QtToolBar()
+{
+  // sign off
+  if (ActionQueue_observing)
+    MoleCuilder::ActionQueue::getInstance().signOff(this, MoleCuilder::ActionQueue::ActionQueued);
+}
+void QtToolBar::addActionItem(const std::string &token, const std::string &description, const std::string &icon_name)
+QAction * QtToolBar::addActionItem(
+    const std::string &token,
+    const std::string &description,
+    const std::string &icon_name)
+{
   QAction *action = addAction(QString(description.c_str()));
 …
   plumbing.push_back(pipe);
   present_actions.insert( token );
+  return action;
+}
 …
+}
+void QtToolBar::update(Observable *publisher)
+{
+  ASSERT(0, "QtToolBar::update() - this should never be called, we are only subscribed to channels.");
+}
+void QtToolBar::subjectKilled(Observable *publisher)
+{
+  ActionQueue_observing = false;
+}
+void QtToolBar::recieveNotification(Observable *publisher, Notification_ptr notification)
+{
+  if (dynamic_cast<MoleCuilder::ActionQueue *>(publisher) != NULL) {
+    switch(notification->getChannelNo()) {
+      case MoleCuilder::ActionQueue::ActionQueued:
+        undoaction->setEnabled(MoleCuilder::ActionQueue::getInstance().canUndo());
+        redoaction->setEnabled(MoleCuilder::ActionQueue::getInstance().canRedo());
+        break;
+      default:
+        ASSERT(0, "QtToolBar::recieveNotification() - cannot get here, not subscribed to channel "
+            +toString(notification->getChannelNo()));
+        break;
+    }
+  } else {
+    ASSERT(0, "QtToolBar::recieveNotification() - cannot get here, we are only subscribed to ActionQueue.");
+  }
+}

src/UIElements/Views/Qt4/QtToolBar.hpp

-              r7b38d3
+              r0ac85c3
 class QtToolBar : public QToolBar
+class QtToolBar : public QToolBar, public Observer
+{
   Q_OBJECT
 …
    * @param description description to appear as tooltip
    * @param icon_name name of icon
+   * @return ref to newly created action
    */
+  void addActionItem(const std::string &token, const std::string &description, const std::string &icon_name);
+  QAction * addActionItem(
+      const std::string &token,
+      const std::string &description,
+      const std::string &icon_name);
   /** Function to add a set of favorite actions.
 …
   const present_actions_t & getPresentActions() const
   { return present_actions; }
+  void update(Observable *publisher);
+  void subjectKilled(Observable *publisher);
+  void recieveNotification(Observable *publisher, Notification_ptr notification);
 private:
 …
   //!> set of already present action icons
   present_actions_t present_actions;
+  //!> sign in to ActionQueue?
+  bool ActionQueue_observing;
+  //!> ref to undoaction to gray out
+  QAction *undoaction;
+  //!> ref to redoaction to gray out
+  QAction *redoaction;
 };

src/UIElements/Views/Qt4/QtToolBar_QtFavoriteActions.cpp

r7b38d3	r0ac85c3
46	46	#include "CodePatterns/Assert.hpp"
47	47	#include "CodePatterns/Log.hpp"
48		~~#include "CodePatterns/Observer/Observer.hpp"~~
49	48
50	49	#include "Actions/Action.hpp"

Context Navigation

Legend:

src/UIElements/CommandLineUI/CommandLineParser.cpp

src/UIElements/Qt4/QtMainWindow.cpp

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

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp

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

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp

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

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp

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

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

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

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

src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp

src/UIElements/Views/Qt4/QtInfoBox.cpp

src/UIElements/Views/Qt4/QtInfoBox.hpp

src/UIElements/Views/Qt4/QtMoleculeList.cpp

src/UIElements/Views/Qt4/QtMoleculeList.hpp

src/UIElements/Views/Qt4/QtToolBar.cpp

src/UIElements/Views/Qt4/QtToolBar.hpp

src/UIElements/Views/Qt4/QtToolBar_QtFavoriteActions.cpp

Download in other formats: